src/test/test_controller_events.c

   1 /* Copyright (c) 2013-2021, The Tor Project, Inc. */
   2 /* See LICENSE for licensing information */
   3
   4 #define CONNECTION_PRIVATE
   5 #define CHANNEL_OBJECT_PRIVATE
   6 #define CONTROL_PRIVATE
   7 #define CONTROL_EVENTS_PRIVATE
   8 #define OCIRC_EVENT_PRIVATE
   9 #define ORCONN_EVENT_PRIVATE
  10 #include "app/main/subsysmgr.h"
  11 #include "core/or/or.h"
  12 #include "core/or/channel.h"
  13 #include "core/or/channeltls.h"
  14 #include "core/or/circuitlist.h"
  15 #include "core/or/ocirc_event.h"
  16 #include "core/or/orconn_event.h"
  17 #include "core/mainloop/connection.h"
  18 #include "feature/control/control_events.h"
  19 #include "feature/control/control_fmt.h"
  20 #include "test/test.h"
  21 #include "test/test_helpers.h"
  22 #include "test/log_test_helpers.h"
  23
  24 #include "core/or/entry_connection_st.h"
  25 #include "core/or/or_circuit_st.h"
  26 #include "core/or/origin_circuit_st.h"
  27 #include "core/or/socks_request_st.h"
  28
  29 static void
  30 add_testing_cell_stats_entry(circuit_t *circ, uint8_t command,
  31                              unsigned int waiting_time,
  32                              unsigned int removed, unsigned int exitward)
  33 {
  34   testing_cell_stats_entry_t *ent = tor_malloc_zero(
  35                                     sizeof(testing_cell_stats_entry_t));
  36   ent->command = command;
  37   ent->waiting_time = waiting_time;
  38   ent->removed = removed;
  39   ent->exitward = exitward;
  40   if (!circ->testing_cell_stats)
  41     circ->testing_cell_stats = smartlist_new();
  42   smartlist_add(circ->testing_cell_stats, ent);
  43 }
  44
  45 static void
  46 test_cntev_sum_up_cell_stats(void *arg)
  47 {
  48   or_circuit_t *or_circ;
  49   circuit_t *circ;
  50   cell_stats_t *cell_stats = NULL;
  51   (void)arg;
  52
  53   /* This circuit is fake. */
  54   or_circ = tor_malloc_zero(sizeof(or_circuit_t));
  55   or_circ->base_.magic = OR_CIRCUIT_MAGIC;
  56   or_circ->base_.purpose = CIRCUIT_PURPOSE_OR;
  57   circ = TO_CIRCUIT(or_circ);
  58
  59   /* A single RELAY cell was added to the appward queue. */
  60   cell_stats = tor_malloc_zero(sizeof(cell_stats_t));
  61   add_testing_cell_stats_entry(circ, CELL_RELAY, 0, 0, 0);
  62   sum_up_cell_stats_by_command(circ, cell_stats);
  63   tt_u64_op(1, OP_EQ, cell_stats->added_cells_appward[CELL_RELAY]);
  64
  65   /* A single RELAY cell was added to the exitward queue. */
  66   add_testing_cell_stats_entry(circ, CELL_RELAY, 0, 0, 1);
  67   sum_up_cell_stats_by_command(circ, cell_stats);
  68   tt_u64_op(1, OP_EQ, cell_stats->added_cells_exitward[CELL_RELAY]);
  69
  70   /* A single RELAY cell was removed from the appward queue where it spent
  71    * 20 msec. */
  72   add_testing_cell_stats_entry(circ, CELL_RELAY, 2, 1, 0);
  73   sum_up_cell_stats_by_command(circ, cell_stats);
  74   tt_u64_op(20, OP_EQ, cell_stats->total_time_appward[CELL_RELAY]);
  75   tt_u64_op(1, OP_EQ, cell_stats->removed_cells_appward[CELL_RELAY]);
  76
  77   /* A single RELAY cell was removed from the exitward queue where it
  78    * spent 30 msec. */
  79   add_testing_cell_stats_entry(circ, CELL_RELAY, 3, 1, 1);
  80   sum_up_cell_stats_by_command(circ, cell_stats);
  81   tt_u64_op(30, OP_EQ, cell_stats->total_time_exitward[CELL_RELAY]);
  82   tt_u64_op(1, OP_EQ, cell_stats->removed_cells_exitward[CELL_RELAY]);
  83
  84  done:
  85   tor_free(cell_stats);
  86   tor_free(or_circ);
  87 }
  88
  89 static void
  90 test_cntev_append_cell_stats(void *arg)
  91 {
  92   smartlist_t *event_parts;
  93   char *cp = NULL;
  94   const char *key = "Z";
  95   uint64_t include_if_non_zero[CELL_COMMAND_MAX_ + 1],
  96            number_to_include[CELL_COMMAND_MAX_ + 1];
  97   (void)arg;
  98
  99   event_parts = smartlist_new();
 100   memset(include_if_non_zero, 0,
 101          (CELL_COMMAND_MAX_ + 1) * sizeof(uint64_t));
 102   memset(number_to_include, 0,
 103          (CELL_COMMAND_MAX_ + 1) * sizeof(uint64_t));
 104
 105   /* All array entries empty. */
 106   append_cell_stats_by_command(event_parts, key,
 107                                include_if_non_zero,
 108                                number_to_include);
 109   tt_int_op(0, OP_EQ, smartlist_len(event_parts));
 110
 111   /* There's a RELAY cell to include, but the corresponding field in
 112    * include_if_non_zero is still zero. */
 113   number_to_include[CELL_RELAY] = 1;
 114   append_cell_stats_by_command(event_parts, key,
 115                                include_if_non_zero,
 116                                number_to_include);
 117   tt_int_op(0, OP_EQ, smartlist_len(event_parts));
 118
 119   /* Now include single RELAY cell. */
 120   include_if_non_zero[CELL_RELAY] = 2;
 121   append_cell_stats_by_command(event_parts, key,
 122                                include_if_non_zero,
 123                                number_to_include);
 124   cp = smartlist_pop_last(event_parts);
 125   tt_str_op("Z=relay:1", OP_EQ, cp);
 126   tor_free(cp);
 127
 128   /* Add four CREATE cells. */
 129   include_if_non_zero[CELL_CREATE] = 3;
 130   number_to_include[CELL_CREATE] = 4;
 131   append_cell_stats_by_command(event_parts, key,
 132                                include_if_non_zero,
 133                                number_to_include);
 134   cp = smartlist_pop_last(event_parts);
 135   tt_str_op("Z=create:4,relay:1", OP_EQ, cp);
 136
 137  done:
 138   tor_free(cp);
 139   smartlist_free(event_parts);
 140 }
 141
 142 static void
 143 test_cntev_format_cell_stats(void *arg)
 144 {
 145   char *event_string = NULL;
 146   origin_circuit_t *ocirc = NULL;
 147   or_circuit_t *or_circ = NULL;
 148   cell_stats_t *cell_stats = NULL;
 149   channel_tls_t *n_chan=NULL, *p_chan=NULL;
 150   (void)arg;
 151
 152   n_chan = tor_malloc_zero(sizeof(channel_tls_t));
 153   n_chan->base_.global_identifier = 1;
 154
 155   ocirc = tor_malloc_zero(sizeof(origin_circuit_t));
 156   ocirc->base_.magic = ORIGIN_CIRCUIT_MAGIC;
 157   ocirc->base_.purpose = CIRCUIT_PURPOSE_C_GENERAL;
 158   ocirc->global_identifier = 2;
 159   ocirc->base_.n_circ_id = 3;
 160   ocirc->base_.n_chan = &(n_chan->base_);
 161
 162   /* Origin circuit was completely idle. */
 163   cell_stats = tor_malloc_zero(sizeof(cell_stats_t));
 164   format_cell_stats(&event_string, TO_CIRCUIT(ocirc), cell_stats);
 165   tt_str_op("ID=2 OutboundQueue=3 OutboundConn=1", OP_EQ, event_string);
 166   tor_free(event_string);
 167
 168   /* Origin circuit had 4 RELAY cells added to its exitward queue. */
 169   cell_stats->added_cells_exitward[CELL_RELAY] = 4;
 170   format_cell_stats(&event_string, TO_CIRCUIT(ocirc), cell_stats);
 171   tt_str_op("ID=2 OutboundQueue=3 OutboundConn=1 OutboundAdded=relay:4",
 172             OP_EQ, event_string);
 173   tor_free(event_string);
 174
 175   /* Origin circuit also had 5 CREATE2 cells added to its exitward
 176    * queue. */
 177   cell_stats->added_cells_exitward[CELL_CREATE2] = 5;
 178   format_cell_stats(&event_string, TO_CIRCUIT(ocirc), cell_stats);
 179   tt_str_op("ID=2 OutboundQueue=3 OutboundConn=1 OutboundAdded=relay:4,"
 180             "create2:5", OP_EQ, event_string);
 181   tor_free(event_string);
 182
 183   /* Origin circuit also had 7 RELAY cells removed from its exitward queue
 184    * which together spent 6 msec in the queue. */
 185   cell_stats->total_time_exitward[CELL_RELAY] = 6;
 186   cell_stats->removed_cells_exitward[CELL_RELAY] = 7;
 187   format_cell_stats(&event_string, TO_CIRCUIT(ocirc), cell_stats);
 188   tt_str_op("ID=2 OutboundQueue=3 OutboundConn=1 OutboundAdded=relay:4,"
 189             "create2:5 OutboundRemoved=relay:7 OutboundTime=relay:6",
 190             OP_EQ, event_string);
 191   tor_free(event_string);
 192
 193   p_chan = tor_malloc_zero(sizeof(channel_tls_t));
 194   p_chan->base_.global_identifier = 2;
 195
 196   or_circ = tor_malloc_zero(sizeof(or_circuit_t));
 197   or_circ->base_.magic = OR_CIRCUIT_MAGIC;
 198   or_circ->base_.purpose = CIRCUIT_PURPOSE_OR;
 199   or_circ->p_circ_id = 8;
 200   or_circ->p_chan = &(p_chan->base_);
 201   or_circ->base_.n_circ_id = 9;
 202   or_circ->base_.n_chan = &(n_chan->base_);
 203
 204   tor_free(cell_stats);
 205
 206   /* OR circuit was idle. */
 207   cell_stats = tor_malloc_zero(sizeof(cell_stats_t));
 208   format_cell_stats(&event_string, TO_CIRCUIT(or_circ), cell_stats);
 209   tt_str_op("InboundQueue=8 InboundConn=2 OutboundQueue=9 OutboundConn=1",
 210             OP_EQ, event_string);
 211   tor_free(event_string);
 212
 213   /* OR circuit had 3 RELAY cells added to its appward queue. */
 214   cell_stats->added_cells_appward[CELL_RELAY] = 3;
 215   format_cell_stats(&event_string, TO_CIRCUIT(or_circ), cell_stats);
 216   tt_str_op("InboundQueue=8 InboundConn=2 InboundAdded=relay:3 "
 217             "OutboundQueue=9 OutboundConn=1", OP_EQ, event_string);
 218   tor_free(event_string);
 219
 220   /* OR circuit had 7 RELAY cells removed from its appward queue which
 221    * together spent 6 msec in the queue. */
 222   cell_stats->total_time_appward[CELL_RELAY] = 6;
 223   cell_stats->removed_cells_appward[CELL_RELAY] = 7;
 224   format_cell_stats(&event_string, TO_CIRCUIT(or_circ), cell_stats);
 225   tt_str_op("InboundQueue=8 InboundConn=2 InboundAdded=relay:3 "
 226             "InboundRemoved=relay:7 InboundTime=relay:6 "
 227             "OutboundQueue=9 OutboundConn=1", OP_EQ, event_string);
 228
 229  done:
 230   tor_free(cell_stats);
 231   tor_free(event_string);
 232   tor_free(or_circ);
 233   tor_free(ocirc);
 234   tor_free(p_chan);
 235   tor_free(n_chan);
 236 }
 237
 238 static void
 239 test_cntev_event_mask(void *arg)
 240 {
 241   unsigned int test_event, selected_event;
 242   (void)arg;
 243
 244   /* Check that nothing is interesting when no events are set */
 245   control_testing_set_global_event_mask(EVENT_MASK_NONE_);
 246
 247   /* Check that nothing is interesting between EVENT_MIN_ and EVENT_MAX_ */
 248   for (test_event = EVENT_MIN_; test_event <= EVENT_MAX_; test_event++)
 249     tt_assert(!control_event_is_interesting(test_event));
 250
 251   /* Check that nothing is interesting outside EVENT_MIN_ to EVENT_MAX_
 252    * This will break if control_event_is_interesting() checks its arguments */
 253   for (test_event = 0; test_event < EVENT_MIN_; test_event++)
 254     tt_assert(!control_event_is_interesting(test_event));
 255   for (test_event = EVENT_MAX_ + 1;
 256        test_event < EVENT_CAPACITY_;
 257        test_event++)
 258     tt_assert(!control_event_is_interesting(test_event));
 259
 260   /* Check that all valid events are interesting when all events are set */
 261   control_testing_set_global_event_mask(EVENT_MASK_ALL_);
 262
 263   /* Check that everything is interesting between EVENT_MIN_ and EVENT_MAX_ */
 264   for (test_event = EVENT_MIN_; test_event <= EVENT_MAX_; test_event++)
 265     tt_assert(control_event_is_interesting(test_event));
 266
 267   /* Check that nothing is interesting outside EVENT_MIN_ to EVENT_MAX_
 268    * This will break if control_event_is_interesting() checks its arguments */
 269   for (test_event = 0; test_event < EVENT_MIN_; test_event++)
 270     tt_assert(!control_event_is_interesting(test_event));
 271   for (test_event = EVENT_MAX_ + 1;
 272        test_event < EVENT_CAPACITY_;
 273        test_event++)
 274     tt_assert(!control_event_is_interesting(test_event));
 275
 276   /* Check that only that event is interesting when a single event is set */
 277   for (selected_event = EVENT_MIN_;
 278        selected_event <= EVENT_MAX_;
 279        selected_event++) {
 280     control_testing_set_global_event_mask(EVENT_MASK_(selected_event));
 281
 282     /* Check that only this event is interesting
 283      * between EVENT_MIN_ and EVENT_MAX_ */
 284     for (test_event = EVENT_MIN_; test_event <= EVENT_MAX_; test_event++) {
 285       if (test_event == selected_event) {
 286         tt_assert(control_event_is_interesting(test_event));
 287       } else {
 288         tt_assert(!control_event_is_interesting(test_event));
 289       }
 290     }
 291
 292     /* Check that nothing is interesting outside EVENT_MIN_ to EVENT_MAX_
 293      * This will break if control_event_is_interesting checks its arguments */
 294     for (test_event = 0; test_event < EVENT_MIN_; test_event++)
 295       tt_assert(!control_event_is_interesting(test_event));
 296     for (test_event = EVENT_MAX_ + 1;
 297          test_event < EVENT_CAPACITY_;
 298          test_event++)
 299       tt_assert(!control_event_is_interesting(test_event));
 300   }
 301
 302   /* Check that only that event is not-interesting
 303    * when a single event is un-set */
 304   for (selected_event = EVENT_MIN_;
 305        selected_event <= EVENT_MAX_;
 306        selected_event++) {
 307     control_testing_set_global_event_mask(
 308                                           EVENT_MASK_ALL_
 309                                           & ~(EVENT_MASK_(selected_event))
 310                                           );
 311
 312     /* Check that only this event is not-interesting
 313      * between EVENT_MIN_ and EVENT_MAX_ */
 314     for (test_event = EVENT_MIN_; test_event <= EVENT_MAX_; test_event++) {
 315       if (test_event == selected_event) {
 316         tt_assert(!control_event_is_interesting(test_event));
 317       } else {
 318         tt_assert(control_event_is_interesting(test_event));
 319       }
 320     }
 321
 322     /* Check that nothing is interesting outside EVENT_MIN_ to EVENT_MAX_
 323      * This will break if control_event_is_interesting checks its arguments */
 324     for (test_event = 0; test_event < EVENT_MIN_; test_event++)
 325       tt_assert(!control_event_is_interesting(test_event));
 326     for (test_event = EVENT_MAX_ + 1;
 327          test_event < EVENT_CAPACITY_;
 328          test_event++)
 329       tt_assert(!control_event_is_interesting(test_event));
 330   }
 331
 332  done:
 333   ;
 334 }
 335
 336 static char *saved_event_str = NULL;
 337
 338 static void
 339 mock_queue_control_event_string(uint16_t event, char *msg)
 340 {
 341   (void)event;
 342
 343   tor_free(saved_event_str);
 344   saved_event_str = msg;
 345 }
 346
 347 /* Helper macro for checking bootstrap control event strings */
 348 #define assert_bootmsg(s)                                               \
 349   tt_ptr_op(strstr(saved_event_str, "650 STATUS_CLIENT NOTICE "         \
 350                    "BOOTSTRAP PROGRESS=" s), OP_EQ, saved_event_str)
 351
 352 /* Test deferral of directory bootstrap messages (requesting_descriptors) */
 353 static void
 354 test_cntev_dirboot_defer_desc(void *arg)
 355 {
 356   (void)arg;
 357
 358   MOCK(queue_control_event_string, mock_queue_control_event_string);
 359   control_testing_set_global_event_mask(EVENT_MASK_(EVENT_STATUS_CLIENT));
 360   control_event_bootstrap(BOOTSTRAP_STATUS_STARTING, 0);
 361   assert_bootmsg("0 TAG=starting");
 362   /* This event should get deferred */
 363   control_event_boot_dir(BOOTSTRAP_STATUS_REQUESTING_DESCRIPTORS, 0);
 364   assert_bootmsg("0 TAG=starting");
 365   control_event_bootstrap(BOOTSTRAP_STATUS_CONN, 0);
 366   assert_bootmsg("5 TAG=conn");
 367   control_event_bootstrap(BOOTSTRAP_STATUS_HANDSHAKE, 0);
 368   assert_bootmsg("14 TAG=handshake");
 369   /* The deferred event should appear */
 370   control_event_boot_first_orconn();
 371   assert_bootmsg("45 TAG=requesting_descriptors");
 372  done:
 373   tor_free(saved_event_str);
 374   UNMOCK(queue_control_event_string);
 375 }
 376
 377 /* Test deferral of directory bootstrap messages (conn_or) */
 378 static void
 379 test_cntev_dirboot_defer_orconn(void *arg)
 380 {
 381   (void)arg;
 382
 383   MOCK(queue_control_event_string, mock_queue_control_event_string);
 384   control_testing_set_global_event_mask(EVENT_MASK_(EVENT_STATUS_CLIENT));
 385   control_event_bootstrap(BOOTSTRAP_STATUS_STARTING, 0);
 386   assert_bootmsg("0 TAG=starting");
 387   /* This event should get deferred */
 388   control_event_boot_dir(BOOTSTRAP_STATUS_ENOUGH_DIRINFO, 0);
 389   assert_bootmsg("0 TAG=starting");
 390   control_event_bootstrap(BOOTSTRAP_STATUS_CONN, 0);
 391   assert_bootmsg("5 TAG=conn");
 392   control_event_bootstrap(BOOTSTRAP_STATUS_HANDSHAKE, 0);
 393   assert_bootmsg("14 TAG=handshake");
 394   /* The deferred event should appear */
 395   control_event_boot_first_orconn();
 396   assert_bootmsg("75 TAG=enough_dirinfo");
 397  done:
 398   tor_free(saved_event_str);
 399   UNMOCK(queue_control_event_string);
 400 }
 401
 402 static void
 403 test_cntev_signal(void *arg)
 404 {
 405   (void)arg;
 406   int rv;
 407
 408   MOCK(queue_control_event_string, mock_queue_control_event_string);
 409
 410   /* Nothing is listening for signals, so no event should be queued. */
 411   rv = control_event_signal(SIGHUP);
 412   tt_int_op(0, OP_EQ, rv);
 413   tt_ptr_op(saved_event_str, OP_EQ, NULL);
 414
 415   /* Now try with signals included in the event mask. */
 416   control_testing_set_global_event_mask(EVENT_MASK_(EVENT_GOT_SIGNAL));
 417   rv = control_event_signal(SIGHUP);
 418   tt_int_op(0, OP_EQ, rv);
 419   tt_str_op(saved_event_str, OP_EQ, "650 SIGNAL RELOAD\r\n");
 420
 421   rv = control_event_signal(SIGACTIVE);
 422   tt_int_op(0, OP_EQ, rv);
 423   tt_str_op(saved_event_str, OP_EQ, "650 SIGNAL ACTIVE\r\n");
 424
 425   /* Try a signal that doesn't exist. */
 426   setup_full_capture_of_logs(LOG_WARN);
 427   tor_free(saved_event_str);
 428   rv = control_event_signal(99999);
 429   tt_int_op(-1, OP_EQ, rv);
 430   tt_ptr_op(saved_event_str, OP_EQ, NULL);
 431   expect_single_log_msg_containing("Unrecognized signal 99999");
 432
 433  done:
 434   tor_free(saved_event_str);
 435  teardown_capture_of_logs();
 436   UNMOCK(queue_control_event_string);
 437 }
 438
 439 static void
 440 test_cntev_log_fmt(void *arg)
 441 {
 442   (void) arg;
 443   char *result = NULL;
 444 #define CHECK(pre, post) \
 445   do {                                            \
 446     result = tor_strdup((pre));                   \
 447     control_logmsg_strip_newlines(result);        \
 448     tt_str_op(result, OP_EQ, (post));             \
 449     tor_free(result);                             \
 450   } while (0)
 451
 452   CHECK("There is a ", "There is a");
 453   CHECK("hello", "hello");
 454   CHECK("", "");
 455   CHECK("Put    spaces at the end   ", "Put    spaces at the end");
 456   CHECK("         ", "");
 457   CHECK("\n\n\n", "");
 458   CHECK("Testing\r\n", "Testing");
 459   CHECK("T e s t\ni n g\n", "T e s t i n g");
 460
 461  done:
 462   tor_free(result);
 463 #undef CHECK
 464 }
 465
 466 static void
 467 setup_orconn_state(orconn_state_msg_t *msg, uint64_t gid, uint64_t chan,
 468                    int proxy_type)
 469 {
 470   msg->gid = gid;
 471   msg->chan = chan;
 472   msg->proxy_type = proxy_type;
 473 }
 474
 475 static void
 476 send_orconn_state(const orconn_state_msg_t *msg_in, uint8_t state)
 477 {
 478   orconn_state_msg_t *msg = tor_malloc(sizeof(*msg));
 479
 480   *msg = *msg_in;
 481   msg->state = state;
 482   orconn_state_publish(msg);
 483 }
 484
 485 static void
 486 send_ocirc_chan(uint32_t gid, uint64_t chan, bool onehop)
 487 {
 488   ocirc_chan_msg_t *msg = tor_malloc(sizeof(*msg));
 489
 490   msg->gid = gid;
 491   msg->chan = chan;
 492   msg->onehop = onehop;
 493   ocirc_chan_publish(msg);
 494 }
 495
 496 static void
 497 test_cntev_orconn_state(void *arg)
 498 {
 499   orconn_state_msg_t conn;
 500   memset(&conn, 0, sizeof(conn));
 501
 502   (void)arg;
 503   MOCK(queue_control_event_string, mock_queue_control_event_string);
 504   control_testing_set_global_event_mask(EVENT_MASK_(EVENT_STATUS_CLIENT));
 505   setup_orconn_state(&conn, 1, 1, PROXY_NONE);
 506
 507   send_orconn_state(&conn, OR_CONN_STATE_CONNECTING);
 508   send_ocirc_chan(1, 1, true);
 509   assert_bootmsg("5 TAG=conn");
 510   send_orconn_state(&conn, OR_CONN_STATE_TLS_HANDSHAKING);
 511   assert_bootmsg("10 TAG=conn_done");
 512   send_orconn_state(&conn, OR_CONN_STATE_OR_HANDSHAKING_V3);
 513   assert_bootmsg("14 TAG=handshake");
 514   send_orconn_state(&conn, OR_CONN_STATE_OPEN);
 515   assert_bootmsg("15 TAG=handshake_done");
 516
 517   conn.gid = 2;
 518   conn.chan = 2;
 519   send_orconn_state(&conn, OR_CONN_STATE_CONNECTING);
 520   /* It doesn't know it's an origin circuit yet */
 521   assert_bootmsg("15 TAG=handshake_done");
 522   send_ocirc_chan(2, 2, false);
 523   assert_bootmsg("80 TAG=ap_conn");
 524   send_orconn_state(&conn, OR_CONN_STATE_TLS_HANDSHAKING);
 525   assert_bootmsg("85 TAG=ap_conn_done");
 526   send_orconn_state(&conn, OR_CONN_STATE_OR_HANDSHAKING_V3);
 527   assert_bootmsg("89 TAG=ap_handshake");
 528   send_orconn_state(&conn, OR_CONN_STATE_OPEN);
 529   assert_bootmsg("90 TAG=ap_handshake_done");
 530
 531  done:
 532   tor_free(saved_event_str);
 533   UNMOCK(queue_control_event_string);
 534 }
 535
 536 static void
 537 test_cntev_orconn_state_pt(void *arg)
 538 {
 539   orconn_state_msg_t conn;
 540   memset(&conn, 0, sizeof(conn));
 541
 542   (void)arg;
 543   MOCK(queue_control_event_string, mock_queue_control_event_string);
 544   control_testing_set_global_event_mask(EVENT_MASK_(EVENT_STATUS_CLIENT));
 545   setup_orconn_state(&conn, 1, 1, PROXY_PLUGGABLE);
 546   send_ocirc_chan(1, 1, true);
 547
 548   send_orconn_state(&conn, OR_CONN_STATE_CONNECTING);
 549   assert_bootmsg("1 TAG=conn_pt");
 550   send_orconn_state(&conn, OR_CONN_STATE_PROXY_HANDSHAKING);
 551   assert_bootmsg("2 TAG=conn_done_pt");
 552   send_orconn_state(&conn, OR_CONN_STATE_TLS_HANDSHAKING);
 553   assert_bootmsg("10 TAG=conn_done");
 554   send_orconn_state(&conn, OR_CONN_STATE_OR_HANDSHAKING_V3);
 555   assert_bootmsg("14 TAG=handshake");
 556   send_orconn_state(&conn, OR_CONN_STATE_OPEN);
 557   assert_bootmsg("15 TAG=handshake_done");
 558
 559   send_ocirc_chan(2, 2, false);
 560   conn.gid = 2;
 561   conn.chan = 2;
 562   send_orconn_state(&conn, OR_CONN_STATE_CONNECTING);
 563   assert_bootmsg("76 TAG=ap_conn_pt");
 564   send_orconn_state(&conn, OR_CONN_STATE_PROXY_HANDSHAKING);
 565   assert_bootmsg("77 TAG=ap_conn_done_pt");
 566
 567  done:
 568   tor_free(saved_event_str);
 569   UNMOCK(queue_control_event_string);
 570 }
 571
 572 static void
 573 test_cntev_orconn_state_proxy(void *arg)
 574 {
 575   orconn_state_msg_t conn;
 576   memset(&conn, 0, sizeof(conn));
 577
 578   (void)arg;
 579   MOCK(queue_control_event_string, mock_queue_control_event_string);
 580   control_testing_set_global_event_mask(EVENT_MASK_(EVENT_STATUS_CLIENT));
 581   setup_orconn_state(&conn, 1, 1, PROXY_CONNECT);
 582   send_ocirc_chan(1, 1, true);
 583
 584   send_orconn_state(&conn, OR_CONN_STATE_CONNECTING);
 585   assert_bootmsg("3 TAG=conn_proxy");
 586   send_orconn_state(&conn, OR_CONN_STATE_PROXY_HANDSHAKING);
 587   assert_bootmsg("4 TAG=conn_done_proxy");
 588   send_orconn_state(&conn, OR_CONN_STATE_TLS_HANDSHAKING);
 589   assert_bootmsg("10 TAG=conn_done");
 590   send_orconn_state(&conn, OR_CONN_STATE_OR_HANDSHAKING_V3);
 591   assert_bootmsg("14 TAG=handshake");
 592   send_orconn_state(&conn, OR_CONN_STATE_OPEN);
 593   assert_bootmsg("15 TAG=handshake_done");
 594
 595   send_ocirc_chan(2, 2, false);
 596   conn.gid = 2;
 597   conn.chan = 2;
 598   send_orconn_state(&conn, OR_CONN_STATE_CONNECTING);
 599   assert_bootmsg("78 TAG=ap_conn_proxy");
 600   send_orconn_state(&conn, OR_CONN_STATE_PROXY_HANDSHAKING);
 601   assert_bootmsg("79 TAG=ap_conn_done_proxy");
 602
 603  done:
 604   tor_free(saved_event_str);
 605   UNMOCK(queue_control_event_string);
 606 }
 607
 608 static void
 609 test_cntev_format_stream(void *arg)
 610 {
 611   entry_connection_t *ec = NULL;
 612   char *conndesc = NULL;
 613   (void)arg;
 614
 615   ec = entry_connection_new(CONN_TYPE_AP, AF_INET);
 616
 617   char *username = tor_strdup("jeremy");
 618   char *password = tor_strdup("letmein");
 619   ec->socks_request->username = username; // steal reference
 620   ec->socks_request->usernamelen = strlen(username);
 621   ec->socks_request->password = password; // steal reference
 622   ec->socks_request->passwordlen = strlen(password);
 623   conndesc = entry_connection_describe_status_for_controller(ec);
 624   tt_assert(strstr(conndesc, "SOCKS_USERNAME=\"jeremy\""));
 625   tt_assert(strstr(conndesc, "SOCKS_PASSWORD=\"letmein\""));
 626   tor_free(conndesc);
 627
 628   ec->socks_request->listener_type = CONN_TYPE_AP_LISTENER;
 629   ec->socks_request->socks_version = 4;
 630   conndesc = entry_connection_describe_status_for_controller(ec);
 631   tt_assert(strstr(conndesc, "CLIENT_PROTOCOL=SOCKS4"));
 632   tor_free(conndesc);
 633
 634   ec->socks_request->listener_type = CONN_TYPE_AP_LISTENER;
 635   ec->socks_request->socks_version = 5;
 636   conndesc = entry_connection_describe_status_for_controller(ec);
 637   tt_assert(strstr(conndesc, "CLIENT_PROTOCOL=SOCKS5"));
 638   tor_free(conndesc);
 639
 640   ec->socks_request->listener_type = CONN_TYPE_AP_LISTENER;
 641   ec->socks_request->socks_version = 6;
 642   conndesc = entry_connection_describe_status_for_controller(ec);
 643   tt_assert(strstr(conndesc, "CLIENT_PROTOCOL=UNKNOWN"));
 644   tor_free(conndesc);
 645
 646   ec->socks_request->listener_type = CONN_TYPE_AP_TRANS_LISTENER;
 647   conndesc = entry_connection_describe_status_for_controller(ec);
 648   tt_assert(strstr(conndesc, "CLIENT_PROTOCOL=TRANS"));
 649   tor_free(conndesc);
 650
 651   ec->socks_request->listener_type = CONN_TYPE_AP_NATD_LISTENER;
 652   conndesc = entry_connection_describe_status_for_controller(ec);
 653   tt_assert(strstr(conndesc, "CLIENT_PROTOCOL=NATD"));
 654   tor_free(conndesc);
 655
 656   ec->socks_request->listener_type = CONN_TYPE_AP_DNS_LISTENER;
 657   conndesc = entry_connection_describe_status_for_controller(ec);
 658   tt_assert(strstr(conndesc, "CLIENT_PROTOCOL=DNS"));
 659   tor_free(conndesc);
 660
 661   ec->socks_request->listener_type = CONN_TYPE_AP_HTTP_CONNECT_LISTENER;
 662   conndesc = entry_connection_describe_status_for_controller(ec);
 663   tt_assert(strstr(conndesc, "CLIENT_PROTOCOL=HTTPCONNECT"));
 664   tor_free(conndesc);
 665
 666   ec->socks_request->listener_type = CONN_TYPE_OR;
 667   conndesc = entry_connection_describe_status_for_controller(ec);
 668   tt_assert(strstr(conndesc, "CLIENT_PROTOCOL=UNKNOWN"));
 669   tor_free(conndesc);
 670
 671   ec->nym_epoch = 1337;
 672   conndesc = entry_connection_describe_status_for_controller(ec);
 673   tt_assert(strstr(conndesc, "NYM_EPOCH=1337"));
 674   tor_free(conndesc);
 675
 676   ec->entry_cfg.session_group = 4321;
 677   conndesc = entry_connection_describe_status_for_controller(ec);
 678   tt_assert(strstr(conndesc, "SESSION_GROUP=4321"));
 679   tor_free(conndesc);
 680
 681   ec->entry_cfg.isolation_flags = ISO_DESTPORT;
 682   conndesc = entry_connection_describe_status_for_controller(ec);
 683   tt_assert(strstr(conndesc, "ISO_FIELDS=DESTPORT"));
 684   tt_assert(!strstr(conndesc, "ISO_FIELDS=DESTPORT,"));
 685   tor_free(conndesc);
 686
 687   ec->entry_cfg.isolation_flags = ISO_DESTADDR;
 688   conndesc = entry_connection_describe_status_for_controller(ec);
 689   tt_assert(strstr(conndesc, "ISO_FIELDS=DESTADDR"));
 690   tt_assert(!strstr(conndesc, "ISO_FIELDS=DESTADDR,"));
 691   tor_free(conndesc);
 692
 693   ec->entry_cfg.isolation_flags = ISO_SOCKSAUTH;
 694   conndesc = entry_connection_describe_status_for_controller(ec);
 695   tt_assert(strstr(conndesc, "ISO_FIELDS=SOCKS_USERNAME,SOCKS_PASSWORD"));
 696   tt_assert(!strstr(conndesc, "ISO_FIELDS=SOCKS_USERNAME,SOCKS_PASSWORD,"));
 697   tor_free(conndesc);
 698
 699   ec->entry_cfg.isolation_flags = ISO_CLIENTPROTO;
 700   conndesc = entry_connection_describe_status_for_controller(ec);
 701   tt_assert(strstr(conndesc, "ISO_FIELDS=CLIENT_PROTOCOL"));
 702   tt_assert(!strstr(conndesc, "ISO_FIELDS=CLIENT_PROTOCOL,"));
 703   tor_free(conndesc);
 704
 705   ec->entry_cfg.isolation_flags = ISO_CLIENTADDR;
 706   conndesc = entry_connection_describe_status_for_controller(ec);
 707   tt_assert(strstr(conndesc, "ISO_FIELDS=CLIENTADDR"));
 708   tt_assert(!strstr(conndesc, "ISO_FIELDS=CLIENTADDR,"));
 709   tor_free(conndesc);
 710
 711   ec->entry_cfg.isolation_flags = ISO_SESSIONGRP;
 712   conndesc = entry_connection_describe_status_for_controller(ec);
 713   tt_assert(strstr(conndesc, "ISO_FIELDS=SESSION_GROUP"));
 714   tt_assert(!strstr(conndesc, "ISO_FIELDS=SESSION_GROUP,"));
 715   tor_free(conndesc);
 716
 717   ec->entry_cfg.isolation_flags = ISO_NYM_EPOCH;
 718   conndesc = entry_connection_describe_status_for_controller(ec);
 719   tt_assert(strstr(conndesc, "ISO_FIELDS=NYM_EPOCH"));
 720   tt_assert(!strstr(conndesc, "ISO_FIELDS=NYM_EPOCH,"));
 721   tor_free(conndesc);
 722
 723   ec->entry_cfg.isolation_flags = ISO_DESTPORT | ISO_SOCKSAUTH | ISO_NYM_EPOCH;
 724   conndesc = entry_connection_describe_status_for_controller(ec);
 725   tt_assert(strstr(conndesc,
 726     "ISO_FIELDS=DESTPORT,SOCKS_USERNAME,SOCKS_PASSWORD,NYM_EPOCH"));
 727   tt_assert(!strstr(conndesc,
 728     "ISO_FIELDS=DESTPORT,SOCKS_USERNAME,SOCKS_PASSWORD,NYM_EPOCH,"));
 729
 730  done:
 731   tor_free(conndesc);
 732   connection_free_minimal(ENTRY_TO_CONN(ec));
 733 }
 734
 735 #define TEST(name, flags)                               \
 736   { #name, test_cntev_ ## name, flags, 0, NULL }
 737
 738 #define T_PUBSUB(name, setup)                                           \
 739   { #name, test_cntev_ ## name, TT_FORK, &helper_pubsub_setup, NULL }
 740
 741 struct testcase_t controller_event_tests[] = {
 742   TEST(sum_up_cell_stats, TT_FORK),
 743   TEST(append_cell_stats, TT_FORK),
 744   TEST(format_cell_stats, TT_FORK),
 745   TEST(event_mask, TT_FORK),
 746   TEST(format_stream, TT_FORK),
 747   TEST(signal, TT_FORK),
 748   TEST(log_fmt, 0),
 749   T_PUBSUB(dirboot_defer_desc, TT_FORK),
 750   T_PUBSUB(dirboot_defer_orconn, TT_FORK),
 751   T_PUBSUB(orconn_state, TT_FORK),
 752   T_PUBSUB(orconn_state_pt, TT_FORK),
 753   T_PUBSUB(orconn_state_proxy, TT_FORK),
 754   END_OF_TESTCASES
 755 };