54 #define CHANNEL_OBJECT_PRIVATE
57 #define CHANNEL_FILE_PRIVATE
63 #include "core/or/channelpadding.h"
70 #include "core/or/dos.h"
122 channel_id_hash, channel_id_eq);
123 HT_GENERATE2(channel_gid_map,
channel_t, gidmap_node,
124 channel_id_hash, channel_id_eq,
130 static uint64_t n_channels_allocated = 0;
140 static
HT_HEAD(channel_idmap, channel_idmap_entry_t) channel_identity_map =
143 typedef struct channel_idmap_entry_t {
144 HT_ENTRY(channel_idmap_entry_t) node;
146 TOR_LIST_HEAD(channel_list_t,
channel_t) channel_list;
147 } channel_idmap_entry_t;
149 static inline unsigned
150 channel_idmap_hash(
const channel_idmap_entry_t *ent)
152 return (
unsigned) siphash24g(ent->digest,
DIGEST_LEN);
156 channel_idmap_eq(
const channel_idmap_entry_t *a,
157 const channel_idmap_entry_t *b)
162 HT_PROTOTYPE(channel_idmap, channel_idmap_entry_t, node, channel_idmap_hash,
164 HT_GENERATE2(channel_idmap, channel_idmap_entry_t, node, channel_idmap_hash,
327 descr =
"channel error";
330 descr =
"temporarily suspended for maintenance";
340 descr =
"unknown or invalid channel state";
362 descr =
"channel listener error";
369 descr =
"unknown or invalid channel listener state";
395 "Registering channel %p (ID %"PRIu64
") "
396 "in state %s (%d) with digest %s",
404 channel_t *oldval = HT_REPLACE(channel_gid_map, &channel_gid_map, chan);
408 if (CHANNEL_FINISHED(chan)) {
418 if (!CHANNEL_IS_CLOSING(chan)) {
425 "Channel %p (global ID %"PRIu64
") "
426 "in state %s (%d) registered with no identity digest",
452 if (CHANNEL_FINISHED(chan)) {
462 channel_t *oldval = HT_REMOVE(channel_gid_map, &channel_gid_map, chan);
470 !(CHANNEL_CONDEMNED(chan))) {
491 "Registering channel listener %p (ID %"PRIu64
") "
505 if (!finished_listeners) finished_listeners =
smartlist_new();
562 channel_idmap_entry_t *ent, search;
573 ent = HT_FIND(channel_idmap, &channel_identity_map, &search);
575 ent = tor_malloc(
sizeof(channel_idmap_entry_t));
577 TOR_LIST_INIT(&ent->channel_list);
578 HT_INSERT(channel_idmap, &channel_identity_map, ent);
580 TOR_LIST_INSERT_HEAD(&ent->channel_list, chan, next_with_same_id);
583 "Added channel %p (global ID %"PRIu64
") "
584 "to identity map in state %s (%d) with digest %s",
599 channel_idmap_entry_t *ent, search;
607 TOR_LIST_REMOVE(chan, next_with_same_id);
610 ent = HT_FIND(channel_idmap, &channel_identity_map, &search);
616 if (TOR_LIST_EMPTY(&ent->channel_list)) {
617 HT_REMOVE(channel_idmap, &channel_identity_map, ent);
622 "Removed channel %p (global ID %"PRIu64
") from "
623 "identity map in state %s (%d) with digest %s",
630 "Trying to remove channel %p (global ID %"PRIu64
") with "
631 "digest %s from identity map, but couldn't find any with "
656 rv = HT_FIND(channel_gid_map, &channel_gid_map, &lookup);
668 const char *rsa_id_digest,
701 channel_idmap_entry_t *ent, search;
712 memcpy(search.digest, rsa_id_digest,
DIGEST_LEN);
713 ent = HT_FIND(channel_idmap, &channel_identity_map, &search);
715 rv = TOR_LIST_FIRST(&ent->channel_list);
735 return TOR_LIST_NEXT(chan, next_with_same_id);
750 channel_idmap_entry_t **iter;
752 int total_dirauth_connections = 0, total_dirauths = 0;
753 int total_relay_connections = 0, total_relays = 0, total_canonical = 0;
754 int total_half_canonical = 0;
755 int total_gt_one_connection = 0, total_gt_two_connections = 0;
756 int total_gt_four_connections = 0;
758 HT_FOREACH(iter, channel_idmap, &channel_identity_map) {
759 int connections_to_relay = 0;
760 const char *id_digest = (
char *) (*iter)->digest;
768 const bool is_dirauth = router_digest_is_trusted_dir(id_digest);
772 for (chan = TOR_LIST_FIRST(&(*iter)->channel_list); chan;
775 if (CHANNEL_CONDEMNED(chan) || !CHANNEL_IS_OPEN(chan))
778 connections_to_relay++;
779 total_relay_connections++;
781 total_dirauth_connections++;
786 total_half_canonical++;
790 if (connections_to_relay > 1) total_gt_one_connection++;
791 if (connections_to_relay > 2) total_gt_two_connections++;
792 if (connections_to_relay > 4) total_gt_four_connections++;
798 #define MIN_RELAY_CONNECTIONS_TO_WARN 25
802 #define MAX_AVG_RELAY_CONNECTIONS 1.5
806 #define MAX_AVG_DIRAUTH_CONNECTIONS 4
810 const int max_tolerable_connections = (int)(
811 (total_relays-total_dirauths) * MAX_AVG_RELAY_CONNECTIONS +
812 total_dirauths * MAX_AVG_DIRAUTH_CONNECTIONS);
815 if (total_relays > MIN_RELAY_CONNECTIONS_TO_WARN &&
816 total_relay_connections > max_tolerable_connections) {
818 "Your relay has a very large number of connections to other relays. "
819 "Is your outbound address the same as your relay address? "
820 "Found %d connections to authorities, %d connections to %d relays. "
821 "Found %d current canonical connections, "
822 "in %d of which we were a non-canonical peer. "
823 "%d relays had more than 1 connection, %d had more than 2, and "
824 "%d had more than 4 connections.",
825 total_dirauth_connections, total_relay_connections,
826 total_relays, total_canonical, total_half_canonical,
827 total_gt_one_connection, total_gt_two_connections,
828 total_gt_four_connections);
830 log_info(
LD_OR,
"Performed connection pruning. "
831 "Found %d connections to authorities, %d connections to %d relays. "
832 "Found %d current canonical connections, "
833 "in %d of which we were a non-canonical peer. "
834 "%d relays had more than 1 connection, %d had more than 2, and "
835 "%d had more than 4 connections.",
836 total_dirauth_connections, total_relay_connections,
837 total_relays, total_canonical, total_half_canonical,
838 total_gt_one_connection, total_gt_two_connections,
839 total_gt_four_connections);
865 memset(&chan->next_with_same_id, 0,
sizeof(chan->next_with_same_id));
917 "Freeing channel %"PRIu64
" at %p",
921 scheduler_release_channel(chan);
934 channel_handles_clear(chan);
945 circuitmux_free(chan->
cmux);
963 "Freeing channel_listener_t %"PRIu64
" at %p",
990 "Force-freeing channel %"PRIu64
" at %p",
994 scheduler_release_channel(chan);
1007 channel_handles_clear(chan);
1016 circuitmux_free(chan->
cmux);
1034 "Force-freeing channel_listener_t %"PRIu64
" at %p",
1050 } SMARTLIST_FOREACH_END(qchan);
1067 channel_listener_fn_ptr listener)
1073 "Setting listener callback for channel listener %p "
1074 "(global ID %"PRIu64
") to %p",
1088 channel_cell_handler_fn_ptr
1093 if (CHANNEL_CAN_HANDLE_CELLS(chan))
1107 channel_cell_handler_fn_ptr cell_handler)
1113 "Setting cell_handler callback for channel %p to %p",
1114 chan, cell_handler);
1147 if (CHANNEL_CONDEMNED(chan))
1151 "Closing channel %p (global ID %"PRIu64
") "
1191 "Closing channel listener %p (global ID %"PRIu64
") "
1202 chan_l->
close(chan_l);
1225 if (CHANNEL_CONDEMNED(chan))
1229 "Closing channel %p (global ID %"PRIu64
") "
1230 "due to lower-layer event",
1253 if (CHANNEL_CONDEMNED(chan))
1257 "Closing channel %p due to lower-layer error",
1281 if (CHANNEL_FINISHED(chan))
1308 int state_not_in_map;
1313 "Clearing remote endpoint digest on channel %p with "
1314 "global ID %"PRIu64,
1317 state_not_in_map = CHANNEL_CONDEMNED(chan);
1336 const char *identity_digest,
1339 int was_in_digest_map, should_be_in_digest_map, state_not_in_map;
1344 "Setting remote endpoint digest on channel %p with "
1345 "global ID %"PRIu64
" to digest %s",
1350 state_not_in_map = CHANNEL_CONDEMNED(chan);
1353 !state_not_in_map &&
1356 should_be_in_digest_map =
1357 !state_not_in_map &&
1362 if (was_in_digest_map)
1368 if (identity_digest) {
1383 if (should_be_in_digest_map)
1396 int state_not_in_map;
1401 "Clearing remote endpoint identity on channel %p with "
1402 "global ID %"PRIu64,
1405 state_not_in_map = CHANNEL_CONDEMNED(chan);
1444 cell_bytes = get_cell_network_size(chan->wide_circ_ids);
1447 if (!CHANNEL_IS_OPEN(chan)) {
1459 chan->n_bytes_xmitted += cell_bytes;
1495 if (CHANNEL_IS_CLOSING(chan)) {
1496 log_debug(
LD_CHANNEL,
"Discarding %p on closing channel %p with "
1497 "global ID %"PRIu64, cell, chan,
1502 "Writing %p to channel %p with global ID "
1511 packed_cell_free(cell);
1526 unsigned char was_active, is_active;
1527 unsigned char was_in_id_map, is_in_id_map;
1530 from_state = chan->
state;
1537 if (from_state == to_state) {
1539 "Got no-op transition from \"%s\" to itself on channel %p"
1540 "(global ID %"PRIu64
")",
1554 "Changing state of channel %p (global ID %"PRIu64
1555 ") from \"%s\" to \"%s\"",
1561 chan->
state = to_state;
1571 if (was_active && !is_active) {
1573 if (!finished_channels) finished_channels =
smartlist_new();
1578 else if (!was_active && is_active) {
1594 else if (was_in_id_map && !is_in_id_map)
1606 scheduler_release_channel(chan);
1647 unsigned char was_active, is_active;
1650 from_state = chan_l->
state;
1657 if (from_state == to_state) {
1659 "Got no-op transition from \"%s\" to itself on channel "
1660 "listener %p (global ID %"PRIu64
")",
1674 "Changing state of channel listener %p (global ID %"PRIu64
1675 "from \"%s\" to \"%s\"",
1680 chan_l->
state = to_state;
1690 if (was_active && !is_active) {
1692 if (!finished_listeners) finished_listeners =
smartlist_new();
1697 else if (!was_active && is_active) {
1713 #define MAX_CELLS_TO_GET_FROM_CIRCUITS_FOR_UNLIMITED 256
1736 unsigned int unlimited = 0;
1737 ssize_t flushed = 0;
1738 int clamped_num_cells;
1742 if (num_cells < 0) unlimited = 1;
1743 if (!unlimited && num_cells <= flushed)
goto done;
1746 if (CHANNEL_IS_OPEN(chan)) {
1750 clamped_num_cells = MAX_CELLS_TO_GET_FROM_CIRCUITS_FOR_UNLIMITED;
1752 if (num_cells - flushed >
1753 MAX_CELLS_TO_GET_FROM_CIRCUITS_FOR_UNLIMITED) {
1754 clamped_num_cells = MAX_CELLS_TO_GET_FROM_CIRCUITS_FOR_UNLIMITED;
1756 clamped_num_cells = (int)(num_cells - flushed);
1762 chan, clamped_num_cells);
1824 "Processing queue of incoming connections for channel "
1825 "listener %p (global ID %"PRIu64
")",
1835 "Handling incoming channel %p (%"PRIu64
") "
1836 "for listener %p (%"PRIu64
")",
1843 listener->
listener(listener, chan);
1844 } SMARTLIST_FOREACH_END(chan);
1867 time_t now = time(NULL);
1868 int close_origin_circuits = 0;
1881 char *transport_name = NULL;
1882 channel_tls_t *tlschan = BASE_CHAN_TO_TLS(chan);
1883 if (chan->get_transport_name(chan, &transport_name) < 0)
1884 transport_name = NULL;
1887 &remote_addr, transport_name,
1890 if (tlschan && tlschan->conn) {
1891 dos_new_client_conn(tlschan->conn, transport_name);
1904 }
else if (hs_service_allow_non_anonymous_connection(
get_options()) &&
1906 CHANNELPADDING_SOS_PARAM,
1907 CHANNELPADDING_SOS_DEFAULT, 0, 1)) {
1911 }
else if (
get_options()->ReducedConnectionPadding) {
1932 int need_to_queue = 0;
1939 "Queueing incoming channel %p (global ID %"PRIu64
") on "
1940 "channel listener %p (global ID %"PRIu64
")",
1945 if (!(listener->
listener)) need_to_queue = 1;
1961 if (!need_to_queue) {
1963 listener->
listener(listener, incoming);
1983 tor_assert(CHANNEL_IS_CLOSING(chan) || CHANNEL_IS_MAINT(chan) ||
1984 CHANNEL_IS_OPEN(chan));
1995 chan->n_bytes_recved += get_cell_network_size(chan->wide_circ_ids);
1998 "Processing incoming cell_t %p for channel %p (global ID "
1999 "%"PRIu64
")", cell, chan,
2013 if (chan->wide_circ_ids) {
2014 if (packed_cell->
body[4] == CELL_DESTROY) {
2019 if (packed_cell->
body[2] == CELL_DESTROY) {
2039 log_warn(
LD_BUG,
"Attempted to send a destroy cell for circID 0 "
2040 "on a channel %"PRIu64
" at %p in state %s (%d)",
2048 if (!CHANNEL_CONDEMNED(chan) && chan->
cmux) {
2050 circuitmux_append_destroy_cell(chan, chan->
cmux, circ_id, reason);
2052 "Sending destroy (circID %u) on channel %p "
2053 "(global ID %"PRIu64
")",
2054 (
unsigned)circ_id, chan,
2058 "Someone called channel_send_destroy() for circID %u "
2059 "on a channel %"PRIu64
" at %p in state %s (%d)",
2077 if (all_channels && smartlist_len(all_channels) > 0) {
2079 "Dumping statistics about %d channels:",
2080 smartlist_len(all_channels));
2082 "%d are active, and %d are done and waiting for cleanup",
2083 (active_channels != NULL) ?
2084 smartlist_len(active_channels) : 0,
2085 (finished_channels != NULL) ?
2086 smartlist_len(finished_channels) : 0);
2092 "Done spamming about channels now");
2095 "No channels to dump");
2108 if (all_listeners && smartlist_len(all_listeners) > 0) {
2110 "Dumping statistics about %d channel listeners:",
2111 smartlist_len(all_listeners));
2113 "%d are active and %d are done and waiting for cleanup",
2114 (active_listeners != NULL) ?
2115 smartlist_len(active_listeners) : 0,
2116 (finished_listeners != NULL) ?
2117 smartlist_len(finished_listeners) : 0);
2123 "Done spamming about channel listeners now");
2126 "No channel listeners to dump");
2142 if (!finished_channels || smartlist_len(finished_channels) == 0)
return;
2153 } SMARTLIST_FOREACH_END(curr);
2168 if (!finished_listeners || smartlist_len(finished_listeners) == 0)
return;
2178 channel_listener_free(tmp);
2179 } SMARTLIST_FOREACH_END(curr);
2188 if (!channels)
return;
2194 "Cleaning up channel %p (global ID %"PRIu64
") "
2196 curr, (curr->global_identifier),
2204 if (mark_for_close) {
2205 if (!CHANNEL_CONDEMNED(curr)) {
2209 }
else channel_free(curr);
2210 } SMARTLIST_FOREACH_END(curr);
2219 if (!listeners)
return;
2225 "Cleaning up channel listener %p (global ID %"PRIu64
") "
2227 curr, (curr->global_identifier),
2230 if (mark_for_close) {
2237 }
else channel_listener_free(curr);
2238 } SMARTLIST_FOREACH_END(curr);
2253 "Shutting down channels...");
2256 if (finished_channels) {
2258 smartlist_free(finished_channels);
2259 finished_channels = NULL;
2263 if (finished_listeners) {
2265 smartlist_free(finished_listeners);
2266 finished_listeners = NULL;
2270 if (active_channels) {
2272 smartlist_free(active_channels);
2273 active_channels = NULL;
2277 if (active_listeners) {
2279 smartlist_free(active_listeners);
2280 active_listeners = NULL;
2286 smartlist_free(all_channels);
2287 all_channels = NULL;
2291 if (all_listeners) {
2293 smartlist_free(all_listeners);
2294 all_listeners = NULL;
2299 "Freeing channel_identity_map");
2301 HT_CLEAR(channel_idmap, &channel_identity_map);
2305 "Freeing channel_gid_map");
2306 HT_CLEAR(channel_gid_map, &channel_gid_map);
2309 "Done cleaning up after channels");
2324 const char *id_digest,
2343 int a_is_canonical, b_is_canonical;
2359 if (a_is_canonical && !b_is_canonical)
return 1;
2360 if (!a_is_canonical && b_is_canonical)
return 0;
2411 bool for_origin_circ,
2412 const char **msg_out,
2416 int n_inprogress_goodaddr = 0, n_old = 0;
2417 int n_noncanonical = 0;
2429 if (CHANNEL_CONDEMNED(chan))
2443 const bool matches_target =
2448 if (!CHANNEL_IS_OPEN(chan)) {
2451 if (matches_target) {
2452 ++n_inprogress_goodaddr;
2453 if (for_origin_circ) {
2486 *msg_out =
"Connection is fine; using it.";
2489 }
else if (n_inprogress_goodaddr) {
2490 *msg_out =
"Connection in progress; waiting.";
2493 }
else if (n_old || n_noncanonical) {
2494 *msg_out =
"Connections all too old, or too non-canonical. "
2495 " Launching a new one.";
2499 *msg_out =
"Not connected. Connecting.";
2543 double avg, interval, age;
2544 time_t now = time(NULL);
2546 int have_remote_addr;
2547 char *remote_addr_str;
2554 "Channel %"PRIu64
" (at %p) with transport %s is in state "
2560 " * Channel %"PRIu64
" was created at %"PRIu64
2561 " (%"PRIu64
" seconds ago) "
2562 "and last active at %"PRIu64
" (%"PRIu64
" seconds ago)",
2566 (uint64_t)(chan->timestamp_active),
2567 (uint64_t)(now - chan->timestamp_active));
2572 " * Channel %"PRIu64
" says it is connected "
2573 "to an OR with digest %s",
2578 " * Channel %"PRIu64
" does not know the digest"
2579 " of the OR it is connected to",
2585 if (have_remote_addr) {
2589 " * Channel %"PRIu64
" says its remote address"
2590 " is %s, and gives a canonical description of \"%s\" and an "
2591 "actual description of \"%s\"",
2593 safe_str(remote_addr_str),
2601 " * Channel %"PRIu64
" does not know its remote "
2602 "address, but gives a canonical description of \"%s\" and an "
2603 "actual description of \"%s\"",
2612 " * Channel %"PRIu64
" has these marks: %s %s %s %s %s",
2615 "bad_for_new_circs" :
"!bad_for_new_circs",
2617 "canonical" :
"!canonical",
2619 "client" :
"!client",
2623 "incoming" :
"outgoing");
2627 " * Channel %"PRIu64
" has %d active circuits out of"
2630 (chan->
cmux != NULL) ?
2632 (chan->
cmux != NULL) ?
2638 " * Channel %"PRIu64
" was never used by a "
2642 " * Channel %"PRIu64
" was last used by a "
2643 "client at %"PRIu64
" (%"PRIu64
" seconds ago)",
2650 " * Channel %"PRIu64
" never received a cell",
2654 " * Channel %"PRIu64
" last received a cell "
2655 "at %"PRIu64
" (%"PRIu64
" seconds ago)",
2662 " * Channel %"PRIu64
" never transmitted a cell",
2666 " * Channel %"PRIu64
" last transmitted a cell "
2667 "at %"PRIu64
" (%"PRIu64
" seconds ago)",
2675 " * Channel %"PRIu64
" has received "
2676 "%"PRIu64
" bytes in %"PRIu64
" cells and transmitted "
2677 "%"PRIu64
" bytes in %"PRIu64
" cells",
2679 (chan->n_bytes_recved),
2681 (chan->n_bytes_xmitted),
2685 if (chan->n_bytes_recved > 0) {
2686 avg = (double)(chan->n_bytes_recved) / age;
2688 " * Channel %"PRIu64
" has averaged %f "
2689 "bytes received per second",
2696 " * Channel %"PRIu64
" has averaged %f "
2697 "cells received per second",
2699 }
else if (avg >= 0.0) {
2700 interval = 1.0 / avg;
2702 " * Channel %"PRIu64
" has averaged %f "
2703 "seconds between received cells",
2707 if (chan->n_bytes_xmitted > 0) {
2708 avg = (double)(chan->n_bytes_xmitted) / age;
2710 " * Channel %"PRIu64
" has averaged %f "
2711 "bytes transmitted per second",
2718 " * Channel %"PRIu64
" has averaged %f "
2719 "cells transmitted per second",
2721 }
else if (avg >= 0.0) {
2722 interval = 1.0 / avg;
2724 " * Channel %"PRIu64
" has averaged %f "
2725 "seconds between transmitted cells",
2743 double avg, interval, age;
2744 time_t now = time(NULL);
2751 "Channel listener %"PRIu64
" (at %p) with transport %s is in "
2757 " * Channel listener %"PRIu64
" was created at %"PRIu64
2758 " (%"PRIu64
" seconds ago) "
2759 "and last active at %"PRIu64
" (%"PRIu64
" seconds ago)",
2763 (uint64_t)(chan_l->timestamp_active),
2764 (uint64_t)(now - chan_l->timestamp_active));
2767 " * Channel listener %"PRIu64
" last accepted an incoming "
2768 "channel at %"PRIu64
" (%"PRIu64
" seconds ago) "
2769 "and has accepted %"PRIu64
" channels in total",
2785 " * Channel listener %"PRIu64
" has averaged %f incoming "
2786 "channels per second",
2788 }
else if (avg >= 0.0) {
2789 interval = 1.0 / avg;
2791 " * Channel listener %"PRIu64
" has averaged %f seconds "
2792 "between incoming channels",
2863 return chan->get_remote_addr(chan, addr_out);
3087 result = chan->num_cells_writeable(chan);
3088 if (result < 0) result = 0;
3110 time_t now = time(NULL);
3126 time_t now = time(NULL);
3146 time_t now = time(NULL);
3151 chan->timestamp_active = now;
3163 time_t now = time(NULL);
3167 chan_l->timestamp_active = now;
3180 time_t now = time(NULL);
3184 chan_l->timestamp_active = now;
3197 time_t now = time(NULL);
3213 time_t now = time(NULL);
3217 chan->timestamp_active = now;
3233 time_t now = time(NULL);
3238 chan->timestamp_active = now;
3319 IF_BUG_ONCE(!target_ipv4_addr && !target_ipv6_addr)
3322 if (target_ipv4_addr && chan->
matches_target(chan, target_ipv4_addr))
3325 if (target_ipv6_addr && chan->
matches_target(chan, target_ipv6_addr))
3343 chan->num_p_circuits;
3355 int consider_identity))
3364 if (! consider_identity) {
3372 our_identity = started_here ?
3375 if (identity_rcvd) {
3387 channel_sort_by_ed25519_identity(
const void **a_,
const void **b_)
3392 &b->ed25519_identity.pubkey,
3410 if (PREDICT_LIKELY(!TOR_LIST_NEXT(chan, next_with_same_id))) {
3412 time(NULL), BASE_CHAN_TO_TLS(chan)->conn, force);
3418 TOR_LIST_FOREACH(chan, lst, next_with_same_id) {
3419 if (BASE_CHAN_TO_TLS(chan)->conn) {
3432 if (!common_ed25519_identity)
3433 common_ed25519_identity = &channel->ed25519_identity;
3436 common_ed25519_identity)) {
3439 common_ed25519_identity = &channel->ed25519_identity;
3443 } SMARTLIST_FOREACH_END(channel);
3450 smartlist_free(or_conns);
3451 smartlist_free(channels);
3463 channel_idmap_entry_t *ent;
3464 channel_idmap_entry_t search;
3465 memset(&search, 0,
sizeof(search));
3467 ent = HT_FIND(channel_idmap, &channel_identity_map, &search);
3475 channel_idmap_entry_t **iter;
3476 HT_FOREACH(iter, channel_idmap, &channel_identity_map) {
void tor_addr_make_unspec(tor_addr_t *a)
char * tor_addr_to_str_dup(const tor_addr_t *addr)
const char * hex_str(const char *from, size_t fromlen)
static uint16_t get_uint16(const void *cp)
static uint32_t get_uint32(const void *cp)
const char * channel_listener_describe_transport(channel_listener_t *chan_l)
int channel_has_queued_writes(channel_t *chan)
channel_t * channel_find_by_global_id(uint64_t global_identifier)
channel_t * channel_find_by_remote_identity(const char *rsa_id_digest, const ed25519_public_key_t *ed_id)
void channel_timestamp_active(channel_t *chan)
void channel_set_circid_type(channel_t *chan, crypto_pk_t *identity_rcvd, int consider_identity)
int channel_is_better(channel_t *a, channel_t *b)
int channel_is_bad_for_new_circs(channel_t *chan)
static void channel_remove_from_digest_map(channel_t *chan)
int channel_is_outgoing(channel_t *chan)
const char * channel_describe_transport(channel_t *chan)
void channel_listener_process_incoming(channel_listener_t *listener)
channel_t * channel_next_with_rsa_identity(channel_t *chan)
void channel_timestamp_recv(channel_t *chan)
void channel_run_cleanup(void)
void channel_update_bad_for_new_circs(const char *digest, int force)
void channel_dumpstats(int severity)
void channel_timestamp_client(channel_t *chan)
void channel_set_identity_digest(channel_t *chan, const char *identity_digest, const ed25519_public_key_t *ed_identity)
void channel_listener_unregister(channel_listener_t *chan_l)
channel_t * channel_connect(const tor_addr_t *addr, uint16_t port, const char *id_digest, const ed25519_public_key_t *ed_id)
void channel_listener_dump_statistics(channel_listener_t *chan_l, int severity)
void channel_mark_local(channel_t *chan)
void channel_set_cell_handlers(channel_t *chan, channel_cell_handler_fn_ptr cell_handler)
void channel_mark_client(channel_t *chan)
time_t channel_when_last_xmit(channel_t *chan)
void channel_listener_run_cleanup(void)
static void channel_force_xfree(channel_t *chan)
void channel_mark_incoming(channel_t *chan)
void channel_closed(channel_t *chan)
void channel_init_listener(channel_listener_t *chan_l)
int channel_listener_state_can_transition(channel_listener_state_t from, channel_listener_state_t to)
STATIC void channel_add_to_digest_map(channel_t *chan)
int channel_state_is_valid(channel_state_t state)
void channel_do_open_actions(channel_t *chan)
void channel_listener_mark_for_close(channel_listener_t *chan_l)
void channel_close_from_lower_layer(channel_t *chan)
void channel_check_for_duplicates(void)
void channel_process_cell(channel_t *chan, cell_t *cell)
void channel_change_state_open(channel_t *chan)
void channel_listener_queue_incoming(channel_listener_t *listener, channel_t *incoming)
int channel_is_canonical(channel_t *chan)
int channel_listener_state_is_valid(channel_listener_state_t state)
void channel_timestamp_created(channel_t *chan)
static void channel_free_list(smartlist_t *channels, int mark_for_close)
int channel_matches_extend_info(channel_t *chan, extend_info_t *extend_info)
int channel_state_can_transition(channel_state_t from, channel_state_t to)
int channel_remote_identity_matches(const channel_t *chan, const char *rsa_id_digest, const ed25519_public_key_t *ed_id)
void channel_listener_set_listener_fn(channel_listener_t *chan_l, channel_listener_fn_ptr listener)
void channel_register(channel_t *chan)
time_t channel_when_last_client(channel_t *chan)
void channel_listener_timestamp_created(channel_listener_t *chan_l)
void channel_listener_timestamp_active(channel_listener_t *chan_l)
void channel_listener_register(channel_listener_t *chan_l)
void channel_listener_dump_transport_statistics(channel_listener_t *chan_l, int severity)
static void channel_change_state_(channel_t *chan, channel_state_t to_state)
static HT_HEAD(channel_gid_map, channel_t)
int channel_send_destroy(circid_t circ_id, channel_t *chan, int reason)
void channel_mark_bad_for_new_circs(channel_t *chan)
int channel_is_incoming(channel_t *chan)
int channel_is_client(const channel_t *chan)
void channel_mark_remote(channel_t *chan)
void channel_unregister(channel_t *chan)
static void channel_rsa_id_group_set_badness(struct channel_list_t *lst, int force)
channel_cell_handler_fn_ptr channel_get_cell_handler(channel_t *chan)
ssize_t channel_flush_some_cells(channel_t *chan, ssize_t num_cells)
static void channel_listener_free_list(smartlist_t *channels, int mark_for_close)
int packed_cell_is_destroy(channel_t *chan, const packed_cell_t *packed_cell, circid_t *circid_out)
STATIC bool channel_matches_target_addr_for_extend(channel_t *chan, const tor_addr_t *target_ipv4_addr, const tor_addr_t *target_ipv6_addr)
void channel_close_for_error(channel_t *chan)
void channel_listener_free_(channel_listener_t *chan_l)
void channel_listener_dumpstats(int severity)
static int write_packed_cell(channel_t *chan, packed_cell_t *cell)
int channel_is_local(channel_t *chan)
void channel_listener_timestamp_accepted(channel_listener_t *chan_l)
void channel_notify_flushed(channel_t *chan)
int channel_num_cells_writeable(channel_t *chan)
void channel_timestamp_xmit(channel_t *chan)
int channel_get_addr_if_possible(const channel_t *chan, tor_addr_t *addr_out)
const char * channel_state_to_string(channel_state_t state)
void channel_mark_for_close(channel_t *chan)
void channel_clear_identity_digest(channel_t *chan)
void channel_clear_remote_end(channel_t *chan)
void channel_listener_change_state(channel_listener_t *chan_l, channel_listener_state_t to_state)
void channel_mark_outgoing(channel_t *chan)
const char * channel_describe_peer(channel_t *chan)
static void channel_listener_force_xfree(channel_listener_t *chan_l)
void channel_dump_statistics(channel_t *chan, int severity)
void channel_free_all(void)
channel_t * channel_get_for_extend(const char *rsa_id_digest, const ed25519_public_key_t *ed_id, const tor_addr_t *target_ipv4_addr, const tor_addr_t *target_ipv6_addr, bool for_origin_circ, const char **msg_out, int *launch_out)
int channel_more_to_flush(channel_t *chan)
void channel_dump_transport_statistics(channel_t *chan, int severity)
unsigned int channel_num_circuits(channel_t *chan)
void channel_clear_client(channel_t *chan)
int channel_write_packed_cell(channel_t *chan, packed_cell_t *cell)
const char * channel_listener_state_to_string(channel_listener_state_t state)
time_t channel_when_created(channel_t *chan)
void channel_init(channel_t *chan)
void channel_free_(channel_t *chan)
void channel_change_state(channel_t *chan, channel_state_t to_state)
Header file for channel.c.
void channel_mark_as_used_for_origin_circuit(channel_t *chan)
@ CHANNEL_LISTENER_STATE_ERROR
@ CHANNEL_LISTENER_STATE_LAST
@ CHANNEL_LISTENER_STATE_LISTENING
@ CHANNEL_LISTENER_STATE_CLOSING
@ CHANNEL_LISTENER_STATE_CLOSED
void channelpadding_disable_padding_on_channel(channel_t *chan)
void channelpadding_reduce_padding_on_channel(channel_t *chan)
channel_t * channel_tls_connect(const tor_addr_t *addr, uint16_t port, const char *id_digest, const ed25519_public_key_t *ed_id)
Header file for channeltls.c.
void circuit_n_chan_done(channel_t *chan, int status, int close_origin_circuits)
Header file for circuitbuild.c.
void channel_note_destroy_pending(channel_t *chan, circid_t id)
void channel_note_destroy_not_pending(channel_t *chan, circid_t id)
void circuit_unlink_all_from_channel(channel_t *chan, int reason)
Header file for circuitlist.c.
void circuitmux_mark_destroyed_circids_usable(circuitmux_t *cmux, channel_t *chan)
void circuitmux_detach_all_circuits(circuitmux_t *cmux, smartlist_t *detached_out)
void circuitmux_set_policy(circuitmux_t *cmux, const circuitmux_policy_t *pol)
unsigned int circuitmux_num_active_circuits(circuitmux_t *cmux)
unsigned int circuitmux_num_circuits(circuitmux_t *cmux)
unsigned int circuitmux_num_cells(circuitmux_t *cmux)
Header file for circuitmux.c.
void circuit_build_times_network_is_live(circuit_build_times_t *cbt)
circuit_build_times_t * get_circuit_build_times_mutable(void)
Header file for circuitstats.c.
Functions and types for monotonic times.
const or_options_t * get_options(void)
tor_cmdline_mode_t command
Header file for config.c.
int connection_or_single_set_badness_(time_t now, or_connection_t *or_conn, int force)
int connection_or_digest_is_known_relay(const char *id_digest)
void connection_or_group_set_badness_(smartlist_t *group, int force)
Header file for connection_or.c.
int ed25519_public_key_is_zero(const ed25519_public_key_t *pubkey)
int ed25519_pubkey_eq(const ed25519_public_key_t *key1, const ed25519_public_key_t *key2)
int crypto_pk_cmp_keys(const crypto_pk_t *a, const crypto_pk_t *b)
int tor_memeq(const void *a, const void *b, size_t sz)
#define fast_memcmp(a, b, c)
#define tor_memneq(a, b, sz)
Header file for dirlist.c.
Header file for circuitbuild.c.
Header file for geoip_stats.c.
@ DIRREQ_CHANNEL_BUFFER_FLUSHED
void geoip_change_dirreq_state(uint64_t dirreq_id, dirreq_type_t type, dirreq_state_t new_state)
void geoip_note_client_seen(geoip_client_action_t action, const tor_addr_t *addr, const char *transport_name, time_t now)
HT_PROTOTYPE(hs_circuitmap_ht, circuit_t, hs_circuitmap_node, hs_circuit_hash_token, hs_circuits_have_same_token)
Header file containing service data for the HS subsystem.
void tor_log(int severity, log_domain_mask_t domain, const char *format,...)
void mainloop_schedule_postloop_cleanup(void)
Header file for mainloop.c.
void tor_free_(void *mem)
void * tor_reallocarray_(void *ptr, size_t sz1, size_t sz2)
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)
Header file for networkstatus.c.
void router_set_status(const char *digest, int up)
Header file for nodelist.c.
Master header file for Tor-specific functionality.
int channel_flush_from_first_active_circuit(channel_t *chan, int max)
uint8_t packed_cell_get_command(const packed_cell_t *cell, int wide_circ_ids)
void rep_hist_padding_count_write(padding_type_t type)
Header file for rephist.c.
@ PADDING_TYPE_ENABLED_CELL
@ PADDING_TYPE_ENABLED_TOTAL
crypto_pk_t * get_tlsclient_identity_key(void)
Header file for router.c.
Header file for routerlist.c.
void scheduler_channel_doesnt_want_writes(channel_t *chan)
Header file for scheduler*.c.
void smartlist_sort(smartlist_t *sl, int(*compare)(const void **a, const void **b))
smartlist_t * smartlist_new(void)
void smartlist_add(smartlist_t *sl, void *element)
void smartlist_clear(smartlist_t *sl)
void smartlist_remove(smartlist_t *sl, const void *element)
#define SMARTLIST_FOREACH_BEGIN(sl, type, var)
#define SMARTLIST_FOREACH(sl, type, var, cmd)
#define SMARTLIST_DEL_CURRENT(sl, var)
channel_listener_state_t state
enum channel_listener_t::@10 reason_for_closing
void(* dumpstats)(channel_listener_t *, int)
uint64_t global_identifier
void(* free_fn)(channel_listener_t *)
smartlist_t * incoming_list
const char *(* describe_transport)(channel_listener_t *)
channel_listener_fn_ptr listener
time_t timestamp_accepted
void(* close)(channel_listener_t *)
void(* free_fn)(channel_t *)
int(* is_canonical)(channel_t *)
void(* close)(channel_t *)
monotime_coarse_t next_padding_time
void(* dumpstats)(channel_t *, int)
time_t timestamp_last_had_circuits
unsigned int num_n_circuits
int(* matches_extend_info)(channel_t *, extend_info_t *)
enum channel_t::@9 scheduler_state
circ_id_type_bitfield_t circ_id_type
unsigned int padding_enabled
char identity_digest[DIGEST_LEN]
uint64_t global_identifier
int(* write_packed_cell)(channel_t *, packed_cell_t *)
struct channel_handle_t * timer_handle
const char *(* describe_peer)(const channel_t *)
tor_addr_t addr_according_to_peer
channel_cell_handler_fn_ptr cell_handler
int(* matches_target)(channel_t *, const tor_addr_t *)
struct ed25519_public_key_t ed25519_identity
unsigned int has_been_open
monotime_coarse_t timestamp_xfer
unsigned int is_bad_for_new_circs
unsigned int is_canonical_to_peer
const char *(* describe_transport)(channel_t *)
struct tor_timer_t * padding_timer
ratelim_t last_warned_circ_ids_exhausted
int(* has_queued_writes)(channel_t *)
enum channel_t::@8 reason_for_closing
char body[CELL_MAX_NETWORK_SIZE]
#define MOCK_IMPL(rv, funcname, arglist)
#define IF_BUG_ONCE(cond)
int tor_digest_is_zero(const char *digest)
#define ED25519_PUBKEY_LEN