1 files changed, 249 insertions, 105 deletions

diff --git a/src/or/main.c b/src/or/main.c
index 96b7b456ea..4b512905c3 100644
--- a/src/or/main.c
+++ b/src/or/main.c
@@ -12,12 +12,50 @@
 
 #define MAIN_PRIVATE
 #include "or.h"
+#include "buffers.h"
+#include "circuitbuild.h"
+#include "circuitlist.h"
+#include "circuituse.h"
+#include "command.h"
+#include "config.h"
+#include "connection.h"
+#include "connection_edge.h"
+#include "connection_or.h"
+#include "control.h"
+#include "cpuworker.h"
+#include "directory.h"
+#include "dirserv.h"
+#include "dirvote.h"
+#include "dns.h"
+#include "dnsserv.h"
+#include "geoip.h"
+#include "hibernate.h"
+#include "main.h"
+#include "microdesc.h"
+#include "networkstatus.h"
+#include "ntmain.h"
+#include "onion.h"
+#include "policies.h"
+#include "relay.h"
+#include "rendclient.h"
+#include "rendcommon.h"
+#include "rendservice.h"
+#include "rephist.h"
+#include "router.h"
+#include "routerlist.h"
+#include "routerparse.h"
 #ifdef USE_DMALLOC
 #include <dmalloc.h>
 #include <openssl/crypto.h>
 #endif
 #include "memarea.h"
 
+#ifdef HAVE_EVENT2_EVENT_H
+#include <event2/event.h>
+#else
+#include <event.h>
+#endif
+
 void evdns_shutdown(int);
 
 /********* PROTOTYPES **********/
@@ -27,7 +65,7 @@ static void dumpstats(int severity); /* log stats */
 static void conn_read_callback(int fd, short event, void *_conn);
 static void conn_write_callback(int fd, short event, void *_conn);
 static void signal_callback(int fd, short events, void *arg);
-static void second_elapsed_callback(int fd, short event, void *args);
+static void second_elapsed_callback(periodic_timer_t *timer, void *args);
 static int conn_close_if_marked(int i);
 static void connection_start_reading_from_linked_conn(connection_t *conn);
 static int connection_should_read_from_linked_conn(connection_t *conn);
@@ -81,8 +119,12 @@ static smartlist_t *active_linked_connection_lst = NULL;
 static int called_loop_once = 0;
 
 /** We set this to 1 when we've opened a circuit, so we can print a log
- * entry to inform the user that Tor is working. */
-int has_completed_circuit=0;
+ * entry to inform the user that Tor is working.  We set it to 0 when
+ * we think the fact that we once opened a circuit doesn't mean we can do so
+ * any longer (a big time jump happened, when we notice our directory is
+ * heinously out-of-date, etc.
+ */
+int can_complete_circuit=0;
 
 /** How often do we check for router descriptors that we should download
  * when we have too little directory info? */
@@ -127,12 +169,10 @@ connection_add(connection_t *conn)
   smartlist_add(connection_array, conn);
 
   if (conn->s >= 0 || conn->linked) {
-    conn->read_event = tor_malloc_zero(sizeof(struct event));
-    conn->write_event = tor_malloc_zero(sizeof(struct event));
-    event_set(conn->read_event, conn->s, EV_READ|EV_PERSIST,
-              conn_read_callback, conn);
-    event_set(conn->write_event, conn->s, EV_WRITE|EV_PERSIST,
-              conn_write_callback, conn);
+    conn->read_event = tor_event_new(tor_libevent_get_base(),
+         conn->s, EV_READ|EV_PERSIST, conn_read_callback, conn);
+    conn->write_event = tor_event_new(tor_libevent_get_base(),
+         conn->s, EV_WRITE|EV_PERSIST, conn_write_callback, conn);
   }
 
   log_debug(LD_NET,"new conn type %s, socket %d, address %s, n_conns %d.",
@@ -142,6 +182,25 @@ connection_add(connection_t *conn)
   return 0;
 }
 
+/** Tell libevent that we don't care about <b>conn</b> any more. */
+void
+connection_unregister_events(connection_t *conn)
+{
+  if (conn->read_event) {
+    if (event_del(conn->read_event))
+      log_warn(LD_BUG, "Error removing read event for %d", conn->s);
+    tor_free(conn->read_event);
+  }
+  if (conn->write_event) {
+    if (event_del(conn->write_event))
+      log_warn(LD_BUG, "Error removing write event for %d", conn->s);
+    tor_free(conn->write_event);
+  }
+  if (conn->dns_server_port) {
+    dnsserv_close_listener(conn);
+  }
+}
+
 /** Remove the connection from the global list, and remove the
  * corresponding poll entry.  Calling this function will shift the last
  * connection (if any) into the position occupied by conn.
@@ -246,17 +305,17 @@ get_connection_array(void)
 }
 
 /** Set the event mask on <b>conn</b> to <b>events</b>.  (The event
- * mask is a bitmask whose bits are EV_READ and EV_WRITE.)
+ * mask is a bitmask whose bits are READ_EVENT and WRITE_EVENT)
  */
 void
-connection_watch_events(connection_t *conn, short events)
+connection_watch_events(connection_t *conn, watchable_events_t events)
 {
-  if (events & EV_READ)
+  if (events & READ_EVENT)
     connection_start_reading(conn);
   else
     connection_stop_reading(conn);
 
-  if (events & EV_WRITE)
+  if (events & WRITE_EVENT)
     connection_start_writing(conn);
   else
     connection_stop_writing(conn);
@@ -393,11 +452,11 @@ connection_start_reading_from_linked_conn(connection_t *conn)
     smartlist_add(active_linked_connection_lst, conn);
     if (!called_loop_once) {
       /* This is the first event on the list; we won't be in LOOP_ONCE mode,
-       * so we need to make sure that the event_loop() actually exits at the
-       * end of its run through the current connections and
-       * lets us activate read events for linked connections. */
+       * so we need to make sure that the event_base_loop() actually exits at
+       * the end of its run through the current connections and lets us
+       * activate read events for linked connections. */
       struct timeval tv = { 0, 0 };
-      event_loopexit(&tv);
+      tor_event_base_loopexit(tor_libevent_get_base(), &tv);
     }
   } else {
     tor_assert(smartlist_isin(active_linked_connection_lst, conn));
@@ -540,7 +599,7 @@ conn_close_if_marked(int i)
       log_info(LD_NET,
                "Conn (addr %s, fd %d, type %s, state %d) marked, but wants "
                "to flush %d bytes. (Marked at %s:%d)",
-               escaped_safe_str(conn->address),
+               escaped_safe_str_client(conn->address),
                conn->s, conn_type_to_string(conn->type), conn->state,
                (int)conn->outbuf_flushlen,
                 conn->marked_for_close_file, conn->marked_for_close);
@@ -593,8 +652,8 @@ conn_close_if_marked(int i)
              "something is wrong with theirs. "
              "(fd %d, type %s, state %d, marked at %s:%d).",
              (int)buf_datalen(conn->outbuf),
-             escaped_safe_str(conn->address), conn->s,
-             conn_type_to_string(conn->type), conn->state,
+             escaped_safe_str_client(conn->address),
+             conn->s, conn_type_to_string(conn->type), conn->state,
              conn->marked_for_close_file,
              conn->marked_for_close);
     }
@@ -623,7 +682,7 @@ directory_all_unreachable(time_t now)
     log_notice(LD_NET,
                "Is your network connection down? "
                "Failing connection to '%s:%d'.",
-               safe_str(edge_conn->socks_request->address),
+               safe_str_client(edge_conn->socks_request->address),
                edge_conn->socks_request->port);
     connection_mark_unattached_ap(edge_conn,
                                   END_STREAM_REASON_NET_UNREACHABLE);
@@ -651,7 +710,7 @@ directory_info_has_arrived(time_t now, int from_cache)
 
     /* if we have enough dir info, then update our guard status with
      * whatever we just learned. */
-    entry_guards_compute_status();
+    entry_guards_compute_status(options, now);
     /* Don't even bother trying to get extrainfo until the rest of our
      * directory info is up-to-date */
     if (options->DownloadExtraInfo)
@@ -659,7 +718,7 @@ directory_info_has_arrived(time_t now, int from_cache)
   }
 
   if (server_mode(options) && !we_are_hibernating() && !from_cache &&
-      (has_completed_circuit || !any_predicted_circuits(now)))
+      (can_complete_circuit || !any_predicted_circuits(now)))
     consider_testing_reachability(1, 1);
 }
 
@@ -722,6 +781,7 @@ run_connection_housekeeping(int i, time_t now)
      the connection or send a keepalive, depending. */
 
   or_conn = TO_OR_CONN(conn);
+  tor_assert(conn->outbuf);
 
   if (or_conn->is_bad_for_new_circs && !or_conn->n_circuits) {
     /* It's bad for new circuits, and has no unmarked circuits on it:
@@ -778,7 +838,7 @@ run_connection_housekeeping(int i, time_t now)
   }
 }
 
-/** Honor a NEWNYM request: make future requests unlinkability to past
+/** Honor a NEWNYM request: make future requests unlinkable to past
  * requests. */
 static void
 signewnym_impl(time_t now)
@@ -804,16 +864,18 @@ run_scheduled_events(time_t now)
   static time_t time_to_try_getting_descriptors = 0;
   static time_t time_to_reset_descriptor_failures = 0;
   static time_t time_to_add_entropy = 0;
-  static time_t time_to_write_hs_statistics = 0;
   static time_t time_to_write_bridge_status_file = 0;
   static time_t time_to_downrate_stability = 0;
   static time_t time_to_save_stability = 0;
   static time_t time_to_clean_caches = 0;
   static time_t time_to_recheck_bandwidth = 0;
   static time_t time_to_check_for_expired_networkstatus = 0;
-  static time_t time_to_dump_geoip_stats = 0;
+  static time_t time_to_write_stats_files = 0;
+  static time_t time_to_write_bridge_stats = 0;
+  static int should_init_bridge_stats = 1;
   static time_t time_to_retry_dns_init = 0;
   or_options_t *options = get_options();
+  int is_server = server_mode(options);
   int i;
   int have_dir_info;
 
@@ -831,11 +893,14 @@ run_scheduled_events(time_t now)
     signewnym_impl(now);
   }
 
+  /* 0c. If we've deferred log messages for the controller, handle them now */
+  flush_pending_log_callbacks();
+
   /** 1a. Every MIN_ONION_KEY_LIFETIME seconds, rotate the onion keys,
    *  shut down and restart all cpuworkers, and update the directory if
    *  necessary.
    */
-  if (server_mode(options) &&
+  if (is_server &&
       get_onion_key_set_at()+MIN_ONION_KEY_LIFETIME < now) {
     log_info(LD_GENERAL,"Rotating onion key.");
     rotate_onion_key();
@@ -851,7 +916,7 @@ run_scheduled_events(time_t now)
     update_router_descriptor_downloads(now);
     update_extrainfo_downloads(now);
     if (options->UseBridges)
-      fetch_bridge_descriptors(now);
+      fetch_bridge_descriptors(options, now);
     if (router_have_minimum_dir_info())
       time_to_try_getting_descriptors = now + LAZY_DESCRIPTOR_RETRY_INTERVAL;
     else
@@ -869,7 +934,10 @@ run_scheduled_events(time_t now)
     last_rotated_x509_certificate = now;
   if (last_rotated_x509_certificate+MAX_SSL_KEY_LIFETIME < now) {
     log_info(LD_GENERAL,"Rotating tls context.");
-    if (tor_tls_context_new(get_identity_key(), MAX_SSL_KEY_LIFETIME) < 0) {
+    if (tor_tls_context_init(public_server_mode(options),
+                             get_tlsclient_identity_key(),
+                             is_server ? get_server_identity_key() : NULL,
+                             MAX_SSL_KEY_LIFETIME) < 0) {
       log_warn(LD_BUG, "Error reinitializing TLS context");
       /* XXX is it a bug here, that we just keep going? -RD */
     }
@@ -897,7 +965,7 @@ run_scheduled_events(time_t now)
   if (now % 10 == 0 && (authdir_mode_tests_reachability(options)) &&
       !we_are_hibernating()) {
     /* try to determine reachability of the other Tor relays */
-    dirserv_test_reachability(now, 0);
+    dirserv_test_reachability(now);
   }
 
   /** 1d. Periodically, we discount older stability information so that new
@@ -939,11 +1007,56 @@ run_scheduled_events(time_t now)
     time_to_check_for_expired_networkstatus = now + CHECK_EXPIRED_NS_INTERVAL;
   }
 
-  if (time_to_dump_geoip_stats < now) {
-#define DUMP_GEOIP_STATS_INTERVAL (60*60);
-    if (time_to_dump_geoip_stats)
-      dump_geoip_stats();
-    time_to_dump_geoip_stats = now + DUMP_GEOIP_STATS_INTERVAL;
+  /* 1g. Check whether we should write statistics to disk.
+   */
+  if (time_to_write_stats_files < now) {
+#define CHECK_WRITE_STATS_INTERVAL (60*60)
+    time_t next_time_to_write_stats_files = (time_to_write_stats_files > 0 ?
+           time_to_write_stats_files : now) + CHECK_WRITE_STATS_INTERVAL;
+    if (options->CellStatistics) {
+      time_t next_write =
+          rep_hist_buffer_stats_write(time_to_write_stats_files);
+      if (next_write && next_write < next_time_to_write_stats_files)
+        next_time_to_write_stats_files = next_write;
+    }
+    if (options->DirReqStatistics) {
+      time_t next_write = geoip_dirreq_stats_write(time_to_write_stats_files);
+      if (next_write && next_write < next_time_to_write_stats_files)
+        next_time_to_write_stats_files = next_write;
+    }
+    if (options->EntryStatistics) {
+      time_t next_write = geoip_entry_stats_write(time_to_write_stats_files);
+      if (next_write && next_write < next_time_to_write_stats_files)
+        next_time_to_write_stats_files = next_write;
+    }
+    if (options->ExitPortStatistics) {
+      time_t next_write = rep_hist_exit_stats_write(time_to_write_stats_files);
+      if (next_write && next_write < next_time_to_write_stats_files)
+        next_time_to_write_stats_files = next_write;
+    }
+    time_to_write_stats_files = next_time_to_write_stats_files;
+  }
+
+  /* 1h. Check whether we should write bridge statistics to disk.
+   */
+  if (should_record_bridge_info(options)) {
+    if (time_to_write_bridge_stats < now) {
+      if (should_init_bridge_stats) {
+        /* (Re-)initialize bridge statistics. */
+        geoip_bridge_stats_init(now);
+        time_to_write_bridge_stats = now + WRITE_STATS_INTERVAL;
+        should_init_bridge_stats = 0;
+      } else {
+        /* Possibly write bridge statistics to disk and ask when to write
+         * them next time. */
+        time_to_write_bridge_stats = geoip_bridge_stats_write(
+                                           time_to_write_bridge_stats);
+      }
+    }
+  } else if (!should_init_bridge_stats) {
+    /* Bridge mode was turned off. Ensure that stats are re-initialized
+     * next time bridge mode is turned on. */
+    should_init_bridge_stats = 1;
   }
 
   /* Remove old information from rephist and the rend cache. */
@@ -991,7 +1104,7 @@ run_scheduled_events(time_t now)
     /* also, check religiously for reachability, if it's within the first
      * 20 minutes of our uptime. */
     if (server_mode(options) &&
-        (has_completed_circuit || !any_predicted_circuits(now)) &&
+        (can_complete_circuit || !any_predicted_circuits(now)) &&
         !we_are_hibernating()) {
       if (stats_n_seconds_working < TIMEOUT_UNTIL_UNREACHABILITY_COMPLAINT) {
         consider_testing_reachability(1, dirport_reachability_count==0);
@@ -1067,7 +1180,7 @@ run_scheduled_events(time_t now)
     circuit_expire_old_circuits_serverside(now);
 
   /** 5. We do housekeeping for each connection... */
-  connection_or_set_bad_connections();
+  connection_or_set_bad_connections(NULL, 0);
   for (i=0;i<smartlist_len(connection_array);i++) {
     run_connection_housekeeping(i, now);
   }
@@ -1090,7 +1203,7 @@ run_scheduled_events(time_t now)
   circuit_close_all_marked();
 
   /** 7. And upload service descriptors if necessary. */
-  if (has_completed_circuit && !we_are_hibernating()) {
+  if (can_complete_circuit && !we_are_hibernating()) {
     rend_consider_services_upload(now);
     rend_consider_descriptor_republication();
   }
@@ -1107,7 +1220,7 @@ run_scheduled_events(time_t now)
 
   /** 9. and if we're a server, check whether our DNS is telling stories to
    * us. */
-  if (server_mode(options) && time_to_check_for_correct_dns < now) {
+  if (is_server && time_to_check_for_correct_dns < now) {
     if (!time_to_check_for_correct_dns) {
       time_to_check_for_correct_dns = now + 60 + crypto_rand_int(120);
     } else {
@@ -1117,12 +1230,6 @@ run_scheduled_events(time_t now)
     }
   }
 
-  /** 10. write hidden service usage statistic to disk */
-  if (options->HSAuthorityRecordStats && time_to_write_hs_statistics < now) {
-    hs_usage_write_statistics_to_file(now);
-#define WRITE_HSUSAGE_INTERVAL (30*60)
-    time_to_write_hs_statistics = now+WRITE_HSUSAGE_INTERVAL;
-  }
   /** 10b. write bridge networkstatus file to disk */
   if (options->BridgeAuthoritativeDir &&
       time_to_write_bridge_status_file < now) {
@@ -1132,39 +1239,30 @@ run_scheduled_events(time_t now)
   }
 }
 
-/** Libevent timer: used to invoke second_elapsed_callback() once per
- * second. */
-static struct event *timeout_event = NULL;
+/** Timer: used to invoke second_elapsed_callback() once per second. */
+static periodic_timer_t *second_timer = NULL;
 /** Number of libevent errors in the last second: we die if we get too many. */
 static int n_libevent_errors = 0;
 
 /** Libevent callback: invoked once every second. */
 static void
-second_elapsed_callback(int fd, short event, void *args)
+second_elapsed_callback(periodic_timer_t *timer, void *arg)
 {
   /* XXXX This could be sensibly refactored into multiple callbacks, and we
    * could use Libevent's timers for this rather than checking the current
    * time against a bunch of timeouts every second. */
-  static struct timeval one_second;
   static time_t current_second = 0;
   time_t now;
   size_t bytes_written;
   size_t bytes_read;
   int seconds_elapsed;
   or_options_t *options = get_options();
-  (void)fd;
-  (void)event;
-  (void)args;
-  if (!timeout_event) {
-    timeout_event = tor_malloc_zero(sizeof(struct event));
-    evtimer_set(timeout_event, second_elapsed_callback, NULL);
-    one_second.tv_sec = 1;
-    one_second.tv_usec = 0;
-  }
+  (void)timer;
+  (void)arg;
 
   n_libevent_errors = 0;
 
-  /* log_fn(LOG_NOTICE, "Tick."); */
+  /* log_notice(LD_GENERAL, "Tick."); */
   now = time(NULL);
   update_approx_time(now);
 
@@ -1187,7 +1285,7 @@ second_elapsed_callback(int fd, short event, void *args)
   if (server_mode(options) &&
       !we_are_hibernating() &&
       seconds_elapsed > 0 &&
-      has_completed_circuit &&
+      can_complete_circuit &&
       stats_n_seconds_working / TIMEOUT_UNTIL_UNREACHABILITY_COMPLAINT !=
       (stats_n_seconds_working+seconds_elapsed) /
         TIMEOUT_UNTIL_UNREACHABILITY_COMPLAINT) {
@@ -1229,18 +1327,6 @@ second_elapsed_callback(int fd, short event, void *args)
   run_scheduled_events(now);
 
   current_second = now; /* remember which second it is, for next time */
-
-#if 0
-  if (current_second % 300 == 0) {
-    rep_history_clean(current_second - options->RephistTrackTime);
-    dumpmemusage(get_min_log_level()<LOG_INFO ?
-                 get_min_log_level() : LOG_INFO);
-  }
-#endif
-
-  if (evtimer_add(timeout_event, &one_second))
-    log_err(LD_NET,
-            "Error from libevent when setting one-second timeout event");
 }
 
 #ifndef MS_WINDOWS
@@ -1383,7 +1469,7 @@ do_main_loop(void)
 
   /* load the private keys, if we're supposed to have them, and set up the
    * TLS context. */
-  if (! identity_key_is_set()) {
+  if (! client_identity_key_is_set()) {
     if (init_keys() < 0) {
       log_err(LD_BUG,"Error initializing keys; exiting");
       return -1;
@@ -1401,8 +1487,10 @@ do_main_loop(void)
   /* initialize the bootstrap status events to know we're starting up */
   control_event_bootstrap(BOOTSTRAP_STATUS_STARTING, 0);
 
-  if (trusted_dirs_reload_certs())
-    return -1;
+  if (trusted_dirs_reload_certs()) {
+    log_warn(LD_DIR,
+             "Couldn't load all cached v3 certificates. Starting anyway.");
+  }
   if (router_reload_v2_networkstatus()) {
     return -1;
   }
@@ -1419,18 +1507,23 @@ do_main_loop(void)
   now = time(NULL);
   directory_info_has_arrived(now, 1);
 
-  if (authdir_mode_tests_reachability(get_options())) {
-    /* the directory is already here, run startup things */
-    dirserv_test_reachability(now, 1);
-  }
-
   if (server_mode(get_options())) {
     /* launch cpuworkers. Need to do this *after* we've read the onion key. */
     cpu_init();
   }
 
   /* set up once-a-second callback. */
-  second_elapsed_callback(0,0,NULL);
+  if (! second_timer) {
+    struct timeval one_second;
+    one_second.tv_sec = 1;
+    one_second.tv_usec = 0;
+
+    second_timer = periodic_timer_new(tor_libevent_get_base(),
+                                      &one_second,
+                                      second_elapsed_callback,
+                                      NULL);
+    tor_assert(second_timer);
+  }
 
   for (;;) {
     if (nt_service_is_stopping())
@@ -1449,20 +1542,16 @@ do_main_loop(void)
 
     /* poll until we have an event, or the second ends, or until we have
      * some active linked connections to trigger events for. */
-    loop_result = event_loop(called_loop_once ? EVLOOP_ONCE : 0);
+    loop_result = event_base_loop(tor_libevent_get_base(),
+                                  called_loop_once ? EVLOOP_ONCE : 0);
 
     /* let catch() handle things like ^c, and otherwise don't worry about it */
     if (loop_result < 0) {
       int e = tor_socket_errno(-1);
       /* let the program survive things like ^z */
       if (e != EINTR && !ERRNO_IS_EINPROGRESS(e)) {
-#ifdef HAVE_EVENT_GET_METHOD
         log_err(LD_NET,"libevent call with %s failed: %s [%d]",
-                event_get_method(), tor_socket_strerror(e), e);
-#else
-        log_err(LD_NET,"libevent call failed: %s [%d]",
-                tor_socket_strerror(e), e);
-#endif
+                tor_libevent_get_method(), tor_socket_strerror(e), e);
         return -1;
 #ifndef MS_WINDOWS
       } else if (e == EINVAL) {
@@ -1605,6 +1694,7 @@ dumpmemusage(int severity)
       U64_PRINTF_ARG(rephist_total_alloc), rephist_total_num);
   dump_routerlist_mem_usage(severity);
   dump_cell_pool_usage(severity);
+  dump_dns_mem_usage(severity);
   buf_dump_freelist_sizes(severity);
   tor_log_mallinfo(severity);
 }
@@ -1631,7 +1721,8 @@ dumpstats(int severity)
     if (!connection_is_listener(conn)) {
       log(severity,LD_GENERAL,
           "Conn %d is to %s:%d.", i,
-          safe_str(conn->address), conn->port);
+          safe_str_client(conn->address),
+          conn->port);
       log(severity,LD_GENERAL,
           "Conn %d: %d bytes waiting on inbuf (len %d, last read %d secs ago)",
           i,
@@ -1728,7 +1819,7 @@ handle_signals(int is_parent)
 {
 #ifndef MS_WINDOWS /* do signal stuff only on Unix */
   int i;
-  static int signals[] = {
+  static const int signals[] = {
     SIGINT,  /* do a controlled slow shutdown */
     SIGTERM, /* to terminate now */
     SIGPIPE, /* otherwise SIGPIPE kills us */
@@ -1740,12 +1831,13 @@ handle_signals(int is_parent)
 #endif
     SIGCHLD, /* handle dns/cpu workers that exit */
     -1 };
-  static struct event signal_events[16]; /* bigger than it has to be. */
+  static struct event *signal_events[16]; /* bigger than it has to be. */
   if (is_parent) {
     for (i = 0; signals[i] >= 0; ++i) {
-      signal_set(&signal_events[i], signals[i], signal_callback,
-                 (void*)(uintptr_t)signals[i]);
-      if (signal_add(&signal_events[i], NULL))
+      signal_events[i] = tor_evsignal_new(
+                       tor_libevent_get_base(), signals[i], signal_callback,
+                       (void*)(uintptr_t)signals[i]);
+      if (event_add(signal_events[i], NULL))
         log_warn(LD_BUG, "Error from libevent when adding event for signal %d",
                  signals[i]);
     }
@@ -1834,7 +1926,9 @@ tor_init(int argc, char *argv[])
              "and you probably shouldn't.");
 #endif
 
-  if (crypto_global_init(get_options()->HardwareAccel)) {
+  if (crypto_global_init(get_options()->HardwareAccel,
+                         get_options()->AccelName,
+                         get_options()->AccelDir)) {
     log_err(LD_BUG, "Unable to initialize OpenSSL. Exiting.");
     return -1;
   }
@@ -1928,7 +2022,6 @@ tor_free_all(int postfork)
   rend_cache_free_all();
   rend_service_authorization_free_all();
   rep_hist_free_all();
-  hs_usage_free_all();
   dns_free_all();
   clear_pending_onions();
   circuit_free_all();
@@ -1936,6 +2029,7 @@ tor_free_all(int postfork)
   connection_free_all();
   buf_shrink_freelists(1);
   memarea_clear_freelist();
+  microdesc_free_all();
   if (!postfork) {
     config_free_all();
     router_free_all();
@@ -1946,13 +2040,11 @@ tor_free_all(int postfork)
     tor_tls_free_all();
   }
   /* stuff in main.c */
-  if (connection_array)
-    smartlist_free(connection_array);
-  if (closeable_connection_lst)
-    smartlist_free(closeable_connection_lst);
-  if (active_linked_connection_lst)
-    smartlist_free(active_linked_connection_lst);
-  tor_free(timeout_event);
+
+  smartlist_free(connection_array);
+  smartlist_free(closeable_connection_lst);
+  smartlist_free(active_linked_connection_lst);
+  periodic_timer_free(second_timer);
   if (!postfork) {
     release_lockfile();
   }
@@ -2013,7 +2105,7 @@ do_list_fingerprint(void)
     log_err(LD_BUG,"Error initializing keys; can't display fingerprint");
     return -1;
   }
-  if (!(k = get_identity_key())) {
+  if (!(k = get_server_identity_key())) {
     log_err(LD_GENERAL,"Error: missing identity key.");
     return -1;
   }
@@ -2043,6 +2135,31 @@ do_hash_password(void)
   printf("16:%s\n",output);
 }
 
+#if defined (WINCE)
+int
+find_flashcard_path(PWCHAR path, size_t size)
+{
+  WIN32_FIND_DATA d = {0};
+  HANDLE h = NULL;
+
+  if (!path)
+    return -1;
+
+  h = FindFirstFlashCard(&d);
+  if (h == INVALID_HANDLE_VALUE)
+    return -1;
+
+  if (wcslen(d.cFileName) == 0) {
+    FindClose(h);
+    return -1;
+  }
+
+  wcsncpy(path,d.cFileName,size);
+  FindClose(h);
+  return 0;
+}
+#endif
+
 /** Main entry point for the Tor process.  Called from main(). */
 /* This function is distinct from main() only so we can link main.c into
  * the unittest binary without conflicting with the unittests' main. */
@@ -2050,6 +2167,33 @@ int
 tor_main(int argc, char *argv[])
 {
   int result = 0;
+#if defined (WINCE)
+  WCHAR path [MAX_PATH] = {0};
+  WCHAR fullpath [MAX_PATH] = {0};
+  PWCHAR p = NULL;
+  FILE* redir = NULL;
+  FILE* redirdbg = NULL;
+
+  // this is to facilitate debugging by opening
+  // a file on a folder shared by the wm emulator.
+  // if no flashcard (real or emulated) is present,
+  // log files will be written in the root folder
+  if (find_flashcard_path(path,MAX_PATH) == -1)
+  {
+    redir = _wfreopen( L"\\stdout.log", L"w", stdout );
+    redirdbg = _wfreopen( L"\\stderr.log", L"w", stderr );
+  } else {
+    swprintf(fullpath,L"\\%s\\tor",path);
+    CreateDirectory(fullpath,NULL);
+
+    swprintf(fullpath,L"\\%s\\tor\\stdout.log",path);
+    redir = _wfreopen( fullpath, L"w", stdout );
+
+    swprintf(fullpath,L"\\%s\\tor\\stderr.log",path);
+    redirdbg = _wfreopen( fullpath, L"w", stderr );
+  }
+#endif
+
   update_approx_time(time(NULL));
   tor_threads_init();
   init_logging();