55#include "feature/client/circpathbias.h"
97#include "core/or/or_circuit_st.h"
145uint64_t stats_n_circ_max_cell_outq_reached = 0;
207 if (BUG(!or_circ->
p_chan))
212 if (cell->
command == CELL_RELAY_EARLY) {
216 }
else if (cell->
command == CELL_RELAY) {
257 "relay crypt failed. Dropping connection.");
258 reason = -END_CIRC_REASON_INTERNAL;
271 "Received undecodable relay cell");
272 return -END_CIRC_REASON_TORPROTOCOL;
289 log_debug(
LD_OR,
"Sending away from origin.");
293 "connection_edge_process_relay_cell (away from origin) "
299 log_debug(
LD_OR,
"Sending to origin.");
308 "connection_edge_process_relay_cell (at origin) failed.");
327 "Dropping unrecognized inbound cell on origin circuit.");
333 reason = -END_CIRC_REASON_TORPROTOCOL;
352 log_warn(
LD_REND,
"Error relaying cell across rendezvous; closing "
360 reason = -END_CIRC_REASON_TORPROTOCOL;
367 "Didn't recognize a cell, but circ stops here! Closing circuit. "
368 "It was created %ld seconds ago.", (
long)seconds_open);
370 reason = -END_CIRC_REASON_TORPROTOCOL;
374 log_debug(
LD_OR,
"Passing on unrecognized cell.");
381 reason = -END_CIRC_REASON_RESOURCELIMIT;
387 circuit_mark_for_close(circ, -reason);
402 const char *filename,
int lineno))
414 log_warn(
LD_BUG,
"outgoing relay cell sent from %s:%d has n_chan==NULL."
415 " Dropping. Circuit is in state %s (%d), and is "
416 "%smarked for close. (%s:%d, %d)", filename, lineno,
428 log_warn(
LD_BUG,
"outgoing relay cell sent from %s:%d on non-origin "
429 "circ. Dropping.", filename, lineno);
445 log_warn(
LD_BUG,
"incoming relay cell at origin circuit. Dropping.");
456 cell_direction, on_stream);
477 if (msg->stream_id == tmpconn->
stream_id &&
480 log_debug(
LD_APP,
"found conn for stream %d.", msg->stream_id);
487 if (msg->stream_id == tmpconn->
stream_id &&
489 log_debug(LD_EXIT,
"found conn for stream %d.", msg->stream_id);
495 for (tmpconn =
TO_OR_CIRCUIT(circ)->resolving_streams; tmpconn;
497 if (msg->stream_id == tmpconn->
stream_id &&
499 log_debug(LD_EXIT,
"found conn for stream %d.", msg->stream_id);
513relay_header_pack(uint8_t *dest,
const relay_header_t *src)
518 memcpy(dest+5, src->integrity, 4);
526relay_header_unpack(relay_header_t *dest,
const uint8_t *src)
531 memcpy(dest->integrity, src+5, 4);
542 case RELAY_COMMAND_BEGIN:
return "BEGIN";
543 case RELAY_COMMAND_DATA:
return "DATA";
544 case RELAY_COMMAND_END:
return "END";
545 case RELAY_COMMAND_CONNECTED:
return "CONNECTED";
546 case RELAY_COMMAND_SENDME:
return "SENDME";
547 case RELAY_COMMAND_EXTEND:
return "EXTEND";
548 case RELAY_COMMAND_EXTENDED:
return "EXTENDED";
549 case RELAY_COMMAND_TRUNCATE:
return "TRUNCATE";
550 case RELAY_COMMAND_TRUNCATED:
return "TRUNCATED";
551 case RELAY_COMMAND_DROP:
return "DROP";
552 case RELAY_COMMAND_RESOLVE:
return "RESOLVE";
553 case RELAY_COMMAND_RESOLVED:
return "RESOLVED";
554 case RELAY_COMMAND_BEGIN_DIR:
return "BEGIN_DIR";
555 case RELAY_COMMAND_ESTABLISH_INTRO:
return "ESTABLISH_INTRO";
556 case RELAY_COMMAND_ESTABLISH_RENDEZVOUS:
return "ESTABLISH_RENDEZVOUS";
557 case RELAY_COMMAND_INTRODUCE1:
return "INTRODUCE1";
558 case RELAY_COMMAND_INTRODUCE2:
return "INTRODUCE2";
559 case RELAY_COMMAND_RENDEZVOUS1:
return "RENDEZVOUS1";
560 case RELAY_COMMAND_RENDEZVOUS2:
return "RENDEZVOUS2";
561 case RELAY_COMMAND_INTRO_ESTABLISHED:
return "INTRO_ESTABLISHED";
562 case RELAY_COMMAND_RENDEZVOUS_ESTABLISHED:
563 return "RENDEZVOUS_ESTABLISHED";
564 case RELAY_COMMAND_INTRODUCE_ACK:
return "INTRODUCE_ACK";
565 case RELAY_COMMAND_EXTEND2:
return "EXTEND2";
566 case RELAY_COMMAND_EXTENDED2:
return "EXTENDED2";
567 case RELAY_COMMAND_PADDING_NEGOTIATE:
return "PADDING_NEGOTIATE";
568 case RELAY_COMMAND_PADDING_NEGOTIATED:
return "PADDING_NEGOTIATED";
569 case RELAY_COMMAND_CONFLUX_LINK:
return "CONFLUX_LINK";
570 case RELAY_COMMAND_CONFLUX_LINKED:
return "CONFLUX_LINKED";
571 case RELAY_COMMAND_CONFLUX_LINKED_ACK:
return "CONFLUX_LINKED_ACK";
572 case RELAY_COMMAND_CONFLUX_SWITCH:
return "CONFLUX_SWITCH";
574 tor_snprintf(buf,
sizeof(buf),
"Unrecognized relay command %u",
591 uint8_t relay_command,
const char *payload,
593 const char *filename,
int lineno))
604 log_warn(
LD_BUG,
"No circuit to send for conflux for relay command %d, "
605 "called from %s:%d", relay_command, filename, lineno);
628 log_warn(
LD_BUG,
"Tried to send a command %d of length %d in "
629 "a v%d cell, from %s:%d",
630 (
int)relay_command, (
int)payload_len, (
int)cell_format,
632 circuit_mark_for_close(circ, END_CIRC_REASON_INTERNAL);
636 msg.command = relay_command;
637 msg.stream_id = stream_id;
638 msg.length = payload_len;
639 msg.body = (
const uint8_t *) payload;
640 msg_body_len = msg.length;
644 circuit_mark_for_close(circ, END_CIRC_REASON_INTERNAL);
660 log_debug(
LD_OR,
"delivering %d cell %s.", relay_command,
668 if (relay_command == RELAY_COMMAND_END && circ->
dirreq_id)
680 (relay_command == RELAY_COMMAND_EXTEND ||
681 relay_command == RELAY_COMMAND_EXTEND2 ||
682 cpath_layer != origin_circ->
cpath)) {
687 cell.
command = CELL_RELAY_EARLY;
691 log_debug(
LD_OR,
"Sending a RELAY_EARLY cell; %d remaining.",
697 }
else if (relay_command == RELAY_COMMAND_EXTEND ||
698 relay_command == RELAY_COMMAND_EXTEND2) {
704 char *commands = NULL;
709 log_warn(
LD_BUG,
"Uh-oh. We're sending a RELAY_COMMAND_EXTEND cell, "
710 "but we have run out of RELAY_EARLY cells on that circuit. "
711 "Commands sent before: %s", commands);
713 smartlist_free(commands_list);
722 cpath_layer, stream_id, filename,
725 circuit_mark_for_close(circ, END_CIRC_REASON_INTERNAL);
727 }
else if (ret == 0) {
745 if (relay_command == RELAY_COMMAND_DATA) {
746 sendme_record_cell_digest_on_circ(circ, cpath_layer);
749 if (sendme_note_circuit_data_packaged(circ, cpath_layer) < 0) {
752 "Circuit package window is below 0. Closing circuit.");
753 circuit_mark_for_close(circ, END_CIRC_REASON_TORPROTOCOL);
772 uint8_t relay_command,
const char *payload,
784 "called on conn that's already marked for close at %s:%d.",
792 log_info(
LD_APP,
"no circ. Closing conn.");
794 END_STREAM_REASON_INTERNAL);
796 log_info(LD_EXIT,
"no circ. Closing conn.");
798 fromconn->
end_reason = END_STREAM_REASON_INTERNAL;
799 connection_mark_for_close(
TO_CONN(fromconn));
810#ifdef MEASUREMENTS_21206
820 return relay_send_command_from_edge(fromconn->
stream_id, circ,
821 relay_command, payload,
822 payload_len, cpath_layer);
828#define MAX_RESOLVE_FAILURES 3
835 return reason == END_STREAM_REASON_HIBERNATING ||
836 reason == END_STREAM_REASON_RESOURCELIMIT ||
837 reason == END_STREAM_REASON_EXITPOLICY ||
838 reason == END_STREAM_REASON_RESOLVEFAILED ||
839 reason == END_STREAM_REASON_MISC ||
840 reason == END_STREAM_REASON_NOROUTE;
858 if (msg->length > 0) {
859 if (reason == END_STREAM_REASON_TORPROTOCOL ||
860 reason == END_STREAM_REASON_DESTROY) {
865 return -END_CIRC_REASON_TORPROTOCOL;
866 }
else if (reason == END_STREAM_REASON_INTERNAL) {
883 if (msg->length == 0) {
884 reason = END_STREAM_REASON_MISC;
892 const char *chosen_exit_digest =
894 log_info(
LD_APP,
"Address '%s' refused due to '%s'. Considering retrying.",
899 case END_STREAM_REASON_EXITPOLICY: {
902 if (msg->length >= 5) {
905 if (msg->length == 5 || msg->length == 9) {
907 if (msg->length == 9)
909 }
else if (msg->length == 17 || msg->length == 21) {
911 if (msg->length == 21)
915 log_info(
LD_APP,
"Address '%s' resolved to 0.0.0.0. Closing,",
917 connection_mark_unattached_ap(conn, END_STREAM_REASON_TORPROTOCOL);
922 !conn->entry_cfg.ipv4_traffic) ||
924 !conn->entry_cfg.ipv6_traffic)) {
926 "Got an EXITPOLICY failure on a connection with a "
927 "mismatched family. Closing.");
928 connection_mark_unattached_ap(conn, END_STREAM_REASON_TORPROTOCOL);
931 if (
get_options()->ClientDNSRejectInternalAddresses &&
932 tor_addr_is_internal(&addr, 0)) {
933 log_info(
LD_APP,
"Address '%s' resolved to internal. Closing,",
935 connection_mark_unattached_ap(conn, END_STREAM_REASON_TORPROTOCOL);
979 case END_STREAM_REASON_CONNECTREFUSED:
985 case END_STREAM_REASON_RESOLVEFAILED:
986 case END_STREAM_REASON_TIMEOUT:
987 case END_STREAM_REASON_MISC:
988 case END_STREAM_REASON_NOROUTE:
1006 "Have tried resolving or connecting to address '%s' "
1007 "at %d different places. Giving up.",
1014 case END_STREAM_REASON_HIBERNATING:
1015 case END_STREAM_REASON_RESOURCELIMIT:
1029 log_info(
LD_APP,
"Giving up on retrying; conn can't be handled.");
1033 "Edge got end (%s) before we're connected. Marking for close.",
1038 connection_mark_unattached_ap(conn, control_reason);
1057 int make_reject_all = 0;
1063 if (family == AF_UNSPEC) {
1064 make_reject_all = 1;
1067 make_reject_all = 1;
1070 if (make_reject_all) {
1072 "Exitrouter %s seems to be more restrictive than its exit "
1073 "policy. Not using this router as exit for now.",
1079 if (family != AF_UNSPEC)
1111 const uint8_t *payload = msg->body;
1115 if (msg->length == 0)
1117 if (msg->length < 4)
1125 if (msg->length >= 8) {
1127 if (bytes <= INT32_MAX)
1131 if (msg->length < 25)
1137 if (bytes <= INT32_MAX)
1138 *ttl_out = (int) bytes;
1163 uint8_t answer_type;
1165 address_ttl_t *addr;
1183 remaining = msg->length;
1185 const uint8_t *cp_orig = cp;
1188 answer_type = *cp++;
1190 if (remaining < 2 + answer_len + 4) {
1193 if (answer_type == RESOLVED_TYPE_IPV4) {
1194 if (answer_len != 4) {
1197 addr = tor_malloc_zero(
sizeof(*addr));
1203 }
else if (answer_type == RESOLVED_TYPE_IPV6) {
1204 if (answer_len != 16)
1206 addr = tor_malloc_zero(
sizeof(*addr));
1212 }
else if (answer_type == RESOLVED_TYPE_HOSTNAME) {
1213 if (answer_len == 0) {
1216 addr = tor_malloc_zero(
sizeof(*addr));
1217 addr->hostname = tor_memdup_nulterm(cp, answer_len);
1222 }
else if (answer_type == RESOLVED_TYPE_ERROR_TRANSIENT ||
1223 answer_type == RESOLVED_TYPE_ERROR) {
1224 errcode = answer_type;
1226 cp += answer_len + 4;
1228 cp += answer_len + 4;
1230 tor_assert(((ssize_t)remaining) >= (cp - cp_orig));
1231 remaining -= (cp - cp_orig);
1234 if (errcode && smartlist_len(addrs) == 0) {
1236 *errcode_out = errcode;
1240 smartlist_free(addrs);
1247 smartlist_free(addrs);
1259 address_ttl_t *addr_ipv4 = NULL;
1260 address_ttl_t *addr_ipv6 = NULL;
1261 address_ttl_t *addr_hostname = NULL;
1262 address_ttl_t *addr_best = NULL;
1266 tor_assert(error_code == RESOLVED_TYPE_ERROR ||
1267 error_code == RESOLVED_TYPE_ERROR_TRANSIENT);
1269 error_code,0,NULL,-1,-1);
1275 if (addr->hostname) {
1276 if (!addr_hostname) {
1277 addr_hostname = addr;
1280 if (!addr_ipv4 && conn->entry_cfg.ipv4_traffic) {
1284 if (!addr_ipv6 && conn->entry_cfg.ipv6_traffic) {
1288 } SMARTLIST_FOREACH_END(addr);
1292 if (addr_hostname) {
1294 RESOLVED_TYPE_HOSTNAME,
1295 strlen(addr_hostname->hostname),
1296 (uint8_t*)addr_hostname->hostname,
1297 addr_hostname->ttl,-1);
1300 RESOLVED_TYPE_ERROR,0,NULL,-1,-1);
1305 if (conn->entry_cfg.prefer_ipv6) {
1306 addr_best = addr_ipv6 ? addr_ipv6 : addr_ipv4;
1308 addr_best = addr_ipv4 ? addr_ipv4 : addr_ipv6;
1314 RESOLVED_TYPE_NOERROR,0,NULL,-1,-1);
1337 log_fn(LOG_PROTOCOL_WARN,
LD_APP,
"Got a 'resolved' cell while "
1338 "not in state resolve_wait. Dropping.");
1346 "Dropping malformed 'resolved' cell");
1347 connection_mark_unattached_ap(entry_conn, END_STREAM_REASON_TORPROTOCOL);
1351 if (
get_options()->ClientDNSRejectInternalAddresses) {
1352 int orig_len = smartlist_len(resolved_addresses);
1354 if (addr->hostname == NULL && tor_addr_is_internal(&addr->addr, 0)) {
1355 log_info(
LD_APP,
"Got a resolved cell with answer %s; dropping that "
1357 safe_str_client(
fmt_addr(&addr->addr)));
1358 address_ttl_free(addr);
1361 } SMARTLIST_FOREACH_END(addr);
1362 if (orig_len && smartlist_len(resolved_addresses) == 0) {
1363 log_info(
LD_APP,
"Got a resolved cell with only private addresses; "
1366 RESOLVED_TYPE_ERROR_TRANSIENT,
1367 0, NULL, 0, TIME_MAX);
1368 connection_mark_unattached_ap(entry_conn,
1369 END_STREAM_REASON_TORPROTOCOL);
1382 resolved_addresses);
1384 connection_mark_unattached_ap(entry_conn,
1385 END_STREAM_REASON_DONE |
1390 address_ttl_free(addr));
1391 smartlist_free(resolved_addresses);
1407 if (msg->command == RELAY_COMMAND_END) {
1417 connection_mark_for_close(
TO_CONN(conn));
1423 msg->command == RELAY_COMMAND_CONNECTED) {
1430 "Got 'connected' while not in state connect_wait. Dropping.");
1433 CONNECTION_AP_EXPECT_NONPENDING(entry_conn);
1435 log_info(
LD_APP,
"'connected' received for circid %u streamid %d "
1436 "after %d seconds.",
1442 "Got a badly formatted connected cell. Closing.");
1444 connection_mark_unattached_ap(entry_conn, END_STREAM_REASON_TORPROTOCOL);
1453 (
get_options()->ClientDNSRejectInternalAddresses &&
1454 tor_addr_is_internal(&addr, 0))) {
1455 log_info(
LD_APP,
"...but it claims the IP address was %s. Closing.",
1458 connection_mark_unattached_ap(entry_conn,
1459 END_STREAM_REASON_TORPROTOCOL);
1463 if ((family == AF_INET && ! entry_conn->entry_cfg.ipv4_traffic) ||
1464 (family == AF_INET6 && ! entry_conn->entry_cfg.ipv6_traffic)) {
1466 "Got a connected cell to %s with unsupported address family."
1467 " Closing.", safe_str(
fmt_addr(&addr)));
1469 connection_mark_unattached_ap(entry_conn,
1470 END_STREAM_REASON_TORPROTOCOL);
1489 log_debug(
LD_APP,
"considering");
1490 if (
TO_CONN(conn)->linked_conn &&
1523 connection_mark_for_close(
TO_CONN(conn));
1529 msg->command == RELAY_COMMAND_RESOLVED) {
1534 "Got an unexpected relay command %d, in state %d (%s). Dropping.",
1535 msg->command, conn->base_.
state,
1559 if (!msg->stream_id) {
1561 ret = sendme_process_circuit_level(layer_hint, circ, msg->body,
1580 log_info(domain,
"Sendme cell on circ %u valid on half-closed "
1586 log_info(domain,
"SENDME cell dropped, unknown stream (streamid %d).",
1593 ret = sendme_process_stream_level(conn, circ, msg->length);
1612 connection_mark_for_close(
TO_CONN(conn));
1629 int optimistic_data)
1631 unsigned domain = layer_hint?
LD_APP:LD_EXIT;
1639 log_debug(domain,
"Cell handled as circuit padding");
1644 switch (msg->command) {
1645 case RELAY_COMMAND_CONFLUX_LINK:
1648 case RELAY_COMMAND_CONFLUX_LINKED:
1651 case RELAY_COMMAND_CONFLUX_LINKED_ACK:
1654 case RELAY_COMMAND_CONFLUX_SWITCH:
1656 case RELAY_COMMAND_BEGIN:
1657 case RELAY_COMMAND_BEGIN_DIR:
1661 "Relay begin request unsupported at AP. Dropping.");
1667 "Relay begin request to Hidden Service "
1668 "from intermediary node. Dropping.");
1672 log_fn(LOG_PROTOCOL_WARN, domain,
1673 "Begin cell for known stream. Dropping.");
1676 if (msg->command == RELAY_COMMAND_BEGIN_DIR &&
1682 static uint64_t next_id = 0;
1687 case RELAY_COMMAND_DATA:
1690 if (msg->stream_id == 0) {
1692 "stream_id. Dropping.");
1701 "data cell on circ %u valid on half-closed "
1706 log_info(domain,
"data cell dropped, unknown stream (streamid %d).",
1714 if (sendme_stream_data_received(conn) < 0) {
1716 "(relay data) conn deliver_window below 0. Killing.");
1718 return -END_CIRC_REASON_TORPROTOCOL;
1726 if (conn->hs_ident) {
1733 connection_buf_add((
char*) msg->body, msg->length,
TO_CONN(conn));
1735#ifdef MEASUREMENTS_21206
1741 ++(
TO_DIR_CONN(linked_conn)->data_cells_received);
1745 if (!optimistic_data) {
1753 case RELAY_COMMAND_XOFF:
1772 case RELAY_COMMAND_XON:
1791 case RELAY_COMMAND_END:
1792 reason = msg->length > 0 ?
get_uint8(msg->body) : END_STREAM_REASON_MISC;
1802 "end cell (%s) on circ %u valid on half-closed "
1809 log_info(domain,
"end cell (%s) dropped, unknown stream.",
1814 log_info(domain,TOR_SOCKET_T_FORMAT
": end cell (%s) for stream %d. "
1824 "open stream hasn't sent socks answer yet? Closing.");
1833 connection_mark_and_flush(
TO_CONN(conn));
1841 case RELAY_COMMAND_EXTEND:
1842 case RELAY_COMMAND_EXTEND2: {
1843 static uint64_t total_n_extend=0, total_nonearly=0;
1845 if (msg->stream_id) {
1846 log_fn(LOG_PROTOCOL_WARN, domain,
1847 "'extend' cell received for non-zero stream. Dropping.");
1850 if (!msg->is_relay_early &&
1852#define EARLY_WARNING_INTERVAL 3600
1854 RATELIM_INIT(EARLY_WARNING_INTERVAL);
1856 if (!msg->is_relay_early) {
1859 double percentage = ((double)total_nonearly)/total_n_extend;
1861 log_fn(LOG_PROTOCOL_WARN, domain,
"EXTEND cell received, "
1862 "but not via RELAY_EARLY. Dropping.%s", m);
1863 log_fn(LOG_PROTOCOL_WARN, domain,
" (We have dropped %.02f%% of "
1864 "all EXTEND cells for this reason)", percentage);
1869 "EXTEND cell received, in a cell with type %d! Dropping.",
1876 case RELAY_COMMAND_EXTENDED:
1877 case RELAY_COMMAND_EXTENDED2:
1880 "'extended' unsupported at non-origin. Dropping.");
1883 log_debug(domain,
"Got an extended cell! Yay.");
1887 msg->body, msg->length) < 0) {
1889 "Can't parse EXTENDED cell; killing circuit.");
1890 return -END_CIRC_REASON_TORPROTOCOL;
1894 circuit_mark_for_close(circ, -reason);
1900 log_info(domain,
"circuit_send_next_onion_skin() failed.");
1908 case RELAY_COMMAND_TRUNCATE:
1911 "'truncate' unsupported at origin. Dropping.");
1916 log_warn(
LD_BUG,
"n_chan and n_hop set on the same circuit!");
1917 extend_info_free(circ->
n_hop);
1923 uint8_t trunc_reason =
get_uint8(msg->body);
1930 log_debug(LD_EXIT,
"Processed 'truncate', replying.");
1933 payload[0] = (char)END_CIRC_REASON_REQUESTED;
1934 relay_send_command_from_edge(0, circ, RELAY_COMMAND_TRUNCATED,
1935 payload,
sizeof(payload), NULL);
1938 case RELAY_COMMAND_TRUNCATED:
1940 log_fn(LOG_PROTOCOL_WARN, LD_EXIT,
1941 "'truncated' unsupported at non-origin. Dropping.");
1952 case RELAY_COMMAND_CONNECTED:
1955 "'connected' unsupported while open. Closing circ.");
1956 return -END_CIRC_REASON_TORPROTOCOL;
1965 "connected cell on circ %u valid on half-closed "
1972 "'connected' received on circid %u for streamid %d, "
1973 "no conn attached anymore. Ignoring.",
1974 (
unsigned)circ->
n_circ_id, msg->stream_id);
1976 case RELAY_COMMAND_SENDME:
1978 case RELAY_COMMAND_RESOLVE:
1981 "resolve request unsupported at AP; dropping.");
1984 log_fn(LOG_PROTOCOL_WARN, domain,
1985 "resolve request for known stream; dropping.");
1988 log_fn(LOG_PROTOCOL_WARN, domain,
1989 "resolve request on circ with purpose %d; dropping",
1994 case RELAY_COMMAND_RESOLVED:
1996 log_fn(LOG_PROTOCOL_WARN, domain,
1997 "'resolved' unsupported while open. Closing circ.");
1998 return -END_CIRC_REASON_TORPROTOCOL;
2008 "resolved cell on circ %u valid on half-closed "
2015 "'resolved' received, no conn attached anymore. Ignoring.");
2017 case RELAY_COMMAND_ESTABLISH_INTRO:
2018 case RELAY_COMMAND_ESTABLISH_RENDEZVOUS:
2019 case RELAY_COMMAND_INTRODUCE1:
2020 case RELAY_COMMAND_INTRODUCE2:
2021 case RELAY_COMMAND_INTRODUCE_ACK:
2022 case RELAY_COMMAND_RENDEZVOUS1:
2023 case RELAY_COMMAND_RENDEZVOUS2:
2024 case RELAY_COMMAND_INTRO_ESTABLISHED:
2025 case RELAY_COMMAND_RENDEZVOUS_ESTABLISHED:
2027 msg->command, msg->length, msg->body);
2031 "Received unknown relay command %d. Perhaps the other side is using "
2032 "a newer version of Tor? Dropping.",
2051 static int num_seen=0;
2052 unsigned domain = layer_hint?
LD_APP:LD_EXIT;
2059 log_debug(domain,
"Now seen %d relay cells here (command %d, stream %d).",
2060 num_seen, msg->command, msg->stream_id);
2062 if (msg->stream_id == 0) {
2063 switch (msg->command) {
2064 case RELAY_COMMAND_BEGIN:
2065 case RELAY_COMMAND_CONNECTED:
2066 case RELAY_COMMAND_END:
2067 case RELAY_COMMAND_RESOLVE:
2068 case RELAY_COMMAND_RESOLVED:
2069 case RELAY_COMMAND_BEGIN_DIR:
2071 "stream_id. Dropping.", msg->command);
2081 if (msg->command == RELAY_COMMAND_DATA) {
2085 if (sendme_circuit_data_received(circ, layer_hint) < 0) {
2087 "(relay data) circ deliver_window below 0. Killing.");
2089 return -END_CIRC_REASON_TORPROTOCOL;
2118 msg, circ, conn, layer_hint);
2133 conflux_relay_msg_free(c_msg);
2136 conflux_relay_msg_free(c_msg);
2153 int optimistic_data = 0;
2166 msg->command == RELAY_COMMAND_DATA) {
2170 optimistic_data = 1;
2171 }
else if (msg->stream_id == 0 && msg->command == RELAY_COMMAND_DATA) {
2172 log_warn(
LD_BUG,
"Somehow I had a connection that matched a "
2173 "data cell with stream ID 0.");
2176 msg, circ, conn, layer_hint);
2216 int package_partial,
2224 const bool force_random_bytes =
2229 size_t target_length =
2232#define RELAY_CELL_PADDING_GAP 4
2236 size_t target_length_with_random = target_length -
2237 RELAY_CELL_PADDING_GAP - 16;
2238 if (force_random_bytes) {
2239 target_length = target_length_with_random;
2243 size_t package_length;
2244 if (n_available >= target_length) {
2245 package_length = target_length;
2247 if (package_partial)
2248 package_length = n_available;
2254 tor_assert_nonfatal(package_length > 0);
2256 if (package_length <= target_length_with_random) {
2272 return package_length;
2289 size_t bytes_to_process, length;
2293 int sending_from_optimistic = 0;
2296 const int sending_optimistically =
2306 "called on conn that's already marked for close at %s:%d.",
2311 if (max_cells && *max_cells <= 0)
2314 repeat_connection_edge_package_raw_inbuf:
2318 log_info(domain,
"conn has no circuit! Closing.");
2327 log_info(domain,
"called with package_window %d. Skipping.",
2333 sending_from_optimistic = entry_conn &&
2334 entry_conn->sending_optimistic_data != NULL;
2336 if (PREDICT_UNLIKELY(sending_from_optimistic)) {
2337 bytes_to_process =
buf_datalen(entry_conn->sending_optimistic_data);
2338 if (PREDICT_UNLIKELY(!bytes_to_process)) {
2339 log_warn(
LD_BUG,
"sending_optimistic_data was non-NULL but empty");
2340 bytes_to_process = connection_get_inbuf_len(
TO_CONN(conn));
2341 sending_from_optimistic = 0;
2344 bytes_to_process = connection_get_inbuf_len(
TO_CONN(conn));
2348 package_partial, circ,
2359 if (PREDICT_UNLIKELY(sending_from_optimistic)) {
2363 buf_get_bytes(entry_conn->sending_optimistic_data, payload, length);
2364 if (!
buf_datalen(entry_conn->sending_optimistic_data)) {
2365 buf_free(entry_conn->sending_optimistic_data);
2366 entry_conn->sending_optimistic_data = NULL;
2372 log_debug(domain,TOR_SOCKET_T_FORMAT
": Packaging %d bytes (%d waiting).",
2374 (
int)length, (
int)connection_get_inbuf_len(
TO_CONN(conn)));
2376 if (sending_optimistically && !sending_from_optimistic) {
2386 payload, length) < 0 ) {
2392 if (sendme_note_stream_data_packaged(conn, length) < 0) {
2394 log_debug(domain,
"conn->package_window reached 0.");
2398 log_debug(domain,
"conn->package_window is now %d",conn->
package_window);
2402 if (*max_cells <= 0)
2407 goto repeat_connection_edge_package_raw_inbuf;
2419 log_debug(layer_hint?
LD_APP:LD_EXIT,
"Too big queue, no resuming");
2426 log_debug(layer_hint?
LD_APP:LD_EXIT,
2427 "Conflux can't send, not resuming edges");
2431 log_debug(layer_hint?
LD_APP:LD_EXIT,
"resuming");
2451 int n_packaging_streams, n_streams_left;
2452 int packaged_this_round;
2458 if (first_conn == NULL) {
2476 int num_streams = 0;
2477 for (conn = first_conn; conn; conn = conn->
next_stream) {
2481 chosen_stream = conn;
2498 n_packaging_streams = 0;
2500 for (conn=chosen_stream; conn; conn = conn->
next_stream) {
2510 if (connection_get_inbuf_len(
TO_CONN(conn)) > 0)
2511 ++n_packaging_streams;
2515 for (conn = first_conn; conn != chosen_stream; conn = conn->
next_stream) {
2524 if (connection_get_inbuf_len(
TO_CONN(conn)) > 0)
2525 ++n_packaging_streams;
2529 if (n_packaging_streams == 0)
2560 cells_per_conn = CEIL_DIV(max_to_package, n_packaging_streams);
2562 packaged_this_round = 0;
2570 for (conn=first_conn; conn; conn=conn->
next_stream) {
2574 int n = cells_per_conn, r;
2579 packaged_this_round += (cells_per_conn-n);
2584 connection_mark_for_close(
TO_CONN(conn));
2589 if (connection_get_inbuf_len(
TO_CONN(conn)))
2605 if (packaged_this_round && packaged_this_round < max_to_package &&
2607 n_packaging_streams = n_streams_left;
2624 unsigned domain = layer_hint ?
LD_APP : LD_EXIT;
2628 log_debug(domain,
"considering circ->package_window %d",
2631 log_debug(domain,
"yes, not-at-origin. stopped.");
2639 log_debug(domain,
"considering layer_hint->package_window %d",
2642 log_debug(domain,
"yes, at-origin. stopped.");
2689 n_cells += c->n_chan_cells.n;
2694 SMARTLIST_FOREACH_END(c);
2696 "%d cells allocated on %d circuits. %d cells leaked.",
2713 TOR_SIMPLEQ_INSERT_TAIL(&queue->head, cell, next);
2723 int exitward,
const cell_t *cell,
2724 int wide_circ_ids,
int use_stats)
2741 TOR_SIMPLEQ_INIT(&queue->head);
2749 while ((cell = TOR_SIMPLEQ_FIRST(&queue->head))) {
2750 TOR_SIMPLEQ_REMOVE_HEAD(&queue->head, next);
2753 TOR_SIMPLEQ_INIT(&queue->head);
2765 TOR_SIMPLEQ_REMOVE_HEAD(&queue->head, next);
2775 TOR_SIMPLEQ_INIT(&queue->head);
2783 while ((cell = TOR_SIMPLEQ_FIRST(&queue->head))) {
2784 TOR_SIMPLEQ_REMOVE_HEAD(&queue->head, next);
2787 TOR_SIMPLEQ_INIT(&queue->head);
2799 TOR_SIMPLEQ_REMOVE_HEAD(&queue->head, next);
2811 cell->circid = circid;
2812 cell->reason = reason;
2816 TOR_SIMPLEQ_INSERT_TAIL(&queue->head, cell, next);
2826 memset(&cell, 0,
sizeof(cell));
2829 cell.
payload[0] = inp->reason;
2830 cell_pack(packed, &cell, wide_circ_ids);
2846cell_queues_get_total_allocation(
void)
2852#define MEMORY_PRESSURE_INTERVAL (30*60)
2859uint64_t oom_stats_n_bytes_removed_cell = 0;
2860uint64_t oom_stats_n_bytes_removed_geoip = 0;
2861uint64_t oom_stats_n_bytes_removed_hsdir = 0;
2869 time_t now = time(NULL);
2870 size_t alloc = cell_queues_get_total_allocation();
2872 alloc += buf_get_total_allocation();
2874 const size_t hs_cache_total = hs_cache_get_total_allocation();
2875 alloc += hs_cache_total;
2876 const size_t geoip_client_cache_total =
2877 geoip_client_cache_total_allocation();
2878 alloc += geoip_client_cache_total;
2879 const size_t dns_cache_total = dns_cache_total_allocation();
2880 alloc += dns_cache_total;
2882 alloc += conflux_total;
2883 if (alloc >=
get_options()->MaxMemInQueues_low_threshold) {
2892 if (hs_cache_total >
get_options()->MaxMemInQueues / 5) {
2893 const size_t bytes_to_remove =
2896 oom_stats_n_bytes_removed_hsdir += removed;
2899 if (geoip_client_cache_total >
get_options()->MaxMemInQueues / 5) {
2900 const size_t bytes_to_remove =
2901 geoip_client_cache_total -
2903 removed = geoip_client_cache_handle_oom(now, bytes_to_remove);
2904 oom_stats_n_bytes_removed_geoip += removed;
2907 if (dns_cache_total >
get_options()->MaxMemInQueues / 5) {
2908 const size_t bytes_to_remove =
2910 removed = dns_cache_handle_oom(now, bytes_to_remove);
2915 if (conflux_total >
get_options()->MaxMemInQueues / 5) {
2916 const size_t bytes_to_remove =
2919 oom_stats_n_bytes_removed_cell += removed;
2923 oom_stats_n_bytes_removed_cell += removed;
2945 const char *file,
int lineno)
2949 circuitmux_t *cmux = NULL;
2969 log_warn(
LD_BUG,
"called on non-attached circuit from %s:%d",
2996 chan->num_p_circuits = 0;
3011 if (circ->
n_chan == chan) {
3039 if (block && can_send) {
3042 }
else if (!block && !can_send) {
3050 if (stream_id && edge->stream_id != stream_id)
3053 if (!conn->
read_event || edge->xoff_received ||
3074 if (wide_circ_ids) {
3085 if (wide_circ_ids) {
3099 circuitmux_t *cmux = NULL;
3114 while (n_flushed < max) {
3116 if (destroy_queue) {
3143 if (circ->
n_chan == chan) {
3169 if (queue->
n == 0) {
3172 circuit_mark_for_close(circ, END_CIRC_REASON_INTERNAL);
3189 uint32_t msec_waiting =
3207 if (circ->
n_chan == chan)
3247 log_debug(
LD_GENERAL,
"Made a circuit inactive.");
3288#define RELAY_CIRC_CELL_QUEUE_SIZE_MIN 50
3290#define RELAY_CIRC_CELL_QUEUE_SIZE_MAX INT32_MAX
3294#define RELAY_CIRC_CELL_QUEUE_SIZE_DEFAULT \
3295 (50 * RELAY_CIRC_CELL_QUEUE_SIZE_MIN)
3299static int32_t max_circuit_cell_queue_size =
3300 RELAY_CIRC_CELL_QUEUE_SIZE_DEFAULT;
3305 RELAY_CIRC_CELL_QUEUE_SIZE_DEFAULT;
3313 RELAY_CIRC_CELL_QUEUE_SIZE_DEFAULT,
3314 RELAY_CIRC_CELL_QUEUE_SIZE_MIN,
3315 RELAY_CIRC_CELL_QUEUE_SIZE_MAX);
3325 RELAY_CIRC_CELL_QUEUE_SIZE_MIN,
3326 RELAY_CIRC_CELL_QUEUE_SIZE_MAX);
3338 max_circuit_cell_queue_size =
3364 int32_t max_queue_size;
3382 max_queue_size = max_circuit_cell_queue_size;
3386 if (PREDICT_UNLIKELY(queue->
n >= max_queue_size)) {
3390 stats_n_circ_max_cell_outq_reached++;
3391 dos_note_circ_max_outq(CONST_TO_OR_CIRCUIT(circ)->p_chan);
3395 "%s circuit has %d cells in its queue, maximum allowed is %d. "
3396 "Closing circuit for safety reasons.",
3397 (exitward) ?
"Outbound" :
"Inbound", queue->
n,
3406 chan->wide_circ_ids, 1);
3421 if (circ_blocked && fromstream) {
3428 update_circuit_on_cmux(circ, direction);
3429 if (queue->
n == 1) {
3432 log_debug(
LD_GENERAL,
"Made a circuit active.");
3453 payload_out[0] = RESOLVED_TYPE_IPV4;
3456 memcpy(payload_out+2, &a, 4);
3459 payload_out[0] = RESOLVED_TYPE_IPV6;
3460 payload_out[1] = 16;
3477 if (payload_len < 2)
3479 if (payload_len < 2+payload[1])
3482 switch (payload[0]) {
3483 case RESOLVED_TYPE_IPV4:
3484 if (payload[1] != 4)
3488 case RESOLVED_TYPE_IPV6:
3489 if (payload[1] != 16)
3497 return payload + 2 + payload[1];
3507 if (circ->
n_chan == chan) {
3522 update_circuit_on_cmux(circ, direction);
3551 tor_assert_unreached();
3561 uint8_t relay_command)
void tor_addr_from_ipv4n(tor_addr_t *dest, uint32_t v4addr)
void tor_addr_make_unspec(tor_addr_t *a)
int tor_addr_parse(tor_addr_t *addr, const char *src)
int tor_addr_is_null(const tor_addr_t *addr)
const char * tor_addr_to_str(char *dest, const tor_addr_t *addr, size_t len, int decorate)
void tor_addr_from_ipv6_bytes(tor_addr_t *dest, const uint8_t *ipv6_bytes)
static uint32_t tor_addr_to_ipv4n(const tor_addr_t *a)
static sa_family_t tor_addr_family(const tor_addr_t *a)
#define tor_addr_to_in6_addr8(x)
#define tor_addr_from_ipv4h(dest, v4addr)
int client_dns_incr_failures(const char *address)
void client_dns_set_addressmap(entry_connection_t *for_conn, const char *address, const tor_addr_t *val, const char *exitname, int ttl)
void client_dns_clear_failures(const char *address)
int buf_add(buf_t *buf, const char *string, size_t string_len)
size_t buf_datalen(const buf_t *buf)
int buf_get_bytes(buf_t *buf, char *string, size_t string_len)
Header file for buffers.c.
static void set_uint16(void *cp, uint16_t v)
static uint16_t get_uint16(const void *cp)
static uint8_t get_uint8(const void *cp)
static void set_uint8(void *cp, uint8_t v)
static uint32_t get_uint32(const void *cp)
Fixed-size cell structure.
void channel_timestamp_client(channel_t *chan)
int channel_send_destroy(circid_t circ_id, channel_t *chan, int reason)
int channel_is_client(const channel_t *chan)
void channel_mark_for_close(channel_t *chan)
int channel_write_packed_cell(channel_t *chan, packed_cell_t *cell)
Header file for channel.c.
void pathbias_count_valid_cells(circuit_t *circ, const relay_msg_t *msg)
int pathbias_check_probe_response(circuit_t *circ, const relay_msg_t *msg)
void pathbias_mark_use_success(origin_circuit_t *circ)
void circuit_log_path(int severity, unsigned int domain, origin_circuit_t *circ)
int circuit_send_next_onion_skin(origin_circuit_t *circ)
int circuit_finish_handshake(origin_circuit_t *circ, const created_cell_t *reply)
int circuit_truncated(origin_circuit_t *circ, int reason)
Header file for circuitbuild.c.
int circuit_extend(const relay_msg_t *rmsg, struct circuit_t *circ)
Header for feature/relay/circuitbuild_relay.c.
void circuit_synchronize_written_or_bandwidth(const circuit_t *c, circuit_channel_direction_t dir)
void circuit_set_n_circid_chan(circuit_t *circ, circid_t id, channel_t *chan)
void circuit_set_state(circuit_t *circ, uint8_t state)
circuit_t * circuit_get_by_edge_conn(edge_connection_t *conn)
origin_circuit_t * TO_ORIGIN_CIRCUIT(circuit_t *x)
void assert_circuit_ok(const circuit_t *c)
const char * circuit_state_to_string(int state)
size_t circuits_handle_oom(size_t current_allocation)
or_circuit_t * TO_OR_CIRCUIT(circuit_t *x)
smartlist_t * circuit_get_global_list(void)
Header file for circuitlist.c.
#define CIRCUIT_PURPOSE_PATH_BIAS_TESTING
#define CIRCUIT_STATE_OPEN
#define CIRCUIT_IS_ORCIRC(c)
#define CIRCUIT_IS_ORIGIN(c)
#define CIRCUIT_PURPOSE_OR
#define CIRCUIT_PURPOSE_S_REND_JOINED
#define CIRCUIT_PURPOSE_REND_ESTABLISHED
cell_direction_t circuitmux_attached_circuit_direction(circuitmux_t *cmux, circuit_t *circ)
void circuitmux_notify_xmit_destroy(circuitmux_t *cmux)
void circuitmux_detach_all_circuits(circuitmux_t *cmux, smartlist_t *detached_out)
void circuitmux_notify_xmit_cells(circuitmux_t *cmux, circuit_t *circ, unsigned int n_cells)
int circuitmux_is_circuit_attached(circuitmux_t *cmux, circuit_t *circ)
void circuitmux_set_num_cells(circuitmux_t *cmux, circuit_t *circ, unsigned int n_cells)
circuit_t * circuitmux_get_first_active_circuit(circuitmux_t *cmux, destroy_cell_queue_t **destroy_queue_out)
int circpad_check_received_cell(const relay_msg_t *msg, circuit_t *circ, crypt_path_t *layer_hint)
void circpad_deliver_sent_relay_cell_events(circuit_t *circ, uint8_t relay_command)
void circpad_deliver_unrecognized_cell_events(circuit_t *circ, cell_direction_t dir)
void circpad_machine_event_circ_has_no_relay_early(origin_circuit_t *circ)
void circpad_deliver_recognized_relay_cell_events(circuit_t *circ, uint8_t relay_command, crypt_path_t *layer_hint)
Header file for circuitpadding.c.
void circuit_sent_valid_data(origin_circuit_t *circ, uint16_t relay_body_len)
void circuit_read_valid_data(origin_circuit_t *circ, uint16_t relay_body_len)
void mark_circuit_unusable_for_new_conns(origin_circuit_t *circ)
Header file for circuituse.c.
uint64_t monotime_coarse_stamp_units_to_approx_msec(uint64_t units)
uint32_t monotime_coarse_get_stamp(void)
size_t tor_compress_get_total_allocation(void)
const or_options_t * get_options(void)
tor_cmdline_mode_t command
Header file for config.c.
void conflux_note_cell_sent(conflux_t *cfx, circuit_t *circ, uint8_t relay_command)
bool conflux_should_multiplex(int relay_command)
circuit_t * conflux_decide_next_circ(conflux_t *cfx)
circuit_t * conflux_decide_circ_for_send(conflux_t *cfx, circuit_t *orig_circ, uint8_t relay_command)
conflux_msg_t * conflux_dequeue_relay_msg(conflux_t *cfx)
bool conflux_process_relay_msg(conflux_t *cfx, circuit_t *in_circ, crypt_path_t *layer_hint, const relay_msg_t *msg)
int conflux_process_switch_command(circuit_t *in_circ, crypt_path_t *layer_hint, const relay_msg_t *msg)
size_t conflux_handle_oom(size_t bytes_to_remove)
uint64_t conflux_get_total_bytes_allocation(void)
Public APIs for conflux multipath support.
void conflux_process_linked_ack(circuit_t *circ)
void conflux_log_set(int loglevel, const conflux_t *cfx, bool is_client)
void conflux_process_link(circuit_t *circ, const relay_msg_t *msg)
void conflux_process_linked(circuit_t *circ, crypt_path_t *layer_hint, const relay_msg_t *msg)
Header file for conflux_pool.c.
crypt_path_t * conflux_get_destination_hop(circuit_t *circ)
int circuit_get_package_window(circuit_t *circ, const crypt_path_t *cpath)
bool conflux_can_send(conflux_t *cfx)
bool relay_crypt_from_last_hop(const origin_circuit_t *circ, const crypt_path_t *layer_hint)
bool edge_uses_cpath(const edge_connection_t *conn, const crypt_path_t *cpath)
Header file for conflux_util.c.
int congestion_control_get_package_window(const circuit_t *circ, const crypt_path_t *cpath)
Public APIs for congestion control.
static int32_t cell_queue_highwatermark(void)
static int32_t cell_queue_lowwatermark(void)
bool circuit_process_stream_xoff(edge_connection_t *conn, const crypt_path_t *layer_hint)
bool circuit_process_stream_xon(edge_connection_t *conn, const crypt_path_t *layer_hint, const relay_msg_t *msg)
APIs for stream flow control on congestion controlled circuits.
int connection_buf_get_bytes(char *string, size_t len, connection_t *conn)
int connection_state_is_open(connection_t *conn)
const char * conn_state_to_string(int type, int state)
Header file for connection.c.
int connection_half_edge_is_valid_data(const smartlist_t *half_conns, streamid_t stream_id)
int connection_exit_begin_resolve(const relay_msg_t *msg, or_circuit_t *circ)
int connection_ap_detach_retriable(entry_connection_t *conn, origin_circuit_t *circ, int reason)
void connection_ap_handshake_socks_reply(entry_connection_t *conn, char *reply, size_t replylen, int endreason)
int connection_half_edge_is_valid_end(smartlist_t *half_conns, streamid_t stream_id)
void connection_edge_end_close(edge_connection_t *conn, uint8_t reason)
int connection_half_edge_is_valid_connected(const smartlist_t *half_conns, streamid_t stream_id)
int connection_exit_begin_conn(const relay_msg_t *msg, circuit_t *circ)
entry_connection_t * EDGE_TO_ENTRY_CONN(edge_connection_t *c)
void connection_ap_handshake_socks_resolved_addr(entry_connection_t *conn, const tor_addr_t *answer, int ttl, time_t expires)
int connection_half_edge_is_valid_resolved(smartlist_t *half_conns, streamid_t stream_id)
int connection_edge_end(edge_connection_t *conn, uint8_t reason)
size_t half_streams_get_total_allocation(void)
int connection_half_edge_is_valid_sendme(const smartlist_t *half_conns, streamid_t stream_id)
int connection_edge_is_rendezvous_stream(const edge_connection_t *conn)
void connection_ap_handshake_socks_resolved(entry_connection_t *conn, int answer_type, size_t answer_len, const uint8_t *answer, int ttl, time_t expires)
Header file for connection_edge.c.
#define EXIT_CONN_STATE_CONNECTING
#define AP_CONN_STATE_CONNECT_WAIT
#define AP_CONN_STATE_OPEN
#define AP_CONN_STATE_RESOLVE_WAIT
#define EXIT_CONN_STATE_RESOLVING
void cell_pack(packed_cell_t *dst, const cell_t *src, int wide_circ_ids)
Header file for connection_or.c.
void control_event_boot_dir(bootstrap_status_t status, int progress)
void control_event_bootstrap(bootstrap_status_t status, int progress)
int control_event_stream_status(entry_connection_t *conn, stream_status_event_t tp, int reason_code)
Header file for control_events.c.
#define REMAP_STREAM_SOURCE_EXIT
Circuit-build-stse structure.
Common functions for using (pseudo-)random number generators.
#define crypto_fast_rng_one_in_n(rng, n)
crypto_fast_rng_t * get_thread_fast_rng(void)
unsigned crypto_fast_rng_get_uint(crypto_fast_rng_t *rng, unsigned limit)
Common functions for cryptographic routines.
const char * node_describe(const node_t *node)
Header file for describe.c.
Destroy-cell queue structures.
Client/server directory connection structure.
dir_connection_t * TO_DIR_CONN(connection_t *c)
Header file for directory.c.
#define DIR_PURPOSE_FETCH_CERTIFICATE
#define DIR_PURPOSE_FETCH_MICRODESC
#define DIR_PURPOSE_FETCH_CONSENSUS
#define DIR_PURPOSE_FETCH_SERVERDESC
Entry connection structure.
#define ENTRY_TO_EDGE_CONN(c)
Header for core/or/extendinfo.c.
Header file for geoip_stats.c.
@ DIRREQ_CIRC_QUEUE_FLUSHED
void geoip_change_dirreq_state(uint64_t dirreq_id, dirreq_type_t type, dirreq_state_t new_state)
size_t hs_cache_handle_oom(size_t min_remove_bytes)
Header file for hs_cache.c.
Header for feature/hs/hs_metrics.c.
#define hs_metrics_app_write_bytes(i, port, n)
void tor_log(int severity, log_domain_mask_t domain, const char *format,...)
#define log_fn(severity, domain, args,...)
void connection_stop_reading(connection_t *conn)
void connection_start_reading(connection_t *conn)
int connection_is_reading(const connection_t *conn)
Header file for mainloop.c.
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)
int consensus_is_waiting_for_certs(void)
Header file for networkstatus.c.
int node_exit_policy_is_exact(const node_t *node, sa_family_t family)
node_t * node_get_mutable_by_id(const char *identity_digest)
int count_loading_descriptors_progress(void)
Header file for nodelist.c.
int extended_cell_parse(extended_cell_t *cell_out, const uint8_t command, const uint8_t *payload, size_t payload_len)
Master header file for Tor-specific functionality.
#define CELL_PAYLOAD_SIZE
#define END_STREAM_REASON_CANT_ATTACH
#define END_STREAM_REASON_FLAG_REMOTE
#define END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED
#define RELAY_PAYLOAD_SIZE_MAX
#define END_CIRC_AT_ORIGIN
#define CIRCWINDOW_INCREMENT
Origin circuit structure.
void addr_policy_append_reject_addr(smartlist_t **dest, const tor_addr_t *addr)
void policies_set_node_exitpolicy_to_reject_all(node_t *node)
Header file for policies.c.
int tor_snprintf(char *str, size_t size, const char *format,...)
char * rate_limit_log(ratelim_t *lim, time_t now)
const char * stream_end_reason_to_string(int reason)
Header file for reasons.c.
int channel_flush_from_first_active_circuit(channel_t *chan, int max)
static int connection_edge_process_relay_cell_not_open(const relay_msg_t *msg, circuit_t *circ, edge_connection_t *conn, crypt_path_t *layer_hint)
void destroy_cell_queue_init(destroy_cell_queue_t *queue)
static int connection_ap_process_end_not_open(const relay_msg_t *msg, origin_circuit_t *circ, entry_connection_t *conn, crypt_path_t *layer_hint)
static int circuit_resume_edge_reading_helper(edge_connection_t *conn, circuit_t *circ, crypt_path_t *layer_hint)
int append_address_to_payload(uint8_t *payload_out, const tor_addr_t *addr)
STATIC int resolved_cell_parse(const relay_msg_t *msg, smartlist_t *addresses_out, int *errcode_out)
uint64_t stats_n_data_cells_received
void packed_cell_free_(packed_cell_t *cell)
STATIC int connection_edge_process_resolved_cell(edge_connection_t *conn, const relay_msg_t *msg)
void destroy_cell_queue_clear(destroy_cell_queue_t *queue)
void destroy_cell_queue_append(destroy_cell_queue_t *queue, circid_t circid, uint8_t reason)
relay_cell_fmt_t circuit_get_relay_format(const circuit_t *circ, const crypt_path_t *cpath)
void channel_unlink_all_circuits(channel_t *chan, smartlist_t *circuits_out)
int append_cell_to_circuit_queue(circuit_t *circ, channel_t *chan, cell_t *cell, cell_direction_t direction, streamid_t fromstream)
void cell_queue_append_packed_copy(circuit_t *circ, cell_queue_t *queue, int exitward, const cell_t *cell, int wide_circ_ids, int use_stats)
uint64_t oom_stats_n_bytes_removed_dns
static packed_cell_t * destroy_cell_to_packed_cell(destroy_cell_t *inp, int wide_circ_ids)
void dump_cell_pool_usage(int severity)
STATIC int connection_edge_process_relay_cell(const relay_msg_t *msg, circuit_t *circ, edge_connection_t *conn, crypt_path_t *layer_hint)
void circuit_reset_sendme_randomness(circuit_t *circ)
uint64_t stats_n_relay_cells_relayed
size_t circuit_max_relay_payload(const circuit_t *circ, const crypt_path_t *cpath, uint8_t relay_command)
uint64_t stats_n_circ_max_cell_reached
#define MAX_RESOLVE_FAILURES
static void remap_event_helper(entry_connection_t *conn, const tor_addr_t *new_addr)
static int circuit_queue_streams_are_blocked(circuit_t *circ)
static void connection_ap_handshake_socks_got_resolved_cell(entry_connection_t *conn, int error_code, smartlist_t *results)
static void adjust_exit_policy_from_exitpolicy_failure(origin_circuit_t *circ, entry_connection_t *conn, node_t *node, const tor_addr_t *addr)
static void circuit_update_channel_usage(circuit_t *circ, cell_t *cell)
uint64_t stats_n_data_cells_packaged
STATIC packed_cell_t * packed_cell_new(void)
void cell_queue_clear(cell_queue_t *queue)
void circuit_clear_cell_queue(circuit_t *circ, channel_t *chan)
void cell_queue_init(cell_queue_t *queue)
int circuit_package_relay_cell(cell_t *cell, circuit_t *circ, cell_direction_t cell_direction, crypt_path_t *layer_hint, streamid_t on_stream, const char *filename, int lineno)
STATIC packed_cell_t * cell_queue_pop(cell_queue_t *queue)
int have_been_under_memory_pressure(void)
uint64_t stats_n_data_bytes_received
circid_t packed_cell_get_circid(const packed_cell_t *cell, int wide_circ_ids)
static int connection_edge_process_ordered_relay_cell(const relay_msg_t *msg, circuit_t *circ, edge_connection_t *conn, crypt_path_t *layer_hint)
const uint8_t * decode_address_from_payload(tor_addr_t *addr_out, const uint8_t *payload, int payload_len)
static uint32_t get_param_max_circuit_cell_queue_size(const networkstatus_t *ns)
void update_circuit_on_cmux_(circuit_t *circ, cell_direction_t direction, const char *file, int lineno)
STATIC destroy_cell_t * destroy_cell_queue_pop(destroy_cell_queue_t *queue)
uint8_t packed_cell_get_command(const packed_cell_t *cell, int wide_circ_ids)
uint64_t stats_n_relay_cells_delivered
STATIC int cell_queues_check_size(void)
STATIC int connected_cell_parse(const relay_msg_t *msg, tor_addr_t *addr_out, int *ttl_out)
static size_t total_cells_allocated
static int32_t max_circuit_cell_queue_size_out
int relay_send_command_from_edge_(streamid_t stream_id, circuit_t *orig_circ, uint8_t relay_command, const char *payload, size_t payload_len, crypt_path_t *cpath_layer, const char *filename, int lineno)
static void packed_cell_free_unchecked(packed_cell_t *cell)
static int edge_reason_is_retriable(int reason)
STATIC size_t connection_edge_get_inbuf_bytes_to_package(size_t n_available, int package_partial, circuit_t *on_circuit, crypt_path_t *cpath)
static void circuit_resume_edge_reading(circuit_t *circ, crypt_path_t *layer_hint)
static void set_circuit_blocked_on_chan(circuit_t *circ, channel_t *chan, int block)
STATIC void address_ttl_free_(address_ttl_t *addr)
static uint32_t get_param_max_circuit_cell_queue_size_out(const networkstatus_t *ns)
STATIC int handle_relay_msg(const relay_msg_t *msg, circuit_t *circ, edge_connection_t *conn, crypt_path_t *layer_hint, int optimistic_data)
static int process_sendme_cell(const relay_msg_t *msg, circuit_t *circ, edge_connection_t *conn, crypt_path_t *layer_hint, int domain)
const char * relay_command_to_string(uint8_t command)
#define MEMORY_PRESSURE_INTERVAL
static void set_block_state_for_streams(circuit_t *circ, edge_connection_t *stream_list, int block, streamid_t stream_id)
void cell_queue_append(cell_queue_t *queue, packed_cell_t *cell)
static edge_connection_t * relay_lookup_conn(circuit_t *circ, const relay_msg_t *msg, cell_direction_t cell_direction, crypt_path_t *layer_hint)
static packed_cell_t * packed_cell_copy(const cell_t *cell, int wide_circ_ids)
int circuit_receive_relay_cell(cell_t *cell, circuit_t *circ, cell_direction_t cell_direction)
int connection_edge_package_raw_inbuf(edge_connection_t *conn, int package_partial, int *max_cells)
int connection_edge_send_command(edge_connection_t *fromconn, uint8_t relay_command, const char *payload, size_t payload_len)
uint64_t stats_n_data_bytes_packaged
size_t packed_cell_mem_cost(void)
static time_t last_time_under_memory_pressure
static int circuit_consider_stop_edge_reading(circuit_t *circ, crypt_path_t *layer_hint)
Header for relay_crypto.c.
void relay_encrypt_cell_outbound(cell_t *cell, origin_circuit_t *or_circ, crypt_path_t *layer_hint)
int relay_decrypt_cell(circuit_t *circ, cell_t *cell, cell_direction_t cell_direction, crypt_path_t **layer_hint, char *recognized)
void relay_encrypt_cell_inbound(cell_t *cell, or_circuit_t *or_circ)
int relay_msg_encode_cell(relay_cell_fmt_t format, const relay_msg_t *msg, cell_t *cell_out)
int relay_msg_decode_cell_in_place(relay_cell_fmt_t format, const cell_t *cell, relay_msg_t *msg_out)
Header file for relay_msg.c.
static size_t relay_cell_max_payload_size(relay_cell_fmt_t format, uint8_t relay_command)
A relay message which contains a relay command and parameters, if any, that is from a relay cell.
void rend_process_relay_cell(circuit_t *circ, const crypt_path_t *layer_hint, int command, size_t length, const uint8_t *payload)
Header file for rendcommon.c.
void rep_hist_note_overload(overload_type_t overload)
Header file for rephist.c.
Router descriptor structure.
#define ROUTER_PURPOSE_GENERAL
Header file for routerlist.c.
void scheduler_channel_has_waiting_cells(channel_t *chan)
Header file for scheduler*.c.
void sendme_connection_edge_consider_sending(edge_connection_t *conn)
void sendme_circuit_consider_sending(circuit_t *circ, crypt_path_t *layer_hint)
Header file for sendme.c.
char * smartlist_join_strings(smartlist_t *sl, const char *join, int terminate, size_t *len_out)
void smartlist_add_all(smartlist_t *s1, const smartlist_t *s2)
smartlist_t * smartlist_new(void)
void smartlist_add(smartlist_t *sl, void *element)
#define SMARTLIST_FOREACH_BEGIN(sl, type, var)
#define SMARTLIST_FOREACH(sl, type, var, cmd)
#define SMARTLIST_DEL_CURRENT(sl, var)
Client request structure.
#define SOCKS_COMMAND_RESOLVE_PTR
uint8_t payload[CELL_PAYLOAD_SIZE]
unsigned int num_n_circuits
channel_usage_info_t channel_usage
int marked_for_close_reason
unsigned int circuit_blocked_on_n_chan
uint16_t send_randomness_after_n_cells
struct create_cell_t * n_chan_create_cell
unsigned int circuit_blocked_on_p_chan
unsigned int have_sent_sufficiently_random_cell
cell_queue_t n_chan_cells
uint16_t marked_for_close
struct conflux_t * conflux
const char * marked_for_close_file
smartlist_t * testing_cell_stats
struct timeval timestamp_created
time_t timestamp_last_read_allowed
uint16_t marked_for_close
const char * marked_for_close_file
struct event * read_event
extend_info_t * chosen_exit
relay_cell_fmt_t relay_cell_format
uint32_t inserted_timestamp
struct crypt_path_t * cpath_layer
struct edge_connection_t * next_stream
unsigned int edge_has_sent_end
struct circuit_t * on_circuit
socks_request_t * socks_request
unsigned int chosen_exit_optional
unsigned int chosen_exit_retries
struct buf_t * pending_optimistic_data
char identity_digest[DIGEST_LEN]
created_cell_t created_cell
ed25519_public_key_t identity_pk
uint16_t orig_virtual_port
uint64_t total_cell_waiting_time
uint32_t n_cells_discarded_at_end
relay_cell_fmt_t relay_cell_format
cell_queue_t p_chan_cells
struct or_circuit_t * rend_splice
edge_connection_t * n_streams
uint32_t n_written_circ_bw
uint32_t global_identifier
edge_connection_t * p_streams
uint8_t relay_early_commands[MAX_RELAY_EARLY_CELLS_PER_CIRCUIT]
int relay_early_cells_sent
unsigned int remaining_relay_early_cells
path_state_bitfield_t path_state
smartlist_t * prepend_policy
cpath_build_state_t * build_state
smartlist_t * half_streams
uint32_t inserted_timestamp
char body[CELL_MAX_NETWORK_SIZE]
unsigned int has_finished
char address[MAX_SOCKS_ADDR_LEN]
unsigned int waiting_time
#define MOCK_IMPL(rv, funcname, arglist)