54 #include "feature/client/circpathbias.h"
95 #include "core/or/or_circuit_st.h"
131 uint64_t stats_n_circ_max_cell_outq_reached = 0;
193 if (BUG(!or_circ->
p_chan))
198 if (cell->
command == CELL_RELAY_EARLY) {
202 }
else if (cell->
command == CELL_RELAY) {
240 "relay crypt failed. Dropping connection.");
241 return -END_CIRC_REASON_INTERNAL;
251 sendme_record_received_cell_digest(circ, layer_hint);
266 log_debug(
LD_OR,
"Sending away from origin.");
270 "connection_edge_process_relay_cell (away from origin) "
277 log_debug(
LD_OR,
"Sending to origin.");
286 "connection_edge_process_relay_cell (at origin) failed.");
305 "Dropping unrecognized inbound cell on origin circuit.");
311 return -END_CIRC_REASON_TORPROTOCOL;
329 log_warn(
LD_REND,
"Error relaying cell across rendezvous; closing "
332 circuit_mark_for_close(circ, -reason);
339 return -END_CIRC_REASON_TORPROTOCOL;
345 "Didn't recognize a cell, but circ stops here! Closing circuit. "
346 "It was created %ld seconds ago.", (
long)seconds_open);
348 return -END_CIRC_REASON_TORPROTOCOL;
351 log_debug(
LD_OR,
"Passing on unrecognized cell.");
369 const char *filename,
int lineno))
381 log_warn(
LD_BUG,
"outgoing relay cell sent from %s:%d has n_chan==NULL."
382 " Dropping. Circuit is in state %s (%d), and is "
383 "%smarked for close. (%s:%d, %d)", filename, lineno,
395 log_warn(
LD_BUG,
"outgoing relay cell sent from %s:%d on non-origin "
396 "circ. Dropping.", filename, lineno);
412 log_warn(
LD_BUG,
"incoming relay cell at origin circuit. Dropping.");
460 log_debug(LD_EXIT,
"found conn for stream %d.", rh.
stream_id);
466 for (tmpconn =
TO_OR_CIRCUIT(circ)->resolving_streams; tmpconn;
470 log_debug(LD_EXIT,
"found conn for stream %d.", rh.
stream_id);
511 case RELAY_COMMAND_BEGIN:
return "BEGIN";
512 case RELAY_COMMAND_DATA:
return "DATA";
513 case RELAY_COMMAND_END:
return "END";
514 case RELAY_COMMAND_CONNECTED:
return "CONNECTED";
515 case RELAY_COMMAND_SENDME:
return "SENDME";
516 case RELAY_COMMAND_EXTEND:
return "EXTEND";
517 case RELAY_COMMAND_EXTENDED:
return "EXTENDED";
518 case RELAY_COMMAND_TRUNCATE:
return "TRUNCATE";
519 case RELAY_COMMAND_TRUNCATED:
return "TRUNCATED";
520 case RELAY_COMMAND_DROP:
return "DROP";
521 case RELAY_COMMAND_RESOLVE:
return "RESOLVE";
522 case RELAY_COMMAND_RESOLVED:
return "RESOLVED";
523 case RELAY_COMMAND_BEGIN_DIR:
return "BEGIN_DIR";
524 case RELAY_COMMAND_ESTABLISH_INTRO:
return "ESTABLISH_INTRO";
525 case RELAY_COMMAND_ESTABLISH_RENDEZVOUS:
return "ESTABLISH_RENDEZVOUS";
526 case RELAY_COMMAND_INTRODUCE1:
return "INTRODUCE1";
527 case RELAY_COMMAND_INTRODUCE2:
return "INTRODUCE2";
528 case RELAY_COMMAND_RENDEZVOUS1:
return "RENDEZVOUS1";
529 case RELAY_COMMAND_RENDEZVOUS2:
return "RENDEZVOUS2";
530 case RELAY_COMMAND_INTRO_ESTABLISHED:
return "INTRO_ESTABLISHED";
531 case RELAY_COMMAND_RENDEZVOUS_ESTABLISHED:
532 return "RENDEZVOUS_ESTABLISHED";
533 case RELAY_COMMAND_INTRODUCE_ACK:
return "INTRODUCE_ACK";
534 case RELAY_COMMAND_EXTEND2:
return "EXTEND2";
535 case RELAY_COMMAND_EXTENDED2:
return "EXTENDED2";
536 case RELAY_COMMAND_PADDING_NEGOTIATE:
return "PADDING_NEGOTIATE";
537 case RELAY_COMMAND_PADDING_NEGOTIATED:
return "PADDING_NEGOTIATED";
539 tor_snprintf(buf,
sizeof(buf),
"Unrecognized relay command %u",
547 #define CELL_PADDING_GAP 4
584 pad_cell_payload(uint8_t *cell_payload,
size_t data_len)
586 size_t pad_offset, pad_len;
591 if (pad_offset == 0) {
600 cell_payload + pad_offset, pad_len);
614 uint8_t relay_command,
const char *payload,
616 const char *filename,
int lineno))
626 memset(&cell, 0,
sizeof(
cell_t));
638 memset(&rh, 0,
sizeof(rh));
647 pad_cell_payload(cell.
payload, payload_len);
649 log_debug(
LD_OR,
"delivering %d cell %s.", relay_command,
657 if (relay_command == RELAY_COMMAND_END && circ->
dirreq_id)
669 (relay_command == RELAY_COMMAND_EXTEND ||
670 relay_command == RELAY_COMMAND_EXTEND2 ||
671 cpath_layer != origin_circ->
cpath)) {
676 cell.
command = CELL_RELAY_EARLY;
680 log_debug(
LD_OR,
"Sending a RELAY_EARLY cell; %d remaining.",
686 }
else if (relay_command == RELAY_COMMAND_EXTEND ||
687 relay_command == RELAY_COMMAND_EXTEND2) {
693 char *commands = NULL;
698 log_warn(
LD_BUG,
"Uh-oh. We're sending a RELAY_COMMAND_EXTEND cell, "
699 "but we have run out of RELAY_EARLY cells on that circuit. "
700 "Commands sent before: %s", commands);
702 smartlist_free(commands_list);
711 stream_id, filename, lineno) < 0) {
712 log_warn(
LD_BUG,
"circuit_package_relay_cell failed. Closing.");
713 circuit_mark_for_close(circ, END_CIRC_REASON_INTERNAL);
720 if (relay_command == RELAY_COMMAND_DATA) {
721 sendme_record_cell_digest_on_circ(circ, cpath_layer);
738 uint8_t relay_command,
const char *payload,
749 "called on conn that's already marked for close at %s:%d.",
757 log_info(
LD_APP,
"no circ. Closing conn.");
759 END_STREAM_REASON_INTERNAL);
761 log_info(LD_EXIT,
"no circ. Closing conn.");
763 fromconn->
end_reason = END_STREAM_REASON_INTERNAL;
764 connection_mark_for_close(
TO_CONN(fromconn));
775 #ifdef MEASUREMENTS_21206
785 return relay_send_command_from_edge(fromconn->
stream_id, circ,
786 relay_command, payload,
787 payload_len, cpath_layer);
793 #define MAX_RESOLVE_FAILURES 3
800 return reason == END_STREAM_REASON_HIBERNATING ||
801 reason == END_STREAM_REASON_RESOURCELIMIT ||
802 reason == END_STREAM_REASON_EXITPOLICY ||
803 reason == END_STREAM_REASON_RESOLVEFAILED ||
804 reason == END_STREAM_REASON_MISC ||
805 reason == END_STREAM_REASON_NOROUTE;
824 if (reason == END_STREAM_REASON_TORPROTOCOL ||
825 reason == END_STREAM_REASON_DESTROY) {
830 return -END_CIRC_REASON_TORPROTOCOL;
831 }
else if (reason == END_STREAM_REASON_INTERNAL) {
849 reason = END_STREAM_REASON_MISC;
857 const char *chosen_exit_digest =
859 log_info(
LD_APP,
"Address '%s' refused due to '%s'. Considering retrying.",
864 case END_STREAM_REASON_EXITPOLICY: {
882 log_info(
LD_APP,
"Address '%s' resolved to 0.0.0.0. Closing,",
884 connection_mark_unattached_ap(conn, END_STREAM_REASON_TORPROTOCOL);
889 !conn->entry_cfg.ipv4_traffic) ||
891 !conn->entry_cfg.ipv6_traffic)) {
893 "Got an EXITPOLICY failure on a connection with a "
894 "mismatched family. Closing.");
895 connection_mark_unattached_ap(conn, END_STREAM_REASON_TORPROTOCOL);
898 if (
get_options()->ClientDNSRejectInternalAddresses &&
899 tor_addr_is_internal(&addr, 0)) {
900 log_info(
LD_APP,
"Address '%s' resolved to internal. Closing,",
902 connection_mark_unattached_ap(conn, END_STREAM_REASON_TORPROTOCOL);
946 case END_STREAM_REASON_CONNECTREFUSED:
952 case END_STREAM_REASON_RESOLVEFAILED:
953 case END_STREAM_REASON_TIMEOUT:
954 case END_STREAM_REASON_MISC:
955 case END_STREAM_REASON_NOROUTE:
973 "Have tried resolving or connecting to address '%s' "
974 "at %d different places. Giving up.",
981 case END_STREAM_REASON_HIBERNATING:
982 case END_STREAM_REASON_RESOURCELIMIT:
996 log_info(
LD_APP,
"Giving up on retrying; conn can't be handled.");
1000 "Edge got end (%s) before we're connected. Marking for close.",
1005 connection_mark_unattached_ap(conn, control_reason);
1024 int make_reject_all = 0;
1030 if (family == AF_UNSPEC) {
1031 make_reject_all = 1;
1034 make_reject_all = 1;
1037 if (make_reject_all) {
1039 "Exitrouter %s seems to be more restrictive than its exit "
1040 "policy. Not using this router as exit for now.",
1046 if (family != AF_UNSPEC)
1094 if (bytes <= INT32_MAX)
1104 if (bytes <= INT32_MAX)
1105 *ttl_out = (int) bytes;
1130 uint8_t answer_type;
1132 address_ttl_t *addr;
1153 const uint8_t *cp_orig = cp;
1156 answer_type = *cp++;
1158 if (remaining < 2 + answer_len + 4) {
1161 if (answer_type == RESOLVED_TYPE_IPV4) {
1162 if (answer_len != 4) {
1165 addr = tor_malloc_zero(
sizeof(*addr));
1171 }
else if (answer_type == RESOLVED_TYPE_IPV6) {
1172 if (answer_len != 16)
1174 addr = tor_malloc_zero(
sizeof(*addr));
1180 }
else if (answer_type == RESOLVED_TYPE_HOSTNAME) {
1181 if (answer_len == 0) {
1184 addr = tor_malloc_zero(
sizeof(*addr));
1185 addr->hostname = tor_memdup_nulterm(cp, answer_len);
1190 }
else if (answer_type == RESOLVED_TYPE_ERROR_TRANSIENT ||
1191 answer_type == RESOLVED_TYPE_ERROR) {
1192 errcode = answer_type;
1194 cp += answer_len + 4;
1196 cp += answer_len + 4;
1198 tor_assert(((ssize_t)remaining) >= (cp - cp_orig));
1199 remaining -= (cp - cp_orig);
1202 if (errcode && smartlist_len(addrs) == 0) {
1204 *errcode_out = errcode;
1208 smartlist_free(addrs);
1215 smartlist_free(addrs);
1227 address_ttl_t *addr_ipv4 = NULL;
1228 address_ttl_t *addr_ipv6 = NULL;
1229 address_ttl_t *addr_hostname = NULL;
1230 address_ttl_t *addr_best = NULL;
1234 tor_assert(error_code == RESOLVED_TYPE_ERROR ||
1235 error_code == RESOLVED_TYPE_ERROR_TRANSIENT);
1237 error_code,0,NULL,-1,-1);
1243 if (addr->hostname) {
1244 if (!addr_hostname) {
1245 addr_hostname = addr;
1248 if (!addr_ipv4 && conn->entry_cfg.ipv4_traffic) {
1252 if (!addr_ipv6 && conn->entry_cfg.ipv6_traffic) {
1256 } SMARTLIST_FOREACH_END(addr);
1260 if (addr_hostname) {
1262 RESOLVED_TYPE_HOSTNAME,
1263 strlen(addr_hostname->hostname),
1264 (uint8_t*)addr_hostname->hostname,
1265 addr_hostname->ttl,-1);
1268 RESOLVED_TYPE_ERROR,0,NULL,-1,-1);
1273 if (conn->entry_cfg.prefer_ipv6) {
1274 addr_best = addr_ipv6 ? addr_ipv6 : addr_ipv4;
1276 addr_best = addr_ipv4 ? addr_ipv4 : addr_ipv6;
1282 RESOLVED_TYPE_ERROR,0,NULL,-1,-1);
1306 log_fn(LOG_PROTOCOL_WARN,
LD_APP,
"Got a 'resolved' cell while "
1307 "not in state resolve_wait. Dropping.");
1315 "Dropping malformed 'resolved' cell");
1316 connection_mark_unattached_ap(entry_conn, END_STREAM_REASON_TORPROTOCOL);
1320 if (
get_options()->ClientDNSRejectInternalAddresses) {
1321 int orig_len = smartlist_len(resolved_addresses);
1323 if (addr->hostname == NULL && tor_addr_is_internal(&addr->addr, 0)) {
1324 log_info(
LD_APP,
"Got a resolved cell with answer %s; dropping that "
1326 safe_str_client(
fmt_addr(&addr->addr)));
1327 address_ttl_free(addr);
1330 } SMARTLIST_FOREACH_END(addr);
1331 if (orig_len && smartlist_len(resolved_addresses) == 0) {
1332 log_info(
LD_APP,
"Got a resolved cell with only private addresses; "
1335 RESOLVED_TYPE_ERROR_TRANSIENT,
1336 0, NULL, 0, TIME_MAX);
1337 connection_mark_unattached_ap(entry_conn,
1338 END_STREAM_REASON_TORPROTOCOL);
1351 resolved_addresses);
1353 connection_mark_unattached_ap(entry_conn,
1354 END_STREAM_REASON_DONE |
1359 address_ttl_free(addr));
1360 smartlist_free(resolved_addresses);
1376 if (rh->
command == RELAY_COMMAND_END) {
1387 connection_mark_for_close(
TO_CONN(conn));
1393 rh->
command == RELAY_COMMAND_CONNECTED) {
1400 "Got 'connected' while not in state connect_wait. Dropping.");
1403 CONNECTION_AP_EXPECT_NONPENDING(entry_conn);
1405 log_info(
LD_APP,
"'connected' received for circid %u streamid %d "
1406 "after %d seconds.",
1412 "Got a badly formatted connected cell. Closing.");
1414 connection_mark_unattached_ap(entry_conn, END_STREAM_REASON_TORPROTOCOL);
1423 (
get_options()->ClientDNSRejectInternalAddresses &&
1424 tor_addr_is_internal(&addr, 0))) {
1425 log_info(
LD_APP,
"...but it claims the IP address was %s. Closing.",
1428 connection_mark_unattached_ap(entry_conn,
1429 END_STREAM_REASON_TORPROTOCOL);
1433 if ((family == AF_INET && ! entry_conn->entry_cfg.ipv4_traffic) ||
1434 (family == AF_INET6 && ! entry_conn->entry_cfg.ipv6_traffic)) {
1436 "Got a connected cell to %s with unsupported address family."
1439 connection_mark_unattached_ap(entry_conn,
1440 END_STREAM_REASON_TORPROTOCOL);
1459 log_debug(
LD_APP,
"considering");
1460 if (
TO_CONN(conn)->linked_conn &&
1493 connection_mark_for_close(
TO_CONN(conn));
1499 rh->
command == RELAY_COMMAND_RESOLVED) {
1504 "Got an unexpected relay command %d, in state %d (%s). Dropping.",
1526 "Got unexpected relay data from intermediate hop");
1550 ret = sendme_process_circuit_level(layer_hint, circ,
1570 log_info(domain,
"Sendme cell on circ %u valid on half-closed "
1576 log_info(domain,
"SENDME cell dropped, unknown stream (streamid %d).",
1583 ret = sendme_process_stream_level(conn, circ, rh->
length);
1602 connection_mark_for_close(
TO_CONN(conn));
1621 unsigned domain = layer_hint?
LD_APP:LD_EXIT;
1629 log_debug(domain,
"Cell handled as circuit padding");
1635 case RELAY_COMMAND_BEGIN:
1636 case RELAY_COMMAND_BEGIN_DIR:
1640 "Relay begin request unsupported at AP. Dropping.");
1646 "Relay begin request to Hidden Service "
1647 "from intermediary node. Dropping.");
1651 log_fn(LOG_PROTOCOL_WARN, domain,
1652 "Begin cell for known stream. Dropping.");
1655 if (rh->
command == RELAY_COMMAND_BEGIN_DIR &&
1661 static uint64_t next_id = 0;
1666 case RELAY_COMMAND_DATA:
1672 if (sendme_circuit_data_received(circ, layer_hint) < 0) {
1674 "(relay data) circ deliver_window below 0. Killing.");
1676 return -END_CIRC_REASON_TORPROTOCOL;
1684 "stream_id. Dropping.");
1693 "data cell on circ %u valid on half-closed "
1698 log_info(domain,
"data cell dropped, unknown stream (streamid %d).",
1707 if (sendme_stream_data_received(conn) < 0) {
1709 "(relay data) conn deliver_window below 0. Killing.");
1711 return -END_CIRC_REASON_TORPROTOCOL;
1719 if (conn->hs_ident) {
1729 #ifdef MEASUREMENTS_21206
1735 ++(
TO_DIR_CONN(linked_conn)->data_cells_received);
1739 if (!optimistic_data) {
1747 case RELAY_COMMAND_XOFF:
1766 case RELAY_COMMAND_XON:
1785 case RELAY_COMMAND_END:
1786 reason = rh->
length > 0 ?
1797 "end cell (%s) on circ %u valid on half-closed "
1804 log_info(domain,
"end cell (%s) dropped, unknown stream.",
1809 log_info(domain,TOR_SOCKET_T_FORMAT
": end cell (%s) for stream %d. "
1819 "open stream hasn't sent socks answer yet? Closing.");
1828 connection_mark_and_flush(
TO_CONN(conn));
1836 case RELAY_COMMAND_EXTEND:
1837 case RELAY_COMMAND_EXTEND2: {
1838 static uint64_t total_n_extend=0, total_nonearly=0;
1841 log_fn(LOG_PROTOCOL_WARN, domain,
1842 "'extend' cell received for non-zero stream. Dropping.");
1845 if (cell->
command != CELL_RELAY_EARLY &&
1847 #define EARLY_WARNING_INTERVAL 3600
1849 RATELIM_INIT(EARLY_WARNING_INTERVAL);
1851 if (cell->
command == CELL_RELAY) {
1854 double percentage = ((double)total_nonearly)/total_n_extend;
1856 log_fn(LOG_PROTOCOL_WARN, domain,
"EXTEND cell received, "
1857 "but not via RELAY_EARLY. Dropping.%s", m);
1858 log_fn(LOG_PROTOCOL_WARN, domain,
" (We have dropped %.02f%% of "
1859 "all EXTEND cells for this reason)", percentage);
1864 "EXTEND cell received, in a cell with type %d! Dropping.",
1871 case RELAY_COMMAND_EXTENDED:
1872 case RELAY_COMMAND_EXTENDED2:
1875 "'extended' unsupported at non-origin. Dropping.");
1878 log_debug(domain,
"Got an extended cell! Yay.");
1885 "Can't parse EXTENDED cell; killing circuit.");
1886 return -END_CIRC_REASON_TORPROTOCOL;
1890 circuit_mark_for_close(circ, -reason);
1896 log_info(domain,
"circuit_send_next_onion_skin() failed.");
1904 case RELAY_COMMAND_TRUNCATE:
1907 "'truncate' unsupported at origin. Dropping.");
1912 log_warn(
LD_BUG,
"n_chan and n_hop set on the same circuit!");
1913 extend_info_free(circ->
n_hop);
1926 log_debug(LD_EXIT,
"Processed 'truncate', replying.");
1929 payload[0] = (char)END_CIRC_REASON_REQUESTED;
1930 relay_send_command_from_edge(0, circ, RELAY_COMMAND_TRUNCATED,
1931 payload,
sizeof(payload), NULL);
1934 case RELAY_COMMAND_TRUNCATED:
1936 log_fn(LOG_PROTOCOL_WARN, LD_EXIT,
1937 "'truncated' unsupported at non-origin. Dropping.");
1950 case RELAY_COMMAND_CONNECTED:
1953 "'connected' unsupported while open. Closing circ.");
1954 return -END_CIRC_REASON_TORPROTOCOL;
1963 "connected cell on circ %u valid on half-closed "
1970 "'connected' received on circid %u for streamid %d, "
1971 "no conn attached anymore. Ignoring.",
1974 case RELAY_COMMAND_SENDME:
1976 case RELAY_COMMAND_RESOLVE:
1979 "resolve request unsupported at AP; dropping.");
1982 log_fn(LOG_PROTOCOL_WARN, domain,
1983 "resolve request for known stream; dropping.");
1986 log_fn(LOG_PROTOCOL_WARN, domain,
1987 "resolve request on circ with purpose %d; dropping",
1993 case RELAY_COMMAND_RESOLVED:
1995 log_fn(LOG_PROTOCOL_WARN, domain,
1996 "'resolved' unsupported while open. Closing circ.");
1997 return -END_CIRC_REASON_TORPROTOCOL;
2007 "resolved cell on circ %u valid on half-closed "
2014 "'resolved' received, no conn attached anymore. Ignoring.");
2016 case RELAY_COMMAND_ESTABLISH_INTRO:
2017 case RELAY_COMMAND_ESTABLISH_RENDEZVOUS:
2018 case RELAY_COMMAND_INTRODUCE1:
2019 case RELAY_COMMAND_INTRODUCE2:
2020 case RELAY_COMMAND_INTRODUCE_ACK:
2021 case RELAY_COMMAND_RENDEZVOUS1:
2022 case RELAY_COMMAND_RENDEZVOUS2:
2023 case RELAY_COMMAND_INTRO_ESTABLISHED:
2024 case RELAY_COMMAND_RENDEZVOUS_ESTABLISHED:
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;
2053 unsigned domain = layer_hint?
LD_APP:LD_EXIT;
2054 int optimistic_data = 0;
2064 log_debug(domain,
"Now seen %d relay cells here (command %d, stream %d).",
2069 "Relay cell length field too long. Closing circuit.");
2070 return - END_CIRC_REASON_TORPROTOCOL;
2075 case RELAY_COMMAND_BEGIN:
2076 case RELAY_COMMAND_CONNECTED:
2077 case RELAY_COMMAND_END:
2078 case RELAY_COMMAND_RESOLVE:
2079 case RELAY_COMMAND_RESOLVED:
2080 case RELAY_COMMAND_BEGIN_DIR:
2082 "stream_id. Dropping.", (
int)rh.
command);
2098 rh.
command == RELAY_COMMAND_DATA) {
2102 optimistic_data = 1;
2104 log_warn(
LD_BUG,
"Somehow I had a connection that matched a "
2105 "data cell with stream ID 0.");
2108 &rh, cell, circ, conn, layer_hint);
2113 &rh, optimistic_data);
2147 #define RELAY_PAYLOAD_LENGTH_FOR_RANDOM_SENDMES \
2148 (RELAY_PAYLOAD_SIZE - CELL_PADDING_GAP - 16)
2156 int package_partial,
2163 const bool force_random_bytes =
2168 size_t target_length;
2169 if (force_random_bytes) {
2176 size_t package_length;
2177 if (n_available >= target_length) {
2178 package_length = target_length;
2180 if (package_partial)
2181 package_length = n_available;
2187 tor_assert_nonfatal(package_length > 0);
2205 return package_length;
2222 size_t bytes_to_process, length;
2226 int sending_from_optimistic = 0;
2229 const int sending_optimistically =
2239 "called on conn that's already marked for close at %s:%d.",
2244 if (max_cells && *max_cells <= 0)
2247 repeat_connection_edge_package_raw_inbuf:
2251 log_info(domain,
"conn has no circuit! Closing.");
2260 log_info(domain,
"called with package_window %d. Skipping.",
2266 sending_from_optimistic = entry_conn &&
2267 entry_conn->sending_optimistic_data != NULL;
2269 if (PREDICT_UNLIKELY(sending_from_optimistic)) {
2270 bytes_to_process =
buf_datalen(entry_conn->sending_optimistic_data);
2271 if (PREDICT_UNLIKELY(!bytes_to_process)) {
2272 log_warn(
LD_BUG,
"sending_optimistic_data was non-NULL but empty");
2273 bytes_to_process = connection_get_inbuf_len(
TO_CONN(conn));
2274 sending_from_optimistic = 0;
2277 bytes_to_process = connection_get_inbuf_len(
TO_CONN(conn));
2281 package_partial, circ);
2291 if (PREDICT_UNLIKELY(sending_from_optimistic)) {
2295 buf_get_bytes(entry_conn->sending_optimistic_data, payload, length);
2296 if (!
buf_datalen(entry_conn->sending_optimistic_data)) {
2297 buf_free(entry_conn->sending_optimistic_data);
2298 entry_conn->sending_optimistic_data = NULL;
2304 log_debug(domain,TOR_SOCKET_T_FORMAT
": Packaging %d bytes (%d waiting).",
2306 (
int)length, (
int)connection_get_inbuf_len(
TO_CONN(conn)));
2308 if (sending_optimistically && !sending_from_optimistic) {
2317 payload, length) < 0 ) {
2323 if (sendme_note_circuit_data_packaged(circ, cpath_layer) < 0) {
2326 "Circuit package window is below 0. Closing circuit.");
2327 conn->
end_reason = END_STREAM_REASON_TORPROTOCOL;
2332 if (sendme_note_stream_data_packaged(conn, length) < 0) {
2334 log_debug(domain,
"conn->package_window reached 0.");
2338 log_debug(domain,
"conn->package_window is now %d",conn->
package_window);
2342 if (*max_cells <= 0)
2347 goto repeat_connection_edge_package_raw_inbuf;
2359 log_debug(layer_hint?
LD_APP:LD_EXIT,
"Too big queue, no resuming");
2362 log_debug(layer_hint?
LD_APP:LD_EXIT,
"resuming");
2382 int n_packaging_streams, n_streams_left;
2383 int packaged_this_round;
2389 if (first_conn == NULL) {
2421 int num_streams = 0;
2422 for (conn = first_conn; conn; conn = conn->
next_stream) {
2426 chosen_stream = conn;
2443 n_packaging_streams = 0;
2445 for (conn=chosen_stream; conn; conn = conn->
next_stream) {
2450 if (!layer_hint || conn->
cpath_layer == layer_hint) {
2453 if (connection_get_inbuf_len(
TO_CONN(conn)) > 0)
2454 ++n_packaging_streams;
2458 for (conn = first_conn; conn != chosen_stream; conn = conn->
next_stream) {
2462 if (!layer_hint || conn->
cpath_layer == layer_hint) {
2465 if (connection_get_inbuf_len(
TO_CONN(conn)) > 0)
2466 ++n_packaging_streams;
2470 if (n_packaging_streams == 0)
2475 cells_per_conn = CEIL_DIV(max_to_package, n_packaging_streams);
2477 packaged_this_round = 0;
2485 for (conn=first_conn; conn; conn=conn->
next_stream) {
2488 if (!layer_hint || conn->
cpath_layer == layer_hint) {
2489 int n = cells_per_conn, r;
2494 packaged_this_round += (cells_per_conn-n);
2499 connection_mark_for_close(
TO_CONN(conn));
2504 if (connection_get_inbuf_len(
TO_CONN(conn)))
2520 if (packaged_this_round && packaged_this_round < max_to_package &&
2522 max_to_package -= packaged_this_round;
2523 n_packaging_streams = n_streams_left;
2540 unsigned domain = layer_hint ?
LD_APP : LD_EXIT;
2544 log_debug(domain,
"considering circ->package_window %d",
2547 log_debug(domain,
"yes, not-at-origin. stopped.");
2555 log_debug(domain,
"considering layer_hint->package_window %d",
2558 log_debug(domain,
"yes, at-origin. stopped.");
2605 n_cells += c->n_chan_cells.n;
2610 SMARTLIST_FOREACH_END(c);
2612 "%d cells allocated on %d circuits. %d cells leaked.",
2629 TOR_SIMPLEQ_INSERT_TAIL(&queue->head, cell, next);
2639 int exitward,
const cell_t *cell,
2640 int wide_circ_ids,
int use_stats)
2657 TOR_SIMPLEQ_INIT(&queue->head);
2665 while ((cell = TOR_SIMPLEQ_FIRST(&queue->head))) {
2666 TOR_SIMPLEQ_REMOVE_HEAD(&queue->head, next);
2669 TOR_SIMPLEQ_INIT(&queue->head);
2681 TOR_SIMPLEQ_REMOVE_HEAD(&queue->head, next);
2691 TOR_SIMPLEQ_INIT(&queue->head);
2699 while ((cell = TOR_SIMPLEQ_FIRST(&queue->head))) {
2700 TOR_SIMPLEQ_REMOVE_HEAD(&queue->head, next);
2703 TOR_SIMPLEQ_INIT(&queue->head);
2715 TOR_SIMPLEQ_REMOVE_HEAD(&queue->head, next);
2727 cell->circid = circid;
2728 cell->reason = reason;
2732 TOR_SIMPLEQ_INSERT_TAIL(&queue->head, cell, next);
2742 memset(&cell, 0,
sizeof(cell));
2745 cell.
payload[0] = inp->reason;
2746 cell_pack(packed, &cell, wide_circ_ids);
2762 cell_queues_get_total_allocation(
void)
2768 #define MEMORY_PRESSURE_INTERVAL (30*60)
2775 uint64_t oom_stats_n_bytes_removed_cell = 0;
2776 uint64_t oom_stats_n_bytes_removed_geoip = 0;
2777 uint64_t oom_stats_n_bytes_removed_hsdir = 0;
2785 time_t now = time(NULL);
2786 size_t alloc = cell_queues_get_total_allocation();
2788 alloc += buf_get_total_allocation();
2790 const size_t hs_cache_total = hs_cache_get_total_allocation();
2791 alloc += hs_cache_total;
2792 const size_t geoip_client_cache_total =
2793 geoip_client_cache_total_allocation();
2794 alloc += geoip_client_cache_total;
2795 const size_t dns_cache_total = dns_cache_total_allocation();
2796 alloc += dns_cache_total;
2797 if (alloc >=
get_options()->MaxMemInQueues_low_threshold) {
2806 if (hs_cache_total >
get_options()->MaxMemInQueues / 5) {
2807 const size_t bytes_to_remove =
2810 oom_stats_n_bytes_removed_hsdir += removed;
2813 if (geoip_client_cache_total >
get_options()->MaxMemInQueues / 5) {
2814 const size_t bytes_to_remove =
2815 geoip_client_cache_total -
2817 removed = geoip_client_cache_handle_oom(now, bytes_to_remove);
2818 oom_stats_n_bytes_removed_geoip += removed;
2821 if (dns_cache_total >
get_options()->MaxMemInQueues / 5) {
2822 const size_t bytes_to_remove =
2824 removed = dns_cache_handle_oom(now, bytes_to_remove);
2829 oom_stats_n_bytes_removed_cell += removed;
2851 const char *file,
int lineno)
2855 circuitmux_t *cmux = NULL;
2875 log_warn(
LD_BUG,
"called on non-attached circuit from %s:%d",
2902 chan->num_p_circuits = 0;
2920 if (circ->
n_chan == chan) {
2932 if (stream_id && edge->
stream_id != stream_id)
2963 if (wide_circ_ids) {
2974 if (wide_circ_ids) {
2988 circuitmux_t *cmux = NULL;
2994 int streams_blocked;
3003 while (n_flushed < max) {
3005 if (destroy_queue) {
3032 if (circ->
n_chan == chan) {
3058 if (queue->
n == 0) {
3061 circuit_mark_for_close(circ, END_CIRC_REASON_INTERNAL);
3078 uint32_t msec_waiting =
3096 if (circ->
n_chan == chan)
3136 log_debug(
LD_GENERAL,
"Made a circuit inactive.");
3177 #define RELAY_CIRC_CELL_QUEUE_SIZE_MIN 50
3179 #define RELAY_CIRC_CELL_QUEUE_SIZE_MAX INT32_MAX
3183 #define RELAY_CIRC_CELL_QUEUE_SIZE_DEFAULT \
3184 (50 * RELAY_CIRC_CELL_QUEUE_SIZE_MIN)
3188 static int32_t max_circuit_cell_queue_size =
3189 RELAY_CIRC_CELL_QUEUE_SIZE_DEFAULT;
3194 RELAY_CIRC_CELL_QUEUE_SIZE_DEFAULT;
3202 RELAY_CIRC_CELL_QUEUE_SIZE_DEFAULT,
3203 RELAY_CIRC_CELL_QUEUE_SIZE_MIN,
3204 RELAY_CIRC_CELL_QUEUE_SIZE_MAX);
3214 RELAY_CIRC_CELL_QUEUE_SIZE_MIN,
3215 RELAY_CIRC_CELL_QUEUE_SIZE_MAX);
3227 max_circuit_cell_queue_size =
3247 int32_t max_queue_size;
3248 int streams_blocked;
3262 max_queue_size = max_circuit_cell_queue_size;
3265 if (PREDICT_UNLIKELY(queue->
n >= max_queue_size)) {
3269 stats_n_circ_max_cell_outq_reached++;
3270 dos_note_circ_max_outq(CONST_TO_OR_CIRCUIT(circ)->p_chan);
3274 "%s circuit has %d cells in its queue, maximum allowed is %d. "
3275 "Closing circuit for safety reasons.",
3276 (exitward) ?
"Outbound" :
"Inbound", queue->
n,
3278 circuit_mark_for_close(circ, END_CIRC_REASON_RESOURCELIMIT);
3286 chan->wide_circ_ids, 1);
3300 if (streams_blocked && fromstream) {
3305 update_circuit_on_cmux(circ, direction);
3306 if (queue->
n == 1) {
3309 log_debug(
LD_GENERAL,
"Made a circuit active.");
3329 payload_out[0] = RESOLVED_TYPE_IPV4;
3332 memcpy(payload_out+2, &a, 4);
3335 payload_out[0] = RESOLVED_TYPE_IPV6;
3336 payload_out[1] = 16;
3353 if (payload_len < 2)
3355 if (payload_len < 2+payload[1])
3358 switch (payload[0]) {
3359 case RESOLVED_TYPE_IPV4:
3360 if (payload[1] != 4)
3364 case RESOLVED_TYPE_IPV6:
3365 if (payload[1] != 16)
3373 return payload + 2 + payload[1];
3383 if (circ->
n_chan == chan) {
3398 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)
const char * tor_addr_to_str(char *dest, const tor_addr_t *addr, size_t len, int decorate)
int tor_addr_parse(tor_addr_t *addr, const char *src)
int tor_addr_is_null(const tor_addr_t *addr)
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)
void assert_circuit_ok(const circuit_t *c)
smartlist_t * circuit_get_global_list(void)
origin_circuit_t * TO_ORIGIN_CIRCUIT(circuit_t *x)
size_t circuits_handle_oom(size_t current_allocation)
or_circuit_t * TO_OR_CIRCUIT(circuit_t *x)
const char * circuit_state_to_string(int state)
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)
circuit_t * circuitmux_get_first_active_circuit(circuitmux_t *cmux, destroy_cell_queue_t **destroy_queue_out)
void circuitmux_set_num_cells(circuitmux_t *cmux, circuit_t *circ, unsigned int n_cells)
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.
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)
const char * conn_state_to_string(int type, int state)
int connection_state_is_open(connection_t *conn)
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(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.
node_t * node_get_mutable_by_id(const char *identity_digest)
int node_exit_policy_is_exact(const node_t *node, sa_family_t family)
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)
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)
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
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)
static packed_cell_t * destroy_cell_to_packed_cell(destroy_cell_t *inp, int wide_circ_ids)
void circuit_reset_sendme_randomness(circuit_t *circ)
const uint8_t * decode_address_from_payload(tor_addr_t *addr_out, const uint8_t *payload, int payload_len)
uint64_t stats_n_relay_cells_relayed
uint64_t stats_n_circ_max_cell_reached
STATIC packed_cell_t * packed_cell_new(void)
STATIC destroy_cell_t * destroy_cell_queue_pop(destroy_cell_queue_t *queue)
#define MAX_RESOLVE_FAILURES
static packed_cell_t * packed_cell_copy(const cell_t *cell, int wide_circ_ids)
static void remap_event_helper(entry_connection_t *conn, const tor_addr_t *new_addr)
STATIC packed_cell_t * cell_queue_pop(cell_queue_t *queue)
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
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)
static int set_streams_blocked_on_circ(circuit_t *circ, channel_t *chan, int block, streamid_t stream_id)
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)
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)
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)
void append_cell_to_circuit_queue(circuit_t *circ, channel_t *chan, cell_t *cell, cell_direction_t direction, streamid_t fromstream)
int relay_send_command_from_edge_(streamid_t stream_id, circuit_t *circ, uint8_t relay_command, const char *payload, size_t payload_len, crypt_path_t *cpath_layer, const char *filename, int lineno)
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)
const char * relay_command_to_string(uint8_t command)
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 bool relay_crypt_from_last_hop(origin_circuit_t *circ, crypt_path_t *layer_hint)
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
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 address_ttl_free_(address_ttl_t *addr)
static uint32_t get_param_max_circuit_cell_queue_size_out(const networkstatus_t *ns)
#define MEMORY_PRESSURE_INTERVAL
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)
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
uint16_t send_randomness_after_n_cells
struct create_cell_t * n_chan_create_cell
unsigned int have_sent_sufficiently_random_cell
unsigned int streams_blocked_on_n_chan
cell_queue_t n_chan_cells
uint16_t marked_for_close
const char * marked_for_close_file
smartlist_t * testing_cell_stats
struct timeval timestamp_created
unsigned int streams_blocked_on_p_chan
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
struct crypt_path_t * prev
uint32_t inserted_timestamp
struct crypt_path_t * cpath_layer
struct edge_connection_t * next_stream
unsigned int edge_has_sent_end
unsigned int edge_blocked_on_circ
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)