Go to the documentation of this file.
53 #define CIRCUITLIST_PRIVATE
54 #define OCIRC_EVENT_PRIVATE
60 #include "feature/client/circpathbias.h"
68 #include "core/or/trace_probes_circuit.h"
98 #include "core/or/channelpadding.h"
115 #include "core/or/or_circuit_st.h"
174 CONST_TO_ORIGIN_CIRCUIT(
const circuit_t *x)
188 time_t made_placeholder_at;
198 return a->chan == b->chan && a->circ_id == b->circ_id;
203 static inline unsigned int
208 uintptr_t chan = (uintptr_t) (
void*) a->chan;
210 array[0] = a->circ_id;
213 array[1] = (uint32_t) (chan >> 6);
214 return (
unsigned) siphash24g(array,
sizeof(array));
219 chan_circid_map = HT_INITIALIZER();
237 circuit_set_circid_chan_helper(
circuit_t *circ,
int direction,
245 int make_active, attached = 0;
257 old_chan = *chan_ptr;
258 old_id = *circid_ptr;
260 if (
id == old_id && chan == old_chan)
263 if (_last_circid_chan_ent &&
264 ((old_id == _last_circid_chan_ent->circ_id &&
265 old_chan == _last_circid_chan_ent->chan) ||
266 (
id == _last_circid_chan_ent->circ_id &&
267 chan == _last_circid_chan_ent->chan))) {
268 _last_circid_chan_ent = NULL;
278 if (old_id != 0 && (old_chan != chan || old_id !=
id) &&
285 search.circ_id = old_id;
286 search.chan = old_chan;
287 found = HT_REMOVE(chan_circid_map, &chan_circid_map, &search);
295 --(old_chan->num_p_circuits);
311 found = HT_FIND(chan_circid_map, &chan_circid_map, &search);
313 found->circuit = circ;
314 found->made_placeholder_at = 0;
319 found->circuit = circ;
320 HT_INSERT(chan_circid_map, &chan_circid_map, found);
328 if (chan &&
id != 0 && (old_chan != chan || old_id !=
id) &&
339 if (make_active && attached)
340 update_circuit_on_cmux(circ, direction);
346 ++chan->num_p_circuits;
361 memset(&search, 0,
sizeof(search));
364 ent = HT_FIND(chan_circid_map, &chan_circid_map, &search);
366 if (ent && ent->circuit) {
368 log_warn(
LD_BUG,
"Tried to mark %u unusable on %p, but there was already "
369 "a circuit there.", (
unsigned)
id, chan);
372 if (!ent->made_placeholder_at)
380 HT_INSERT(chan_circid_map, &chan_circid_map, ent);
394 memset(&search, 0,
sizeof(search));
397 ent = HT_REMOVE(chan_circid_map, &chan_circid_map, &search);
398 if (ent && ent->circuit) {
399 log_warn(
LD_BUG,
"Tried to mark %u usable on %p, but there was already "
400 "a circuit there.", (
unsigned)
id, chan);
403 if (_last_circid_chan_ent == ent)
404 _last_circid_chan_ent = NULL;
510 msg->
reason = reason_code;
513 ocirc_cevent_publish(msg);
531 ocirc = CONST_TO_ORIGIN_CIRCUIT(circ);
539 ocirc_state_publish(msg);
548 if (state == circ->
state)
571 tor_trace(
TR_SUBSYS(circuit), TR_EV(change_state), circ, circ->
state, state);
605 } SMARTLIST_FOREACH_END(circ);
619 cnt = smartlist_len(sl);
621 log_debug(
LD_CIRC,
"or_conn to %s, %d pending circs",
676 if (idx < smartlist_len(lst)) {
677 circuit_t *replacement = smartlist_get(lst, idx);
689 } SMARTLIST_FOREACH_END(circ);
724 if (!
TO_CIRCUIT(next_circ)->marked_for_close &&
725 next_circ->has_opened &&
728 next_circ->build_state &&
733 } SMARTLIST_FOREACH_END(next_circ);
775 log_warn(
LD_BUG,
"Unknown circuit state %d", state);
776 tor_snprintf(buf,
sizeof(buf),
"unknown state [%d]", state);
798 return "HS_CLIENT_HSDIR";
803 return "HS_CLIENT_INTRO";
809 return "HS_CLIENT_REND";
812 return "HS_SERVICE_HSDIR";
816 return "HS_SERVICE_INTRO";
820 return "HS_SERVICE_REND";
825 return "MEASURE_TIMEOUT";
829 return "PATH_BIAS_TESTING";
831 return "HS_VANGUARDS";
833 return "CIRCUIT_PADDING";
836 tor_snprintf(buf,
sizeof(buf),
"UNKNOWN_%d", (
int)purpose);
851 "Unrecognized circuit purpose: %d",
867 return "OR_HSSI_ESTABLISHED";
869 return "OR_HSCR_ESTABLISHED";
871 return "OR_HS_R_JOINED";
875 return "HSCI_CONNECTING";
877 return "HSCI_INTRO_SENT";
882 return "HSCR_CONNECTING";
884 return "HSCR_ESTABLISHED_IDLE";
886 return "HSCR_ESTABLISHED_WAITING";
888 return "HSCR_JOINED";
892 return "HSSI_CONNECTING";
894 return "HSSI_ESTABLISHED";
897 return "HSSR_CONNECTING";
899 return "HSSR_JOINED";
912 return "Circuit at relay";
914 return "Acting as intro point";
916 return "Acting as rendezvous (pending)";
918 return "Acting as rendezvous (established)";
920 return "General-purpose client";
922 return "Hidden service client: Connecting to intro point";
924 return "Hidden service client: Waiting for ack from intro point";
926 return "Hidden service client: Received ack from intro point";
928 return "Hidden service client: Establishing rendezvous point";
930 return "Hidden service client: Pending rendezvous point";
932 return "Hidden service client: Pending rendezvous point (ack received)";
934 return "Hidden service client: Active rendezvous point";
936 return "Hidden service client: Fetching HS descriptor";
939 return "Measuring circuit timeout";
942 return "Hidden service: Establishing introduction point";
944 return "Hidden service: Introduction point";
946 return "Hidden service: Connecting to rendezvous point";
948 return "Hidden service: Active rendezvous point";
950 return "Hidden service: Uploading HS descriptor";
953 return "Testing circuit";
956 return "Circuit made by controller";
959 return "Path-bias testing circuit";
962 return "Hidden service: Pre-built vanguard circuit";
965 return "Circuit kept open for padding";
968 tor_snprintf(buf,
sizeof(buf),
"UNKNOWN_%d", (
int)purpose);
980 CIRCWINDOW_START_MIN,
981 CIRCWINDOW_START_MAX);
1012 #define DFLT_IDLE_TIMEOUT_WHILE_LEARNING (3*60)
1013 #define MIN_IDLE_TIMEOUT_WHILE_LEARNING (10)
1014 #define MAX_IDLE_TIMEOUT_WHILE_LEARNING (1000*60)
1025 static uint32_t n_circuits_allocated = 1;
1050 MIN_IDLE_TIMEOUT_WHILE_LEARNING,
1051 MAX_IDLE_TIMEOUT_WHILE_LEARNING);
1060 int prediction_time_remaining =
1067 "Circuit chose a negative idle timeout of %d based on "
1068 "%d seconds of predictive building remaining.",
1070 prediction_time_remaining);
1074 MIN_IDLE_TIMEOUT_WHILE_LEARNING,
1075 MAX_IDLE_TIMEOUT_WHILE_LEARNING);
1079 "Circuit %"PRIu32
" chose an idle timeout of %d based on "
1080 "%d seconds of predictive building remaining.",
1083 prediction_time_remaining);
1086 tor_trace(
TR_SUBSYS(circuit), TR_EV(new_origin), circ);
1109 tor_trace(
TR_SUBSYS(circuit), TR_EV(new_or), circ);
1133 int should_free = 1;
1159 half_edge_free(half_conn);
1160 } SMARTLIST_FOREACH_END(half_conn);
1179 crypto_pk_free(ocirc->intro_key);
1184 hs_ident_circuit_free(ocirc->
hs_ident);
1188 if (ocirc->socks_username) {
1189 memwipe(ocirc->socks_username, 0x12, ocirc->socks_username_len);
1192 if (ocirc->socks_password) {
1193 memwipe(ocirc->socks_password, 0x06, ocirc->socks_password_len);
1224 extend_info_free(circ->
n_hop);
1251 log_info(
LD_CIRC,
"Circuit %u (id: %" PRIu32
") has been freed.",
1260 circuit_handles_clear(circ);
1264 tor_trace(
TR_SUBSYS(circuit), TR_EV(free), circ);
1287 head = cpath = circ->
cpath;
1294 while (cpath->
next && cpath->
next != head) {
1296 cpath = victim->
next;
1321 tmp->global_circuitlist_idx = -1;
1325 } SMARTLIST_FOREACH_END(tmp);
1327 smartlist_free(lst);
1344 for (elt = HT_START(chan_circid_map, &chan_circid_map);
1348 next = HT_NEXT_RMV(chan_circid_map, &chan_circid_map, elt);
1354 HT_CLEAR(chan_circid_map, &chan_circid_map);
1361 if (cpath_ref != NULL) {
1362 if (--(cpath_ref->
refcount) == 0) {
1375 int conn_array_index,
1381 "(other side %u), state %d (%s), born %ld:",
1382 conn_array_index, type, (
unsigned)this_circid, (
unsigned)other_circid,
1412 if (
TO_CONN(tmpconn) == conn) {
1414 "App-ward", p_circ_id, n_circ_id);
1422 if (
TO_CONN(tmpconn) == conn) {
1424 "Exit-ward", n_circ_id, p_circ_id);
1429 SMARTLIST_FOREACH_END(circ);
1446 SMARTLIST_FOREACH_END(circ);
1460 int *found_entry_out)
1465 if (_last_circid_chan_ent &&
1466 circ_id == _last_circid_chan_ent->circ_id &&
1467 chan == _last_circid_chan_ent->chan) {
1468 found = _last_circid_chan_ent;
1470 search.circ_id = circ_id;
1472 found = HT_FIND(chan_circid_map, &chan_circid_map, &search);
1473 _last_circid_chan_ent = found;
1475 if (found && found->circuit) {
1477 "circuit_get_by_circid_channel_impl() returning circuit %p for"
1478 " circ_id %u, channel ID %"PRIu64
" (%p)",
1479 found->circuit, (
unsigned)circ_id,
1481 if (found_entry_out)
1482 *found_entry_out = 1;
1483 return found->circuit;
1487 "circuit_get_by_circid_channel_impl() found %s for"
1488 " circ_id %u, channel ID %"PRIu64
" (%p)",
1489 found ?
"placeholder" :
"nothing",
1493 if (found_entry_out)
1494 *found_entry_out = found ? 1 : 0;
1574 memset(&search, 0,
sizeof(search));
1575 search.circ_id = circ_id;
1578 found = HT_FIND(chan_circid_map, &chan_circid_map, &search);
1580 if (! found || found->circuit)
1583 return found->made_placeholder_at;
1613 #ifdef DEBUG_CIRCUIT_UNLINK_ALL
1616 int mismatch = 0, badlen = 0;
1619 if (circ->
n_chan == chan ||
1625 SMARTLIST_FOREACH_END(circ);
1627 if (smartlist_len(detached) != smartlist_len(detached_2)) {
1628 log_warn(
LD_BUG,
"List of detached circuits had the wrong length! "
1629 "(got %d, should have gotten %d)",
1630 (
int)smartlist_len(detached),
1631 (
int)smartlist_len(detached_2));
1638 if (c != smartlist_get(detached_2, c_sl_idx))
1643 log_warn(
LD_BUG,
"Mismatch in list of detached circuits.");
1645 if (badlen || mismatch) {
1646 smartlist_free(detached);
1647 detached = detached_2;
1649 log_notice(
LD_CIRC,
"List of %d circuits was as expected.",
1650 (
int)smartlist_len(detached));
1651 smartlist_free(detached_2);
1658 if (circ->
n_chan == chan) {
1670 if (or_circ->
p_chan == chan) {
1676 log_warn(
LD_BUG,
"Circuit on detached list which I had no reason "
1681 circuit_mark_for_close(circ, reason);
1682 } SMARTLIST_FOREACH_END(circ);
1684 smartlist_free(detached);
1714 SMARTLIST_FOREACH_END(circ);
1735 bool want_client_circ)
1741 idx =
TO_CIRCUIT(start)->global_circuitlist_idx + 1;
1744 for ( ; idx < smartlist_len(lst); ++idx) {
1745 circuit_t *circ = smartlist_get(lst, idx);
1754 if (want_client_circ) {
1792 idx =
TO_CIRCUIT(start)->global_circuitlist_idx + 1;
1795 for ( ; idx < smartlist_len(lst); ++idx) {
1796 circuit_t *circ = smartlist_get(lst, idx);
1821 const uint8_t *digest, uint8_t purpose)
1829 idx =
TO_CIRCUIT(start)->global_circuitlist_idx + 1;
1831 for ( ; idx < smartlist_len(lst); ++idx) {
1832 circuit_t *circ = smartlist_get(lst, idx);
1847 if (rend_circuit_pk_digest_eq(ocirc, digest)) {
1864 if (BUG(!chosen_exit)) {
1922 int purpose_to_search_for;
1929 purpose_to_produce);
1935 "Hunting for a circ to cannibalize: purpose %d, uptime %d, "
1936 "capacity %d, internal %d",
1937 purpose_to_produce, need_uptime, need_capacity,
internal);
1942 !circ_->marked_for_close &&
1943 circ_->purpose == purpose_to_search_for &&
1944 !circ_->timestamp_dirty) {
1966 !circ->unusable_for_new_conns &&
1984 }
while (hop!=circ->
cpath);
1997 }
while (hop != circ->
cpath);
2002 log_debug(
LD_GENERAL,
"Skipping uncannibalizable circuit for v3 "
2003 "rendezvous point.");
2013 SMARTLIST_FOREACH_END(circ_);
2040 if (circuits_upgraded && smartlist_len(result)) {
2043 smartlist_free(result);
2054 if (circ && circ->
cpath) {
2056 for (cpath = circ->
cpath; cpath_next != circ->
cpath; cpath = cpath_next) {
2057 cpath_next = cpath->
next;
2070 if (circ && circ->
cpath) {
2072 for (cpath = circ->
cpath;
2073 cpath->
state == CPATH_STATE_OPEN
2074 && cpath_next != circ->
cpath;
2075 cpath = cpath_next) {
2076 cpath_next = cpath->
next;
2089 if (circ && circ->
cpath && hopnum > 0) {
2091 for (cpath = circ->
cpath; cpath_next != circ->
cpath; cpath = cpath_next) {
2092 cpath_next = cpath->
next;
2109 circuit_mark_for_close(circ, END_CIRC_REASON_FINISHED);
2111 SMARTLIST_FOREACH_END(circ);
2131 SMARTLIST_FOREACH_END(circ);
2155 uint64_t written_sync;
2162 or_circ = CONST_TO_OR_CIRCUIT(c);
2164 if (dir == CIRCUIT_N_CHAN) {
2175 cell_size = get_cell_network_size(chan->wide_circ_ids);
2181 bool is_ipv6 = chan &&
2187 written_sync = cells*(cell_size+TLS_PER_CELL_OVERHEAD);
2215 int orig_reason = reason;
2227 "Duplicate call to circuit_mark_for_close at %s:%d"
2228 " (first at %s:%d)", file, line,
2234 log_warn(
LD_BUG,
"Specified 'at-origin' non-reason for ending circuit, "
2235 "but circuit was not at origin. (called %s:%d, purpose=%d)",
2238 reason = END_CIRC_REASON_NONE;
2248 reason = END_CIRC_REASON_NONE;
2257 if (reason < END_CIRC_REASON_MIN_ || reason > END_CIRC_REASON_MAX_) {
2259 log_warn(
LD_BUG,
"Reason %d out of range at %s:%d", reason, file, line);
2260 reason = END_CIRC_REASON_NONE;
2288 log_info(
LD_GENERAL,
"Circuit %u (id: %" PRIu32
") marked for close at "
2289 "%s:%d (orig reason: %d, new reason: %d)",
2293 file, line, orig_reason, reason);
2294 tor_trace(
TR_SUBSYS(circuit), TR_EV(mark_for_close), circ);
2359 CIRC_EVENT_CLOSED:CIRC_EVENT_FAILED,
2366 if (!CHANNEL_CONDEMNED(circ->
n_chan)) {
2388 conn->
end_reason = END_STREAM_REASON_DESTROY;
2390 connection_mark_for_close(
TO_CONN(conn));
2398 if (!CHANNEL_CONDEMNED(or_circ->
p_chan)) {
2419 log_warn(
LD_BUG,
"Called on non-marked circuit");
2460 result += single_conn_free_bytes(conn);
2462 result += single_conn_free_bytes(conn->
linked_conn);
2520 if (NULL != (cell = TOR_SIMPLEQ_FIRST(&c->
n_chan_cells.head)))
2525 if (NULL != (cell = TOR_SIMPLEQ_FIRST(&orcirc->
p_chan_cells.head))) {
2541 uint32_t age = 0, age2;
2561 uint32_t age = 0, age2;
2584 CONST_TO_ORIGIN_CIRCUIT(c)->p_streams, now);
2587 CONST_TO_OR_CIRCUIT(c)->n_streams, now);
2599 if (cell_age > data_age)
2617 else if (age_a == age_b)
2623 static uint32_t now_ts_for_buf_cmp;
2637 else if (age_a == age_b)
2643 #define FRACTION_OF_DATA_TO_RETAIN_ON_OOM 0.90
2654 size_t mem_to_recover;
2655 size_t mem_recovered=0;
2656 int n_circuits_killed=0;
2657 int n_dirconns_killed=0;
2659 log_notice(
LD_GENERAL,
"We're low on memory (cell queues total alloc:"
2660 " %"TOR_PRIuSZ
" buffer total alloc: %" TOR_PRIuSZ
","
2661 " tor compress total alloc: %" TOR_PRIuSZ
2662 " (zlib: %" TOR_PRIuSZ
", zstd: %" TOR_PRIuSZ
","
2663 " lzma: %" TOR_PRIuSZ
"),"
2664 " rendezvous cache total alloc: %" TOR_PRIuSZ
"). Killing"
2665 " circuits withover-long queues. (This behavior is controlled by"
2666 " MaxMemInQueues.)",
2667 cell_queues_get_total_allocation(),
2668 buf_get_total_allocation(),
2673 rend_cache_get_total_allocation());
2677 FRACTION_OF_DATA_TO_RETAIN_ON_OOM);
2678 if (current_allocation <= mem_target)
2680 mem_to_recover = current_allocation - mem_target;
2688 } SMARTLIST_FOREACH_END(circ);
2697 } SMARTLIST_FOREACH_END(circ);
2700 now_ts_for_buf_cmp = now_ts;
2702 now_ts_for_buf_cmp = 0;
2707 } SMARTLIST_FOREACH_END(conn);
2722 if (conn_age < circ->age_tmp) {
2727 connection_mark_for_close(conn);
2728 mem_recovered += single_conn_free_bytes(conn);
2730 ++n_dirconns_killed;
2732 if (mem_recovered >= mem_to_recover)
2733 goto done_recovering_mem;
2742 circuit_mark_for_close(circ, END_CIRC_REASON_RESOURCELIMIT);
2747 ++n_circuits_killed;
2750 mem_recovered += half_stream_alloc;
2751 mem_recovered += freed;
2753 if (mem_recovered >= mem_to_recover)
2754 goto done_recovering_mem;
2755 } SMARTLIST_FOREACH_END(circ);
2757 done_recovering_mem:
2759 log_notice(
LD_GENERAL,
"Removed %"TOR_PRIuSZ
" bytes by killing %d circuits; "
2760 "%d circuits remain alive. Also killed %d non-linked directory "
2764 smartlist_len(circlist) - n_circuits_killed,
2781 c->
purpose <= CIRCUIT_PURPOSE_MAX_);
2784 origin_circ = CONST_TO_ORIGIN_CIRCUIT(c);
2786 or_circ = CONST_TO_OR_CIRCUIT(c);
2799 if (or_circ && or_circ->
p_chan) {
2828 if (origin_circ && origin_circ->
cpath) {
#define log_fn(severity, domain, args,...)
#define CELL_MAX_NETWORK_SIZE
void circuit_unlink_all_from_channel(channel_t *chan, int reason)
void channel_note_destroy_not_pending(channel_t *chan, circid_t id)
#define DOWNCAST(to, ptr)
size_t tor_zstd_get_total_allocation(void)
circuit_t * circuit_get_by_circid_channel(circid_t circ_id, channel_t *chan)
circuit_build_times_t * get_circuit_build_times_mutable(void)
static void circuit_remove_from_origin_circuit_list(origin_circuit_t *origin_circ)
static int circuits_compare_by_oldest_queued_item_(const void **a_, const void **b_)
Header file for connection_edge.c.
smartlist_t * half_streams
void tor_free_(void *mem)
static sa_family_t tor_addr_family(const tor_addr_t *a)
#define CIRCUIT_PURPOSE_REND_ESTABLISHED
#define CIRCUIT_PURPOSE_IS_ORIGIN(p)
#define ORIGIN_CIRCUIT_MAGIC
char identity_digest[DIGEST_LEN]
#define CIRCUIT_STATE_OPEN
uint16_t marked_for_close
reference-counting structure for crypt_path_t
STATIC uint32_t circuit_max_queued_data_age(const circuit_t *c, uint32_t now)
Header file containing circuit and connection identifier data for the whole HS subsystem.
void memwipe(void *mem, uint8_t byte, size_t sz)
size_t packed_cell_mem_cost(void)
#define CIRCUIT_PURPOSE_C_GENERAL
origin_circuit_t * circuit_get_next_intro_circ(const origin_circuit_t *start, bool want_client_circ)
struct create_cell_t * n_chan_create_cell
smartlist_t * prepend_policy
#define MOCK_IMPL(rv, funcname, arglist)
unsigned int edge_has_sent_end
smartlist_t * circuit_get_global_list(void)
#define CIRCUIT_PURPOSE_INTRO_POINT
unsigned int isolation_values_set
static void marked_circuit_free_cells(circuit_t *circ)
static int any_opened_circs_cached_val
int routerset_contains_extendinfo(const routerset_t *set, const extend_info_t *ei)
#define CIRCLAUNCH_NEED_CAPACITY
static size_t circuit_alloc_in_half_streams(const circuit_t *c)
void circuit_set_p_circid_chan(or_circuit_t *or_circ, circid_t id, channel_t *chan)
Circuit-build-stse structure.
#define DEFAULT_ROUTE_LEN
#define CIRCUIT_PURPOSE_PATH_BIAS_TESTING
Header file for circuituse.c.
size_t tor_compress_state_size(const tor_compress_state_t *state)
Header file for channel.c.
Header for feature/stats/bwhist.c.
#define MAX_RELAY_EARLY_CELLS_PER_CIRCUIT
Header for compress_lzma.c.
void bwhist_note_bytes_written(uint64_t num_bytes, time_t when, bool ipv6)
streamid_t next_stream_id
int control_event_circuit_status(origin_circuit_t *circ, circuit_status_event_t tp, int reason_code)
#define tor_fragile_assert()
void circuit_clear_cpath(origin_circuit_t *circ)
circuit_t * circuit_get_by_circid_channel_even_if_marked(circid_t circ_id, channel_t *chan)
void * tor_reallocarray_(void *ptr, size_t sz1, size_t sz2)
int route_len_for_purpose(uint8_t purpose, extend_info_t *exit_ei)
const node_t * node_get_by_id(const char *identity_digest)
void smartlist_add(smartlist_t *sl, void *element)
static int conns_compare_by_buffer_age_(const void **a_, const void **b_)
void entry_guard_cancel(circuit_guard_state_t **guard_state_p)
guard_selection_t * get_guard_selection_info(void)
origin_circuit_t * circuit_get_next_by_pk_and_purpose(origin_circuit_t *start, const uint8_t *digest, uint8_t purpose)
#define CIRCUIT_PURPOSE_C_REND_JOINED
#define CIRCUIT_STATE_ONIONSKIN_PENDING
smartlist_t * testing_cell_stats
Integer definitions used throughout Tor.
#define END_CIRC_REASON_FLAG_REMOTE
STATIC void circuit_free_(circuit_t *circ)
int marked_for_close_reason
void circuits_handle_oom(size_t current_allocation)
const char * marked_for_close_file
static void circuit_dump_conn_details(int severity, circuit_t *circ, int conn_array_index, const char *type, circid_t this_circid, circid_t other_circid)
smartlist_t * smartlist_new(void)
Header file for crypt_path.c.
static void circuit_state_publish(const circuit_t *circ)
void circuit_dump_by_conn(connection_t *conn, int severity)
int tor_snprintf(char *str, size_t size, const char *format,...)
#define CIRCUIT_IS_ORIGIN(c)
Header file for onion_queue.c.
static size_t marked_circuit_free_stream_bytes(circuit_t *c)
circuit_channel_direction_t
Header file for circuitpadding.c.
#define CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT
#define SMARTLIST_FOREACH(sl, type, var, cmd)
int crypto_rand_int(unsigned int max)
int global_circuitlist_idx
void cell_queue_init(cell_queue_t *queue)
cell_queue_t p_chan_cells
Header file for networkstatus.c.
uint32_t global_identifier
Header file for onion_fast.c.
#define END_CIRC_AT_ORIGIN
static uint32_t circuit_get_streams_max_data_age(const edge_connection_t *stream, uint32_t now)
#define CIRCUIT_PURPOSE_REND_POINT_WAITING
STATIC uint32_t circuit_max_queued_item_age(const circuit_t *c, uint32_t now)
#define CIRCUIT_PURPOSE_C_ESTABLISH_REND
#define CIRCUIT_PURPOSE_S_HSDIR_POST
void rep_hist_buffer_stats_add_circ(circuit_t *circ, time_t end_of_interval)
int tor_memeq(const void *a, const void *b, size_t sz)
#define CIRCUIT_PURPOSE_OR
Common functions for cryptographic routines.
#define CIRCUIT_PURPOSE_CONTROLLER
static int circuit_can_be_cannibalized_for_v3_rp(const origin_circuit_t *circ)
static smartlist_t * global_origin_circuit_list
int predicted_ports_prediction_time_remaining(time_t now)
void channel_mark_circid_usable(channel_t *chan, circid_t id)
void hs_circ_cleanup_on_free(circuit_t *circ)
Header file for circuitlist.c.
Header file for mainloop.c.
void circuit_log_path(int severity, unsigned int domain, origin_circuit_t *circ)
static HT_HEAD(HT_PROTOTYPE(chan_circid_map, HT_PROTOTYPE(chan_circid_circuit_map_t)
void cpath_assert_ok(const crypt_path_t *cp)
int rend_cmp_service_ids(const char *one, const char *two)
int marked_for_close_orig_reason
const char * channel_describe_peer(channel_t *chan)
void cpath_free(crypt_path_t *victim)
origin_circuit_t * circuit_find_to_cannibalize(uint8_t purpose_to_produce, extend_info_t *info, int flags)
extend_info_t * chosen_exit
Half-open connection structure.
edge_connection_t * resolving_streams
void channel_mark_circid_unusable(channel_t *chan, circid_t id)
static void init_circuit_base(circuit_t *circ)
int circpad_marked_circuit_for_padding(circuit_t *circ, int reason)
static uint32_t conn_get_buffer_age(const connection_t *conn, uint32_t now_ts)
unsigned int remaining_relay_early_cells
void circuit_cache_opened_circuit_state(int circuits_are_opened)
#define tor_memneq(a, b, sz)
Header file for circuitbuild.c.
origin_circuit_t * circuit_get_by_global_id(uint32_t id)
void circuitmux_detach_circuit(circuitmux_t *cmux, circuit_t *circ)
static uint8_t get_circuit_purpose_needed_to_cannibalize(uint8_t purpose)
int entry_guards_upgrade_waiting_circuits(guard_selection_t *gs, const smartlist_t *all_circuits_in, smartlist_t *newly_complete_out)
void mainloop_schedule_postloop_cleanup(void)
int circuit_any_opened_circuits(void)
smartlist_t * circuit_get_global_origin_circuit_list(void)
static smartlist_t * global_circuitlist
#define CIRCUIT_IS_ORCIRC(c)
#define CIRCUIT_PURPOSE_C_CIRCUIT_PADDING
#define CIRCLAUNCH_ONEHOP_TUNNEL
unsigned int onehop_tunnel
static size_t marked_circuit_streams_free_bytes(edge_connection_t *stream)
Header file for directory.c.
int tor_digest_is_zero(const char *digest)
#define CIRCUIT_PURPOSE_HS_VANGUARDS
struct routerset_t * ExcludeNodes
edge_connection_t * n_streams
static void circuit_add_to_origin_circuit_list(origin_circuit_t *origin_circ)
#define CIRCUIT_STATE_CHAN_WAIT
smartlist_t * sendme_last_digests
static smartlist_t * circuits_pending_chans
void smartlist_del(smartlist_t *sl, int idx)
struct timeval timestamp_began
#define CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT
smartlist_t * get_connection_array(void)
int nodes_in_same_family(const node_t *node1, const node_t *node2)
static void circuit_about_to_free_atexit(circuit_t *circ)
uint16_t marked_for_close
Header file for nodelist.c.
Header file for routerlist.c.
Header file for routerset.c.
Header for compress_zstd.c.
const char * circuit_purpose_to_controller_string(uint8_t purpose)
void circpad_circuit_free_all_machineinfos(circuit_t *circ)
Header file for predict_ports.c.
struct or_circuit_t * rend_splice
const circuit_build_times_t * get_circuit_build_times(void)
void tor_gettimeofday(struct timeval *timeval)
or_circuit_t * or_circuit_new(circid_t p_circ_id, channel_t *p_chan)
Header file for circuitstats.c.
struct timeval timestamp_created
const char * circuit_purpose_to_controller_hs_state_string(uint8_t purpose)
static smartlist_t * circuits_pending_other_guards
Header for core/or/extendinfo.c.
Header file for buffers.c.
#define DEAD_CIRCUIT_MAGIC
char rend_cookie[REND_COOKIE_LEN]
unsigned int p_delete_pending
int entry_guard_could_succeed(const circuit_guard_state_t *guard_state)
void smartlist_sort_pointers(smartlist_t *sl)
struct circuit_guard_state_t * guard_state
Common functions for using (pseudo-)random number generators.
void connection_free_(connection_t *conn)
void relay_crypto_assert_ok(const relay_crypto_t *crypto)
struct circuit_t * on_circuit
Header file for control_events.c.
void circuit_synchronize_written_or_bandwidth(const circuit_t *c, circuit_channel_direction_t dir)
const or_options_t * get_options(void)
#define DFLT_IDLE_TIMEOUT_WHILE_LEARNING
Header for compress_zlib.c.
cpath_build_state_t * build_state
int circuit_count_pending_on_channel(channel_t *chan)
void channel_note_destroy_pending(channel_t *chan, circid_t id)
STATIC smartlist_t * connection_array
Header file for circuitbuild.c.
#define CIRCUIT_PURPOSE_S_REND_JOINED
unsigned int remaining_relay_early_cells
int circuit_any_opened_circuits_cached(void)
void smartlist_clear(smartlist_t *sl)
#define CIRCLAUNCH_IS_INTERNAL
unsigned int n_delete_pending
int circuit_id_in_use_on_channel(circid_t circ_id, channel_t *chan)
#define CIRCUIT_PURPOSE_C_INTRODUCE_ACKED
size_t buf_allocation(const buf_t *buf)
cell_queue_t n_chan_cells
Edge-connection structure.
#define CIRCLAUNCH_NEED_UPTIME
int pathbias_check_close(origin_circuit_t *ocirc, int reason)
void channel_unlink_all_circuits(channel_t *chan, smartlist_t *circuits_out)
smartlist_t * circuit_find_circuits_to_upgrade_from_guard_wait(void)
unsigned int need_capacity
int circuit_build_times_needs_circuits(const circuit_build_times_t *cbt)
#define CIRCUIT_PURPOSE_C_HSDIR_GET
static void cpath_ref_decref(crypt_path_reference_t *cpath_ref)
origin_circuit_t * TO_ORIGIN_CIRCUIT(circuit_t *x)
#define CIRCUIT_PURPOSE_C_REND_READY
int circuit_get_cpath_opened_len(const origin_circuit_t *circ)
Header file for connection.c.
struct connection_t * linked_conn
Header file for channeltls.c.
static void circuit_about_to_free(circuit_t *circ)
void onion_pending_remove(or_circuit_t *circ)
void assert_circuit_ok(const circuit_t *c)
char identity_digest[DIGEST_LEN]
void cell_queue_clear(cell_queue_t *queue)
void circuit_mark_all_unused_circs(void)
#define CIRCUIT_PURPOSE_S_CONNECT_REND
void circuit_set_n_circid_chan(circuit_t *circ, circid_t id, channel_t *chan)
uint32_t buf_get_oldest_chunk_timestamp(const buf_t *buf, uint32_t now)
void circuit_build_failed(origin_circuit_t *circ)
#define FALLTHROUGH_UNLESS_ALL_BUGS_ARE_FATAL
void circuit_close_all_marked(void)
uint32_t monotime_coarse_get_stamp(void)
void circuit_reset_sendme_randomness(circuit_t *circ)
int circuit_should_use_vanguards(uint8_t purpose)
#define CIRCUIT_PURPOSE_S_ESTABLISH_INTRO
bool node_supports_v3_rendezvous_point(const node_t *node)
#define CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED
static circuit_t * circuit_get_by_circid_channel_impl(circid_t circ_id, channel_t *chan, int *found_entry_out)
extend_info_t * extend_info
origin_circuit_t * circuit_get_ready_rend_circ_by_rend_data(const rend_data_t *rend_data)
#define CIRCUIT_PURPOSE_S_INTRO
#define SMARTLIST_FOREACH_BEGIN(sl, type, var)
time_t circuit_id_when_marked_unusable_on_channel(circid_t circ_id, channel_t *chan)
Header for relay_crypto.c.
#define SMARTLIST_DEL_CURRENT(sl, var)
void circuitmux_attach_circuit(circuitmux_t *cmux, circuit_t *circ, cell_direction_t direction)
#define CIRCUIT_PURPOSE_TESTING
void circuit_mark_all_dirty_circs_as_unusable(void)
Client/server directory connection structure.
Header file for onion_crypto.c.
#define CIRCLAUNCH_IS_V3_RP
void buf_clear(buf_t *buf)
int channel_matches_extend_info(channel_t *chan, extend_info_t *extend_info)
STATIC size_t n_cells_in_circ_queues(const circuit_t *c)
struct workqueue_entry_t * workqueue_entry
Header file for policies.c.
dir_connection_t * TO_DIR_CONN(connection_t *c)
HT_PROTOTYPE(hs_circuitmap_ht, circuit_t, hs_circuitmap_node, hs_circuit_hash_token, hs_circuits_have_same_token)
struct crypt_path_t * next
Header file for hs_circuitmap.c.
const char * rend_data_get_address(const rend_data_t *rend_data)
void circuit_set_state(circuit_t *circ, uint8_t state)
Header file for config.c.
size_t tor_compress_get_total_allocation(void)
enum channel_t::@8 reason_for_closing
const char * circuit_state_to_string(int state)
void circuit_free_all(void)
int smartlist_contains(const smartlist_t *sl, const void *element)
int global_origin_circuit_list_idx
uint64_t global_identifier
void tor_log(int severity, log_domain_mask_t domain, const char *format,...)
origin_circuit_t * circuit_get_next_service_rp_circ(origin_circuit_t *start)
void mark_circuit_unusable_for_new_conns(origin_circuit_t *circ)
struct hs_ident_circuit_t * hs_ident
#define CIRCUIT_STATE_GUARD_WAIT
int circuit_get_cpath_len(origin_circuit_t *circ)
time_t timestamp_last_had_circuits
edge_connection_t * p_streams
unsigned int num_n_circuits
void circuit_mark_for_close_(circuit_t *circ, int reason, int line, const char *file)
struct edge_connection_t * next_stream
int channel_get_addr_if_possible(const channel_t *chan, tor_addr_t *addr_out)
void relay_crypto_clear(relay_crypto_t *crypto)
crypt_path_t * pending_final_cpath
struct tor_compress_state_t * compress_state
Header file containing circuit data for the whole HS subsystem.
size_t tor_zlib_get_total_allocation(void)
void hs_circ_cleanup_on_close(circuit_t *circ)
int32_t networkstatus_get_param(const networkstatus_t *ns, const char *param_name, int32_t default_val, int32_t min_val, int32_t max_val)
void smartlist_sort(smartlist_t *sl, int(*compare)(const void **a, const void **b))
int connection_edge_destroy(circid_t circ_id, edge_connection_t *conn)
int channel_send_destroy(circid_t circ_id, channel_t *chan, int reason)
or_circuit_t * TO_OR_CIRCUIT(circuit_t *x)
#define CIRCUIT_STATE_BUILDING
Origin circuit structure.
size_t tor_lzma_get_total_allocation(void)
circuit_t * circuit_get_by_edge_conn(edge_connection_t *conn)
void smartlist_remove(smartlist_t *sl, const void *element)
void circuit_clear_testing_cell_stats(circuit_t *circ)
origin_circuit_t * origin_circuit_new(void)
Header file for rendclient.c.
int32_t circuit_initial_package_window(void)
int circuit_build_times_disabled(const or_options_t *options)
Header file for rendcommon.c.
void circuit_get_all_pending_on_channel(smartlist_t *out, channel_t *chan)
Header file for rephist.c.
#define CIRCUIT_PURPOSE_C_INTRODUCING
Header file for ocirc_event.c.
Header file for connection_or.c.
#define END_STREAM_REASON_FLAG_ALREADY_SENT_CLOSED
uint32_t inserted_timestamp
crypt_path_reference_t * service_pending_final_cpath_ref
STATIC uint32_t circuit_max_queued_cell_age(const circuit_t *c, uint32_t now)
static smartlist_t * circuits_pending_close
const char * circuit_purpose_to_string(uint8_t purpose)
static int chan_circid_entries_eq_(chan_circid_circuit_map_t *a, chan_circid_circuit_map_t *b)
static unsigned int chan_circid_entry_hash_(chan_circid_circuit_map_t *a)
Master header file for Tor-specific functionality.
int circuit_event_status(origin_circuit_t *circ, circuit_status_event_t tp, int reason_code)
void circuit_clear_cell_queue(circuit_t *circ, channel_t *chan)
crypt_path_t * circuit_get_cpath_hop(origin_circuit_t *circ, int hopnum)