Initial channeltls.c/channeltls.h for bug 6465

9 files changed, 2431 insertions, 392 deletions

diff --git a/src/or/Makefile.nmake b/src/or/Makefile.nmake
index 5915364b6..b145fdcae 100644
--- a/src/or/Makefile.nmake
+++ b/src/or/Makefile.nmake
@@ -8,7 +8,7 @@ LIBS = ..\..\..\build-alpha\lib\libevent.a \
  ..\..\..\build-alpha\lib\libz.a \
  ws2_32.lib advapi32.lib shell32.lib
 
-LIBTOR_OBJECTS = buffers.obj channel.obj circuitbuild.obj \
+LIBTOR_OBJECTS = buffers.obj channel.obj channeltls.obj circuitbuild.obj \
 	circuitlist.obj circuituse.obj command.obj config.obj connection.obj
 	connection_edge.obj connection_or.obj control.obj cpuworker.obj \
 	directory.obj dirserv.obj dirvote.obj dns.obj dnsserv.obj geoip.obj \
diff --git a/src/or/channel.h b/src/or/channel.h
index 18d9a8120..242a07853 100644
--- a/src/or/channel.h
+++ b/src/or/channel.h
@@ -38,6 +38,11 @@ struct channel_s {
    */
   unsigned int is_listener:1;
 
+  /** Unique ID for measuring direct network status requests;vtunneled ones
+   * come over a circuit_t, which has a dirreq_id field as well, but is a
+   * distinct namespace. */
+  uint64_t dirreq_id;
+
   /** Why did we close?
    */
   enum {
diff --git a/src/or/channeltls.c b/src/or/channeltls.c
new file mode 100644
index 000000000..352037c14
--- /dev/null
+++ b/src/or/channeltls.c
@@ -0,0 +1,1894 @@
+/* * Copyright (c) 2012, The Tor Project, Inc. */
+/* See LICENSE for licensing information */
+
+/**
+ * \file channeltls.c
+ * \brief channel_t concrete subclass using or_connection_t
+ **/
+
+/*
+ * Define this so channel.h gives us things only channel_t subclasses
+ * should touch.
+ */
+
+#define _TOR_CHANNEL_INTERNAL
+
+#include "or.h"
+#include "channel.h"
+#include "channeltls.h"
+#include "config.h"
+#include "connection.h"
+#include "connection_or.h"
+#include "control.h"
+#include "relay.h"
+#include "router.h"
+#include "routerlist.h"
+
+/** How many CELL_PADDING cells have we received, ever? */
+uint64_t stats_n_padding_cells_processed = 0;
+/** How many CELL_VERSIONS cells have we received, ever? */
+uint64_t stats_n_versions_cells_processed = 0;
+/** How many CELL_NETINFO cells have we received, ever? */
+uint64_t stats_n_netinfo_cells_processed = 0;
+/** How many CELL_VPADDING cells have we received, ever? */
+uint64_t stats_n_vpadding_cells_processed = 0;
+/** How many CELL_CERTS cells have we received, ever? */
+uint64_t stats_n_certs_cells_processed = 0;
+/** How many CELL_AUTH_CHALLENGE cells have we received, ever? */
+uint64_t stats_n_auth_challenge_cells_processed = 0;
+/** How many CELL_AUTHENTICATE cells have we received, ever? */
+uint64_t stats_n_authenticate_cells_processed = 0;
+/** How many CELL_AUTHORIZE cells have we received, ever? */
+uint64_t stats_n_authorize_cells_processed = 0;
+
+/** Active listener, if any */
+channel_tls_t *channel_tls_listener = NULL;
+
+/* channel_tls_t method declarations */
+
+static void channel_tls_close_method(channel_t *chan);
+static int
+channel_tls_get_remote_addr_method(channel_t *chan, tor_addr_t *addr_out);
+static const char *
+channel_tls_get_remote_descr_method(channel_t *chan, int req);
+static int channel_tls_has_queued_writes_method(channel_t *chan);
+static int channel_tls_is_canonical_method(channel_t *chan, int req);
+static int
+channel_tls_matches_extend_info_method(channel_t *chan,
+                                       extend_info_t *extend_info);
+static int channel_tls_matches_target_method(channel_t *chan,
+                                             const tor_addr_t *target);
+static int channel_tls_write_cell_method(channel_t *chan,
+                                         cell_t *cell);
+static int channel_tls_write_packed_cell_method(channel_t *chan,
+                                                packed_cell_t *packed_cell);
+static int channel_tls_write_var_cell_method(channel_t *chan,
+                                             var_cell_t *var_cell);
+
+/** Handle incoming cells for the handshake stuff here rather than
+ * passing them on up. */
+
+static void channel_tls_process_versions_cell(var_cell_t *cell,
+                                              channel_tls_t *tlschan);
+static void channel_tls_process_netinfo_cell(cell_t *cell,
+                                             channel_tls_t *tlschan);
+static void channel_tls_process_certs_cell(var_cell_t *cell,
+                                           channel_tls_t *tlschan);
+static void channel_tls_process_auth_challenge_cell(var_cell_t *cell,
+                                                    channel_tls_t *tlschan);
+static void channel_tls_process_authenticate_cell(var_cell_t *cell,
+                                                  channel_tls_t *tlschan);
+static int command_allowed_before_handshake(uint8_t command);
+static int enter_v3_handshake_with_cell(var_cell_t *cell,
+                                        channel_tls_t *tlschan);
+
+/**
+ * Start a new TLS channel
+ *
+ * Launch a new OR connection to <b>addr</b>:<b>port</b> and expect to
+ * handshake with an OR with identity digest <b>id_digest</b>, and wrap
+ * it in a channel_tls_t.
+ *
+ * @param addr Address to connect on
+ * @param port Port to connect on
+ * @param id_digest Identity digest we want
+ * @return The launched channel, or NULL if it failed.
+ */
+
+channel_t *
+channel_tls_connect(const tor_addr_t *addr, uint16_t port,
+                    const char *id_digest)
+{
+  channel_tls_t *tlschan = tor_malloc_zero(sizeof(*tlschan));
+  channel_t *chan = TLS_CHAN_TO_BASE(tlschan);
+  channel_init_for_cells(chan);
+  chan->state = CHANNEL_STATE_OPENING;
+  chan->close = channel_tls_close_method;
+  chan->u.cell_chan.get_remote_addr = channel_tls_get_remote_addr_method;
+  chan->u.cell_chan.get_remote_descr = channel_tls_get_remote_descr_method;
+  chan->u.cell_chan.has_queued_writes = channel_tls_has_queued_writes_method;
+  chan->u.cell_chan.is_canonical = channel_tls_is_canonical_method;
+  chan->u.cell_chan.matches_extend_info =
+    channel_tls_matches_extend_info_method;
+  chan->u.cell_chan.matches_target = channel_tls_matches_target_method;
+  chan->u.cell_chan.write_cell = channel_tls_write_cell_method;
+  chan->u.cell_chan.write_packed_cell = channel_tls_write_packed_cell_method;
+  chan->u.cell_chan.write_var_cell = channel_tls_write_var_cell_method;
+
+  log_debug(LD_CHANNEL,
+            "In channel_tls_connect() for channel %p (global id %lu)",
+            tlschan, chan->global_identifier);
+
+  if (is_local_addr(addr)) channel_mark_local(chan);
+  channel_mark_outgoing(chan);
+
+  chan->u.cell_chan.active_circuit_pqueue = smartlist_new();
+  chan->u.cell_chan.active_circuit_pqueue_last_recalibrated =
+    cell_ewma_get_tick();
+
+  /* Set up or_connection stuff */
+  connection_or_connect(addr, port, id_digest, tlschan);
+  /* connection_or_connect() will fill in tlschan->conn */
+  if (!(tlschan->conn)) {
+    channel_change_state(chan, CHANNEL_STATE_ERROR);
+    goto err;
+  }
+
+  log_debug(LD_CHANNEL,
+            "Got orconn %p for channel with global id %lu",
+            tlschan->conn, chan->global_identifier);
+
+  goto done;
+
+ err:
+  smartlist_free(chan->u.cell_chan.active_circuit_pqueue);
+  tor_free(tlschan);
+  chan = NULL;
+
+ done:
+  /* If we got one, we should register it */
+  if (chan) channel_register(chan);
+
+  return chan;
+}
+
+/**
+ * Return the current channel_tls_t listener
+ *
+ * Returns the current listening channel for incoming TLS connections, or
+ * NULL if none has been established
+ *
+ * @return TLS listener
+ */
+
+channel_t *
+channel_tls_get_listener(void)
+{
+  return TLS_CHAN_TO_BASE(channel_tls_listener);
+}
+
+/**
+ * Start a channel_tls_t listener if necessary
+ *
+ * Return the current channel_tls_t listener, or start one if we haven't yet,
+ * and return that.
+ *
+ * @return TLS listener
+ */
+
+channel_t *
+channel_tls_start_listener(void)
+{
+  channel_tls_t *listener;
+  channel_t *lchan;
+
+  if (!channel_tls_listener) {
+    listener = tor_malloc_zero(sizeof(*listener));
+    lchan = TLS_CHAN_TO_BASE(listener);
+    channel_init_listener(lchan);
+    lchan->state = CHANNEL_STATE_LISTENING;
+    lchan->close = channel_tls_close_method;
+
+    channel_tls_listener = listener;
+
+    log_debug(LD_CHANNEL,
+              "Starting TLS listener channel %p with global id %lu",
+              lchan, lchan->global_identifier);
+  } else lchan = TLS_CHAN_TO_BASE(channel_tls_listener);
+
+  return lchan;
+}
+
+/**
+ * Free everything on shutdown
+ *
+ * Not much to do here, since channel_free_all() takes care of a lot, but let's
+ * get rid of the listener.
+ */
+
+void
+channel_tls_free_all(void)
+{
+  channel_t *base = NULL;
+
+  log_debug(LD_CHANNEL,
+            "Shutting down TLS channels...");
+
+  if (channel_tls_listener) {
+    base = TLS_CHAN_TO_BASE(channel_tls_listener);
+    channel_unregister(base);
+    channel_request_close(base);
+    channel_free(base);
+    channel_tls_listener = NULL;
+  }
+
+  log_debug(LD_CHANNEL,
+            "Done shutting down TLS channels");
+}
+
+/**
+ * Create a new channel around an incoming or_connection_t
+ *
+ * @param orconn New or_connection_t
+ * @return A channel to queue on the TLS listener
+ */
+
+channel_t *
+channel_tls_handle_incoming(or_connection_t *orconn)
+{
+  channel_tls_t *tlschan = tor_malloc_zero(sizeof(*tlschan));
+  channel_t *chan = TLS_CHAN_TO_BASE(tlschan);
+
+  tor_assert(orconn);
+  tor_assert(!(orconn->chan));
+
+  channel_init_for_cells(chan);
+  chan->state = CHANNEL_STATE_OPENING;
+  chan->close = channel_tls_close_method;
+  chan->u.cell_chan.get_remote_descr = channel_tls_get_remote_descr_method;
+  chan->u.cell_chan.has_queued_writes = channel_tls_has_queued_writes_method;
+  chan->u.cell_chan.is_canonical = channel_tls_is_canonical_method;
+  chan->u.cell_chan.matches_extend_info =
+    channel_tls_matches_extend_info_method;
+  chan->u.cell_chan.matches_target = channel_tls_matches_target_method;
+  chan->u.cell_chan.write_cell = channel_tls_write_cell_method;
+  chan->u.cell_chan.write_packed_cell = channel_tls_write_packed_cell_method;
+  chan->u.cell_chan.write_var_cell = channel_tls_write_var_cell_method;
+
+  /* Link the channel and orconn to each other */
+  tlschan->conn = orconn;
+  orconn->chan = tlschan;
+
+  if (is_local_addr(&(TO_CONN(orconn)->addr))) channel_mark_local(chan);
+  channel_mark_incoming(chan);
+
+  chan->u.cell_chan.active_circuit_pqueue = smartlist_new();
+  chan->u.cell_chan.active_circuit_pqueue_last_recalibrated =
+    cell_ewma_get_tick();
+
+  /* If we got one, we should register it */
+  if (chan) channel_register(chan);
+
+  return chan;
+}
+
+/********************************************
+ * Method implementations for channel_tls_t *
+ *******************************************/
+
+/**
+ * Close a channel_tls_t
+ *
+ * This implements the close method for channel_tls_t
+ *
+ * @param chan Channel to close
+ */
+
+static void
+channel_tls_close_method(channel_t *chan)
+{
+  channel_tls_t *tlschan = BASE_CHAN_TO_TLS(chan);
+  channel_t *tmp = NULL;
+
+  tor_assert(tlschan);
+
+  if (chan->is_listener) {
+    /*
+     * Listeners we just go ahead and change state through to CLOSED, but
+     * make sure to check if they're channel_tls_listener to NULL it out.
+     */
+    if (chan == TLS_CHAN_TO_BASE(channel_tls_listener))
+      channel_tls_listener = NULL;
+
+    if (!(chan->state == CHANNEL_STATE_CLOSING ||
+          chan->state == CHANNEL_STATE_CLOSED ||
+          chan->state == CHANNEL_STATE_ERROR)) {
+      channel_change_state(chan, CHANNEL_STATE_CLOSING);
+    }
+
+    if (chan->u.listener.incoming_list) {
+      SMARTLIST_FOREACH_BEGIN(chan->u.listener.incoming_list,
+                              channel_t *, ichan) {
+        tmp = ichan;
+        SMARTLIST_DEL_CURRENT(chan->u.listener.incoming_list, ichan);
+        channel_request_close(tmp);
+      } SMARTLIST_FOREACH_END(ichan);
+
+      smartlist_free(chan->u.listener.incoming_list);
+      chan->u.listener.incoming_list = NULL;
+    }
+
+    if (!(chan->state == CHANNEL_STATE_CLOSED ||
+          chan->state == CHANNEL_STATE_ERROR)) {
+      channel_change_state(chan, CHANNEL_STATE_CLOSED);
+    }
+  } else {
+    if (tlschan->conn) connection_or_close_normally(tlschan->conn, 1);
+    else {
+      /* Weird - we'll have to change the state ourselves, I guess */
+      log_info(LD_CHANNEL,
+               "Tried to close channel_tls_t %p with NULL conn",
+               tlschan);
+      channel_change_state(chan, CHANNEL_STATE_ERROR);
+    }
+  }
+}
+
+/**
+ * Get the remote address of a channel_tls_t
+ *
+ * This implements the get_remote_addr method for channel_tls_t; copy the
+ * remote endpoint of the channel to addr_out and return 1 (always
+ * succeeds for this transport).
+ *
+ * @param chan Channel to query
+ * @param addr_out Write the address out here
+ * @return Always succeeds and returns 1
+ */
+
+static int
+channel_tls_get_remote_addr_method(channel_t *chan, tor_addr_t *addr_out)
+{
+  channel_tls_t *tlschan = BASE_CHAN_TO_TLS(chan);
+
+  tor_assert(tlschan);
+  tor_assert(addr_out);
+  tor_assert(tlschan->conn);
+
+  tor_addr_copy(addr_out, &(TO_CONN(tlschan->conn)->addr));
+
+  return 1;
+}
+
+/**
+ * Get endpoint description of a channel_tls_t
+ *
+ * This implements the get_remote_descr method for channel_tls_t; it returns
+ * a text description of the remote endpoint of the channel suitable for use
+ * in log messages.  The req parameter is 0 for the canonical address or 1 for
+ * the actual address seen.
+ *
+ * @param chan Channel to query
+ * @param req Request type (0 for canonical, 1 for actual)
+ * @return Pointer to string containing description
+ */
+
+static const char *
+channel_tls_get_remote_descr_method(channel_t *chan, int req)
+{
+#define MAX_DESCR_LEN 32
+
+  static char buf[MAX_DESCR_LEN + 1];
+  channel_tls_t *tlschan = BASE_CHAN_TO_TLS(chan);
+  connection_t *conn;
+  const char *answer = NULL;
+  char *addr_str;
+
+  tor_assert(tlschan);
+  tor_assert(tlschan->conn);
+
+  conn = TO_CONN(tlschan->conn);
+
+  switch (req) {
+    case 0:
+      /* Canonical address */
+      tor_snprintf(buf, MAX_DESCR_LEN + 1,
+                   "%s:%u", conn->address, conn->port);
+      answer = buf;
+      break;
+    case 1:
+      /* Actual address */
+      addr_str = tor_dup_addr(&(tlschan->conn->real_addr));
+      tor_snprintf(buf, MAX_DESCR_LEN + 1,
+                   "%s:%u", addr_str, conn->port);
+      tor_free(addr_str);
+      answer = buf;
+      break;
+    default:
+      /* Something's broken in channel.c */
+      tor_assert(1);
+  }
+
+  return answer;
+}
+
+/**
+ * Tell the upper layer if we have queued writes
+ *
+ * This implements the has_queued_writes method for channel_tls _t; it returns
+ * 1 iff we have queued writes on the outbuf of the underlying or_connection_t.
+ *
+ * @param chan Channel to query
+ * @return Whether we have queued writes on the outbuf
+ */
+
+static int
+channel_tls_has_queued_writes_method(channel_t *chan)
+{
+  size_t outbuf_len;
+  channel_tls_t *tlschan = BASE_CHAN_TO_TLS(chan);
+
+  tor_assert(tlschan);
+  tor_assert(tlschan->conn);
+
+  outbuf_len = connection_get_outbuf_len(TO_CONN(tlschan->conn));
+
+  return (outbuf_len > 0);
+}
+
+/**
+ * Tell the upper layer if we're canonical
+ *
+ * This implements the is_canonical method for channel_tls_t; if req is zero,
+ * it returns whether this is a canonical channel, and if it is one it returns
+ * whether that can be relied upon.
+ *
+ * @param chan Channel to query
+ * @param req Request type (0 for is_canonical, 1 for is_canonical_reliable)
+ * @return Query response
+ */
+
+static int
+channel_tls_is_canonical_method(channel_t *chan, int req)
+{
+  int answer = 0;
+  channel_tls_t *tlschan = BASE_CHAN_TO_TLS(chan);
+
+  tor_assert(tlschan);
+  tor_assert(tlschan->conn);
+
+  switch (req) {
+    case 0:
+      answer = tlschan->conn->is_canonical;
+      break;
+    case 1:
+      /*
+       * Is the is_canonical bit reliable?  In protocols version 2 and up
+       * we get the canonical address from a NETINFO cell, but in older
+       * versions it might be based on an obsolete descriptor.
+       */
+      answer = (tlschan->conn->link_proto >= 2);
+      break;
+    default:
+      /* This shouldn't happen; channel.c is broken if it does */
+      tor_assert(1);
+  }
+
+  return answer;
+}
+
+/**
+ * Check if we match an extend_info_t
+ *
+ * This implements the matches_extend_info method for channel_tls_t; the upper
+ * layer wants to know if this channel matches an extend_info_t.
+ *
+ * @param chan Channel to test
+ * @param extend_info The extend_info_t to match
+ * @return 1 if this channel matches, 0 otherwise
+ */
+
+static int
+channel_tls_matches_extend_info_method(channel_t *chan,
+                                       extend_info_t *extend_info)
+{
+  channel_tls_t *tlschan = BASE_CHAN_TO_TLS(chan);
+
+  tor_assert(tlschan);
+  tor_assert(extend_info);
+
+  return (tor_addr_eq(&(extend_info->addr),
+                      &(TO_CONN(tlschan->conn)->addr)) &&
+         (extend_info->port == TO_CONN(tlschan->conn)->port));
+}
+
+/**
+ * Check if we match a target address
+ *
+ * This implements the matches_target method for channel_tls _t; the upper
+ * layer wants to know if this channel matches a target address when extending
+ * a circuit.
+ *
+ * @param chan Channel to test
+ * @param target Address to match
+ * @return 1 if this channel matches, 0 otherwise
+ */
+
+static int
+channel_tls_matches_target_method(channel_t *chan,
+                                  const tor_addr_t *target)
+{
+  channel_tls_t *tlschan = BASE_CHAN_TO_TLS(chan);
+
+  tor_assert(tlschan);
+  tor_assert(target);
+  tor_assert(tlschan->conn);
+
+  return tor_addr_compare(&(tlschan->conn->real_addr),
+                          target, CMP_EXACT);
+}
+
+/**
+ * Write a cell to a channel_tls_t
+ *
+ * This implements the write_cell method for channel_tls_t; given a
+ * channel_tls_t and a cell_t, transmit the cell_t.
+ *
+ * @param chan Channel to transmit on
+ * @param cell Cell to transmit
+ * @return Always succeeds and returns 1
+ */
+
+static int
+channel_tls_write_cell_method(channel_t *chan, cell_t *cell)
+{
+  channel_tls_t *tlschan = BASE_CHAN_TO_TLS(chan);
+
+  tor_assert(tlschan);
+  tor_assert(cell);
+  tor_assert(tlschan->conn);
+
+  connection_or_write_cell_to_buf(cell, tlschan->conn);
+
+  return 1;
+}
+
+/**
+ * Write a packed cell to a channel_tls_t
+ *
+ * This implements the write_packed_cell method for channel_tls_t; given a
+ * channel_tls_t and a packed_cell_t, transmit the packed_cell_t.
+ *
+ * @param chan Channel to transmit on
+ * @param packed_cell Cell to transmit
+ * @return Always succeeds and returns 1
+ */
+
+static int
+channel_tls_write_packed_cell_method(channel_t *chan,
+                                     packed_cell_t *packed_cell)
+{
+  channel_tls_t *tlschan = BASE_CHAN_TO_TLS(chan);
+
+  tor_assert(tlschan);
+  tor_assert(packed_cell);
+  tor_assert(tlschan->conn);
+
+  connection_write_to_buf(packed_cell->body, CELL_NETWORK_SIZE,
+                          TO_CONN(tlschan->conn));
+
+  /* This is where the cell is finished; used to be done from relay.c */
+  packed_cell_free(packed_cell);
+
+  return 1;
+}
+
+/**
+ * Write a variable-length cell to a channel_tls_t
+ *
+ * This implements the write_var_cell method for channel_tls_t; given a
+ * channel_tls_t and a var_cell_t, transmit the var_cell_t.
+ *
+ * @param chan Channel to transmit on
+ * @param var_cell Cell to transmit
+ * @return Always succeeds and returns 1
+ */
+
+static int
+channel_tls_write_var_cell_method(channel_t *chan, var_cell_t *var_cell)
+{
+  channel_tls_t *tlschan = BASE_CHAN_TO_TLS(chan);
+
+  tor_assert(tlschan);
+  tor_assert(var_cell);
+  tor_assert(tlschan->conn);
+
+  connection_or_write_var_cell_to_buf(var_cell, tlschan->conn);
+
+  return 1;
+}
+
+/*******************************************************
+ * Functions for handling events on an or_connection_t *
+ ******************************************************/
+
+/**
+ * Handle orconn state changes
+ *
+ * This function will be called by connection_or.c when the or_connection_t
+ * associated with this channel_tls_t changes state.
+ *
+ * @param chan Channel controlling the or_connection_t
+ * @param conn The or_connection_t changing state
+ * @param old_state The old state of conn
+ * @param state The new state of conn
+ */
+
+void
+channel_tls_handle_state_change_on_orconn(channel_tls_t *chan,
+                                          or_connection_t *conn,
+                                          uint8_t old_state,
+                                          uint8_t state)
+{
+  channel_t *base_chan;
+
+  tor_assert(chan);
+  tor_assert(conn);
+  tor_assert(conn->chan == chan);
+  tor_assert(chan->conn == conn);
+  /* -Werror appeasement */
+  tor_assert(old_state == old_state);
+
+  base_chan = TLS_CHAN_TO_BASE(chan);
+
+  /* Make sure the base connection state makes sense - shouldn't be error,
+   * closed or listening. */
+
+  tor_assert(base_chan->state == CHANNEL_STATE_OPENING ||
+             base_chan->state == CHANNEL_STATE_OPEN ||
+             base_chan->state == CHANNEL_STATE_MAINT ||
+             base_chan->state == CHANNEL_STATE_CLOSING);
+
+  /* Did we just go to state open? */
+  if (state == OR_CONN_STATE_OPEN) {
+    /*
+     * We can go to CHANNEL_STATE_OPEN from CHANNEL_STATE_OPENING or
+     * CHANNEL_STATE_MAINT on this.
+     */
+    channel_change_state(base_chan, CHANNEL_STATE_OPEN);
+  } else {
+    /*
+     * Not open, so from CHANNEL_STATE_OPEN we go to CHANNEL_STATE_MAINT,
+     * otherwise no change.
+     */
+    if (base_chan->state == CHANNEL_STATE_OPEN) {
+      channel_change_state(base_chan, CHANNEL_STATE_MAINT);
+    }
+  }
+}
+
+/**
+ * Try to flush cells from a channel_tls_t
+ *
+ * Try to flush up to about num_cells cells, and return how many we flushed.
+ *
+ * @param chan Channel to flush
+ * @param num_cells Maximum number of cells
+ * @return Number of cells actually flushed
+ */
+
+ssize_t
+channel_tls_flush_some_cells(channel_tls_t *chan, ssize_t num_cells)
+{
+  ssize_t flushed = 0;
+
+  tor_assert(chan);
+
+  if (flushed >= num_cells) goto done;
+
+  /*
+   * If channel_tls_t ever buffers anything below the channel_t layer, flush
+   * that first here.
+   */
+
+  flushed += channel_flush_some_cells(TLS_CHAN_TO_BASE(chan),
+                                      num_cells - flushed);
+
+  /*
+   * If channel_tls_t ever buffers anything below the channel_t layer, check
+   * how much we actually got and push it on down here.
+   */
+
+ done:
+  return flushed;
+}
+
+/**
+ * Check if a channel_tls_t has anything to flush
+ *
+ * Return true if there is any more to flush on this channel (cells in queue
+ * or active circuits).
+ *
+ * @param chan Channel to test
+ * @return 1 if chan has anything to flush, 0 otherwise
+ */
+
+int
+channel_tls_more_to_flush(channel_tls_t *chan)
+{
+  tor_assert(chan);
+
+  /*
+   * If channel_tls_t ever buffers anything below channel_t, the
+   * check for that should go here first.
+   */
+
+  return channel_more_to_flush(TLS_CHAN_TO_BASE(chan));
+}
+
+#ifdef KEEP_TIMING_STATS
+
+/**
+ * Timing states wrapper
+ *
+ * This is a wrapper function around the actual function that processes the
+ * <b>cell</b> that just arrived on <b>chan</b>. Increment <b>*time</b>
+ * by the number of microseconds used by the call to <b>*func(cell, chan)</b>.
+ *
+ * @param cell Incoming cell to process
+ * @param chan Channel it arrived on
+ * @param time Increment this by the number of microseconds it took to handle
+ *        this cell
+ * @param func Function pointer to cell handling function
+ */
+
+static void
+channel_tls_time_process_cell(cell_t *cell, channel_tls_t *chan, int *time,
+                              void (*func)(cell_t *, channel_tls_t *))
+{
+  struct timeval start, end;
+  long time_passed;
+
+  tor_gettimeofday(&start);
+
+  (*func)(cell, chan);
+
+  tor_gettimeofday(&end);
+  time_passed = tv_udiff(&start, &end) ;
+
+  if (time_passed > 10000) { /* more than 10ms */
+    log_debug(LD_OR,"That call just took %ld ms.",time_passed/1000);
+  }
+
+  if (time_passed < 0) {
+    log_info(LD_GENERAL,"That call took us back in time!");
+    time_passed = 0;
+  }
+
+  *time += time_passed;
+}
+#endif
+
+/**
+ * Handle an incoming cell on a channel_tls_t
+ *
+ * This is called from connection_or.c to handle an arriving cell; it checks
+ * for cell types specific to the handshake for this transport protocol and
+ * handles them, and queues all other cells to the channel_t layer, which
+ * eventually will hand them off to command.c.
+ *
+ * @param cell Cell to handle
+ * @param conn The or_connection_t cell arrived on
+ */
+
+void
+channel_tls_handle_cell(cell_t *cell, or_connection_t *conn)
+{
+  channel_tls_t *chan;
+  int handshaking;
+
+#ifdef KEEP_TIMING_STATS
+#define PROCESS_CELL(tp, cl, cn) STMT_BEGIN {                   \
+    ++num ## tp;                                                \
+    channel_tls_time_process_cell(cl, cn, & tp ## time ,            \
+                             channel_tls_process_ ## tp ## _cell);  \
+    } STMT_END
+#else
+#define PROCESS_CELL(tp, cl, cn) channel_tls_process_ ## tp ## _cell(cl, cn)
+#endif
+
+  tor_assert(cell);
+  tor_assert(conn);
+
+  chan = conn->chan;
+
+ if (!chan) {
+   log_warn(LD_CHANNEL,
+            "Got a cell_t on an OR connection with no channel");
+   return;
+  }
+
+  tor_assert(!(TLS_CHAN_TO_BASE(chan)->is_listener));
+
+  handshaking = (TO_CONN(conn)->state != OR_CONN_STATE_OPEN);
+
+  if (conn->_base.marked_for_close)
+    return;
+
+  /* Reject all but VERSIONS and NETINFO when handshaking. */
+  /* (VERSIONS should actually be impossible; it's variable-length.) */
+  if (handshaking && cell->command != CELL_VERSIONS &&
+      cell->command != CELL_NETINFO) {
+    log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
+           "Received unexpected cell command %d in chan state %s / "
+           "conn state %s; closing the connection.",
+           (int)cell->command,
+           channel_state_to_string(TLS_CHAN_TO_BASE(chan)->state),
+           conn_state_to_string(CONN_TYPE_OR, TO_CONN(conn)->state));
+    connection_or_close_for_error(conn, 0);
+    return;
+  }
+
+  if (conn->_base.state == OR_CONN_STATE_OR_HANDSHAKING_V3)
+    or_handshake_state_record_cell(conn->handshake_state, cell, 1);
+
+  switch (cell->command) {
+    case CELL_PADDING:
+      ++stats_n_padding_cells_processed;
+      /* do nothing */
+      break;
+    case CELL_VERSIONS:
+      tor_fragile_assert();
+      break;
+    case CELL_NETINFO:
+      ++stats_n_netinfo_cells_processed;
+      PROCESS_CELL(netinfo, cell, chan);
+      break;
+    case CELL_CREATE:
+    case CELL_CREATE_FAST:
+    case CELL_CREATED:
+    case CELL_CREATED_FAST:
+    case CELL_RELAY:
+    case CELL_RELAY_EARLY:
+    case CELL_DESTROY:
+      /*
+       * These are all transport independent and we pass them up through the
+       * channel_t mechanism.  They are ultimately handled in command.c.
+       */
+      channel_queue_cell(TLS_CHAN_TO_BASE(chan), cell);
+      break;
+    default:
+      log_fn(LOG_INFO, LD_PROTOCOL,
+             "Cell of unknown type (%d) received in channeltls.c.  "
+             "Dropping.",
+             cell->command);
+             break;
+  }
+}
+
+/**
+ * Handle an incoming variable-length cell on a channel_tls_t
+ *
+ * Process a <b>var_cell</b> that was just received on <b>conn</b>. Keep
+ * internal statistics about how many of each cell we've processed so far
+ * this second, and the total number of microseconds it took to
+ * process each type of cell.  All the var_cell commands are handshake-
+ * related and live below the channel_t layer, so no variable-length
+ * cells ever get delivered in the current implementation, but I've left
+ * the mechanism in place for future use.
+ *
+ * @param var_cell Incoming cell to handle
+ * @param conn The or_connection_t var_cell arrived on
+ */
+
+void
+channel_tls_handle_var_cell(var_cell_t *var_cell, or_connection_t *conn)
+{
+  channel_tls_t *chan;
+  int handshaking;
+
+#ifdef KEEP_TIMING_STATS
+  /* how many of each cell have we seen so far this second? needs better
+   * name. */
+  static int num_versions = 0, num_certs = 0;
+  static time_t current_second = 0; /* from previous calls to time */
+  time_t now = time(NULL);
+
+  if (current_second == 0) current_second = now;
+  if (now > current_second) { /* the second has rolled over */
+    /* print stats */
+    log_info(LD_OR,
+             "At end of second: %d versions (%d ms), %d certs (%d ms)",
+             num_versions, versions_time / ((now - current_second) * 1000),
+             num_certs, certs_time / ((now - current_second) * 1000));
+
+    num_versions = num_certs = 0;
+    versions_time = certs_time = 0;
+
+    /* remember which second it is, for next time */
+    current_second = now;
+  }
+#endif
+
+  tor_assert(var_cell);
+  tor_assert(conn);
+
+  chan = conn->chan;
+
+  if (!chan) {
+    log_warn(LD_CHANNEL,
+             "Got a var_cell_t on an OR connection with no channel");
+    return;
+  }
+
+  tor_assert(!(TLS_CHAN_TO_BASE(chan)->is_listener));
+
+  handshaking = (TO_CONN(conn)->state != OR_CONN_STATE_OPEN);
+
+  if (TO_CONN(conn)->marked_for_close)
+    return;
+
+  switch (TO_CONN(conn)->state) {
+    case OR_CONN_STATE_OR_HANDSHAKING_V2:
+      if (var_cell->command != CELL_VERSIONS) {
+        log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
+               "Received a cell with command %d in unexpected "
+               "orconn state \"%s\" [%d], channel state \"%s\" [%d]; "
+               "closing the connection.",
+               (int)(var_cell->command),
+               conn_state_to_string(CONN_TYPE_OR, TO_CONN(conn)->state),
+               TO_CONN(conn)->state,
+               channel_state_to_string(TLS_CHAN_TO_BASE(chan)->state),
+               (int)(TLS_CHAN_TO_BASE(chan)->state));
+        /*
+         * The code in connection_or.c will tell channel_t to close for
+         * error; it will go to CHANNEL_STATE_CLOSING, and then to
+         * CHANNEL_STATE_ERROR when conn is closed.
+         */
+        connection_or_close_for_error(conn, 0);
+        return;
+      }
+      break;
+    case OR_CONN_STATE_TLS_HANDSHAKING:
+      /* If we're using bufferevents, it's entirely possible for us to
+       * notice "hey, data arrived!" before we notice "hey, the handshake
+       * finished!" And we need to be accepting both at once to handle both
+       * the v2 and v3 handshakes. */
+
+      /* fall through */
+    case OR_CONN_STATE_TLS_SERVER_RENEGOTIATING:
+      if (!(command_allowed_before_handshake(var_cell->command))) {
+        log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
+               "Received a cell with command %d in unexpected "
+               "orconn state \"%s\" [%d], channel state \"%s\" [%d]; "
+               "closing the connection.",
+               (int)(var_cell->command),
+               conn_state_to_string(CONN_TYPE_OR, TO_CONN(conn)->state),
+               (int)(TO_CONN(conn)->state),
+               channel_state_to_string(TLS_CHAN_TO_BASE(chan)->state),
+               (int)(TLS_CHAN_TO_BASE(chan)->state));
+        /* see above comment about CHANNEL_STATE_ERROR */
+        connection_or_close_for_error(conn, 0);
+        return;
+      } else {
+        if (enter_v3_handshake_with_cell(var_cell, chan) < 0)
+          return;
+      }
+      break;
+    case OR_CONN_STATE_OR_HANDSHAKING_V3:
+      if (var_cell->command != CELL_AUTHENTICATE)
+        or_handshake_state_record_var_cell(conn->handshake_state, var_cell, 1);
+      break; /* Everything is allowed */
+    case OR_CONN_STATE_OPEN:
+      if (conn->link_proto < 3) {
+        log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
+               "Received a variable-length cell with command %d in orconn "
+               "state %s [%d], channel state %s [%d] with link protocol %d; "
+               "ignoring it.",
+               (int)(var_cell->command),
+               conn_state_to_string(CONN_TYPE_OR, TO_CONN(conn)->state),
+               (int)(TO_CONN(conn)->state),
+               channel_state_to_string(TLS_CHAN_TO_BASE(chan)->state),
+               (int)(TLS_CHAN_TO_BASE(chan)->state),
+               (int)(conn->link_proto));
+        return;
+      }
+      break;
+    default:
+      log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
+             "Received var-length cell with command %d in unexpected "
+             "orconn state \"%s\" [%d], channel state \"%s\" [%d]; "
+             "ignoring it.",
+             (int)(var_cell->command),
+             conn_state_to_string(CONN_TYPE_OR, TO_CONN(conn)->state),
+             (int)(TO_CONN(conn)->state),
+             channel_state_to_string(TLS_CHAN_TO_BASE(chan)->state),
+             (int)(TLS_CHAN_TO_BASE(chan)->state));
+      return;
+  }
+
+  /* Now handle the cell */
+
+  switch (var_cell->command) {
+    case CELL_VERSIONS:
+      ++stats_n_versions_cells_processed;
+      PROCESS_CELL(versions, var_cell, chan);
+      break;
+    case CELL_VPADDING:
+      ++stats_n_vpadding_cells_processed;
+      /* Do nothing */
+      break;
+    case CELL_CERTS:
+      ++stats_n_certs_cells_processed;
+      PROCESS_CELL(certs, var_cell, chan);
+      break;
+    case CELL_AUTH_CHALLENGE:
+      ++stats_n_auth_challenge_cells_processed;
+      PROCESS_CELL(auth_challenge, var_cell, chan);
+      break;
+    case CELL_AUTHENTICATE:
+      ++stats_n_authenticate_cells_processed;
+      PROCESS_CELL(authenticate, var_cell, chan);
+      break;
+    case CELL_AUTHORIZE:
+      ++stats_n_authorize_cells_processed;
+      /* Ignored so far. */
+      break;
+    default:
+      log_fn(LOG_INFO, LD_PROTOCOL,
+             "Variable-length cell of unknown type (%d) received.",
+             (int)(var_cell->command));
+      break;
+  }
+}
+
+/**
+ * Check if this cell type is allowed before the handshake is finished
+ *
+ * Return true if <b>command</b> is a cell command that's allowed to start a
+ * V3 handshake.
+ *
+ * @param command Cell type to check
+ */
+
+static int
+command_allowed_before_handshake(uint8_t command)
+{
+  switch (command) {
+    case CELL_VERSIONS:
+    case CELL_VPADDING:
+    case CELL_AUTHORIZE:
+      return 1;
+    default:
+      return 0;
+  }
+}
+
+/**
+ * Start a V3 handshake on an incoming connection
+ *
+ * Called when we as a server receive an appropriate cell while waiting
+ * either for a cell or a TLS handshake.  Set the connection's state to
+ * "handshaking_v3', initializes the or_handshake_state field as needed,
+ * and add the cell to the hash of incoming cells.)
+ *
+ * @param cell Incoming cell initiating the handshake
+ * @param chan Channel cell was received on
+ * @return 0 on success; return -1 and mark the connection on failure.
+ */
+
+static int
+enter_v3_handshake_with_cell(var_cell_t *cell, channel_tls_t *chan)
+{
+  int started_here = 0;
+
+  tor_assert(cell);
+  tor_assert(chan);
+  tor_assert(!(TLS_CHAN_TO_BASE(chan)->is_listener));
+  tor_assert(chan->conn);
+
+  started_here = connection_or_nonopen_was_started_here(chan->conn);
+
+  tor_assert(TO_CONN(chan->conn)->state == OR_CONN_STATE_TLS_HANDSHAKING ||
+             TO_CONN(chan->conn)->state ==
+               OR_CONN_STATE_TLS_SERVER_RENEGOTIATING);
+
+  if (started_here) {
+    log_fn(LOG_PROTOCOL_WARN, LD_OR,
+           "Received a cell while TLS-handshaking, not in "
+           "OR_HANDSHAKING_V3, on a connection we originated.");
+  }
+  chan->conn->_base.state = OR_CONN_STATE_OR_HANDSHAKING_V3;
+  if (connection_init_or_handshake_state(chan->conn, started_here) < 0) {
+    connection_or_close_for_error(chan->conn, 0);
+    return -1;
+  }
+  or_handshake_state_record_var_cell(chan->conn->handshake_state, cell, 1);
+  return 0;
+}
+
+/**
+ * Process a 'versions' cell.
+ *
+ * This function is called to handle an incoming VERSIONS cell; the current
+ * link protocol version must be 0 to indicate that no version has yet been
+ * negotiated.  We compare the versions in the cell to the list of versions
+ * we support, pick the highest version we have in common, and continue the
+ * negotiation from there.
+ *
+ * @param cell Incoming VERSIONS cell
+ * @param chan Channel that cell arrived on
+ */
+
+static void
+channel_tls_process_versions_cell(var_cell_t *cell, channel_tls_t *chan)
+{
+  int highest_supported_version = 0;
+  const uint8_t *cp, *end;
+  int started_here = 0;
+
+  tor_assert(cell);
+  tor_assert(chan);
+  tor_assert(!(TLS_CHAN_TO_BASE(chan)->is_listener));
+  tor_assert(chan->conn);
+
+  started_here = connection_or_nonopen_was_started_here(chan->conn);
+
+  if (chan->conn->link_proto != 0 ||
+      (chan->conn->handshake_state &&
+       chan->conn->handshake_state->received_versions)) {
+    log_fn(LOG_PROTOCOL_WARN, LD_OR,
+           "Received a VERSIONS cell on a connection with its version "
+           "already set to %d; dropping",
+           (int)(chan->conn->link_proto));
+    return;
+  }
+  switch (chan->conn->_base.state)
+    {
+    case OR_CONN_STATE_OR_HANDSHAKING_V2:
+    case OR_CONN_STATE_OR_HANDSHAKING_V3:
+      break;
+    case OR_CONN_STATE_TLS_HANDSHAKING:
+    case OR_CONN_STATE_TLS_SERVER_RENEGOTIATING:
+    default:
+      log_fn(LOG_PROTOCOL_WARN, LD_OR,
+             "VERSIONS cell while in unexpected state");
+      return;
+  }
+
+  tor_assert(chan->conn->handshake_state);
+  end = cell->payload + cell->payload_len;
+  for (cp = cell->payload; cp+1 < end; ++cp) {
+    uint16_t v = ntohs(get_uint16(cp));
+    if (is_or_protocol_version_known(v) && v > highest_supported_version)
+      highest_supported_version = v;
+  }
+  if (!highest_supported_version) {
+    log_fn(LOG_PROTOCOL_WARN, LD_OR,
+           "Couldn't find a version in common between my version list and the "
+           "list in the VERSIONS cell; closing connection.");
+    connection_or_close_for_error(chan->conn, 0);
+    return;
+  } else if (highest_supported_version == 1) {
+    /* Negotiating version 1 makes no sense, since version 1 has no VERSIONS
+     * cells. */
+    log_fn(LOG_PROTOCOL_WARN, LD_OR,
+           "Used version negotiation protocol to negotiate a v1 connection. "
+           "That's crazily non-compliant. Closing connection.");
+    connection_or_close_for_error(chan->conn, 0);
+    return;
+  } else if (highest_supported_version < 3 &&
+             chan->conn->_base.state ==  OR_CONN_STATE_OR_HANDSHAKING_V3) {
+    log_fn(LOG_PROTOCOL_WARN, LD_OR,
+           "Negotiated link protocol 2 or lower after doing a v3 TLS "
+           "handshake. Closing connection.");
+    connection_or_close_for_error(chan->conn, 0);
+    return;
+  }
+
+  chan->conn->link_proto = highest_supported_version;
+  chan->conn->handshake_state->received_versions = 1;
+
+  if (chan->conn->link_proto == 2) {
+    log_info(LD_OR,
+             "Negotiated version %d with %s:%d; sending NETINFO.",
+             highest_supported_version,
+             safe_str_client(chan->conn->_base.address),
+             chan->conn->_base.port);
+
+    if (connection_or_send_netinfo(chan->conn) < 0) {
+      connection_or_close_for_error(chan->conn, 0);
+      return;
+    }
+  } else {
+    const int send_versions = !started_here;
+    /* If we want to authenticate, send a CERTS cell */
+    const int send_certs = !started_here || public_server_mode(get_options());
+    /* If we're a relay that got a connection, ask for authentication. */
+    const int send_chall = !started_here && public_server_mode(get_options());
+    /* If our certs cell will authenticate us, we can send a netinfo cell
+     * right now. */
+    const int send_netinfo = !started_here;
+    const int send_any =
+      send_versions || send_certs || send_chall || send_netinfo;
+    tor_assert(chan->conn->link_proto >= 3);
+
+    log_info(LD_OR,
+             "Negotiated version %d with %s:%d; %s%s%s%s%s",
+             highest_supported_version,
+             safe_str_client(chan->conn->_base.address),
+             chan->conn->_base.port,
+             send_any ? "Sending cells:" : "Waiting for CERTS cell",
+             send_versions ? " VERSIONS" : "",
+             send_certs ? " CERTS" : "",
+             send_chall ? " AUTH_CHALLENGE" : "",
+             send_netinfo ? " NETINFO" : "");
+
+#ifdef DISABLE_V3_LINKPROTO_SERVERSIDE
+    if (1) {
+      connection_or_close_normally(chan->conn, 1);
+      return;
+    }
+#endif
+
+    if (send_versions) {
+      if (connection_or_send_versions(chan->conn, 1) < 0) {
+        log_warn(LD_OR, "Couldn't send versions cell");
+        connection_or_close_for_error(chan->conn, 0);
+        return;
+      }
+    }
+    if (send_certs) {
+      if (connection_or_send_certs_cell(chan->conn) < 0) {
+        log_warn(LD_OR, "Couldn't send certs cell");
+        connection_or_close_for_error(chan->conn, 0);
+        return;
+      }
+    }
+    if (send_chall) {
+      if (connection_or_send_auth_challenge_cell(chan->conn) < 0) {
+        log_warn(LD_OR, "Couldn't send auth_challenge cell");
+        connection_or_close_for_error(chan->conn, 0);
+        return;
+      }
+    }
+    if (send_netinfo) {
+      if (connection_or_send_netinfo(chan->conn) < 0) {
+        log_warn(LD_OR, "Couldn't send netinfo cell");
+        connection_or_close_for_error(chan->conn, 0);
+        return;
+      }
+    }
+  }
+}
+
+/**
+ * Process a 'netinfo' cell
+ *
+ * This function is called to handle an incoming NETINFO cell; read and act
+ * on its contents, and set the connection state to "open".
+ *
+ * @param cell Incoming NETINFO cell
+ * @param chan Channel that cell arrived on
+ */
+
+static void
+channel_tls_process_netinfo_cell(cell_t *cell, channel_tls_t *chan)
+{
+  time_t timestamp;
+  uint8_t my_addr_type;
+  uint8_t my_addr_len;
+  const uint8_t *my_addr_ptr;
+  const uint8_t *cp, *end;
+  uint8_t n_other_addrs;
+  time_t now = time(NULL);
+
+  long apparent_skew = 0;
+  tor_addr_t my_apparent_addr = TOR_ADDR_NULL;
+
+  tor_assert(cell);
+  tor_assert(chan);
+  tor_assert(!(TLS_CHAN_TO_BASE(chan)->is_listener));
+  tor_assert(chan->conn);
+
+  if (chan->conn->link_proto < 2) {
+    log_fn(LOG_PROTOCOL_WARN, LD_OR,
+           "Received a NETINFO cell on %s connection; dropping.",
+           chan->conn->link_proto == 0 ? "non-versioned" : "a v1");
+    return;
+  }
+  if (chan->conn->_base.state != OR_CONN_STATE_OR_HANDSHAKING_V2 &&
+      chan->conn->_base.state != OR_CONN_STATE_OR_HANDSHAKING_V3) {
+    log_fn(LOG_PROTOCOL_WARN, LD_OR,
+           "Received a NETINFO cell on non-handshaking connection; dropping.");
+    return;
+  }
+  tor_assert(chan->conn->handshake_state &&
+             chan->conn->handshake_state->received_versions);
+
+  if (chan->conn->_base.state == OR_CONN_STATE_OR_HANDSHAKING_V3) {
+    tor_assert(chan->conn->link_proto >= 3);
+    if (chan->conn->handshake_state->started_here) {
+      if (!(chan->conn->handshake_state->authenticated)) {
+        log_fn(LOG_PROTOCOL_WARN, LD_OR,
+               "Got a NETINFO cell from server, "
+               "but no authentication.  Closing the connection.");
+        connection_or_close_for_error(chan->conn, 0);
+        return;
+      }
+    } else {
+      /* we're the server.  If the client never authenticated, we have
+         some housekeeping to do.*/
+      if (!(chan->conn->handshake_state->authenticated)) {
+        tor_assert(tor_digest_is_zero(
+                  (const char*)(chan->conn->handshake_state->
+                      authenticated_peer_id)));
+        channel_set_circid_type(TLS_CHAN_TO_BASE(chan), NULL);
+
+        connection_or_init_conn_from_address(chan->conn,
+                  &(chan->conn->_base.addr),
+                  chan->conn->_base.port,
+                  (const char*)(chan->conn->handshake_state->
+                   authenticated_peer_id),
+                  0);
+      }
+    }
+  }
+
+  /* Decode the cell. */
+  timestamp = ntohl(get_uint32(cell->payload));
+  if (labs(now - chan->conn->handshake_state->sent_versions_at) < 180) {
+    apparent_skew = now - timestamp;
+  }
+
+  my_addr_type = (uint8_t) cell->payload[4];
+  my_addr_len = (uint8_t) cell->payload[5];
+  my_addr_ptr = (uint8_t*) cell->payload + 6;
+  end = cell->payload + CELL_PAYLOAD_SIZE;
+  cp = cell->payload + 6 + my_addr_len;
+  if (cp >= end) {
+    log_fn(LOG_PROTOCOL_WARN, LD_OR,
+           "Addresses too long in netinfo cell; closing connection.");
+    connection_or_close_for_error(chan->conn, 0);
+    return;
+  } else if (my_addr_type == RESOLVED_TYPE_IPV4 && my_addr_len == 4) {
+    tor_addr_from_ipv4n(&my_apparent_addr, get_uint32(my_addr_ptr));
+  } else if (my_addr_type == RESOLVED_TYPE_IPV6 && my_addr_len == 16) {
+    tor_addr_from_ipv6_bytes(&my_apparent_addr, (const char *) my_addr_ptr);
+  }
+
+  n_other_addrs = (uint8_t) *cp++;
+  while (n_other_addrs && cp < end-2) {
+    /* Consider all the other addresses; if any matches, this connection is
+     * "canonical." */
+    tor_addr_t addr;
+    const uint8_t *next =
+      decode_address_from_payload(&addr, cp, (int)(end-cp));
+    if (next == NULL) {
+      log_fn(LOG_PROTOCOL_WARN,  LD_OR,
+             "Bad address in netinfo cell; closing connection.");
+      connection_or_close_for_error(chan->conn, 0);
+      return;
+    }
+    if (tor_addr_eq(&addr, &(chan->conn->real_addr))) {
+      chan->conn->is_canonical = 1;
+      break;
+    }
+    cp = next;
+    --n_other_addrs;
+  }
+
+  /* Act on apparent skew. */
+  /** Warn when we get a netinfo skew with at least this value. */
+#define NETINFO_NOTICE_SKEW 3600
+  if (labs(apparent_skew) > NETINFO_NOTICE_SKEW &&
+      router_get_by_id_digest(chan->conn->identity_digest)) {
+    char dbuf[64];
+    int severity;
+    /*XXXX be smarter about when everybody says we are skewed. */
+    if (router_digest_is_trusted_dir(chan->conn->identity_digest))
+      severity = LOG_WARN;
+    else
+      severity = LOG_INFO;
+    format_time_interval(dbuf, sizeof(dbuf), apparent_skew);
+    log_fn(severity, LD_GENERAL,
+           "Received NETINFO cell with skewed time from "
+           "server at %s:%d.  It seems that our clock is %s by %s, or "
+           "that theirs is %s. Tor requires an accurate clock to work: "
+           "please check your time and date settings.",
+           chan->conn->_base.address,
+           (int)(chan->conn->_base.port),
+           apparent_skew > 0 ? "ahead" : "behind",
+           dbuf,
+           apparent_skew > 0 ? "behind" : "ahead");
+    if (severity == LOG_WARN) /* only tell the controller if an authority */
+      control_event_general_status(LOG_WARN,
+                          "CLOCK_SKEW SKEW=%ld SOURCE=OR:%s:%d",
+                          apparent_skew,
+                          chan->conn->_base.address,
+                          chan->conn->_base.port);
+  }
+
+  /* XXX maybe act on my_apparent_addr, if the source is sufficiently
+   * trustworthy. */
+
+  if (connection_or_set_state_open(chan->conn) < 0) {
+    log_fn(LOG_PROTOCOL_WARN, LD_OR,
+           "Got good NETINFO cell from %s:%d; but "
+           "was unable to make the OR connection become open.",
+           safe_str_client(chan->conn->_base.address),
+           chan->conn->_base.port);
+    connection_or_close_for_error(chan->conn, 0);
+  } else {
+    log_info(LD_OR,
+             "Got good NETINFO cell from %s:%d; OR connection is now "
+             "open, using protocol version %d. Its ID digest is %s. "
+             "Our address is apparently %s.",
+             safe_str_client(chan->conn->_base.address),
+             chan->conn->_base.port,
+             (int)(chan->conn->link_proto),
+             hex_str(TLS_CHAN_TO_BASE(chan)->u.cell_chan.identity_digest,
+                     DIGEST_LEN),
+             tor_addr_is_null(&my_apparent_addr) ?
+             "<none>" : fmt_and_decorate_addr(&my_apparent_addr));
+  }
+  assert_connection_ok(TO_CONN(chan->conn),time(NULL));
+}
+
+/**
+ * Process a CERTS cell from a channel.
+ *
+ * This function is called to process an incoming CERTS cell on a
+ * channel_tls_t:
+ *
+ * If the other side should not have sent us a CERTS cell, or the cell is
+ * malformed, or it is supposed to authenticate the TLS key but it doesn't,
+ * then mark the connection.
+ *
+ * If the cell has a good cert chain and we're doing a v3 handshake, then
+ * store the certificates in or_handshake_state.  If this is the client side
+ * of the connection, we then authenticate the server or mark the connection.
+ * If it's the server side, wait for an AUTHENTICATE cell.
+ *
+ * @param cell Incoming CERTS cell
+ * @param chan Channel that cell arrived on
+ */
+
+static void
+channel_tls_process_certs_cell(var_cell_t *cell, channel_tls_t *chan)
+{
+  tor_cert_t *link_cert = NULL;
+  tor_cert_t *id_cert = NULL;
+  tor_cert_t *auth_cert = NULL;
+  uint8_t *ptr;
+  int n_certs, i;
+  int send_netinfo = 0;
+
+  tor_assert(cell);
+  tor_assert(chan);
+  tor_assert(!(TLS_CHAN_TO_BASE(chan)->is_listener));
+  tor_assert(chan->conn);
+
+#define ERR(s)                                                  \
+  do {                                                          \
+    log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,                      \
+           "Received a bad CERTS cell from %s:%d: %s",          \
+           safe_str(chan->conn->_base.address),                 \
+           chan->conn->_base.port, (s));                        \
+    connection_or_close_for_error(chan->conn, 0);               \
+    return;                                                     \
+  } while (0)
+
+  if (chan->conn->_base.state != OR_CONN_STATE_OR_HANDSHAKING_V3)
+    ERR("We're not doing a v3 handshake!");
+  if (chan->conn->link_proto < 3)
+    ERR("We're not using link protocol >= 3");
+  if (chan->conn->handshake_state->received_certs_cell)
+    ERR("We already got one");
+  if (chan->conn->handshake_state->authenticated) {
+    /* Should be unreachable, but let's make sure. */
+    ERR("We're already authenticated!");
+  }
+  if (cell->payload_len < 1)
+    ERR("It had no body");
+  if (cell->circ_id)
+    ERR("It had a nonzero circuit ID");
+
+  n_certs = cell->payload[0];
+  ptr = cell->payload + 1;
+  for (i = 0; i < n_certs; ++i) {
+    uint8_t cert_type;
+    uint16_t cert_len;
+    if (ptr + 3 > cell->payload + cell->payload_len) {
+      goto truncated;
+    }
+    cert_type = *ptr;
+    cert_len = ntohs(get_uint16(ptr+1));
+    if (ptr + 3 + cert_len > cell->payload + cell->payload_len) {
+      goto truncated;
+    }
+    if (cert_type == OR_CERT_TYPE_TLS_LINK ||
+        cert_type == OR_CERT_TYPE_ID_1024 ||
+        cert_type == OR_CERT_TYPE_AUTH_1024) {
+      tor_cert_t *cert = tor_cert_decode(ptr + 3, cert_len);
+      if (!cert) {
+        log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
+               "Received undecodable certificate in CERTS cell from %s:%d",
+               safe_str(chan->conn->_base.address),
+               chan->conn->_base.port);
+      } else {
+        if (cert_type == OR_CERT_TYPE_TLS_LINK) {
+          if (link_cert) {
+            tor_cert_free(cert);
+            ERR("Too many TLS_LINK certificates");
+          }
+          link_cert = cert;
+        } else if (cert_type == OR_CERT_TYPE_ID_1024) {
+          if (id_cert) {
+            tor_cert_free(cert);
+            ERR("Too many ID_1024 certificates");
+          }
+          id_cert = cert;
+        } else if (cert_type == OR_CERT_TYPE_AUTH_1024) {
+          if (auth_cert) {
+            tor_cert_free(cert);
+            ERR("Too many AUTH_1024 certificates");
+          }
+          auth_cert = cert;
+        } else {
+          tor_cert_free(cert);
+        }
+      }
+    }
+    ptr += 3 + cert_len;
+    continue;
+
+  truncated:
+    ERR("It ends in the middle of a certificate");
+  }
+
+  if (chan->conn->handshake_state->started_here) {
+    int severity;
+    if (! (id_cert && link_cert))
+      ERR("The certs we wanted were missing");
+    /* Okay. We should be able to check the certificates now. */
+    if (! tor_tls_cert_matches_key(chan->conn->tls, link_cert)) {
+      ERR("The link certificate didn't match the TLS public key");
+    }
+    /* Note that this warns more loudly about time and validity if we were
+    * _trying_ to connect to an authority, not necessarily if we _did_ connect
+    * to one. */
+    if (router_digest_is_trusted_dir(
+          TLS_CHAN_TO_BASE(chan)->u.cell_chan.identity_digest))
+      severity = LOG_WARN;
+    else
+      severity = LOG_PROTOCOL_WARN;
+
+    if (! tor_tls_cert_is_valid(severity, link_cert, id_cert, 0))
+      ERR("The link certificate was not valid");
+    if (! tor_tls_cert_is_valid(severity, id_cert, id_cert, 1))
+      ERR("The ID certificate was not valid");
+
+    chan->conn->handshake_state->authenticated = 1;
+    {
+      const digests_t *id_digests = tor_cert_get_id_digests(id_cert);
+      crypto_pk_t *identity_rcvd;
+      if (!id_digests)
+        ERR("Couldn't compute digests for key in ID cert");
+
+      identity_rcvd = tor_tls_cert_get_key(id_cert);
+      if (!identity_rcvd)
+        ERR("Internal error: Couldn't get RSA key from ID cert.");
+      memcpy(chan->conn->handshake_state->authenticated_peer_id,
+             id_digests->d[DIGEST_SHA1], DIGEST_LEN);
+      channel_set_circid_type(TLS_CHAN_TO_BASE(chan), identity_rcvd);
+      crypto_pk_free(identity_rcvd);
+    }
+
+    if (connection_or_client_learned_peer_id(chan->conn,
+            chan->conn->handshake_state->authenticated_peer_id) < 0)
+      ERR("Problem setting or checking peer id");
+
+    log_info(LD_OR,
+             "Got some good certificates from %s:%d: Authenticated it.",
+             safe_str(chan->conn->_base.address), chan->conn->_base.port);
+
+    chan->conn->handshake_state->id_cert = id_cert;
+    id_cert = NULL;
+
+    if (!public_server_mode(get_options())) {
+      /* If we initiated the connection and we are not a public server, we
+       * aren't planning to authenticate at all.  At this point we know who we
+       * are talking to, so we can just send a netinfo now. */
+      send_netinfo = 1;
+    }
+  } else {
+    if (! (id_cert && auth_cert))
+      ERR("The certs we wanted were missing");
+
+    /* Remember these certificates so we can check an AUTHENTICATE cell */
+    if (! tor_tls_cert_is_valid(LOG_PROTOCOL_WARN, auth_cert, id_cert, 1))
+      ERR("The authentication certificate was not valid");
+    if (! tor_tls_cert_is_valid(LOG_PROTOCOL_WARN, id_cert, id_cert, 1))
+      ERR("The ID certificate was not valid");
+
+    log_info(LD_OR,
+             "Got some good certificates from %s:%d: "
+             "Waiting for AUTHENTICATE.",
+             safe_str(chan->conn->_base.address),
+             chan->conn->_base.port);
+    /* XXXX check more stuff? */
+
+    chan->conn->handshake_state->id_cert = id_cert;
+    chan->conn->handshake_state->auth_cert = auth_cert;
+    id_cert = auth_cert = NULL;
+  }
+
+  chan->conn->handshake_state->received_certs_cell = 1;
+
+  if (send_netinfo) {
+    if (connection_or_send_netinfo(chan->conn) < 0) {
+      log_warn(LD_OR, "Couldn't send netinfo cell");
+      connection_or_close_for_error(chan->conn, 0);
+      goto err;
+    }
+  }
+
+ err:
+  tor_cert_free(id_cert);
+  tor_cert_free(link_cert);
+  tor_cert_free(auth_cert);
+#undef ERR
+}
+
+/**
+ * Process an AUTH_CHALLENGE cell from a channel_tls_t
+ *
+ * This function is called to handle an incoming AUTH_CHALLENGE cell on a
+ * channel_tls_t; if we weren't supposed to get one (for example, because we're
+ * not the originator of the channel), or it's ill-formed, or we aren't doing
+ * a v3 handshake, mark the channel.  If the cell is well-formed but we don't
+ * want to authenticate, just drop it.  If the cell is well-formed *and* we
+ * want to authenticate, send an AUTHENTICATE cell and then a NETINFO cell.
+ *
+ * @param cell Incoming AUTH_CHALLENGE cell to handle
+ * @param chan Channel that cell arrived on
+ */
+
+static void
+channel_tls_process_auth_challenge_cell(var_cell_t *cell, channel_tls_t *chan)
+{
+  int n_types, i, use_type = -1;
+  uint8_t *cp;
+
+  tor_assert(cell);
+  tor_assert(chan);
+  tor_assert(!(TLS_CHAN_TO_BASE(chan)->is_listener));
+  tor_assert(chan->conn);
+
+#define ERR(s)                                                  \
+  do {                                                          \
+    log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,                      \
+           "Received a bad AUTH_CHALLENGE cell from %s:%d: %s", \
+           safe_str(chan->conn->_base.address),                 \
+           chan->conn->_base.port, (s));                        \
+    connection_or_close_for_error(chan->conn, 0);               \
+    return;                                                     \
+  } while (0)
+
+  if (chan->conn->_base.state != OR_CONN_STATE_OR_HANDSHAKING_V3)
+    ERR("We're not currently doing a v3 handshake");
+  if (chan->conn->link_proto < 3)
+    ERR("We're not using link protocol >= 3");
+  if (!(chan->conn->handshake_state->started_here))
+    ERR("We didn't originate this connection");
+  if (chan->conn->handshake_state->received_auth_challenge)
+    ERR("We already received one");
+  if (!(chan->conn->handshake_state->received_certs_cell))
+    ERR("We haven't gotten a CERTS cell yet");
+  if (cell->payload_len < OR_AUTH_CHALLENGE_LEN + 2)
+    ERR("It was too short");
+  if (cell->circ_id)
+    ERR("It had a nonzero circuit ID");
+
+  n_types = ntohs(get_uint16(cell->payload + OR_AUTH_CHALLENGE_LEN));
+  if (cell->payload_len < OR_AUTH_CHALLENGE_LEN + 2 + 2*n_types)
+    ERR("It looks truncated");
+
+  /* Now see if there is an authentication type we can use */
+  cp = cell->payload+OR_AUTH_CHALLENGE_LEN + 2;
+  for (i = 0; i < n_types; ++i, cp += 2) {
+    uint16_t authtype = ntohs(get_uint16(cp));
+    if (authtype == AUTHTYPE_RSA_SHA256_TLSSECRET)
+      use_type = authtype;
+  }
+
+  chan->conn->handshake_state->received_auth_challenge = 1;
+
+  if (! public_server_mode(get_options())) {
+    /* If we're not a public server then we don't want to authenticate on a
+       connection we originated, and we already sent a NETINFO cell when we
+       got the CERTS cell. We have nothing more to do. */
+    return;
+  }
+
+  if (use_type >= 0) {
+    log_info(LD_OR,
+             "Got an AUTH_CHALLENGE cell from %s:%d: Sending "
+             "authentication",
+             safe_str(chan->conn->_base.address),
+             chan->conn->_base.port);
+
+    if (connection_or_send_authenticate_cell(chan->conn, use_type) < 0) {
+      log_warn(LD_OR,
+               "Couldn't send authenticate cell");
+      connection_or_close_for_error(chan->conn, 0);
+      return;
+    }
+  } else {
+    log_info(LD_OR,
+             "Got an AUTH_CHALLENGE cell from %s:%d, but we don't "
+             "know any of its authentication types. Not authenticating.",
+             safe_str(chan->conn->_base.address),
+             chan->conn->_base.port);
+  }
+
+  if (connection_or_send_netinfo(chan->conn) < 0) {
+    log_warn(LD_OR, "Couldn't send netinfo cell");
+    connection_or_close_for_error(chan->conn, 0);
+    return;
+  }
+
+#undef ERR
+}
+
+/**
+ * Process an AUTHENTICATE cell from a channel_tls_t
+ *
+ * If it's ill-formed or we weren't supposed to get one or we're not doing a
+ * v3 handshake, then mark the connection.  If it does not authenticate the
+ * other side of the connection successfully (because it isn't signed right,
+ * we didn't get a CERTS cell, etc) mark the connection.  Otherwise, accept
+ * the identity of the router on the other side of the connection.
+ *
+ * @param cell Incoming AUTHENTICATE cell
+ * @param chan Channel that cell arrived on
+ */
+
+static void
+channel_tls_process_authenticate_cell(var_cell_t *cell, channel_tls_t *chan)
+{
+  uint8_t expected[V3_AUTH_FIXED_PART_LEN];
+  const uint8_t *auth;
+  int authlen;
+
+  tor_assert(cell);
+  tor_assert(chan);
+  tor_assert(!(TLS_CHAN_TO_BASE(chan)->is_listener));
+  tor_assert(chan->conn);
+
+#define ERR(s)                                                  \
+  do {                                                          \
+    log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,                      \
+           "Received a bad AUTHENTICATE cell from %s:%d: %s",   \
+           safe_str(chan->conn->_base.address),                 \
+           chan->conn->_base.port, (s));                        \
+    connection_or_close_for_error(chan->conn, 0);               \
+    return;                                                     \
+  } while (0)
+
+  if (chan->conn->_base.state != OR_CONN_STATE_OR_HANDSHAKING_V3)
+    ERR("We're not doing a v3 handshake");
+  if (chan->conn->link_proto < 3)
+    ERR("We're not using link protocol >= 3");
+  if (chan->conn->handshake_state->started_here)
+    ERR("We originated this connection");
+  if (chan->conn->handshake_state->received_authenticate)
+    ERR("We already got one!");
+  if (chan->conn->handshake_state->authenticated) {
+    /* Should be impossible given other checks */
+    ERR("The peer is already authenticated");
+  }
+  if (!(chan->conn->handshake_state->received_certs_cell))
+    ERR("We never got a certs cell");
+  if (chan->conn->handshake_state->auth_cert == NULL)
+    ERR("We never got an authentication certificate");
+  if (chan->conn->handshake_state->id_cert == NULL)
+    ERR("We never got an identity certificate");
+  if (cell->payload_len < 4)
+    ERR("Cell was way too short");
+
+  auth = cell->payload;
+  {
+    uint16_t type = ntohs(get_uint16(auth));
+    uint16_t len = ntohs(get_uint16(auth+2));
+    if (4 + len > cell->payload_len)
+      ERR("Authenticator was truncated");
+
+    if (type != AUTHTYPE_RSA_SHA256_TLSSECRET)
+      ERR("Authenticator type was not recognized");
+
+    auth += 4;
+    authlen = len;
+  }
+
+  if (authlen < V3_AUTH_BODY_LEN + 1)
+    ERR("Authenticator was too short");
+
+  if (connection_or_compute_authenticate_cell_body(
+                        chan->conn, expected, sizeof(expected), NULL, 1) < 0)
+    ERR("Couldn't compute expected AUTHENTICATE cell body");
+
+  if (tor_memneq(expected, auth, sizeof(expected)))
+    ERR("Some field in the AUTHENTICATE cell body was not as expected");
+
+  {
+    crypto_pk_t *pk = tor_tls_cert_get_key(
+                                   chan->conn->handshake_state->auth_cert);
+    char d[DIGEST256_LEN];
+    char *signed_data;
+    size_t keysize;
+    int signed_len;
+
+    if (!pk)
+      ERR("Internal error: couldn't get RSA key from AUTH cert.");
+    crypto_digest256(d, (char*)auth, V3_AUTH_BODY_LEN, DIGEST_SHA256);
+
+    keysize = crypto_pk_keysize(pk);
+    signed_data = tor_malloc(keysize);
+    signed_len = crypto_pk_public_checksig(pk, signed_data, keysize,
+                                           (char*)auth + V3_AUTH_BODY_LEN,
+                                           authlen - V3_AUTH_BODY_LEN);
+    crypto_pk_free(pk);
+    if (signed_len < 0) {
+      tor_free(signed_data);
+      ERR("Signature wasn't valid");
+    }
+    if (signed_len < DIGEST256_LEN) {
+      tor_free(signed_data);
+      ERR("Not enough data was signed");
+    }
+    /* Note that we deliberately allow *more* than DIGEST256_LEN bytes here,
+     * in case they're later used to hold a SHA3 digest or something. */
+    if (tor_memneq(signed_data, d, DIGEST256_LEN)) {
+      tor_free(signed_data);
+      ERR("Signature did not match data to be signed.");
+    }
+    tor_free(signed_data);
+  }
+
+  /* Okay, we are authenticated. */
+  chan->conn->handshake_state->received_authenticate = 1;
+  chan->conn->handshake_state->authenticated = 1;
+  chan->conn->handshake_state->digest_received_data = 0;
+  {
+    crypto_pk_t *identity_rcvd =
+      tor_tls_cert_get_key(chan->conn->handshake_state->id_cert);
+    const digests_t *id_digests =
+      tor_cert_get_id_digests(chan->conn->handshake_state->id_cert);
+
+    /* This must exist; we checked key type when reading the cert. */
+    tor_assert(id_digests);
+
+    memcpy(chan->conn->handshake_state->authenticated_peer_id,
+           id_digests->d[DIGEST_SHA1], DIGEST_LEN);
+
+    channel_set_circid_type(TLS_CHAN_TO_BASE(chan), identity_rcvd);
+    crypto_pk_free(identity_rcvd);
+
+    connection_or_init_conn_from_address(chan->conn,
+                  &(chan->conn->_base.addr),
+                  chan->conn->_base.port,
+                  (const char*)(chan->conn->handshake_state->
+                    authenticated_peer_id),
+                  0);
+
+    log_info(LD_OR,
+             "Got an AUTHENTICATE cell from %s:%d: Looks good.",
+             safe_str(chan->conn->_base.address),
+             chan->conn->_base.port);
+  }
+
+#undef ERR
+}
+
diff --git a/src/or/channeltls.h b/src/or/channeltls.h
new file mode 100644
index 000000000..3b7d6a7a1
--- /dev/null
+++ b/src/or/channeltls.h
@@ -0,0 +1,50 @@
+/* * Copyright (c) 2012, The Tor Project, Inc. */
+/* See LICENSE for licensing information */
+
+/**
+ * \file channeltls.h
+ * \brief Header file for channeltls.c
+ **/
+
+#ifndef _TOR_CHANNEL_TLS_H
+#define _TOR_CHANNEL_TLS_H
+
+#include "or.h"
+#include "channel.h"
+
+#define BASE_CHAN_TO_TLS(c) ((channel_tls_t *)(c))
+#define TLS_CHAN_TO_BASE(c) ((channel_t *)(c))
+
+#ifdef _TOR_CHANNEL_INTERNAL
+
+struct channel_tls_s {
+  /* Base channel_t struct */
+  channel_t _base;
+  /* or_connection_t pointer */
+  or_connection_t *conn;
+};
+
+#endif /* _TOR_CHANNEL_INTERNAL */
+
+channel_t * channel_tls_connect(const tor_addr_t *addr, uint16_t port,
+                                const char *id_digest);
+channel_t * channel_tls_get_listener(void);
+channel_t * channel_tls_start_listener(void);
+channel_t * channel_tls_handle_incoming(or_connection_t *orconn);
+
+/* Things for connection_or.c to call back into */
+ssize_t channel_tls_flush_some_cells(channel_tls_t *chan, ssize_t num_cells);
+int channel_tls_more_to_flush(channel_tls_t *chan);
+void channel_tls_handle_cell(cell_t *cell, or_connection_t *conn);
+void channel_tls_handle_state_change_on_orconn(channel_tls_t *chan,
+                                               or_connection_t *conn,
+                                               uint8_t old_state,
+                                               uint8_t state);
+void channel_tls_handle_var_cell(var_cell_t *var_cell,
+                                 or_connection_t *conn);
+
+/* Cleanup at shutdown */
+void channel_tls_free_all(void);
+
+#endif
+
diff --git a/src/or/connection.c b/src/or/connection.c
index d64c676bf..8e9c70191 100644
--- a/src/or/connection.c
+++ b/src/or/connection.c
@@ -12,6 +12,13 @@
 
 #include "or.h"
 #include "buffers.h"
+/*
+ * Define this so we get channel internal functions, since we're implementing
+ * part of a subclass (channel_tls_t).
+ */
+#define _TOR_CHANNEL_INTERNAL
+#include "channel.h"
+#include "channeltls.h"
 #include "circuitbuild.h"
 #include "circuitlist.h"
 #include "circuituse.h"
@@ -257,7 +264,6 @@ or_connection_new(int socket_family)
   connection_init(now, TO_CONN(or_conn), CONN_TYPE_OR, socket_family);
 
   or_conn->timestamp_last_added_nonpadding = time(NULL);
-  or_conn->next_circ_id = crypto_rand_int(1<<15);
 
   or_conn->active_circuit_pqueue = smartlist_new();
   or_conn->active_circuit_pqueue_last_recalibrated = cell_ewma_get_tick();
@@ -693,6 +699,16 @@ _connection_mark_for_close(connection_t *conn, int line, const char *file)
     return;
   }
 
+  if (conn->type == CONN_TYPE_OR) {
+    /*
+     * Bad news if this happens without telling the controlling channel; do
+     * this so we can find things that call this wrongly when the asserts hit.
+     */
+    log_debug(LD_CHANNEL,
+              "Calling connection_mark_for_close on an OR conn at %s:%d",
+              file, line);
+  }
+
   conn->marked_for_close = line;
   conn->marked_for_close_file = file;
   add_connection_to_closeable_list(conn);
@@ -1281,12 +1297,19 @@ static int
 connection_init_accepted_conn(connection_t *conn,
                               const listener_connection_t *listener)
 {
+  int rv;
+
   connection_start_reading(conn);
 
   switch (conn->type) {
     case CONN_TYPE_OR:
       control_event_or_conn_status(TO_OR_CONN(conn), OR_CONN_EVENT_NEW, 0);
-      return connection_tls_start_handshake(TO_OR_CONN(conn), 1);
+      rv = connection_tls_start_handshake(TO_OR_CONN(conn), 1);
+      if (rv < 0) {
+        connection_or_close_for_error(TO_OR_CONN(conn), 0);
+      }
+      return rv;
+      break;
     case CONN_TYPE_AP:
       TO_ENTRY_CONN(conn)->isolation_flags = listener->isolation_flags;
       TO_ENTRY_CONN(conn)->session_group = listener->session_group;
@@ -2091,7 +2114,8 @@ static int
 connection_counts_as_relayed_traffic(connection_t *conn, time_t now)
 {
   if (conn->type == CONN_TYPE_OR &&
-      TO_OR_CONN(conn)->client_used + CLIENT_IDLE_TIME_FOR_PRIORITY < now)
+      connection_or_client_used(TO_OR_CONN(conn)) +
+                                CLIENT_IDLE_TIME_FOR_PRIORITY < now)
     return 1;
   if (conn->type == CONN_TYPE_DIR && DIR_CONN_IS_SERVER(conn))
     return 1;
@@ -2688,11 +2712,14 @@ connection_handle_read_impl(connection_t *conn)
   before = buf_datalen(conn->inbuf);
   if (connection_read_to_buf(conn, &max_to_read, &socket_error) < 0) {
     /* There's a read error; kill the connection.*/
-    if (conn->type == CONN_TYPE_OR &&
-        conn->state == OR_CONN_STATE_CONNECTING) {
-      connection_or_connect_failed(TO_OR_CONN(conn),
-                                   errno_to_orconn_end_reason(socket_error),
-                                   tor_socket_strerror(socket_error));
+    if (conn->type == CONN_TYPE_OR) {
+      connection_or_notify_error(TO_OR_CONN(conn),
+                                 socket_error != 0 ?
+                                   errno_to_orconn_end_reason(socket_error) :
+                                   END_OR_CONN_REASON_CONNRESET,
+                                 socket_error != 0 ?
+                                   tor_socket_strerror(socket_error) :
+                                   "(unknown, errno was 0)");
     }
     if (CONN_IS_EDGE(conn)) {
       edge_connection_t *edge_conn = TO_EDGE_CONN(conn);
@@ -3214,9 +3241,9 @@ connection_handle_write_impl(connection_t *conn, int force)
         if (CONN_IS_EDGE(conn))
           connection_edge_end_errno(TO_EDGE_CONN(conn));
         if (conn->type == CONN_TYPE_OR)
-          connection_or_connect_failed(TO_OR_CONN(conn),
-                                       errno_to_orconn_end_reason(e),
-                                       tor_socket_strerror(e));
+          connection_or_notify_error(TO_OR_CONN(conn),
+                                     errno_to_orconn_end_reason(e),
+                                     tor_socket_strerror(e));
 
         connection_close_immediate(conn);
         connection_mark_for_close(conn);
@@ -3241,6 +3268,10 @@ connection_handle_write_impl(connection_t *conn, int force)
       connection_stop_writing(conn);
       if (connection_tls_continue_handshake(or_conn) < 0) {
         /* Don't flush; connection is dead. */
+        connection_or_notify_error(or_conn,
+                                   END_OR_CONN_REASON_MISC,
+                                   "TLS error in connection_tls_"
+                                   "continue_handshake()");
         connection_close_immediate(conn);
         connection_mark_for_close(conn);
         return -1;
@@ -3254,19 +3285,23 @@ connection_handle_write_impl(connection_t *conn, int force)
     result = flush_buf_tls(or_conn->tls, conn->outbuf,
                            max_to_write, &conn->outbuf_flushlen);
 
-    /* If we just flushed the last bytes, check if this tunneled dir
-     * request is done. */
+    /* If we just flushed the last bytes, tell the channel on the
+     * or_conn to check if it needs to geoip_change_dirreq_state() */
     /* XXXX move this to flushed_some or finished_flushing -NM */
-    if (buf_datalen(conn->outbuf) == 0 && conn->dirreq_id)
-      geoip_change_dirreq_state(conn->dirreq_id, DIRREQ_TUNNELED,
-                                DIRREQ_OR_CONN_BUFFER_FLUSHED);
+    if (buf_datalen(conn->outbuf) == 0 && or_conn->chan)
+      channel_notify_flushed(TLS_CHAN_TO_BASE(or_conn->chan));
 
     switch (result) {
       CASE_TOR_TLS_ERROR_ANY:
       case TOR_TLS_CLOSE:
-        log_info(LD_NET,result!=TOR_TLS_CLOSE?
+        log_info(LD_NET, result != TOR_TLS_CLOSE ?
                  "tls error. breaking.":"TLS connection closed on flush");
         /* Don't flush; connection is dead. */
+        connection_or_notify_error(or_conn,
+                                   END_OR_CONN_REASON_MISC,
+                                   result != TOR_TLS_CLOSE ?
+                                     "TLS error in during flush" :
+                                     "TLS closed during flush");
         connection_close_immediate(conn);
         connection_mark_for_close(conn);
         return -1;
@@ -3325,8 +3360,16 @@ connection_handle_write_impl(connection_t *conn, int force)
   if (result > 0) {
     /* If we wrote any bytes from our buffer, then call the appropriate
      * functions. */
-    if (connection_flushed_some(conn) < 0)
+    if (connection_flushed_some(conn) < 0) {
+      if (connection_speaks_cells(conn)) {
+        connection_or_notify_error(TO_OR_CONN(conn),
+                                   END_OR_CONN_REASON_MISC,
+                                   "Got error back from "
+                                   "connection_flushed_some()");
+      }
+
       connection_mark_for_close(conn);
+    }
   }
 
   if (!connection_wants_to_flush(conn)) { /* it's done flushing */
@@ -4125,7 +4168,6 @@ assert_connection_ok(connection_t *conn, time_t now)
     case CONN_TYPE_OR:
       tor_assert(conn->state >= _OR_CONN_STATE_MIN);
       tor_assert(conn->state <= _OR_CONN_STATE_MAX);
-      tor_assert(TO_OR_CONN(conn)->n_circuits >= 0);
       break;
     case CONN_TYPE_EXIT:
       tor_assert(conn->state >= _EXIT_CONN_STATE_MIN);
diff --git a/src/or/connection_or.c b/src/or/connection_or.c
index dbd875766..a3df7759e 100644
--- a/src/or/connection_or.c
+++ b/src/or/connection_or.c
@@ -12,6 +12,13 @@
 
 #include "or.h"
 #include "buffers.h"
+/*
+ * Define this so we get channel internal functions, since we're implementing
+ * part of a subclass (channel_tls_t).
+ */
+#define _TOR_CHANNEL_INTERNAL
+#include "channel.h"
+#include "channeltls.h"
 #include "circuitbuild.h"
 #include "circuitlist.h"
 #include "command.h"
@@ -43,6 +50,17 @@ static int connection_or_check_valid_tls_handshake(or_connection_t *conn,
 
 static void connection_or_tls_renegotiated_cb(tor_tls_t *tls, void *_conn);
 
+static unsigned int
+connection_or_is_bad_for_new_circs(or_connection_t *or_conn);
+static void connection_or_mark_bad_for_new_circs(or_connection_t *or_conn);
+
+/*
+ * Call this when changing connection state, so notifications to the owning
+ * channel can be handled.
+ */
+
+static void connection_or_change_state(or_connection_t *conn, uint8_t state);
+
 #ifdef USE_BUFFEREVENTS
 static void connection_or_handle_event_cb(struct bufferevent *bufev,
                                           short event, void *arg);
@@ -127,8 +145,11 @@ connection_or_set_identity_digest(or_connection_t *conn, const char *digest)
     return;
 
   /* If the identity was set previously, remove the old mapping. */
-  if (! tor_digest_is_zero(conn->identity_digest))
+  if (! tor_digest_is_zero(conn->identity_digest)) {
     connection_or_remove_from_identity_map(conn);
+    if (conn->chan)
+      channel_clear_identity_digest(TLS_CHAN_TO_BASE(conn->chan));
+  }
 
   memcpy(conn->identity_digest, digest, DIGEST_LEN);
 
@@ -139,6 +160,10 @@ connection_or_set_identity_digest(or_connection_t *conn, const char *digest)
   tmp = digestmap_set(orconn_identity_map, digest, conn);
   conn->next_with_same_id = tmp;
 
+  /* Deal with channels */
+  if (conn->chan)
+    channel_set_identity_digest(TLS_CHAN_TO_BASE(conn->chan), digest);
+
 #if 1
   /* Testing code to check for bugs in representation. */
   for (; tmp; tmp = tmp->next_with_same_id) {
@@ -282,6 +307,40 @@ connection_or_report_broken_states(int severity, int domain)
   smartlist_free(items);
 }
 
+/** Call this to change or_connection_t states, so the owning channel_tls_t can
+ * be notified.
+ */
+
+static void
+connection_or_change_state(or_connection_t *conn, uint8_t state)
+{
+  uint8_t old_state;
+
+  tor_assert(conn);
+
+  old_state = conn->_base.state;
+  conn->_base.state = state;
+
+  if (conn->chan)
+    channel_tls_handle_state_change_on_orconn(conn->chan, conn,
+                                              old_state, state);
+}
+
+/** Return the number of circuits using an or_connection_t; this used to
+ * be an or_connection_t field, but it got moved to channel_t and we
+ * shouldn't maintain two copies. */
+
+int
+connection_or_get_num_circuits(or_connection_t *conn)
+{
+  tor_assert(conn);
+
+  if (conn->chan) {
+    tor_assert(!(TLS_CHAN_TO_BASE(conn->chan)->is_listener));
+    return TLS_CHAN_TO_BASE(conn->chan)->u.cell_chan.n_circuits;
+  } else return 0;
+}
+
 /**************************************************************/
 
 /** Pack the cell_t host-order structure <b>src</b> into network-order
@@ -345,8 +404,11 @@ var_cell_free(var_cell_t *cell)
 int
 connection_or_reached_eof(or_connection_t *conn)
 {
+  tor_assert(conn);
+
   log_info(LD_OR,"OR connection reached EOF. Closing.");
-  connection_mark_for_close(TO_CONN(conn));
+  connection_or_close_normally(conn, 1);
+
   return 0;
 }
 
@@ -375,9 +437,12 @@ connection_or_process_inbuf(or_connection_t *conn)
         tor_assert(TO_CONN(conn)->proxy_state == PROXY_CONNECTED);
         if (connection_tls_start_handshake(conn, 0) < 0)
           ret = -1;
+        /* Touch the channel's active timestamp if there is one */
+        if (conn->chan)
+          channel_timestamp_active(TLS_CHAN_TO_BASE(conn->chan));
       }
       if (ret < 0) {
-        connection_mark_for_close(TO_CONN(conn));
+        connection_or_close_for_error(conn, 0);
       }
 
       return ret;
@@ -410,7 +475,7 @@ connection_or_process_inbuf(or_connection_t *conn)
            connection_or_nonopen_was_started_here(conn) ? "to" : "from",
            conn->_base.address, conn->_base.port,
            conn_state_to_string(conn->_base.type, conn->_base.state));
-    connection_mark_for_close(TO_CONN(conn));
+    connection_or_close_for_error(conn, 0);
     ret = -1;
   }
 
@@ -430,18 +495,31 @@ connection_or_process_inbuf(or_connection_t *conn)
 int
 connection_or_flushed_some(or_connection_t *conn)
 {
-  size_t datalen = connection_get_outbuf_len(TO_CONN(conn));
+  size_t datalen, temp;
+  ssize_t n, flushed;
+
   /* If we're under the low water mark, add cells until we're just over the
    * high water mark. */
+  datalen = connection_get_outbuf_len(TO_CONN(conn));
   if (datalen < OR_CONN_LOWWATER) {
-    ssize_t n = CEIL_DIV(OR_CONN_HIGHWATER - datalen, CELL_NETWORK_SIZE);
-    time_t now = approx_time();
-    while (conn->active_circuits && n > 0) {
-      int flushed;
-      flushed = connection_or_flush_from_first_active_circuit(conn, 1, now);
-      n -= flushed;
+    while ((conn->chan) && channel_tls_more_to_flush(conn->chan)) {
+      /* Compute how many more cells we want at most */
+      n = CEIL_DIV(OR_CONN_HIGHWATER - datalen, CELL_NETWORK_SIZE);
+      /* Bail out if we don't want any more */
+      if (n <= 0) break;
+      /* We're still here; try to flush some more cells */
+      flushed = channel_tls_flush_some_cells(conn->chan, n);
+      /* Bail out if it says it didn't flush anything */
+      if (flushed <= 0) break;
+      /* How much in the outbuf now? */
+      temp = connection_get_outbuf_len(TO_CONN(conn));
+      /* Bail out if we didn't actually increase the outbuf size */
+      if (temp <= datalen) break;
+      /* Update datalen for the next iteration */
+      datalen = temp;
     }
   }
+
   return 0;
 }
 
@@ -480,6 +558,7 @@ connection_or_finished_connecting(or_connection_t *or_conn)
 {
   const int proxy_type = or_conn->proxy_type;
   connection_t *conn;
+
   tor_assert(or_conn);
   conn = TO_CONN(or_conn);
   tor_assert(conn->state == OR_CONN_STATE_CONNECTING);
@@ -491,18 +570,18 @@ connection_or_finished_connecting(or_connection_t *or_conn)
   if (proxy_type != PROXY_NONE) {
     /* start proxy handshake */
     if (connection_proxy_connect(conn, proxy_type) < 0) {
-      connection_mark_for_close(conn);
+      connection_or_close_for_error(or_conn, 0);
       return -1;
     }
 
     connection_start_reading(conn);
-    conn->state = OR_CONN_STATE_PROXY_HANDSHAKING;
+    connection_or_change_state(or_conn, OR_CONN_STATE_PROXY_HANDSHAKING);
     return 0;
   }
 
   if (connection_tls_start_handshake(or_conn, 0) < 0) {
     /* TLS handshaking error of some kind. */
-    connection_mark_for_close(conn);
+    connection_or_close_for_error(or_conn, 0);
     return -1;
   }
   return 0;
@@ -516,11 +595,14 @@ connection_or_about_to_close(or_connection_t *or_conn)
   time_t now = time(NULL);
   connection_t *conn = TO_CONN(or_conn);
 
+  /* Tell the controlling channel we're closed */
+  if (or_conn->chan) {
+    channel_closed(TLS_CHAN_TO_BASE(or_conn->chan));
+    or_conn->chan = NULL;
+  }
+
   /* Remember why we're closing this connection. */
   if (conn->state != OR_CONN_STATE_OPEN) {
-    /* Inform any pending (not attached) circs that they should
-     * give up. */
-    circuit_n_conn_done(TO_OR_CONN(conn), 0);
     /* now mark things down as needed */
     if (connection_or_nonopen_was_started_here(or_conn)) {
       const or_options_t *options = get_options();
@@ -548,9 +630,6 @@ connection_or_about_to_close(or_connection_t *or_conn)
     control_event_or_conn_status(or_conn, OR_CONN_EVENT_CLOSED,
                 tls_error_to_orconn_end_reason(or_conn->tls_error));
   }
-  /* Now close all the attached circuits on it. */
-  circuit_unlink_all_from_or_conn(TO_OR_CONN(conn),
-                                  END_CIRC_REASON_OR_CONN_CLOSED);
 }
 
 /** Return 1 if identity digest <b>id_digest</b> is known to be a
@@ -708,152 +787,26 @@ connection_or_init_conn_from_address(or_connection_t *conn,
   }
 }
 
-/** Return true iff <b>a</b> is "better" than <b>b</b> for new circuits.
- *
- * A more canonical connection is always better than a less canonical
- * connection.  That aside, a connection is better if it has circuits and the
- * other does not, or if it was created more recently.
- *
- * Requires that both input connections are open; not is_bad_for_new_circs,
- * and not impossibly non-canonical.
- *
- * If <b>forgive_new_connections</b> is true, then we do not call
- * <b>a</b>better than <b>b</b> simply because b has no circuits,
- * unless b is also relatively old.
- */
-static int
-connection_or_is_better(time_t now,
-                        const or_connection_t *a,
-                        const or_connection_t *b,
-                        int forgive_new_connections)
-{
-  int newer;
-/** Do not definitively deprecate a new connection with no circuits on it
- * until this much time has passed. */
-#define NEW_CONN_GRACE_PERIOD (15*60)
-
-  if (b->is_canonical && !a->is_canonical)
-    return 0; /* A canonical connection is better than a non-canonical
-               * one, no matter how new it is or which has circuits. */
-
-  newer = b->_base.timestamp_created < a->_base.timestamp_created;
-
-  if (
-      /* We prefer canonical connections regardless of newness. */
-      (!b->is_canonical && a->is_canonical) ||
-      /* If both have circuits we prefer the newer: */
-      (b->n_circuits && a->n_circuits && newer) ||
-      /* If neither has circuits we prefer the newer: */
-      (!b->n_circuits && !a->n_circuits && newer))
-    return 1;
+/** These just pass all the is_bad_for_new_circs manipulation on to
+ * channel_t */
 
-  /* If one has no circuits and the other does... */
-  if (!b->n_circuits && a->n_circuits) {
-    /* Then it's bad, unless it's in its grace period and we're forgiving. */
-    if (forgive_new_connections &&
-        now < b->_base.timestamp_created + NEW_CONN_GRACE_PERIOD)
-      return 0;
-    else
-      return 1;
-  }
+static unsigned int
+connection_or_is_bad_for_new_circs(or_connection_t *or_conn)
+{
+  tor_assert(or_conn);
 
-  return 0;
+  if (or_conn->chan)
+    return channel_is_bad_for_new_circs(TLS_CHAN_TO_BASE(or_conn->chan));
+  else return 0;
 }
 
-/** Return the OR connection we should use to extend a circuit to the router
- * whose identity is <b>digest</b>, and whose address we believe (or have been
- * told in an extend cell) is <b>target_addr</b>.  If there is no good
- * connection, set *<b>msg_out</b> to a message describing the connection's
- * state and our next action, and set <b>launch_out</b> to a boolean for
- * whether we should launch a new connection or not.
- */
-or_connection_t *
-connection_or_get_for_extend(const char *digest,
-                             const tor_addr_t *target_addr,
-                             const char **msg_out,
-                             int *launch_out)
+static void
+connection_or_mark_bad_for_new_circs(or_connection_t *or_conn)
 {
-  or_connection_t *conn, *best=NULL;
-  int n_inprogress_goodaddr = 0, n_old = 0, n_noncanonical = 0, n_possible = 0;
-  time_t now = approx_time();
-
-  tor_assert(msg_out);
-  tor_assert(launch_out);
-
-  if (!orconn_identity_map) {
-    *msg_out = "Router not connected (nothing is).  Connecting.";
-    *launch_out = 1;
-    return NULL;
-  }
-
-  conn = digestmap_get(orconn_identity_map, digest);
-
-  for (; conn; conn = conn->next_with_same_id) {
-    tor_assert(conn->_base.magic == OR_CONNECTION_MAGIC);
-    tor_assert(conn->_base.type == CONN_TYPE_OR);
-    tor_assert(tor_memeq(conn->identity_digest, digest, DIGEST_LEN));
-    if (conn->_base.marked_for_close)
-      continue;
-    /* Never return a connection on which the other end appears to be
-     * a client. */
-    if (conn->is_connection_with_client) {
-      continue;
-    }
-    /* Never return a non-open connection. */
-    if (conn->_base.state != OR_CONN_STATE_OPEN) {
-      /* If the address matches, don't launch a new connection for this
-       * circuit. */
-      if (!tor_addr_compare(&conn->real_addr, target_addr, CMP_EXACT))
-        ++n_inprogress_goodaddr;
-      continue;
-    }
-    /* Never return a connection that shouldn't be used for circs. */
-    if (conn->is_bad_for_new_circs) {
-      ++n_old;
-      continue;
-    }
-    /* Never return a non-canonical connection using a recent link protocol
-     * if the address is not what we wanted.
-     *
-     * (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 (!conn->is_canonical && conn->link_proto >= 2 &&
-        tor_addr_compare(&conn->real_addr, target_addr, CMP_EXACT)) {
-      ++n_noncanonical;
-      continue;
-    }
-
-    ++n_possible;
-
-    if (!best) {
-      best = conn; /* If we have no 'best' so far, this one is good enough. */
-      continue;
-    }
-
-    if (connection_or_is_better(now, conn, best, 0))
-      best = conn;
-  }
+  tor_assert(or_conn);
 
-  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;
-  }
+  if (or_conn->chan)
+    channel_mark_bad_for_new_circs(TLS_CHAN_TO_BASE(or_conn->chan));
 }
 
 /** How old do we let a connection to an OR get before deciding it's
@@ -874,8 +827,8 @@ connection_or_get_for_extend(const char *digest,
  *    - all open non-canonical connections for which a 'better' non-canonical
  *      connection exists to the same router at the same address.
  *
- * See connection_or_is_better() for our idea of what makes one OR connection
- * better than another.
+ * See channel_is_better() in channel.c for our idea of what makes one OR
+ * connection better than another.
  */
 static void
 connection_or_group_set_badness(or_connection_t *head, int force)
@@ -888,7 +841,7 @@ connection_or_group_set_badness(or_connection_t *head, int force)
    * everything else is. */
   for (or_conn = head; or_conn; or_conn = or_conn->next_with_same_id) {
     if (or_conn->_base.marked_for_close ||
-        or_conn->is_bad_for_new_circs)
+        connection_or_is_bad_for_new_circs(or_conn))
       continue;
     if (force ||
         or_conn->_base.timestamp_created + TIME_BEFORE_OR_CONN_IS_TOO_OLD
@@ -898,10 +851,10 @@ connection_or_group_set_badness(or_connection_t *head, int force)
                "(fd %d, %d secs old).",
                or_conn->_base.address, or_conn->_base.port, or_conn->_base.s,
                (int)(now - or_conn->_base.timestamp_created));
-      or_conn->is_bad_for_new_circs = 1;
+      connection_or_mark_bad_for_new_circs(or_conn);
     }
 
-    if (or_conn->is_bad_for_new_circs) {
+    if (connection_or_is_bad_for_new_circs(or_conn)) {
       ++n_old;
     } else if (or_conn->_base.state != OR_CONN_STATE_OPEN) {
       ++n_inprogress;
@@ -916,7 +869,7 @@ connection_or_group_set_badness(or_connection_t *head, int force)
    * expire everything that's worse, and find the very best if we can. */
   for (or_conn = head; or_conn; or_conn = or_conn->next_with_same_id) {
     if (or_conn->_base.marked_for_close ||
-        or_conn->is_bad_for_new_circs)
+        connection_or_is_bad_for_new_circs(or_conn))
       continue; /* This one doesn't need to be marked bad. */
     if (or_conn->_base.state != OR_CONN_STATE_OPEN)
       continue; /* Don't mark anything bad until we have seen what happens
@@ -930,12 +883,17 @@ connection_or_group_set_badness(or_connection_t *head, int force)
                "another connection to that OR that is.",
                or_conn->_base.address, or_conn->_base.port, or_conn->_base.s,
                (int)(now - or_conn->_base.timestamp_created));
-      or_conn->is_bad_for_new_circs = 1;
+      connection_or_mark_bad_for_new_circs(or_conn);
       continue;
     }
 
-    if (!best || connection_or_is_better(now, or_conn, best, 0))
+    if (!best ||
+        channel_is_better(now,
+                          TLS_CHAN_TO_BASE(or_conn->chan),
+                          TLS_CHAN_TO_BASE(best->chan),
+                          0)) {
       best = or_conn;
+    }
   }
 
   if (!best)
@@ -957,10 +915,13 @@ connection_or_group_set_badness(or_connection_t *head, int force)
    */
   for (or_conn = head; or_conn; or_conn = or_conn->next_with_same_id) {
     if (or_conn->_base.marked_for_close ||
-        or_conn->is_bad_for_new_circs ||
+        connection_or_is_bad_for_new_circs(or_conn) ||
         or_conn->_base.state != OR_CONN_STATE_OPEN)
       continue;
-    if (or_conn != best && connection_or_is_better(now, best, or_conn, 1)) {
+    if (or_conn != best &&
+        channel_is_better(now,
+                          TLS_CHAN_TO_BASE(best->chan),
+                          TLS_CHAN_TO_BASE(or_conn->chan), 1)) {
       /* This isn't the best conn, _and_ the best conn is better than it,
          even when we're being forgiving. */
       if (best->is_canonical) {
@@ -971,7 +932,7 @@ connection_or_group_set_badness(or_connection_t *head, int force)
                  or_conn->_base.address, or_conn->_base.port, or_conn->_base.s,
                  (int)(now - or_conn->_base.timestamp_created),
                  best->_base.s, (int)(now - best->_base.timestamp_created));
-        or_conn->is_bad_for_new_circs = 1;
+        connection_or_mark_bad_for_new_circs(or_conn);
       } else if (!tor_addr_compare(&or_conn->real_addr,
                                    &best->real_addr, CMP_EXACT)) {
         log_info(LD_OR,
@@ -981,7 +942,7 @@ connection_or_group_set_badness(or_connection_t *head, int force)
                  or_conn->_base.address, or_conn->_base.port, or_conn->_base.s,
                  (int)(now - or_conn->_base.timestamp_created),
                  best->_base.s, (int)(now - best->_base.timestamp_created));
-        or_conn->is_bad_for_new_circs = 1;
+        connection_or_mark_bad_for_new_circs(or_conn);
       }
     }
   }
@@ -1019,8 +980,43 @@ connection_or_connect_failed(or_connection_t *conn,
     control_event_bootstrap_problem(msg, reason);
 }
 
+/** <b>conn</b> got an error in connection_handle_read_impl() or
+ * connection_handle_write_impl() and is going to die soon.
+ *
+ * <b>reason</b> specifies the or_conn_end_reason for the failure;
+ * <b>msg</b> specifies the strerror-style error message.
+ */
+void
+connection_or_notify_error(or_connection_t *conn,
+                           int reason, const char *msg)
+{
+  channel_t *chan;
+
+  tor_assert(conn);
+
+  /* If we're connecting, call connect_failed() too */
+  if (TO_CONN(conn)->state == OR_CONN_STATE_CONNECTING)
+    connection_or_connect_failed(conn, reason, msg);
+
+  /* Tell the controlling channel if we have one */
+  if (conn->chan) {
+    chan = TLS_CHAN_TO_BASE(conn->chan);
+    /* This shouldn't ever happen in the listening state */
+    tor_assert(chan->state != CHANNEL_STATE_LISTENING);
+    /* Don't transition if we're already in closing, closed or error */
+    if (!(chan->state == CHANNEL_STATE_CLOSING ||
+          chan->state == CHANNEL_STATE_CLOSED ||
+          chan->state == CHANNEL_STATE_ERROR)) {
+      channel_close_for_error(chan);
+    }
+  }
+
+  /* No need to mark for error because connection.c is about to do that */
+}
+
 /** Launch a new OR connection to <b>addr</b>:<b>port</b> and expect to
- * handshake with an OR with identity digest <b>id_digest</b>.
+ * handshake with an OR with identity digest <b>id_digest</b>.  Optionally,
+ * pass in a pointer to a channel using this connection.
  *
  * If <b>id_digest</b> is me, do nothing. If we're already connected to it,
  * return that connection. If the connect() is in progress, set the
@@ -1035,7 +1031,8 @@ connection_or_connect_failed(or_connection_t *conn,
  */
 or_connection_t *
 connection_or_connect(const tor_addr_t *_addr, uint16_t port,
-                      const char *id_digest)
+                      const char *id_digest,
+                      channel_tls_t *chan)
 {
   or_connection_t *conn;
   const or_options_t *options = get_options();
@@ -1058,9 +1055,17 @@ connection_or_connect(const tor_addr_t *_addr, uint16_t port,
 
   conn = or_connection_new(tor_addr_family(&addr));
 
-  /* set up conn so it's got all the data we need to remember */
+  /*
+   * Set up conn so it's got all the data we need to remember for channels
+   *
+   * This stuff needs to happen before connection_or_init_conn_from_address()
+   * so connection_or_set_identity_digest() and such know where to look to
+   * keep the channel up to date.
+   */
+  conn->chan = chan;
+  chan->conn = conn;
   connection_or_init_conn_from_address(conn, &addr, port, id_digest, 1);
-  conn->_base.state = OR_CONN_STATE_CONNECTING;
+  connection_or_change_state(conn, OR_CONN_STATE_CONNECTING);
   control_event_or_conn_status(conn, OR_CONN_EVENT_LAUNCHED, 0);
 
   conn->is_outgoing = 1;
@@ -1129,6 +1134,56 @@ connection_or_connect(const tor_addr_t *_addr, uint16_t port,
   return conn;
 }
 
+/** Mark orconn for close and transition the associated channel, if any, to
+ * the closing state.
+ */
+
+void
+connection_or_close_normally(or_connection_t *orconn, int flush)
+{
+  channel_t *chan = NULL;
+
+  tor_assert(orconn);
+  if (flush) connection_mark_and_flush(TO_CONN(orconn));
+  else connection_mark_for_close(TO_CONN(orconn));
+  if (orconn->chan) {
+    chan = TLS_CHAN_TO_BASE(orconn->chan);
+    /* This shouldn't ever happen in the listening state */
+    tor_assert(chan->state != CHANNEL_STATE_LISTENING);
+    /* Don't transition if we're already in closing, closed or error */
+    if (!(chan->state == CHANNEL_STATE_CLOSING ||
+          chan->state == CHANNEL_STATE_CLOSED ||
+          chan->state == CHANNEL_STATE_ERROR)) {
+      channel_close_from_lower_layer(chan);
+    }
+  }
+}
+
+/** Mark orconn for close and transition the associated channel, if any, to
+ * the error state.
+ */
+
+void
+connection_or_close_for_error(or_connection_t *orconn, int flush)
+{
+  channel_t *chan = NULL;
+
+  tor_assert(orconn);
+  if (flush) connection_mark_and_flush(TO_CONN(orconn));
+  else connection_mark_for_close(TO_CONN(orconn));
+  if (orconn->chan) {
+    chan = TLS_CHAN_TO_BASE(orconn->chan);
+    /* This shouldn't ever happen in the listening state */
+    tor_assert(chan->state != CHANNEL_STATE_LISTENING);
+    /* Don't transition if we're already in closing, closed or error */
+    if (!(chan->state == CHANNEL_STATE_CLOSING ||
+          chan->state == CHANNEL_STATE_CLOSED ||
+          chan->state == CHANNEL_STATE_ERROR)) {
+      channel_close_for_error(chan);
+    }
+  }
+}
+
 /** Begin the tls handshake with <b>conn</b>. <b>receiving</b> is 0 if
  * we initiated the connection, else it's 1.
  *
@@ -1140,7 +1195,23 @@ connection_or_connect(const tor_addr_t *_addr, uint16_t port,
 int
 connection_tls_start_handshake(or_connection_t *conn, int receiving)
 {
-  conn->_base.state = OR_CONN_STATE_TLS_HANDSHAKING;
+  channel_t *chan_listener, *chan;
+
+  /* Incoming connections will need a new channel passed to the
+   * channel_tls_listener */
+  if (receiving) {
+    /* It shouldn't already be set */
+    tor_assert(!(conn->chan));
+    chan_listener = channel_tls_get_listener();
+    if (!chan_listener) {
+      chan_listener = channel_tls_start_listener();
+      command_setup_listener(chan_listener);
+    }
+    chan = channel_tls_handle_incoming(conn);
+    channel_queue_incoming(chan_listener, chan);
+  }
+
+  connection_or_change_state(conn, OR_CONN_STATE_TLS_HANDSHAKING);
   tor_assert(!conn->tls);
   conn->tls = tor_tls_new(conn->_base.s, receiving);
   if (!conn->tls) {
@@ -1201,7 +1272,7 @@ connection_or_tls_renegotiated_cb(tor_tls_t *tls, void *_conn)
   if (connection_tls_finish_handshake(conn) < 0) {
     /* XXXX_TLS double-check that it's ok to do this from inside read. */
     /* XXXX_TLS double-check that this verifies certificates. */
-    connection_mark_for_close(TO_CONN(conn));
+    connection_or_close_for_error(conn, 0);
   }
 }
 
@@ -1242,7 +1313,8 @@ connection_tls_continue_handshake(or_connection_t *conn)
             } else {
               log_debug(LD_OR, "Done with initial SSL handshake (client-side)."
                         " Requesting renegotiation.");
-              conn->_base.state = OR_CONN_STATE_TLS_CLIENT_RENEGOTIATING;
+              connection_or_change_state(conn,
+                  OR_CONN_STATE_TLS_CLIENT_RENEGOTIATING);
               goto again;
             }
           }
@@ -1254,7 +1326,8 @@ connection_tls_continue_handshake(or_connection_t *conn)
           tor_tls_set_renegotiate_callback(conn->tls,
                                            connection_or_tls_renegotiated_cb,
                                            conn);
-          conn->_base.state = OR_CONN_STATE_TLS_SERVER_RENEGOTIATING;
+          connection_or_change_state(conn,
+              OR_CONN_STATE_TLS_SERVER_RENEGOTIATING);
           connection_stop_writing(TO_CONN(conn));
           connection_start_reading(TO_CONN(conn));
           return 0;
@@ -1287,7 +1360,7 @@ connection_or_handle_event_cb(struct bufferevent *bufev, short event,
     if (conn->_base.state == OR_CONN_STATE_TLS_HANDSHAKING) {
       if (tor_tls_finish_handshake(conn->tls) < 0) {
         log_warn(LD_OR, "Problem finishing handshake");
-        connection_mark_for_close(TO_CONN(conn));
+        connection_or_close_for_error(conn, 0);
         return;
       }
     }
@@ -1298,14 +1371,15 @@ connection_or_handle_event_cb(struct bufferevent *bufev, short event,
           if (tor_tls_received_v3_certificate(conn->tls)) {
             log_info(LD_OR, "Client got a v3 cert!");
             if (connection_or_launch_v3_or_handshake(conn) < 0)
-              connection_mark_for_close(TO_CONN(conn));
+              connection_or_close_for_error(conn, 0);
             return;
           } else {
-            conn->_base.state = OR_CONN_STATE_TLS_CLIENT_RENEGOTIATING;
+            connection_or_change_state(conn,
+                OR_CONN_STATE_TLS_CLIENT_RENEGOTIATING);
             tor_tls_unblock_renegotiation(conn->tls);
             if (bufferevent_ssl_renegotiate(conn->_base.bufev)<0) {
               log_warn(LD_OR, "Start_renegotiating went badly.");
-              connection_mark_for_close(TO_CONN(conn));
+              connection_or_close_for_error(conn, 0);
             }
             tor_tls_unblock_renegotiation(conn->tls);
             return; /* ???? */
@@ -1320,7 +1394,8 @@ connection_or_handle_event_cb(struct bufferevent *bufev, short event,
           tor_tls_set_renegotiate_callback(conn->tls,
                                            connection_or_tls_renegotiated_cb,
                                            conn);
-          conn->_base.state = OR_CONN_STATE_TLS_SERVER_RENEGOTIATING;
+          connection_or_change_state(conn,
+              OR_CONN_STATE_TLS_SERVER_RENEGOTIATING);
         } else if (handshakes == 2) {
           /* v2 handshake, as a server.  Two handshakes happened already,
            * so we treat renegotiation as done.
@@ -1329,18 +1404,18 @@ connection_or_handle_event_cb(struct bufferevent *bufev, short event,
         } else if (handshakes > 2) {
           log_warn(LD_OR, "More than two handshakes done on connection. "
                    "Closing.");
-          connection_mark_for_close(TO_CONN(conn));
+          connection_or_close_for_error(conn, 0);
         } else {
           log_warn(LD_BUG, "We were unexpectedly told that a connection "
                    "got %d handshakes. Closing.", handshakes);
-          connection_mark_for_close(TO_CONN(conn));
+          connection_or_close_for_error(conn, 0);
         }
         return;
       }
     }
     connection_watch_events(TO_CONN(conn), READ_EVENT|WRITE_EVENT);
     if (connection_tls_finish_handshake(conn) < 0)
-      connection_mark_for_close(TO_CONN(conn)); /* ???? */
+      connection_or_close_for_error(conn, 0); /* ???? */
     return;
   }
 
@@ -1370,29 +1445,6 @@ connection_or_nonopen_was_started_here(or_connection_t *conn)
   return !tor_tls_is_server(conn->tls);
 }
 
-/** Set the circid_type field of <b>conn</b> (which determines which part of
- * the circuit ID space we're willing to use) based on comparing our ID to
- * <b>identity_rcvd</b> */
-void
-connection_or_set_circid_type(or_connection_t *conn,
-                              crypto_pk_t *identity_rcvd)
-{
-  const int started_here = connection_or_nonopen_was_started_here(conn);
-  crypto_pk_t *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) {
-      conn->circ_id_type = CIRC_ID_TYPE_LOWER;
-    } else {
-      conn->circ_id_type = CIRC_ID_TYPE_HIGHER;
-    }
-  } else {
-    conn->circ_id_type = CIRC_ID_TYPE_NEITHER;
-  }
-}
-
 /** <b>Conn</b> just completed its handshake. Return 0 if all is well, and
  * return -1 if he is lying, broken, or otherwise something is wrong.
  *
@@ -1470,7 +1522,8 @@ connection_or_check_valid_tls_handshake(or_connection_t *conn,
     memset(digest_rcvd_out, 0, DIGEST_LEN);
   }
 
-  connection_or_set_circid_type(conn, identity_rcvd);
+  tor_assert(conn->chan);
+  channel_set_circid_type(TLS_CHAN_TO_BASE(conn->chan), identity_rcvd);
   crypto_pk_free(identity_rcvd);
 
   if (started_here)
@@ -1547,6 +1600,19 @@ connection_or_client_learned_peer_id(or_connection_t *conn,
   return 0;
 }
 
+/** Return when a client used this, for connection.c, since client_used
+ * is now one of the timestamps of channel_t */
+
+time_t
+connection_or_client_used(or_connection_t *conn)
+{
+  tor_assert(conn);
+
+  if (conn->chan) {
+    return channel_when_last_client(TLS_CHAN_TO_BASE(conn->chan));
+  } else return 0;
+}
+
 /** The v1/v2 TLS handshake is finished.
  *
  * Make sure we are happy with the person we just handshaked with.
@@ -1588,7 +1654,7 @@ connection_tls_finish_handshake(or_connection_t *conn)
     tor_tls_block_renegotiation(conn->tls);
     return connection_or_set_state_open(conn);
   } else {
-    conn->_base.state = OR_CONN_STATE_OR_HANDSHAKING_V2;
+    connection_or_change_state(conn, OR_CONN_STATE_OR_HANDSHAKING_V2);
     if (connection_init_or_handshake_state(conn, started_here) < 0)
       return -1;
     if (!started_here) {
@@ -1613,7 +1679,7 @@ connection_or_launch_v3_or_handshake(or_connection_t *conn)
 
   circuit_build_times_network_is_live(&circ_times);
 
-  conn->_base.state = OR_CONN_STATE_OR_HANDSHAKING_V3;
+  connection_or_change_state(conn, OR_CONN_STATE_OR_HANDSHAKING_V3);
   if (connection_init_or_handshake_state(conn, 1) < 0)
     return -1;
 
@@ -1732,35 +1798,9 @@ or_handshake_state_record_var_cell(or_handshake_state_t *state,
 int
 connection_or_set_state_open(or_connection_t *conn)
 {
-  int started_here = connection_or_nonopen_was_started_here(conn);
-  time_t now = time(NULL);
-  conn->_base.state = OR_CONN_STATE_OPEN;
+  connection_or_change_state(conn, OR_CONN_STATE_OPEN);
   control_event_or_conn_status(conn, OR_CONN_EVENT_CONNECTED, 0);
 
-  if (started_here) {
-    circuit_build_times_network_is_live(&circ_times);
-    rep_hist_note_connect_succeeded(conn->identity_digest, now);
-    if (entry_guard_register_connect_status(conn->identity_digest,
-                                            1, 0, now) < 0) {
-      /* Close any circuits pending on this conn. We leave it in state
-       * 'open' though, because it didn't actually *fail* -- we just
-       * chose not to use it. (Otherwise
-       * connection_about_to_close_connection() will call a big pile of
-       * functions to indicate we shouldn't try it again.) */
-      log_debug(LD_OR, "New entry guard was reachable, but closing this "
-                "connection so we can retry the earlier entry guards.");
-      circuit_n_conn_done(conn, 0);
-      return -1;
-    }
-    router_set_status(conn->identity_digest, 1);
-  } else {
-    /* only report it to the geoip module if it's not a known router */
-    if (!router_get_by_id_digest(conn->identity_digest)) {
-      geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &TO_CONN(conn)->addr,
-                             now);
-    }
-  }
-
   or_handshake_state_free(conn->handshake_state);
   conn->handshake_state = NULL;
   IF_HAS_BUFFEREVENT(TO_CONN(conn), {
@@ -1769,8 +1809,6 @@ connection_or_set_state_open(or_connection_t *conn)
     connection_start_reading(TO_CONN(conn));
   }
 
-  circuit_n_conn_done(conn, 1); /* send the pending creates, if any. */
-
   return 0;
 }
 
@@ -1790,6 +1828,10 @@ connection_or_write_cell_to_buf(const cell_t *cell, or_connection_t *conn)
 
   connection_write_to_buf(networkcell.body, CELL_NETWORK_SIZE, TO_CONN(conn));
 
+  /* Touch the channel's active timestamp if there is one */
+  if (conn->chan)
+    channel_timestamp_active(TLS_CHAN_TO_BASE(conn->chan));
+
   if (conn->_base.state == OR_CONN_STATE_OR_HANDSHAKING_V3)
     or_handshake_state_record_cell(conn->handshake_state, cell, 0);
 
@@ -1816,6 +1858,10 @@ connection_or_write_var_cell_to_buf(const var_cell_t *cell,
     or_handshake_state_record_var_cell(conn->handshake_state, cell, 0);
   if (cell->command != CELL_PADDING)
     conn->timestamp_last_added_nonpadding = approx_time();
+
+  /* Touch the channel's active timestamp if there is one */
+  if (conn->chan)
+    channel_timestamp_active(TLS_CHAN_TO_BASE(conn->chan));
 }
 
 /** See whether there's a variable-length cell waiting on <b>or_conn</b>'s
@@ -1852,8 +1898,13 @@ connection_or_process_cells_from_inbuf(or_connection_t *conn)
     if (connection_fetch_var_cell_from_buf(conn, &var_cell)) {
       if (!var_cell)
         return 0; /* not yet. */
+
+      /* Touch the channel's active timestamp if there is one */
+      if (conn->chan)
+        channel_timestamp_active(TLS_CHAN_TO_BASE(conn->chan));
+
       circuit_build_times_network_is_live(&circ_times);
-      command_process_var_cell(var_cell, conn);
+      channel_tls_handle_var_cell(var_cell, conn);
       var_cell_free(var_cell);
     } else {
       char buf[CELL_NETWORK_SIZE];
@@ -1862,6 +1913,10 @@ connection_or_process_cells_from_inbuf(or_connection_t *conn)
           < CELL_NETWORK_SIZE) /* whole response available? */
         return 0; /* not yet */
 
+      /* Touch the channel's active timestamp if there is one */
+      if (conn->chan)
+        channel_timestamp_active(TLS_CHAN_TO_BASE(conn->chan));
+
       circuit_build_times_network_is_live(&circ_times);
       connection_fetch_from_buf(buf, CELL_NETWORK_SIZE, TO_CONN(conn));
 
@@ -1869,34 +1924,11 @@ connection_or_process_cells_from_inbuf(or_connection_t *conn)
        * network-order string) */
       cell_unpack(&cell, buf);
 
-      command_process_cell(&cell, conn);
+      channel_tls_handle_cell(&cell, conn);
     }
   }
 }
 
-/** Write a destroy cell with circ ID <b>circ_id</b> and reason <b>reason</b>
- * onto OR connection <b>conn</b>.  Don't perform range-checking on reason:
- * we may want to propagate reasons from other cells.
- *
- * Return 0.
- */
-int
-connection_or_send_destroy(circid_t circ_id, or_connection_t *conn, int reason)
-{
-  cell_t cell;
-
-  tor_assert(conn);
-
-  memset(&cell, 0, sizeof(cell_t));
-  cell.circ_id = circ_id;
-  cell.command = CELL_DESTROY;
-  cell.payload[0] = (uint8_t) reason;
-  log_debug(LD_OR,"Sending destroy (circID %d).", circ_id);
-
-  connection_or_write_cell_to_buf(&cell, conn);
-  return 0;
-}
-
 /** Array of recognized link protocol versions. */
 static const uint16_t or_protocol_versions[] = { 1, 2, 3 };
 /** Number of versions in <b>or_protocol_versions</b>. */
diff --git a/src/or/connection_or.h b/src/or/connection_or.h
index 3e98f5cce..22126b05f 100644
--- a/src/or/connection_or.h
+++ b/src/or/connection_or.h
@@ -33,8 +33,14 @@ void connection_or_update_token_buckets(smartlist_t *conns,
 
 void connection_or_connect_failed(or_connection_t *conn,
                                   int reason, const char *msg);
+void connection_or_notify_error(or_connection_t *conn,
+                                int reason, const char *msg);
 or_connection_t *connection_or_connect(const tor_addr_t *addr, uint16_t port,
-                                       const char *id_digest);
+                                       const char *id_digest,
+                                       channel_tls_t *chan);
+
+void connection_or_close_normally(or_connection_t *orconn, int flush);
+void connection_or_close_for_error(or_connection_t *orconn, int flush);
 
 void connection_or_report_broken_states(int severity, int domain);
 
@@ -50,8 +56,8 @@ void connection_or_init_conn_from_address(or_connection_t *conn,
                                           int started_here);
 int connection_or_client_learned_peer_id(or_connection_t *conn,
                                          const uint8_t *peer_id);
-void connection_or_set_circid_type(or_connection_t *conn,
-                                   crypto_pk_t *identity_rcvd);
+time_t connection_or_client_used(or_connection_t *conn);
+int connection_or_get_num_circuits(or_connection_t *conn);
 void or_handshake_state_free(or_handshake_state_t *state);
 void or_handshake_state_record_cell(or_handshake_state_t *state,
                                     const cell_t *cell,
@@ -65,8 +71,6 @@ void connection_or_write_cell_to_buf(const cell_t *cell,
                                      or_connection_t *conn);
 void connection_or_write_var_cell_to_buf(const var_cell_t *cell,
                                          or_connection_t *conn);
-int connection_or_send_destroy(circid_t circ_id, or_connection_t *conn,
-                               int reason);
 int connection_or_send_versions(or_connection_t *conn, int v3_plus);
 int connection_or_send_netinfo(or_connection_t *conn);
 int connection_or_send_certs_cell(or_connection_t *conn);
diff --git a/src/or/include.am b/src/or/include.am
index b9032d97e..c32357532 100644
--- a/src/or/include.am
+++ b/src/or/include.am
@@ -18,6 +18,7 @@ endif
 src_or_libtor_a_SOURCES = \
 	src/or/buffers.c				\
 	src/or/channel.c				\
+	src/or/channeltls.c				\
 	src/or/circuitbuild.c				\
 	src/or/circuitlist.c				\
 	src/or/circuituse.c				\
@@ -88,6 +89,7 @@ src_or_tor_LDADD = src/or/libtor.a src/common/libor.a src/common/libor-crypto.a
 ORHEADERS = \
 	src/or/buffers.h				\
 	src/or/channel.h				\
+	src/or/channeltls.h				\
 	src/or/circuitbuild.h				\
 	src/or/circuitlist.h				\
 	src/or/circuituse.h				\
diff --git a/src/or/or.h b/src/or/or.h
index a916ac86e..2eee6ec46 100644
--- a/src/or/or.h
+++ b/src/or/or.h
@@ -879,6 +879,102 @@ typedef uint16_t circid_t;
 /** Identifies a stream on a circuit */
 typedef uint16_t streamid_t;
 
+/* channel_t typedef; struct channel_s is in channel.h */
+
+typedef struct channel_s channel_t;
+
+/* channel states for channel_t */
+
+typedef enum {
+  /*
+   * Closed state - channel is inactive
+   *
+   * Permitted transitions from:
+   *   - CHANNEL_STATE_CLOSING
+   * Permitted transitions to:
+   *   - CHANNEL_STATE_LISTENING
+   *   - CHANNEL_STATE_OPENING
+   */
+  CHANNEL_STATE_CLOSED = 0,
+  /*
+   * Listening state - channel is listening for incoming connections
+   *
+   * Permitted transitions from:
+   *   - CHANNEL_STATE_CLOSED
+   * Permitted transitions to:
+   *   - CHANNEL_STATE_CLOSING
+   *   - CHANNEL_STATE_ERROR
+   */
+  CHANNEL_STATE_LISTENING,
+  /*
+   * Opening state - channel is trying to connect
+   *
+   * Permitted transitions from:
+   *   - CHANNEL_STATE_CLOSED
+   * Permitted transitions to:
+   *   - CHANNEL_STATE_CLOSING
+   *   - CHANNEL_STATE_ERROR
+   *   - CHANNEL_STATE_OPEN
+   */
+  CHANNEL_STATE_OPENING,
+  /*
+   * Open state - channel is active and ready for use
+   *
+   * Permitted transitions from:
+   *   - CHANNEL_STATE_MAINT
+   *   - CHANNEL_STATE_OPENING
+   * Permitted transitions to:
+   *   - CHANNEL_STATE_CLOSING
+   *   - CHANNEL_STATE_ERROR
+   *   - CHANNEL_STATE_MAINT
+   */
+  CHANNEL_STATE_OPEN,
+  /*
+   * Maintenance state - channel is temporarily offline for subclass specific
+   *   maintenance activities such as TLS renegotiation.
+   *
+   * Permitted transitions from:
+   *   - CHANNEL_STATE_OPEN
+   * Permitted transitions to:
+   *   - CHANNEL_STATE_CLOSING
+   *   - CHANNEL_STATE_ERROR
+   *   - CHANNEL_STATE_OPEN
+   */
+  CHANNEL_STATE_MAINT,
+  /*
+   * Closing state - channel is shutting down
+   *
+   * Permitted transitions from:
+   *   - CHANNEL_STATE_MAINT
+   *   - CHANNEL_STATE_OPEN
+   * Permitted transitions to:
+   *   - CHANNEL_STATE_CLOSED,
+   *   - CHANNEL_STATE_ERROR
+   */
+  CHANNEL_STATE_CLOSING,
+  /*
+   * Error state - channel has experienced a permanent error
+   *
+   * Permitted transitions from:
+   *   - CHANNEL_STATE_CLOSING
+   *   - CHANNEL_STATE_LISTENING
+   *   - CHANNEL_STATE_MAINT
+   *   - CHANNEL_STATE_OPENING
+   *   - CHANNEL_STATE_OPEN
+   * Permitted transitions to:
+   *   - None
+   */
+  CHANNEL_STATE_ERROR,
+  /*
+   * Placeholder for maximum state value
+   */
+  CHANNEL_STATE_LAST
+} channel_state_t;
+
+/* TLS channel stuff */
+
+typedef struct channel_tls_s channel_tls_t;
+
 /** Parsed onion routing cell.  All communication between nodes
  * is via cells. */
 typedef struct cell_t {
@@ -1061,9 +1157,6 @@ typedef struct connection_t {
 
   /** Unique identifier for this connection on this Tor instance. */
   uint64_t global_identifier;
-
-  /** Unique ID for measuring tunneled network status requests. */
-  uint64_t dirreq_id;
 } connection_t;
 
 /** Subtype of connection_t; used for a listener socket. */
@@ -1203,6 +1296,9 @@ typedef struct or_connection_t {
   /** When we last used this conn for any client traffic. If not
    * recent, we can rate limit it further. */
 
+  /* Channel using this connection */
+  channel_tls_t *chan;
+
   tor_addr_t real_addr; /**< The actual address that this connection came from
                        * or went to.  The <b>addr</b> field is prone to
                        * getting overridden by the address from the router
@@ -1245,8 +1341,6 @@ typedef struct or_connection_t {
   /* XXXX we could share this among all connections. */
   struct ev_token_bucket_cfg *bucket_cfg;
 #endif
-  int n_circuits; /**< How many circuits use this connection as p_conn or
-                   * n_conn ? */
 
   struct or_connection_t *next_with_same_id; /**< Next connection with same
                                               * identity digest as this one. */
@@ -1299,6 +1393,10 @@ typedef struct edge_connection_t {
    * cells. */
   unsigned int edge_blocked_on_circ:1;
 
+  /** Unique ID for directory requests; this used to be in connection_t, but
+   * that's going away and being used on channels instead.  We still tag
+   * edge connections with dirreq_id from circuits, so it's copied here. */
+  uint64_t dirreq_id;
 } edge_connection_t;
 
 /** Subtype of edge_connection_t for an "entry connection" -- that is, a SOCKS
@@ -1421,6 +1519,10 @@ typedef struct dir_connection_t {
   char identity_digest[DIGEST_LEN]; /**< Hash of the public RSA key for
                                      * the directory server's signing key. */
 
+  /** Unique ID for directory requests; this used to be in connection_t, but
+   * that's going away and being used on channels instead.  The dirserver still
+   * needs this for the incoming side, so it's moved here. */
+  uint64_t dirreq_id;
 } dir_connection_t;
 
 /** Subtype of connection_t for an connection to a controller. */
@@ -1520,98 +1622,6 @@ static INLINE listener_connection_t *TO_LISTENER_CONN(connection_t *c)
   return DOWNCAST(listener_connection_t, c);
 }
 
-/* channel_t typedef; struct channel_s is in channel.h */
-
-typedef struct channel_s channel_t;
-
-/* channel states for channel_t */
-
-typedef enum {
-  /*
-   * Closed state - channel is inactive
-   *
-   * Permitted transitions from:
-   *   - CHANNEL_STATE_CLOSING
-   * Permitted transitions to:
-   *   - CHANNEL_STATE_LISTENING
-   *   - CHANNEL_STATE_OPENING
-   */
-  CHANNEL_STATE_CLOSED = 0,
-  /*
-   * Listening state - channel is listening for incoming connections
-   *
-   * Permitted transitions from:
-   *   - CHANNEL_STATE_CLOSED
-   * Permitted transitions to:
-   *   - CHANNEL_STATE_CLOSING
-   *   - CHANNEL_STATE_ERROR
-   */
-  CHANNEL_STATE_LISTENING,
-  /*
-   * Opening state - channel is trying to connect
-   *
-   * Permitted transitions from:
-   *   - CHANNEL_STATE_CLOSED
-   * Permitted transitions to:
-   *   - CHANNEL_STATE_CLOSING
-   *   - CHANNEL_STATE_ERROR
-   *   - CHANNEL_STATE_OPEN
-   */
-  CHANNEL_STATE_OPENING,
-  /*
-   * Open state - channel is active and ready for use
-   *
-   * Permitted transitions from:
-   *   - CHANNEL_STATE_MAINT
-   *   - CHANNEL_STATE_OPENING
-   * Permitted transitions to:
-   *   - CHANNEL_STATE_CLOSING
-   *   - CHANNEL_STATE_ERROR
-   *   - CHANNEL_STATE_MAINT
-   */
-  CHANNEL_STATE_OPEN,
-  /*
-   * Maintenance state - channel is temporarily offline for subclass specific
-   *   maintenance activities such as TLS renegotiation.
-   *
-   * Permitted transitions from:
-   *   - CHANNEL_STATE_OPEN
-   * Permitted transitions to:
-   *   - CHANNEL_STATE_CLOSING
-   *   - CHANNEL_STATE_ERROR
-   *   - CHANNEL_STATE_OPEN
-   */
-  CHANNEL_STATE_MAINT,
-  /*
-   * Closing state - channel is shutting down
-   *
-   * Permitted transitions from:
-   *   - CHANNEL_STATE_MAINT
-   *   - CHANNEL_STATE_OPEN
-   * Permitted transitions to:
-   *   - CHANNEL_STATE_CLOSED,
-   *   - CHANNEL_STATE_ERROR
-   */
-  CHANNEL_STATE_CLOSING,
-  /*
-   * Error state - channel has experienced a permanent error
-   *
-   * Permitted transitions from:
-   *   - CHANNEL_STATE_CLOSING
-   *   - CHANNEL_STATE_LISTENING
-   *   - CHANNEL_STATE_MAINT
-   *   - CHANNEL_STATE_OPENING
-   *   - CHANNEL_STATE_OPEN
-   * Permitted transitions to:
-   *   - None
-   */
-  CHANNEL_STATE_ERROR,
-  /*
-   * Placeholder for maximum state value
-   */
-  CHANNEL_STATE_LAST
-} channel_state_t;
-
 /* Conditional macros to help write code that works whether bufferevents are
    disabled or not.
 
@@ -4199,10 +4209,10 @@ typedef enum {
   /** Flushed last cell from queue of the circuit that initiated a
     * tunneled request to the outbuf of the OR connection. */
   DIRREQ_CIRC_QUEUE_FLUSHED = 3,
-  /** Flushed last byte from buffer of the OR connection belonging to the
+  /** Flushed last byte from buffer of the channel belonging to the
     * circuit that initiated a tunneled request; completes a tunneled
     * request. */
-  DIRREQ_OR_CONN_BUFFER_FLUSHED = 4
+  DIRREQ_CHANNEL_BUFFER_FLUSHED = 4
 } dirreq_state_t;
 
 #define WRITE_STATS_INTERVAL (24*60*60)