src/test/test_router.c

   1 /* Copyright (c) 2017-2021, The Tor Project, Inc. */
   2 /* Copyright (c) 2017, isis agora lovecruft  */
   3 /* See LICENSE for licensing information     */
   4
   5 /**
   6  * \file test_router.c
   7  * \brief Unittests for code in router.c
   8  **/
   9
  10 #define CONFIG_PRIVATE
  11 #define CONNECTION_PRIVATE
  12 #define ROUTER_PRIVATE
  13
  14 #include "core/or/or.h"
  15 #include "app/config/config.h"
  16 #include "core/mainloop/mainloop.h"
  17 #include "core/mainloop/connection.h"
  18 #include "feature/hibernate/hibernate.h"
  19 #include "feature/nodelist/networkstatus.h"
  20 #include "feature/nodelist/networkstatus_st.h"
  21 #include "feature/nodelist/node_st.h"
  22 #include "feature/nodelist/nodelist.h"
  23 #include "feature/nodelist/routerinfo_st.h"
  24 #include "feature/nodelist/routerlist.h"
  25 #include "feature/nodelist/routerstatus_st.h"
  26 #include "feature/nodelist/torcert.h"
  27 #include "feature/relay/router.h"
  28 #include "feature/stats/bwhist.h"
  29 #include "lib/crypt_ops/crypto_curve25519.h"
  30 #include "lib/crypt_ops/crypto_ed25519.h"
  31 #include "lib/encoding/confline.h"
  32
  33 #include "core/or/listener_connection_st.h"
  34
  35 /* Test suite stuff */
  36 #include "test/test.h"
  37 #include "test/log_test_helpers.h"
  38
  39 static routerinfo_t *
  40 rtr_tests_gen_routerinfo(crypto_pk_t *ident_key, crypto_pk_t *tap_key)
  41 {
  42   time_t now;
  43
  44   routerinfo_t *mock_routerinfo;
  45
  46   /* Mock the published timestamp, otherwise router_dump_router_to_string()
  47    * will poop its pants. */
  48   time(&now);
  49
  50   /* We'll need keys, or router_dump_router_to_string() would return NULL. */
  51   tor_assert(ident_key != NULL);
  52   tor_assert(tap_key != NULL);
  53
  54   mock_routerinfo = tor_malloc_zero(sizeof(routerinfo_t));
  55   mock_routerinfo->nickname = tor_strdup("ConlonNancarrow");
  56   tor_addr_from_ipv4h(&mock_routerinfo->ipv4_addr, 123456789);
  57   mock_routerinfo->ipv4_orport = 443;
  58   mock_routerinfo->platform = tor_strdup("unittest");
  59   mock_routerinfo->cache_info.published_on = now;
  60   mock_routerinfo->identity_pkey = crypto_pk_dup_key(ident_key);
  61   mock_routerinfo->protocol_list =
  62     tor_strdup("Cons=1-2 Desc=1-2 DirCache=1-2");
  63   router_set_rsa_onion_pkey(tap_key, &mock_routerinfo->onion_pkey,
  64                             &mock_routerinfo->onion_pkey_len);
  65   mock_routerinfo->bandwidthrate = 9001;
  66   mock_routerinfo->bandwidthburst = 9002;
  67
  68   return mock_routerinfo;
  69 }
  70
  71 /* If no distribution option was set, then check_bridge_distribution_setting()
  72  * should have set it to "any". */
  73 static void
  74 test_router_dump_router_to_string_no_bridge_distribution_method(void *arg)
  75 {
  76   const char* needle = "bridge-distribution-request any";
  77   or_options_t* options = get_options_mutable();
  78   routerinfo_t* router = NULL;
  79   curve25519_keypair_t ntor_keypair;
  80   ed25519_keypair_t signing_keypair;
  81   ed25519_keypair_t identity_keypair;
  82   char* desc = NULL;
  83   char* found = NULL;
  84   (void)arg;
  85   crypto_pk_t *ident_key = pk_generate(0);
  86   crypto_pk_t *tap_key = pk_generate(0);
  87
  88   options->ORPort_set = 1;
  89   options->BridgeRelay = 1;
  90
  91   /* Generate keys which router_dump_router_to_string() expects to exist. */
  92   tt_int_op(0, OP_EQ, curve25519_keypair_generate(&ntor_keypair, 0));
  93   tt_int_op(0, OP_EQ, ed25519_keypair_generate(&signing_keypair, 0));
  94   tt_int_op(0, OP_EQ, ed25519_keypair_generate(&identity_keypair, 0));
  95
  96   /* Set up part of our routerinfo_t so that we don't trigger any other
  97    * assertions in router_dump_router_to_string(). */
  98   router = rtr_tests_gen_routerinfo(ident_key, tap_key);
  99   tt_ptr_op(router, OP_NE, NULL);
 100
 101   router->cache_info.signing_key_cert =
 102     tor_cert_create_ed25519(&identity_keypair,
 103                             CERT_TYPE_ID_SIGNING,
 104                             &signing_keypair.pubkey,
 105                             time(NULL),
 106                             86400,
 107                             CERT_FLAG_INCLUDE_SIGNING_KEY);
 108
 109   /* The real router_get_my_routerinfo() looks up onion_curve25519_pkey using
 110    * get_current_curve25519_keypair(), but we don't initialise static data in
 111    * this test. */
 112   router->onion_curve25519_pkey = &ntor_keypair.pubkey;
 113
 114   /* Generate our server descriptor and ensure that the substring
 115    * "bridge-distribution-request any" occurs somewhere within it. */
 116   desc = router_dump_router_to_string(router,
 117                                       ident_key,
 118                                       tap_key,
 119                                       &ntor_keypair,
 120                                       &signing_keypair);
 121   tt_ptr_op(desc, OP_NE, NULL);
 122   found = strstr(desc, needle);
 123   tt_ptr_op(found, OP_NE, NULL);
 124
 125  done:
 126   if (router)
 127     router->onion_curve25519_pkey = NULL; // avoid double-free
 128   routerinfo_free(router);
 129   tor_free(desc);
 130   crypto_pk_free(ident_key);
 131   crypto_pk_free(tap_key);
 132 }
 133
 134 static routerinfo_t *mock_router_get_my_routerinfo_result = NULL;
 135
 136 static const routerinfo_t *
 137 mock_router_get_my_routerinfo(void)
 138 {
 139   return mock_router_get_my_routerinfo_result;
 140 }
 141
 142 static long
 143 mock_get_uptime_3h(void)
 144 {
 145   return 3*60*60;
 146 }
 147
 148 static long
 149 mock_get_uptime_1d(void)
 150 {
 151   return 24*60*60;
 152 }
 153
 154 static int
 155 mock_rep_hist_bandwidth_assess(void)
 156 {
 157   return 20001;
 158 }
 159
 160 static int
 161 mock_we_are_not_hibernating(void)
 162 {
 163   return 0;
 164 }
 165
 166 static int
 167 mock_we_are_hibernating(void)
 168 {
 169   return 0;
 170 }
 171
 172 static void
 173 test_router_check_descriptor_bandwidth_changed(void *arg)
 174 {
 175   (void)arg;
 176   routerinfo_t routerinfo;
 177   memset(&routerinfo, 0, sizeof(routerinfo));
 178   mock_router_get_my_routerinfo_result = NULL;
 179
 180   MOCK(we_are_hibernating, mock_we_are_not_hibernating);
 181   MOCK(router_get_my_routerinfo, mock_router_get_my_routerinfo);
 182   mock_router_get_my_routerinfo_result = &routerinfo;
 183
 184   /* When uptime is less than 24h, no previous bandwidth, no last_changed
 185    * Uptime: 10800, last_changed: 0, Previous bw: 0, Current bw: 0 */
 186   routerinfo.bandwidthcapacity = 0;
 187   MOCK(get_uptime, mock_get_uptime_3h);
 188   setup_full_capture_of_logs(LOG_INFO);
 189   check_descriptor_bandwidth_changed(time(NULL));
 190   expect_log_msg_not_containing(
 191      "Measured bandwidth has changed; rebuilding descriptor.");
 192   teardown_capture_of_logs();
 193
 194   /* When uptime is less than 24h, previous bandwidth,
 195    * last_changed more than 3h ago
 196    * Uptime: 10800, last_changed: 0, Previous bw: 10000, Current bw: 0 */
 197   routerinfo.bandwidthcapacity = 10000;
 198   setup_full_capture_of_logs(LOG_INFO);
 199   check_descriptor_bandwidth_changed(time(NULL));
 200   expect_log_msg_containing(
 201      "Measured bandwidth has changed; rebuilding descriptor.");
 202   teardown_capture_of_logs();
 203
 204   /* When uptime is less than 24h, previous bandwidth,
 205    * last_changed more than 3h ago, and hibernating
 206    * Uptime: 10800, last_changed: 0, Previous bw: 10000, Current bw: 0 */
 207
 208   UNMOCK(we_are_hibernating);
 209   MOCK(we_are_hibernating, mock_we_are_hibernating);
 210   routerinfo.bandwidthcapacity = 10000;
 211   setup_full_capture_of_logs(LOG_INFO);
 212   check_descriptor_bandwidth_changed(time(NULL));
 213   expect_log_msg_not_containing(
 214      "Measured bandwidth has changed; rebuilding descriptor.");
 215   teardown_capture_of_logs();
 216   UNMOCK(we_are_hibernating);
 217   MOCK(we_are_hibernating, mock_we_are_not_hibernating);
 218
 219   /* When uptime is less than 24h, last_changed is not more than 3h ago
 220    * Uptime: 10800, last_changed: x, Previous bw: 10000, Current bw: 0 */
 221   setup_full_capture_of_logs(LOG_INFO);
 222   check_descriptor_bandwidth_changed(time(NULL));
 223   expect_log_msg_not_containing(
 224      "Measured bandwidth has changed; rebuilding descriptor.");
 225   teardown_capture_of_logs();
 226
 227   /* When uptime is less than 24h and bandwidthcapacity does not change
 228    * Uptime: 10800, last_changed: x, Previous bw: 10000, Current bw: 20001 */
 229   MOCK(bwhist_bandwidth_assess, mock_rep_hist_bandwidth_assess);
 230   setup_full_capture_of_logs(LOG_INFO);
 231   check_descriptor_bandwidth_changed(time(NULL) + 6*60*60 + 1);
 232   expect_log_msg_containing(
 233      "Measured bandwidth has changed; rebuilding descriptor.");
 234   UNMOCK(get_uptime);
 235   UNMOCK(bwhist_bandwidth_assess);
 236   teardown_capture_of_logs();
 237
 238   /* When uptime is more than 24h */
 239   MOCK(get_uptime, mock_get_uptime_1d);
 240   setup_full_capture_of_logs(LOG_INFO);
 241   check_descriptor_bandwidth_changed(time(NULL));
 242   expect_log_msg_not_containing(
 243      "Measured bandwidth has changed; rebuilding descriptor.");
 244   teardown_capture_of_logs();
 245
 246  done:
 247   UNMOCK(get_uptime);
 248   UNMOCK(router_get_my_routerinfo);
 249   UNMOCK(we_are_hibernating);
 250 }
 251
 252 static networkstatus_t *mock_ns = NULL;
 253 static networkstatus_t *
 254 mock_networkstatus_get_live_consensus(time_t now)
 255 {
 256   (void)now;
 257   return mock_ns;
 258 }
 259
 260 static routerstatus_t *mock_rs = NULL;
 261 static const routerstatus_t *
 262 mock_networkstatus_vote_find_entry(networkstatus_t *ns, const char *digest)
 263 {
 264   (void)ns;
 265   (void)digest;
 266   return mock_rs;
 267 }
 268
 269 static void
 270 test_router_mark_if_too_old(void *arg)
 271 {
 272   (void)arg;
 273   time_t now = approx_time();
 274   MOCK(networkstatus_get_live_consensus,
 275        mock_networkstatus_get_live_consensus);
 276   MOCK(networkstatus_vote_find_entry, mock_networkstatus_vote_find_entry);
 277
 278   routerstatus_t rs;
 279   networkstatus_t ns;
 280   memset(&rs, 0, sizeof(rs));
 281   memset(&ns, 0, sizeof(ns));
 282   mock_ns = &ns;
 283   mock_ns->valid_after = now-3600;
 284   mock_rs = &rs;
 285
 286   // no reason to mark this time.
 287   desc_clean_since = now-10;
 288   desc_dirty_reason = NULL;
 289   mark_my_descriptor_dirty_if_too_old(now);
 290   tt_i64_op(desc_clean_since, OP_EQ, now-10);
 291
 292   // Doesn't appear in consensus?  Still don't mark it.
 293   mock_ns = NULL;
 294   mark_my_descriptor_dirty_if_too_old(now);
 295   tt_i64_op(desc_clean_since, OP_EQ, now-10);
 296   mock_ns = &ns;
 297
 298   // No new descriptor in a long time?  Mark it.
 299   desc_clean_since = now - 3600 * 96;
 300   mark_my_descriptor_dirty_if_too_old(now);
 301   tt_i64_op(desc_clean_since, OP_EQ, 0);
 302   tt_str_op(desc_dirty_reason, OP_EQ, "time for new descriptor");
 303
 304   desc_clean_since = now - 10;
 305   desc_dirty_reason = NULL;
 306   mark_my_descriptor_dirty_if_too_old(now);
 307   tt_i64_op(desc_clean_since, OP_EQ, now - 10);
 308
 309   // Version in consensus marked as stale?  We'll mark it.
 310   desc_clean_since = now - 2 * 3600;
 311   desc_dirty_reason = NULL;
 312   mock_rs->is_staledesc = 1;
 313   mark_my_descriptor_dirty_if_too_old(now);
 314   tt_i64_op(desc_clean_since, OP_EQ, 0);
 315   tt_str_op(desc_dirty_reason, OP_EQ,
 316             "listed as stale in consensus");
 317
 318   // same deal if we're absent from the consensus.
 319   desc_clean_since = now - 2 * 3600;
 320   desc_dirty_reason = NULL;
 321   mock_rs = NULL;
 322   mark_my_descriptor_dirty_if_too_old(now);
 323   tt_i64_op(desc_clean_since, OP_EQ, 0);
 324   tt_str_op(desc_dirty_reason, OP_EQ,
 325             "not listed in consensus");
 326
 327  done:
 328   UNMOCK(networkstatus_get_live_consensus);
 329   UNMOCK(networkstatus_vote_find_entry);
 330 }
 331
 332 static node_t fake_node;
 333 static const node_t *
 334 mock_node_get_by_nickname(const char *name, unsigned flags)
 335 {
 336   (void)flags;
 337   if (!strcasecmp(name, "crumpet"))
 338     return &fake_node;
 339   else
 340     return NULL;
 341 }
 342
 343 static void
 344 test_router_get_my_family(void *arg)
 345 {
 346   (void)arg;
 347   or_options_t *options = options_new();
 348   smartlist_t *sl = NULL;
 349   char *join = NULL;
 350   // Overwrite the result of router_get_my_identity_digest().  This
 351   // happens to be okay, but only for testing.
 352   set_server_identity_key_digest_testing(
 353                                    (const uint8_t*)"holeinthebottomofthe");
 354
 355   setup_capture_of_logs(LOG_WARN);
 356
 357   // No family listed -- so there's no list.
 358   sl = get_my_declared_family(options);
 359   tt_ptr_op(sl, OP_EQ, NULL);
 360   expect_no_log_entry();
 361
 362 #define CLEAR() do {                                    \
 363     if (sl) {                                           \
 364       SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));  \
 365       smartlist_free(sl);                               \
 366     }                                                   \
 367     tor_free(join);                                     \
 368     mock_clean_saved_logs();                            \
 369   } while (0)
 370
 371   // Add a single nice friendly hex member.  This should be enough
 372   // to have our own ID added.
 373   tt_ptr_op(options->MyFamily, OP_EQ, NULL);
 374   config_line_append(&options->MyFamily, "MyFamily",
 375                      "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
 376
 377   sl = get_my_declared_family(options);
 378   tt_ptr_op(sl, OP_NE, NULL);
 379   tt_int_op(smartlist_len(sl), OP_EQ, 2);
 380   join = smartlist_join_strings(sl, " ", 0, NULL);
 381   tt_str_op(join, OP_EQ,
 382             "$686F6C65696E746865626F74746F6D6F66746865 "
 383             "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
 384   expect_no_log_entry();
 385   CLEAR();
 386
 387   // Add a hex member with a ~.  The ~ part should get removed.
 388   config_line_append(&options->MyFamily, "MyFamily",
 389                      "$0123456789abcdef0123456789abcdef01234567~Muffin");
 390   sl = get_my_declared_family(options);
 391   tt_ptr_op(sl, OP_NE, NULL);
 392   tt_int_op(smartlist_len(sl), OP_EQ, 3);
 393   join = smartlist_join_strings(sl, " ", 0, NULL);
 394   tt_str_op(join, OP_EQ,
 395             "$0123456789ABCDEF0123456789ABCDEF01234567 "
 396             "$686F6C65696E746865626F74746F6D6F66746865 "
 397             "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
 398   expect_no_log_entry();
 399   CLEAR();
 400
 401   // Nickname lookup will fail, so a nickname will appear verbatim.
 402   config_line_append(&options->MyFamily, "MyFamily",
 403                      "BAGEL");
 404   sl = get_my_declared_family(options);
 405   tt_ptr_op(sl, OP_NE, NULL);
 406   tt_int_op(smartlist_len(sl), OP_EQ, 4);
 407   join = smartlist_join_strings(sl, " ", 0, NULL);
 408   tt_str_op(join, OP_EQ,
 409             "$0123456789ABCDEF0123456789ABCDEF01234567 "
 410             "$686F6C65696E746865626F74746F6D6F66746865 "
 411             "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA "
 412             "bagel");
 413   expect_single_log_msg_containing(
 414            "There is a router named \"BAGEL\" in my declared family, but "
 415            "I have no descriptor for it.");
 416   CLEAR();
 417
 418   // A bogus digest should fail entirely.
 419   config_line_append(&options->MyFamily, "MyFamily",
 420                      "$painauchocolat");
 421   sl = get_my_declared_family(options);
 422   tt_ptr_op(sl, OP_NE, NULL);
 423   tt_int_op(smartlist_len(sl), OP_EQ, 4);
 424   join = smartlist_join_strings(sl, " ", 0, NULL);
 425   tt_str_op(join, OP_EQ,
 426             "$0123456789ABCDEF0123456789ABCDEF01234567 "
 427             "$686F6C65696E746865626F74746F6D6F66746865 "
 428             "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA "
 429             "bagel");
 430   // "BAGEL" is still there, but it won't make a warning, because we already
 431   // warned about it.
 432   expect_single_log_msg_containing(
 433            "There is a router named \"$painauchocolat\" in my declared "
 434            "family, but that isn't a legal digest or nickname. Skipping it.");
 435   CLEAR();
 436
 437   // Let's introduce a node we can look up by nickname
 438   memset(&fake_node, 0, sizeof(fake_node));
 439   memcpy(fake_node.identity, "whydoyouasknonononon", DIGEST_LEN);
 440   MOCK(node_get_by_nickname, mock_node_get_by_nickname);
 441
 442   config_line_append(&options->MyFamily, "MyFamily",
 443                      "CRUmpeT");
 444   sl = get_my_declared_family(options);
 445   tt_ptr_op(sl, OP_NE, NULL);
 446   tt_int_op(smartlist_len(sl), OP_EQ, 5);
 447   join = smartlist_join_strings(sl, " ", 0, NULL);
 448   tt_str_op(join, OP_EQ,
 449             "$0123456789ABCDEF0123456789ABCDEF01234567 "
 450             "$686F6C65696E746865626F74746F6D6F66746865 "
 451             "$776879646F796F7561736B6E6F6E6F6E6F6E6F6E "
 452             "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA "
 453             "bagel");
 454   // "BAGEL" is still there, but it won't make a warning, because we already
 455   // warned about it.  Some with "$painauchocolat".
 456   expect_single_log_msg_containing(
 457            "There is a router named \"CRUmpeT\" in my declared "
 458            "family, but it wasn't listed by digest. Please consider saying "
 459            "$776879646F796F7561736B6E6F6E6F6E6F6E6F6E instead, if that's "
 460            "what you meant.");
 461   CLEAR();
 462   UNMOCK(node_get_by_nickname);
 463
 464   // Try a singleton list containing only us: It should give us NULL.
 465   config_free_lines(options->MyFamily);
 466   config_line_append(&options->MyFamily, "MyFamily",
 467                      "$686F6C65696E746865626F74746F6D6F66746865");
 468   sl = get_my_declared_family(options);
 469   tt_ptr_op(sl, OP_EQ, NULL);
 470   expect_no_log_entry();
 471
 472  done:
 473   or_options_free(options);
 474   teardown_capture_of_logs();
 475   CLEAR();
 476   UNMOCK(node_get_by_nickname);
 477
 478 #undef CLEAR
 479 }
 480
 481 static smartlist_t *fake_connection_array = NULL;
 482 static smartlist_t *
 483 mock_get_connection_array(void)
 484 {
 485   return fake_connection_array;
 486 }
 487
 488 static void
 489 test_router_get_advertised_or_port(void *arg)
 490 {
 491   (void)arg;
 492   int r, w=0, n=0;
 493   char *msg=NULL;
 494   or_options_t *opts = options_new();
 495   listener_connection_t *listener = NULL;
 496   tor_addr_port_t ipv6;
 497
 498   // Test one failing case of routerconf_find_ipv6_or_ap().
 499   routerconf_find_ipv6_or_ap(opts, &ipv6);
 500   tt_str_op(fmt_addrport(&ipv6.addr, ipv6.port), OP_EQ, "[::]:0");
 501
 502   // And one failing case of routerconf_find_or_port().
 503   tt_int_op(0, OP_EQ, routerconf_find_or_port(opts, AF_INET));
 504
 505   // Set up a couple of configured ports.
 506   config_line_append(&opts->ORPort_lines, "ORPort", "[1234::5678]:auto");
 507   config_line_append(&opts->ORPort_lines, "ORPort", "5.6.7.8:9999");
 508   r = parse_ports(opts, 0, &msg, &n, &w);
 509   tt_assert(r == 0);
 510
 511   // There are no listeners, so the "auto" case will turn up no results.
 512   tt_int_op(0, OP_EQ, routerconf_find_or_port(opts, AF_INET6));
 513   routerconf_find_ipv6_or_ap(opts, &ipv6);
 514   tt_str_op(fmt_addrport(&ipv6.addr, ipv6.port), OP_EQ, "[::]:0");
 515
 516   // This will return the matching value from the configured port.
 517   tt_int_op(9999, OP_EQ, routerconf_find_or_port(opts, AF_INET));
 518
 519   // Now set up a dummy listener.
 520   MOCK(get_connection_array, mock_get_connection_array);
 521   fake_connection_array = smartlist_new();
 522   listener = listener_connection_new(CONN_TYPE_OR_LISTENER, AF_INET6);
 523   TO_CONN(listener)->port = 54321;
 524   smartlist_add(fake_connection_array, TO_CONN(listener));
 525
 526   // We should get a port this time.
 527   tt_int_op(54321, OP_EQ, routerconf_find_or_port(opts, AF_INET6));
 528
 529   // Test one succeeding case of routerconf_find_ipv6_or_ap().
 530   routerconf_find_ipv6_or_ap(opts, &ipv6);
 531   tt_str_op(fmt_addrport(&ipv6.addr, ipv6.port), OP_EQ,
 532             "[1234::5678]:54321");
 533
 534   // This will return the matching value from the configured port.
 535   tt_int_op(9999, OP_EQ, routerconf_find_or_port(opts, AF_INET));
 536
 537  done:
 538   or_options_free(opts);
 539   config_free_all();
 540   smartlist_free(fake_connection_array);
 541   connection_free_minimal(TO_CONN(listener));
 542   UNMOCK(get_connection_array);
 543 }
 544
 545 static void
 546 test_router_get_advertised_or_port_localhost(void *arg)
 547 {
 548   (void)arg;
 549   int r, w=0, n=0;
 550   char *msg=NULL;
 551   or_options_t *opts = options_new();
 552   tor_addr_port_t ipv6;
 553
 554   // Set up a couple of configured ports on localhost.
 555   config_line_append(&opts->ORPort_lines, "ORPort", "[::1]:9999");
 556   config_line_append(&opts->ORPort_lines, "ORPort", "127.0.0.1:8888");
 557   r = parse_ports(opts, 0, &msg, &n, &w);
 558   tt_assert(r == 0);
 559
 560   // We should refuse to advertise them, since we have default dirauths.
 561   routerconf_find_ipv6_or_ap(opts, &ipv6);
 562   tt_str_op(fmt_addrport(&ipv6.addr, ipv6.port), OP_EQ, "[::]:0");
 563   // But the lower-level function should still report the correct value
 564   tt_int_op(9999, OP_EQ, routerconf_find_or_port(opts, AF_INET6));
 565
 566   // The IPv4 checks are done in resolve_my_address(), which doesn't use
 567   // ORPorts so we can't test them here. (See #33681.) Both these lower-level
 568   // functions should still report the correct value.
 569   tt_int_op(8888, OP_EQ, routerconf_find_or_port(opts, AF_INET));
 570
 571   // Now try with a fake authority set up.
 572   config_line_append(&opts->DirAuthorities, "DirAuthority",
 573                      "127.0.0.1:1066 "
 574                      "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
 575
 576   tt_int_op(9999, OP_EQ, routerconf_find_or_port(opts, AF_INET6));
 577   routerconf_find_ipv6_or_ap(opts, &ipv6);
 578   tt_str_op(fmt_addrport(&ipv6.addr, ipv6.port), OP_EQ, "[::1]:9999");
 579
 580   tt_int_op(8888, OP_EQ, routerconf_find_or_port(opts, AF_INET));
 581
 582  done:
 583   or_options_free(opts);
 584   config_free_all();
 585 }
 586
 587 #define ROUTER_TEST(name, flags)                          \
 588   { #name, test_router_ ## name, flags, NULL, NULL }
 589
 590 struct testcase_t router_tests[] = {
 591   ROUTER_TEST(check_descriptor_bandwidth_changed, TT_FORK),
 592   ROUTER_TEST(dump_router_to_string_no_bridge_distribution_method, TT_FORK),
 593   ROUTER_TEST(mark_if_too_old, TT_FORK),
 594   ROUTER_TEST(get_my_family, TT_FORK),
 595   ROUTER_TEST(get_advertised_or_port, TT_FORK),
 596   ROUTER_TEST(get_advertised_or_port_localhost, TT_FORK),
 597   END_OF_TESTCASES
 598 };