54#include "feature/client/circpathbias.h"
95#include "core/or/or_circuit_st.h"
142uint64_t stats_n_circ_max_cell_outq_reached = 0;
204 if (BUG(!or_circ->
p_chan))
209 if (cell->
command == CELL_RELAY_EARLY) {
213 }
else if (cell->
command == CELL_RELAY) {
251 "relay crypt failed. Dropping connection.");
252 return -END_CIRC_REASON_INTERNAL;
262 sendme_record_received_cell_digest(circ, layer_hint);
277 log_debug(
LD_OR,
"Sending away from origin.");
281 "connection_edge_process_relay_cell (away from origin) "
288 log_debug(
LD_OR,
"Sending to origin.");
297 "connection_edge_process_relay_cell (at origin) failed.");
316 "Dropping unrecognized inbound cell on origin circuit.");
322 return -END_CIRC_REASON_TORPROTOCOL;
340 log_warn(
LD_REND,
"Error relaying cell across rendezvous; closing "
343 circuit_mark_for_close(circ, -reason);
350 return -END_CIRC_REASON_TORPROTOCOL;
356 "Didn't recognize a cell, but circ stops here! Closing circuit. "
357 "It was created %ld seconds ago.", (
long)seconds_open);
359 return -END_CIRC_REASON_TORPROTOCOL;
362 log_debug(
LD_OR,
"Passing on unrecognized cell.");
369 return -END_CIRC_REASON_RESOURCELIMIT;
385 const char *filename,
int lineno))
397 log_warn(
LD_BUG,
"outgoing relay cell sent from %s:%d has n_chan==NULL."
398 " Dropping. Circuit is in state %s (%d), and is "
399 "%smarked for close. (%s:%d, %d)", filename, lineno,
411 log_warn(
LD_BUG,
"outgoing relay cell sent from %s:%d on non-origin "
412 "circ. Dropping.", filename, lineno);
428 log_warn(
LD_BUG,
"incoming relay cell at origin circuit. Dropping.");
439 cell_direction, on_stream);
475 log_debug(LD_EXIT,
"found conn for stream %d.", rh.
stream_id);
481 for (tmpconn =
TO_OR_CIRCUIT(circ)->resolving_streams; tmpconn;
485 log_debug(LD_EXIT,
"found conn for stream %d.", rh.
stream_id);
526 case RELAY_COMMAND_BEGIN:
return "BEGIN";
527 case RELAY_COMMAND_DATA:
return "DATA";
528 case RELAY_COMMAND_END:
return "END";
529 case RELAY_COMMAND_CONNECTED:
return "CONNECTED";
530 case RELAY_COMMAND_SENDME:
return "SENDME";
531 case RELAY_COMMAND_EXTEND:
return "EXTEND";
532 case RELAY_COMMAND_EXTENDED:
return "EXTENDED";
533 case RELAY_COMMAND_TRUNCATE:
return "TRUNCATE";
534 case RELAY_COMMAND_TRUNCATED:
return "TRUNCATED";
535 case RELAY_COMMAND_DROP:
return "DROP";
536 case RELAY_COMMAND_RESOLVE:
return "RESOLVE";
537 case RELAY_COMMAND_RESOLVED:
return "RESOLVED";
538 case RELAY_COMMAND_BEGIN_DIR:
return "BEGIN_DIR";
539 case RELAY_COMMAND_ESTABLISH_INTRO:
return "ESTABLISH_INTRO";
540 case RELAY_COMMAND_ESTABLISH_RENDEZVOUS:
return "ESTABLISH_RENDEZVOUS";
541 case RELAY_COMMAND_INTRODUCE1:
return "INTRODUCE1";
542 case RELAY_COMMAND_INTRODUCE2:
return "INTRODUCE2";
543 case RELAY_COMMAND_RENDEZVOUS1:
return "RENDEZVOUS1";
544 case RELAY_COMMAND_RENDEZVOUS2:
return "RENDEZVOUS2";
545 case RELAY_COMMAND_INTRO_ESTABLISHED:
return "INTRO_ESTABLISHED";
546 case RELAY_COMMAND_RENDEZVOUS_ESTABLISHED:
547 return "RENDEZVOUS_ESTABLISHED";
548 case RELAY_COMMAND_INTRODUCE_ACK:
return "INTRODUCE_ACK";
549 case RELAY_COMMAND_EXTEND2:
return "EXTEND2";
550 case RELAY_COMMAND_EXTENDED2:
return "EXTENDED2";
551 case RELAY_COMMAND_PADDING_NEGOTIATE:
return "PADDING_NEGOTIATE";
552 case RELAY_COMMAND_PADDING_NEGOTIATED:
return "PADDING_NEGOTIATED";
553 case RELAY_COMMAND_CONFLUX_LINK:
return "CONFLUX_LINK";
554 case RELAY_COMMAND_CONFLUX_LINKED:
return "CONFLUX_LINKED";
555 case RELAY_COMMAND_CONFLUX_LINKED_ACK:
return "CONFLUX_LINKED_ACK";
556 case RELAY_COMMAND_CONFLUX_SWITCH:
return "CONFLUX_SWITCH";
558 tor_snprintf(buf,
sizeof(buf),
"Unrecognized relay command %u",
566#define CELL_PADDING_GAP 4
603pad_cell_payload(uint8_t *cell_payload,
size_t data_len)
605 size_t pad_offset, pad_len;
610 if (pad_offset == 0) {
619 cell_payload + pad_offset, pad_len);
633 uint8_t relay_command,
const char *payload,
635 const char *filename,
int lineno))
647 log_warn(
LD_BUG,
"No circuit to send for conflux for relay command %d, "
648 "called from %s:%d", relay_command, filename, lineno);
665 memset(&cell, 0,
sizeof(
cell_t));
677 memset(&rh, 0,
sizeof(rh));
687 pad_cell_payload(cell.
payload, payload_len);
689 log_debug(
LD_OR,
"delivering %d cell %s.", relay_command,
697 if (relay_command == RELAY_COMMAND_END && circ->
dirreq_id)
709 (relay_command == RELAY_COMMAND_EXTEND ||
710 relay_command == RELAY_COMMAND_EXTEND2 ||
711 cpath_layer != origin_circ->
cpath)) {
716 cell.
command = CELL_RELAY_EARLY;
720 log_debug(
LD_OR,
"Sending a RELAY_EARLY cell; %d remaining.",
726 }
else if (relay_command == RELAY_COMMAND_EXTEND ||
727 relay_command == RELAY_COMMAND_EXTEND2) {
733 char *commands = NULL;
738 log_warn(
LD_BUG,
"Uh-oh. We're sending a RELAY_COMMAND_EXTEND cell, "
739 "but we have run out of RELAY_EARLY cells on that circuit. "
740 "Commands sent before: %s", commands);
742 smartlist_free(commands_list);
751 cpath_layer, stream_id, filename,
754 circuit_mark_for_close(circ, END_CIRC_REASON_INTERNAL);
756 }
else if (ret == 0) {
774 if (relay_command == RELAY_COMMAND_DATA) {
775 sendme_record_cell_digest_on_circ(circ, cpath_layer);
778 if (sendme_note_circuit_data_packaged(circ, cpath_layer) < 0) {
781 "Circuit package window is below 0. Closing circuit.");
782 circuit_mark_for_close(circ, END_CIRC_REASON_TORPROTOCOL);
801 uint8_t relay_command,
const char *payload,
813 "called on conn that's already marked for close at %s:%d.",
821 log_info(
LD_APP,
"no circ. Closing conn.");
823 END_STREAM_REASON_INTERNAL);
825 log_info(LD_EXIT,
"no circ. Closing conn.");
827 fromconn->
end_reason = END_STREAM_REASON_INTERNAL;
828 connection_mark_for_close(
TO_CONN(fromconn));
839#ifdef MEASUREMENTS_21206
849 return relay_send_command_from_edge(fromconn->
stream_id, circ,
850 relay_command, payload,
851 payload_len, cpath_layer);
857#define MAX_RESOLVE_FAILURES 3
864 return reason == END_STREAM_REASON_HIBERNATING ||
865 reason == END_STREAM_REASON_RESOURCELIMIT ||
866 reason == END_STREAM_REASON_EXITPOLICY ||
867 reason == END_STREAM_REASON_RESOLVEFAILED ||
868 reason == END_STREAM_REASON_MISC ||
869 reason == END_STREAM_REASON_NOROUTE;
888 if (reason == END_STREAM_REASON_TORPROTOCOL ||
889 reason == END_STREAM_REASON_DESTROY) {
894 return -END_CIRC_REASON_TORPROTOCOL;
895 }
else if (reason == END_STREAM_REASON_INTERNAL) {
913 reason = END_STREAM_REASON_MISC;
921 const char *chosen_exit_digest =
923 log_info(
LD_APP,
"Address '%s' refused due to '%s'. Considering retrying.",
928 case END_STREAM_REASON_EXITPOLICY: {
946 log_info(
LD_APP,
"Address '%s' resolved to 0.0.0.0. Closing,",
948 connection_mark_unattached_ap(conn, END_STREAM_REASON_TORPROTOCOL);
953 !conn->entry_cfg.ipv4_traffic) ||
955 !conn->entry_cfg.ipv6_traffic)) {
957 "Got an EXITPOLICY failure on a connection with a "
958 "mismatched family. Closing.");
959 connection_mark_unattached_ap(conn, END_STREAM_REASON_TORPROTOCOL);
962 if (
get_options()->ClientDNSRejectInternalAddresses &&
963 tor_addr_is_internal(&addr, 0)) {
964 log_info(
LD_APP,
"Address '%s' resolved to internal. Closing,",
966 connection_mark_unattached_ap(conn, END_STREAM_REASON_TORPROTOCOL);
1010 case END_STREAM_REASON_CONNECTREFUSED:
1016 case END_STREAM_REASON_RESOLVEFAILED:
1017 case END_STREAM_REASON_TIMEOUT:
1018 case END_STREAM_REASON_MISC:
1019 case END_STREAM_REASON_NOROUTE:
1037 "Have tried resolving or connecting to address '%s' "
1038 "at %d different places. Giving up.",
1045 case END_STREAM_REASON_HIBERNATING:
1046 case END_STREAM_REASON_RESOURCELIMIT:
1060 log_info(
LD_APP,
"Giving up on retrying; conn can't be handled.");
1064 "Edge got end (%s) before we're connected. Marking for close.",
1069 connection_mark_unattached_ap(conn, control_reason);
1088 int make_reject_all = 0;
1094 if (family == AF_UNSPEC) {
1095 make_reject_all = 1;
1098 make_reject_all = 1;
1101 if (make_reject_all) {
1103 "Exitrouter %s seems to be more restrictive than its exit "
1104 "policy. Not using this router as exit for now.",
1110 if (family != AF_UNSPEC)
1158 if (bytes <= INT32_MAX)
1168 if (bytes <= INT32_MAX)
1169 *ttl_out = (int) bytes;
1194 uint8_t answer_type;
1196 address_ttl_t *addr;
1217 const uint8_t *cp_orig = cp;
1220 answer_type = *cp++;
1222 if (remaining < 2 + answer_len + 4) {
1225 if (answer_type == RESOLVED_TYPE_IPV4) {
1226 if (answer_len != 4) {
1229 addr = tor_malloc_zero(
sizeof(*addr));
1235 }
else if (answer_type == RESOLVED_TYPE_IPV6) {
1236 if (answer_len != 16)
1238 addr = tor_malloc_zero(
sizeof(*addr));
1244 }
else if (answer_type == RESOLVED_TYPE_HOSTNAME) {
1245 if (answer_len == 0) {
1248 addr = tor_malloc_zero(
sizeof(*addr));
1249 addr->hostname = tor_memdup_nulterm(cp, answer_len);
1254 }
else if (answer_type == RESOLVED_TYPE_ERROR_TRANSIENT ||
1255 answer_type == RESOLVED_TYPE_ERROR) {
1256 errcode = answer_type;
1258 cp += answer_len + 4;
1260 cp += answer_len + 4;
1262 tor_assert(((ssize_t)remaining) >= (cp - cp_orig));
1263 remaining -= (cp - cp_orig);
1266 if (errcode && smartlist_len(addrs) == 0) {
1268 *errcode_out = errcode;
1272 smartlist_free(addrs);
1279 smartlist_free(addrs);
1291 address_ttl_t *addr_ipv4 = NULL;
1292 address_ttl_t *addr_ipv6 = NULL;
1293 address_ttl_t *addr_hostname = NULL;
1294 address_ttl_t *addr_best = NULL;
1298 tor_assert(error_code == RESOLVED_TYPE_ERROR ||
1299 error_code == RESOLVED_TYPE_ERROR_TRANSIENT);
1301 error_code,0,NULL,-1,-1);
1307 if (addr->hostname) {
1308 if (!addr_hostname) {
1309 addr_hostname = addr;
1312 if (!addr_ipv4 && conn->entry_cfg.ipv4_traffic) {
1316 if (!addr_ipv6 && conn->entry_cfg.ipv6_traffic) {
1320 } SMARTLIST_FOREACH_END(addr);
1324 if (addr_hostname) {
1326 RESOLVED_TYPE_HOSTNAME,
1327 strlen(addr_hostname->hostname),
1328 (uint8_t*)addr_hostname->hostname,
1329 addr_hostname->ttl,-1);
1332 RESOLVED_TYPE_ERROR,0,NULL,-1,-1);
1337 if (conn->entry_cfg.prefer_ipv6) {
1338 addr_best = addr_ipv6 ? addr_ipv6 : addr_ipv4;
1340 addr_best = addr_ipv4 ? addr_ipv4 : addr_ipv6;
1346 RESOLVED_TYPE_NOERROR,0,NULL,-1,-1);
1370 log_fn(LOG_PROTOCOL_WARN,
LD_APP,
"Got a 'resolved' cell while "
1371 "not in state resolve_wait. Dropping.");
1379 "Dropping malformed 'resolved' cell");
1380 connection_mark_unattached_ap(entry_conn, END_STREAM_REASON_TORPROTOCOL);
1384 if (
get_options()->ClientDNSRejectInternalAddresses) {
1385 int orig_len = smartlist_len(resolved_addresses);
1387 if (addr->hostname == NULL && tor_addr_is_internal(&addr->addr, 0)) {
1388 log_info(
LD_APP,
"Got a resolved cell with answer %s; dropping that "
1390 safe_str_client(
fmt_addr(&addr->addr)));
1391 address_ttl_free(addr);
1394 } SMARTLIST_FOREACH_END(addr);
1395 if (orig_len && smartlist_len(resolved_addresses) == 0) {
1396 log_info(
LD_APP,
"Got a resolved cell with only private addresses; "
1399 RESOLVED_TYPE_ERROR_TRANSIENT,
1400 0, NULL, 0, TIME_MAX);
1401 connection_mark_unattached_ap(entry_conn,
1402 END_STREAM_REASON_TORPROTOCOL);
1415 resolved_addresses);
1417 connection_mark_unattached_ap(entry_conn,
1418 END_STREAM_REASON_DONE |
1423 address_ttl_free(addr));
1424 smartlist_free(resolved_addresses);
1440 if (rh->
command == RELAY_COMMAND_END) {
1451 connection_mark_for_close(
TO_CONN(conn));
1457 rh->
command == RELAY_COMMAND_CONNECTED) {
1464 "Got 'connected' while not in state connect_wait. Dropping.");
1467 CONNECTION_AP_EXPECT_NONPENDING(entry_conn);
1469 log_info(
LD_APP,
"'connected' received for circid %u streamid %d "
1470 "after %d seconds.",
1476 "Got a badly formatted connected cell. Closing.");
1478 connection_mark_unattached_ap(entry_conn, END_STREAM_REASON_TORPROTOCOL);
1487 (
get_options()->ClientDNSRejectInternalAddresses &&
1488 tor_addr_is_internal(&addr, 0))) {
1489 log_info(
LD_APP,
"...but it claims the IP address was %s. Closing.",
1492 connection_mark_unattached_ap(entry_conn,
1493 END_STREAM_REASON_TORPROTOCOL);
1497 if ((family == AF_INET && ! entry_conn->entry_cfg.ipv4_traffic) ||
1498 (family == AF_INET6 && ! entry_conn->entry_cfg.ipv6_traffic)) {
1500 "Got a connected cell to %s with unsupported address family."
1501 " Closing.", safe_str(
fmt_addr(&addr)));
1503 connection_mark_unattached_ap(entry_conn,
1504 END_STREAM_REASON_TORPROTOCOL);
1523 log_debug(
LD_APP,
"considering");
1524 if (
TO_CONN(conn)->linked_conn &&
1557 connection_mark_for_close(
TO_CONN(conn));
1563 rh->
command == RELAY_COMMAND_RESOLVED) {
1568 "Got an unexpected relay command %d, in state %d (%s). Dropping.",
1595 ret = sendme_process_circuit_level(layer_hint, circ,
1615 log_info(domain,
"Sendme cell on circ %u valid on half-closed "
1621 log_info(domain,
"SENDME cell dropped, unknown stream (streamid %d).",
1628 ret = sendme_process_stream_level(conn, circ, rh->
length);
1647 connection_mark_for_close(
TO_CONN(conn));
1666 unsigned domain = layer_hint?
LD_APP:LD_EXIT;
1674 log_debug(domain,
"Cell handled as circuit padding");
1680 case RELAY_COMMAND_CONFLUX_LINK:
1683 case RELAY_COMMAND_CONFLUX_LINKED:
1686 case RELAY_COMMAND_CONFLUX_LINKED_ACK:
1689 case RELAY_COMMAND_CONFLUX_SWITCH:
1691 case RELAY_COMMAND_BEGIN:
1692 case RELAY_COMMAND_BEGIN_DIR:
1696 "Relay begin request unsupported at AP. Dropping.");
1702 "Relay begin request to Hidden Service "
1703 "from intermediary node. Dropping.");
1707 log_fn(LOG_PROTOCOL_WARN, domain,
1708 "Begin cell for known stream. Dropping.");
1711 if (rh->
command == RELAY_COMMAND_BEGIN_DIR &&
1717 static uint64_t next_id = 0;
1722 case RELAY_COMMAND_DATA:
1727 "stream_id. Dropping.");
1736 "data cell on circ %u valid on half-closed "
1741 log_info(domain,
"data cell dropped, unknown stream (streamid %d).",
1749 if (sendme_stream_data_received(conn) < 0) {
1751 "(relay data) conn deliver_window below 0. Killing.");
1753 return -END_CIRC_REASON_TORPROTOCOL;
1761 if (conn->hs_ident) {
1771#ifdef MEASUREMENTS_21206
1777 ++(
TO_DIR_CONN(linked_conn)->data_cells_received);
1781 if (!optimistic_data) {
1789 case RELAY_COMMAND_XOFF:
1808 case RELAY_COMMAND_XON:
1827 case RELAY_COMMAND_END:
1828 reason = rh->
length > 0 ?
1839 "end cell (%s) on circ %u valid on half-closed "
1846 log_info(domain,
"end cell (%s) dropped, unknown stream.",
1851 log_info(domain,TOR_SOCKET_T_FORMAT
": end cell (%s) for stream %d. "
1861 "open stream hasn't sent socks answer yet? Closing.");
1870 connection_mark_and_flush(
TO_CONN(conn));
1878 case RELAY_COMMAND_EXTEND:
1879 case RELAY_COMMAND_EXTEND2: {
1880 static uint64_t total_n_extend=0, total_nonearly=0;
1883 log_fn(LOG_PROTOCOL_WARN, domain,
1884 "'extend' cell received for non-zero stream. Dropping.");
1887 if (cell->
command != CELL_RELAY_EARLY &&
1889#define EARLY_WARNING_INTERVAL 3600
1891 RATELIM_INIT(EARLY_WARNING_INTERVAL);
1893 if (cell->
command == CELL_RELAY) {
1896 double percentage = ((double)total_nonearly)/total_n_extend;
1898 log_fn(LOG_PROTOCOL_WARN, domain,
"EXTEND cell received, "
1899 "but not via RELAY_EARLY. Dropping.%s", m);
1900 log_fn(LOG_PROTOCOL_WARN, domain,
" (We have dropped %.02f%% of "
1901 "all EXTEND cells for this reason)", percentage);
1906 "EXTEND cell received, in a cell with type %d! Dropping.",
1913 case RELAY_COMMAND_EXTENDED:
1914 case RELAY_COMMAND_EXTENDED2:
1917 "'extended' unsupported at non-origin. Dropping.");
1920 log_debug(domain,
"Got an extended cell! Yay.");
1927 "Can't parse EXTENDED cell; killing circuit.");
1928 return -END_CIRC_REASON_TORPROTOCOL;
1932 circuit_mark_for_close(circ, -reason);
1938 log_info(domain,
"circuit_send_next_onion_skin() failed.");
1946 case RELAY_COMMAND_TRUNCATE:
1949 "'truncate' unsupported at origin. Dropping.");
1954 log_warn(
LD_BUG,
"n_chan and n_hop set on the same circuit!");
1955 extend_info_free(circ->
n_hop);
1968 log_debug(LD_EXIT,
"Processed 'truncate', replying.");
1971 payload[0] = (char)END_CIRC_REASON_REQUESTED;
1972 relay_send_command_from_edge(0, circ, RELAY_COMMAND_TRUNCATED,
1973 payload,
sizeof(payload), NULL);
1976 case RELAY_COMMAND_TRUNCATED:
1978 log_fn(LOG_PROTOCOL_WARN, LD_EXIT,
1979 "'truncated' unsupported at non-origin. Dropping.");
1992 case RELAY_COMMAND_CONNECTED:
1995 "'connected' unsupported while open. Closing circ.");
1996 return -END_CIRC_REASON_TORPROTOCOL;
2005 "connected cell on circ %u valid on half-closed "
2012 "'connected' received on circid %u for streamid %d, "
2013 "no conn attached anymore. Ignoring.",
2016 case RELAY_COMMAND_SENDME:
2018 case RELAY_COMMAND_RESOLVE:
2021 "resolve request unsupported at AP; dropping.");
2024 log_fn(LOG_PROTOCOL_WARN, domain,
2025 "resolve request for known stream; dropping.");
2028 log_fn(LOG_PROTOCOL_WARN, domain,
2029 "resolve request on circ with purpose %d; dropping",
2034 case RELAY_COMMAND_RESOLVED:
2036 log_fn(LOG_PROTOCOL_WARN, domain,
2037 "'resolved' unsupported while open. Closing circ.");
2038 return -END_CIRC_REASON_TORPROTOCOL;
2048 "resolved cell on circ %u valid on half-closed "
2055 "'resolved' received, no conn attached anymore. Ignoring.");
2057 case RELAY_COMMAND_ESTABLISH_INTRO:
2058 case RELAY_COMMAND_ESTABLISH_RENDEZVOUS:
2059 case RELAY_COMMAND_INTRODUCE1:
2060 case RELAY_COMMAND_INTRODUCE2:
2061 case RELAY_COMMAND_INTRODUCE_ACK:
2062 case RELAY_COMMAND_RENDEZVOUS1:
2063 case RELAY_COMMAND_RENDEZVOUS2:
2064 case RELAY_COMMAND_INTRO_ESTABLISHED:
2065 case RELAY_COMMAND_RENDEZVOUS_ESTABLISHED:
2072 "Received unknown relay command %d. Perhaps the other side is using "
2073 "a newer version of Tor? Dropping.",
2092 static int num_seen=0;
2094 unsigned domain = layer_hint?
LD_APP:LD_EXIT;
2102 log_debug(domain,
"Now seen %d relay cells here (command %d, stream %d).",
2107 "Relay cell length field too long. Closing circuit.");
2108 return - END_CIRC_REASON_TORPROTOCOL;
2113 case RELAY_COMMAND_BEGIN:
2114 case RELAY_COMMAND_CONNECTED:
2115 case RELAY_COMMAND_END:
2116 case RELAY_COMMAND_RESOLVE:
2117 case RELAY_COMMAND_RESOLVED:
2118 case RELAY_COMMAND_BEGIN_DIR:
2120 "stream_id. Dropping.", (
int)rh.
command);
2130 if (rh.
command == RELAY_COMMAND_DATA) {
2134 if (sendme_circuit_data_received(circ, layer_hint) < 0) {
2136 "(relay data) circ deliver_window below 0. Killing.");
2138 return -END_CIRC_REASON_TORPROTOCOL;
2167 layer_hint, &rh)) < 0) {
2177 circ, conn, layer_hint,
2201 int optimistic_data = 0;
2214 rh->
command == RELAY_COMMAND_DATA) {
2218 optimistic_data = 1;
2220 log_warn(
LD_BUG,
"Somehow I had a connection that matched a "
2221 "data cell with stream ID 0.");
2224 rh, cell, circ, conn, layer_hint);
2229 rh, optimistic_data);
2263#define RELAY_PAYLOAD_LENGTH_FOR_RANDOM_SENDMES \
2264 (RELAY_PAYLOAD_SIZE - CELL_PADDING_GAP - 16)
2272 int package_partial,
2279 const bool force_random_bytes =
2284 size_t target_length;
2285 if (force_random_bytes) {
2292 size_t package_length;
2293 if (n_available >= target_length) {
2294 package_length = target_length;
2296 if (package_partial)
2297 package_length = n_available;
2303 tor_assert_nonfatal(package_length > 0);
2321 return package_length;
2338 size_t bytes_to_process, length;
2342 int sending_from_optimistic = 0;
2345 const int sending_optimistically =
2355 "called on conn that's already marked for close at %s:%d.",
2360 if (max_cells && *max_cells <= 0)
2363 repeat_connection_edge_package_raw_inbuf:
2367 log_info(domain,
"conn has no circuit! Closing.");
2376 log_info(domain,
"called with package_window %d. Skipping.",
2382 sending_from_optimistic = entry_conn &&
2383 entry_conn->sending_optimistic_data != NULL;
2385 if (PREDICT_UNLIKELY(sending_from_optimistic)) {
2386 bytes_to_process =
buf_datalen(entry_conn->sending_optimistic_data);
2387 if (PREDICT_UNLIKELY(!bytes_to_process)) {
2388 log_warn(
LD_BUG,
"sending_optimistic_data was non-NULL but empty");
2389 bytes_to_process = connection_get_inbuf_len(
TO_CONN(conn));
2390 sending_from_optimistic = 0;
2393 bytes_to_process = connection_get_inbuf_len(
TO_CONN(conn));
2397 package_partial, circ);
2407 if (PREDICT_UNLIKELY(sending_from_optimistic)) {
2411 buf_get_bytes(entry_conn->sending_optimistic_data, payload, length);
2412 if (!
buf_datalen(entry_conn->sending_optimistic_data)) {
2413 buf_free(entry_conn->sending_optimistic_data);
2414 entry_conn->sending_optimistic_data = NULL;
2420 log_debug(domain,TOR_SOCKET_T_FORMAT
": Packaging %d bytes (%d waiting).",
2422 (
int)length, (
int)connection_get_inbuf_len(
TO_CONN(conn)));
2424 if (sending_optimistically && !sending_from_optimistic) {
2434 payload, length) < 0 ) {
2440 if (sendme_note_stream_data_packaged(conn, length) < 0) {
2442 log_debug(domain,
"conn->package_window reached 0.");
2446 log_debug(domain,
"conn->package_window is now %d",conn->
package_window);
2450 if (*max_cells <= 0)
2455 goto repeat_connection_edge_package_raw_inbuf;
2467 log_debug(layer_hint?
LD_APP:LD_EXIT,
"Too big queue, no resuming");
2474 log_debug(layer_hint?
LD_APP:LD_EXIT,
2475 "Conflux can't send, not resuming edges");
2479 log_debug(layer_hint?
LD_APP:LD_EXIT,
"resuming");
2499 int n_packaging_streams, n_streams_left;
2500 int packaged_this_round;
2506 if (first_conn == NULL) {
2524 int num_streams = 0;
2525 for (conn = first_conn; conn; conn = conn->
next_stream) {
2529 chosen_stream = conn;
2546 n_packaging_streams = 0;
2548 for (conn=chosen_stream; conn; conn = conn->
next_stream) {
2558 if (connection_get_inbuf_len(
TO_CONN(conn)) > 0)
2559 ++n_packaging_streams;
2563 for (conn = first_conn; conn != chosen_stream; conn = conn->
next_stream) {
2572 if (connection_get_inbuf_len(
TO_CONN(conn)) > 0)
2573 ++n_packaging_streams;
2577 if (n_packaging_streams == 0)
2608 cells_per_conn = CEIL_DIV(max_to_package, n_packaging_streams);
2610 packaged_this_round = 0;
2618 for (conn=first_conn; conn; conn=conn->
next_stream) {
2622 int n = cells_per_conn, r;
2627 packaged_this_round += (cells_per_conn-n);
2632 connection_mark_for_close(
TO_CONN(conn));
2637 if (connection_get_inbuf_len(
TO_CONN(conn)))
2653 if (packaged_this_round && packaged_this_round < max_to_package &&
2655 n_packaging_streams = n_streams_left;
2672 unsigned domain = layer_hint ?
LD_APP : LD_EXIT;
2676 log_debug(domain,
"considering circ->package_window %d",
2679 log_debug(domain,
"yes, not-at-origin. stopped.");
2687 log_debug(domain,
"considering layer_hint->package_window %d",
2690 log_debug(domain,
"yes, at-origin. stopped.");
2737 n_cells += c->n_chan_cells.n;
2742 SMARTLIST_FOREACH_END(c);
2744 "%d cells allocated on %d circuits. %d cells leaked.",
2761 TOR_SIMPLEQ_INSERT_TAIL(&queue->head, cell, next);
2771 int exitward,
const cell_t *cell,
2772 int wide_circ_ids,
int use_stats)
2789 TOR_SIMPLEQ_INIT(&queue->head);
2797 while ((cell = TOR_SIMPLEQ_FIRST(&queue->head))) {
2798 TOR_SIMPLEQ_REMOVE_HEAD(&queue->head, next);
2801 TOR_SIMPLEQ_INIT(&queue->head);
2813 TOR_SIMPLEQ_REMOVE_HEAD(&queue->head, next);
2823 TOR_SIMPLEQ_INIT(&queue->head);
2831 while ((cell = TOR_SIMPLEQ_FIRST(&queue->head))) {
2832 TOR_SIMPLEQ_REMOVE_HEAD(&queue->head, next);
2835 TOR_SIMPLEQ_INIT(&queue->head);
2847 TOR_SIMPLEQ_REMOVE_HEAD(&queue->head, next);
2859 cell->circid = circid;
2860 cell->reason = reason;
2864 TOR_SIMPLEQ_INSERT_TAIL(&queue->head, cell, next);
2874 memset(&cell, 0,
sizeof(cell));
2877 cell.
payload[0] = inp->reason;
2878 cell_pack(packed, &cell, wide_circ_ids);
2894cell_queues_get_total_allocation(
void)
2900#define MEMORY_PRESSURE_INTERVAL (30*60)
2907uint64_t oom_stats_n_bytes_removed_cell = 0;
2908uint64_t oom_stats_n_bytes_removed_geoip = 0;
2909uint64_t oom_stats_n_bytes_removed_hsdir = 0;
2917 time_t now = time(NULL);
2918 size_t alloc = cell_queues_get_total_allocation();
2920 alloc += buf_get_total_allocation();
2922 const size_t hs_cache_total = hs_cache_get_total_allocation();
2923 alloc += hs_cache_total;
2924 const size_t geoip_client_cache_total =
2925 geoip_client_cache_total_allocation();
2926 alloc += geoip_client_cache_total;
2927 const size_t dns_cache_total = dns_cache_total_allocation();
2928 alloc += dns_cache_total;
2930 alloc += conflux_total;
2931 if (alloc >=
get_options()->MaxMemInQueues_low_threshold) {
2940 if (hs_cache_total >
get_options()->MaxMemInQueues / 5) {
2941 const size_t bytes_to_remove =
2944 oom_stats_n_bytes_removed_hsdir += removed;
2947 if (geoip_client_cache_total >
get_options()->MaxMemInQueues / 5) {
2948 const size_t bytes_to_remove =
2949 geoip_client_cache_total -
2951 removed = geoip_client_cache_handle_oom(now, bytes_to_remove);
2952 oom_stats_n_bytes_removed_geoip += removed;
2955 if (dns_cache_total >
get_options()->MaxMemInQueues / 5) {
2956 const size_t bytes_to_remove =
2958 removed = dns_cache_handle_oom(now, bytes_to_remove);
2963 if (conflux_total >
get_options()->MaxMemInQueues / 5) {
2964 const size_t bytes_to_remove =
2967 oom_stats_n_bytes_removed_cell += removed;
2971 oom_stats_n_bytes_removed_cell += removed;
2993 const char *file,
int lineno)
2997 circuitmux_t *cmux = NULL;
3017 log_warn(
LD_BUG,
"called on non-attached circuit from %s:%d",
3044 chan->num_p_circuits = 0;
3059 if (circ->
n_chan == chan) {
3087 if (block && can_send) {
3090 }
else if (!block && !can_send) {
3098 if (stream_id && edge->stream_id != stream_id)
3101 if (!conn->
read_event || edge->xoff_received ||
3122 if (wide_circ_ids) {
3133 if (wide_circ_ids) {
3147 circuitmux_t *cmux = NULL;
3162 while (n_flushed < max) {
3164 if (destroy_queue) {
3191 if (circ->
n_chan == chan) {
3217 if (queue->
n == 0) {
3220 circuit_mark_for_close(circ, END_CIRC_REASON_INTERNAL);
3237 uint32_t msec_waiting =
3255 if (circ->
n_chan == chan)
3295 log_debug(
LD_GENERAL,
"Made a circuit inactive.");
3336#define RELAY_CIRC_CELL_QUEUE_SIZE_MIN 50
3338#define RELAY_CIRC_CELL_QUEUE_SIZE_MAX INT32_MAX
3342#define RELAY_CIRC_CELL_QUEUE_SIZE_DEFAULT \
3343 (50 * RELAY_CIRC_CELL_QUEUE_SIZE_MIN)
3347static int32_t max_circuit_cell_queue_size =
3348 RELAY_CIRC_CELL_QUEUE_SIZE_DEFAULT;
3353 RELAY_CIRC_CELL_QUEUE_SIZE_DEFAULT;
3361 RELAY_CIRC_CELL_QUEUE_SIZE_DEFAULT,
3362 RELAY_CIRC_CELL_QUEUE_SIZE_MIN,
3363 RELAY_CIRC_CELL_QUEUE_SIZE_MAX);
3373 RELAY_CIRC_CELL_QUEUE_SIZE_MIN,
3374 RELAY_CIRC_CELL_QUEUE_SIZE_MAX);
3386 max_circuit_cell_queue_size =
3412 int32_t max_queue_size;
3430 max_queue_size = max_circuit_cell_queue_size;
3434 if (PREDICT_UNLIKELY(queue->
n >= max_queue_size)) {
3438 stats_n_circ_max_cell_outq_reached++;
3439 dos_note_circ_max_outq(CONST_TO_OR_CIRCUIT(circ)->p_chan);
3443 "%s circuit has %d cells in its queue, maximum allowed is %d. "
3444 "Closing circuit for safety reasons.",
3445 (exitward) ?
"Outbound" :
"Inbound", queue->
n,
3454 chan->wide_circ_ids, 1);
3469 if (circ_blocked && fromstream) {
3476 update_circuit_on_cmux(circ, direction);
3477 if (queue->
n == 1) {
3480 log_debug(
LD_GENERAL,
"Made a circuit active.");
3501 payload_out[0] = RESOLVED_TYPE_IPV4;
3504 memcpy(payload_out+2, &a, 4);
3507 payload_out[0] = RESOLVED_TYPE_IPV6;
3508 payload_out[1] = 16;
3525 if (payload_len < 2)
3527 if (payload_len < 2+payload[1])
3530 switch (payload[0]) {
3531 case RESOLVED_TYPE_IPV4:
3532 if (payload[1] != 4)
3536 case RESOLVED_TYPE_IPV6:
3537 if (payload[1] != 16)
3545 return payload + 2 + payload[1];
3555 if (circ->
n_chan == chan) {
3570 update_circuit_on_cmux(circ, direction);
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 cell_t *cell)
int pathbias_check_probe_response(circuit_t *circ, const cell_t *cell)
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(struct cell_t *cell, 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)
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)
int circpad_check_received_cell(cell_t *cell, circuit_t *circ, crypt_path_t *layer_hint, const relay_header_t *rh)
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_process_cell(conflux_t *cfx, circuit_t *in_circ, crypt_path_t *layer_hint, cell_t *cell)
int conflux_process_switch_command(circuit_t *in_circ, crypt_path_t *layer_hint, cell_t *cell, relay_header_t *rh)
bool conflux_should_multiplex(int relay_command)
circuit_t * conflux_decide_next_circ(conflux_t *cfx)
conflux_cell_t * conflux_dequeue_cell(conflux_t *cfx)
circuit_t * conflux_decide_circ_for_send(conflux_t *cfx, circuit_t *orig_circ, uint8_t relay_command)
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_linked(circuit_t *circ, crypt_path_t *layer_hint, const cell_t *cell, const uint16_t cell_len)
void conflux_process_link(circuit_t *circ, const cell_t *cell, const uint16_t cell_len)
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, const cell_t *cell)
bool circuit_process_stream_xon(edge_connection_t *conn, const crypt_path_t *layer_hint, const cell_t *cell)
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_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_exit_begin_resolve(cell_t *cell, or_circuit_t *circ)
int connection_half_edge_is_valid_connected(const smartlist_t *half_conns, streamid_t stream_id)
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)
int connection_exit_begin_conn(cell_t *cell, circuit_t *circ)
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)
void crypto_fast_rng_getbytes(crypto_fast_rng_t *rng, uint8_t *out, size_t n)
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(time_t now, 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 RELAY_PAYLOAD_SIZE
#define END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED
#define RELAY_HEADER_SIZE
#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 size_t connection_edge_get_inbuf_bytes_to_package(size_t n_available, int package_partial, circuit_t *on_circuit)
static int connection_edge_process_ordered_relay_cell(cell_t *cell, circuit_t *circ, edge_connection_t *conn, crypt_path_t *layer_hint, relay_header_t *rh)
void destroy_cell_queue_init(destroy_cell_queue_t *queue)
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)
uint64_t stats_n_data_cells_received
void packed_cell_free_(packed_cell_t *cell)
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)
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)
STATIC size_t get_pad_cell_offset(size_t data_len)
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(cell_t *cell, 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
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)
STATIC int connected_cell_parse(const relay_header_t *rh, const cell_t *cell, tor_addr_t *addr_out, int *ttl_out)
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
void relay_header_pack(uint8_t *dest, const relay_header_t *src)
circid_t packed_cell_get_circid(const packed_cell_t *cell, int wide_circ_ids)
static edge_connection_t * relay_lookup_conn(circuit_t *circ, cell_t *cell, cell_direction_t cell_direction, 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)
void relay_header_unpack(relay_header_t *dest, const uint8_t *src)
static int connection_edge_process_relay_cell_not_open(relay_header_t *rh, cell_t *cell, circuit_t *circ, edge_connection_t *conn, crypt_path_t *layer_hint)
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 process_sendme_cell(const relay_header_t *rh, const cell_t *cell, circuit_t *circ, edge_connection_t *conn, crypt_path_t *layer_hint, int domain)
STATIC int handle_relay_cell_command(cell_t *cell, circuit_t *circ, edge_connection_t *conn, crypt_path_t *layer_hint, relay_header_t *rh, int optimistic_data)
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 void circuit_resume_edge_reading(circuit_t *circ, crypt_path_t *layer_hint)
#define RELAY_PAYLOAD_LENGTH_FOR_RANDOM_SENDMES
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)
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 int connection_ap_process_end_not_open(relay_header_t *rh, cell_t *cell, origin_circuit_t *circ, entry_connection_t *conn, 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)
STATIC int resolved_cell_parse(const cell_t *cell, const relay_header_t *rh, smartlist_t *addresses_out, int *errcode_out)
uint64_t stats_n_data_bytes_packaged
STATIC int connection_edge_process_resolved_cell(edge_connection_t *conn, const cell_t *cell, const relay_header_t *rh)
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)
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
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
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)