channel.h 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604
  1. /* * Copyright (c) 2012-2015, The Tor Project, Inc. */
  2. /* See LICENSE for licensing information */
  3. /**
  4. * \file channel.h
  5. * \brief Header file for channel.c
  6. **/
  7. #ifndef TOR_CHANNEL_H
  8. #define TOR_CHANNEL_H
  9. #include "or.h"
  10. #include "circuitmux.h"
  11. /* Channel handler function pointer typedefs */
  12. typedef void (*channel_listener_fn_ptr)(channel_listener_t *, channel_t *);
  13. typedef void (*channel_cell_handler_fn_ptr)(channel_t *, cell_t *);
  14. typedef void (*channel_var_cell_handler_fn_ptr)(channel_t *, var_cell_t *);
  15. struct cell_queue_entry_s;
  16. TOR_SIMPLEQ_HEAD(chan_cell_queue, cell_queue_entry_s) incoming_queue;
  17. typedef struct chan_cell_queue chan_cell_queue_t;
  18. /**
  19. * Channel struct; see the channel_t typedef in or.h. A channel is an
  20. * abstract interface for the OR-to-OR connection, similar to connection_or_t,
  21. * but without the strong coupling to the underlying TLS implementation. They
  22. * are constructed by calling a protocol-specific function to open a channel
  23. * to a particular node, and once constructed support the abstract operations
  24. * defined below.
  25. */
  26. struct channel_s {
  27. /** Magic number for type-checking cast macros */
  28. uint32_t magic;
  29. /** Current channel state */
  30. channel_state_t state;
  31. /** Globally unique ID number for a channel over the lifetime of a Tor
  32. * process.
  33. */
  34. uint64_t global_identifier;
  35. /** Should we expect to see this channel in the channel lists? */
  36. unsigned char registered:1;
  37. /** has this channel ever been open? */
  38. unsigned int has_been_open:1;
  39. /** Why did we close?
  40. */
  41. enum {
  42. CHANNEL_NOT_CLOSING = 0,
  43. CHANNEL_CLOSE_REQUESTED,
  44. CHANNEL_CLOSE_FROM_BELOW,
  45. CHANNEL_CLOSE_FOR_ERROR
  46. } reason_for_closing;
  47. /** State variable for use by the scheduler */
  48. enum {
  49. /*
  50. * The channel is not open, or it has a full output buffer but no queued
  51. * cells.
  52. */
  53. SCHED_CHAN_IDLE = 0,
  54. /*
  55. * The channel has space on its output buffer to write, but no queued
  56. * cells.
  57. */
  58. SCHED_CHAN_WAITING_FOR_CELLS,
  59. /*
  60. * The scheduler has queued cells but no output buffer space to write.
  61. */
  62. SCHED_CHAN_WAITING_TO_WRITE,
  63. /*
  64. * The scheduler has both queued cells and output buffer space, and is
  65. * eligible for the scheduler loop.
  66. */
  67. SCHED_CHAN_PENDING
  68. } scheduler_state;
  69. /** Heap index for use by the scheduler */
  70. int sched_heap_idx;
  71. /** Timestamps for both cell channels and listeners */
  72. time_t timestamp_created; /* Channel created */
  73. time_t timestamp_active; /* Any activity */
  74. /* Methods implemented by the lower layer */
  75. /** Free a channel */
  76. void (*free)(channel_t *);
  77. /** Close an open channel */
  78. void (*close)(channel_t *);
  79. /** Describe the transport subclass for this channel */
  80. const char * (*describe_transport)(channel_t *);
  81. /** Optional method to dump transport-specific statistics on the channel */
  82. void (*dumpstats)(channel_t *, int);
  83. /** Registered handlers for incoming cells */
  84. channel_cell_handler_fn_ptr cell_handler;
  85. channel_var_cell_handler_fn_ptr var_cell_handler;
  86. /* Methods implemented by the lower layer */
  87. /**
  88. * Ask the lower layer for an estimate of the average overhead for
  89. * transmissions on this channel.
  90. */
  91. double (*get_overhead_estimate)(channel_t *);
  92. /*
  93. * Ask the underlying transport what the remote endpoint address is, in
  94. * a tor_addr_t. This is optional and subclasses may leave this NULL.
  95. * If they implement it, they should write the address out to the
  96. * provided tor_addr_t *, and return 1 if successful or 0 if no address
  97. * available.
  98. */
  99. int (*get_remote_addr)(channel_t *, tor_addr_t *);
  100. int (*get_transport_name)(channel_t *chan, char **transport_out);
  101. #define GRD_FLAG_ORIGINAL 1
  102. #define GRD_FLAG_ADDR_ONLY 2
  103. /**
  104. * Get a text description of the remote endpoint; canonicalized if the flag
  105. * GRD_FLAG_ORIGINAL is not set, or the one we originally connected
  106. * to/received from if it is. If GRD_FLAG_ADDR_ONLY is set, we return only
  107. * the original address.
  108. */
  109. const char * (*get_remote_descr)(channel_t *, int);
  110. /** Check if the lower layer has queued writes */
  111. int (*has_queued_writes)(channel_t *);
  112. /**
  113. * If the second param is zero, ask the lower layer if this is
  114. * 'canonical', for a transport-specific definition of canonical; if
  115. * it is 1, ask if the answer to the preceding query is safe to rely
  116. * on.
  117. */
  118. int (*is_canonical)(channel_t *, int);
  119. /** Check if this channel matches a specified extend_info_t */
  120. int (*matches_extend_info)(channel_t *, extend_info_t *);
  121. /** Check if this channel matches a target address when extending */
  122. int (*matches_target)(channel_t *, const tor_addr_t *);
  123. /* Ask the lower layer how many bytes it has queued but not yet sent */
  124. size_t (*num_bytes_queued)(channel_t *);
  125. /* Ask the lower layer how many cells can be written */
  126. int (*num_cells_writeable)(channel_t *);
  127. /* Write a cell to an open channel */
  128. int (*write_cell)(channel_t *, cell_t *);
  129. /** Write a packed cell to an open channel */
  130. int (*write_packed_cell)(channel_t *, packed_cell_t *);
  131. /** Write a variable-length cell to an open channel */
  132. int (*write_var_cell)(channel_t *, var_cell_t *);
  133. /**
  134. * Hash of the public RSA key for the other side's identity key, or
  135. * zeroes if the other side hasn't shown us a valid identity key.
  136. */
  137. char identity_digest[DIGEST_LEN];
  138. /** Nickname of the OR on the other side, or NULL if none. */
  139. char *nickname;
  140. /**
  141. * Linked list of channels with the same identity digest, for the
  142. * digest->channel map
  143. */
  144. TOR_LIST_ENTRY(channel_s) next_with_same_id;
  145. /** List of incoming cells to handle */
  146. chan_cell_queue_t incoming_queue;
  147. /** List of queued outgoing cells */
  148. chan_cell_queue_t outgoing_queue;
  149. /** Circuit mux for circuits sending on this channel */
  150. circuitmux_t *cmux;
  151. /** Circuit ID generation stuff for use by circuitbuild.c */
  152. /**
  153. * When we send CREATE cells along this connection, which half of the
  154. * space should we use?
  155. */
  156. circ_id_type_bitfield_t circ_id_type:2;
  157. /** DOCDOC*/
  158. unsigned wide_circ_ids:1;
  159. /** For how many circuits are we n_chan? What about p_chan? */
  160. unsigned int num_n_circuits, num_p_circuits;
  161. /**
  162. * True iff this channel shouldn't get any new circs attached to it,
  163. * because the connection is too old, or because there's a better one.
  164. * More generally, this flag is used to note an unhealthy connection;
  165. * for example, if a bad connection fails we shouldn't assume that the
  166. * router itself has a problem.
  167. */
  168. unsigned int is_bad_for_new_circs:1;
  169. /** True iff we have decided that the other end of this connection
  170. * is a client. Channels with this flag set should never be used
  171. * to satisfy an EXTEND request. */
  172. unsigned int is_client:1;
  173. /** Set if the channel was initiated remotely (came from a listener) */
  174. unsigned int is_incoming:1;
  175. /** Set by lower layer if this is local; i.e., everything it communicates
  176. * with for this channel returns true for is_local_addr(). This is used
  177. * to decide whether to declare reachability when we receive something on
  178. * this channel in circuitbuild.c
  179. */
  180. unsigned int is_local:1;
  181. /** Have we logged a warning about circID exhaustion on this channel?
  182. * If so, when? */
  183. ratelim_t last_warned_circ_ids_exhausted;
  184. /** Channel timestamps for cell channels */
  185. time_t timestamp_client; /* Client used this, according to relay.c */
  186. time_t timestamp_drained; /* Output queue empty */
  187. time_t timestamp_recv; /* Cell received from lower layer */
  188. time_t timestamp_xmit; /* Cell sent to lower layer */
  189. /** Timestamp for run_connection_housekeeping(). We update this once a
  190. * second when we run housekeeping and find a circuit on this channel, and
  191. * whenever we add a circuit to the channel. */
  192. time_t timestamp_last_had_circuits;
  193. /** Unique ID for measuring direct network status requests;vtunneled ones
  194. * come over a circuit_t, which has a dirreq_id field as well, but is a
  195. * distinct namespace. */
  196. uint64_t dirreq_id;
  197. /** Channel counters for cell channels */
  198. uint64_t n_cells_recved, n_bytes_recved;
  199. uint64_t n_cells_xmitted, n_bytes_xmitted;
  200. /** Our current contribution to the scheduler's total xmit queue */
  201. uint64_t bytes_queued_for_xmit;
  202. /** Number of bytes in this channel's cell queue; does not include
  203. * lower-layer queueing.
  204. */
  205. uint64_t bytes_in_queue;
  206. };
  207. struct channel_listener_s {
  208. /* Current channel listener state */
  209. channel_listener_state_t state;
  210. /* Globally unique ID number for a channel over the lifetime of a Tor
  211. * process.
  212. */
  213. uint64_t global_identifier;
  214. /** Should we expect to see this channel in the channel lists? */
  215. unsigned char registered:1;
  216. /** Why did we close?
  217. */
  218. enum {
  219. CHANNEL_LISTENER_NOT_CLOSING = 0,
  220. CHANNEL_LISTENER_CLOSE_REQUESTED,
  221. CHANNEL_LISTENER_CLOSE_FROM_BELOW,
  222. CHANNEL_LISTENER_CLOSE_FOR_ERROR
  223. } reason_for_closing;
  224. /** Timestamps for both cell channels and listeners */
  225. time_t timestamp_created; /* Channel created */
  226. time_t timestamp_active; /* Any activity */
  227. /* Methods implemented by the lower layer */
  228. /** Free a channel */
  229. void (*free)(channel_listener_t *);
  230. /** Close an open channel */
  231. void (*close)(channel_listener_t *);
  232. /** Describe the transport subclass for this channel */
  233. const char * (*describe_transport)(channel_listener_t *);
  234. /** Optional method to dump transport-specific statistics on the channel */
  235. void (*dumpstats)(channel_listener_t *, int);
  236. /** Registered listen handler to call on incoming connection */
  237. channel_listener_fn_ptr listener;
  238. /** List of pending incoming connections */
  239. smartlist_t *incoming_list;
  240. /** Timestamps for listeners */
  241. time_t timestamp_accepted;
  242. /** Counters for listeners */
  243. uint64_t n_accepted;
  244. };
  245. /* Channel state manipulations */
  246. int channel_state_is_valid(channel_state_t state);
  247. int channel_listener_state_is_valid(channel_listener_state_t state);
  248. int channel_state_can_transition(channel_state_t from, channel_state_t to);
  249. int channel_listener_state_can_transition(channel_listener_state_t from,
  250. channel_listener_state_t to);
  251. const char * channel_state_to_string(channel_state_t state);
  252. const char *
  253. channel_listener_state_to_string(channel_listener_state_t state);
  254. /* Abstract channel operations */
  255. void channel_mark_for_close(channel_t *chan);
  256. void channel_write_cell(channel_t *chan, cell_t *cell);
  257. void channel_write_packed_cell(channel_t *chan, packed_cell_t *cell);
  258. void channel_write_var_cell(channel_t *chan, var_cell_t *cell);
  259. void channel_listener_mark_for_close(channel_listener_t *chan_l);
  260. /* Channel callback registrations */
  261. /* Listener callback */
  262. channel_listener_fn_ptr
  263. channel_listener_get_listener_fn(channel_listener_t *chan);
  264. void channel_listener_set_listener_fn(channel_listener_t *chan,
  265. channel_listener_fn_ptr listener);
  266. /* Incoming cell callbacks */
  267. channel_cell_handler_fn_ptr channel_get_cell_handler(channel_t *chan);
  268. channel_var_cell_handler_fn_ptr
  269. channel_get_var_cell_handler(channel_t *chan);
  270. void channel_set_cell_handlers(channel_t *chan,
  271. channel_cell_handler_fn_ptr cell_handler,
  272. channel_var_cell_handler_fn_ptr
  273. var_cell_handler);
  274. /* Clean up closed channels and channel listeners periodically; these are
  275. * called from run_scheduled_events() in main.c.
  276. */
  277. void channel_run_cleanup(void);
  278. void channel_listener_run_cleanup(void);
  279. /* Close all channels and deallocate everything */
  280. void channel_free_all(void);
  281. /* Dump some statistics in the log */
  282. void channel_dumpstats(int severity);
  283. void channel_listener_dumpstats(int severity);
  284. /* Set the cmux policy on all active channels */
  285. void channel_set_cmux_policy_everywhere(circuitmux_policy_t *pol);
  286. #ifdef TOR_CHANNEL_INTERNAL_
  287. #ifdef CHANNEL_PRIVATE_
  288. /* Cell queue structure (here rather than channel.c for test suite use) */
  289. typedef struct cell_queue_entry_s cell_queue_entry_t;
  290. struct cell_queue_entry_s {
  291. TOR_SIMPLEQ_ENTRY(cell_queue_entry_s) next;
  292. enum {
  293. CELL_QUEUE_FIXED,
  294. CELL_QUEUE_VAR,
  295. CELL_QUEUE_PACKED
  296. } type;
  297. union {
  298. struct {
  299. cell_t *cell;
  300. } fixed;
  301. struct {
  302. var_cell_t *var_cell;
  303. } var;
  304. struct {
  305. packed_cell_t *packed_cell;
  306. } packed;
  307. } u;
  308. };
  309. /* Cell queue functions for benefit of test suite */
  310. STATIC int chan_cell_queue_len(const chan_cell_queue_t *queue);
  311. STATIC void cell_queue_entry_free(cell_queue_entry_t *q, int handed_off);
  312. #endif
  313. /* Channel operations for subclasses and internal use only */
  314. /* Initialize a newly allocated channel - do this first in subclass
  315. * constructors.
  316. */
  317. void channel_init(channel_t *chan);
  318. void channel_init_listener(channel_listener_t *chan);
  319. /* Channel registration/unregistration */
  320. void channel_register(channel_t *chan);
  321. void channel_unregister(channel_t *chan);
  322. /* Channel listener registration/unregistration */
  323. void channel_listener_register(channel_listener_t *chan_l);
  324. void channel_listener_unregister(channel_listener_t *chan_l);
  325. /* Close from below */
  326. void channel_close_from_lower_layer(channel_t *chan);
  327. void channel_close_for_error(channel_t *chan);
  328. void channel_closed(channel_t *chan);
  329. void channel_listener_close_from_lower_layer(channel_listener_t *chan_l);
  330. void channel_listener_close_for_error(channel_listener_t *chan_l);
  331. void channel_listener_closed(channel_listener_t *chan_l);
  332. /* Free a channel */
  333. void channel_free(channel_t *chan);
  334. void channel_listener_free(channel_listener_t *chan_l);
  335. /* State/metadata setters */
  336. void channel_change_state(channel_t *chan, channel_state_t to_state);
  337. void channel_clear_identity_digest(channel_t *chan);
  338. void channel_clear_remote_end(channel_t *chan);
  339. void channel_mark_local(channel_t *chan);
  340. void channel_mark_incoming(channel_t *chan);
  341. void channel_mark_outgoing(channel_t *chan);
  342. void channel_mark_remote(channel_t *chan);
  343. void channel_set_identity_digest(channel_t *chan,
  344. const char *identity_digest);
  345. void channel_set_remote_end(channel_t *chan,
  346. const char *identity_digest,
  347. const char *nickname);
  348. void channel_listener_change_state(channel_listener_t *chan_l,
  349. channel_listener_state_t to_state);
  350. /* Timestamp updates */
  351. void channel_timestamp_created(channel_t *chan);
  352. void channel_timestamp_active(channel_t *chan);
  353. void channel_timestamp_drained(channel_t *chan);
  354. void channel_timestamp_recv(channel_t *chan);
  355. void channel_timestamp_xmit(channel_t *chan);
  356. void channel_listener_timestamp_created(channel_listener_t *chan_l);
  357. void channel_listener_timestamp_active(channel_listener_t *chan_l);
  358. void channel_listener_timestamp_accepted(channel_listener_t *chan_l);
  359. /* Incoming channel handling */
  360. void channel_listener_process_incoming(channel_listener_t *listener);
  361. void channel_listener_queue_incoming(channel_listener_t *listener,
  362. channel_t *incoming);
  363. /* Incoming cell handling */
  364. void channel_process_cells(channel_t *chan);
  365. void channel_queue_cell(channel_t *chan, cell_t *cell);
  366. void channel_queue_var_cell(channel_t *chan, var_cell_t *var_cell);
  367. /* Outgoing cell handling */
  368. void channel_flush_cells(channel_t *chan);
  369. /* Request from lower layer for more cells if available */
  370. MOCK_DECL(ssize_t, channel_flush_some_cells,
  371. (channel_t *chan, ssize_t num_cells));
  372. /* Query if data available on this channel */
  373. int channel_more_to_flush(channel_t *chan);
  374. /* Notify flushed outgoing for dirreq handling */
  375. void channel_notify_flushed(channel_t *chan);
  376. /* Handle stuff we need to do on open like notifying circuits */
  377. void channel_do_open_actions(channel_t *chan);
  378. #endif
  379. /* Helper functions to perform operations on channels */
  380. int channel_send_destroy(circid_t circ_id, channel_t *chan,
  381. int reason);
  382. /*
  383. * Outside abstract interfaces that should eventually get turned into
  384. * something transport/address format independent.
  385. */
  386. channel_t * channel_connect(const tor_addr_t *addr, uint16_t port,
  387. const char *id_digest);
  388. channel_t * channel_get_for_extend(const char *digest,
  389. const tor_addr_t *target_addr,
  390. const char **msg_out,
  391. int *launch_out);
  392. /* Ask which of two channels is better for circuit-extension purposes */
  393. int channel_is_better(time_t now,
  394. channel_t *a, channel_t *b,
  395. int forgive_new_connections);
  396. /** Channel lookups
  397. */
  398. channel_t * channel_find_by_global_id(uint64_t global_identifier);
  399. channel_t * channel_find_by_remote_digest(const char *identity_digest);
  400. /** For things returned by channel_find_by_remote_digest(), walk the list.
  401. */
  402. channel_t * channel_next_with_digest(channel_t *chan);
  403. /*
  404. * Helper macros to lookup state of given channel.
  405. */
  406. #define CHANNEL_IS_CLOSED(chan) (channel_is_in_state((chan), \
  407. CHANNEL_STATE_CLOSED))
  408. #define CHANNEL_IS_OPENING(chan) (channel_is_in_state((chan), \
  409. CHANNEL_STATE_OPENING))
  410. #define CHANNEL_IS_OPEN(chan) (channel_is_in_state((chan), \
  411. CHANNEL_STATE_OPEN))
  412. #define CHANNEL_IS_MAINT(chan) (channel_is_in_state((chan), \
  413. CHANNEL_STATE_MAINT))
  414. #define CHANNEL_IS_CLOSING(chan) (channel_is_in_state((chan), \
  415. CHANNEL_STATE_CLOSING))
  416. #define CHANNEL_IS_ERROR(chan) (channel_is_in_state((chan), \
  417. CHANNEL_STATE_ERROR))
  418. #define CHANNEL_FINISHED(chan) (CHANNEL_IS_CLOSED(chan) || \
  419. CHANNEL_IS_ERROR(chan))
  420. #define CHANNEL_CONDEMNED(chan) (CHANNEL_IS_CLOSING(chan) || \
  421. CHANNEL_FINISHED(chan))
  422. #define CHANNEL_CAN_HANDLE_CELLS(chan) (CHANNEL_IS_OPENING(chan) || \
  423. CHANNEL_IS_OPEN(chan) || \
  424. CHANNEL_IS_MAINT(chan))
  425. static inline int
  426. channel_is_in_state(channel_t *chan, channel_state_t state)
  427. {
  428. return chan->state == state;
  429. }
  430. /*
  431. * Metadata queries/updates
  432. */
  433. const char * channel_describe_transport(channel_t *chan);
  434. MOCK_DECL(void, channel_dump_statistics, (channel_t *chan, int severity));
  435. void channel_dump_transport_statistics(channel_t *chan, int severity);
  436. const char * channel_get_actual_remote_descr(channel_t *chan);
  437. const char * channel_get_actual_remote_address(channel_t *chan);
  438. int channel_get_addr_if_possible(channel_t *chan, tor_addr_t *addr_out);
  439. const char * channel_get_canonical_remote_descr(channel_t *chan);
  440. int channel_has_queued_writes(channel_t *chan);
  441. int channel_is_bad_for_new_circs(channel_t *chan);
  442. void channel_mark_bad_for_new_circs(channel_t *chan);
  443. int channel_is_canonical(channel_t *chan);
  444. int channel_is_canonical_is_reliable(channel_t *chan);
  445. int channel_is_client(channel_t *chan);
  446. int channel_is_local(channel_t *chan);
  447. int channel_is_incoming(channel_t *chan);
  448. int channel_is_outgoing(channel_t *chan);
  449. void channel_mark_client(channel_t *chan);
  450. int channel_matches_extend_info(channel_t *chan, extend_info_t *extend_info);
  451. int channel_matches_target_addr_for_extend(channel_t *chan,
  452. const tor_addr_t *target);
  453. unsigned int channel_num_circuits(channel_t *chan);
  454. MOCK_DECL(void,channel_set_circid_type,(channel_t *chan,
  455. crypto_pk_t *identity_rcvd,
  456. int consider_identity));
  457. void channel_timestamp_client(channel_t *chan);
  458. void channel_update_xmit_queue_size(channel_t *chan);
  459. const char * channel_listener_describe_transport(channel_listener_t *chan_l);
  460. void channel_listener_dump_statistics(channel_listener_t *chan_l,
  461. int severity);
  462. void channel_listener_dump_transport_statistics(channel_listener_t *chan_l,
  463. int severity);
  464. /* Flow control queries */
  465. uint64_t channel_get_global_queue_estimate(void);
  466. int channel_num_cells_writeable(channel_t *chan);
  467. /* Timestamp queries */
  468. time_t channel_when_created(channel_t *chan);
  469. time_t channel_when_last_active(channel_t *chan);
  470. time_t channel_when_last_client(channel_t *chan);
  471. time_t channel_when_last_drained(channel_t *chan);
  472. time_t channel_when_last_recv(channel_t *chan);
  473. time_t channel_when_last_xmit(channel_t *chan);
  474. time_t channel_listener_when_created(channel_listener_t *chan_l);
  475. time_t channel_listener_when_last_active(channel_listener_t *chan_l);
  476. time_t channel_listener_when_last_accepted(channel_listener_t *chan_l);
  477. /* Counter queries */
  478. uint64_t channel_count_recved(channel_t *chan);
  479. uint64_t channel_count_xmitted(channel_t *chan);
  480. uint64_t channel_listener_count_accepted(channel_listener_t *chan_l);
  481. int packed_cell_is_destroy(channel_t *chan,
  482. const packed_cell_t *packed_cell,
  483. circid_t *circid_out);
  484. #endif