src/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-2013, 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
  18 int circuit_receive_relay_cell(cell_t *cell, circuit_t *circ,
  19                                cell_direction_t cell_direction);
  20
  21 void relay_header_pack(uint8_t *dest, const relay_header_t *src);
  22 void relay_header_unpack(relay_header_t *dest, const uint8_t *src);
  23 int relay_send_command_from_edge_(streamid_t stream_id, circuit_t *circ,
  24                                uint8_t relay_command, const char *payload,
  25                                size_t payload_len, crypt_path_t *cpath_layer,
  26                                const char *filename, int lineno);
  27 #define relay_send_command_from_edge(stream_id, circ, relay_command, payload, \
  28                                      payload_len, cpath_layer)          \
  29   relay_send_command_from_edge_((stream_id), (circ), (relay_command),   \
  30                                 (payload), (payload_len), (cpath_layer), \
  31                                 __FILE__, __LINE__)
  32 int connection_edge_send_command(edge_connection_t *fromconn,
  33                                  uint8_t relay_command, const char *payload,
  34                                  size_t payload_len);
  35 int connection_edge_package_raw_inbuf(edge_connection_t *conn,
  36                                       int package_partial,
  37                                       int *max_cells);
  38 void connection_edge_consider_sending_sendme(edge_connection_t *conn);
  39
  40 extern uint64_t stats_n_data_cells_packaged;
  41 extern uint64_t stats_n_data_bytes_packaged;
  42 extern uint64_t stats_n_data_cells_received;
  43 extern uint64_t stats_n_data_bytes_received;
  44
  45 #ifdef ENABLE_MEMPOOLS
  46 void init_cell_pool(void);
  47 void free_cell_pool(void);
  48 void clean_cell_pool(void);
  49 #endif /* ENABLE_MEMPOOLS */
  50 void dump_cell_pool_usage(int severity);
  51 size_t packed_cell_mem_cost(void);
  52
  53 /* For channeltls.c */
  54 void packed_cell_free(packed_cell_t *cell);
  55
  56 void cell_queue_init(cell_queue_t *queue);
  57 void cell_queue_clear(cell_queue_t *queue);
  58 void cell_queue_append(cell_queue_t *queue, packed_cell_t *cell);
  59 void cell_queue_append_packed_copy(circuit_t *circ, cell_queue_t *queue,
  60                                    int exitward, const cell_t *cell,
  61                                    int wide_circ_ids, int use_stats);
  62
  63 void append_cell_to_circuit_queue(circuit_t *circ, channel_t *chan,
  64                                   cell_t *cell, cell_direction_t direction,
  65                                   streamid_t fromstream);
  66 void channel_unlink_all_circuits(channel_t *chan, smartlist_t *detached_out);
  67 int channel_flush_from_first_active_circuit(channel_t *chan, int max);
  68 void assert_circuit_mux_okay(channel_t *chan);
  69 void update_circuit_on_cmux_(circuit_t *circ, cell_direction_t direction,
  70                              const char *file, int lineno);
  71 #define update_circuit_on_cmux(circ, direction) \
  72   update_circuit_on_cmux_((circ), (direction), SHORT_FILE__, __LINE__)
  73
  74 int append_address_to_payload(uint8_t *payload_out, const tor_addr_t *addr);
  75 const uint8_t *decode_address_from_payload(tor_addr_t *addr_out,
  76                                         const uint8_t *payload,
  77                                         int payload_len);
  78 void circuit_clear_cell_queue(circuit_t *circ, channel_t *chan);
  79
  80 void stream_choice_seed_weak_rng(void);
  81
  82 int relay_crypt(circuit_t *circ, cell_t *cell, cell_direction_t cell_direction,
  83                 crypt_path_t **layer_hint, char *recognized);
  84
  85 circid_t packed_cell_get_circid(const packed_cell_t *cell, int wide_circ_ids);
  86
  87 #ifdef RELAY_PRIVATE
  88 STATIC int connected_cell_parse(const relay_header_t *rh, const cell_t *cell,
  89                          tor_addr_t *addr_out, int *ttl_out);
  90 /** An address-and-ttl tuple as yielded by resolved_cell_parse */
  91 typedef struct address_ttl_s {
  92   tor_addr_t addr;
  93   char *hostname;
  94   int ttl;
  95 } address_ttl_t;
  96 STATIC void address_ttl_free(address_ttl_t *addr);
  97 STATIC int resolved_cell_parse(const cell_t *cell, const relay_header_t *rh,
  98                                smartlist_t *addresses_out, int *errcode_out);
  99 STATIC int connection_edge_process_resolved_cell(edge_connection_t *conn,
 100                                                  const cell_t *cell,
 101                                                  const relay_header_t *rh);
 102 STATIC packed_cell_t *packed_cell_new(void);
 103 STATIC packed_cell_t *cell_queue_pop(cell_queue_t *queue);
 104 STATIC size_t cell_queues_get_total_allocation(void);
 105 STATIC int cell_queues_check_size(void);
 106 #endif
 107
 108 #endif
 109