src/core/or/relay.h

   1 /* Copyright (c) 2001 Matej Pfajfar.
   2  * Copyright (c) 2001-2004, Roger Dingledine.
   3  * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
   4  * Copyright (c) 2007-2021, The Tor Project, Inc. */
   5 /* See LICENSE for licensing information */
   6
   7 /**
   8  * \file relay.h
   9  * \brief Header file for relay.c.
  10  **/
  11
  12 #ifndef TOR_RELAY_H
  13 #define TOR_RELAY_H
  14
  15 extern uint64_t stats_n_relay_cells_relayed;
  16 extern uint64_t stats_n_relay_cells_delivered;
  17 extern uint64_t stats_n_circ_max_cell_reached;
  18 extern uint64_t stats_n_circ_max_cell_outq_reached;
  19
  20 const char *relay_command_to_string(uint8_t command);
  21
  22 void relay_consensus_has_changed(const networkstatus_t *ns);
  23 uint32_t relay_get_param_max_circuit_cell_queue_size(
  24                                      const networkstatus_t *ns);
  25 int circuit_receive_relay_cell(cell_t *cell, circuit_t *circ,
  26                                cell_direction_t cell_direction);
  27 size_t cell_queues_get_total_allocation(void);
  28
  29 void relay_header_pack(uint8_t *dest, const relay_header_t *src);
  30 void relay_header_unpack(relay_header_t *dest, const uint8_t *src);
  31 MOCK_DECL(int,
  32 relay_send_command_from_edge_,(streamid_t stream_id, circuit_t *circ,
  33                                uint8_t relay_command, const char *payload,
  34                                size_t payload_len, crypt_path_t *cpath_layer,
  35                                const char *filename, int lineno));
  36 /* Indicates to relay_send_command_from_edge() that it is a control cell. */
  37 #define CONTROL_CELL_ID 0
  38 #define relay_send_command_from_edge(stream_id, circ, relay_command, payload, \
  39                                      payload_len, cpath_layer)          \
  40   relay_send_command_from_edge_((stream_id), (circ), (relay_command),   \
  41                                 (payload), (payload_len), (cpath_layer), \
  42                                 __FILE__, __LINE__)
  43 int connection_edge_send_command(edge_connection_t *fromconn,
  44                                  uint8_t relay_command, const char *payload,
  45                                  size_t payload_len);
  46 int connection_edge_package_raw_inbuf(edge_connection_t *conn,
  47                                       int package_partial,
  48                                       int *max_cells);
  49 void connection_edge_consider_sending_sendme(edge_connection_t *conn);
  50 void circuit_reset_sendme_randomness(circuit_t *circ);
  51
  52 extern uint64_t stats_n_data_cells_packaged;
  53 extern uint64_t stats_n_data_bytes_packaged;
  54 extern uint64_t stats_n_data_cells_received;
  55 extern uint64_t stats_n_data_bytes_received;
  56
  57 extern uint64_t oom_stats_n_bytes_removed_dns;
  58 extern uint64_t oom_stats_n_bytes_removed_cell;
  59 extern uint64_t oom_stats_n_bytes_removed_geoip;
  60 extern uint64_t oom_stats_n_bytes_removed_hsdir;
  61
  62 void dump_cell_pool_usage(int severity);
  63 size_t packed_cell_mem_cost(void);
  64
  65 int have_been_under_memory_pressure(void);
  66
  67 /* For channeltls.c */
  68 void packed_cell_free_(packed_cell_t *cell);
  69 #define packed_cell_free(cell) \
  70   FREE_AND_NULL(packed_cell_t, packed_cell_free_, (cell))
  71
  72 void cell_queue_init(cell_queue_t *queue);
  73 void cell_queue_clear(cell_queue_t *queue);
  74 void cell_queue_append(cell_queue_t *queue, packed_cell_t *cell);
  75 void cell_queue_append_packed_copy(circuit_t *circ, cell_queue_t *queue,
  76                                    int exitward, const cell_t *cell,
  77                                    int wide_circ_ids, int use_stats);
  78
  79 void append_cell_to_circuit_queue(circuit_t *circ, channel_t *chan,
  80                                   cell_t *cell, cell_direction_t direction,
  81                                   streamid_t fromstream);
  82
  83 void destroy_cell_queue_init(destroy_cell_queue_t *queue);
  84 void destroy_cell_queue_clear(destroy_cell_queue_t *queue);
  85 void destroy_cell_queue_append(destroy_cell_queue_t *queue,
  86                                circid_t circid,
  87                                uint8_t reason);
  88
  89 void channel_unlink_all_circuits(channel_t *chan, smartlist_t *detached_out);
  90 MOCK_DECL(int, channel_flush_from_first_active_circuit,
  91           (channel_t *chan, int max));
  92 MOCK_DECL(int, circuit_package_relay_cell, (cell_t *cell, circuit_t *circ,
  93                            cell_direction_t cell_direction,
  94                            crypt_path_t *layer_hint, streamid_t on_stream,
  95                            const char *filename, int lineno));
  96
  97 void update_circuit_on_cmux_(circuit_t *circ, cell_direction_t direction,
  98                              const char *file, int lineno);
  99 #define update_circuit_on_cmux(circ, direction) \
 100   update_circuit_on_cmux_((circ), (direction), SHORT_FILE__, __LINE__)
 101
 102 int append_address_to_payload(uint8_t *payload_out, const tor_addr_t *addr);
 103 const uint8_t *decode_address_from_payload(tor_addr_t *addr_out,
 104                                         const uint8_t *payload,
 105                                         int payload_len);
 106 void circuit_clear_cell_queue(circuit_t *circ, channel_t *chan);
 107
 108 circid_t packed_cell_get_circid(const packed_cell_t *cell, int wide_circ_ids);
 109 uint8_t packed_cell_get_command(const packed_cell_t *cell, int wide_circ_ids);
 110
 111 #ifdef RELAY_PRIVATE
 112 STATIC int
 113 handle_relay_cell_command(cell_t *cell, circuit_t *circ,
 114                      edge_connection_t *conn, crypt_path_t *layer_hint,
 115                      relay_header_t *rh, int optimistic_data);
 116
 117 STATIC int connected_cell_parse(const relay_header_t *rh, const cell_t *cell,
 118                          tor_addr_t *addr_out, int *ttl_out);
 119 /** An address-and-ttl tuple as yielded by resolved_cell_parse */
 120 typedef struct address_ttl_t {
 121   tor_addr_t addr;
 122   char *hostname;
 123   int ttl;
 124 } address_ttl_t;
 125 STATIC void address_ttl_free_(address_ttl_t *addr);
 126 #define address_ttl_free(addr) \
 127   FREE_AND_NULL(address_ttl_t, address_ttl_free_, (addr))
 128 STATIC int resolved_cell_parse(const cell_t *cell, const relay_header_t *rh,
 129                                smartlist_t *addresses_out, int *errcode_out);
 130 STATIC int connection_edge_process_resolved_cell(edge_connection_t *conn,
 131                                                  const cell_t *cell,
 132                                                  const relay_header_t *rh);
 133 STATIC packed_cell_t *packed_cell_new(void);
 134 STATIC packed_cell_t *cell_queue_pop(cell_queue_t *queue);
 135 STATIC destroy_cell_t *destroy_cell_queue_pop(destroy_cell_queue_t *queue);
 136 STATIC int cell_queues_check_size(void);
 137 STATIC int connection_edge_process_relay_cell(cell_t *cell, circuit_t *circ,
 138                                    edge_connection_t *conn,
 139                                    crypt_path_t *layer_hint);
 140 STATIC size_t get_pad_cell_offset(size_t payload_len);
 141 STATIC size_t connection_edge_get_inbuf_bytes_to_package(size_t n_available,
 142                                                       int package_partial,
 143                                                       circuit_t *on_circuit);
 144
 145 #endif /* defined(RELAY_PRIVATE) */
 146
 147 #endif /* !defined(TOR_RELAY_H) */