3479 lines
101 KiB
C
3479 lines
101 KiB
C
|
|
/* * Copyright (c) 2012-2017, The Tor Project, Inc. */
|
|
/* See LICENSE for licensing information */
|
|
|
|
/**
|
|
* \file channel.c
|
|
*
|
|
* \brief OR/OP-to-OR channel abstraction layer. A channel's job is to
|
|
* transfer cells from Tor instance to Tor instance. Currently, there is only
|
|
* one implementation of the channel abstraction: in channeltls.c.
|
|
*
|
|
* Channels are a higher-level abstraction than or_connection_t: In general,
|
|
* any means that two Tor relays use to exchange cells, or any means that a
|
|
* relay and a client use to exchange cells, is a channel.
|
|
*
|
|
* Channels differ from pluggable transports in that they do not wrap an
|
|
* underlying protocol over which cells are transmitted: they <em>are</em> the
|
|
* underlying protocol.
|
|
*
|
|
* This module defines the generic parts of the channel_t interface, and
|
|
* provides the machinery necessary for specialized implementations to be
|
|
* created. At present, there is one specialized implementation in
|
|
* channeltls.c, which uses connection_or.c to send cells over a TLS
|
|
* connection.
|
|
*
|
|
* Every channel implementation is responsible for being able to transmit
|
|
* cells that are passed to it
|
|
*
|
|
* For *inbound* cells, the entry point is: channel_process_cell(). It takes a
|
|
* cell and will pass it to the cell handler set by
|
|
* channel_set_cell_handlers(). Currently, this is passed back to the command
|
|
* subsystem which is command_process_cell().
|
|
*
|
|
* NOTE: For now, the separation between channels and specialized channels
|
|
* (like channeltls) is not that well defined. So the channeltls layer calls
|
|
* channel_process_cell() which originally comes from the connection subsytem.
|
|
* This should be hopefully be fixed with #23993.
|
|
*
|
|
* For *outbound* cells, the entry point is: channel_write_packed_cell().
|
|
* Only packed cells are dequeued from the circuit queue by the scheduler
|
|
* which uses channel_flush_from_first_active_circuit() to decide which cells
|
|
* to flush from which circuit on the channel. They are then passed down to
|
|
* the channel subsystem. This calls the low layer with the function pointer
|
|
* .write_packed_cell().
|
|
*
|
|
* Each specialized channel (currently only channeltls_t) MUST implement a
|
|
* series of function found in channel_t. See channel.h for more
|
|
* documentation.
|
|
**/
|
|
|
|
/*
|
|
* Define this so channel.h gives us things only channel_t subclasses
|
|
* should touch.
|
|
*/
|
|
#define TOR_CHANNEL_INTERNAL_
|
|
|
|
/* This one's for stuff only channel.c and the test suite should see */
|
|
#define CHANNEL_PRIVATE_
|
|
|
|
#include "or.h"
|
|
#include "channel.h"
|
|
#include "channeltls.h"
|
|
#include "channelpadding.h"
|
|
#include "circuitbuild.h"
|
|
#include "circuitlist.h"
|
|
#include "circuitstats.h"
|
|
#include "config.h"
|
|
#include "connection_or.h" /* For var_cell_free() */
|
|
#include "circuitmux.h"
|
|
#include "entrynodes.h"
|
|
#include "geoip.h"
|
|
#include "main.h"
|
|
#include "nodelist.h"
|
|
#include "relay.h"
|
|
#include "rephist.h"
|
|
#include "router.h"
|
|
#include "routerlist.h"
|
|
#include "scheduler.h"
|
|
#include "compat_time.h"
|
|
#include "networkstatus.h"
|
|
#include "rendservice.h"
|
|
|
|
/* Global lists of channels */
|
|
|
|
/* All channel_t instances */
|
|
static smartlist_t *all_channels = NULL;
|
|
|
|
/* All channel_t instances not in ERROR or CLOSED states */
|
|
static smartlist_t *active_channels = NULL;
|
|
|
|
/* All channel_t instances in ERROR or CLOSED states */
|
|
static smartlist_t *finished_channels = NULL;
|
|
|
|
/* All channel_listener_t instances */
|
|
static smartlist_t *all_listeners = NULL;
|
|
|
|
/* All channel_listener_t instances in LISTENING state */
|
|
static smartlist_t *active_listeners = NULL;
|
|
|
|
/* All channel_listener_t instances in LISTENING state */
|
|
static smartlist_t *finished_listeners = NULL;
|
|
|
|
/** Map from channel->global_identifier to channel. Contains the same
|
|
* elements as all_channels. */
|
|
static HT_HEAD(channel_gid_map, channel_s) channel_gid_map = HT_INITIALIZER();
|
|
|
|
static unsigned
|
|
channel_id_hash(const channel_t *chan)
|
|
{
|
|
return (unsigned) chan->global_identifier;
|
|
}
|
|
static int
|
|
channel_id_eq(const channel_t *a, const channel_t *b)
|
|
{
|
|
return a->global_identifier == b->global_identifier;
|
|
}
|
|
HT_PROTOTYPE(channel_gid_map, channel_s, gidmap_node,
|
|
channel_id_hash, channel_id_eq)
|
|
HT_GENERATE2(channel_gid_map, channel_s, gidmap_node,
|
|
channel_id_hash, channel_id_eq,
|
|
0.6, tor_reallocarray_, tor_free_)
|
|
|
|
HANDLE_IMPL(channel, channel_s,)
|
|
|
|
/* Counter for ID numbers */
|
|
static uint64_t n_channels_allocated = 0;
|
|
|
|
/* Digest->channel map
|
|
*
|
|
* Similar to the one used in connection_or.c, this maps from the identity
|
|
* digest of a remote endpoint to a channel_t to that endpoint. Channels
|
|
* should be placed here when registered and removed when they close or error.
|
|
* If more than one channel exists, follow the next_with_same_id pointer
|
|
* as a linked list.
|
|
*/
|
|
static HT_HEAD(channel_idmap, channel_idmap_entry_s) channel_identity_map =
|
|
HT_INITIALIZER();
|
|
|
|
typedef struct channel_idmap_entry_s {
|
|
HT_ENTRY(channel_idmap_entry_s) node;
|
|
uint8_t digest[DIGEST_LEN];
|
|
TOR_LIST_HEAD(channel_list_s, channel_s) channel_list;
|
|
} channel_idmap_entry_t;
|
|
|
|
static inline unsigned
|
|
channel_idmap_hash(const channel_idmap_entry_t *ent)
|
|
{
|
|
return (unsigned) siphash24g(ent->digest, DIGEST_LEN);
|
|
}
|
|
|
|
static inline int
|
|
channel_idmap_eq(const channel_idmap_entry_t *a,
|
|
const channel_idmap_entry_t *b)
|
|
{
|
|
return tor_memeq(a->digest, b->digest, DIGEST_LEN);
|
|
}
|
|
|
|
HT_PROTOTYPE(channel_idmap, channel_idmap_entry_s, node, channel_idmap_hash,
|
|
channel_idmap_eq)
|
|
HT_GENERATE2(channel_idmap, channel_idmap_entry_s, node, channel_idmap_hash,
|
|
channel_idmap_eq, 0.5, tor_reallocarray_, tor_free_)
|
|
|
|
/* Functions to maintain the digest map */
|
|
static void channel_remove_from_digest_map(channel_t *chan);
|
|
|
|
static void channel_force_xfree(channel_t *chan);
|
|
static void channel_free_list(smartlist_t *channels,
|
|
int mark_for_close);
|
|
static void channel_listener_free_list(smartlist_t *channels,
|
|
int mark_for_close);
|
|
static void channel_listener_force_xfree(channel_listener_t *chan_l);
|
|
|
|
/***********************************
|
|
* Channel state utility functions *
|
|
**********************************/
|
|
|
|
/**
|
|
* Indicate whether a given channel state is valid.
|
|
*/
|
|
int
|
|
channel_state_is_valid(channel_state_t state)
|
|
{
|
|
int is_valid;
|
|
|
|
switch (state) {
|
|
case CHANNEL_STATE_CLOSED:
|
|
case CHANNEL_STATE_CLOSING:
|
|
case CHANNEL_STATE_ERROR:
|
|
case CHANNEL_STATE_MAINT:
|
|
case CHANNEL_STATE_OPENING:
|
|
case CHANNEL_STATE_OPEN:
|
|
is_valid = 1;
|
|
break;
|
|
case CHANNEL_STATE_LAST:
|
|
default:
|
|
is_valid = 0;
|
|
}
|
|
|
|
return is_valid;
|
|
}
|
|
|
|
/**
|
|
* Indicate whether a given channel listener state is valid.
|
|
*/
|
|
int
|
|
channel_listener_state_is_valid(channel_listener_state_t state)
|
|
{
|
|
int is_valid;
|
|
|
|
switch (state) {
|
|
case CHANNEL_LISTENER_STATE_CLOSED:
|
|
case CHANNEL_LISTENER_STATE_LISTENING:
|
|
case CHANNEL_LISTENER_STATE_CLOSING:
|
|
case CHANNEL_LISTENER_STATE_ERROR:
|
|
is_valid = 1;
|
|
break;
|
|
case CHANNEL_LISTENER_STATE_LAST:
|
|
default:
|
|
is_valid = 0;
|
|
}
|
|
|
|
return is_valid;
|
|
}
|
|
|
|
/**
|
|
* Indicate whether a channel state transition is valid.
|
|
*
|
|
* This function takes two channel states and indicates whether a
|
|
* transition between them is permitted (see the state definitions and
|
|
* transition table in or.h at the channel_state_t typedef).
|
|
*/
|
|
int
|
|
channel_state_can_transition(channel_state_t from, channel_state_t to)
|
|
{
|
|
int is_valid;
|
|
|
|
switch (from) {
|
|
case CHANNEL_STATE_CLOSED:
|
|
is_valid = (to == CHANNEL_STATE_OPENING);
|
|
break;
|
|
case CHANNEL_STATE_CLOSING:
|
|
is_valid = (to == CHANNEL_STATE_CLOSED ||
|
|
to == CHANNEL_STATE_ERROR);
|
|
break;
|
|
case CHANNEL_STATE_ERROR:
|
|
is_valid = 0;
|
|
break;
|
|
case CHANNEL_STATE_MAINT:
|
|
is_valid = (to == CHANNEL_STATE_CLOSING ||
|
|
to == CHANNEL_STATE_ERROR ||
|
|
to == CHANNEL_STATE_OPEN);
|
|
break;
|
|
case CHANNEL_STATE_OPENING:
|
|
is_valid = (to == CHANNEL_STATE_CLOSING ||
|
|
to == CHANNEL_STATE_ERROR ||
|
|
to == CHANNEL_STATE_OPEN);
|
|
break;
|
|
case CHANNEL_STATE_OPEN:
|
|
is_valid = (to == CHANNEL_STATE_CLOSING ||
|
|
to == CHANNEL_STATE_ERROR ||
|
|
to == CHANNEL_STATE_MAINT);
|
|
break;
|
|
case CHANNEL_STATE_LAST:
|
|
default:
|
|
is_valid = 0;
|
|
}
|
|
|
|
return is_valid;
|
|
}
|
|
|
|
/**
|
|
* Indicate whether a channel listener state transition is valid.
|
|
*
|
|
* This function takes two channel listener states and indicates whether a
|
|
* transition between them is permitted (see the state definitions and
|
|
* transition table in or.h at the channel_listener_state_t typedef).
|
|
*/
|
|
int
|
|
channel_listener_state_can_transition(channel_listener_state_t from,
|
|
channel_listener_state_t to)
|
|
{
|
|
int is_valid;
|
|
|
|
switch (from) {
|
|
case CHANNEL_LISTENER_STATE_CLOSED:
|
|
is_valid = (to == CHANNEL_LISTENER_STATE_LISTENING);
|
|
break;
|
|
case CHANNEL_LISTENER_STATE_CLOSING:
|
|
is_valid = (to == CHANNEL_LISTENER_STATE_CLOSED ||
|
|
to == CHANNEL_LISTENER_STATE_ERROR);
|
|
break;
|
|
case CHANNEL_LISTENER_STATE_ERROR:
|
|
is_valid = 0;
|
|
break;
|
|
case CHANNEL_LISTENER_STATE_LISTENING:
|
|
is_valid = (to == CHANNEL_LISTENER_STATE_CLOSING ||
|
|
to == CHANNEL_LISTENER_STATE_ERROR);
|
|
break;
|
|
case CHANNEL_LISTENER_STATE_LAST:
|
|
default:
|
|
is_valid = 0;
|
|
}
|
|
|
|
return is_valid;
|
|
}
|
|
|
|
/**
|
|
* Return a human-readable description for a channel state.
|
|
*/
|
|
const char *
|
|
channel_state_to_string(channel_state_t state)
|
|
{
|
|
const char *descr;
|
|
|
|
switch (state) {
|
|
case CHANNEL_STATE_CLOSED:
|
|
descr = "closed";
|
|
break;
|
|
case CHANNEL_STATE_CLOSING:
|
|
descr = "closing";
|
|
break;
|
|
case CHANNEL_STATE_ERROR:
|
|
descr = "channel error";
|
|
break;
|
|
case CHANNEL_STATE_MAINT:
|
|
descr = "temporarily suspended for maintenance";
|
|
break;
|
|
case CHANNEL_STATE_OPENING:
|
|
descr = "opening";
|
|
break;
|
|
case CHANNEL_STATE_OPEN:
|
|
descr = "open";
|
|
break;
|
|
case CHANNEL_STATE_LAST:
|
|
default:
|
|
descr = "unknown or invalid channel state";
|
|
}
|
|
|
|
return descr;
|
|
}
|
|
|
|
/**
|
|
* Return a human-readable description for a channel listener state.
|
|
*/
|
|
const char *
|
|
channel_listener_state_to_string(channel_listener_state_t state)
|
|
{
|
|
const char *descr;
|
|
|
|
switch (state) {
|
|
case CHANNEL_LISTENER_STATE_CLOSED:
|
|
descr = "closed";
|
|
break;
|
|
case CHANNEL_LISTENER_STATE_CLOSING:
|
|
descr = "closing";
|
|
break;
|
|
case CHANNEL_LISTENER_STATE_ERROR:
|
|
descr = "channel listener error";
|
|
break;
|
|
case CHANNEL_LISTENER_STATE_LISTENING:
|
|
descr = "listening";
|
|
break;
|
|
case CHANNEL_LISTENER_STATE_LAST:
|
|
default:
|
|
descr = "unknown or invalid channel listener state";
|
|
}
|
|
|
|
return descr;
|
|
}
|
|
|
|
/***************************************
|
|
* Channel registration/unregistration *
|
|
***************************************/
|
|
|
|
/**
|
|
* Register a channel.
|
|
*
|
|
* This function registers a newly created channel in the global lists/maps
|
|
* of active channels.
|
|
*/
|
|
void
|
|
channel_register(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
tor_assert(chan->global_identifier);
|
|
|
|
/* No-op if already registered */
|
|
if (chan->registered) return;
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Registering channel %p (ID " U64_FORMAT ") "
|
|
"in state %s (%d) with digest %s",
|
|
chan, U64_PRINTF_ARG(chan->global_identifier),
|
|
channel_state_to_string(chan->state), chan->state,
|
|
hex_str(chan->identity_digest, DIGEST_LEN));
|
|
|
|
/* Make sure we have all_channels, then add it */
|
|
if (!all_channels) all_channels = smartlist_new();
|
|
smartlist_add(all_channels, chan);
|
|
channel_t *oldval = HT_REPLACE(channel_gid_map, &channel_gid_map, chan);
|
|
tor_assert(! oldval);
|
|
|
|
/* Is it finished? */
|
|
if (CHANNEL_FINISHED(chan)) {
|
|
/* Put it in the finished list, creating it if necessary */
|
|
if (!finished_channels) finished_channels = smartlist_new();
|
|
smartlist_add(finished_channels, chan);
|
|
mainloop_schedule_postloop_cleanup();
|
|
} else {
|
|
/* Put it in the active list, creating it if necessary */
|
|
if (!active_channels) active_channels = smartlist_new();
|
|
smartlist_add(active_channels, chan);
|
|
|
|
if (!CHANNEL_IS_CLOSING(chan)) {
|
|
/* It should have a digest set */
|
|
if (!tor_digest_is_zero(chan->identity_digest)) {
|
|
/* Yeah, we're good, add it to the map */
|
|
channel_add_to_digest_map(chan);
|
|
} else {
|
|
log_info(LD_CHANNEL,
|
|
"Channel %p (global ID " U64_FORMAT ") "
|
|
"in state %s (%d) registered with no identity digest",
|
|
chan, U64_PRINTF_ARG(chan->global_identifier),
|
|
channel_state_to_string(chan->state), chan->state);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Mark it as registered */
|
|
chan->registered = 1;
|
|
}
|
|
|
|
/**
|
|
* Unregister a channel.
|
|
*
|
|
* This function removes a channel from the global lists and maps and is used
|
|
* when freeing a closed/errored channel.
|
|
*/
|
|
void
|
|
channel_unregister(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
/* No-op if not registered */
|
|
if (!(chan->registered)) return;
|
|
|
|
/* Is it finished? */
|
|
if (CHANNEL_FINISHED(chan)) {
|
|
/* Get it out of the finished list */
|
|
if (finished_channels) smartlist_remove(finished_channels, chan);
|
|
} else {
|
|
/* Get it out of the active list */
|
|
if (active_channels) smartlist_remove(active_channels, chan);
|
|
}
|
|
|
|
/* Get it out of all_channels */
|
|
if (all_channels) smartlist_remove(all_channels, chan);
|
|
channel_t *oldval = HT_REMOVE(channel_gid_map, &channel_gid_map, chan);
|
|
tor_assert(oldval == NULL || oldval == chan);
|
|
|
|
/* Mark it as unregistered */
|
|
chan->registered = 0;
|
|
|
|
/* Should it be in the digest map? */
|
|
if (!tor_digest_is_zero(chan->identity_digest) &&
|
|
!(CHANNEL_CONDEMNED(chan))) {
|
|
/* Remove it */
|
|
channel_remove_from_digest_map(chan);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Register a channel listener.
|
|
*
|
|
* This function registers a newly created channel listener in the global
|
|
* lists/maps of active channel listeners.
|
|
*/
|
|
void
|
|
channel_listener_register(channel_listener_t *chan_l)
|
|
{
|
|
tor_assert(chan_l);
|
|
|
|
/* No-op if already registered */
|
|
if (chan_l->registered) return;
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Registering channel listener %p (ID " U64_FORMAT ") "
|
|
"in state %s (%d)",
|
|
chan_l, U64_PRINTF_ARG(chan_l->global_identifier),
|
|
channel_listener_state_to_string(chan_l->state),
|
|
chan_l->state);
|
|
|
|
/* Make sure we have all_listeners, then add it */
|
|
if (!all_listeners) all_listeners = smartlist_new();
|
|
smartlist_add(all_listeners, chan_l);
|
|
|
|
/* Is it finished? */
|
|
if (chan_l->state == CHANNEL_LISTENER_STATE_CLOSED ||
|
|
chan_l->state == CHANNEL_LISTENER_STATE_ERROR) {
|
|
/* Put it in the finished list, creating it if necessary */
|
|
if (!finished_listeners) finished_listeners = smartlist_new();
|
|
smartlist_add(finished_listeners, chan_l);
|
|
} else {
|
|
/* Put it in the active list, creating it if necessary */
|
|
if (!active_listeners) active_listeners = smartlist_new();
|
|
smartlist_add(active_listeners, chan_l);
|
|
}
|
|
|
|
/* Mark it as registered */
|
|
chan_l->registered = 1;
|
|
}
|
|
|
|
/**
|
|
* Unregister a channel listener.
|
|
*
|
|
* This function removes a channel listener from the global lists and maps
|
|
* and is used when freeing a closed/errored channel listener.
|
|
*/
|
|
void
|
|
channel_listener_unregister(channel_listener_t *chan_l)
|
|
{
|
|
tor_assert(chan_l);
|
|
|
|
/* No-op if not registered */
|
|
if (!(chan_l->registered)) return;
|
|
|
|
/* Is it finished? */
|
|
if (chan_l->state == CHANNEL_LISTENER_STATE_CLOSED ||
|
|
chan_l->state == CHANNEL_LISTENER_STATE_ERROR) {
|
|
/* Get it out of the finished list */
|
|
if (finished_listeners) smartlist_remove(finished_listeners, chan_l);
|
|
} else {
|
|
/* Get it out of the active list */
|
|
if (active_listeners) smartlist_remove(active_listeners, chan_l);
|
|
}
|
|
|
|
/* Get it out of all_listeners */
|
|
if (all_listeners) smartlist_remove(all_listeners, chan_l);
|
|
|
|
/* Mark it as unregistered */
|
|
chan_l->registered = 0;
|
|
}
|
|
|
|
/*********************************
|
|
* Channel digest map maintenance
|
|
*********************************/
|
|
|
|
/**
|
|
* Add a channel to the digest map.
|
|
*
|
|
* This function adds a channel to the digest map and inserts it into the
|
|
* correct linked list if channels with that remote endpoint identity digest
|
|
* already exist.
|
|
*/
|
|
STATIC void
|
|
channel_add_to_digest_map(channel_t *chan)
|
|
{
|
|
channel_idmap_entry_t *ent, search;
|
|
|
|
tor_assert(chan);
|
|
|
|
/* Assert that the state makes sense */
|
|
tor_assert(!CHANNEL_CONDEMNED(chan));
|
|
|
|
/* Assert that there is a digest */
|
|
tor_assert(!tor_digest_is_zero(chan->identity_digest));
|
|
|
|
memcpy(search.digest, chan->identity_digest, DIGEST_LEN);
|
|
ent = HT_FIND(channel_idmap, &channel_identity_map, &search);
|
|
if (! ent) {
|
|
ent = tor_malloc(sizeof(channel_idmap_entry_t));
|
|
memcpy(ent->digest, chan->identity_digest, DIGEST_LEN);
|
|
TOR_LIST_INIT(&ent->channel_list);
|
|
HT_INSERT(channel_idmap, &channel_identity_map, ent);
|
|
}
|
|
TOR_LIST_INSERT_HEAD(&ent->channel_list, chan, next_with_same_id);
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Added channel %p (global ID " U64_FORMAT ") "
|
|
"to identity map in state %s (%d) with digest %s",
|
|
chan, U64_PRINTF_ARG(chan->global_identifier),
|
|
channel_state_to_string(chan->state), chan->state,
|
|
hex_str(chan->identity_digest, DIGEST_LEN));
|
|
}
|
|
|
|
/**
|
|
* Remove a channel from the digest map.
|
|
*
|
|
* This function removes a channel from the digest map and the linked list of
|
|
* channels for that digest if more than one exists.
|
|
*/
|
|
static void
|
|
channel_remove_from_digest_map(channel_t *chan)
|
|
{
|
|
channel_idmap_entry_t *ent, search;
|
|
|
|
tor_assert(chan);
|
|
|
|
/* Assert that there is a digest */
|
|
tor_assert(!tor_digest_is_zero(chan->identity_digest));
|
|
|
|
/* Pull it out of its list, wherever that list is */
|
|
TOR_LIST_REMOVE(chan, next_with_same_id);
|
|
|
|
memcpy(search.digest, chan->identity_digest, DIGEST_LEN);
|
|
ent = HT_FIND(channel_idmap, &channel_identity_map, &search);
|
|
|
|
/* Look for it in the map */
|
|
if (ent) {
|
|
/* Okay, it's here */
|
|
|
|
if (TOR_LIST_EMPTY(&ent->channel_list)) {
|
|
HT_REMOVE(channel_idmap, &channel_identity_map, ent);
|
|
tor_free(ent);
|
|
}
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Removed channel %p (global ID " U64_FORMAT ") from "
|
|
"identity map in state %s (%d) with digest %s",
|
|
chan, U64_PRINTF_ARG(chan->global_identifier),
|
|
channel_state_to_string(chan->state), chan->state,
|
|
hex_str(chan->identity_digest, DIGEST_LEN));
|
|
} else {
|
|
/* Shouldn't happen */
|
|
log_warn(LD_BUG,
|
|
"Trying to remove channel %p (global ID " U64_FORMAT ") with "
|
|
"digest %s from identity map, but couldn't find any with "
|
|
"that digest",
|
|
chan, U64_PRINTF_ARG(chan->global_identifier),
|
|
hex_str(chan->identity_digest, DIGEST_LEN));
|
|
}
|
|
}
|
|
|
|
/****************************
|
|
* Channel lookup functions *
|
|
***************************/
|
|
|
|
/**
|
|
* Find channel by global ID.
|
|
*
|
|
* This function searches for a channel by the global_identifier assigned
|
|
* at initialization time. This identifier is unique for the lifetime of the
|
|
* Tor process.
|
|
*/
|
|
channel_t *
|
|
channel_find_by_global_id(uint64_t global_identifier)
|
|
{
|
|
channel_t lookup;
|
|
channel_t *rv = NULL;
|
|
|
|
lookup.global_identifier = global_identifier;
|
|
rv = HT_FIND(channel_gid_map, &channel_gid_map, &lookup);
|
|
if (rv) {
|
|
tor_assert(rv->global_identifier == global_identifier);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/** Return true iff <b>chan</b> matches <b>rsa_id_digest</b> and <b>ed_id</b>.
|
|
* as its identity keys. If either is NULL, do not check for a match. */
|
|
static int
|
|
channel_remote_identity_matches(const channel_t *chan,
|
|
const char *rsa_id_digest,
|
|
const ed25519_public_key_t *ed_id)
|
|
{
|
|
if (BUG(!chan))
|
|
return 0;
|
|
if (rsa_id_digest) {
|
|
if (tor_memneq(rsa_id_digest, chan->identity_digest, DIGEST_LEN))
|
|
return 0;
|
|
}
|
|
if (ed_id) {
|
|
if (tor_memneq(ed_id->pubkey, chan->ed25519_identity.pubkey,
|
|
ED25519_PUBKEY_LEN))
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Find channel by RSA/Ed25519 identity of of the remote endpoint.
|
|
*
|
|
* This function looks up a channel by the digest of its remote endpoint's RSA
|
|
* identity key. If <b>ed_id</b> is provided and nonzero, only a channel
|
|
* matching the <b>ed_id</b> will be returned.
|
|
*
|
|
* It's possible that more than one channel to a given endpoint exists. Use
|
|
* channel_next_with_rsa_identity() to walk the list of channels; make sure
|
|
* to test for Ed25519 identity match too (as appropriate)
|
|
*/
|
|
channel_t *
|
|
channel_find_by_remote_identity(const char *rsa_id_digest,
|
|
const ed25519_public_key_t *ed_id)
|
|
{
|
|
channel_t *rv = NULL;
|
|
channel_idmap_entry_t *ent, search;
|
|
|
|
tor_assert(rsa_id_digest); /* For now, we require that every channel have
|
|
* an RSA identity, and that every lookup
|
|
* contain an RSA identity */
|
|
if (ed_id && ed25519_public_key_is_zero(ed_id)) {
|
|
/* Treat zero as meaning "We don't care about the presence or absence of
|
|
* an Ed key", not "There must be no Ed key". */
|
|
ed_id = NULL;
|
|
}
|
|
|
|
memcpy(search.digest, rsa_id_digest, DIGEST_LEN);
|
|
ent = HT_FIND(channel_idmap, &channel_identity_map, &search);
|
|
if (ent) {
|
|
rv = TOR_LIST_FIRST(&ent->channel_list);
|
|
}
|
|
while (rv && ! channel_remote_identity_matches(rv, rsa_id_digest, ed_id)) {
|
|
rv = channel_next_with_rsa_identity(rv);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/**
|
|
* Get next channel with digest.
|
|
*
|
|
* This function takes a channel and finds the next channel in the list
|
|
* with the same digest.
|
|
*/
|
|
channel_t *
|
|
channel_next_with_rsa_identity(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
return TOR_LIST_NEXT(chan, next_with_same_id);
|
|
}
|
|
|
|
/**
|
|
* Relays run this once an hour to look over our list of channels to other
|
|
* relays. It prints out some statistics if there are multiple connections
|
|
* to many relays.
|
|
*
|
|
* This function is similar to connection_or_set_bad_connections(),
|
|
* and probably could be adapted to replace it, if it was modified to actually
|
|
* take action on any of these connections.
|
|
*/
|
|
void
|
|
channel_check_for_duplicates(void)
|
|
{
|
|
channel_idmap_entry_t **iter;
|
|
channel_t *chan;
|
|
int total_relay_connections = 0, total_relays = 0, total_canonical = 0;
|
|
int total_half_canonical = 0;
|
|
int total_gt_one_connection = 0, total_gt_two_connections = 0;
|
|
int total_gt_four_connections = 0;
|
|
|
|
HT_FOREACH(iter, channel_idmap, &channel_identity_map) {
|
|
int connections_to_relay = 0;
|
|
|
|
/* Only consider relay connections */
|
|
if (!connection_or_digest_is_known_relay((char*)(*iter)->digest))
|
|
continue;
|
|
|
|
total_relays++;
|
|
|
|
for (chan = TOR_LIST_FIRST(&(*iter)->channel_list); chan;
|
|
chan = channel_next_with_rsa_identity(chan)) {
|
|
|
|
if (CHANNEL_CONDEMNED(chan) || !CHANNEL_IS_OPEN(chan))
|
|
continue;
|
|
|
|
connections_to_relay++;
|
|
total_relay_connections++;
|
|
|
|
if (chan->is_canonical(chan, 0)) total_canonical++;
|
|
|
|
if (!chan->is_canonical_to_peer && chan->is_canonical(chan, 0)
|
|
&& chan->is_canonical(chan, 1)) {
|
|
total_half_canonical++;
|
|
}
|
|
}
|
|
|
|
if (connections_to_relay > 1) total_gt_one_connection++;
|
|
if (connections_to_relay > 2) total_gt_two_connections++;
|
|
if (connections_to_relay > 4) total_gt_four_connections++;
|
|
}
|
|
|
|
#define MIN_RELAY_CONNECTIONS_TO_WARN 5
|
|
|
|
/* If we average 1.5 or more connections per relay, something is wrong */
|
|
if (total_relays > MIN_RELAY_CONNECTIONS_TO_WARN &&
|
|
total_relay_connections >= 1.5*total_relays) {
|
|
log_notice(LD_OR,
|
|
"Your relay has a very large number of connections to other relays. "
|
|
"Is your outbound address the same as your relay address? "
|
|
"Found %d connections to %d relays. Found %d current canonical "
|
|
"connections, in %d of which we were a non-canonical peer. "
|
|
"%d relays had more than 1 connection, %d had more than 2, and "
|
|
"%d had more than 4 connections.",
|
|
total_relay_connections, total_relays, total_canonical,
|
|
total_half_canonical, total_gt_one_connection,
|
|
total_gt_two_connections, total_gt_four_connections);
|
|
} else {
|
|
log_info(LD_OR, "Performed connection pruning. "
|
|
"Found %d connections to %d relays. Found %d current canonical "
|
|
"connections, in %d of which we were a non-canonical peer. "
|
|
"%d relays had more than 1 connection, %d had more than 2, and "
|
|
"%d had more than 4 connections.",
|
|
total_relay_connections, total_relays, total_canonical,
|
|
total_half_canonical, total_gt_one_connection,
|
|
total_gt_two_connections, total_gt_four_connections);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Initialize a channel.
|
|
*
|
|
* This function should be called by subclasses to set up some per-channel
|
|
* variables. I.e., this is the superclass constructor. Before this, the
|
|
* channel should be allocated with tor_malloc_zero().
|
|
*/
|
|
void
|
|
channel_init(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
/* Assign an ID and bump the counter */
|
|
chan->global_identifier = ++n_channels_allocated;
|
|
|
|
/* Init timestamp */
|
|
chan->timestamp_last_had_circuits = time(NULL);
|
|
|
|
/* Warn about exhausted circuit IDs no more than hourly. */
|
|
chan->last_warned_circ_ids_exhausted.rate = 3600;
|
|
|
|
/* Initialize list entries. */
|
|
memset(&chan->next_with_same_id, 0, sizeof(chan->next_with_same_id));
|
|
|
|
/* Timestamp it */
|
|
channel_timestamp_created(chan);
|
|
|
|
/* It hasn't been open yet. */
|
|
chan->has_been_open = 0;
|
|
|
|
/* Scheduler state is idle */
|
|
chan->scheduler_state = SCHED_CHAN_IDLE;
|
|
|
|
/* Channel is not in the scheduler heap. */
|
|
chan->sched_heap_idx = -1;
|
|
}
|
|
|
|
/**
|
|
* Initialize a channel listener.
|
|
*
|
|
* This function should be called by subclasses to set up some per-channel
|
|
* variables. I.e., this is the superclass constructor. Before this, the
|
|
* channel listener should be allocated with tor_malloc_zero().
|
|
*/
|
|
void
|
|
channel_init_listener(channel_listener_t *chan_l)
|
|
{
|
|
tor_assert(chan_l);
|
|
|
|
/* Assign an ID and bump the counter */
|
|
chan_l->global_identifier = ++n_channels_allocated;
|
|
|
|
/* Timestamp it */
|
|
channel_listener_timestamp_created(chan_l);
|
|
}
|
|
|
|
/**
|
|
* Free a channel; nothing outside of channel.c and subclasses should call
|
|
* this - it frees channels after they have closed and been unregistered.
|
|
*/
|
|
void
|
|
channel_free_(channel_t *chan)
|
|
{
|
|
if (!chan) return;
|
|
|
|
/* It must be closed or errored */
|
|
tor_assert(CHANNEL_FINISHED(chan));
|
|
|
|
/* It must be deregistered */
|
|
tor_assert(!(chan->registered));
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Freeing channel " U64_FORMAT " at %p",
|
|
U64_PRINTF_ARG(chan->global_identifier), chan);
|
|
|
|
/* Get this one out of the scheduler */
|
|
scheduler_release_channel(chan);
|
|
|
|
/*
|
|
* Get rid of cmux policy before we do anything, so cmux policies don't
|
|
* see channels in weird half-freed states.
|
|
*/
|
|
if (chan->cmux) {
|
|
circuitmux_set_policy(chan->cmux, NULL);
|
|
}
|
|
|
|
/* Remove all timers and associated handle entries now */
|
|
timer_free(chan->padding_timer);
|
|
channel_handle_free(chan->timer_handle);
|
|
channel_handles_clear(chan);
|
|
|
|
/* Call a free method if there is one */
|
|
if (chan->free_fn) chan->free_fn(chan);
|
|
|
|
channel_clear_remote_end(chan);
|
|
|
|
/* Get rid of cmux */
|
|
if (chan->cmux) {
|
|
circuitmux_detach_all_circuits(chan->cmux, NULL);
|
|
circuitmux_mark_destroyed_circids_usable(chan->cmux, chan);
|
|
circuitmux_free(chan->cmux);
|
|
chan->cmux = NULL;
|
|
}
|
|
|
|
tor_free(chan);
|
|
}
|
|
|
|
/**
|
|
* Free a channel listener; nothing outside of channel.c and subclasses
|
|
* should call this - it frees channel listeners after they have closed and
|
|
* been unregistered.
|
|
*/
|
|
void
|
|
channel_listener_free_(channel_listener_t *chan_l)
|
|
{
|
|
if (!chan_l) return;
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Freeing channel_listener_t " U64_FORMAT " at %p",
|
|
U64_PRINTF_ARG(chan_l->global_identifier),
|
|
chan_l);
|
|
|
|
/* It must be closed or errored */
|
|
tor_assert(chan_l->state == CHANNEL_LISTENER_STATE_CLOSED ||
|
|
chan_l->state == CHANNEL_LISTENER_STATE_ERROR);
|
|
/* It must be deregistered */
|
|
tor_assert(!(chan_l->registered));
|
|
|
|
/* Call a free method if there is one */
|
|
if (chan_l->free_fn) chan_l->free_fn(chan_l);
|
|
|
|
tor_free(chan_l);
|
|
}
|
|
|
|
/**
|
|
* Free a channel and skip the state/registration asserts; this internal-
|
|
* use-only function should be called only from channel_free_all() when
|
|
* shutting down the Tor process.
|
|
*/
|
|
static void
|
|
channel_force_xfree(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Force-freeing channel " U64_FORMAT " at %p",
|
|
U64_PRINTF_ARG(chan->global_identifier), chan);
|
|
|
|
/* Get this one out of the scheduler */
|
|
scheduler_release_channel(chan);
|
|
|
|
/*
|
|
* Get rid of cmux policy before we do anything, so cmux policies don't
|
|
* see channels in weird half-freed states.
|
|
*/
|
|
if (chan->cmux) {
|
|
circuitmux_set_policy(chan->cmux, NULL);
|
|
}
|
|
|
|
/* Remove all timers and associated handle entries now */
|
|
timer_free(chan->padding_timer);
|
|
channel_handle_free(chan->timer_handle);
|
|
channel_handles_clear(chan);
|
|
|
|
/* Call a free method if there is one */
|
|
if (chan->free_fn) chan->free_fn(chan);
|
|
|
|
channel_clear_remote_end(chan);
|
|
|
|
/* Get rid of cmux */
|
|
if (chan->cmux) {
|
|
circuitmux_free(chan->cmux);
|
|
chan->cmux = NULL;
|
|
}
|
|
|
|
tor_free(chan);
|
|
}
|
|
|
|
/**
|
|
* Free a channel listener and skip the state/registration asserts; this
|
|
* internal-use-only function should be called only from channel_free_all()
|
|
* when shutting down the Tor process.
|
|
*/
|
|
static void
|
|
channel_listener_force_xfree(channel_listener_t *chan_l)
|
|
{
|
|
tor_assert(chan_l);
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Force-freeing channel_listener_t " U64_FORMAT " at %p",
|
|
U64_PRINTF_ARG(chan_l->global_identifier),
|
|
chan_l);
|
|
|
|
/* Call a free method if there is one */
|
|
if (chan_l->free_fn) chan_l->free_fn(chan_l);
|
|
|
|
/*
|
|
* The incoming list just gets emptied and freed; we request close on
|
|
* any channels we find there, but since we got called while shutting
|
|
* down they will get deregistered and freed elsewhere anyway.
|
|
*/
|
|
if (chan_l->incoming_list) {
|
|
SMARTLIST_FOREACH_BEGIN(chan_l->incoming_list,
|
|
channel_t *, qchan) {
|
|
channel_mark_for_close(qchan);
|
|
} SMARTLIST_FOREACH_END(qchan);
|
|
|
|
smartlist_free(chan_l->incoming_list);
|
|
chan_l->incoming_list = NULL;
|
|
}
|
|
|
|
tor_free(chan_l);
|
|
}
|
|
|
|
/**
|
|
* Set the listener for a channel listener.
|
|
*
|
|
* This function sets the handler for new incoming channels on a channel
|
|
* listener.
|
|
*/
|
|
void
|
|
channel_listener_set_listener_fn(channel_listener_t *chan_l,
|
|
channel_listener_fn_ptr listener)
|
|
{
|
|
tor_assert(chan_l);
|
|
tor_assert(chan_l->state == CHANNEL_LISTENER_STATE_LISTENING);
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Setting listener callback for channel listener %p "
|
|
"(global ID " U64_FORMAT ") to %p",
|
|
chan_l, U64_PRINTF_ARG(chan_l->global_identifier),
|
|
listener);
|
|
|
|
chan_l->listener = listener;
|
|
if (chan_l->listener) channel_listener_process_incoming(chan_l);
|
|
}
|
|
|
|
/**
|
|
* Return the fixed-length cell handler for a channel.
|
|
*
|
|
* This function gets the handler for incoming fixed-length cells installed
|
|
* on a channel.
|
|
*/
|
|
channel_cell_handler_fn_ptr
|
|
channel_get_cell_handler(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
if (CHANNEL_CAN_HANDLE_CELLS(chan))
|
|
return chan->cell_handler;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* Return the variable-length cell handler for a channel.
|
|
*
|
|
* This function gets the handler for incoming variable-length cells
|
|
* installed on a channel.
|
|
*/
|
|
channel_var_cell_handler_fn_ptr
|
|
channel_get_var_cell_handler(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
if (CHANNEL_CAN_HANDLE_CELLS(chan))
|
|
return chan->var_cell_handler;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* Set both cell handlers for a channel.
|
|
*
|
|
* This function sets both the fixed-length and variable length cell handlers
|
|
* for a channel.
|
|
*/
|
|
void
|
|
channel_set_cell_handlers(channel_t *chan,
|
|
channel_cell_handler_fn_ptr cell_handler,
|
|
channel_var_cell_handler_fn_ptr
|
|
var_cell_handler)
|
|
{
|
|
tor_assert(chan);
|
|
tor_assert(CHANNEL_CAN_HANDLE_CELLS(chan));
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Setting cell_handler callback for channel %p to %p",
|
|
chan, cell_handler);
|
|
log_debug(LD_CHANNEL,
|
|
"Setting var_cell_handler callback for channel %p to %p",
|
|
chan, var_cell_handler);
|
|
|
|
/* Change them */
|
|
chan->cell_handler = cell_handler;
|
|
chan->var_cell_handler = var_cell_handler;
|
|
}
|
|
|
|
/*
|
|
* On closing channels
|
|
*
|
|
* There are three functions that close channels, for use in
|
|
* different circumstances:
|
|
*
|
|
* - Use channel_mark_for_close() for most cases
|
|
* - Use channel_close_from_lower_layer() if you are connection_or.c
|
|
* and the other end closes the underlying connection.
|
|
* - Use channel_close_for_error() if you are connection_or.c and
|
|
* some sort of error has occurred.
|
|
*/
|
|
|
|
/**
|
|
* Mark a channel for closure.
|
|
*
|
|
* This function tries to close a channel_t; it will go into the CLOSING
|
|
* state, and eventually the lower layer should put it into the CLOSED or
|
|
* ERROR state. Then, channel_run_cleanup() will eventually free it.
|
|
*/
|
|
void
|
|
channel_mark_for_close(channel_t *chan)
|
|
{
|
|
tor_assert(chan != NULL);
|
|
tor_assert(chan->close != NULL);
|
|
|
|
/* If it's already in CLOSING, CLOSED or ERROR, this is a no-op */
|
|
if (CHANNEL_CONDEMNED(chan))
|
|
return;
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Closing channel %p (global ID " U64_FORMAT ") "
|
|
"by request",
|
|
chan, U64_PRINTF_ARG(chan->global_identifier));
|
|
|
|
/* Note closing by request from above */
|
|
chan->reason_for_closing = CHANNEL_CLOSE_REQUESTED;
|
|
|
|
/* Change state to CLOSING */
|
|
channel_change_state(chan, CHANNEL_STATE_CLOSING);
|
|
|
|
/* Tell the lower layer */
|
|
chan->close(chan);
|
|
|
|
/*
|
|
* It's up to the lower layer to change state to CLOSED or ERROR when we're
|
|
* ready; we'll try to free channels that are in the finished list from
|
|
* channel_run_cleanup(). The lower layer should do this by calling
|
|
* channel_closed().
|
|
*/
|
|
}
|
|
|
|
/**
|
|
* Mark a channel listener for closure.
|
|
*
|
|
* This function tries to close a channel_listener_t; it will go into the
|
|
* CLOSING state, and eventually the lower layer should put it into the CLOSED
|
|
* or ERROR state. Then, channel_run_cleanup() will eventually free it.
|
|
*/
|
|
void
|
|
channel_listener_mark_for_close(channel_listener_t *chan_l)
|
|
{
|
|
tor_assert(chan_l != NULL);
|
|
tor_assert(chan_l->close != NULL);
|
|
|
|
/* If it's already in CLOSING, CLOSED or ERROR, this is a no-op */
|
|
if (chan_l->state == CHANNEL_LISTENER_STATE_CLOSING ||
|
|
chan_l->state == CHANNEL_LISTENER_STATE_CLOSED ||
|
|
chan_l->state == CHANNEL_LISTENER_STATE_ERROR) return;
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Closing channel listener %p (global ID " U64_FORMAT ") "
|
|
"by request",
|
|
chan_l, U64_PRINTF_ARG(chan_l->global_identifier));
|
|
|
|
/* Note closing by request from above */
|
|
chan_l->reason_for_closing = CHANNEL_LISTENER_CLOSE_REQUESTED;
|
|
|
|
/* Change state to CLOSING */
|
|
channel_listener_change_state(chan_l, CHANNEL_LISTENER_STATE_CLOSING);
|
|
|
|
/* Tell the lower layer */
|
|
chan_l->close(chan_l);
|
|
|
|
/*
|
|
* It's up to the lower layer to change state to CLOSED or ERROR when we're
|
|
* ready; we'll try to free channels that are in the finished list from
|
|
* channel_run_cleanup(). The lower layer should do this by calling
|
|
* channel_listener_closed().
|
|
*/
|
|
}
|
|
|
|
/**
|
|
* Close a channel from the lower layer.
|
|
*
|
|
* Notify the channel code that the channel is being closed due to a non-error
|
|
* condition in the lower layer. This does not call the close() method, since
|
|
* the lower layer already knows.
|
|
*/
|
|
void
|
|
channel_close_from_lower_layer(channel_t *chan)
|
|
{
|
|
tor_assert(chan != NULL);
|
|
|
|
/* If it's already in CLOSING, CLOSED or ERROR, this is a no-op */
|
|
if (CHANNEL_CONDEMNED(chan))
|
|
return;
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Closing channel %p (global ID " U64_FORMAT ") "
|
|
"due to lower-layer event",
|
|
chan, U64_PRINTF_ARG(chan->global_identifier));
|
|
|
|
/* Note closing by event from below */
|
|
chan->reason_for_closing = CHANNEL_CLOSE_FROM_BELOW;
|
|
|
|
/* Change state to CLOSING */
|
|
channel_change_state(chan, CHANNEL_STATE_CLOSING);
|
|
}
|
|
|
|
/**
|
|
* Notify that the channel is being closed due to an error condition.
|
|
*
|
|
* This function is called by the lower layer implementing the transport
|
|
* when a channel must be closed due to an error condition. This does not
|
|
* call the channel's close method, since the lower layer already knows.
|
|
*/
|
|
void
|
|
channel_close_for_error(channel_t *chan)
|
|
{
|
|
tor_assert(chan != NULL);
|
|
|
|
/* If it's already in CLOSING, CLOSED or ERROR, this is a no-op */
|
|
if (CHANNEL_CONDEMNED(chan))
|
|
return;
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Closing channel %p due to lower-layer error",
|
|
chan);
|
|
|
|
/* Note closing by event from below */
|
|
chan->reason_for_closing = CHANNEL_CLOSE_FOR_ERROR;
|
|
|
|
/* Change state to CLOSING */
|
|
channel_change_state(chan, CHANNEL_STATE_CLOSING);
|
|
}
|
|
|
|
/**
|
|
* Notify that the lower layer is finished closing the channel.
|
|
*
|
|
* This function should be called by the lower layer when a channel
|
|
* is finished closing and it should be regarded as inactive and
|
|
* freed by the channel code.
|
|
*/
|
|
void
|
|
channel_closed(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
tor_assert(CHANNEL_CONDEMNED(chan));
|
|
|
|
/* No-op if already inactive */
|
|
if (CHANNEL_FINISHED(chan))
|
|
return;
|
|
|
|
/* Inform any pending (not attached) circs that they should
|
|
* give up. */
|
|
if (! chan->has_been_open)
|
|
circuit_n_chan_done(chan, 0, 0);
|
|
|
|
/* Now close all the attached circuits on it. */
|
|
circuit_unlink_all_from_channel(chan, END_CIRC_REASON_CHANNEL_CLOSED);
|
|
|
|
if (chan->reason_for_closing != CHANNEL_CLOSE_FOR_ERROR) {
|
|
channel_change_state(chan, CHANNEL_STATE_CLOSED);
|
|
} else {
|
|
channel_change_state(chan, CHANNEL_STATE_ERROR);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Clear the identity_digest of a channel.
|
|
*
|
|
* This function clears the identity digest of the remote endpoint for a
|
|
* channel; this is intended for use by the lower layer.
|
|
*/
|
|
void
|
|
channel_clear_identity_digest(channel_t *chan)
|
|
{
|
|
int state_not_in_map;
|
|
|
|
tor_assert(chan);
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Clearing remote endpoint digest on channel %p with "
|
|
"global ID " U64_FORMAT,
|
|
chan, U64_PRINTF_ARG(chan->global_identifier));
|
|
|
|
state_not_in_map = CHANNEL_CONDEMNED(chan);
|
|
|
|
if (!state_not_in_map && chan->registered &&
|
|
!tor_digest_is_zero(chan->identity_digest))
|
|
/* if it's registered get it out of the digest map */
|
|
channel_remove_from_digest_map(chan);
|
|
|
|
memset(chan->identity_digest, 0,
|
|
sizeof(chan->identity_digest));
|
|
}
|
|
|
|
/**
|
|
* Set the identity_digest of a channel.
|
|
*
|
|
* This function sets the identity digest of the remote endpoint for a
|
|
* channel; this is intended for use by the lower layer.
|
|
*/
|
|
void
|
|
channel_set_identity_digest(channel_t *chan,
|
|
const char *identity_digest,
|
|
const ed25519_public_key_t *ed_identity)
|
|
{
|
|
int was_in_digest_map, should_be_in_digest_map, state_not_in_map;
|
|
|
|
tor_assert(chan);
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Setting remote endpoint digest on channel %p with "
|
|
"global ID " U64_FORMAT " to digest %s",
|
|
chan, U64_PRINTF_ARG(chan->global_identifier),
|
|
identity_digest ?
|
|
hex_str(identity_digest, DIGEST_LEN) : "(null)");
|
|
|
|
state_not_in_map = CHANNEL_CONDEMNED(chan);
|
|
|
|
was_in_digest_map =
|
|
!state_not_in_map &&
|
|
chan->registered &&
|
|
!tor_digest_is_zero(chan->identity_digest);
|
|
should_be_in_digest_map =
|
|
!state_not_in_map &&
|
|
chan->registered &&
|
|
(identity_digest &&
|
|
!tor_digest_is_zero(identity_digest));
|
|
|
|
if (was_in_digest_map)
|
|
/* We should always remove it; we'll add it back if we're writing
|
|
* in a new digest.
|
|
*/
|
|
channel_remove_from_digest_map(chan);
|
|
|
|
if (identity_digest) {
|
|
memcpy(chan->identity_digest,
|
|
identity_digest,
|
|
sizeof(chan->identity_digest));
|
|
} else {
|
|
memset(chan->identity_digest, 0,
|
|
sizeof(chan->identity_digest));
|
|
}
|
|
if (ed_identity) {
|
|
memcpy(&chan->ed25519_identity, ed_identity, sizeof(*ed_identity));
|
|
} else {
|
|
memset(&chan->ed25519_identity, 0, sizeof(*ed_identity));
|
|
}
|
|
|
|
/* Put it in the digest map if we should */
|
|
if (should_be_in_digest_map)
|
|
channel_add_to_digest_map(chan);
|
|
}
|
|
|
|
/**
|
|
* Clear the remote end metadata (identity_digest) of a channel.
|
|
*
|
|
* This function clears all the remote end info from a channel; this is
|
|
* intended for use by the lower layer.
|
|
*/
|
|
void
|
|
channel_clear_remote_end(channel_t *chan)
|
|
{
|
|
int state_not_in_map;
|
|
|
|
tor_assert(chan);
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Clearing remote endpoint identity on channel %p with "
|
|
"global ID " U64_FORMAT,
|
|
chan, U64_PRINTF_ARG(chan->global_identifier));
|
|
|
|
state_not_in_map = CHANNEL_CONDEMNED(chan);
|
|
|
|
if (!state_not_in_map && chan->registered &&
|
|
!tor_digest_is_zero(chan->identity_digest))
|
|
/* if it's registered get it out of the digest map */
|
|
channel_remove_from_digest_map(chan);
|
|
|
|
memset(chan->identity_digest, 0,
|
|
sizeof(chan->identity_digest));
|
|
}
|
|
|
|
/**
|
|
* Write to a channel the given packed cell.
|
|
*
|
|
* Two possible errors can happen. Either the channel is not opened or the
|
|
* lower layer (specialized channel) failed to write it. In both cases, it is
|
|
* the caller responsibility to free the cell.
|
|
*/
|
|
static int
|
|
write_packed_cell(channel_t *chan, packed_cell_t *cell)
|
|
{
|
|
int ret = -1;
|
|
size_t cell_bytes;
|
|
|
|
tor_assert(chan);
|
|
tor_assert(cell);
|
|
|
|
/* Assert that the state makes sense for a cell write */
|
|
tor_assert(CHANNEL_CAN_HANDLE_CELLS(chan));
|
|
|
|
{
|
|
circid_t circ_id;
|
|
if (packed_cell_is_destroy(chan, cell, &circ_id)) {
|
|
channel_note_destroy_not_pending(chan, circ_id);
|
|
}
|
|
}
|
|
|
|
/* For statistical purposes, figure out how big this cell is */
|
|
cell_bytes = get_cell_network_size(chan->wide_circ_ids);
|
|
|
|
/* Can we send it right out? If so, try */
|
|
if (!CHANNEL_IS_OPEN(chan)) {
|
|
goto done;
|
|
}
|
|
|
|
/* Write the cell on the connection's outbuf. */
|
|
if (chan->write_packed_cell(chan, cell) < 0) {
|
|
goto done;
|
|
}
|
|
/* Timestamp for transmission */
|
|
channel_timestamp_xmit(chan);
|
|
/* Update the counter */
|
|
++(chan->n_cells_xmitted);
|
|
chan->n_bytes_xmitted += cell_bytes;
|
|
/* Successfully sent the cell. */
|
|
ret = 0;
|
|
|
|
done:
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Write a packed cell to a channel.
|
|
*
|
|
* Write a packed cell to a channel using the write_cell() method. This is
|
|
* called by the transport-independent code to deliver a packed cell to a
|
|
* channel for transmission.
|
|
*
|
|
* Return 0 on success else a negative value. In both cases, the caller should
|
|
* not access the cell anymore, it is freed both on success and error.
|
|
*/
|
|
int
|
|
channel_write_packed_cell(channel_t *chan, packed_cell_t *cell)
|
|
{
|
|
int ret = -1;
|
|
|
|
tor_assert(chan);
|
|
tor_assert(cell);
|
|
|
|
if (CHANNEL_IS_CLOSING(chan)) {
|
|
log_debug(LD_CHANNEL, "Discarding %p on closing channel %p with "
|
|
"global ID "U64_FORMAT, cell, chan,
|
|
U64_PRINTF_ARG(chan->global_identifier));
|
|
goto end;
|
|
}
|
|
log_debug(LD_CHANNEL,
|
|
"Writing %p to channel %p with global ID "
|
|
U64_FORMAT, cell, chan, U64_PRINTF_ARG(chan->global_identifier));
|
|
|
|
ret = write_packed_cell(chan, cell);
|
|
|
|
end:
|
|
/* Whatever happens, we free the cell. Either an error occurred or the cell
|
|
* was put on the connection outbuf, both cases we have ownership of the
|
|
* cell and we free it. */
|
|
packed_cell_free(cell);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Change channel state.
|
|
*
|
|
* This internal and subclass use only function is used to change channel
|
|
* state, performing all transition validity checks and whatever actions
|
|
* are appropriate to the state transition in question.
|
|
*/
|
|
static void
|
|
channel_change_state_(channel_t *chan, channel_state_t to_state)
|
|
{
|
|
channel_state_t from_state;
|
|
unsigned char was_active, is_active;
|
|
unsigned char was_in_id_map, is_in_id_map;
|
|
|
|
tor_assert(chan);
|
|
from_state = chan->state;
|
|
|
|
tor_assert(channel_state_is_valid(from_state));
|
|
tor_assert(channel_state_is_valid(to_state));
|
|
tor_assert(channel_state_can_transition(chan->state, to_state));
|
|
|
|
/* Check for no-op transitions */
|
|
if (from_state == to_state) {
|
|
log_debug(LD_CHANNEL,
|
|
"Got no-op transition from \"%s\" to itself on channel %p"
|
|
"(global ID " U64_FORMAT ")",
|
|
channel_state_to_string(to_state),
|
|
chan, U64_PRINTF_ARG(chan->global_identifier));
|
|
return;
|
|
}
|
|
|
|
/* If we're going to a closing or closed state, we must have a reason set */
|
|
if (to_state == CHANNEL_STATE_CLOSING ||
|
|
to_state == CHANNEL_STATE_CLOSED ||
|
|
to_state == CHANNEL_STATE_ERROR) {
|
|
tor_assert(chan->reason_for_closing != CHANNEL_NOT_CLOSING);
|
|
}
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Changing state of channel %p (global ID " U64_FORMAT
|
|
") from \"%s\" to \"%s\"",
|
|
chan,
|
|
U64_PRINTF_ARG(chan->global_identifier),
|
|
channel_state_to_string(chan->state),
|
|
channel_state_to_string(to_state));
|
|
|
|
chan->state = to_state;
|
|
|
|
/* Need to add to the right lists if the channel is registered */
|
|
if (chan->registered) {
|
|
was_active = !(from_state == CHANNEL_STATE_CLOSED ||
|
|
from_state == CHANNEL_STATE_ERROR);
|
|
is_active = !(to_state == CHANNEL_STATE_CLOSED ||
|
|
to_state == CHANNEL_STATE_ERROR);
|
|
|
|
/* Need to take off active list and put on finished list? */
|
|
if (was_active && !is_active) {
|
|
if (active_channels) smartlist_remove(active_channels, chan);
|
|
if (!finished_channels) finished_channels = smartlist_new();
|
|
smartlist_add(finished_channels, chan);
|
|
mainloop_schedule_postloop_cleanup();
|
|
}
|
|
/* Need to put on active list? */
|
|
else if (!was_active && is_active) {
|
|
if (finished_channels) smartlist_remove(finished_channels, chan);
|
|
if (!active_channels) active_channels = smartlist_new();
|
|
smartlist_add(active_channels, chan);
|
|
}
|
|
|
|
if (!tor_digest_is_zero(chan->identity_digest)) {
|
|
/* Now we need to handle the identity map */
|
|
was_in_id_map = !(from_state == CHANNEL_STATE_CLOSING ||
|
|
from_state == CHANNEL_STATE_CLOSED ||
|
|
from_state == CHANNEL_STATE_ERROR);
|
|
is_in_id_map = !(to_state == CHANNEL_STATE_CLOSING ||
|
|
to_state == CHANNEL_STATE_CLOSED ||
|
|
to_state == CHANNEL_STATE_ERROR);
|
|
|
|
if (!was_in_id_map && is_in_id_map) channel_add_to_digest_map(chan);
|
|
else if (was_in_id_map && !is_in_id_map)
|
|
channel_remove_from_digest_map(chan);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If we're going to a closed/closing state, we don't need scheduling any
|
|
* more; in CHANNEL_STATE_MAINT we can't accept writes.
|
|
*/
|
|
if (to_state == CHANNEL_STATE_CLOSING ||
|
|
to_state == CHANNEL_STATE_CLOSED ||
|
|
to_state == CHANNEL_STATE_ERROR) {
|
|
scheduler_release_channel(chan);
|
|
} else if (to_state == CHANNEL_STATE_MAINT) {
|
|
scheduler_channel_doesnt_want_writes(chan);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* As channel_change_state_, but change the state to any state but open.
|
|
*/
|
|
void
|
|
channel_change_state(channel_t *chan, channel_state_t to_state)
|
|
{
|
|
tor_assert(to_state != CHANNEL_STATE_OPEN);
|
|
channel_change_state_(chan, to_state);
|
|
}
|
|
|
|
/**
|
|
* As channel_change_state, but change the state to open.
|
|
*/
|
|
void
|
|
channel_change_state_open(channel_t *chan)
|
|
{
|
|
channel_change_state_(chan, CHANNEL_STATE_OPEN);
|
|
|
|
/* Tell circuits if we opened and stuff */
|
|
channel_do_open_actions(chan);
|
|
chan->has_been_open = 1;
|
|
}
|
|
|
|
/**
|
|
* Change channel listener state.
|
|
*
|
|
* This internal and subclass use only function is used to change channel
|
|
* listener state, performing all transition validity checks and whatever
|
|
* actions are appropriate to the state transition in question.
|
|
*/
|
|
void
|
|
channel_listener_change_state(channel_listener_t *chan_l,
|
|
channel_listener_state_t to_state)
|
|
{
|
|
channel_listener_state_t from_state;
|
|
unsigned char was_active, is_active;
|
|
|
|
tor_assert(chan_l);
|
|
from_state = chan_l->state;
|
|
|
|
tor_assert(channel_listener_state_is_valid(from_state));
|
|
tor_assert(channel_listener_state_is_valid(to_state));
|
|
tor_assert(channel_listener_state_can_transition(chan_l->state, to_state));
|
|
|
|
/* Check for no-op transitions */
|
|
if (from_state == to_state) {
|
|
log_debug(LD_CHANNEL,
|
|
"Got no-op transition from \"%s\" to itself on channel "
|
|
"listener %p (global ID " U64_FORMAT ")",
|
|
channel_listener_state_to_string(to_state),
|
|
chan_l, U64_PRINTF_ARG(chan_l->global_identifier));
|
|
return;
|
|
}
|
|
|
|
/* If we're going to a closing or closed state, we must have a reason set */
|
|
if (to_state == CHANNEL_LISTENER_STATE_CLOSING ||
|
|
to_state == CHANNEL_LISTENER_STATE_CLOSED ||
|
|
to_state == CHANNEL_LISTENER_STATE_ERROR) {
|
|
tor_assert(chan_l->reason_for_closing != CHANNEL_LISTENER_NOT_CLOSING);
|
|
}
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Changing state of channel listener %p (global ID " U64_FORMAT
|
|
"from \"%s\" to \"%s\"",
|
|
chan_l, U64_PRINTF_ARG(chan_l->global_identifier),
|
|
channel_listener_state_to_string(chan_l->state),
|
|
channel_listener_state_to_string(to_state));
|
|
|
|
chan_l->state = to_state;
|
|
|
|
/* Need to add to the right lists if the channel listener is registered */
|
|
if (chan_l->registered) {
|
|
was_active = !(from_state == CHANNEL_LISTENER_STATE_CLOSED ||
|
|
from_state == CHANNEL_LISTENER_STATE_ERROR);
|
|
is_active = !(to_state == CHANNEL_LISTENER_STATE_CLOSED ||
|
|
to_state == CHANNEL_LISTENER_STATE_ERROR);
|
|
|
|
/* Need to take off active list and put on finished list? */
|
|
if (was_active && !is_active) {
|
|
if (active_listeners) smartlist_remove(active_listeners, chan_l);
|
|
if (!finished_listeners) finished_listeners = smartlist_new();
|
|
smartlist_add(finished_listeners, chan_l);
|
|
mainloop_schedule_postloop_cleanup();
|
|
}
|
|
/* Need to put on active list? */
|
|
else if (!was_active && is_active) {
|
|
if (finished_listeners) smartlist_remove(finished_listeners, chan_l);
|
|
if (!active_listeners) active_listeners = smartlist_new();
|
|
smartlist_add(active_listeners, chan_l);
|
|
}
|
|
}
|
|
|
|
if (to_state == CHANNEL_LISTENER_STATE_CLOSED ||
|
|
to_state == CHANNEL_LISTENER_STATE_ERROR) {
|
|
tor_assert(!(chan_l->incoming_list) ||
|
|
smartlist_len(chan_l->incoming_list) == 0);
|
|
}
|
|
}
|
|
|
|
/* Maximum number of cells that is allowed to flush at once within
|
|
* channel_flush_some_cells(). */
|
|
#define MAX_CELLS_TO_GET_FROM_CIRCUITS_FOR_UNLIMITED 256
|
|
|
|
/**
|
|
* Try to flush cells of the given channel chan up to a maximum of num_cells.
|
|
*
|
|
* This is called by the scheduler when it wants to flush cells from the
|
|
* channel's circuit queue(s) to the connection outbuf (not yet on the wire).
|
|
*
|
|
* If the channel is not in state CHANNEL_STATE_OPEN, this does nothing and
|
|
* will return 0 meaning no cells were flushed.
|
|
*
|
|
* If num_cells is -1, we'll try to flush up to the maximum cells allowed
|
|
* defined in MAX_CELLS_TO_GET_FROM_CIRCUITS_FOR_UNLIMITED.
|
|
*
|
|
* On success, the number of flushed cells are returned and it can never be
|
|
* above num_cells. If 0 is returned, no cells were flushed either because the
|
|
* channel was not opened or we had no cells on the channel. A negative number
|
|
* can NOT be sent back.
|
|
*
|
|
* This function is part of the fast path. */
|
|
MOCK_IMPL(ssize_t,
|
|
channel_flush_some_cells, (channel_t *chan, ssize_t num_cells))
|
|
{
|
|
unsigned int unlimited = 0;
|
|
ssize_t flushed = 0;
|
|
int clamped_num_cells;
|
|
|
|
tor_assert(chan);
|
|
|
|
if (num_cells < 0) unlimited = 1;
|
|
if (!unlimited && num_cells <= flushed) goto done;
|
|
|
|
/* If we aren't in CHANNEL_STATE_OPEN, nothing goes through */
|
|
if (CHANNEL_IS_OPEN(chan)) {
|
|
if (circuitmux_num_cells(chan->cmux) > 0) {
|
|
/* Calculate number of cells, including clamp */
|
|
if (unlimited) {
|
|
clamped_num_cells = MAX_CELLS_TO_GET_FROM_CIRCUITS_FOR_UNLIMITED;
|
|
} else {
|
|
if (num_cells - flushed >
|
|
MAX_CELLS_TO_GET_FROM_CIRCUITS_FOR_UNLIMITED) {
|
|
clamped_num_cells = MAX_CELLS_TO_GET_FROM_CIRCUITS_FOR_UNLIMITED;
|
|
} else {
|
|
clamped_num_cells = (int)(num_cells - flushed);
|
|
}
|
|
}
|
|
|
|
/* Try to get more cells from any active circuits */
|
|
flushed = channel_flush_from_first_active_circuit(
|
|
chan, clamped_num_cells);
|
|
}
|
|
}
|
|
|
|
done:
|
|
return flushed;
|
|
}
|
|
|
|
/**
|
|
* Check if any cells are available.
|
|
*
|
|
* This is used by the scheduler to know if the channel has more to flush
|
|
* after a scheduling round.
|
|
*/
|
|
MOCK_IMPL(int,
|
|
channel_more_to_flush, (channel_t *chan))
|
|
{
|
|
tor_assert(chan);
|
|
|
|
if (circuitmux_num_cells(chan->cmux) > 0) return 1;
|
|
|
|
/* Else no */
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Notify the channel we're done flushing the output in the lower layer.
|
|
*
|
|
* Connection.c will call this when we've flushed the output; there's some
|
|
* dirreq-related maintenance to do.
|
|
*/
|
|
void
|
|
channel_notify_flushed(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
if (chan->dirreq_id != 0)
|
|
geoip_change_dirreq_state(chan->dirreq_id,
|
|
DIRREQ_TUNNELED,
|
|
DIRREQ_CHANNEL_BUFFER_FLUSHED);
|
|
}
|
|
|
|
/**
|
|
* Process the queue of incoming channels on a listener.
|
|
*
|
|
* Use a listener's registered callback to process as many entries in the
|
|
* queue of incoming channels as possible.
|
|
*/
|
|
void
|
|
channel_listener_process_incoming(channel_listener_t *listener)
|
|
{
|
|
tor_assert(listener);
|
|
|
|
/*
|
|
* CHANNEL_LISTENER_STATE_CLOSING permitted because we drain the queue
|
|
* while closing a listener.
|
|
*/
|
|
tor_assert(listener->state == CHANNEL_LISTENER_STATE_LISTENING ||
|
|
listener->state == CHANNEL_LISTENER_STATE_CLOSING);
|
|
tor_assert(listener->listener);
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Processing queue of incoming connections for channel "
|
|
"listener %p (global ID " U64_FORMAT ")",
|
|
listener, U64_PRINTF_ARG(listener->global_identifier));
|
|
|
|
if (!(listener->incoming_list)) return;
|
|
|
|
SMARTLIST_FOREACH_BEGIN(listener->incoming_list,
|
|
channel_t *, chan) {
|
|
tor_assert(chan);
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Handling incoming channel %p (" U64_FORMAT ") "
|
|
"for listener %p (" U64_FORMAT ")",
|
|
chan,
|
|
U64_PRINTF_ARG(chan->global_identifier),
|
|
listener,
|
|
U64_PRINTF_ARG(listener->global_identifier));
|
|
/* Make sure this is set correctly */
|
|
channel_mark_incoming(chan);
|
|
listener->listener(listener, chan);
|
|
} SMARTLIST_FOREACH_END(chan);
|
|
|
|
smartlist_free(listener->incoming_list);
|
|
listener->incoming_list = NULL;
|
|
}
|
|
|
|
/**
|
|
* Take actions required when a channel becomes open.
|
|
*
|
|
* Handle actions we should do when we know a channel is open; a lot of
|
|
* this comes from the old connection_or_set_state_open() of connection_or.c.
|
|
*
|
|
* Because of this mechanism, future channel_t subclasses should take care
|
|
* not to change a channel from CHANNEL_STATE_OPENING to CHANNEL_STATE_OPEN
|
|
* until there is positive confirmation that the network is operational.
|
|
* In particular, anything UDP-based should not make this transition until a
|
|
* packet is received from the other side.
|
|
*/
|
|
void
|
|
channel_do_open_actions(channel_t *chan)
|
|
{
|
|
tor_addr_t remote_addr;
|
|
int started_here;
|
|
time_t now = time(NULL);
|
|
int close_origin_circuits = 0;
|
|
|
|
tor_assert(chan);
|
|
|
|
started_here = channel_is_outgoing(chan);
|
|
|
|
if (started_here) {
|
|
circuit_build_times_network_is_live(get_circuit_build_times_mutable());
|
|
router_set_status(chan->identity_digest, 1);
|
|
} else {
|
|
/* only report it to the geoip module if it's a client */
|
|
if (channel_is_client(chan)) {
|
|
if (channel_get_addr_if_possible(chan, &remote_addr)) {
|
|
char *transport_name = NULL;
|
|
channel_tls_t *tlschan = BASE_CHAN_TO_TLS(chan);
|
|
if (chan->get_transport_name(chan, &transport_name) < 0)
|
|
transport_name = NULL;
|
|
|
|
geoip_note_client_seen(GEOIP_CLIENT_CONNECT,
|
|
&remote_addr, transport_name,
|
|
now);
|
|
tor_free(transport_name);
|
|
/* Notify the DoS subsystem of a new client. */
|
|
if (tlschan && tlschan->conn) {
|
|
dos_new_client_conn(tlschan->conn);
|
|
}
|
|
}
|
|
/* Otherwise the underlying transport can't tell us this, so skip it */
|
|
}
|
|
}
|
|
|
|
/* Disable or reduce padding according to user prefs. */
|
|
if (chan->padding_enabled || get_options()->ConnectionPadding == 1) {
|
|
if (!get_options()->ConnectionPadding) {
|
|
/* Disable if torrc disabled */
|
|
channelpadding_disable_padding_on_channel(chan);
|
|
} else if (get_options()->Tor2webMode &&
|
|
!networkstatus_get_param(NULL,
|
|
CHANNELPADDING_TOR2WEB_PARAM,
|
|
CHANNELPADDING_TOR2WEB_DEFAULT, 0, 1)) {
|
|
/* Disable if we're using tor2web and the consensus disabled padding
|
|
* for tor2web */
|
|
channelpadding_disable_padding_on_channel(chan);
|
|
} else if (rend_service_allow_non_anonymous_connection(get_options()) &&
|
|
!networkstatus_get_param(NULL,
|
|
CHANNELPADDING_SOS_PARAM,
|
|
CHANNELPADDING_SOS_DEFAULT, 0, 1)) {
|
|
/* Disable if we're using RSOS and the consensus disabled padding
|
|
* for RSOS */
|
|
channelpadding_disable_padding_on_channel(chan);
|
|
} else if (get_options()->ReducedConnectionPadding) {
|
|
/* Padding can be forced and/or reduced by clients, regardless of if
|
|
* the channel supports it */
|
|
channelpadding_reduce_padding_on_channel(chan);
|
|
}
|
|
}
|
|
|
|
circuit_n_chan_done(chan, 1, close_origin_circuits);
|
|
}
|
|
|
|
/**
|
|
* Queue an incoming channel on a listener.
|
|
*
|
|
* Internal and subclass use only function to queue an incoming channel from
|
|
* a listener. A subclass of channel_listener_t should call this when a new
|
|
* incoming channel is created.
|
|
*/
|
|
void
|
|
channel_listener_queue_incoming(channel_listener_t *listener,
|
|
channel_t *incoming)
|
|
{
|
|
int need_to_queue = 0;
|
|
|
|
tor_assert(listener);
|
|
tor_assert(listener->state == CHANNEL_LISTENER_STATE_LISTENING);
|
|
tor_assert(incoming);
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Queueing incoming channel %p (global ID " U64_FORMAT ") on "
|
|
"channel listener %p (global ID " U64_FORMAT ")",
|
|
incoming, U64_PRINTF_ARG(incoming->global_identifier),
|
|
listener, U64_PRINTF_ARG(listener->global_identifier));
|
|
|
|
/* Do we need to queue it, or can we just call the listener right away? */
|
|
if (!(listener->listener)) need_to_queue = 1;
|
|
if (listener->incoming_list &&
|
|
(smartlist_len(listener->incoming_list) > 0))
|
|
need_to_queue = 1;
|
|
|
|
/* If we need to queue and have no queue, create one */
|
|
if (need_to_queue && !(listener->incoming_list)) {
|
|
listener->incoming_list = smartlist_new();
|
|
}
|
|
|
|
/* Bump the counter and timestamp it */
|
|
channel_listener_timestamp_active(listener);
|
|
channel_listener_timestamp_accepted(listener);
|
|
++(listener->n_accepted);
|
|
|
|
/* If we don't need to queue, process it right away */
|
|
if (!need_to_queue) {
|
|
tor_assert(listener->listener);
|
|
listener->listener(listener, incoming);
|
|
}
|
|
/*
|
|
* Otherwise, we need to queue; queue and then process the queue if
|
|
* we can.
|
|
*/
|
|
else {
|
|
tor_assert(listener->incoming_list);
|
|
smartlist_add(listener->incoming_list, incoming);
|
|
if (listener->listener) channel_listener_process_incoming(listener);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Process a cell from the given channel.
|
|
*/
|
|
void
|
|
channel_process_cell(channel_t *chan, cell_t *cell)
|
|
{
|
|
tor_assert(chan);
|
|
tor_assert(CHANNEL_IS_CLOSING(chan) || CHANNEL_IS_MAINT(chan) ||
|
|
CHANNEL_IS_OPEN(chan));
|
|
tor_assert(cell);
|
|
|
|
/* Nothing we can do if we have no registered cell handlers */
|
|
if (!chan->cell_handler)
|
|
return;
|
|
|
|
/* Timestamp for receiving */
|
|
channel_timestamp_recv(chan);
|
|
/* Update received counter. */
|
|
++(chan->n_cells_recved);
|
|
chan->n_bytes_recved += get_cell_network_size(chan->wide_circ_ids);
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Processing incoming cell_t %p for channel %p (global ID "
|
|
U64_FORMAT ")", cell, chan,
|
|
U64_PRINTF_ARG(chan->global_identifier));
|
|
chan->cell_handler(chan, cell);
|
|
}
|
|
|
|
/** If <b>packed_cell</b> on <b>chan</b> is a destroy cell, then set
|
|
* *<b>circid_out</b> to its circuit ID, and return true. Otherwise, return
|
|
* false. */
|
|
/* XXXX Move this function. */
|
|
int
|
|
packed_cell_is_destroy(channel_t *chan,
|
|
const packed_cell_t *packed_cell,
|
|
circid_t *circid_out)
|
|
{
|
|
if (chan->wide_circ_ids) {
|
|
if (packed_cell->body[4] == CELL_DESTROY) {
|
|
*circid_out = ntohl(get_uint32(packed_cell->body));
|
|
return 1;
|
|
}
|
|
} else {
|
|
if (packed_cell->body[2] == CELL_DESTROY) {
|
|
*circid_out = ntohs(get_uint16(packed_cell->body));
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Send destroy cell on a channel.
|
|
*
|
|
* Write a destroy cell with circ ID <b>circ_id</b> and reason <b>reason</b>
|
|
* onto channel <b>chan</b>. Don't perform range-checking on reason:
|
|
* we may want to propagate reasons from other cells.
|
|
*/
|
|
int
|
|
channel_send_destroy(circid_t circ_id, channel_t *chan, int reason)
|
|
{
|
|
tor_assert(chan);
|
|
if (circ_id == 0) {
|
|
log_warn(LD_BUG, "Attempted to send a destroy cell for circID 0 "
|
|
"on a channel " U64_FORMAT " at %p in state %s (%d)",
|
|
U64_PRINTF_ARG(chan->global_identifier),
|
|
chan, channel_state_to_string(chan->state),
|
|
chan->state);
|
|
return 0;
|
|
}
|
|
|
|
/* Check to make sure we can send on this channel first */
|
|
if (!CHANNEL_CONDEMNED(chan) && chan->cmux) {
|
|
channel_note_destroy_pending(chan, circ_id);
|
|
circuitmux_append_destroy_cell(chan, chan->cmux, circ_id, reason);
|
|
log_debug(LD_OR,
|
|
"Sending destroy (circID %u) on channel %p "
|
|
"(global ID " U64_FORMAT ")",
|
|
(unsigned)circ_id, chan,
|
|
U64_PRINTF_ARG(chan->global_identifier));
|
|
} else {
|
|
log_warn(LD_BUG,
|
|
"Someone called channel_send_destroy() for circID %u "
|
|
"on a channel " U64_FORMAT " at %p in state %s (%d)",
|
|
(unsigned)circ_id, U64_PRINTF_ARG(chan->global_identifier),
|
|
chan, channel_state_to_string(chan->state),
|
|
chan->state);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Dump channel statistics to the log.
|
|
*
|
|
* This is called from dumpstats() in main.c and spams the log with
|
|
* statistics on channels.
|
|
*/
|
|
void
|
|
channel_dumpstats(int severity)
|
|
{
|
|
if (all_channels && smartlist_len(all_channels) > 0) {
|
|
tor_log(severity, LD_GENERAL,
|
|
"Dumping statistics about %d channels:",
|
|
smartlist_len(all_channels));
|
|
tor_log(severity, LD_GENERAL,
|
|
"%d are active, and %d are done and waiting for cleanup",
|
|
(active_channels != NULL) ?
|
|
smartlist_len(active_channels) : 0,
|
|
(finished_channels != NULL) ?
|
|
smartlist_len(finished_channels) : 0);
|
|
|
|
SMARTLIST_FOREACH(all_channels, channel_t *, chan,
|
|
channel_dump_statistics(chan, severity));
|
|
|
|
tor_log(severity, LD_GENERAL,
|
|
"Done spamming about channels now");
|
|
} else {
|
|
tor_log(severity, LD_GENERAL,
|
|
"No channels to dump");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Dump channel listener statistics to the log.
|
|
*
|
|
* This is called from dumpstats() in main.c and spams the log with
|
|
* statistics on channel listeners.
|
|
*/
|
|
void
|
|
channel_listener_dumpstats(int severity)
|
|
{
|
|
if (all_listeners && smartlist_len(all_listeners) > 0) {
|
|
tor_log(severity, LD_GENERAL,
|
|
"Dumping statistics about %d channel listeners:",
|
|
smartlist_len(all_listeners));
|
|
tor_log(severity, LD_GENERAL,
|
|
"%d are active and %d are done and waiting for cleanup",
|
|
(active_listeners != NULL) ?
|
|
smartlist_len(active_listeners) : 0,
|
|
(finished_listeners != NULL) ?
|
|
smartlist_len(finished_listeners) : 0);
|
|
|
|
SMARTLIST_FOREACH(all_listeners, channel_listener_t *, chan_l,
|
|
channel_listener_dump_statistics(chan_l, severity));
|
|
|
|
tor_log(severity, LD_GENERAL,
|
|
"Done spamming about channel listeners now");
|
|
} else {
|
|
tor_log(severity, LD_GENERAL,
|
|
"No channel listeners to dump");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Clean up channels.
|
|
*
|
|
* This gets called periodically from run_scheduled_events() in main.c;
|
|
* it cleans up after closed channels.
|
|
*/
|
|
void
|
|
channel_run_cleanup(void)
|
|
{
|
|
channel_t *tmp = NULL;
|
|
|
|
/* Check if we need to do anything */
|
|
if (!finished_channels || smartlist_len(finished_channels) == 0) return;
|
|
|
|
/* Iterate through finished_channels and get rid of them */
|
|
SMARTLIST_FOREACH_BEGIN(finished_channels, channel_t *, curr) {
|
|
tmp = curr;
|
|
/* Remove it from the list */
|
|
SMARTLIST_DEL_CURRENT(finished_channels, curr);
|
|
/* Also unregister it */
|
|
channel_unregister(tmp);
|
|
/* ... and free it */
|
|
channel_free(tmp);
|
|
} SMARTLIST_FOREACH_END(curr);
|
|
}
|
|
|
|
/**
|
|
* Clean up channel listeners.
|
|
*
|
|
* This gets called periodically from run_scheduled_events() in main.c;
|
|
* it cleans up after closed channel listeners.
|
|
*/
|
|
void
|
|
channel_listener_run_cleanup(void)
|
|
{
|
|
channel_listener_t *tmp = NULL;
|
|
|
|
/* Check if we need to do anything */
|
|
if (!finished_listeners || smartlist_len(finished_listeners) == 0) return;
|
|
|
|
/* Iterate through finished_channels and get rid of them */
|
|
SMARTLIST_FOREACH_BEGIN(finished_listeners, channel_listener_t *, curr) {
|
|
tmp = curr;
|
|
/* Remove it from the list */
|
|
SMARTLIST_DEL_CURRENT(finished_listeners, curr);
|
|
/* Also unregister it */
|
|
channel_listener_unregister(tmp);
|
|
/* ... and free it */
|
|
channel_listener_free(tmp);
|
|
} SMARTLIST_FOREACH_END(curr);
|
|
}
|
|
|
|
/**
|
|
* Free a list of channels for channel_free_all().
|
|
*/
|
|
static void
|
|
channel_free_list(smartlist_t *channels, int mark_for_close)
|
|
{
|
|
if (!channels) return;
|
|
|
|
SMARTLIST_FOREACH_BEGIN(channels, channel_t *, curr) {
|
|
/* Deregister and free it */
|
|
tor_assert(curr);
|
|
log_debug(LD_CHANNEL,
|
|
"Cleaning up channel %p (global ID " U64_FORMAT ") "
|
|
"in state %s (%d)",
|
|
curr, U64_PRINTF_ARG(curr->global_identifier),
|
|
channel_state_to_string(curr->state), curr->state);
|
|
/* Detach circuits early so they can find the channel */
|
|
if (curr->cmux) {
|
|
circuitmux_detach_all_circuits(curr->cmux, NULL);
|
|
}
|
|
SMARTLIST_DEL_CURRENT(channels, curr);
|
|
channel_unregister(curr);
|
|
if (mark_for_close) {
|
|
if (!CHANNEL_CONDEMNED(curr)) {
|
|
channel_mark_for_close(curr);
|
|
}
|
|
channel_force_xfree(curr);
|
|
} else channel_free(curr);
|
|
} SMARTLIST_FOREACH_END(curr);
|
|
}
|
|
|
|
/**
|
|
* Free a list of channel listeners for channel_free_all().
|
|
*/
|
|
static void
|
|
channel_listener_free_list(smartlist_t *listeners, int mark_for_close)
|
|
{
|
|
if (!listeners) return;
|
|
|
|
SMARTLIST_FOREACH_BEGIN(listeners, channel_listener_t *, curr) {
|
|
/* Deregister and free it */
|
|
tor_assert(curr);
|
|
log_debug(LD_CHANNEL,
|
|
"Cleaning up channel listener %p (global ID " U64_FORMAT ") "
|
|
"in state %s (%d)",
|
|
curr, U64_PRINTF_ARG(curr->global_identifier),
|
|
channel_listener_state_to_string(curr->state), curr->state);
|
|
channel_listener_unregister(curr);
|
|
if (mark_for_close) {
|
|
if (!(curr->state == CHANNEL_LISTENER_STATE_CLOSING ||
|
|
curr->state == CHANNEL_LISTENER_STATE_CLOSED ||
|
|
curr->state == CHANNEL_LISTENER_STATE_ERROR)) {
|
|
channel_listener_mark_for_close(curr);
|
|
}
|
|
channel_listener_force_xfree(curr);
|
|
} else channel_listener_free(curr);
|
|
} SMARTLIST_FOREACH_END(curr);
|
|
}
|
|
|
|
/**
|
|
* Close all channels and free everything.
|
|
*
|
|
* This gets called from tor_free_all() in main.c to clean up on exit.
|
|
* It will close all registered channels and free associated storage,
|
|
* then free the all_channels, active_channels, listening_channels and
|
|
* finished_channels lists and also channel_identity_map.
|
|
*/
|
|
void
|
|
channel_free_all(void)
|
|
{
|
|
log_debug(LD_CHANNEL,
|
|
"Shutting down channels...");
|
|
|
|
/* First, let's go for finished channels */
|
|
if (finished_channels) {
|
|
channel_free_list(finished_channels, 0);
|
|
smartlist_free(finished_channels);
|
|
finished_channels = NULL;
|
|
}
|
|
|
|
/* Now the finished listeners */
|
|
if (finished_listeners) {
|
|
channel_listener_free_list(finished_listeners, 0);
|
|
smartlist_free(finished_listeners);
|
|
finished_listeners = NULL;
|
|
}
|
|
|
|
/* Now all active channels */
|
|
if (active_channels) {
|
|
channel_free_list(active_channels, 1);
|
|
smartlist_free(active_channels);
|
|
active_channels = NULL;
|
|
}
|
|
|
|
/* Now all active listeners */
|
|
if (active_listeners) {
|
|
channel_listener_free_list(active_listeners, 1);
|
|
smartlist_free(active_listeners);
|
|
active_listeners = NULL;
|
|
}
|
|
|
|
/* Now all channels, in case any are left over */
|
|
if (all_channels) {
|
|
channel_free_list(all_channels, 1);
|
|
smartlist_free(all_channels);
|
|
all_channels = NULL;
|
|
}
|
|
|
|
/* Now all listeners, in case any are left over */
|
|
if (all_listeners) {
|
|
channel_listener_free_list(all_listeners, 1);
|
|
smartlist_free(all_listeners);
|
|
all_listeners = NULL;
|
|
}
|
|
|
|
/* Now free channel_identity_map */
|
|
log_debug(LD_CHANNEL,
|
|
"Freeing channel_identity_map");
|
|
/* Geez, anything still left over just won't die ... let it leak then */
|
|
HT_CLEAR(channel_idmap, &channel_identity_map);
|
|
|
|
/* Same with channel_gid_map */
|
|
log_debug(LD_CHANNEL,
|
|
"Freeing channel_gid_map");
|
|
HT_CLEAR(channel_gid_map, &channel_gid_map);
|
|
|
|
log_debug(LD_CHANNEL,
|
|
"Done cleaning up after channels");
|
|
}
|
|
|
|
/**
|
|
* Connect to a given addr/port/digest.
|
|
*
|
|
* This sets up a new outgoing channel; in the future if multiple
|
|
* channel_t subclasses are available, this is where the selection policy
|
|
* should go. It may also be desirable to fold port into tor_addr_t
|
|
* or make a new type including a tor_addr_t and port, so we have a
|
|
* single abstract object encapsulating all the protocol details of
|
|
* how to contact an OR.
|
|
*/
|
|
channel_t *
|
|
channel_connect(const tor_addr_t *addr, uint16_t port,
|
|
const char *id_digest,
|
|
const ed25519_public_key_t *ed_id)
|
|
{
|
|
return channel_tls_connect(addr, port, id_digest, ed_id);
|
|
}
|
|
|
|
/**
|
|
* Decide which of two channels to prefer for extending a circuit.
|
|
*
|
|
* This function is called while extending a circuit and returns true iff
|
|
* a is 'better' than b. The most important criterion here is that a
|
|
* canonical channel is always better than a non-canonical one, but the
|
|
* number of circuits and the age are used as tie-breakers.
|
|
*
|
|
* This is based on the former connection_or_is_better() of connection_or.c
|
|
*/
|
|
int
|
|
channel_is_better(channel_t *a, channel_t *b)
|
|
{
|
|
int a_is_canonical, b_is_canonical;
|
|
|
|
tor_assert(a);
|
|
tor_assert(b);
|
|
|
|
/* If one channel is bad for new circuits, and the other isn't,
|
|
* use the one that is still good. */
|
|
if (!channel_is_bad_for_new_circs(a) && channel_is_bad_for_new_circs(b))
|
|
return 1;
|
|
if (channel_is_bad_for_new_circs(a) && !channel_is_bad_for_new_circs(b))
|
|
return 0;
|
|
|
|
/* Check if one is canonical and the other isn't first */
|
|
a_is_canonical = channel_is_canonical(a);
|
|
b_is_canonical = channel_is_canonical(b);
|
|
|
|
if (a_is_canonical && !b_is_canonical) return 1;
|
|
if (!a_is_canonical && b_is_canonical) return 0;
|
|
|
|
/* Check if we suspect that one of the channels will be preferred
|
|
* by the peer */
|
|
if (a->is_canonical_to_peer && !b->is_canonical_to_peer) return 1;
|
|
if (!a->is_canonical_to_peer && b->is_canonical_to_peer) return 0;
|
|
|
|
/*
|
|
* Okay, if we're here they tied on canonicity, the prefer the older
|
|
* connection, so that the adversary can't create a new connection
|
|
* and try to switch us over to it (which will leak information
|
|
* about long-lived circuits). Additionally, switching connections
|
|
* too often makes us more vulnerable to attacks like Torscan and
|
|
* passive netflow-based equivalents.
|
|
*
|
|
* Connections will still only live for at most a week, due to
|
|
* the check in connection_or_group_set_badness() against
|
|
* TIME_BEFORE_OR_CONN_IS_TOO_OLD, which marks old connections as
|
|
* unusable for new circuits after 1 week. That check sets
|
|
* is_bad_for_new_circs, which is checked in channel_get_for_extend().
|
|
*
|
|
* We check channel_is_bad_for_new_circs() above here anyway, for safety.
|
|
*/
|
|
if (channel_when_created(a) < channel_when_created(b)) return 1;
|
|
else if (channel_when_created(a) > channel_when_created(b)) return 0;
|
|
|
|
if (channel_num_circuits(a) > channel_num_circuits(b)) return 1;
|
|
else return 0;
|
|
}
|
|
|
|
/**
|
|
* Get a channel to extend a circuit.
|
|
*
|
|
* Pick a suitable channel to extend a circuit to given the desired digest
|
|
* the address we believe is correct for that digest; this tries to see
|
|
* if we already have one for the requested endpoint, but if there is no good
|
|
* channel, set *msg_out to a message describing the channel's state
|
|
* and our next action, and set *launch_out to a boolean indicated whether
|
|
* the caller should try to launch a new channel with channel_connect().
|
|
*/
|
|
channel_t *
|
|
channel_get_for_extend(const char *rsa_id_digest,
|
|
const ed25519_public_key_t *ed_id,
|
|
const tor_addr_t *target_addr,
|
|
const char **msg_out,
|
|
int *launch_out)
|
|
{
|
|
channel_t *chan, *best = NULL;
|
|
int n_inprogress_goodaddr = 0, n_old = 0;
|
|
int n_noncanonical = 0;
|
|
|
|
tor_assert(msg_out);
|
|
tor_assert(launch_out);
|
|
|
|
chan = channel_find_by_remote_identity(rsa_id_digest, ed_id);
|
|
|
|
/* Walk the list, unrefing the old one and refing the new at each
|
|
* iteration.
|
|
*/
|
|
for (; chan; chan = channel_next_with_rsa_identity(chan)) {
|
|
tor_assert(tor_memeq(chan->identity_digest,
|
|
rsa_id_digest, DIGEST_LEN));
|
|
|
|
if (CHANNEL_CONDEMNED(chan))
|
|
continue;
|
|
|
|
/* Never return a channel on which the other end appears to be
|
|
* a client. */
|
|
if (channel_is_client(chan)) {
|
|
continue;
|
|
}
|
|
|
|
/* The Ed25519 key has to match too */
|
|
if (!channel_remote_identity_matches(chan, rsa_id_digest, ed_id)) {
|
|
continue;
|
|
}
|
|
|
|
/* Never return a non-open connection. */
|
|
if (!CHANNEL_IS_OPEN(chan)) {
|
|
/* If the address matches, don't launch a new connection for this
|
|
* circuit. */
|
|
if (channel_matches_target_addr_for_extend(chan, target_addr))
|
|
++n_inprogress_goodaddr;
|
|
continue;
|
|
}
|
|
|
|
/* Never return a connection that shouldn't be used for circs. */
|
|
if (channel_is_bad_for_new_circs(chan)) {
|
|
++n_old;
|
|
continue;
|
|
}
|
|
|
|
/* Never return a non-canonical connection using a recent link protocol
|
|
* if the address is not what we wanted.
|
|
*
|
|
* The channel_is_canonical_is_reliable() function asks the lower layer
|
|
* if we should trust channel_is_canonical(). The below is from the
|
|
* comments of the old circuit_or_get_for_extend() and applies when
|
|
* the lower-layer transport is channel_tls_t.
|
|
*
|
|
* (For old link protocols, we can't rely on is_canonical getting
|
|
* set properly if we're talking to the right address, since we might
|
|
* have an out-of-date descriptor, and we will get no NETINFO cell to
|
|
* tell us about the right address.)
|
|
*/
|
|
if (!channel_is_canonical(chan) &&
|
|
channel_is_canonical_is_reliable(chan) &&
|
|
!channel_matches_target_addr_for_extend(chan, target_addr)) {
|
|
++n_noncanonical;
|
|
continue;
|
|
}
|
|
|
|
if (!best) {
|
|
best = chan; /* If we have no 'best' so far, this one is good enough. */
|
|
continue;
|
|
}
|
|
|
|
if (channel_is_better(chan, best))
|
|
best = chan;
|
|
}
|
|
|
|
if (best) {
|
|
*msg_out = "Connection is fine; using it.";
|
|
*launch_out = 0;
|
|
return best;
|
|
} else if (n_inprogress_goodaddr) {
|
|
*msg_out = "Connection in progress; waiting.";
|
|
*launch_out = 0;
|
|
return NULL;
|
|
} else if (n_old || n_noncanonical) {
|
|
*msg_out = "Connections all too old, or too non-canonical. "
|
|
" Launching a new one.";
|
|
*launch_out = 1;
|
|
return NULL;
|
|
} else {
|
|
*msg_out = "Not connected. Connecting.";
|
|
*launch_out = 1;
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Describe the transport subclass for a channel.
|
|
*
|
|
* Invoke a method to get a string description of the lower-layer
|
|
* transport for this channel.
|
|
*/
|
|
const char *
|
|
channel_describe_transport(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
tor_assert(chan->describe_transport);
|
|
|
|
return chan->describe_transport(chan);
|
|
}
|
|
|
|
/**
|
|
* Describe the transport subclass for a channel listener.
|
|
*
|
|
* Invoke a method to get a string description of the lower-layer
|
|
* transport for this channel listener.
|
|
*/
|
|
const char *
|
|
channel_listener_describe_transport(channel_listener_t *chan_l)
|
|
{
|
|
tor_assert(chan_l);
|
|
tor_assert(chan_l->describe_transport);
|
|
|
|
return chan_l->describe_transport(chan_l);
|
|
}
|
|
|
|
/**
|
|
* Dump channel statistics.
|
|
*
|
|
* Dump statistics for one channel to the log.
|
|
*/
|
|
MOCK_IMPL(void,
|
|
channel_dump_statistics, (channel_t *chan, int severity))
|
|
{
|
|
double avg, interval, age;
|
|
time_t now = time(NULL);
|
|
tor_addr_t remote_addr;
|
|
int have_remote_addr;
|
|
char *remote_addr_str;
|
|
|
|
tor_assert(chan);
|
|
|
|
age = (double)(now - chan->timestamp_created);
|
|
|
|
tor_log(severity, LD_GENERAL,
|
|
"Channel " U64_FORMAT " (at %p) with transport %s is in state "
|
|
"%s (%d)",
|
|
U64_PRINTF_ARG(chan->global_identifier), chan,
|
|
channel_describe_transport(chan),
|
|
channel_state_to_string(chan->state), chan->state);
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel " U64_FORMAT " was created at " U64_FORMAT
|
|
" (" U64_FORMAT " seconds ago) "
|
|
"and last active at " U64_FORMAT " (" U64_FORMAT " seconds ago)",
|
|
U64_PRINTF_ARG(chan->global_identifier),
|
|
U64_PRINTF_ARG(chan->timestamp_created),
|
|
U64_PRINTF_ARG(now - chan->timestamp_created),
|
|
U64_PRINTF_ARG(chan->timestamp_active),
|
|
U64_PRINTF_ARG(now - chan->timestamp_active));
|
|
|
|
/* Handle digest. */
|
|
if (!tor_digest_is_zero(chan->identity_digest)) {
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel " U64_FORMAT " says it is connected "
|
|
"to an OR with digest %s",
|
|
U64_PRINTF_ARG(chan->global_identifier),
|
|
hex_str(chan->identity_digest, DIGEST_LEN));
|
|
} else {
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel " U64_FORMAT " does not know the digest"
|
|
" of the OR it is connected to",
|
|
U64_PRINTF_ARG(chan->global_identifier));
|
|
}
|
|
|
|
/* Handle remote address and descriptions */
|
|
have_remote_addr = channel_get_addr_if_possible(chan, &remote_addr);
|
|
if (have_remote_addr) {
|
|
char *actual = tor_strdup(channel_get_actual_remote_descr(chan));
|
|
remote_addr_str = tor_addr_to_str_dup(&remote_addr);
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel " U64_FORMAT " says its remote address"
|
|
" is %s, and gives a canonical description of \"%s\" and an "
|
|
"actual description of \"%s\"",
|
|
U64_PRINTF_ARG(chan->global_identifier),
|
|
safe_str(remote_addr_str),
|
|
safe_str(channel_get_canonical_remote_descr(chan)),
|
|
safe_str(actual));
|
|
tor_free(remote_addr_str);
|
|
tor_free(actual);
|
|
} else {
|
|
char *actual = tor_strdup(channel_get_actual_remote_descr(chan));
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel " U64_FORMAT " does not know its remote "
|
|
"address, but gives a canonical description of \"%s\" and an "
|
|
"actual description of \"%s\"",
|
|
U64_PRINTF_ARG(chan->global_identifier),
|
|
channel_get_canonical_remote_descr(chan),
|
|
actual);
|
|
tor_free(actual);
|
|
}
|
|
|
|
/* Handle marks */
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel " U64_FORMAT " has these marks: %s %s %s "
|
|
"%s %s %s",
|
|
U64_PRINTF_ARG(chan->global_identifier),
|
|
channel_is_bad_for_new_circs(chan) ?
|
|
"bad_for_new_circs" : "!bad_for_new_circs",
|
|
channel_is_canonical(chan) ?
|
|
"canonical" : "!canonical",
|
|
channel_is_canonical_is_reliable(chan) ?
|
|
"is_canonical_is_reliable" :
|
|
"!is_canonical_is_reliable",
|
|
channel_is_client(chan) ?
|
|
"client" : "!client",
|
|
channel_is_local(chan) ?
|
|
"local" : "!local",
|
|
channel_is_incoming(chan) ?
|
|
"incoming" : "outgoing");
|
|
|
|
/* Describe circuits */
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel " U64_FORMAT " has %d active circuits out of"
|
|
" %d in total",
|
|
U64_PRINTF_ARG(chan->global_identifier),
|
|
(chan->cmux != NULL) ?
|
|
circuitmux_num_active_circuits(chan->cmux) : 0,
|
|
(chan->cmux != NULL) ?
|
|
circuitmux_num_circuits(chan->cmux) : 0);
|
|
|
|
/* Describe timestamps */
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel " U64_FORMAT " was last used by a "
|
|
"client at " U64_FORMAT " (" U64_FORMAT " seconds ago)",
|
|
U64_PRINTF_ARG(chan->global_identifier),
|
|
U64_PRINTF_ARG(chan->timestamp_client),
|
|
U64_PRINTF_ARG(now - chan->timestamp_client));
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel " U64_FORMAT " last received a cell "
|
|
"at " U64_FORMAT " (" U64_FORMAT " seconds ago)",
|
|
U64_PRINTF_ARG(chan->global_identifier),
|
|
U64_PRINTF_ARG(chan->timestamp_recv),
|
|
U64_PRINTF_ARG(now - chan->timestamp_recv));
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel " U64_FORMAT " last transmitted a cell "
|
|
"at " U64_FORMAT " (" U64_FORMAT " seconds ago)",
|
|
U64_PRINTF_ARG(chan->global_identifier),
|
|
U64_PRINTF_ARG(chan->timestamp_xmit),
|
|
U64_PRINTF_ARG(now - chan->timestamp_xmit));
|
|
|
|
/* Describe counters and rates */
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel " U64_FORMAT " has received "
|
|
U64_FORMAT " bytes in " U64_FORMAT " cells and transmitted "
|
|
U64_FORMAT " bytes in " U64_FORMAT " cells",
|
|
U64_PRINTF_ARG(chan->global_identifier),
|
|
U64_PRINTF_ARG(chan->n_bytes_recved),
|
|
U64_PRINTF_ARG(chan->n_cells_recved),
|
|
U64_PRINTF_ARG(chan->n_bytes_xmitted),
|
|
U64_PRINTF_ARG(chan->n_cells_xmitted));
|
|
if (now > chan->timestamp_created &&
|
|
chan->timestamp_created > 0) {
|
|
if (chan->n_bytes_recved > 0) {
|
|
avg = (double)(chan->n_bytes_recved) / age;
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel " U64_FORMAT " has averaged %f "
|
|
"bytes received per second",
|
|
U64_PRINTF_ARG(chan->global_identifier), avg);
|
|
}
|
|
if (chan->n_cells_recved > 0) {
|
|
avg = (double)(chan->n_cells_recved) / age;
|
|
if (avg >= 1.0) {
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel " U64_FORMAT " has averaged %f "
|
|
"cells received per second",
|
|
U64_PRINTF_ARG(chan->global_identifier), avg);
|
|
} else if (avg >= 0.0) {
|
|
interval = 1.0 / avg;
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel " U64_FORMAT " has averaged %f "
|
|
"seconds between received cells",
|
|
U64_PRINTF_ARG(chan->global_identifier), interval);
|
|
}
|
|
}
|
|
if (chan->n_bytes_xmitted > 0) {
|
|
avg = (double)(chan->n_bytes_xmitted) / age;
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel " U64_FORMAT " has averaged %f "
|
|
"bytes transmitted per second",
|
|
U64_PRINTF_ARG(chan->global_identifier), avg);
|
|
}
|
|
if (chan->n_cells_xmitted > 0) {
|
|
avg = (double)(chan->n_cells_xmitted) / age;
|
|
if (avg >= 1.0) {
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel " U64_FORMAT " has averaged %f "
|
|
"cells transmitted per second",
|
|
U64_PRINTF_ARG(chan->global_identifier), avg);
|
|
} else if (avg >= 0.0) {
|
|
interval = 1.0 / avg;
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel " U64_FORMAT " has averaged %f "
|
|
"seconds between transmitted cells",
|
|
U64_PRINTF_ARG(chan->global_identifier), interval);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Dump anything the lower layer has to say */
|
|
channel_dump_transport_statistics(chan, severity);
|
|
}
|
|
|
|
/**
|
|
* Dump channel listener statistics.
|
|
*
|
|
* Dump statistics for one channel listener to the log.
|
|
*/
|
|
void
|
|
channel_listener_dump_statistics(channel_listener_t *chan_l, int severity)
|
|
{
|
|
double avg, interval, age;
|
|
time_t now = time(NULL);
|
|
|
|
tor_assert(chan_l);
|
|
|
|
age = (double)(now - chan_l->timestamp_created);
|
|
|
|
tor_log(severity, LD_GENERAL,
|
|
"Channel listener " U64_FORMAT " (at %p) with transport %s is in "
|
|
"state %s (%d)",
|
|
U64_PRINTF_ARG(chan_l->global_identifier), chan_l,
|
|
channel_listener_describe_transport(chan_l),
|
|
channel_listener_state_to_string(chan_l->state), chan_l->state);
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel listener " U64_FORMAT " was created at " U64_FORMAT
|
|
" (" U64_FORMAT " seconds ago) "
|
|
"and last active at " U64_FORMAT " (" U64_FORMAT " seconds ago)",
|
|
U64_PRINTF_ARG(chan_l->global_identifier),
|
|
U64_PRINTF_ARG(chan_l->timestamp_created),
|
|
U64_PRINTF_ARG(now - chan_l->timestamp_created),
|
|
U64_PRINTF_ARG(chan_l->timestamp_active),
|
|
U64_PRINTF_ARG(now - chan_l->timestamp_active));
|
|
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel listener " U64_FORMAT " last accepted an incoming "
|
|
"channel at " U64_FORMAT " (" U64_FORMAT " seconds ago) "
|
|
"and has accepted " U64_FORMAT " channels in total",
|
|
U64_PRINTF_ARG(chan_l->global_identifier),
|
|
U64_PRINTF_ARG(chan_l->timestamp_accepted),
|
|
U64_PRINTF_ARG(now - chan_l->timestamp_accepted),
|
|
U64_PRINTF_ARG(chan_l->n_accepted));
|
|
|
|
/*
|
|
* If it's sensible to do so, get the rate of incoming channels on this
|
|
* listener
|
|
*/
|
|
if (now > chan_l->timestamp_created &&
|
|
chan_l->timestamp_created > 0 &&
|
|
chan_l->n_accepted > 0) {
|
|
avg = (double)(chan_l->n_accepted) / age;
|
|
if (avg >= 1.0) {
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel listener " U64_FORMAT " has averaged %f incoming "
|
|
"channels per second",
|
|
U64_PRINTF_ARG(chan_l->global_identifier), avg);
|
|
} else if (avg >= 0.0) {
|
|
interval = 1.0 / avg;
|
|
tor_log(severity, LD_GENERAL,
|
|
" * Channel listener " U64_FORMAT " has averaged %f seconds "
|
|
"between incoming channels",
|
|
U64_PRINTF_ARG(chan_l->global_identifier), interval);
|
|
}
|
|
}
|
|
|
|
/* Dump anything the lower layer has to say */
|
|
channel_listener_dump_transport_statistics(chan_l, severity);
|
|
}
|
|
|
|
/**
|
|
* Invoke transport-specific stats dump for channel.
|
|
*
|
|
* If there is a lower-layer statistics dump method, invoke it.
|
|
*/
|
|
void
|
|
channel_dump_transport_statistics(channel_t *chan, int severity)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
if (chan->dumpstats) chan->dumpstats(chan, severity);
|
|
}
|
|
|
|
/**
|
|
* Invoke transport-specific stats dump for channel listener.
|
|
*
|
|
* If there is a lower-layer statistics dump method, invoke it.
|
|
*/
|
|
void
|
|
channel_listener_dump_transport_statistics(channel_listener_t *chan_l,
|
|
int severity)
|
|
{
|
|
tor_assert(chan_l);
|
|
|
|
if (chan_l->dumpstats) chan_l->dumpstats(chan_l, severity);
|
|
}
|
|
|
|
/**
|
|
* Return text description of the remote endpoint.
|
|
*
|
|
* This function return a test provided by the lower layer of the remote
|
|
* endpoint for this channel; it should specify the actual address connected
|
|
* to/from.
|
|
*
|
|
* Subsequent calls to channel_get_{actual,canonical}_remote_{address,descr}
|
|
* may invalidate the return value from this function.
|
|
*/
|
|
const char *
|
|
channel_get_actual_remote_descr(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
tor_assert(chan->get_remote_descr);
|
|
|
|
/* Param 1 indicates the actual description */
|
|
return chan->get_remote_descr(chan, GRD_FLAG_ORIGINAL);
|
|
}
|
|
|
|
/**
|
|
* Return the text address of the remote endpoint.
|
|
*
|
|
* Subsequent calls to channel_get_{actual,canonical}_remote_{address,descr}
|
|
* may invalidate the return value from this function.
|
|
*/
|
|
const char *
|
|
channel_get_actual_remote_address(channel_t *chan)
|
|
{
|
|
/* Param 1 indicates the actual description */
|
|
return chan->get_remote_descr(chan, GRD_FLAG_ORIGINAL|GRD_FLAG_ADDR_ONLY);
|
|
}
|
|
|
|
/**
|
|
* Return text description of the remote endpoint canonical address.
|
|
*
|
|
* This function return a test provided by the lower layer of the remote
|
|
* endpoint for this channel; it should use the known canonical address for
|
|
* this OR's identity digest if possible.
|
|
*
|
|
* Subsequent calls to channel_get_{actual,canonical}_remote_{address,descr}
|
|
* may invalidate the return value from this function.
|
|
*/
|
|
const char *
|
|
channel_get_canonical_remote_descr(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
tor_assert(chan->get_remote_descr);
|
|
|
|
/* Param 0 indicates the canonicalized description */
|
|
return chan->get_remote_descr(chan, 0);
|
|
}
|
|
|
|
/**
|
|
* Get remote address if possible.
|
|
*
|
|
* Write the remote address out to a tor_addr_t if the underlying transport
|
|
* supports this operation, and return 1. Return 0 if the underlying transport
|
|
* doesn't let us do this.
|
|
*/
|
|
MOCK_IMPL(int,
|
|
channel_get_addr_if_possible,(channel_t *chan, tor_addr_t *addr_out))
|
|
{
|
|
tor_assert(chan);
|
|
tor_assert(addr_out);
|
|
|
|
if (chan->get_remote_addr)
|
|
return chan->get_remote_addr(chan, addr_out);
|
|
/* Else no support, method not implemented */
|
|
else return 0;
|
|
}
|
|
|
|
/**
|
|
* Return true iff the channel has any cells on the connection outbuf waiting
|
|
* to be sent onto the network.
|
|
*/
|
|
int
|
|
channel_has_queued_writes(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
tor_assert(chan->has_queued_writes);
|
|
|
|
/* Check with the lower layer */
|
|
return chan->has_queued_writes(chan);
|
|
}
|
|
|
|
/**
|
|
* Check the is_bad_for_new_circs flag.
|
|
*
|
|
* This function returns the is_bad_for_new_circs flag of the specified
|
|
* channel.
|
|
*/
|
|
int
|
|
channel_is_bad_for_new_circs(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
return chan->is_bad_for_new_circs;
|
|
}
|
|
|
|
/**
|
|
* Mark a channel as bad for new circuits.
|
|
*
|
|
* Set the is_bad_for_new_circs_flag on chan.
|
|
*/
|
|
void
|
|
channel_mark_bad_for_new_circs(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
chan->is_bad_for_new_circs = 1;
|
|
}
|
|
|
|
/**
|
|
* Get the client flag.
|
|
*
|
|
* This returns the client flag of a channel, which will be set if
|
|
* command_process_create_cell() in command.c thinks this is a connection
|
|
* from a client.
|
|
*/
|
|
int
|
|
channel_is_client(const channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
return chan->is_client;
|
|
}
|
|
|
|
/**
|
|
* Set the client flag.
|
|
*
|
|
* Mark a channel as being from a client.
|
|
*/
|
|
void
|
|
channel_mark_client(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
chan->is_client = 1;
|
|
}
|
|
|
|
/**
|
|
* Clear the client flag.
|
|
*
|
|
* Mark a channel as being _not_ from a client.
|
|
*/
|
|
void
|
|
channel_clear_client(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
chan->is_client = 0;
|
|
}
|
|
|
|
/**
|
|
* Get the canonical flag for a channel.
|
|
*
|
|
* This returns the is_canonical for a channel; this flag is determined by
|
|
* the lower layer and can't be set in a transport-independent way.
|
|
*/
|
|
int
|
|
channel_is_canonical(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
tor_assert(chan->is_canonical);
|
|
|
|
return chan->is_canonical(chan, 0);
|
|
}
|
|
|
|
/**
|
|
* Test if the canonical flag is reliable.
|
|
*
|
|
* This function asks if the lower layer thinks it's safe to trust the
|
|
* result of channel_is_canonical().
|
|
*/
|
|
int
|
|
channel_is_canonical_is_reliable(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
tor_assert(chan->is_canonical);
|
|
|
|
return chan->is_canonical(chan, 1);
|
|
}
|
|
|
|
/**
|
|
* Test incoming flag.
|
|
*
|
|
* This function gets the incoming flag; this is set when a listener spawns
|
|
* a channel. If this returns true the channel was remotely initiated.
|
|
*/
|
|
int
|
|
channel_is_incoming(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
return chan->is_incoming;
|
|
}
|
|
|
|
/**
|
|
* Set the incoming flag.
|
|
*
|
|
* This function is called when a channel arrives on a listening channel
|
|
* to mark it as incoming.
|
|
*/
|
|
void
|
|
channel_mark_incoming(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
chan->is_incoming = 1;
|
|
}
|
|
|
|
/**
|
|
* Test local flag.
|
|
*
|
|
* This function gets the local flag; the lower layer should set this when
|
|
* setting up the channel if is_local_addr() is true for all of the
|
|
* destinations it will communicate with on behalf of this channel. It's
|
|
* used to decide whether to declare the network reachable when seeing incoming
|
|
* traffic on the channel.
|
|
*/
|
|
int
|
|
channel_is_local(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
return chan->is_local;
|
|
}
|
|
|
|
/**
|
|
* Set the local flag.
|
|
*
|
|
* This internal-only function should be called by the lower layer if the
|
|
* channel is to a local address. See channel_is_local() above or the
|
|
* description of the is_local bit in channel.h.
|
|
*/
|
|
void
|
|
channel_mark_local(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
chan->is_local = 1;
|
|
}
|
|
|
|
/**
|
|
* Mark a channel as remote.
|
|
*
|
|
* This internal-only function should be called by the lower layer if the
|
|
* channel is not to a local address but has previously been marked local.
|
|
* See channel_is_local() above or the description of the is_local bit in
|
|
* channel.h
|
|
*/
|
|
void
|
|
channel_mark_remote(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
chan->is_local = 0;
|
|
}
|
|
|
|
/**
|
|
* Test outgoing flag.
|
|
*
|
|
* This function gets the outgoing flag; this is the inverse of the incoming
|
|
* bit set when a listener spawns a channel. If this returns true the channel
|
|
* was locally initiated.
|
|
*/
|
|
int
|
|
channel_is_outgoing(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
return !(chan->is_incoming);
|
|
}
|
|
|
|
/**
|
|
* Mark a channel as outgoing.
|
|
*
|
|
* This function clears the incoming flag and thus marks a channel as
|
|
* outgoing.
|
|
*/
|
|
void
|
|
channel_mark_outgoing(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
chan->is_incoming = 0;
|
|
}
|
|
|
|
/************************
|
|
* Flow control queries *
|
|
***********************/
|
|
|
|
/**
|
|
* Estimate the number of writeable cells.
|
|
*
|
|
* Ask the lower layer for an estimate of how many cells it can accept.
|
|
*/
|
|
int
|
|
channel_num_cells_writeable(channel_t *chan)
|
|
{
|
|
int result;
|
|
|
|
tor_assert(chan);
|
|
tor_assert(chan->num_cells_writeable);
|
|
|
|
if (chan->state == CHANNEL_STATE_OPEN) {
|
|
/* Query lower layer */
|
|
result = chan->num_cells_writeable(chan);
|
|
if (result < 0) result = 0;
|
|
} else {
|
|
/* No cells are writeable in any other state */
|
|
result = 0;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/*********************
|
|
* Timestamp updates *
|
|
********************/
|
|
|
|
/**
|
|
* Update the created timestamp for a channel.
|
|
*
|
|
* This updates the channel's created timestamp and should only be called
|
|
* from channel_init().
|
|
*/
|
|
void
|
|
channel_timestamp_created(channel_t *chan)
|
|
{
|
|
time_t now = time(NULL);
|
|
|
|
tor_assert(chan);
|
|
|
|
chan->timestamp_created = now;
|
|
}
|
|
|
|
/**
|
|
* Update the created timestamp for a channel listener.
|
|
*
|
|
* This updates the channel listener's created timestamp and should only be
|
|
* called from channel_init_listener().
|
|
*/
|
|
void
|
|
channel_listener_timestamp_created(channel_listener_t *chan_l)
|
|
{
|
|
time_t now = time(NULL);
|
|
|
|
tor_assert(chan_l);
|
|
|
|
chan_l->timestamp_created = now;
|
|
}
|
|
|
|
/**
|
|
* Update the last active timestamp for a channel.
|
|
*
|
|
* This function updates the channel's last active timestamp; it should be
|
|
* called by the lower layer whenever there is activity on the channel which
|
|
* does not lead to a cell being transmitted or received; the active timestamp
|
|
* is also updated from channel_timestamp_recv() and channel_timestamp_xmit(),
|
|
* but it should be updated for things like the v3 handshake and stuff that
|
|
* produce activity only visible to the lower layer.
|
|
*/
|
|
void
|
|
channel_timestamp_active(channel_t *chan)
|
|
{
|
|
time_t now = time(NULL);
|
|
|
|
tor_assert(chan);
|
|
monotime_coarse_get(&chan->timestamp_xfer);
|
|
|
|
chan->timestamp_active = now;
|
|
|
|
/* Clear any potential netflow padding timer. We're active */
|
|
monotime_coarse_zero(&chan->next_padding_time);
|
|
}
|
|
|
|
/**
|
|
* Update the last active timestamp for a channel listener.
|
|
*/
|
|
void
|
|
channel_listener_timestamp_active(channel_listener_t *chan_l)
|
|
{
|
|
time_t now = time(NULL);
|
|
|
|
tor_assert(chan_l);
|
|
|
|
chan_l->timestamp_active = now;
|
|
}
|
|
|
|
/**
|
|
* Update the last accepted timestamp.
|
|
*
|
|
* This function updates the channel listener's last accepted timestamp; it
|
|
* should be called whenever a new incoming channel is accepted on a
|
|
* listener.
|
|
*/
|
|
void
|
|
channel_listener_timestamp_accepted(channel_listener_t *chan_l)
|
|
{
|
|
time_t now = time(NULL);
|
|
|
|
tor_assert(chan_l);
|
|
|
|
chan_l->timestamp_active = now;
|
|
chan_l->timestamp_accepted = now;
|
|
}
|
|
|
|
/**
|
|
* Update client timestamp.
|
|
*
|
|
* This function is called by relay.c to timestamp a channel that appears to
|
|
* be used as a client.
|
|
*/
|
|
void
|
|
channel_timestamp_client(channel_t *chan)
|
|
{
|
|
time_t now = time(NULL);
|
|
|
|
tor_assert(chan);
|
|
|
|
chan->timestamp_client = now;
|
|
}
|
|
|
|
/**
|
|
* Update the recv timestamp.
|
|
*
|
|
* This is called whenever we get an incoming cell from the lower layer.
|
|
* This also updates the active timestamp.
|
|
*/
|
|
void
|
|
channel_timestamp_recv(channel_t *chan)
|
|
{
|
|
time_t now = time(NULL);
|
|
tor_assert(chan);
|
|
monotime_coarse_get(&chan->timestamp_xfer);
|
|
|
|
chan->timestamp_active = now;
|
|
chan->timestamp_recv = now;
|
|
|
|
/* Clear any potential netflow padding timer. We're active */
|
|
monotime_coarse_zero(&chan->next_padding_time);
|
|
}
|
|
|
|
/**
|
|
* Update the xmit timestamp.
|
|
*
|
|
* This is called whenever we pass an outgoing cell to the lower layer. This
|
|
* also updates the active timestamp.
|
|
*/
|
|
void
|
|
channel_timestamp_xmit(channel_t *chan)
|
|
{
|
|
time_t now = time(NULL);
|
|
tor_assert(chan);
|
|
|
|
monotime_coarse_get(&chan->timestamp_xfer);
|
|
|
|
chan->timestamp_active = now;
|
|
chan->timestamp_xmit = now;
|
|
|
|
/* Clear any potential netflow padding timer. We're active */
|
|
monotime_coarse_zero(&chan->next_padding_time);
|
|
}
|
|
|
|
/***************************************************************
|
|
* Timestamp queries - see above for definitions of timestamps *
|
|
**************************************************************/
|
|
|
|
/**
|
|
* Query created timestamp for a channel.
|
|
*/
|
|
time_t
|
|
channel_when_created(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
return chan->timestamp_created;
|
|
}
|
|
|
|
/**
|
|
* Query client timestamp.
|
|
*/
|
|
time_t
|
|
channel_when_last_client(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
return chan->timestamp_client;
|
|
}
|
|
|
|
/**
|
|
* Query xmit timestamp.
|
|
*/
|
|
time_t
|
|
channel_when_last_xmit(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
return chan->timestamp_xmit;
|
|
}
|
|
|
|
/**
|
|
* Check if a channel matches an extend_info_t.
|
|
*
|
|
* This function calls the lower layer and asks if this channel matches a
|
|
* given extend_info_t.
|
|
*/
|
|
int
|
|
channel_matches_extend_info(channel_t *chan, extend_info_t *extend_info)
|
|
{
|
|
tor_assert(chan);
|
|
tor_assert(chan->matches_extend_info);
|
|
tor_assert(extend_info);
|
|
|
|
return chan->matches_extend_info(chan, extend_info);
|
|
}
|
|
|
|
/**
|
|
* Check if a channel matches a given target address; return true iff we do.
|
|
*
|
|
* This function calls into the lower layer and asks if this channel thinks
|
|
* it matches a given target address for circuit extension purposes.
|
|
*/
|
|
int
|
|
channel_matches_target_addr_for_extend(channel_t *chan,
|
|
const tor_addr_t *target)
|
|
{
|
|
tor_assert(chan);
|
|
tor_assert(chan->matches_target);
|
|
tor_assert(target);
|
|
|
|
return chan->matches_target(chan, target);
|
|
}
|
|
|
|
/**
|
|
* Return the total number of circuits used by a channel.
|
|
*
|
|
* @param chan Channel to query
|
|
* @return Number of circuits using this as n_chan or p_chan
|
|
*/
|
|
unsigned int
|
|
channel_num_circuits(channel_t *chan)
|
|
{
|
|
tor_assert(chan);
|
|
|
|
return chan->num_n_circuits +
|
|
chan->num_p_circuits;
|
|
}
|
|
|
|
/**
|
|
* Set up circuit ID generation.
|
|
*
|
|
* This is called when setting up a channel and replaces the old
|
|
* connection_or_set_circid_type().
|
|
*/
|
|
MOCK_IMPL(void,
|
|
channel_set_circid_type,(channel_t *chan,
|
|
crypto_pk_t *identity_rcvd,
|
|
int consider_identity))
|
|
{
|
|
int started_here;
|
|
crypto_pk_t *our_identity;
|
|
|
|
tor_assert(chan);
|
|
|
|
started_here = channel_is_outgoing(chan);
|
|
|
|
if (! consider_identity) {
|
|
if (started_here)
|
|
chan->circ_id_type = CIRC_ID_TYPE_HIGHER;
|
|
else
|
|
chan->circ_id_type = CIRC_ID_TYPE_LOWER;
|
|
return;
|
|
}
|
|
|
|
our_identity = started_here ?
|
|
get_tlsclient_identity_key() : get_server_identity_key();
|
|
|
|
if (identity_rcvd) {
|
|
if (crypto_pk_cmp_keys(our_identity, identity_rcvd) < 0) {
|
|
chan->circ_id_type = CIRC_ID_TYPE_LOWER;
|
|
} else {
|
|
chan->circ_id_type = CIRC_ID_TYPE_HIGHER;
|
|
}
|
|
} else {
|
|
chan->circ_id_type = CIRC_ID_TYPE_NEITHER;
|
|
}
|
|
}
|
|
|
|
static int
|
|
channel_sort_by_ed25519_identity(const void **a_, const void **b_)
|
|
{
|
|
const channel_t *a = *a_,
|
|
*b = *b_;
|
|
return fast_memcmp(&a->ed25519_identity.pubkey,
|
|
&b->ed25519_identity.pubkey,
|
|
sizeof(a->ed25519_identity.pubkey));
|
|
}
|
|
|
|
/** Helper for channel_update_bad_for_new_circs(): Perform the
|
|
* channel_update_bad_for_new_circs operation on all channels in <b>lst</b>,
|
|
* all of which MUST have the same RSA ID. (They MAY have different
|
|
* Ed25519 IDs.) */
|
|
static void
|
|
channel_rsa_id_group_set_badness(struct channel_list_s *lst, int force)
|
|
{
|
|
/*XXXX This function should really be about channels. 15056 */
|
|
channel_t *chan = TOR_LIST_FIRST(lst);
|
|
|
|
if (!chan)
|
|
return;
|
|
|
|
/* if there is only one channel, don't bother looping */
|
|
if (PREDICT_LIKELY(!TOR_LIST_NEXT(chan, next_with_same_id))) {
|
|
connection_or_single_set_badness_(
|
|
time(NULL), BASE_CHAN_TO_TLS(chan)->conn, force);
|
|
return;
|
|
}
|
|
|
|
smartlist_t *channels = smartlist_new();
|
|
|
|
TOR_LIST_FOREACH(chan, lst, next_with_same_id) {
|
|
if (BASE_CHAN_TO_TLS(chan)->conn) {
|
|
smartlist_add(channels, chan);
|
|
}
|
|
}
|
|
|
|
smartlist_sort(channels, channel_sort_by_ed25519_identity);
|
|
|
|
const ed25519_public_key_t *common_ed25519_identity = NULL;
|
|
/* it would be more efficient to do a slice, but this case is rare */
|
|
smartlist_t *or_conns = smartlist_new();
|
|
SMARTLIST_FOREACH_BEGIN(channels, channel_t *, channel) {
|
|
if (!common_ed25519_identity)
|
|
common_ed25519_identity = &channel->ed25519_identity;
|
|
|
|
if (! ed25519_pubkey_eq(&channel->ed25519_identity,
|
|
common_ed25519_identity)) {
|
|
connection_or_group_set_badness_(or_conns, force);
|
|
smartlist_clear(or_conns);
|
|
common_ed25519_identity = &channel->ed25519_identity;
|
|
}
|
|
|
|
smartlist_add(or_conns, BASE_CHAN_TO_TLS(channel)->conn);
|
|
} SMARTLIST_FOREACH_END(channel);
|
|
|
|
connection_or_group_set_badness_(or_conns, force);
|
|
|
|
/* XXXX 15056 we may want to do something special with connections that have
|
|
* no set Ed25519 identity! */
|
|
|
|
smartlist_free(or_conns);
|
|
smartlist_free(channels);
|
|
}
|
|
|
|
/** Go through all the channels (or if <b>digest</b> is non-NULL, just
|
|
* the OR connections with that digest), and set the is_bad_for_new_circs
|
|
* flag based on the rules in connection_or_group_set_badness() (or just
|
|
* always set it if <b>force</b> is true).
|
|
*/
|
|
void
|
|
channel_update_bad_for_new_circs(const char *digest, int force)
|
|
{
|
|
if (digest) {
|
|
channel_idmap_entry_t *ent;
|
|
channel_idmap_entry_t search;
|
|
memset(&search, 0, sizeof(search));
|
|
memcpy(search.digest, digest, DIGEST_LEN);
|
|
ent = HT_FIND(channel_idmap, &channel_identity_map, &search);
|
|
if (ent) {
|
|
channel_rsa_id_group_set_badness(&ent->channel_list, force);
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* no digest; just look at everything. */
|
|
channel_idmap_entry_t **iter;
|
|
HT_FOREACH(iter, channel_idmap, &channel_identity_map) {
|
|
channel_rsa_id_group_set_badness(&(*iter)->channel_list, force);
|
|
}
|
|
}
|
|
|