Tor  0.4.5.0-alpha-dev
channel.c
Go to the documentation of this file.
1 /* * Copyright (c) 2012-2020, The Tor Project, Inc. */
2 /* See LICENSE for licensing information */
3 
4 /**
5  * \file channel.c
6  *
7  * \brief OR/OP-to-OR channel abstraction layer. A channel's job is to
8  * transfer cells from Tor instance to Tor instance. Currently, there is only
9  * one implementation of the channel abstraction: in channeltls.c.
10  *
11  * Channels are a higher-level abstraction than or_connection_t: In general,
12  * any means that two Tor relays use to exchange cells, or any means that a
13  * relay and a client use to exchange cells, is a channel.
14  *
15  * Channels differ from pluggable transports in that they do not wrap an
16  * underlying protocol over which cells are transmitted: they <em>are</em> the
17  * underlying protocol.
18  *
19  * This module defines the generic parts of the channel_t interface, and
20  * provides the machinery necessary for specialized implementations to be
21  * created. At present, there is one specialized implementation in
22  * channeltls.c, which uses connection_or.c to send cells over a TLS
23  * connection.
24  *
25  * Every channel implementation is responsible for being able to transmit
26  * cells that are passed to it
27  *
28  * For *inbound* cells, the entry point is: channel_process_cell(). It takes a
29  * cell and will pass it to the cell handler set by
30  * channel_set_cell_handlers(). Currently, this is passed back to the command
31  * subsystem which is command_process_cell().
32  *
33  * NOTE: For now, the separation between channels and specialized channels
34  * (like channeltls) is not that well defined. So the channeltls layer calls
35  * channel_process_cell() which originally comes from the connection subsytem.
36  * This should be hopefully be fixed with #23993.
37  *
38  * For *outbound* cells, the entry point is: channel_write_packed_cell().
39  * Only packed cells are dequeued from the circuit queue by the scheduler
40  * which uses channel_flush_from_first_active_circuit() to decide which cells
41  * to flush from which circuit on the channel. They are then passed down to
42  * the channel subsystem. This calls the low layer with the function pointer
43  * .write_packed_cell().
44  *
45  * Each specialized channel (currently only channeltls_t) MUST implement a
46  * series of function found in channel_t. See channel.h for more
47  * documentation.
48  **/
49 
50 /*
51  * Define this so channel.h gives us things only channel_t subclasses
52  * should touch.
53  */
54 #define CHANNEL_OBJECT_PRIVATE
55 
56 /* This one's for stuff only channel.c and the test suite should see */
57 #define CHANNEL_FILE_PRIVATE
58 
59 #include "core/or/or.h"
60 #include "app/config/config.h"
61 #include "core/mainloop/mainloop.h"
62 #include "core/or/channel.h"
63 #include "core/or/channelpadding.h"
64 #include "core/or/channeltls.h"
65 #include "core/or/circuitbuild.h"
66 #include "core/or/circuitlist.h"
67 #include "core/or/circuitmux.h"
68 #include "core/or/circuitstats.h"
69 #include "core/or/connection_or.h" /* For var_cell_free() */
70 #include "core/or/dos.h"
71 #include "core/or/relay.h"
72 #include "core/or/scheduler.h"
78 #include "feature/relay/router.h"
81 #include "feature/stats/rephist.h"
82 #include "lib/evloop/timers.h"
83 #include "lib/time/compat_time.h"
84 
85 #include "core/or/cell_queue_st.h"
86 
87 /* Global lists of channels */
88 
89 /* All channel_t instances */
90 static smartlist_t *all_channels = NULL;
91 
92 /* All channel_t instances not in ERROR or CLOSED states */
93 static smartlist_t *active_channels = NULL;
94 
95 /* All channel_t instances in ERROR or CLOSED states */
96 static smartlist_t *finished_channels = NULL;
97 
98 /* All channel_listener_t instances */
99 static smartlist_t *all_listeners = NULL;
100 
101 /* All channel_listener_t instances in LISTENING state */
102 static smartlist_t *active_listeners = NULL;
103 
104 /* All channel_listener_t instances in LISTENING state */
105 static smartlist_t *finished_listeners = NULL;
106 
107 /** Map from channel->global_identifier to channel. Contains the same
108  * elements as all_channels. */
109 static HT_HEAD(channel_gid_map, channel_t) channel_gid_map = HT_INITIALIZER();
110 
111 static unsigned
112 channel_id_hash(const channel_t *chan)
113 {
114  return (unsigned) chan->global_identifier;
115 }
116 static int
117 channel_id_eq(const channel_t *a, const channel_t *b)
118 {
119  return a->global_identifier == b->global_identifier;
120 }
121 HT_PROTOTYPE(channel_gid_map, channel_t, gidmap_node,
122  channel_id_hash, channel_id_eq);
123 HT_GENERATE2(channel_gid_map, channel_t, gidmap_node,
124  channel_id_hash, channel_id_eq,
126 
127 HANDLE_IMPL(channel, channel_t,)
128 
129 /* Counter for ID numbers */
130 static uint64_t n_channels_allocated = 0;
131 
132 /* Digest->channel map
133  *
134  * Similar to the one used in connection_or.c, this maps from the identity
135  * digest of a remote endpoint to a channel_t to that endpoint. Channels
136  * should be placed here when registered and removed when they close or error.
137  * If more than one channel exists, follow the next_with_same_id pointer
138  * as a linked list.
139  */
140 static HT_HEAD(channel_idmap, channel_idmap_entry_t) channel_identity_map =
141  HT_INITIALIZER();
142 
143 typedef struct channel_idmap_entry_t {
144  HT_ENTRY(channel_idmap_entry_t) node;
145  uint8_t digest[DIGEST_LEN];
146  TOR_LIST_HEAD(channel_list_t, channel_t) channel_list;
147 } channel_idmap_entry_t;
148 
149 static inline unsigned
150 channel_idmap_hash(const channel_idmap_entry_t *ent)
151 {
152  return (unsigned) siphash24g(ent->digest, DIGEST_LEN);
153 }
154 
155 static inline int
156 channel_idmap_eq(const channel_idmap_entry_t *a,
157  const channel_idmap_entry_t *b)
158 {
159  return tor_memeq(a->digest, b->digest, DIGEST_LEN);
160 }
161 
162 HT_PROTOTYPE(channel_idmap, channel_idmap_entry_t, node, channel_idmap_hash,
163  channel_idmap_eq);
164 HT_GENERATE2(channel_idmap, channel_idmap_entry_t, node, channel_idmap_hash,
165  channel_idmap_eq, 0.5, tor_reallocarray_, tor_free_);
166 
167 /* Functions to maintain the digest map */
168 static void channel_remove_from_digest_map(channel_t *chan);
169 
170 static void channel_force_xfree(channel_t *chan);
171 static void channel_free_list(smartlist_t *channels,
172  int mark_for_close);
173 static void channel_listener_free_list(smartlist_t *channels,
174  int mark_for_close);
176 
177 /***********************************
178  * Channel state utility functions *
179  **********************************/
180 
181 /**
182  * Indicate whether a given channel state is valid.
183  */
184 int
186 {
187  int is_valid;
188 
189  switch (state) {
192  case CHANNEL_STATE_ERROR:
193  case CHANNEL_STATE_MAINT:
195  case CHANNEL_STATE_OPEN:
196  is_valid = 1;
197  break;
198  case CHANNEL_STATE_LAST:
199  default:
200  is_valid = 0;
201  }
202 
203  return is_valid;
204 }
205 
206 /**
207  * Indicate whether a given channel listener state is valid.
208  */
209 int
211 {
212  int is_valid;
213 
214  switch (state) {
219  is_valid = 1;
220  break;
222  default:
223  is_valid = 0;
224  }
225 
226  return is_valid;
227 }
228 
229 /**
230  * Indicate whether a channel state transition is valid.
231  *
232  * This function takes two channel states and indicates whether a
233  * transition between them is permitted (see the state definitions and
234  * transition table in or.h at the channel_state_t typedef).
235  */
236 int
238 {
239  int is_valid;
240 
241  switch (from) {
243  is_valid = (to == CHANNEL_STATE_OPENING);
244  break;
246  is_valid = (to == CHANNEL_STATE_CLOSED ||
247  to == CHANNEL_STATE_ERROR);
248  break;
249  case CHANNEL_STATE_ERROR:
250  is_valid = 0;
251  break;
252  case CHANNEL_STATE_MAINT:
253  is_valid = (to == CHANNEL_STATE_CLOSING ||
254  to == CHANNEL_STATE_ERROR ||
255  to == CHANNEL_STATE_OPEN);
256  break;
258  is_valid = (to == CHANNEL_STATE_CLOSING ||
259  to == CHANNEL_STATE_ERROR ||
260  to == CHANNEL_STATE_OPEN);
261  break;
262  case CHANNEL_STATE_OPEN:
263  is_valid = (to == CHANNEL_STATE_CLOSING ||
264  to == CHANNEL_STATE_ERROR ||
265  to == CHANNEL_STATE_MAINT);
266  break;
267  case CHANNEL_STATE_LAST:
268  default:
269  is_valid = 0;
270  }
271 
272  return is_valid;
273 }
274 
275 /**
276  * Indicate whether a channel listener state transition is valid.
277  *
278  * This function takes two channel listener states and indicates whether a
279  * transition between them is permitted (see the state definitions and
280  * transition table in or.h at the channel_listener_state_t typedef).
281  */
282 int
285 {
286  int is_valid;
287 
288  switch (from) {
290  is_valid = (to == CHANNEL_LISTENER_STATE_LISTENING);
291  break;
293  is_valid = (to == CHANNEL_LISTENER_STATE_CLOSED ||
295  break;
297  is_valid = 0;
298  break;
300  is_valid = (to == CHANNEL_LISTENER_STATE_CLOSING ||
302  break;
304  default:
305  is_valid = 0;
306  }
307 
308  return is_valid;
309 }
310 
311 /**
312  * Return a human-readable description for a channel state.
313  */
314 const char *
316 {
317  const char *descr;
318 
319  switch (state) {
321  descr = "closed";
322  break;
324  descr = "closing";
325  break;
326  case CHANNEL_STATE_ERROR:
327  descr = "channel error";
328  break;
329  case CHANNEL_STATE_MAINT:
330  descr = "temporarily suspended for maintenance";
331  break;
333  descr = "opening";
334  break;
335  case CHANNEL_STATE_OPEN:
336  descr = "open";
337  break;
338  case CHANNEL_STATE_LAST:
339  default:
340  descr = "unknown or invalid channel state";
341  }
342 
343  return descr;
344 }
345 
346 /**
347  * Return a human-readable description for a channel listener state.
348  */
349 const char *
351 {
352  const char *descr;
353 
354  switch (state) {
356  descr = "closed";
357  break;
359  descr = "closing";
360  break;
362  descr = "channel listener error";
363  break;
365  descr = "listening";
366  break;
368  default:
369  descr = "unknown or invalid channel listener state";
370  }
371 
372  return descr;
373 }
374 
375 /***************************************
376  * Channel registration/unregistration *
377  ***************************************/
378 
379 /**
380  * Register a channel.
381  *
382  * This function registers a newly created channel in the global lists/maps
383  * of active channels.
384  */
385 void
387 {
388  tor_assert(chan);
390 
391  /* No-op if already registered */
392  if (chan->registered) return;
393 
394  log_debug(LD_CHANNEL,
395  "Registering channel %p (ID %"PRIu64 ") "
396  "in state %s (%d) with digest %s",
397  chan, (chan->global_identifier),
398  channel_state_to_string(chan->state), chan->state,
400 
401  /* Make sure we have all_channels, then add it */
402  if (!all_channels) all_channels = smartlist_new();
403  smartlist_add(all_channels, chan);
404  channel_t *oldval = HT_REPLACE(channel_gid_map, &channel_gid_map, chan);
405  tor_assert(! oldval);
406 
407  /* Is it finished? */
408  if (CHANNEL_FINISHED(chan)) {
409  /* Put it in the finished list, creating it if necessary */
410  if (!finished_channels) finished_channels = smartlist_new();
411  smartlist_add(finished_channels, chan);
413  } else {
414  /* Put it in the active list, creating it if necessary */
415  if (!active_channels) active_channels = smartlist_new();
416  smartlist_add(active_channels, chan);
417 
418  if (!CHANNEL_IS_CLOSING(chan)) {
419  /* It should have a digest set */
420  if (!tor_digest_is_zero(chan->identity_digest)) {
421  /* Yeah, we're good, add it to the map */
423  } else {
424  log_info(LD_CHANNEL,
425  "Channel %p (global ID %"PRIu64 ") "
426  "in state %s (%d) registered with no identity digest",
427  chan, (chan->global_identifier),
428  channel_state_to_string(chan->state), chan->state);
429  }
430  }
431  }
432 
433  /* Mark it as registered */
434  chan->registered = 1;
435 }
436 
437 /**
438  * Unregister a channel.
439  *
440  * This function removes a channel from the global lists and maps and is used
441  * when freeing a closed/errored channel.
442  */
443 void
445 {
446  tor_assert(chan);
447 
448  /* No-op if not registered */
449  if (!(chan->registered)) return;
450 
451  /* Is it finished? */
452  if (CHANNEL_FINISHED(chan)) {
453  /* Get it out of the finished list */
454  if (finished_channels) smartlist_remove(finished_channels, chan);
455  } else {
456  /* Get it out of the active list */
457  if (active_channels) smartlist_remove(active_channels, chan);
458  }
459 
460  /* Get it out of all_channels */
461  if (all_channels) smartlist_remove(all_channels, chan);
462  channel_t *oldval = HT_REMOVE(channel_gid_map, &channel_gid_map, chan);
463  tor_assert(oldval == NULL || oldval == chan);
464 
465  /* Mark it as unregistered */
466  chan->registered = 0;
467 
468  /* Should it be in the digest map? */
469  if (!tor_digest_is_zero(chan->identity_digest) &&
470  !(CHANNEL_CONDEMNED(chan))) {
471  /* Remove it */
473  }
474 }
475 
476 /**
477  * Register a channel listener.
478  *
479  * This function registers a newly created channel listener in the global
480  * lists/maps of active channel listeners.
481  */
482 void
484 {
485  tor_assert(chan_l);
486 
487  /* No-op if already registered */
488  if (chan_l->registered) return;
489 
490  log_debug(LD_CHANNEL,
491  "Registering channel listener %p (ID %"PRIu64 ") "
492  "in state %s (%d)",
493  chan_l, (chan_l->global_identifier),
495  chan_l->state);
496 
497  /* Make sure we have all_listeners, then add it */
498  if (!all_listeners) all_listeners = smartlist_new();
499  smartlist_add(all_listeners, chan_l);
500 
501  /* Is it finished? */
502  if (chan_l->state == CHANNEL_LISTENER_STATE_CLOSED ||
503  chan_l->state == CHANNEL_LISTENER_STATE_ERROR) {
504  /* Put it in the finished list, creating it if necessary */
505  if (!finished_listeners) finished_listeners = smartlist_new();
506  smartlist_add(finished_listeners, chan_l);
507  } else {
508  /* Put it in the active list, creating it if necessary */
509  if (!active_listeners) active_listeners = smartlist_new();
510  smartlist_add(active_listeners, chan_l);
511  }
512 
513  /* Mark it as registered */
514  chan_l->registered = 1;
515 }
516 
517 /**
518  * Unregister a channel listener.
519  *
520  * This function removes a channel listener from the global lists and maps
521  * and is used when freeing a closed/errored channel listener.
522  */
523 void
525 {
526  tor_assert(chan_l);
527 
528  /* No-op if not registered */
529  if (!(chan_l->registered)) return;
530 
531  /* Is it finished? */
532  if (chan_l->state == CHANNEL_LISTENER_STATE_CLOSED ||
533  chan_l->state == CHANNEL_LISTENER_STATE_ERROR) {
534  /* Get it out of the finished list */
535  if (finished_listeners) smartlist_remove(finished_listeners, chan_l);
536  } else {
537  /* Get it out of the active list */
538  if (active_listeners) smartlist_remove(active_listeners, chan_l);
539  }
540 
541  /* Get it out of all_listeners */
542  if (all_listeners) smartlist_remove(all_listeners, chan_l);
543 
544  /* Mark it as unregistered */
545  chan_l->registered = 0;
546 }
547 
548 /*********************************
549  * Channel digest map maintenance
550  *********************************/
551 
552 /**
553  * Add a channel to the digest map.
554  *
555  * This function adds a channel to the digest map and inserts it into the
556  * correct linked list if channels with that remote endpoint identity digest
557  * already exist.
558  */
559 STATIC void
561 {
562  channel_idmap_entry_t *ent, search;
563 
564  tor_assert(chan);
565 
566  /* Assert that the state makes sense */
567  tor_assert(!CHANNEL_CONDEMNED(chan));
568 
569  /* Assert that there is a digest */
571 
572  memcpy(search.digest, chan->identity_digest, DIGEST_LEN);
573  ent = HT_FIND(channel_idmap, &channel_identity_map, &search);
574  if (! ent) {
575  ent = tor_malloc(sizeof(channel_idmap_entry_t));
576  memcpy(ent->digest, chan->identity_digest, DIGEST_LEN);
577  TOR_LIST_INIT(&ent->channel_list);
578  HT_INSERT(channel_idmap, &channel_identity_map, ent);
579  }
580  TOR_LIST_INSERT_HEAD(&ent->channel_list, chan, next_with_same_id);
581 
582  log_debug(LD_CHANNEL,
583  "Added channel %p (global ID %"PRIu64 ") "
584  "to identity map in state %s (%d) with digest %s",
585  chan, (chan->global_identifier),
586  channel_state_to_string(chan->state), chan->state,
588 }
589 
590 /**
591  * Remove a channel from the digest map.
592  *
593  * This function removes a channel from the digest map and the linked list of
594  * channels for that digest if more than one exists.
595  */
596 static void
598 {
599  channel_idmap_entry_t *ent, search;
600 
601  tor_assert(chan);
602 
603  /* Assert that there is a digest */
605 
606  /* Pull it out of its list, wherever that list is */
607  TOR_LIST_REMOVE(chan, next_with_same_id);
608 
609  memcpy(search.digest, chan->identity_digest, DIGEST_LEN);
610  ent = HT_FIND(channel_idmap, &channel_identity_map, &search);
611 
612  /* Look for it in the map */
613  if (ent) {
614  /* Okay, it's here */
615 
616  if (TOR_LIST_EMPTY(&ent->channel_list)) {
617  HT_REMOVE(channel_idmap, &channel_identity_map, ent);
618  tor_free(ent);
619  }
620 
621  log_debug(LD_CHANNEL,
622  "Removed channel %p (global ID %"PRIu64 ") from "
623  "identity map in state %s (%d) with digest %s",
624  chan, (chan->global_identifier),
625  channel_state_to_string(chan->state), chan->state,
627  } else {
628  /* Shouldn't happen */
629  log_warn(LD_BUG,
630  "Trying to remove channel %p (global ID %"PRIu64 ") with "
631  "digest %s from identity map, but couldn't find any with "
632  "that digest",
633  chan, (chan->global_identifier),
635  }
636 }
637 
638 /****************************
639  * Channel lookup functions *
640  ***************************/
641 
642 /**
643  * Find channel by global ID.
644  *
645  * This function searches for a channel by the global_identifier assigned
646  * at initialization time. This identifier is unique for the lifetime of the
647  * Tor process.
648  */
649 channel_t *
650 channel_find_by_global_id(uint64_t global_identifier)
651 {
652  channel_t lookup;
653  channel_t *rv = NULL;
654 
655  lookup.global_identifier = global_identifier;
656  rv = HT_FIND(channel_gid_map, &channel_gid_map, &lookup);
657  if (rv) {
658  tor_assert(rv->global_identifier == global_identifier);
659  }
660 
661  return rv;
662 }
663 
664 /** Return true iff <b>chan</b> matches <b>rsa_id_digest</b> and <b>ed_id</b>.
665  * as its identity keys. If either is NULL, do not check for a match. */
666 static int
668  const char *rsa_id_digest,
669  const ed25519_public_key_t *ed_id)
670 {
671  if (BUG(!chan))
672  return 0;
673  if (rsa_id_digest) {
674  if (tor_memneq(rsa_id_digest, chan->identity_digest, DIGEST_LEN))
675  return 0;
676  }
677  if (ed_id) {
678  if (tor_memneq(ed_id->pubkey, chan->ed25519_identity.pubkey,
680  return 0;
681  }
682  return 1;
683 }
684 
685 /**
686  * Find channel by RSA/Ed25519 identity of of the remote endpoint.
687  *
688  * This function looks up a channel by the digest of its remote endpoint's RSA
689  * identity key. If <b>ed_id</b> is provided and nonzero, only a channel
690  * matching the <b>ed_id</b> will be returned.
691  *
692  * It's possible that more than one channel to a given endpoint exists. Use
693  * channel_next_with_rsa_identity() to walk the list of channels; make sure
694  * to test for Ed25519 identity match too (as appropriate)
695  */
696 channel_t *
697 channel_find_by_remote_identity(const char *rsa_id_digest,
698  const ed25519_public_key_t *ed_id)
699 {
700  channel_t *rv = NULL;
701  channel_idmap_entry_t *ent, search;
702 
703  tor_assert(rsa_id_digest); /* For now, we require that every channel have
704  * an RSA identity, and that every lookup
705  * contain an RSA identity */
706  if (ed_id && ed25519_public_key_is_zero(ed_id)) {
707  /* Treat zero as meaning "We don't care about the presence or absence of
708  * an Ed key", not "There must be no Ed key". */
709  ed_id = NULL;
710  }
711 
712  memcpy(search.digest, rsa_id_digest, DIGEST_LEN);
713  ent = HT_FIND(channel_idmap, &channel_identity_map, &search);
714  if (ent) {
715  rv = TOR_LIST_FIRST(&ent->channel_list);
716  }
717  while (rv && ! channel_remote_identity_matches(rv, rsa_id_digest, ed_id)) {
719  }
720 
721  return rv;
722 }
723 
724 /**
725  * Get next channel with digest.
726  *
727  * This function takes a channel and finds the next channel in the list
728  * with the same digest.
729  */
730 channel_t *
732 {
733  tor_assert(chan);
734 
735  return TOR_LIST_NEXT(chan, next_with_same_id);
736 }
737 
738 /**
739  * Relays run this once an hour to look over our list of channels to other
740  * relays. It prints out some statistics if there are multiple connections
741  * to many relays.
742  *
743  * This function is similar to connection_or_set_bad_connections(),
744  * and probably could be adapted to replace it, if it was modified to actually
745  * take action on any of these connections.
746  */
747 void
749 {
750  channel_idmap_entry_t **iter;
751  channel_t *chan;
752  int total_dirauth_connections = 0, total_dirauths = 0;
753  int total_relay_connections = 0, total_relays = 0, total_canonical = 0;
754  int total_half_canonical = 0;
755  int total_gt_one_connection = 0, total_gt_two_connections = 0;
756  int total_gt_four_connections = 0;
757 
758  HT_FOREACH(iter, channel_idmap, &channel_identity_map) {
759  int connections_to_relay = 0;
760  const char *id_digest = (char *) (*iter)->digest;
761 
762  /* Only consider relay connections */
763  if (!connection_or_digest_is_known_relay(id_digest))
764  continue;
765 
766  total_relays++;
767 
768  const bool is_dirauth = router_digest_is_trusted_dir(id_digest);
769  if (is_dirauth)
770  total_dirauths++;
771 
772  for (chan = TOR_LIST_FIRST(&(*iter)->channel_list); chan;
773  chan = channel_next_with_rsa_identity(chan)) {
774 
775  if (CHANNEL_CONDEMNED(chan) || !CHANNEL_IS_OPEN(chan))
776  continue;
777 
778  connections_to_relay++;
779  total_relay_connections++;
780  if (is_dirauth)
781  total_dirauth_connections++;
782 
783  if (chan->is_canonical(chan)) total_canonical++;
784 
785  if (!chan->is_canonical_to_peer && chan->is_canonical(chan)) {
786  total_half_canonical++;
787  }
788  }
789 
790  if (connections_to_relay > 1) total_gt_one_connection++;
791  if (connections_to_relay > 2) total_gt_two_connections++;
792  if (connections_to_relay > 4) total_gt_four_connections++;
793  }
794 
795  /* Don't bother warning about excessive connections unless we have
796  * at least this many connections, total.
797  */
798 #define MIN_RELAY_CONNECTIONS_TO_WARN 25
799  /* If the average number of connections for a regular relay is more than
800  * this, that's too high.
801  */
802 #define MAX_AVG_RELAY_CONNECTIONS 1.5
803  /* If the average number of connections for a dirauth is more than
804  * this, that's too high.
805  */
806 #define MAX_AVG_DIRAUTH_CONNECTIONS 4
807 
808  /* How many connections total would be okay, given the number of
809  * relays and dirauths that we have connections to? */
810  const int max_tolerable_connections = (int)(
811  (total_relays-total_dirauths) * MAX_AVG_RELAY_CONNECTIONS +
812  total_dirauths * MAX_AVG_DIRAUTH_CONNECTIONS);
813 
814  /* If we average 1.5 or more connections per relay, something is wrong */
815  if (total_relays > MIN_RELAY_CONNECTIONS_TO_WARN &&
816  total_relay_connections > max_tolerable_connections) {
817  log_notice(LD_OR,
818  "Your relay has a very large number of connections to other relays. "
819  "Is your outbound address the same as your relay address? "
820  "Found %d connections to %d relays. Found %d current canonical "
821  "connections, in %d of which we were a non-canonical peer. "
822  "%d relays had more than 1 connection, %d had more than 2, and "
823  "%d had more than 4 connections.",
824  total_relay_connections, total_relays, total_canonical,
825  total_half_canonical, total_gt_one_connection,
826  total_gt_two_connections, total_gt_four_connections);
827  } else {
828  log_info(LD_OR, "Performed connection pruning. "
829  "Found %d connections to %d relays. Found %d current canonical "
830  "connections, in %d of which we were a non-canonical peer. "
831  "%d relays had more than 1 connection, %d had more than 2, and "
832  "%d had more than 4 connections.",
833  total_relay_connections, total_relays, total_canonical,
834  total_half_canonical, total_gt_one_connection,
835  total_gt_two_connections, total_gt_four_connections);
836  }
837 }
838 
839 /**
840  * Initialize a channel.
841  *
842  * This function should be called by subclasses to set up some per-channel
843  * variables. I.e., this is the superclass constructor. Before this, the
844  * channel should be allocated with tor_malloc_zero().
845  */
846 void
848 {
849  tor_assert(chan);
850 
851  /* Assign an ID and bump the counter */
852  chan->global_identifier = ++n_channels_allocated;
853 
854  /* Init timestamp */
855  chan->timestamp_last_had_circuits = time(NULL);
856 
857  /* Warn about exhausted circuit IDs no more than hourly. */
859 
860  /* Initialize list entries. */
861  memset(&chan->next_with_same_id, 0, sizeof(chan->next_with_same_id));
862 
863  /* Timestamp it */
865 
866  /* It hasn't been open yet. */
867  chan->has_been_open = 0;
868 
869  /* Scheduler state is idle */
870  chan->scheduler_state = SCHED_CHAN_IDLE;
871 
872  /* Channel is not in the scheduler heap. */
873  chan->sched_heap_idx = -1;
874 
876 }
877 
878 /**
879  * Initialize a channel listener.
880  *
881  * This function should be called by subclasses to set up some per-channel
882  * variables. I.e., this is the superclass constructor. Before this, the
883  * channel listener should be allocated with tor_malloc_zero().
884  */
885 void
887 {
888  tor_assert(chan_l);
889 
890  /* Assign an ID and bump the counter */
891  chan_l->global_identifier = ++n_channels_allocated;
892 
893  /* Timestamp it */
895 }
896 
897 /**
898  * Free a channel; nothing outside of channel.c and subclasses should call
899  * this - it frees channels after they have closed and been unregistered.
900  */
901 void
903 {
904  if (!chan) return;
905 
906  /* It must be closed or errored */
907  tor_assert(CHANNEL_FINISHED(chan));
908 
909  /* It must be deregistered */
910  tor_assert(!(chan->registered));
911 
912  log_debug(LD_CHANNEL,
913  "Freeing channel %"PRIu64 " at %p",
914  (chan->global_identifier), chan);
915 
916  /* Get this one out of the scheduler */
917  scheduler_release_channel(chan);
918 
919  /*
920  * Get rid of cmux policy before we do anything, so cmux policies don't
921  * see channels in weird half-freed states.
922  */
923  if (chan->cmux) {
924  circuitmux_set_policy(chan->cmux, NULL);
925  }
926 
927  /* Remove all timers and associated handle entries now */
928  timer_free(chan->padding_timer);
929  channel_handle_free(chan->timer_handle);
930  channel_handles_clear(chan);
931 
932  /* Call a free method if there is one */
933  if (chan->free_fn) chan->free_fn(chan);
934 
936 
937  /* Get rid of cmux */
938  if (chan->cmux) {
941  circuitmux_free(chan->cmux);
942  chan->cmux = NULL;
943  }
944 
945  tor_free(chan);
946 }
947 
948 /**
949  * Free a channel listener; nothing outside of channel.c and subclasses
950  * should call this - it frees channel listeners after they have closed and
951  * been unregistered.
952  */
953 void
955 {
956  if (!chan_l) return;
957 
958  log_debug(LD_CHANNEL,
959  "Freeing channel_listener_t %"PRIu64 " at %p",
960  (chan_l->global_identifier),
961  chan_l);
962 
963  /* It must be closed or errored */
966  /* It must be deregistered */
967  tor_assert(!(chan_l->registered));
968 
969  /* Call a free method if there is one */
970  if (chan_l->free_fn) chan_l->free_fn(chan_l);
971 
972  tor_free(chan_l);
973 }
974 
975 /**
976  * Free a channel and skip the state/registration asserts; this internal-
977  * use-only function should be called only from channel_free_all() when
978  * shutting down the Tor process.
979  */
980 static void
982 {
983  tor_assert(chan);
984 
985  log_debug(LD_CHANNEL,
986  "Force-freeing channel %"PRIu64 " at %p",
987  (chan->global_identifier), chan);
988 
989  /* Get this one out of the scheduler */
990  scheduler_release_channel(chan);
991 
992  /*
993  * Get rid of cmux policy before we do anything, so cmux policies don't
994  * see channels in weird half-freed states.
995  */
996  if (chan->cmux) {
997  circuitmux_set_policy(chan->cmux, NULL);
998  }
999 
1000  /* Remove all timers and associated handle entries now */
1001  timer_free(chan->padding_timer);
1002  channel_handle_free(chan->timer_handle);
1003  channel_handles_clear(chan);
1004 
1005  /* Call a free method if there is one */
1006  if (chan->free_fn) chan->free_fn(chan);
1007 
1009 
1010  /* Get rid of cmux */
1011  if (chan->cmux) {
1012  circuitmux_free(chan->cmux);
1013  chan->cmux = NULL;
1014  }
1015 
1016  tor_free(chan);
1017 }
1018 
1019 /**
1020  * Free a channel listener and skip the state/registration asserts; this
1021  * internal-use-only function should be called only from channel_free_all()
1022  * when shutting down the Tor process.
1023  */
1024 static void
1026 {
1027  tor_assert(chan_l);
1028 
1029  log_debug(LD_CHANNEL,
1030  "Force-freeing channel_listener_t %"PRIu64 " at %p",
1031  (chan_l->global_identifier),
1032  chan_l);
1033 
1034  /* Call a free method if there is one */
1035  if (chan_l->free_fn) chan_l->free_fn(chan_l);
1036 
1037  /*
1038  * The incoming list just gets emptied and freed; we request close on
1039  * any channels we find there, but since we got called while shutting
1040  * down they will get deregistered and freed elsewhere anyway.
1041  */
1042  if (chan_l->incoming_list) {
1044  channel_t *, qchan) {
1045  channel_mark_for_close(qchan);
1046  } SMARTLIST_FOREACH_END(qchan);
1047 
1048  smartlist_free(chan_l->incoming_list);
1049  chan_l->incoming_list = NULL;
1050  }
1051 
1052  tor_free(chan_l);
1053 }
1054 
1055 /**
1056  * Set the listener for a channel listener.
1057  *
1058  * This function sets the handler for new incoming channels on a channel
1059  * listener.
1060  */
1061 void
1063  channel_listener_fn_ptr listener)
1064 {
1065  tor_assert(chan_l);
1067 
1068  log_debug(LD_CHANNEL,
1069  "Setting listener callback for channel listener %p "
1070  "(global ID %"PRIu64 ") to %p",
1071  chan_l, (chan_l->global_identifier),
1072  listener);
1073 
1074  chan_l->listener = listener;
1075  if (chan_l->listener) channel_listener_process_incoming(chan_l);
1076 }
1077 
1078 /**
1079  * Return the fixed-length cell handler for a channel.
1080  *
1081  * This function gets the handler for incoming fixed-length cells installed
1082  * on a channel.
1083  */
1084 channel_cell_handler_fn_ptr
1086 {
1087  tor_assert(chan);
1088 
1089  if (CHANNEL_CAN_HANDLE_CELLS(chan))
1090  return chan->cell_handler;
1091 
1092  return NULL;
1093 }
1094 
1095 /**
1096  * Set both cell handlers for a channel.
1097  *
1098  * This function sets both the fixed-length and variable length cell handlers
1099  * for a channel.
1100  */
1101 void
1103  channel_cell_handler_fn_ptr cell_handler)
1104 {
1105  tor_assert(chan);
1106  tor_assert(CHANNEL_CAN_HANDLE_CELLS(chan));
1107 
1108  log_debug(LD_CHANNEL,
1109  "Setting cell_handler callback for channel %p to %p",
1110  chan, cell_handler);
1111 
1112  /* Change them */
1113  chan->cell_handler = cell_handler;
1114 }
1115 
1116 /*
1117  * On closing channels
1118  *
1119  * There are three functions that close channels, for use in
1120  * different circumstances:
1121  *
1122  * - Use channel_mark_for_close() for most cases
1123  * - Use channel_close_from_lower_layer() if you are connection_or.c
1124  * and the other end closes the underlying connection.
1125  * - Use channel_close_for_error() if you are connection_or.c and
1126  * some sort of error has occurred.
1127  */
1128 
1129 /**
1130  * Mark a channel for closure.
1131  *
1132  * This function tries to close a channel_t; it will go into the CLOSING
1133  * state, and eventually the lower layer should put it into the CLOSED or
1134  * ERROR state. Then, channel_run_cleanup() will eventually free it.
1135  */
1136 void
1138 {
1139  tor_assert(chan != NULL);
1140  tor_assert(chan->close != NULL);
1141 
1142  /* If it's already in CLOSING, CLOSED or ERROR, this is a no-op */
1143  if (CHANNEL_CONDEMNED(chan))
1144  return;
1145 
1146  log_debug(LD_CHANNEL,
1147  "Closing channel %p (global ID %"PRIu64 ") "
1148  "by request",
1149  chan, (chan->global_identifier));
1150 
1151  /* Note closing by request from above */
1152  chan->reason_for_closing = CHANNEL_CLOSE_REQUESTED;
1153 
1154  /* Change state to CLOSING */
1156 
1157  /* Tell the lower layer */
1158  chan->close(chan);
1159 
1160  /*
1161  * It's up to the lower layer to change state to CLOSED or ERROR when we're
1162  * ready; we'll try to free channels that are in the finished list from
1163  * channel_run_cleanup(). The lower layer should do this by calling
1164  * channel_closed().
1165  */
1166 }
1167 
1168 /**
1169  * Mark a channel listener for closure.
1170  *
1171  * This function tries to close a channel_listener_t; it will go into the
1172  * CLOSING state, and eventually the lower layer should put it into the CLOSED
1173  * or ERROR state. Then, channel_run_cleanup() will eventually free it.
1174  */
1175 void
1177 {
1178  tor_assert(chan_l != NULL);
1179  tor_assert(chan_l->close != NULL);
1180 
1181  /* If it's already in CLOSING, CLOSED or ERROR, this is a no-op */
1182  if (chan_l->state == CHANNEL_LISTENER_STATE_CLOSING ||
1183  chan_l->state == CHANNEL_LISTENER_STATE_CLOSED ||
1184  chan_l->state == CHANNEL_LISTENER_STATE_ERROR) return;
1185 
1186  log_debug(LD_CHANNEL,
1187  "Closing channel listener %p (global ID %"PRIu64 ") "
1188  "by request",
1189  chan_l, (chan_l->global_identifier));
1190 
1191  /* Note closing by request from above */
1192  chan_l->reason_for_closing = CHANNEL_LISTENER_CLOSE_REQUESTED;
1193 
1194  /* Change state to CLOSING */
1196 
1197  /* Tell the lower layer */
1198  chan_l->close(chan_l);
1199 
1200  /*
1201  * It's up to the lower layer to change state to CLOSED or ERROR when we're
1202  * ready; we'll try to free channels that are in the finished list from
1203  * channel_run_cleanup(). The lower layer should do this by calling
1204  * channel_listener_closed().
1205  */
1206 }
1207 
1208 /**
1209  * Close a channel from the lower layer.
1210  *
1211  * Notify the channel code that the channel is being closed due to a non-error
1212  * condition in the lower layer. This does not call the close() method, since
1213  * the lower layer already knows.
1214  */
1215 void
1217 {
1218  tor_assert(chan != NULL);
1219 
1220  /* If it's already in CLOSING, CLOSED or ERROR, this is a no-op */
1221  if (CHANNEL_CONDEMNED(chan))
1222  return;
1223 
1224  log_debug(LD_CHANNEL,
1225  "Closing channel %p (global ID %"PRIu64 ") "
1226  "due to lower-layer event",
1227  chan, (chan->global_identifier));
1228 
1229  /* Note closing by event from below */
1230  chan->reason_for_closing = CHANNEL_CLOSE_FROM_BELOW;
1231 
1232  /* Change state to CLOSING */
1234 }
1235 
1236 /**
1237  * Notify that the channel is being closed due to an error condition.
1238  *
1239  * This function is called by the lower layer implementing the transport
1240  * when a channel must be closed due to an error condition. This does not
1241  * call the channel's close method, since the lower layer already knows.
1242  */
1243 void
1245 {
1246  tor_assert(chan != NULL);
1247 
1248  /* If it's already in CLOSING, CLOSED or ERROR, this is a no-op */
1249  if (CHANNEL_CONDEMNED(chan))
1250  return;
1251 
1252  log_debug(LD_CHANNEL,
1253  "Closing channel %p due to lower-layer error",
1254  chan);
1255 
1256  /* Note closing by event from below */
1257  chan->reason_for_closing = CHANNEL_CLOSE_FOR_ERROR;
1258 
1259  /* Change state to CLOSING */
1261 }
1262 
1263 /**
1264  * Notify that the lower layer is finished closing the channel.
1265  *
1266  * This function should be called by the lower layer when a channel
1267  * is finished closing and it should be regarded as inactive and
1268  * freed by the channel code.
1269  */
1270 void
1272 {
1273  tor_assert(chan);
1274  tor_assert(CHANNEL_CONDEMNED(chan));
1275 
1276  /* No-op if already inactive */
1277  if (CHANNEL_FINISHED(chan))
1278  return;
1279 
1280  /* Inform any pending (not attached) circs that they should
1281  * give up. */
1282  if (! chan->has_been_open)
1283  circuit_n_chan_done(chan, 0, 0);
1284 
1285  /* Now close all the attached circuits on it. */
1286  circuit_unlink_all_from_channel(chan, END_CIRC_REASON_CHANNEL_CLOSED);
1287 
1288  if (chan->reason_for_closing != CHANNEL_CLOSE_FOR_ERROR) {
1290  } else {
1292  }
1293 }
1294 
1295 /**
1296  * Clear the identity_digest of a channel.
1297  *
1298  * This function clears the identity digest of the remote endpoint for a
1299  * channel; this is intended for use by the lower layer.
1300  */
1301 void
1303 {
1304  int state_not_in_map;
1305 
1306  tor_assert(chan);
1307 
1308  log_debug(LD_CHANNEL,
1309  "Clearing remote endpoint digest on channel %p with "
1310  "global ID %"PRIu64,
1311  chan, (chan->global_identifier));
1312 
1313  state_not_in_map = CHANNEL_CONDEMNED(chan);
1314 
1315  if (!state_not_in_map && chan->registered &&
1317  /* if it's registered get it out of the digest map */
1319 
1320  memset(chan->identity_digest, 0,
1321  sizeof(chan->identity_digest));
1322 }
1323 
1324 /**
1325  * Set the identity_digest of a channel.
1326  *
1327  * This function sets the identity digest of the remote endpoint for a
1328  * channel; this is intended for use by the lower layer.
1329  */
1330 void
1332  const char *identity_digest,
1333  const ed25519_public_key_t *ed_identity)
1334 {
1335  int was_in_digest_map, should_be_in_digest_map, state_not_in_map;
1336 
1337  tor_assert(chan);
1338 
1339  log_debug(LD_CHANNEL,
1340  "Setting remote endpoint digest on channel %p with "
1341  "global ID %"PRIu64 " to digest %s",
1342  chan, (chan->global_identifier),
1343  identity_digest ?
1344  hex_str(identity_digest, DIGEST_LEN) : "(null)");
1345 
1346  state_not_in_map = CHANNEL_CONDEMNED(chan);
1347 
1348  was_in_digest_map =
1349  !state_not_in_map &&
1350  chan->registered &&
1352  should_be_in_digest_map =
1353  !state_not_in_map &&
1354  chan->registered &&
1355  (identity_digest &&
1356  !tor_digest_is_zero(identity_digest));
1357 
1358  if (was_in_digest_map)
1359  /* We should always remove it; we'll add it back if we're writing
1360  * in a new digest.
1361  */
1363 
1364  if (identity_digest) {
1365  memcpy(chan->identity_digest,
1366  identity_digest,
1367  sizeof(chan->identity_digest));
1368  } else {
1369  memset(chan->identity_digest, 0,
1370  sizeof(chan->identity_digest));
1371  }
1372  if (ed_identity) {
1373  memcpy(&chan->ed25519_identity, ed_identity, sizeof(*ed_identity));
1374  } else {
1375  memset(&chan->ed25519_identity, 0, sizeof(*ed_identity));
1376  }
1377 
1378  /* Put it in the digest map if we should */
1379  if (should_be_in_digest_map)
1381 }
1382 
1383 /**
1384  * Clear the remote end metadata (identity_digest) of a channel.
1385  *
1386  * This function clears all the remote end info from a channel; this is
1387  * intended for use by the lower layer.
1388  */
1389 void
1391 {
1392  int state_not_in_map;
1393 
1394  tor_assert(chan);
1395 
1396  log_debug(LD_CHANNEL,
1397  "Clearing remote endpoint identity on channel %p with "
1398  "global ID %"PRIu64,
1399  chan, (chan->global_identifier));
1400 
1401  state_not_in_map = CHANNEL_CONDEMNED(chan);
1402 
1403  if (!state_not_in_map && chan->registered &&
1405  /* if it's registered get it out of the digest map */
1407 
1408  memset(chan->identity_digest, 0,
1409  sizeof(chan->identity_digest));
1410 }
1411 
1412 /**
1413  * Write to a channel the given packed cell.
1414  *
1415  * Two possible errors can happen. Either the channel is not opened or the
1416  * lower layer (specialized channel) failed to write it. In both cases, it is
1417  * the caller responsibility to free the cell.
1418  */
1419 static int
1421 {
1422  int ret = -1;
1423  size_t cell_bytes;
1424  uint8_t command = packed_cell_get_command(cell, chan->wide_circ_ids);
1425 
1426  tor_assert(chan);
1427  tor_assert(cell);
1428 
1429  /* Assert that the state makes sense for a cell write */
1430  tor_assert(CHANNEL_CAN_HANDLE_CELLS(chan));
1431 
1432  {
1433  circid_t circ_id;
1434  if (packed_cell_is_destroy(chan, cell, &circ_id)) {
1435  channel_note_destroy_not_pending(chan, circ_id);
1436  }
1437  }
1438 
1439  /* For statistical purposes, figure out how big this cell is */
1440  cell_bytes = get_cell_network_size(chan->wide_circ_ids);
1441 
1442  /* Can we send it right out? If so, try */
1443  if (!CHANNEL_IS_OPEN(chan)) {
1444  goto done;
1445  }
1446 
1447  /* Write the cell on the connection's outbuf. */
1448  if (chan->write_packed_cell(chan, cell) < 0) {
1449  goto done;
1450  }
1451  /* Timestamp for transmission */
1452  channel_timestamp_xmit(chan);
1453  /* Update the counter */
1454  ++(chan->n_cells_xmitted);
1455  chan->n_bytes_xmitted += cell_bytes;
1456  /* Successfully sent the cell. */
1457  ret = 0;
1458 
1459  /* Update padding statistics for the packed codepath.. */
1461  if (command == CELL_PADDING)
1463  if (chan->padding_enabled) {
1465  if (command == CELL_PADDING)
1467  }
1468 
1469  done:
1470  return ret;
1471 }
1472 
1473 /**
1474  * Write a packed cell to a channel.
1475  *
1476  * Write a packed cell to a channel using the write_cell() method. This is
1477  * called by the transport-independent code to deliver a packed cell to a
1478  * channel for transmission.
1479  *
1480  * Return 0 on success else a negative value. In both cases, the caller should
1481  * not access the cell anymore, it is freed both on success and error.
1482  */
1483 int
1485 {
1486  int ret = -1;
1487 
1488  tor_assert(chan);
1489  tor_assert(cell);
1490 
1491  if (CHANNEL_IS_CLOSING(chan)) {
1492  log_debug(LD_CHANNEL, "Discarding %p on closing channel %p with "
1493  "global ID %"PRIu64, cell, chan,
1494  (chan->global_identifier));
1495  goto end;
1496  }
1497  log_debug(LD_CHANNEL,
1498  "Writing %p to channel %p with global ID "
1499  "%"PRIu64, cell, chan, (chan->global_identifier));
1500 
1501  ret = write_packed_cell(chan, cell);
1502 
1503  end:
1504  /* Whatever happens, we free the cell. Either an error occurred or the cell
1505  * was put on the connection outbuf, both cases we have ownership of the
1506  * cell and we free it. */
1507  packed_cell_free(cell);
1508  return ret;
1509 }
1510 
1511 /**
1512  * Change channel state.
1513  *
1514  * This internal and subclass use only function is used to change channel
1515  * state, performing all transition validity checks and whatever actions
1516  * are appropriate to the state transition in question.
1517  */
1518 static void
1520 {
1521  channel_state_t from_state;
1522  unsigned char was_active, is_active;
1523  unsigned char was_in_id_map, is_in_id_map;
1524 
1525  tor_assert(chan);
1526  from_state = chan->state;
1527 
1528  tor_assert(channel_state_is_valid(from_state));
1530  tor_assert(channel_state_can_transition(chan->state, to_state));
1531 
1532  /* Check for no-op transitions */
1533  if (from_state == to_state) {
1534  log_debug(LD_CHANNEL,
1535  "Got no-op transition from \"%s\" to itself on channel %p"
1536  "(global ID %"PRIu64 ")",
1537  channel_state_to_string(to_state),
1538  chan, (chan->global_identifier));
1539  return;
1540  }
1541 
1542  /* If we're going to a closing or closed state, we must have a reason set */
1543  if (to_state == CHANNEL_STATE_CLOSING ||
1544  to_state == CHANNEL_STATE_CLOSED ||
1545  to_state == CHANNEL_STATE_ERROR) {
1546  tor_assert(chan->reason_for_closing != CHANNEL_NOT_CLOSING);
1547  }
1548 
1549  log_debug(LD_CHANNEL,
1550  "Changing state of channel %p (global ID %"PRIu64
1551  ") from \"%s\" to \"%s\"",
1552  chan,
1553  (chan->global_identifier),
1555  channel_state_to_string(to_state));
1556 
1557  chan->state = to_state;
1558 
1559  /* Need to add to the right lists if the channel is registered */
1560  if (chan->registered) {
1561  was_active = !(from_state == CHANNEL_STATE_CLOSED ||
1562  from_state == CHANNEL_STATE_ERROR);
1563  is_active = !(to_state == CHANNEL_STATE_CLOSED ||
1564  to_state == CHANNEL_STATE_ERROR);
1565 
1566  /* Need to take off active list and put on finished list? */
1567  if (was_active && !is_active) {
1568  if (active_channels) smartlist_remove(active_channels, chan);
1569  if (!finished_channels) finished_channels = smartlist_new();
1570  smartlist_add(finished_channels, chan);
1572  }
1573  /* Need to put on active list? */
1574  else if (!was_active && is_active) {
1575  if (finished_channels) smartlist_remove(finished_channels, chan);
1576  if (!active_channels) active_channels = smartlist_new();
1577  smartlist_add(active_channels, chan);
1578  }
1579 
1580  if (!tor_digest_is_zero(chan->identity_digest)) {
1581  /* Now we need to handle the identity map */
1582  was_in_id_map = !(from_state == CHANNEL_STATE_CLOSING ||
1583  from_state == CHANNEL_STATE_CLOSED ||
1584  from_state == CHANNEL_STATE_ERROR);
1585  is_in_id_map = !(to_state == CHANNEL_STATE_CLOSING ||
1586  to_state == CHANNEL_STATE_CLOSED ||
1587  to_state == CHANNEL_STATE_ERROR);
1588 
1589  if (!was_in_id_map && is_in_id_map) channel_add_to_digest_map(chan);
1590  else if (was_in_id_map && !is_in_id_map)
1592  }
1593  }
1594 
1595  /*
1596  * If we're going to a closed/closing state, we don't need scheduling any
1597  * more; in CHANNEL_STATE_MAINT we can't accept writes.
1598  */
1599  if (to_state == CHANNEL_STATE_CLOSING ||
1600  to_state == CHANNEL_STATE_CLOSED ||
1601  to_state == CHANNEL_STATE_ERROR) {
1602  scheduler_release_channel(chan);
1603  } else if (to_state == CHANNEL_STATE_MAINT) {
1605  }
1606 }
1607 
1608 /**
1609  * As channel_change_state_, but change the state to any state but open.
1610  */
1611 void
1613 {
1614  tor_assert(to_state != CHANNEL_STATE_OPEN);
1615  channel_change_state_(chan, to_state);
1616 }
1617 
1618 /**
1619  * As channel_change_state, but change the state to open.
1620  */
1621 void
1623 {
1625 
1626  /* Tell circuits if we opened and stuff */
1628  chan->has_been_open = 1;
1629 }
1630 
1631 /**
1632  * Change channel listener state.
1633  *
1634  * This internal and subclass use only function is used to change channel
1635  * listener state, performing all transition validity checks and whatever
1636  * actions are appropriate to the state transition in question.
1637  */
1638 void
1640  channel_listener_state_t to_state)
1641 {
1642  channel_listener_state_t from_state;
1643  unsigned char was_active, is_active;
1644 
1645  tor_assert(chan_l);
1646  from_state = chan_l->state;
1647 
1651 
1652  /* Check for no-op transitions */
1653  if (from_state == to_state) {
1654  log_debug(LD_CHANNEL,
1655  "Got no-op transition from \"%s\" to itself on channel "
1656  "listener %p (global ID %"PRIu64 ")",
1658  chan_l, (chan_l->global_identifier));
1659  return;
1660  }
1661 
1662  /* If we're going to a closing or closed state, we must have a reason set */
1663  if (to_state == CHANNEL_LISTENER_STATE_CLOSING ||
1664  to_state == CHANNEL_LISTENER_STATE_CLOSED ||
1665  to_state == CHANNEL_LISTENER_STATE_ERROR) {
1666  tor_assert(chan_l->reason_for_closing != CHANNEL_LISTENER_NOT_CLOSING);
1667  }
1668 
1669  log_debug(LD_CHANNEL,
1670  "Changing state of channel listener %p (global ID %"PRIu64
1671  "from \"%s\" to \"%s\"",
1672  chan_l, (chan_l->global_identifier),
1675 
1676  chan_l->state = to_state;
1677 
1678  /* Need to add to the right lists if the channel listener is registered */
1679  if (chan_l->registered) {
1680  was_active = !(from_state == CHANNEL_LISTENER_STATE_CLOSED ||
1681  from_state == CHANNEL_LISTENER_STATE_ERROR);
1682  is_active = !(to_state == CHANNEL_LISTENER_STATE_CLOSED ||
1683  to_state == CHANNEL_LISTENER_STATE_ERROR);
1684 
1685  /* Need to take off active list and put on finished list? */
1686  if (was_active && !is_active) {
1687  if (active_listeners) smartlist_remove(active_listeners, chan_l);
1688  if (!finished_listeners) finished_listeners = smartlist_new();
1689  smartlist_add(finished_listeners, chan_l);
1691  }
1692  /* Need to put on active list? */
1693  else if (!was_active && is_active) {
1694  if (finished_listeners) smartlist_remove(finished_listeners, chan_l);
1695  if (!active_listeners) active_listeners = smartlist_new();
1696  smartlist_add(active_listeners, chan_l);
1697  }
1698  }
1699 
1700  if (to_state == CHANNEL_LISTENER_STATE_CLOSED ||
1701  to_state == CHANNEL_LISTENER_STATE_ERROR) {
1702  tor_assert(!(chan_l->incoming_list) ||
1703  smartlist_len(chan_l->incoming_list) == 0);
1704  }
1705 }
1706 
1707 /* Maximum number of cells that is allowed to flush at once within
1708  * channel_flush_some_cells(). */
1709 #define MAX_CELLS_TO_GET_FROM_CIRCUITS_FOR_UNLIMITED 256
1710 
1711 /**
1712  * Try to flush cells of the given channel chan up to a maximum of num_cells.
1713  *
1714  * This is called by the scheduler when it wants to flush cells from the
1715  * channel's circuit queue(s) to the connection outbuf (not yet on the wire).
1716  *
1717  * If the channel is not in state CHANNEL_STATE_OPEN, this does nothing and
1718  * will return 0 meaning no cells were flushed.
1719  *
1720  * If num_cells is -1, we'll try to flush up to the maximum cells allowed
1721  * defined in MAX_CELLS_TO_GET_FROM_CIRCUITS_FOR_UNLIMITED.
1722  *
1723  * On success, the number of flushed cells are returned and it can never be
1724  * above num_cells. If 0 is returned, no cells were flushed either because the
1725  * channel was not opened or we had no cells on the channel. A negative number
1726  * can NOT be sent back.
1727  *
1728  * This function is part of the fast path. */
1729 MOCK_IMPL(ssize_t,
1730 channel_flush_some_cells, (channel_t *chan, ssize_t num_cells))
1731 {
1732  unsigned int unlimited = 0;
1733  ssize_t flushed = 0;
1734  int clamped_num_cells;
1735 
1736  tor_assert(chan);
1737 
1738  if (num_cells < 0) unlimited = 1;
1739  if (!unlimited && num_cells <= flushed) goto done;
1740 
1741  /* If we aren't in CHANNEL_STATE_OPEN, nothing goes through */
1742  if (CHANNEL_IS_OPEN(chan)) {
1743  if (circuitmux_num_cells(chan->cmux) > 0) {
1744  /* Calculate number of cells, including clamp */
1745  if (unlimited) {
1746  clamped_num_cells = MAX_CELLS_TO_GET_FROM_CIRCUITS_FOR_UNLIMITED;
1747  } else {
1748  if (num_cells - flushed >
1749  MAX_CELLS_TO_GET_FROM_CIRCUITS_FOR_UNLIMITED) {
1750  clamped_num_cells = MAX_CELLS_TO_GET_FROM_CIRCUITS_FOR_UNLIMITED;
1751  } else {
1752  clamped_num_cells = (int)(num_cells - flushed);
1753  }
1754  }
1755 
1756  /* Try to get more cells from any active circuits */
1758  chan, clamped_num_cells);
1759  }
1760  }
1761 
1762  done:
1763  return flushed;
1764 }
1765 
1766 /**
1767  * Check if any cells are available.
1768  *
1769  * This is used by the scheduler to know if the channel has more to flush
1770  * after a scheduling round.
1771  */
1772 MOCK_IMPL(int,
1774 {
1775  tor_assert(chan);
1776 
1777  if (circuitmux_num_cells(chan->cmux) > 0) return 1;
1778 
1779  /* Else no */
1780  return 0;
1781 }
1782 
1783 /**
1784  * Notify the channel we're done flushing the output in the lower layer.
1785  *
1786  * Connection.c will call this when we've flushed the output; there's some
1787  * dirreq-related maintenance to do.
1788  */
1789 void
1791 {
1792  tor_assert(chan);
1793 
1794  if (chan->dirreq_id != 0)
1796  DIRREQ_TUNNELED,
1798 }
1799 
1800 /**
1801  * Process the queue of incoming channels on a listener.
1802  *
1803  * Use a listener's registered callback to process as many entries in the
1804  * queue of incoming channels as possible.
1805  */
1806 void
1808 {
1809  tor_assert(listener);
1810 
1811  /*
1812  * CHANNEL_LISTENER_STATE_CLOSING permitted because we drain the queue
1813  * while closing a listener.
1814  */
1816  listener->state == CHANNEL_LISTENER_STATE_CLOSING);
1817  tor_assert(listener->listener);
1818 
1819  log_debug(LD_CHANNEL,
1820  "Processing queue of incoming connections for channel "
1821  "listener %p (global ID %"PRIu64 ")",
1822  listener, (listener->global_identifier));
1823 
1824  if (!(listener->incoming_list)) return;
1825 
1827  channel_t *, chan) {
1828  tor_assert(chan);
1829 
1830  log_debug(LD_CHANNEL,
1831  "Handling incoming channel %p (%"PRIu64 ") "
1832  "for listener %p (%"PRIu64 ")",
1833  chan,
1834  (chan->global_identifier),
1835  listener,
1836  (listener->global_identifier));
1837  /* Make sure this is set correctly */
1838  channel_mark_incoming(chan);
1839  listener->listener(listener, chan);
1840  } SMARTLIST_FOREACH_END(chan);
1841 
1842  smartlist_free(listener->incoming_list);
1843  listener->incoming_list = NULL;
1844 }
1845 
1846 /**
1847  * Take actions required when a channel becomes open.
1848  *
1849  * Handle actions we should do when we know a channel is open; a lot of
1850  * this comes from the old connection_or_set_state_open() of connection_or.c.
1851  *
1852  * Because of this mechanism, future channel_t subclasses should take care
1853  * not to change a channel from CHANNEL_STATE_OPENING to CHANNEL_STATE_OPEN
1854  * until there is positive confirmation that the network is operational.
1855  * In particular, anything UDP-based should not make this transition until a
1856  * packet is received from the other side.
1857  */
1858 void
1860 {
1861  tor_addr_t remote_addr;
1862  int started_here;
1863  time_t now = time(NULL);
1864  int close_origin_circuits = 0;
1865 
1866  tor_assert(chan);
1867 
1868  started_here = channel_is_outgoing(chan);
1869 
1870  if (started_here) {
1873  } else {
1874  /* only report it to the geoip module if it's a client */
1875  if (channel_is_client(chan)) {
1876  if (channel_get_addr_if_possible(chan, &remote_addr)) {
1877  char *transport_name = NULL;
1878  channel_tls_t *tlschan = BASE_CHAN_TO_TLS(chan);
1879  if (chan->get_transport_name(chan, &transport_name) < 0)
1880  transport_name = NULL;
1881 
1883  &remote_addr, transport_name,
1884  now);
1885  tor_free(transport_name);
1886  /* Notify the DoS subsystem of a new client. */
1887  if (tlschan && tlschan->conn) {
1888  dos_new_client_conn(tlschan->conn, transport_name);
1889  }
1890  }
1891  /* Otherwise the underlying transport can't tell us this, so skip it */
1892  }
1893  }
1894 
1895  /* Disable or reduce padding according to user prefs. */
1896  if (chan->padding_enabled || get_options()->ConnectionPadding == 1) {
1897  if (!get_options()->ConnectionPadding) {
1898  /* Disable if torrc disabled */
1900  } else if (rend_service_allow_non_anonymous_connection(get_options()) &&
1902  CHANNELPADDING_SOS_PARAM,
1903  CHANNELPADDING_SOS_DEFAULT, 0, 1)) {
1904  /* Disable if we're using RSOS and the consensus disabled padding
1905  * for RSOS */
1907  } else if (get_options()->ReducedConnectionPadding) {
1908  /* Padding can be forced and/or reduced by clients, regardless of if
1909  * the channel supports it */
1911  }
1912  }
1913 
1914  circuit_n_chan_done(chan, 1, close_origin_circuits);
1915 }
1916 
1917 /**
1918  * Queue an incoming channel on a listener.
1919  *
1920  * Internal and subclass use only function to queue an incoming channel from
1921  * a listener. A subclass of channel_listener_t should call this when a new
1922  * incoming channel is created.
1923  */
1924 void
1926  channel_t *incoming)
1927 {
1928  int need_to_queue = 0;
1929 
1930  tor_assert(listener);
1932  tor_assert(incoming);
1933 
1934  log_debug(LD_CHANNEL,
1935  "Queueing incoming channel %p (global ID %"PRIu64 ") on "
1936  "channel listener %p (global ID %"PRIu64 ")",
1937  incoming, (incoming->global_identifier),
1938  listener, (listener->global_identifier));
1939 
1940  /* Do we need to queue it, or can we just call the listener right away? */
1941  if (!(listener->listener)) need_to_queue = 1;
1942  if (listener->incoming_list &&
1943  (smartlist_len(listener->incoming_list) > 0))
1944  need_to_queue = 1;
1945 
1946  /* If we need to queue and have no queue, create one */
1947  if (need_to_queue && !(listener->incoming_list)) {
1948  listener->incoming_list = smartlist_new();
1949  }
1950 
1951  /* Bump the counter and timestamp it */
1954  ++(listener->n_accepted);
1955 
1956  /* If we don't need to queue, process it right away */
1957  if (!need_to_queue) {
1958  tor_assert(listener->listener);
1959  listener->listener(listener, incoming);
1960  }
1961  /*
1962  * Otherwise, we need to queue; queue and then process the queue if
1963  * we can.
1964  */
1965  else {
1966  tor_assert(listener->incoming_list);
1967  smartlist_add(listener->incoming_list, incoming);
1968  if (listener->listener) channel_listener_process_incoming(listener);
1969  }
1970 }
1971 
1972 /**
1973  * Process a cell from the given channel.
1974  */
1975 void
1977 {
1978  tor_assert(chan);
1979  tor_assert(CHANNEL_IS_CLOSING(chan) || CHANNEL_IS_MAINT(chan) ||
1980  CHANNEL_IS_OPEN(chan));
1981  tor_assert(cell);
1982 
1983  /* Nothing we can do if we have no registered cell handlers */
1984  if (!chan->cell_handler)
1985  return;
1986 
1987  /* Timestamp for receiving */
1988  channel_timestamp_recv(chan);
1989  /* Update received counter. */
1990  ++(chan->n_cells_recved);
1991  chan->n_bytes_recved += get_cell_network_size(chan->wide_circ_ids);
1992 
1993  log_debug(LD_CHANNEL,
1994  "Processing incoming cell_t %p for channel %p (global ID "
1995  "%"PRIu64 ")", cell, chan,
1996  (chan->global_identifier));
1997  chan->cell_handler(chan, cell);
1998 }
1999 
2000 /** If <b>packed_cell</b> on <b>chan</b> is a destroy cell, then set
2001  * *<b>circid_out</b> to its circuit ID, and return true. Otherwise, return
2002  * false. */
2003 /* XXXX Move this function. */
2004 int
2006  const packed_cell_t *packed_cell,
2007  circid_t *circid_out)
2008 {
2009  if (chan->wide_circ_ids) {
2010  if (packed_cell->body[4] == CELL_DESTROY) {
2011  *circid_out = ntohl(get_uint32(packed_cell->body));
2012  return 1;
2013  }
2014  } else {
2015  if (packed_cell->body[2] == CELL_DESTROY) {
2016  *circid_out = ntohs(get_uint16(packed_cell->body));
2017  return 1;
2018  }
2019  }
2020  return 0;
2021 }
2022 
2023 /**
2024  * Send destroy cell on a channel.
2025  *
2026  * Write a destroy cell with circ ID <b>circ_id</b> and reason <b>reason</b>
2027  * onto channel <b>chan</b>. Don't perform range-checking on reason:
2028  * we may want to propagate reasons from other cells.
2029  */
2030 int
2031 channel_send_destroy(circid_t circ_id, channel_t *chan, int reason)
2032 {
2033  tor_assert(chan);
2034  if (circ_id == 0) {
2035  log_warn(LD_BUG, "Attempted to send a destroy cell for circID 0 "
2036  "on a channel %"PRIu64 " at %p in state %s (%d)",
2037  (chan->global_identifier),
2038  chan, channel_state_to_string(chan->state),
2039  chan->state);
2040  return 0;
2041  }
2042 
2043  /* Check to make sure we can send on this channel first */
2044  if (!CHANNEL_CONDEMNED(chan) && chan->cmux) {
2045  channel_note_destroy_pending(chan, circ_id);
2046  circuitmux_append_destroy_cell(chan, chan->cmux, circ_id, reason);
2047  log_debug(LD_OR,
2048  "Sending destroy (circID %u) on channel %p "
2049  "(global ID %"PRIu64 ")",
2050  (unsigned)circ_id, chan,
2051  (chan->global_identifier));
2052  } else {
2053  log_warn(LD_BUG,
2054  "Someone called channel_send_destroy() for circID %u "
2055  "on a channel %"PRIu64 " at %p in state %s (%d)",
2056  (unsigned)circ_id, (chan->global_identifier),
2057  chan, channel_state_to_string(chan->state),
2058  chan->state);
2059  }
2060 
2061  return 0;
2062 }
2063 
2064 /**
2065  * Dump channel statistics to the log.
2066  *
2067  * This is called from dumpstats() in main.c and spams the log with
2068  * statistics on channels.
2069  */
2070 void
2071 channel_dumpstats(int severity)
2072 {
2073  if (all_channels && smartlist_len(all_channels) > 0) {
2074  tor_log(severity, LD_GENERAL,
2075  "Dumping statistics about %d channels:",
2076  smartlist_len(all_channels));
2077  tor_log(severity, LD_GENERAL,
2078  "%d are active, and %d are done and waiting for cleanup",
2079  (active_channels != NULL) ?
2080  smartlist_len(active_channels) : 0,
2081  (finished_channels != NULL) ?
2082  smartlist_len(finished_channels) : 0);
2083 
2084  SMARTLIST_FOREACH(all_channels, channel_t *, chan,
2085  channel_dump_statistics(chan, severity));
2086 
2087  tor_log(severity, LD_GENERAL,
2088  "Done spamming about channels now");
2089  } else {
2090  tor_log(severity, LD_GENERAL,
2091  "No channels to dump");
2092  }
2093 }
2094 
2095 /**
2096  * Dump channel listener statistics to the log.
2097  *
2098  * This is called from dumpstats() in main.c and spams the log with
2099  * statistics on channel listeners.
2100  */
2101 void
2103 {
2104  if (all_listeners && smartlist_len(all_listeners) > 0) {
2105  tor_log(severity, LD_GENERAL,
2106  "Dumping statistics about %d channel listeners:",
2107  smartlist_len(all_listeners));
2108  tor_log(severity, LD_GENERAL,
2109  "%d are active and %d are done and waiting for cleanup",
2110  (active_listeners != NULL) ?
2111  smartlist_len(active_listeners) : 0,
2112  (finished_listeners != NULL) ?
2113  smartlist_len(finished_listeners) : 0);
2114 
2115  SMARTLIST_FOREACH(all_listeners, channel_listener_t *, chan_l,
2116  channel_listener_dump_statistics(chan_l, severity));
2117 
2118  tor_log(severity, LD_GENERAL,
2119  "Done spamming about channel listeners now");
2120  } else {
2121  tor_log(severity, LD_GENERAL,
2122  "No channel listeners to dump");
2123  }
2124 }
2125 
2126 /**
2127  * Clean up channels.
2128  *
2129  * This gets called periodically from run_scheduled_events() in main.c;
2130  * it cleans up after closed channels.
2131  */
2132 void
2134 {
2135  channel_t *tmp = NULL;
2136 
2137  /* Check if we need to do anything */
2138  if (!finished_channels || smartlist_len(finished_channels) == 0) return;
2139 
2140  /* Iterate through finished_channels and get rid of them */
2141  SMARTLIST_FOREACH_BEGIN(finished_channels, channel_t *, curr) {
2142  tmp = curr;
2143  /* Remove it from the list */
2144  SMARTLIST_DEL_CURRENT(finished_channels, curr);
2145  /* Also unregister it */
2146  channel_unregister(tmp);
2147  /* ... and free it */
2148  channel_free(tmp);
2149  } SMARTLIST_FOREACH_END(curr);
2150 }
2151 
2152 /**
2153  * Clean up channel listeners.
2154  *
2155  * This gets called periodically from run_scheduled_events() in main.c;
2156  * it cleans up after closed channel listeners.
2157  */
2158 void
2160 {
2161  channel_listener_t *tmp = NULL;
2162 
2163  /* Check if we need to do anything */
2164  if (!finished_listeners || smartlist_len(finished_listeners) == 0) return;
2165 
2166  /* Iterate through finished_channels and get rid of them */
2167  SMARTLIST_FOREACH_BEGIN(finished_listeners, channel_listener_t *, curr) {
2168  tmp = curr;
2169  /* Remove it from the list */
2170  SMARTLIST_DEL_CURRENT(finished_listeners, curr);
2171  /* Also unregister it */
2173  /* ... and free it */
2174  channel_listener_free(tmp);
2175  } SMARTLIST_FOREACH_END(curr);
2176 }
2177 
2178 /**
2179  * Free a list of channels for channel_free_all().
2180  */
2181 static void
2182 channel_free_list(smartlist_t *channels, int mark_for_close)
2183 {
2184  if (!channels) return;
2185 
2186  SMARTLIST_FOREACH_BEGIN(channels, channel_t *, curr) {
2187  /* Deregister and free it */
2188  tor_assert(curr);
2189  log_debug(LD_CHANNEL,
2190  "Cleaning up channel %p (global ID %"PRIu64 ") "
2191  "in state %s (%d)",
2192  curr, (curr->global_identifier),
2193  channel_state_to_string(curr->state), curr->state);
2194  /* Detach circuits early so they can find the channel */
2195  if (curr->cmux) {
2196  circuitmux_detach_all_circuits(curr->cmux, NULL);
2197  }
2198  SMARTLIST_DEL_CURRENT(channels, curr);
2199  channel_unregister(curr);
2200  if (mark_for_close) {
2201  if (!CHANNEL_CONDEMNED(curr)) {
2202  channel_mark_for_close(curr);
2203  }
2204  channel_force_xfree(curr);
2205  } else channel_free(curr);
2206  } SMARTLIST_FOREACH_END(curr);
2207 }
2208 
2209 /**
2210  * Free a list of channel listeners for channel_free_all().
2211  */
2212 static void
2213 channel_listener_free_list(smartlist_t *listeners, int mark_for_close)
2214 {
2215  if (!listeners) return;
2216 
2217  SMARTLIST_FOREACH_BEGIN(listeners, channel_listener_t *, curr) {
2218  /* Deregister and free it */
2219  tor_assert(curr);
2220  log_debug(LD_CHANNEL,
2221  "Cleaning up channel listener %p (global ID %"PRIu64 ") "
2222  "in state %s (%d)",
2223  curr, (curr->global_identifier),
2224  channel_listener_state_to_string(curr->state), curr->state);
2226  if (mark_for_close) {
2227  if (!(curr->state == CHANNEL_LISTENER_STATE_CLOSING ||
2228  curr->state == CHANNEL_LISTENER_STATE_CLOSED ||
2229  curr->state == CHANNEL_LISTENER_STATE_ERROR)) {
2231  }
2233  } else channel_listener_free(curr);
2234  } SMARTLIST_FOREACH_END(curr);
2235 }
2236 
2237 /**
2238  * Close all channels and free everything.
2239  *
2240  * This gets called from tor_free_all() in main.c to clean up on exit.
2241  * It will close all registered channels and free associated storage,
2242  * then free the all_channels, active_channels, listening_channels and
2243  * finished_channels lists and also channel_identity_map.
2244  */
2245 void
2247 {
2248  log_debug(LD_CHANNEL,
2249  "Shutting down channels...");
2250 
2251  /* First, let's go for finished channels */
2252  if (finished_channels) {
2253  channel_free_list(finished_channels, 0);
2254  smartlist_free(finished_channels);
2255  finished_channels = NULL;
2256  }
2257 
2258  /* Now the finished listeners */
2259  if (finished_listeners) {
2260  channel_listener_free_list(finished_listeners, 0);
2261  smartlist_free(finished_listeners);
2262  finished_listeners = NULL;
2263  }
2264 
2265  /* Now all active channels */
2266  if (active_channels) {
2267  channel_free_list(active_channels, 1);
2268  smartlist_free(active_channels);
2269  active_channels = NULL;
2270  }
2271 
2272  /* Now all active listeners */
2273  if (active_listeners) {
2274  channel_listener_free_list(active_listeners, 1);
2275  smartlist_free(active_listeners);
2276  active_listeners = NULL;
2277  }
2278 
2279  /* Now all channels, in case any are left over */
2280  if (all_channels) {
2281  channel_free_list(all_channels, 1);
2282  smartlist_free(all_channels);
2283  all_channels = NULL;
2284  }
2285 
2286  /* Now all listeners, in case any are left over */
2287  if (all_listeners) {
2288  channel_listener_free_list(all_listeners, 1);
2289  smartlist_free(all_listeners);
2290  all_listeners = NULL;
2291  }
2292 
2293  /* Now free channel_identity_map */
2294  log_debug(LD_CHANNEL,
2295  "Freeing channel_identity_map");
2296  /* Geez, anything still left over just won't die ... let it leak then */
2297  HT_CLEAR(channel_idmap, &channel_identity_map);
2298 
2299  /* Same with channel_gid_map */
2300  log_debug(LD_CHANNEL,
2301  "Freeing channel_gid_map");
2302  HT_CLEAR(channel_gid_map, &channel_gid_map);
2303 
2304  log_debug(LD_CHANNEL,
2305  "Done cleaning up after channels");
2306 }
2307 
2308 /**
2309  * Connect to a given addr/port/digest.
2310  *
2311  * This sets up a new outgoing channel; in the future if multiple
2312  * channel_t subclasses are available, this is where the selection policy
2313  * should go. It may also be desirable to fold port into tor_addr_t
2314  * or make a new type including a tor_addr_t and port, so we have a
2315  * single abstract object encapsulating all the protocol details of
2316  * how to contact an OR.
2317  */
2318 channel_t *
2319 channel_connect(const tor_addr_t *addr, uint16_t port,
2320  const char *id_digest,
2321  const ed25519_public_key_t *ed_id)
2322 {
2323  return channel_tls_connect(addr, port, id_digest, ed_id);
2324 }
2325 
2326 /**
2327  * Decide which of two channels to prefer for extending a circuit.
2328  *
2329  * This function is called while extending a circuit and returns true iff
2330  * a is 'better' than b. The most important criterion here is that a
2331  * canonical channel is always better than a non-canonical one, but the
2332  * number of circuits and the age are used as tie-breakers.
2333  *
2334  * This is based on the former connection_or_is_better() of connection_or.c
2335  */
2336 int
2338 {
2339  int a_is_canonical, b_is_canonical;
2340 
2341  tor_assert(a);
2342  tor_assert(b);
2343 
2344  /* If one channel is bad for new circuits, and the other isn't,
2345  * use the one that is still good. */
2347  return 1;
2349  return 0;
2350 
2351  /* Check if one is canonical and the other isn't first */
2352  a_is_canonical = channel_is_canonical(a);
2353  b_is_canonical = channel_is_canonical(b);
2354 
2355  if (a_is_canonical && !b_is_canonical) return 1;
2356  if (!a_is_canonical && b_is_canonical) return 0;
2357 
2358  /* Check if we suspect that one of the channels will be preferred
2359  * by the peer */
2360  if (a->is_canonical_to_peer && !b->is_canonical_to_peer) return 1;
2361  if (!a->is_canonical_to_peer && b->is_canonical_to_peer) return 0;
2362 
2363  /*
2364  * Okay, if we're here they tied on canonicity. Prefer the older
2365  * connection, so that the adversary can't create a new connection
2366  * and try to switch us over to it (which will leak information
2367  * about long-lived circuits). Additionally, switching connections
2368  * too often makes us more vulnerable to attacks like Torscan and
2369  * passive netflow-based equivalents.
2370  *
2371  * Connections will still only live for at most a week, due to
2372  * the check in connection_or_group_set_badness() against
2373  * TIME_BEFORE_OR_CONN_IS_TOO_OLD, which marks old connections as
2374  * unusable for new circuits after 1 week. That check sets
2375  * is_bad_for_new_circs, which is checked in channel_get_for_extend().
2376  *
2377  * We check channel_is_bad_for_new_circs() above here anyway, for safety.
2378  */
2379  if (channel_when_created(a) < channel_when_created(b)) return 1;
2380  else if (channel_when_created(a) > channel_when_created(b)) return 0;
2381 
2382  if (channel_num_circuits(a) > channel_num_circuits(b)) return 1;
2383  else return 0;
2384 }
2385 
2386 /**
2387  * Get a channel to extend a circuit.
2388  *
2389  * Given the desired relay identity, pick a suitable channel to extend a
2390  * circuit to the target IPv4 or IPv6 address requsted by the client. Search
2391  * for an existing channel for the requested endpoint. Make sure the channel
2392  * is usable for new circuits, and matches one of the target addresses.
2393  *
2394  * Try to return the best channel. But if there is no good channel, set
2395  * *msg_out to a message describing the channel's state and our next action,
2396  * and set *launch_out to a boolean indicated whether the caller should try to
2397  * launch a new channel with channel_connect().
2398  */
2400 channel_get_for_extend,(const char *rsa_id_digest,
2401  const ed25519_public_key_t *ed_id,
2402  const tor_addr_t *target_ipv4_addr,
2403  const tor_addr_t *target_ipv6_addr,
2404  const char **msg_out,
2405  int *launch_out))
2406 {
2407  channel_t *chan, *best = NULL;
2408  int n_inprogress_goodaddr = 0, n_old = 0;
2409  int n_noncanonical = 0;
2410 
2411  tor_assert(msg_out);
2412  tor_assert(launch_out);
2413 
2414  chan = channel_find_by_remote_identity(rsa_id_digest, ed_id);
2415 
2416  /* Walk the list of channels */
2417  for (; chan; chan = channel_next_with_rsa_identity(chan)) {
2419  rsa_id_digest, DIGEST_LEN));
2420 
2421  if (CHANNEL_CONDEMNED(chan))
2422  continue;
2423 
2424  /* Never return a channel on which the other end appears to be
2425  * a client. */
2426  if (channel_is_client(chan)) {
2427  continue;
2428  }
2429 
2430  /* The Ed25519 key has to match too */
2431  if (!channel_remote_identity_matches(chan, rsa_id_digest, ed_id)) {
2432  continue;
2433  }
2434 
2435  const bool matches_target =
2437  target_ipv4_addr,
2438  target_ipv6_addr);
2439  /* Never return a non-open connection. */
2440  if (!CHANNEL_IS_OPEN(chan)) {
2441  /* If the address matches, don't launch a new connection for this
2442  * circuit. */
2443  if (matches_target)
2444  ++n_inprogress_goodaddr;
2445  continue;
2446  }
2447 
2448  /* Never return a connection that shouldn't be used for circs. */
2449  if (channel_is_bad_for_new_circs(chan)) {
2450  ++n_old;
2451  continue;
2452  }
2453 
2454  /* Only return canonical connections or connections where the address
2455  * is the address we wanted. */
2456  if (!channel_is_canonical(chan) && !matches_target) {
2457  ++n_noncanonical;
2458  continue;
2459  }
2460 
2461  if (!best) {
2462  best = chan; /* If we have no 'best' so far, this one is good enough. */
2463  continue;
2464  }
2465 
2466  if (channel_is_better(chan, best))
2467  best = chan;
2468  }
2469 
2470  if (best) {
2471  *msg_out = "Connection is fine; using it.";
2472  *launch_out = 0;
2473  return best;
2474  } else if (n_inprogress_goodaddr) {
2475  *msg_out = "Connection in progress; waiting.";
2476  *launch_out = 0;
2477  return NULL;
2478  } else if (n_old || n_noncanonical) {
2479  *msg_out = "Connections all too old, or too non-canonical. "
2480  " Launching a new one.";
2481  *launch_out = 1;
2482  return NULL;
2483  } else {
2484  *msg_out = "Not connected. Connecting.";
2485  *launch_out = 1;
2486  return NULL;
2487  }
2488 }
2489 
2490 /**
2491  * Describe the transport subclass for a channel.
2492  *
2493  * Invoke a method to get a string description of the lower-layer
2494  * transport for this channel.
2495  */
2496 const char *
2498 {
2499  tor_assert(chan);
2501 
2502  return chan->describe_transport(chan);
2503 }
2504 
2505 /**
2506  * Describe the transport subclass for a channel listener.
2507  *
2508  * Invoke a method to get a string description of the lower-layer
2509  * transport for this channel listener.
2510  */
2511 const char *
2513 {
2514  tor_assert(chan_l);
2515  tor_assert(chan_l->describe_transport);
2516 
2517  return chan_l->describe_transport(chan_l);
2518 }
2519 
2520 /**
2521  * Dump channel statistics.
2522  *
2523  * Dump statistics for one channel to the log.
2524  */
2525 MOCK_IMPL(void,
2526 channel_dump_statistics, (channel_t *chan, int severity))
2527 {
2528  double avg, interval, age;
2529  time_t now = time(NULL);
2530  tor_addr_t remote_addr;
2531  int have_remote_addr;
2532  char *remote_addr_str;
2533 
2534  tor_assert(chan);
2535 
2536  age = (double)(now - chan->timestamp_created);
2537 
2538  tor_log(severity, LD_GENERAL,
2539  "Channel %"PRIu64 " (at %p) with transport %s is in state "
2540  "%s (%d)",
2541  (chan->global_identifier), chan,
2543  channel_state_to_string(chan->state), chan->state);
2544  tor_log(severity, LD_GENERAL,
2545  " * Channel %"PRIu64 " was created at %"PRIu64
2546  " (%"PRIu64 " seconds ago) "
2547  "and last active at %"PRIu64 " (%"PRIu64 " seconds ago)",
2548  (chan->global_identifier),
2549  (uint64_t)(chan->timestamp_created),
2550  (uint64_t)(now - chan->timestamp_created),
2551  (uint64_t)(chan->timestamp_active),
2552  (uint64_t)(now - chan->timestamp_active));
2553 
2554  /* Handle digest. */
2555  if (!tor_digest_is_zero(chan->identity_digest)) {
2556  tor_log(severity, LD_GENERAL,
2557  " * Channel %"PRIu64 " says it is connected "
2558  "to an OR with digest %s",
2559  (chan->global_identifier),
2561  } else {
2562  tor_log(severity, LD_GENERAL,
2563  " * Channel %"PRIu64 " does not know the digest"
2564  " of the OR it is connected to",
2565  (chan->global_identifier));
2566  }
2567 
2568  /* Handle remote address and descriptions */
2569  have_remote_addr = channel_get_addr_if_possible(chan, &remote_addr);
2570  if (have_remote_addr) {
2571  char *actual = tor_strdup(channel_describe_peer(chan));
2572  remote_addr_str = tor_addr_to_str_dup(&remote_addr);
2573  tor_log(severity, LD_GENERAL,
2574  " * Channel %"PRIu64 " says its remote address"
2575  " is %s, and gives a canonical description of \"%s\" and an "
2576  "actual description of \"%s\"",
2577  (chan->global_identifier),
2578  safe_str(remote_addr_str),
2579  safe_str(channel_describe_peer(chan)),
2580  safe_str(actual));
2581  tor_free(remote_addr_str);
2582  tor_free(actual);
2583  } else {
2584  char *actual = tor_strdup(channel_describe_peer(chan));
2585  tor_log(severity, LD_GENERAL,
2586  " * Channel %"PRIu64 " does not know its remote "
2587  "address, but gives a canonical description of \"%s\" and an "
2588  "actual description of \"%s\"",
2589  (chan->global_identifier),
2590  channel_describe_peer(chan),
2591  actual);
2592  tor_free(actual);
2593  }
2594 
2595  /* Handle marks */
2596  tor_log(severity, LD_GENERAL,
2597  " * Channel %"PRIu64 " has these marks: %s %s %s %s %s",
2598  (chan->global_identifier),
2600  "bad_for_new_circs" : "!bad_for_new_circs",
2601  channel_is_canonical(chan) ?
2602  "canonical" : "!canonical",
2603  channel_is_client(chan) ?
2604  "client" : "!client",
2605  channel_is_local(chan) ?
2606  "local" : "!local",
2607  channel_is_incoming(chan) ?
2608  "incoming" : "outgoing");
2609 
2610  /* Describe circuits */
2611  tor_log(severity, LD_GENERAL,
2612  " * Channel %"PRIu64 " has %d active circuits out of"
2613  " %d in total",
2614  (chan->global_identifier),
2615  (chan->cmux != NULL) ?
2617  (chan->cmux != NULL) ?
2618  circuitmux_num_circuits(chan->cmux) : 0);
2619 
2620  /* Describe timestamps */
2621  tor_log(severity, LD_GENERAL,
2622  " * Channel %"PRIu64 " was last used by a "
2623  "client at %"PRIu64 " (%"PRIu64 " seconds ago)",
2624  (chan->global_identifier),
2625  (uint64_t)(chan->timestamp_client),
2626  (uint64_t)(now - chan->timestamp_client));
2627  tor_log(severity, LD_GENERAL,
2628  " * Channel %"PRIu64 " last received a cell "
2629  "at %"PRIu64 " (%"PRIu64 " seconds ago)",
2630  (chan->global_identifier),
2631  (uint64_t)(chan->timestamp_recv),
2632  (uint64_t)(now - chan->timestamp_recv));
2633  tor_log(severity, LD_GENERAL,
2634  " * Channel %"PRIu64 " last transmitted a cell "
2635  "at %"PRIu64 " (%"PRIu64 " seconds ago)",
2636  (chan->global_identifier),
2637  (uint64_t)(chan->timestamp_xmit),
2638  (uint64_t)(now - chan->timestamp_xmit));
2639 
2640  /* Describe counters and rates */
2641  tor_log(severity, LD_GENERAL,
2642  " * Channel %"PRIu64 " has received "
2643  "%"PRIu64 " bytes in %"PRIu64 " cells and transmitted "
2644  "%"PRIu64 " bytes in %"PRIu64 " cells",
2645  (chan->global_identifier),
2646  (chan->n_bytes_recved),
2647  (chan->n_cells_recved),
2648  (chan->n_bytes_xmitted),
2649  (chan->n_cells_xmitted));
2650  if (now > chan->timestamp_created &&
2651  chan->timestamp_created > 0) {
2652  if (chan->n_bytes_recved > 0) {
2653  avg = (double)(chan->n_bytes_recved) / age;
2654  tor_log(severity, LD_GENERAL,
2655  " * Channel %"PRIu64 " has averaged %f "
2656  "bytes received per second",
2657  (chan->global_identifier), avg);
2658  }
2659  if (chan->n_cells_recved > 0) {
2660  avg = (double)(chan->n_cells_recved) / age;
2661  if (avg >= 1.0) {
2662  tor_log(severity, LD_GENERAL,
2663  " * Channel %"PRIu64 " has averaged %f "
2664  "cells received per second",
2665  (chan->global_identifier), avg);
2666  } else if (avg >= 0.0) {
2667  interval = 1.0 / avg;
2668  tor_log(severity, LD_GENERAL,
2669  " * Channel %"PRIu64 " has averaged %f "
2670  "seconds between received cells",
2671  (chan->global_identifier), interval);
2672  }
2673  }
2674  if (chan->n_bytes_xmitted > 0) {
2675  avg = (double)(chan->n_bytes_xmitted) / age;
2676  tor_log(severity, LD_GENERAL,
2677  " * Channel %"PRIu64 " has averaged %f "
2678  "bytes transmitted per second",
2679  (chan->global_identifier), avg);
2680  }
2681  if (chan->n_cells_xmitted > 0) {
2682  avg = (double)(chan->n_cells_xmitted) / age;
2683  if (avg >= 1.0) {
2684  tor_log(severity, LD_GENERAL,
2685  " * Channel %"PRIu64 " has averaged %f "
2686  "cells transmitted per second",
2687  (chan->global_identifier), avg);
2688  } else if (avg >= 0.0) {
2689  interval = 1.0 / avg;
2690  tor_log(severity, LD_GENERAL,
2691  " * Channel %"PRIu64 " has averaged %f "
2692  "seconds between transmitted cells",
2693  (chan->global_identifier), interval);
2694  }
2695  }
2696  }
2697 
2698  /* Dump anything the lower layer has to say */
2699  channel_dump_transport_statistics(chan, severity);
2700 }
2701 
2702 /**
2703  * Dump channel listener statistics.
2704  *
2705  * Dump statistics for one channel listener to the log.
2706  */
2707 void
2709 {
2710  double avg, interval, age;
2711  time_t now = time(NULL);
2712 
2713  tor_assert(chan_l);
2714 
2715  age = (double)(now - chan_l->timestamp_created);
2716 
2717  tor_log(severity, LD_GENERAL,
2718  "Channel listener %"PRIu64 " (at %p) with transport %s is in "
2719  "state %s (%d)",
2720  (chan_l->global_identifier), chan_l,
2722  channel_listener_state_to_string(chan_l->state), chan_l->state);
2723  tor_log(severity, LD_GENERAL,
2724  " * Channel listener %"PRIu64 " was created at %"PRIu64
2725  " (%"PRIu64 " seconds ago) "
2726  "and last active at %"PRIu64 " (%"PRIu64 " seconds ago)",
2727  (chan_l->global_identifier),
2728  (uint64_t)(chan_l->timestamp_created),
2729  (uint64_t)(now - chan_l->timestamp_created),
2730  (uint64_t)(chan_l->timestamp_active),
2731  (uint64_t)(now - chan_l->timestamp_active));
2732 
2733  tor_log(severity, LD_GENERAL,
2734  " * Channel listener %"PRIu64 " last accepted an incoming "
2735  "channel at %"PRIu64 " (%"PRIu64 " seconds ago) "
2736  "and has accepted %"PRIu64 " channels in total",
2737  (chan_l->global_identifier),
2738  (uint64_t)(chan_l->timestamp_accepted),
2739  (uint64_t)(now - chan_l->timestamp_accepted),
2740  (uint64_t)(chan_l->n_accepted));
2741 
2742  /*
2743  * If it's sensible to do so, get the rate of incoming channels on this
2744  * listener
2745  */
2746  if (now > chan_l->timestamp_created &&
2747  chan_l->timestamp_created > 0 &&
2748  chan_l->n_accepted > 0) {
2749  avg = (double)(chan_l->n_accepted) / age;
2750  if (avg >= 1.0) {
2751  tor_log(severity, LD_GENERAL,
2752  " * Channel listener %"PRIu64 " has averaged %f incoming "
2753  "channels per second",
2754  (chan_l->global_identifier), avg);
2755  } else if (avg >= 0.0) {
2756  interval = 1.0 / avg;
2757  tor_log(severity, LD_GENERAL,
2758  " * Channel listener %"PRIu64 " has averaged %f seconds "
2759  "between incoming channels",
2760  (chan_l->global_identifier), interval);
2761  }
2762  }
2763 
2764  /* Dump anything the lower layer has to say */
2766 }
2767 
2768 /**
2769  * Invoke transport-specific stats dump for channel.
2770  *
2771  * If there is a lower-layer statistics dump method, invoke it.
2772  */
2773 void
2775 {
2776  tor_assert(chan);
2777 
2778  if (chan->dumpstats) chan->dumpstats(chan, severity);
2779 }
2780 
2781 /**
2782  * Invoke transport-specific stats dump for channel listener.
2783  *
2784  * If there is a lower-layer statistics dump method, invoke it.
2785  */
2786 void
2788  int severity)
2789 {
2790  tor_assert(chan_l);
2791 
2792  if (chan_l->dumpstats) chan_l->dumpstats(chan_l, severity);
2793 }
2794 
2795 /**
2796  * Return text description of the remote endpoint canonical address.
2797  *
2798  * This function returns a human-readable string for logging; nothing
2799  * should parse it or rely on a particular format.
2800  *
2801  * Subsequent calls to this function may invalidate its return value.
2802  */
2803 MOCK_IMPL(const char *,
2805 {
2806  tor_assert(chan);
2807  tor_assert(chan->describe_peer);
2808 
2809  return chan->describe_peer(chan);
2810 }
2811 
2812 /**
2813  * Get the remote address for this channel, if possible.
2814  *
2815  * Write the remote address out to a tor_addr_t if the underlying transport
2816  * supports this operation, and return 1. Return 0 if the underlying transport
2817  * doesn't let us do this.
2818  *
2819  * Always returns the "real" address of the peer -- the one we're connected to
2820  * on the internet.
2821  */
2822 MOCK_IMPL(int,
2824  tor_addr_t *addr_out))
2825 {
2826  tor_assert(chan);
2827  tor_assert(addr_out);
2828  tor_assert(chan->get_remote_addr);
2829 
2830  return chan->get_remote_addr(chan, addr_out);
2831 }
2832 
2833 /**
2834  * Return true iff the channel has any cells on the connection outbuf waiting
2835  * to be sent onto the network.
2836  */
2837 int
2839 {
2840  tor_assert(chan);
2842 
2843  /* Check with the lower layer */
2844  return chan->has_queued_writes(chan);
2845 }
2846 
2847 /**
2848  * Check the is_bad_for_new_circs flag.
2849  *
2850  * This function returns the is_bad_for_new_circs flag of the specified
2851  * channel.
2852  */
2853 int
2855 {
2856  tor_assert(chan);
2857 
2858  return chan->is_bad_for_new_circs;
2859 }
2860 
2861 /**
2862  * Mark a channel as bad for new circuits.
2863  *
2864  * Set the is_bad_for_new_circs_flag on chan.
2865  */
2866 void
2868 {
2869  tor_assert(chan);
2870 
2871  chan->is_bad_for_new_circs = 1;
2872 }
2873 
2874 /**
2875  * Get the client flag.
2876  *
2877  * This returns the client flag of a channel, which will be set if
2878  * command_process_create_cell() in command.c thinks this is a connection
2879  * from a client.
2880  */
2881 int
2883 {
2884  tor_assert(chan);
2885 
2886  return chan->is_client;
2887 }
2888 
2889 /**
2890  * Set the client flag.
2891  *
2892  * Mark a channel as being from a client.
2893  */
2894 void
2896 {
2897  tor_assert(chan);
2898 
2899  chan->is_client = 1;
2900 }
2901 
2902 /**
2903  * Clear the client flag.
2904  *
2905  * Mark a channel as being _not_ from a client.
2906  */
2907 void
2909 {
2910  tor_assert(chan);
2911 
2912  chan->is_client = 0;
2913 }
2914 
2915 /**
2916  * Get the canonical flag for a channel.
2917  *
2918  * This returns the is_canonical for a channel; this flag is determined by
2919  * the lower layer and can't be set in a transport-independent way.
2920  */
2921 int
2923 {
2924  tor_assert(chan);
2925  tor_assert(chan->is_canonical);
2926 
2927  return chan->is_canonical(chan);
2928 }
2929 
2930 /**
2931  * Test incoming flag.
2932  *
2933  * This function gets the incoming flag; this is set when a listener spawns
2934  * a channel. If this returns true the channel was remotely initiated.
2935  */
2936 int
2938 {
2939  tor_assert(chan);
2940 
2941  return chan->is_incoming;
2942 }
2943 
2944 /**
2945  * Set the incoming flag.
2946  *
2947  * This function is called when a channel arrives on a listening channel
2948  * to mark it as incoming.
2949  */
2950 void
2952 {
2953  tor_assert(chan);
2954 
2955  chan->is_incoming = 1;
2956 }
2957 
2958 /**
2959  * Test local flag.
2960  *
2961  * This function gets the local flag; the lower layer should set this when
2962  * setting up the channel if is_local_addr() is true for all of the
2963  * destinations it will communicate with on behalf of this channel. It's
2964  * used to decide whether to declare the network reachable when seeing incoming
2965  * traffic on the channel.
2966  */
2967 int
2969 {
2970  tor_assert(chan);
2971 
2972  return chan->is_local;
2973 }
2974 
2975 /**
2976  * Set the local flag.
2977  *
2978  * This internal-only function should be called by the lower layer if the
2979  * channel is to a local address. See channel_is_local() above or the
2980  * description of the is_local bit in channel.h.
2981  */
2982 void
2984 {
2985  tor_assert(chan);
2986 
2987  chan->is_local = 1;
2988 }
2989 
2990 /**
2991  * Mark a channel as remote.
2992  *
2993  * This internal-only function should be called by the lower layer if the
2994  * channel is not to a local address but has previously been marked local.
2995  * See channel_is_local() above or the description of the is_local bit in
2996  * channel.h
2997  */
2998 void
3000 {
3001  tor_assert(chan);
3002 
3003  chan->is_local = 0;
3004 }
3005 
3006 /**
3007  * Test outgoing flag.
3008  *
3009  * This function gets the outgoing flag; this is the inverse of the incoming
3010  * bit set when a listener spawns a channel. If this returns true the channel
3011  * was locally initiated.
3012  */
3013 int
3015 {
3016  tor_assert(chan);
3017 
3018  return !(chan->is_incoming);
3019 }
3020 
3021 /**
3022  * Mark a channel as outgoing.
3023  *
3024  * This function clears the incoming flag and thus marks a channel as
3025  * outgoing.
3026  */
3027 void
3029 {
3030  tor_assert(chan);
3031 
3032  chan->is_incoming = 0;
3033 }
3034 
3035 /************************
3036  * Flow control queries *
3037  ***********************/
3038 
3039 /**
3040  * Estimate the number of writeable cells.
3041  *
3042  * Ask the lower layer for an estimate of how many cells it can accept.
3043  */
3044 int
3046 {
3047  int result;
3048 
3049  tor_assert(chan);
3050  tor_assert(chan->num_cells_writeable);
3051 
3052  if (chan->state == CHANNEL_STATE_OPEN) {
3053  /* Query lower layer */
3054  result = chan->num_cells_writeable(chan);
3055  if (result < 0) result = 0;
3056  } else {
3057  /* No cells are writeable in any other state */
3058  result = 0;
3059  }
3060 
3061  return result;
3062 }
3063 
3064 /*********************
3065  * Timestamp updates *
3066  ********************/
3067 
3068 /**
3069  * Update the created timestamp for a channel.
3070  *
3071  * This updates the channel's created timestamp and should only be called
3072  * from channel_init().
3073  */
3074 void
3076 {
3077  time_t now = time(NULL);
3078 
3079  tor_assert(chan);
3080 
3081  chan->timestamp_created = now;
3082 }
3083 
3084 /**
3085  * Update the created timestamp for a channel listener.
3086  *
3087  * This updates the channel listener's created timestamp and should only be
3088  * called from channel_init_listener().
3089  */
3090 void
3092 {
3093  time_t now = time(NULL);
3094 
3095  tor_assert(chan_l);
3096 
3097  chan_l->timestamp_created = now;
3098 }
3099 
3100 /**
3101  * Update the last active timestamp for a channel.
3102  *
3103  * This function updates the channel's last active timestamp; it should be
3104  * called by the lower layer whenever there is activity on the channel which
3105  * does not lead to a cell being transmitted or received; the active timestamp
3106  * is also updated from channel_timestamp_recv() and channel_timestamp_xmit(),
3107  * but it should be updated for things like the v3 handshake and stuff that
3108  * produce activity only visible to the lower layer.
3109  */
3110 void
3112 {
3113  time_t now = time(NULL);
3114 
3115  tor_assert(chan);
3116  monotime_coarse_get(&chan->timestamp_xfer);
3117 
3118  chan->timestamp_active = now;
3119 
3120  /* Clear any potential netflow padding timer. We're active */
3121  monotime_coarse_zero(&chan->next_padding_time);
3122 }
3123 
3124 /**
3125  * Update the last active timestamp for a channel listener.
3126  */
3127 void
3129 {
3130  time_t now = time(NULL);
3131 
3132  tor_assert(chan_l);
3133 
3134  chan_l->timestamp_active = now;
3135 }
3136 
3137 /**
3138  * Update the last accepted timestamp.
3139  *
3140  * This function updates the channel listener's last accepted timestamp; it
3141  * should be called whenever a new incoming channel is accepted on a
3142  * listener.
3143  */
3144 void
3146 {
3147  time_t now = time(NULL);
3148 
3149  tor_assert(chan_l);
3150 
3151  chan_l->timestamp_active = now;
3152  chan_l->timestamp_accepted = now;
3153 }
3154 
3155 /**
3156  * Update client timestamp.
3157  *
3158  * This function is called by relay.c to timestamp a channel that appears to
3159  * be used as a client.
3160  */
3161 void
3163 {
3164  time_t now = time(NULL);
3165 
3166  tor_assert(chan);
3167 
3168  chan->timestamp_client = now;
3169 }
3170 
3171 /**
3172  * Update the recv timestamp.
3173  *
3174  * This is called whenever we get an incoming cell from the lower layer.
3175  * This also updates the active timestamp.
3176  */
3177 void
3179 {
3180  time_t now = time(NULL);
3181  tor_assert(chan);
3182  monotime_coarse_get(&chan->timestamp_xfer);
3183 
3184  chan->timestamp_active = now;
3185  chan->timestamp_recv = now;
3186 
3187  /* Clear any potential netflow padding timer. We're active */
3188  monotime_coarse_zero(&chan->next_padding_time);
3189 }
3190 
3191 /**
3192  * Update the xmit timestamp.
3193  *
3194  * This is called whenever we pass an outgoing cell to the lower layer. This
3195  * also updates the active timestamp.
3196  */
3197 void
3199 {
3200  time_t now = time(NULL);
3201  tor_assert(chan);
3202 
3203  monotime_coarse_get(&chan->timestamp_xfer);
3204 
3205  chan->timestamp_active = now;
3206  chan->timestamp_xmit = now;
3207 
3208  /* Clear any potential netflow padding timer. We're active */
3209  monotime_coarse_zero(&chan->next_padding_time);
3210 }
3211 
3212 /***************************************************************
3213  * Timestamp queries - see above for definitions of timestamps *
3214  **************************************************************/
3215 
3216 /**
3217  * Query created timestamp for a channel.
3218  */
3219 time_t
3221 {
3222  tor_assert(chan);
3223 
3224  return chan->timestamp_created;
3225 }
3226 
3227 /**
3228  * Query client timestamp.
3229  */
3230 time_t
3232 {
3233  tor_assert(chan);
3234 
3235  return chan->timestamp_client;
3236 }
3237 
3238 /**
3239  * Query xmit timestamp.
3240  */
3241 time_t
3243 {
3244  tor_assert(chan);
3245 
3246  return chan->timestamp_xmit;
3247 }
3248 
3249 /**
3250  * Check if a channel matches an extend_info_t.
3251  *
3252  * This function calls the lower layer and asks if this channel matches a
3253  * given extend_info_t.
3254  *
3255  * NOTE that this function only checks for an address/port match, and should
3256  * be used only when no identity is available.
3257  */
3258 int
3260 {
3261  tor_assert(chan);
3263  tor_assert(extend_info);
3264 
3265  return chan->matches_extend_info(chan, extend_info);
3266 }
3267 
3268 /**
3269  * Check if a channel matches the given target IPv4 or IPv6 addresses.
3270  * If either address matches, return true. If neither address matches,
3271  * return false.
3272  *
3273  * Both addresses can't be NULL.
3274  *
3275  * This function calls into the lower layer and asks if this channel thinks
3276  * it matches the target addresses for circuit extension purposes.
3277  */
3278 STATIC bool
3280  const tor_addr_t *target_ipv4_addr,
3281  const tor_addr_t *target_ipv6_addr)
3282 {
3283  tor_assert(chan);
3284  tor_assert(chan->matches_target);
3285 
3286  IF_BUG_ONCE(!target_ipv4_addr && !target_ipv6_addr)
3287  return false;
3288 
3289  if (target_ipv4_addr && chan->matches_target(chan, target_ipv4_addr))
3290  return true;
3291 
3292  if (target_ipv6_addr && chan->matches_target(chan, target_ipv6_addr))
3293  return true;
3294 
3295  return false;
3296 }
3297 
3298 /**
3299  * Return the total number of circuits used by a channel.
3300  *
3301  * @param chan Channel to query
3302  * @return Number of circuits using this as n_chan or p_chan
3303  */
3304 unsigned int
3306 {
3307  tor_assert(chan);
3308 
3309  return chan->num_n_circuits +
3310  chan->num_p_circuits;
3311 }
3312 
3313 /**
3314  * Set up circuit ID generation.
3315  *
3316  * This is called when setting up a channel and replaces the old
3317  * connection_or_set_circid_type().
3318  */
3319 MOCK_IMPL(void,
3321  crypto_pk_t *identity_rcvd,
3322  int consider_identity))
3323 {
3324  int started_here;
3325  crypto_pk_t *our_identity;
3326 
3327  tor_assert(chan);
3328 
3329  started_here = channel_is_outgoing(chan);
3330 
3331  if (! consider_identity) {
3332  if (started_here)
3334  else
3336  return;
3337  }
3338 
3339  our_identity = started_here ?
3340  get_tlsclient_identity_key() : get_server_identity_key();
3341 
3342  if (identity_rcvd) {
3343  if (crypto_pk_cmp_keys(our_identity, identity_rcvd) < 0) {
3345  } else {
3347  }
3348  } else {
3350  }
3351 }
3352 
3353 static int
3354 channel_sort_by_ed25519_identity(const void **a_, const void **b_)
3355 {
3356  const channel_t *a = *a_,
3357  *b = *b_;
3358  return fast_memcmp(&a->ed25519_identity.pubkey,
3359  &b->ed25519_identity.pubkey,
3360  sizeof(a->ed25519_identity.pubkey));
3361 }
3362 
3363 /** Helper for channel_update_bad_for_new_circs(): Perform the
3364  * channel_update_bad_for_new_circs operation on all channels in <b>lst</b>,
3365  * all of which MUST have the same RSA ID. (They MAY have different
3366  * Ed25519 IDs.) */
3367 static void
3368 channel_rsa_id_group_set_badness(struct channel_list_t *lst, int force)
3369 {
3370  /*XXXX This function should really be about channels. 15056 */
3371  channel_t *chan = TOR_LIST_FIRST(lst);
3372 
3373  if (!chan)
3374  return;
3375 
3376  /* if there is only one channel, don't bother looping */
3377  if (PREDICT_LIKELY(!TOR_LIST_NEXT(chan, next_with_same_id))) {
3379  time(NULL), BASE_CHAN_TO_TLS(chan)->conn, force);
3380  return;
3381  }
3382 
3383  smartlist_t *channels = smartlist_new();
3384 
3385  TOR_LIST_FOREACH(chan, lst, next_with_same_id) {
3386  if (BASE_CHAN_TO_TLS(chan)->conn) {
3387  smartlist_add(channels, chan);
3388  }
3389  }
3390 
3391  smartlist_sort(channels, channel_sort_by_ed25519_identity);
3392 
3393  const ed25519_public_key_t *common_ed25519_identity = NULL;
3394  /* it would be more efficient to do a slice, but this case is rare */
3395  smartlist_t *or_conns = smartlist_new();
3396  SMARTLIST_FOREACH_BEGIN(channels, channel_t *, channel) {
3397  tor_assert(channel); // Suppresses some compiler warnings.
3398 
3399  if (!common_ed25519_identity)
3400  common_ed25519_identity = &channel->ed25519_identity;
3401 
3402  if (! ed25519_pubkey_eq(&channel->ed25519_identity,
3403  common_ed25519_identity)) {
3404  connection_or_group_set_badness_(or_conns, force);
3405  smartlist_clear(or_conns);
3406  common_ed25519_identity = &channel->ed25519_identity;
3407  }
3408 
3409  smartlist_add(or_conns, BASE_CHAN_TO_TLS(channel)->conn);
3410  } SMARTLIST_FOREACH_END(channel);
3411 
3412  connection_or_group_set_badness_(or_conns, force);
3413 
3414  /* XXXX 15056 we may want to do something special with connections that have
3415  * no set Ed25519 identity! */
3416 
3417  smartlist_free(or_conns);
3418  smartlist_free(channels);
3419 }
3420 
3421 /** Go through all the channels (or if <b>digest</b> is non-NULL, just
3422  * the OR connections with that digest), and set the is_bad_for_new_circs
3423  * flag based on the rules in connection_or_group_set_badness() (or just
3424  * always set it if <b>force</b> is true).
3425  */
3426 void
3427 channel_update_bad_for_new_circs(const char *digest, int force)
3428 {
3429  if (digest) {
3430  channel_idmap_entry_t *ent;
3431  channel_idmap_entry_t search;
3432  memset(&search, 0, sizeof(search));
3433  memcpy(search.digest, digest, DIGEST_LEN);
3434  ent = HT_FIND(channel_idmap, &channel_identity_map, &search);
3435  if (ent) {
3436  channel_rsa_id_group_set_badness(&ent->channel_list, force);
3437  }
3438  return;
3439  }
3440 
3441  /* no digest; just look at everything. */
3442  channel_idmap_entry_t **iter;
3443  HT_FOREACH(iter, channel_idmap, &channel_identity_map) {
3444  channel_rsa_id_group_set_badness(&(*iter)->channel_list, force);
3445  }
3446 }
CHANNEL_STATE_OPENING
@ CHANNEL_STATE_OPENING
Definition: channel.h:70
CHANNEL_STATE_CLOSED
@ CHANNEL_STATE_CLOSED
Definition: channel.h:59
circuit_unlink_all_from_channel
void circuit_unlink_all_from_channel(channel_t *chan, int reason)
Definition: circuitlist.c:1605
channel_note_destroy_not_pending
void channel_note_destroy_not_pending(channel_t *chan, circid_t id)
Definition: circuitlist.c:431
channel_has_queued_writes
int channel_has_queued_writes(channel_t *chan)
Definition: channel.c:2838
tor_free
#define tor_free(p)
Definition: malloc.h:52
get_circuit_build_times_mutable
circuit_build_times_t * get_circuit_build_times_mutable(void)
Definition: circuitstats.c:86
channel_t::dirreq_id
uint64_t dirreq_id
Definition: channel.h:453
channel_timestamp_created
void channel_timestamp_created(channel_t *chan)
Definition: channel.c:3075
tor_free_
void tor_free_(void *mem)
Definition: malloc.c:227
hex_str
const char * hex_str(const char *from, size_t fromlen)
Definition: binascii.c:34
channel_t::is_bad_for_new_circs
unsigned int is_bad_for_new_circs
Definition: channel.h:419
channel_t::identity_digest
char identity_digest[DIGEST_LEN]
Definition: channel.h:378
channel_is_client
int channel_is_client(const channel_t *chan)
Definition: channel.c:2882
channel_listener_force_xfree
static void channel_listener_force_xfree(channel_listener_t *chan_l)
Definition: channel.c:1025
channel_t::timestamp_created
time_t timestamp_created
Definition: channel.h:298
channel_timestamp_active
void channel_timestamp_active(channel_t *chan)
Definition: channel.c:3111
tor_addr_t
Definition: address.h:69
channel_change_state_open
void channel_change_state_open(channel_t *chan)
Definition: channel.c:1622
circuitmux_detach_all_circuits
void circuitmux_detach_all_circuits(circuitmux_t *cmux, smartlist_t *detached_out)
Definition: circuitmux.c:213
MOCK_IMPL
#define MOCK_IMPL(rv, funcname, arglist)
Definition: testsupport.h:133
channel_free_list
static void channel_free_list(smartlist_t *channels, int mark_for_close)
Definition: channel.c:2182
channel_listener_t::close
void(* close)(channel_listener_t *)
Definition: channel.h:491
channel_t::has_queued_writes
int(* has_queued_writes)(channel_t *)
Definition: channel.h:348
channel_clear_client
void channel_clear_client(channel_t *chan)
Definition: channel.c:2908
channel_t::last_warned_circ_ids_exhausted
ratelim_t last_warned_circ_ids_exhausted
Definition: channel.h:438
channel_listener_state_can_transition
int channel_listener_state_can_transition(channel_listener_state_t from, channel_listener_state_t to)
Definition: channel.c:283
channel_mark_client
void channel_mark_client(channel_t *chan)
Definition: channel.c:2895
tor_assert
#define tor_assert(expr)
Definition: util_bug.h:102
LD_BUG
#define LD_BUG
Definition: log.h:86
channel_state_to_string
const char * channel_state_to_string(channel_state_t state)
Definition: channel.c:315
ed25519_pubkey_eq
int ed25519_pubkey_eq(const ed25519_public_key_t *key1, const ed25519_public_key_t *key2)
Definition: crypto_ed25519.c:642
router.h
Header file for router.c.
channel_listener_t::describe_transport
const char *(* describe_transport)(channel_listener_t *)
Definition: channel.h:493
channel_change_state
void channel_change_state(channel_t *chan, channel_state_t to_state)
Definition: channel.c:1612
channel_mark_for_close
void channel_mark_for_close(channel_t *chan)
Definition: channel.c:1137
channel_listener_t::timestamp_created
time_t timestamp_created
Definition: channel.h:483
channel.h
Header file for channel.c.
crypto_pk_cmp_keys
int crypto_pk_cmp_keys(const crypto_pk_t *a, const crypto_pk_t *b)
Definition: crypto_rsa_nss.c:302
LD_GENERAL
#define LD_GENERAL
Definition: log.h:62
PADDING_TYPE_ENABLED_CELL
@ PADDING_TYPE_ENABLED_CELL
Definition: rephist.h:99
channel_remote_identity_matches
static int channel_remote_identity_matches(const channel_t *chan, const char *rsa_id_digest, const ed25519_public_key_t *ed_id)
Definition: channel.c:667
channel_t::n_cells_xmitted
uint64_t n_cells_xmitted
Definition: channel.h:458
channel_t::padding_timer
struct tor_timer_t * padding_timer
Definition: channel.h:235
channel_is_better
int channel_is_better(channel_t *a, channel_t *b)
Definition: channel.c:2337
channel_when_last_client
time_t channel_when_last_client(channel_t *chan)
Definition: channel.c:3231
channel_listener_register
void channel_listener_register(channel_listener_t *chan_l)
Definition: channel.c:483
channel_t::free_fn
void(* free_fn)(channel_t *)
Definition: channel.h:316
channel_listener_timestamp_active
void channel_listener_timestamp_active(channel_listener_t *chan_l)
Definition: channel.c:3128
channel_t::close
void(* close)(channel_t *)
Definition: channel.h:318
channel_listener_t::reason_for_closing
enum channel_listener_t::@2 reason_for_closing
tor_reallocarray_
void * tor_reallocarray_(void *ptr, size_t sz1, size_t sz2)
Definition: malloc.c:146
channel_close_from_lower_layer
void channel_close_from_lower_layer(channel_t *chan)
Definition: channel.c:1216
channel_listener_describe_transport
const char * channel_listener_describe_transport(channel_listener_t *chan_l)
Definition: channel.c:2512
smartlist_add
void smartlist_add(smartlist_t *sl, void *element)
Definition: smartlist_core.c:117
channel_t::has_been_open
unsigned int has_been_open
Definition: channel.h:203
channel_update_bad_for_new_circs
void channel_update_bad_for_new_circs(const char *digest, int force)
Definition: channel.c:3427
CHANNEL_LISTENER_STATE_CLOSED
@ CHANNEL_LISTENER_STATE_CLOSED
Definition: channel.h:135
channel_next_with_rsa_identity
channel_t * channel_next_with_rsa_identity(channel_t *chan)
Definition: channel.c:731
channel_is_canonical
int channel_is_canonical(channel_t *chan)
Definition: channel.c:2922
channel_when_last_xmit
time_t channel_when_last_xmit(channel_t *chan)
Definition: channel.c:3242
ed25519_public_key_is_zero
int ed25519_public_key_is_zero(const ed25519_public_key_t *pubkey)
Definition: crypto_ed25519.c:227
channel_mark_bad_for_new_circs
void channel_mark_bad_for_new_circs(channel_t *chan)
Definition: channel.c:2867
channel_get_cell_handler
channel_cell_handler_fn_ptr channel_get_cell_handler(channel_t *chan)
Definition: channel.c:1085
channel_listener_t::dumpstats
void(* dumpstats)(channel_listener_t *, int)
Definition: channel.h:495
channel_set_cell_handlers
void channel_set_cell_handlers(channel_t *chan, channel_cell_handler_fn_ptr cell_handler)
Definition: channel.c:1102
channel_t::is_canonical
int(* is_canonical)(channel_t *)
Definition: channel.h:353
compat_time.h
Functions and types for monotonic times.
channel_t::timestamp_client
time_t timestamp_client
Definition: channel.h:441
channel_more_to_flush
int channel_more_to_flush(channel_t *chan)
Definition: channel.c:1773
channel_listener_t::state
channel_listener_state_t state
Definition: channel.h:463
channel_listener_t::registered
unsigned char registered
Definition: channel.h:471
channel_dumpstats
void channel_dumpstats(int severity)
Definition: channel.c:2071
channel_write_packed_cell
int channel_write_packed_cell(channel_t *chan, packed_cell_t *cell)
Definition: channel.c:1484
ED25519_PUBKEY_LEN
#define ED25519_PUBKEY_LEN
Definition: x25519_sizes.h:27
smartlist_new
smartlist_t * smartlist_new(void)
Definition: smartlist_core.c:26
tor_addr_make_unspec
void tor_addr_make_unspec(tor_addr_t *a)
Definition: address.c:225
channel_describe_transport
const char * channel_describe_transport(channel_t *chan)
Definition: channel.c:2497
write_packed_cell
static int write_packed_cell(channel_t *chan, packed_cell_t *cell)
Definition: channel.c:1420
circuit_n_chan_done
void circuit_n_chan_done(channel_t *chan, int status, int close_origin_circuits)
Definition: circuitbuild.c:627
channel_t::reason_for_closing
enum channel_t::@0 reason_for_closing
channel_t::n_cells_recved
uint64_t n_cells_recved
Definition: channel.h:456
circuitmux.h
Header file for circuitmux.c.
SMARTLIST_FOREACH
#define SMARTLIST_FOREACH(sl, type, var, cmd)
Definition: smartlist_foreach.h:112
channel_listener_timestamp_created
void channel_listener_timestamp_created(channel_listener_t *chan_l)
Definition: channel.c:3091
channel_when_created
time_t channel_when_created(channel_t *chan)
Definition: channel.c:3220
channel_t::cmux
circuitmux_t * cmux
Definition: channel.h:397
ratelim_t::rate
int rate
Definition: ratelim.h:44
packed_cell_get_command
uint8_t packed_cell_get_command(const packed_cell_t *cell, int wide_circ_ids)
Definition: relay.c:2867
networkstatus.h
Header file for networkstatus.c.
channel_tls_connect
channel_t * channel_tls_connect(const tor_addr_t *addr, uint16_t port, const char *id_digest, const ed25519_public_key_t *ed_id)
Definition: channeltls.c:191
scheduler.h
Header file for scheduler*.c.
cell_t
Definition: cell_st.h:17
geoip_stats.h
Header file for geoip_stats.c.
packed_cell_is_destroy
int packed_cell_is_destroy(channel_t *chan, const packed_cell_t *packed_cell, circid_t *circid_out)
Definition: channel.c:2005
channel_t::is_incoming
unsigned int is_incoming
Definition: channel.h:427
tor_memeq
int tor_memeq(const void *a, const void *b, size_t sz)
Definition: di_ops.c:107
dirlist.h
Header file for dirlist.c.
scheduler_channel_doesnt_want_writes
void scheduler_channel_doesnt_want_writes(channel_t *chan)
Definition: scheduler.c:512
channelpadding_disable_padding_on_channel
void channelpadding_disable_padding_on_channel(channel_t *chan)
Definition: channelpadding.c:678
channel_free_
void channel_free_(channel_t *chan)
Definition: channel.c:902
channel_is_local
int channel_is_local(channel_t *chan)
Definition: channel.c:2968
channel_run_cleanup
void channel_run_cleanup(void)
Definition: channel.c:2133
circuitlist.h
Header file for circuitlist.c.
mainloop.h
Header file for mainloop.c.
DIGEST_LEN
#define DIGEST_LEN
Definition: digest_sizes.h:20
CHANNEL_STATE_MAINT
@ CHANNEL_STATE_MAINT
Definition: channel.h:94
LD_CHANNEL
#define LD_CHANNEL
Definition: log.h:105
channel_describe_peer
const char * channel_describe_peer(channel_t *chan)
Definition: channel.c:2804
channel_state_t
channel_state_t
Definition: channel.h:50
channel_timestamp_client
void channel_timestamp_client(channel_t *chan)
Definition: channel.c:3162
packed_cell_t
Definition: cell_queue_st.h:18
PADDING_TYPE_ENABLED_TOTAL
@ PADDING_TYPE_ENABLED_TOTAL
Definition: rephist.h:97
channel_t::describe_peer
const char *(* describe_peer)(const channel_t *)
Definition: channel.h:346
tor_memneq
#define tor_memneq(a, b, sz)
Definition: di_ops.h:21
entrynodes.h
Header file for circuitbuild.c.
channel_add_to_digest_map
STATIC void channel_add_to_digest_map(channel_t *chan)
Definition: channel.c:560
channel_listener_set_listener_fn
void channel_listener_set_listener_fn(channel_listener_t *chan_l, channel_listener_fn_ptr listener)
Definition: channel.c:1062
channel_find_by_global_id
channel_t * channel_find_by_global_id(uint64_t global_identifier)
Definition: channel.c:650
mainloop_schedule_postloop_cleanup
void mainloop_schedule_postloop_cleanup(void)
Definition: mainloop.c:1634
LD_OR
#define LD_OR
Definition: log.h:92
channel_t::timestamp_xfer
monotime_coarse_t timestamp_xfer
Definition: channel.h:311
channel_dump_transport_statistics
void channel_dump_transport_statistics(channel_t *chan, int severity)
Definition: channel.c:2774
GEOIP_CLIENT_CONNECT
@ GEOIP_CLIENT_CONNECT
Definition: geoip_stats.h:24
circuit_build_times_network_is_live
void circuit_build_times_network_is_live(circuit_build_times_t *cbt)
Definition: circuitstats.c:1418
channel_flush_some_cells
ssize_t channel_flush_some_cells(channel_t *chan, ssize_t num_cells)
Definition: channel.c:1730
channel_t::circ_id_type
circ_id_type_bitfield_t circ_id_type
Definition: channel.h:405
channel_state_can_transition
int channel_state_can_transition(channel_state_t from, channel_state_t to)
Definition: channel.c:237
tor_digest_is_zero
int tor_digest_is_zero(const char *digest)
Definition: util_string.c:96
channel_listener_mark_for_close
void channel_listener_mark_for_close(channel_listener_t *chan_l)
Definition: channel.c:1176
ed25519_public_key_t
Definition: crypto_ed25519.h:23
circuitmux_num_circuits
unsigned int circuitmux_num_circuits(circuitmux_t *cmux)
Definition: circuitmux.c:713
channel_t::addr_according_to_peer
tor_addr_t addr_according_to_peer
Definition: channel.h:240
channel_rsa_id_group_set_badness
static void channel_rsa_id_group_set_badness(struct channel_list_t *lst, int force)
Definition: channel.c:3368
channel_t::timestamp_xmit
time_t timestamp_xmit
Definition: channel.h:443
channel_t::matches_extend_info
int(* matches_extend_info)(channel_t *, extend_info_t *)
Definition: channel.h:355
channel_init_listener
void channel_init_listener(channel_listener_t *chan_l)
Definition: channel.c:886
connection_or_single_set_badness_
int connection_or_single_set_badness_(time_t now, or_connection_t *or_conn, int force)
Definition: connection_or.c:998
channel_mark_remote
void channel_mark_remote(channel_t *chan)
Definition: channel.c:2999
circuitmux_num_cells
unsigned int circuitmux_num_cells(circuitmux_t *cmux)
Definition: circuitmux.c:689
channel_listener_state_is_valid
int channel_listener_state_is_valid(channel_listener_state_t state)
Definition: channel.c:210
nodelist.h
Header file for nodelist.c.
channel_num_cells_writeable
int channel_num_cells_writeable(channel_t *chan)
Definition: channel.c:3045
routerlist.h
Header file for routerlist.c.
channel_listener_queue_incoming
void channel_listener_queue_incoming(channel_listener_t *listener, channel_t *incoming)
Definition: channel.c:1925
rendservice.h
Header file for rendservice.c.
circuitstats.h
Header file for circuitstats.c.
channel_check_for_duplicates
void channel_check_for_duplicates(void)
Definition: channel.c:748
channel_listener_dump_transport_statistics
void channel_listener_dump_transport_statistics(channel_listener_t *chan_l, int severity)
Definition: channel.c:2787
tor_addr_to_str_dup
char * tor_addr_to_str_dup(const tor_addr_t *addr)
Definition: address.c:1164
channel_process_cell
void channel_process_cell(channel_t *chan, cell_t *cell)
Definition: channel.c:1976
channel_t
Definition: channel.h:181
PADDING_TYPE_TOTAL
@ PADDING_TYPE_TOTAL
Definition: rephist.h:95
channel_t::scheduler_state
enum channel_t::@1 scheduler_state
command
tor_cmdline_mode_t command
Definition: config.c:2447
channel_t::describe_transport
const char *(* describe_transport)(channel_t *)
Definition: channel.h:320
channel_state_is_valid
int channel_state_is_valid(channel_state_t state)
Definition: channel.c:185
channel_t::ed25519_identity
struct ed25519_public_key_t ed25519_identity
Definition: channel.h:388
channel_mark_incoming
void channel_mark_incoming(channel_t *chan)
Definition: channel.c:2951
channel_find_by_remote_identity
channel_t * channel_find_by_remote_identity(const char *rsa_id_digest, const ed25519_public_key_t *ed_id)
Definition: channel.c:697
rep_hist_padding_count_write
void rep_hist_padding_count_write(padding_type_t type)
Definition: rephist.c:1967
channel_listener_run_cleanup
void channel_listener_run_cleanup(void)
Definition: channel.c:2159
packed_cell_t::body
char body[CELL_MAX_NETWORK_SIZE]
Definition: cell_queue_st.h:21
channel_remove_from_digest_map
static void channel_remove_from_digest_map(channel_t *chan)
Definition: channel.c:597
channel_listener_t::timestamp_accepted
time_t timestamp_accepted
Definition: channel.h:504
channel_listener_t::global_identifier
uint64_t global_identifier
Definition: channel.h:468
channel_notify_flushed
void channel_notify_flushed(channel_t *chan)
Definition: channel.c:1790
channel_listener_unregister
void channel_listener_unregister(channel_listener_t *chan_l)
Definition: channel.c:524
CHANNEL_LISTENER_STATE_ERROR
@ CHANNEL_LISTENER_STATE_ERROR
Definition: channel.h:166
CIRC_ID_TYPE_LOWER
@ CIRC_ID_TYPE_LOWER
Definition: channel.h:40
channel_listener_change_state
void channel_listener_change_state(channel_listener_t *chan_l, channel_listener_state_t to_state)
Definition: channel.c:1639
channel_free_all
void channel_free_all(void)
Definition: channel.c:2246
get_options
const or_options_t * get_options(void)
Definition: config.c:928
channel_force_xfree
static void channel_force_xfree(channel_t *chan)
Definition: channel.c:981
channel_note_destroy_pending
void channel_note_destroy_pending(channel_t *chan, circid_t id)
Definition: circuitlist.c:411
geoip_note_client_seen
void geoip_note_client_seen(geoip_client_action_t action, const tor_addr_t *addr, const char *transport_name, time_t now)
Definition: geoip_stats.c:227
circuitbuild.h
Header file for circuitbuild.c.
circuitmux_num_active_circuits
unsigned int circuitmux_num_active_circuits(circuitmux_t *cmux)
Definition: circuitmux.c:701
channel_listener_dump_statistics
void channel_listener_dump_statistics(channel_listener_t *chan_l, int severity)
Definition: channel.c:2708
channel_t::registered
unsigned char registered
Definition: channel.h:200
get_uint32
static uint32_t get_uint32(const void *cp)
Definition: bytes.h:54
smartlist_clear
void smartlist_clear(smartlist_t *sl)
Definition: smartlist_core.c:50
channel_dump_statistics
void channel_dump_statistics(channel_t *chan, int severity)
Definition: channel.c:2526
channel_t::write_packed_cell
int(* write_packed_cell)(channel_t *, packed_cell_t *)
Definition: channel.h:365
channel_mark_outgoing
void channel_mark_outgoing(channel_t *chan)
Definition: channel.c:3028
channel_listener_dumpstats
void channel_listener_dumpstats(int severity)
Definition: channel.c:2102
get_tlsclient_identity_key
crypto_pk_t * get_tlsclient_identity_key(void)
Definition: router.c:417
channel_listener_t::n_accepted
uint64_t n_accepted
Definition: channel.h:507
channel_clear_identity_digest
void channel_clear_identity_digest(channel_t *chan)
Definition: channel.c:1302
IF_BUG_ONCE
#define IF_BUG_ONCE(cond)
Definition: util_bug.h:246
geoip_change_dirreq_state
void geoip_change_dirreq_state(uint64_t dirreq_id, dirreq_type_t type, dirreq_state_t new_state)
Definition: geoip_stats.c:550
relay.h
Header file for relay.c.
channel_is_bad_for_new_circs
int channel_is_bad_for_new_circs(channel_t *chan)
Definition: channel.c:2854
channel_listener_process_incoming
void channel_listener_process_incoming(channel_listener_t *listener)
Definition: channel.c:1807
channel_t::cell_handler
channel_cell_handler_fn_ptr cell_handler
Definition: channel.h:325
channeltls.h
Header file for channeltls.c.
channel_listener_free_
void channel_listener_free_(channel_listener_t *chan_l)
Definition: channel.c:954
channel_clear_remote_end
void channel_clear_remote_end(channel_t *chan)
Definition: channel.c:1390
HT_HEAD
static HT_HEAD(channel_gid_map, channel_t)
Definition: channel.c:109
timers.h
Header for timers.c.
channel_do_open_actions
void channel_do_open_actions(channel_t *chan)
Definition: channel.c:1859
channel_register
void channel_register(channel_t *chan)
Definition: channel.c:386
channelpadding_reduce_padding_on_channel
void channelpadding_reduce_padding_on_channel(channel_t *chan)
Definition: channelpadding.c:692
channel_listener_t
Definition: channel.h:461
channel_listener_timestamp_accepted
void channel_listener_timestamp_accepted(channel_listener_t *chan_l)
Definition: channel.c:3145
channel_listener_state_to_string
const char * channel_listener_state_to_string(channel_listener_state_t state)
Definition: channel.c:350
channel_t::dumpstats
void(* dumpstats)(channel_t *, int)
Definition: channel.h:322
channel_get_for_extend
channel_t * channel_get_for_extend(const char *rsa_id_digest, const ed25519_public_key_t *ed_id, const tor_addr_t *target_ipv4_addr, const tor_addr_t *target_ipv6_addr, const char **msg_out, int *launch_out)
Definition: channel.c:2405
channel_listener_free_list
static void channel_listener_free_list(smartlist_t *channels, int mark_for_close)
Definition: channel.c:2213
channel_t::next_padding_time
monotime_coarse_t next_padding_time
Definition: channel.h:232
SMARTLIST_FOREACH_BEGIN
#define SMARTLIST_FOREACH_BEGIN(sl, type, var)
Definition: smartlist_foreach.h:78
crypto_pk_t
Definition: crypto_rsa_nss.c:37
channel_init
void channel_init(channel_t *chan)
Definition: channel.c:847
SMARTLIST_DEL_CURRENT
#define SMARTLIST_DEL_CURRENT(sl, var)
Definition: smartlist_foreach.h:120
channel_connect
channel_t * channel_connect(const tor_addr_t *addr, uint16_t port, const char *id_digest, const ed25519_public_key_t *ed_id)
Definition: channel.c:2319
fast_memcmp
#define fast_memcmp(a, b, c)
Definition: di_ops.h:28
channel_matches_extend_info
int channel_matches_extend_info(channel_t *chan, extend_info_t *extend_info)
Definition: channel.c:3259
channel_t::sched_heap_idx
int sched_heap_idx
Definition: channel.h:295
CHANNEL_STATE_CLOSING
@ CHANNEL_STATE_CLOSING
Definition: channel.h:105
circuitmux_set_policy
void circuitmux_set_policy(circuitmux_t *cmux, const circuitmux_policy_t *pol)
Definition: circuitmux.c:427
channel_t::is_canonical_to_peer
unsigned int is_canonical_to_peer
Definition: channel.h:224
connection_or_digest_is_known_relay
int connection_or_digest_is_known_relay(const char *id_digest)
Definition: connection_or.c:786
CHANNEL_STATE_LAST
@ CHANNEL_STATE_LAST
Definition: channel.h:121
HT_PROTOTYPE
HT_PROTOTYPE(hs_circuitmap_ht, circuit_t, hs_circuitmap_node, hs_circuit_hash_token, hs_circuits_have_same_token)
channel_mark_local
void channel_mark_local(channel_t *chan)
Definition: channel.c:2983
channel_listener_state_t
channel_listener_state_t
Definition: channel.h:126
channel_t::timestamp_recv
time_t timestamp_recv
Definition: channel.h:442
config.h
Header file for config.c.
CHANNEL_LISTENER_STATE_CLOSING
@ CHANNEL_LISTENER_STATE_CLOSING
Definition: channel.h:156
get_uint16
static uint16_t get_uint16(const void *cp)
Definition: bytes.h:42
channel_t::matches_target
int(* matches_target)(channel_t *, const tor_addr_t *)
Definition: channel.h:357
channel_t::global_identifier
uint64_t global_identifier
Definition: channel.h:197
channel_listener_t::free_fn
void(* free_fn)(channel_listener_t *)
Definition: channel.h:489
channel_set_circid_type
void channel_set_circid_type(channel_t *chan, crypto_pk_t *identity_rcvd, int consider_identity)
Definition: channel.c:3322
tor_log
void tor_log(int severity, log_domain_mask_t domain, const char *format,...)
Definition: log.c:628
CIRC_ID_TYPE_HIGHER
@ CIRC_ID_TYPE_HIGHER
Definition: channel.h:41
channel_timestamp_recv
void channel_timestamp_recv(channel_t *chan)
Definition: channel.c:3178
channel_t::timestamp_last_had_circuits
time_t timestamp_last_had_circuits
Definition: channel.h:448
channel_t::num_n_circuits
unsigned int num_n_circuits
Definition: channel.h:410
channel_t::padding_enabled
unsigned int padding_enabled
Definition: channel.h:214
CHANNEL_STATE_OPEN
@ CHANNEL_STATE_OPEN
Definition: channel.h:82
CHANNEL_LISTENER_STATE_LISTENING
@ CHANNEL_LISTENER_STATE_LISTENING
Definition: channel.h:146
STATIC
#define STATIC
Definition: testsupport.h:32
channel_get_addr_if_possible
int channel_get_addr_if_possible(const channel_t *chan, tor_addr_t *addr_out)
Definition: channel.c:2824
channel_flush_from_first_active_circuit
int channel_flush_from_first_active_circuit(channel_t *chan, int max)
Definition: relay.c:2892
channel_t::timer_handle
struct channel_handle_t * timer_handle
Definition: channel.h:237
cell_queue_st.h
Cell queue structures.
channel_num_circuits
unsigned int channel_num_circuits(channel_t *chan)
Definition: channel.c:3305
channel_is_outgoing
int channel_is_outgoing(channel_t *chan)
Definition: channel.c:3014
networkstatus_get_param
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)
Definition: networkstatus.c:2495
CIRC_ID_TYPE_NEITHER
@ CIRC_ID_TYPE_NEITHER
Definition: channel.h:44
connection_or_group_set_badness_
void connection_or_group_set_badness_(smartlist_t *group, int force)
Definition: connection_or.c:1040
smartlist_sort
void smartlist_sort(smartlist_t *sl, int(*compare)(const void **a, const void **b))
Definition: smartlist.c:334
channel_send_destroy
int channel_send_destroy(circid_t circ_id, channel_t *chan, int reason)
Definition: channel.c:2031
channel_unregister
void channel_unregister(channel_t *chan)
Definition: channel.c:444
channel_t::is_local
unsigned int is_local
Definition: channel.h:434
channel_listener_t::incoming_list
smartlist_t * incoming_list
Definition: channel.h:501
channel_timestamp_xmit
void channel_timestamp_xmit(channel_t *chan)
Definition: channel.c:3198
PADDING_TYPE_CELL
@ PADDING_TYPE_CELL
Definition: rephist.h:93
smartlist_t
Definition: smartlist_core.h:26
smartlist_remove
void smartlist_remove(smartlist_t *sl, const void *element)
Definition: smartlist_core.c:151
channel_set_identity_digest
void channel_set_identity_digest(channel_t *chan, const char *identity_digest, const ed25519_public_key_t *ed_identity)
Definition: channel.c:1331
rephist.h
Header file for rephist.c.
channel_is_incoming
int channel_is_incoming(channel_t *chan)
Definition: channel.c:2937
connection_or.h
Header file for connection_or.c.
CHANNEL_LISTENER_STATE_LAST
@ CHANNEL_LISTENER_STATE_LAST
Definition: channel.h:170
DIRREQ_CHANNEL_BUFFER_FLUSHED
@ DIRREQ_CHANNEL_BUFFER_FLUSHED
Definition: geoip_stats.h:73
channel_t::state
channel_state_t state
Definition: channel.h:192
extend_info_t
Definition: extend_info_st.h:27
channel_change_state_
static void channel_change_state_(channel_t *chan, channel_state_t to_state)
Definition: channel.c:1519
channel_close_for_error
void channel_close_for_error(channel_t *chan)
Definition: channel.c:1244
circid_t
uint32_t circid_t
Definition: or.h:609
channel_matches_target_addr_for_extend
STATIC bool channel_matches_target_addr_for_extend(channel_t *chan, const tor_addr_t *target_ipv4_addr, const tor_addr_t *target_ipv6_addr)
Definition: channel.c:3279
channel_listener_t::listener
channel_listener_fn_ptr listener
Definition: channel.h:498
CHANNEL_STATE_ERROR
@ CHANNEL_STATE_ERROR
Definition: channel.h:117
channel_t::is_client
unsigned int is_client
Definition: channel.h:424
or.h
Master header file for Tor-specific functionality.
circuitmux_mark_destroyed_circids_usable
void circuitmux_mark_destroyed_circids_usable(circuitmux_t *cmux, channel_t *chan)
Definition: circuitmux.c:323
router_set_status
void router_set_status(const char *digest, int up)
Definition: nodelist.c:2290
channel_closed
void channel_closed(channel_t *chan)
Definition: channel.c:1271