src/test/test_bridges.c

   1 /* Copyright (c) 2018, The Tor Project, Inc. */
   2 /* See LICENSE for licensing information     */
   3
   4 /**
   5  * \file test_bridges.c
   6  * \brief Unittests for code in bridges.c
   7  **/
   8
   9 #define TOR_BRIDGES_PRIVATE
  10 #define PT_PRIVATE /* Only needed for the mock_* items below */
  11
  12 #include <stdbool.h>
  13
  14 #include "core/or/or.h"
  15 #include "lib/net/address.h"
  16 #include "feature/client/bridges.h"
  17 #include "app/config/config.h"
  18 #include "feature/client/transports.h"
  19 #include "feature/nodelist/node_st.h"
  20 #include "feature/nodelist/routerinfo_st.h"
  21 #include "feature/nodelist/routerstatus_st.h"
  22 #include "feature/nodelist/microdesc_st.h"
  23
  24 /* Test suite stuff */
  25 #include "test/test.h"
  26
  27 /**
  28  * A mocked transport_t, constructed via mock_transport_get_by_name().
  29  */
  30 static transport_t *mock_transport = NULL;
  31
  32 /**
  33  * Mock transport_get_by_name() to simply return a transport_t for the
  34  * transport name that was input to it.
  35  */
  36 static transport_t *
  37 mock_transport_get_by_name(const char *name)
  38 {
  39   tor_addr_t *addr = tor_malloc(sizeof(tor_addr_t));
  40   uint16_t port = 9999;
  41   int socksv = 9;
  42   char *args = tor_strdup("foo=bar");
  43
  44   if (!mock_transport) {
  45     tor_addr_parse(addr, "99.99.99.99");
  46     mock_transport = transport_new(addr, port, name, socksv, args);
  47   }
  48
  49   tor_free(addr);
  50   tor_free(args);
  51
  52   return mock_transport;
  53 }
  54
  55 #undef PT_PRIVATE /* defined(PT_PRIVATE) */
  56
  57 /**
  58  * Test helper: Add a variety of bridges to our global bridgelist.
  59  */
  60 static void
  61 helper_add_bridges_to_bridgelist(void *arg)
  62 {
  63   /* Note: the two bridges which do not have specified fingerprints will be
  64    * internally stored as both having the same fingerprint of all-zero bytes.
  65    */
  66
  67   (void)arg;
  68   char *bridge0 = tor_strdup("6.6.6.6:6666");
  69   char *bridge1 = tor_strdup("6.6.6.7:6667 "
  70                              "A10C4F666D27364036B562823E5830BC448E046A");
  71   char *bridge2 = tor_strdup("obfs4 198.245.60.51:443 "
  72                              "752CF7825B3B9EA6A98C83AC41F7099D67007EA5 "
  73                   "cert=xpmQtKUqQ/6v5X7ijgYE/f03+l2/EuQ1dexjyUhh16wQlu/"
  74                              "cpXUGalmhDIlhuiQPNEKmKw iat-mode=0");
  75   char *bridge3 = tor_strdup("banana 5.5.5.5:5555 "
  76                              "9D6AE1BD4FDF39721CE908966E79E16F9BFCCF2F");
  77   char *bridge4 = tor_strdup("obfs4 1.2.3.4:1234 "
  78                              "foo=abcdefghijklmnopqrstuvwxyz");
  79   char *bridge5 = tor_strdup("apple 4.4.4.4:4444 "
  80                              "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA "
  81                              "foo=abcdefghijklmnopqrstuvwxyz");
  82   char *bridge6 = tor_strdup("[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:6666");
  83
  84   mark_bridge_list();
  85
  86 #define ADD_BRIDGE(bridge)                                          \
  87   bridge_line_t *bridge_line_ ##bridge = parse_bridge_line(bridge); \
  88   if (!bridge_line_ ##bridge) {                                     \
  89     printf("Unparseable bridge line: '%s'", #bridge);               \
  90   } else {                                                          \
  91     bridge_add_from_config(bridge_line_ ##bridge);                  \
  92   }                                                                 \
  93   tor_free(bridge);
  94
  95   ADD_BRIDGE(bridge0);
  96   ADD_BRIDGE(bridge1);
  97   ADD_BRIDGE(bridge2);
  98   ADD_BRIDGE(bridge3);
  99   ADD_BRIDGE(bridge4);
 100   ADD_BRIDGE(bridge5);
 101   ADD_BRIDGE(bridge6);
 102 #undef ADD_BRIDGES
 103
 104   sweep_bridge_list();
 105 }
 106
 107 /**
 108  * Make sure our test helper works too.
 109  */
 110 static void
 111 test_bridges_helper_func_add_bridges_to_bridgelist(void *arg)
 112 {
 113   helper_add_bridges_to_bridgelist(arg);
 114   tt_finished();
 115
 116  done:
 117   mark_bridge_list();
 118   sweep_bridge_list();
 119 }
 120
 121 /**
 122  * Calling bridge_list_get() should create a new bridgelist if we
 123  * didn't have one before.
 124  */
 125 static void
 126 test_bridges_bridge_list_get_creates_new_bridgelist(void *arg)
 127 {
 128   const smartlist_t *bridgelist = bridge_list_get();
 129
 130   (void)arg;
 131
 132   tt_ptr_op(bridgelist, OP_NE, NULL);
 133
 134  done:
 135   return;
 136 }
 137
 138 /**
 139  * Calling clear_bridge_list() should remove all bridges from the bridgelist.
 140  */
 141 static void
 142 test_bridges_clear_bridge_list(void *arg)
 143 {
 144   const smartlist_t *bridgelist;
 145   const smartlist_t *bridgelist_after;
 146   const bridge_info_t *bridge;
 147
 148   helper_add_bridges_to_bridgelist(arg);
 149   bridgelist = bridge_list_get();
 150   tt_ptr_op(bridgelist, OP_NE, NULL);
 151
 152   bridge = smartlist_get(bridgelist, 0);
 153   tt_ptr_op(bridge, OP_NE, NULL);
 154
 155   clear_bridge_list();
 156   bridgelist_after = bridge_list_get();
 157   tt_ptr_op(bridgelist_after, OP_NE, NULL);
 158   tt_int_op(smartlist_len(bridgelist_after), OP_EQ, 0);
 159
 160  done:
 161   return;
 162 }
 163
 164 /**
 165  * Calling bridge_get_addrport() should give me the address and port
 166  * of the bridge.  In this case, we sort the smartlist of bridges on
 167  * fingerprints and choose the first one.
 168  */
 169 static void
 170 test_bridges_bridge_get_addrport(void *arg)
 171 {
 172   smartlist_t *bridgelist;
 173   const bridge_info_t *bridge;
 174   const tor_addr_port_t *addrport;
 175
 176   helper_add_bridges_to_bridgelist(arg);
 177   bridgelist = (smartlist_t*)bridge_list_get();
 178   tt_ptr_op(bridgelist, OP_NE, NULL);
 179
 180   // This should be the bridge at 6.6.6.6:6666 with fingerprint
 181   // 0000000000000000000000000000000000000000
 182   bridge = smartlist_get(bridgelist, 0);
 183   tt_ptr_op(bridge, OP_NE, NULL);
 184
 185   addrport = bridge_get_addr_port(bridge);
 186   tt_int_op(addrport->port, OP_EQ, 6666);
 187
 188  done:
 189   mark_bridge_list();
 190   sweep_bridge_list();
 191 }
 192
 193 /**
 194  * Calling get_configured_bridge_by_orports_digest() with two
 195  * configured bridge orports and an invalid digest should return the
 196  * bridge of the first addrport in the list.
 197  */
 198 static void
 199 test_bridges_get_configured_bridge_by_orports_digest(void *arg)
 200 {
 201   smartlist_t *orports = NULL;
 202   const smartlist_t *bridgelist;
 203   const bridge_info_t *bridge1;
 204   const bridge_info_t *bridge2;
 205   const bridge_info_t *ret;
 206   tor_addr_port_t *addrport1;
 207   tor_addr_port_t *addrport2;
 208   const char *digest;
 209
 210   helper_add_bridges_to_bridgelist(arg);
 211   bridgelist = bridge_list_get();
 212   tt_ptr_op(bridgelist, OP_NE, NULL);
 213
 214   // This should be the bridge at 6.6.6.6:6666 with fingerprint
 215   // 0000000000000000000000000000000000000000
 216   bridge1 = smartlist_get(bridgelist, 0);
 217   tt_ptr_op(bridge1, OP_NE, NULL);
 218   // This should be the bridge at 6.6.6.7:6667 with fingerprint
 219   // A10C4F666D27364036B562823E5830BC448E046A
 220   bridge2 = smartlist_get(bridgelist, 1);
 221   tt_ptr_op(bridge2, OP_NE, NULL);
 222
 223   addrport1 = (tor_addr_port_t*)bridge_get_addr_port(bridge1);
 224   tt_int_op(addrport1->port, OP_EQ, 6666);
 225   addrport2 = (tor_addr_port_t*)bridge_get_addr_port(bridge2);
 226   tt_int_op(addrport2->port, OP_EQ, 6667);
 227
 228   orports = smartlist_new();
 229   smartlist_add(orports, addrport1);
 230   smartlist_add(orports, addrport2);
 231
 232   digest = "zzzzzzzzzzzzzzzz";
 233
 234   ret = get_configured_bridge_by_orports_digest(digest, orports);
 235   tt_ptr_op(ret, OP_NE, NULL);
 236
 237   tt_assert(tor_addr_port_eq(addrport1, bridge_get_addr_port(ret)));
 238
 239  done:
 240   smartlist_free(orports);
 241
 242   mark_bridge_list();
 243   sweep_bridge_list();
 244 }
 245
 246 /**
 247  * Calling get_configured_bridge_by_addr_port_digest() with a digest that we do
 248  * have and an addr:port pair we don't should return the bridge for that
 249  * digest.
 250  */
 251 static void
 252 test_bridges_get_configured_bridge_by_addr_port_digest_digest_only(void *arg)
 253 {
 254   char digest[DIGEST_LEN];
 255   bridge_info_t *bridge;
 256   const char fingerprint[HEX_DIGEST_LEN] =
 257     "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 258   tor_addr_t *addr = tor_malloc(sizeof(tor_addr_t));
 259   char ret_addr[16];
 260   uint16_t port = 11111;
 261   int ret;
 262
 263   helper_add_bridges_to_bridgelist(arg);
 264
 265   // We don't actually have a bridge with this addr:port pair
 266   base16_decode(digest, DIGEST_LEN, fingerprint, HEX_DIGEST_LEN);
 267   ret = tor_addr_parse(addr, "111.111.111.111");
 268   tt_int_op(ret, OP_EQ, 2); // it returns the address family on success
 269
 270   bridge = get_configured_bridge_by_addr_port_digest(addr, port, digest);
 271   tt_ptr_op(bridge, OP_NE, NULL);
 272
 273   tor_addr_to_str(ret_addr, &bridge_get_addr_port(bridge)->addr, 16, 0);
 274   tt_str_op("4.4.4.4", OP_EQ, ret_addr);
 275
 276  done:
 277   tor_free(addr);
 278
 279   mark_bridge_list();
 280   sweep_bridge_list();
 281 }
 282
 283 /**
 284  * Calling get_configured_bridge_by_addr_port_digest() with only an
 285  * addr:port (i.e. digest set to NULL) should return the bridge for
 286  * that digest when there is such a bridge.
 287  */
 288 static void
 289 test_bridges_get_configured_bridge_by_addr_port_digest_address_only(void *arg)
 290 {
 291   bridge_info_t *bridge;
 292   tor_addr_t *addr = tor_malloc(sizeof(tor_addr_t));
 293   char ret_addr[16];
 294   uint16_t port = 6666;
 295   int ret;
 296
 297   helper_add_bridges_to_bridgelist(arg);
 298
 299   ret = tor_addr_parse(addr, "6.6.6.6");
 300   tt_int_op(ret, OP_EQ, 2); // it returns the address family on success
 301
 302   bridge = get_configured_bridge_by_addr_port_digest(addr, port, NULL);
 303   tt_ptr_op(bridge, OP_NE, NULL);
 304
 305   tor_addr_to_str(ret_addr, &bridge_get_addr_port(bridge)->addr, 16, 0);
 306   tt_str_op("6.6.6.6", OP_EQ, ret_addr);
 307
 308  done:
 309   tor_free(addr);
 310
 311   mark_bridge_list();
 312   sweep_bridge_list();
 313 }
 314
 315 /**
 316  * Calling get_configured_bridge_by_exact_addr_port_digest() with a digest that
 317  * we do have, and an addr:port pair we don't have, should return NULL.
 318  */
 319 static void
 320 test_bridges_get_configured_bridge_by_exact_addr_port_digest_donly(void *arg)
 321 {
 322   char digest[DIGEST_LEN];
 323   bridge_info_t *bridge;
 324   const char fingerprint[HEX_DIGEST_LEN] =
 325     "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 326   tor_addr_t *addr = tor_malloc(sizeof(tor_addr_t));
 327   uint16_t port = 11111;
 328   int ret;
 329
 330   helper_add_bridges_to_bridgelist(arg);
 331
 332   // We don't actually have a bridge with this addr:port pair
 333   base16_decode(digest, DIGEST_LEN, fingerprint, HEX_DIGEST_LEN);
 334   ret = tor_addr_parse(addr, "111.111.111.111");
 335   tt_int_op(ret, OP_EQ, 2); // it returns the address family on success
 336
 337   bridge = get_configured_bridge_by_exact_addr_port_digest(addr, port, digest);
 338   tt_ptr_op(bridge, OP_EQ, NULL);
 339
 340  done:
 341   tor_free(addr);
 342
 343   mark_bridge_list();
 344   sweep_bridge_list();
 345 }
 346
 347 /**
 348  * Calling get_configured_bridge_by_exact_addr_port_digest() with a digest that
 349  * we do have, and an addr:port pair we do have, should return the bridge.
 350  */
 351 static void
 352 test_bridges_get_configured_bridge_by_exact_addr_port_digest_both(void *arg)
 353 {
 354   char digest[DIGEST_LEN];
 355   bridge_info_t *bridge;
 356   const char fingerprint[HEX_DIGEST_LEN] =
 357     "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 358   tor_addr_t *addr = tor_malloc(sizeof(tor_addr_t));
 359   uint16_t port = 4444;
 360   char ret_addr[16];
 361   int ret;
 362
 363   helper_add_bridges_to_bridgelist(arg);
 364
 365   base16_decode(digest, DIGEST_LEN, fingerprint, HEX_DIGEST_LEN);
 366   ret = tor_addr_parse(addr, "4.4.4.4");
 367   tt_int_op(ret, OP_EQ, 2); // it returns the address family on success
 368
 369   bridge = get_configured_bridge_by_exact_addr_port_digest(addr, port, digest);
 370   tt_ptr_op(bridge, OP_NE, NULL);
 371
 372   tor_addr_to_str(ret_addr, &bridge_get_addr_port(bridge)->addr, 16, 0);
 373   tt_str_op("4.4.4.4", OP_EQ, ret_addr);
 374
 375  done:
 376   tor_free(addr);
 377
 378   mark_bridge_list();
 379   sweep_bridge_list();
 380 }
 381
 382 /**
 383  * Calling get_configured_bridge_by_exact_addr_port_digest() with no digest,
 384  * and an addr:port pair we do have, should return the bridge.
 385  */
 386 static void
 387 test_bridges_get_configured_bridge_by_exact_addr_port_digest_aonly(void *arg)
 388 {
 389   bridge_info_t *bridge;
 390   tor_addr_t *addr = tor_malloc(sizeof(tor_addr_t));
 391   uint16_t port = 4444;
 392   char ret_addr[16];
 393   int ret;
 394
 395   helper_add_bridges_to_bridgelist(arg);
 396
 397   ret = tor_addr_parse(addr, "4.4.4.4");
 398   tt_int_op(ret, OP_EQ, 2); // it returns the address family on success
 399
 400   bridge = get_configured_bridge_by_exact_addr_port_digest(addr, port, NULL);
 401   tt_ptr_op(bridge, OP_NE, NULL);
 402
 403   tor_addr_to_str(ret_addr, &bridge_get_addr_port(bridge)->addr, 16, 0);
 404   tt_str_op("4.4.4.4", OP_EQ, ret_addr);
 405
 406  done:
 407   tor_free(addr);
 408
 409   mark_bridge_list();
 410   sweep_bridge_list();
 411 }
 412
 413 /**
 414  * Calling find_bridge_by_digest() when we have a bridge with a known
 415  * identity digest should return the bridge's information.
 416  */
 417 static void
 418 test_bridges_find_bridge_by_digest_known(void *arg)
 419 {
 420   char digest1[DIGEST_LEN];
 421   bridge_info_t *bridge;
 422   const char fingerprint[HEX_DIGEST_LEN] =
 423     "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 424
 425   helper_add_bridges_to_bridgelist(arg);
 426
 427   base16_decode(digest1, DIGEST_LEN, fingerprint, HEX_DIGEST_LEN);
 428   bridge = find_bridge_by_digest(digest1);
 429
 430   tt_ptr_op(bridge, OP_NE, NULL);
 431
 432   /* We have to call bridge_get_rsa_id_digest() here because the bridge_info_t
 433    * struct is opaquely defined in bridges.h. */
 434   const uint8_t *digest2 = bridge_get_rsa_id_digest(bridge);
 435
 436   tt_mem_op((char*)digest2, OP_EQ, digest1, DIGEST_LEN);
 437
 438  done:
 439   mark_bridge_list();
 440   sweep_bridge_list();
 441 }
 442
 443 /**
 444  * Calling find_bridge_by_digest() when we do NOT have a bridge with that
 445  * identity digest should return NULL.
 446  */
 447 static void
 448 test_bridges_find_bridge_by_digest_unknown(void *arg)
 449 {
 450   const char *fingerprint = "cccccccccccccccccccccccccccccccccccccccc";
 451   bridge_info_t *bridge;
 452
 453   helper_add_bridges_to_bridgelist(arg);
 454
 455   bridge = find_bridge_by_digest(fingerprint);
 456
 457   tt_ptr_op(bridge, OP_EQ, NULL);
 458
 459  done:
 460   mark_bridge_list();
 461   sweep_bridge_list();
 462 }
 463
 464 /**
 465  * Calling bridge_resolve_conflicts() with an identical bridge to one we've
 466  * already configure should mark the pre-configured bridge for removal.
 467  */
 468 static void
 469 test_bridges_bridge_resolve_conflicts(void *arg)
 470 {
 471   tor_addr_t *addr = tor_malloc(sizeof(tor_addr_t));
 472   uint16_t port = 4444;
 473   const char *digest = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
 474   const char *transport = "apple";
 475   int ret;
 476
 477   helper_add_bridges_to_bridgelist(arg);
 478
 479   ret = tor_addr_parse(addr, "4.4.4.4");
 480   tt_int_op(ret, OP_EQ, 2); // it returns the address family on success
 481
 482   bridge_resolve_conflicts((const tor_addr_t*)addr, port, digest, transport);
 483
 484   /* The bridge should now be marked for removal, and removed when we sweep the
 485    * bridge_list */
 486   sweep_bridge_list();
 487   ret = addr_is_a_configured_bridge((const tor_addr_t*)addr, port, digest);
 488   tt_int_op(ret, OP_EQ, 0);
 489
 490  done:
 491   tor_free(addr);
 492
 493   mark_bridge_list();
 494   sweep_bridge_list();
 495 }
 496
 497 /**
 498  * Calling transport_is_needed() with a transport we do need ("obfs4") and a
 499  * bogus transport that we don't need should return 1 and 0, respectively.
 500  */
 501 static void
 502 test_bridges_transport_is_needed(void *arg)
 503 {
 504   int ret;
 505
 506   helper_add_bridges_to_bridgelist(arg);
 507
 508   ret = transport_is_needed("obfs4");
 509   tt_int_op(ret, OP_EQ, 1);
 510
 511   ret = transport_is_needed("apowefjaoewpaief");
 512   tt_int_op(ret, OP_EQ, 0);
 513
 514  done:
 515   mark_bridge_list();
 516   sweep_bridge_list();
 517 }
 518
 519 /**
 520  * Calling get_transport_by_bridge_addrport() with the address and port of a
 521  * configured bridge which uses a pluggable transport when there is no global
 522  * transport_list should return -1 and the transport_t should be NULL.
 523  */
 524 static void
 525 test_bridges_get_transport_by_bridge_addrport_no_ptlist(void *arg)
 526 {
 527   transport_t *transport = NULL;
 528   tor_addr_t *addr = tor_malloc(sizeof(tor_addr_t));
 529   uint16_t port = 1234;
 530   int ret;
 531
 532   helper_add_bridges_to_bridgelist(arg);
 533
 534   ret = tor_addr_parse(addr, "1.2.3.4");
 535   tt_int_op(ret, OP_EQ, 2); // it returns the address family on success?
 536
 537   /* This will fail because the global transport_list has nothing in it, and so
 538    * transport_get_by_name() has nothing to return, even the the bridge *did*
 539    * say it had an obfs4 transport.
 540    */
 541   ret = get_transport_by_bridge_addrport((const tor_addr_t*)addr, port,
 542                                          (const transport_t**)&transport);
 543   tt_int_op(ret, OP_EQ, -1); // returns -1 on failure
 544   tt_ptr_op(transport, OP_EQ, NULL);
 545
 546  done:
 547   tor_free(addr);
 548
 549   mark_bridge_list();
 550   sweep_bridge_list();
 551 }
 552
 553 #define PT_PRIVATE
 554
 555 /**
 556  * Calling get_transport_by_bridge_addrport() with the address and port of a
 557  * configured bridge which uses a pluggable transport should return 0 and set
 558  * appropriate transport_t.
 559  */
 560 static void
 561 test_bridges_get_transport_by_bridge_addrport(void *arg)
 562 {
 563   transport_t *transport = NULL;
 564   tor_addr_t *addr = tor_malloc(sizeof(tor_addr_t));
 565   uint16_t port = 1234;
 566   int ret;
 567
 568   helper_add_bridges_to_bridgelist(arg);
 569   mark_transport_list(); // Also initialise our transport_list
 570
 571   ret = tor_addr_parse(addr, "1.2.3.4");
 572   tt_int_op(ret, OP_EQ, 2); // it returns the address family on success?
 573
 574   /* After we mock transport_get_by_name() to return a bogus transport_t with
 575    * the name it was asked for, the call should succeed.
 576    */
 577   MOCK(transport_get_by_name, mock_transport_get_by_name);
 578   ret = get_transport_by_bridge_addrport((const tor_addr_t*)addr, port,
 579                                          (const transport_t**)&transport);
 580   tt_int_op(ret, OP_EQ, 0); // returns 0 on success
 581   tt_ptr_op(transport, OP_NE, NULL);
 582   tt_str_op(transport->name, OP_EQ, "obfs4");
 583
 584  done:
 585   UNMOCK(transport_get_by_name);
 586
 587   tor_free(addr);
 588   transport_free(transport);
 589
 590   mark_bridge_list();
 591   sweep_bridge_list();
 592 }
 593
 594 static void
 595 test_bridges_node_is_a_configured_bridge(void *arg)
 596 {
 597   routerinfo_t ri_ipv4 = { .addr = 0x06060606, .or_port = 6666 };
 598   routerstatus_t rs_ipv4 = { .addr = 0x06060606, .or_port = 6666 };
 599
 600   routerinfo_t ri_ipv6 = { .ipv6_orport = 6666 };
 601   tor_addr_parse(&(ri_ipv6.ipv6_addr),
 602                  "2001:0db8:85a3:0000:0000:8a2e:0370:7334");
 603
 604   routerstatus_t rs_ipv6 = { .ipv6_orport = 6666 };
 605   tor_addr_parse(&(rs_ipv6.ipv6_addr),
 606                  "2001:0db8:85a3:0000:0000:8a2e:0370:7334");
 607
 608   microdesc_t md_ipv6 = { .ipv6_orport = 6666 };
 609   tor_addr_parse(&(md_ipv6.ipv6_addr),
 610                  "2001:0db8:85a3:0000:0000:8a2e:0370:7334");
 611
 612   helper_add_bridges_to_bridgelist(arg);
 613
 614   node_t node_with_digest;
 615   memset(&node_with_digest, 0, sizeof(node_with_digest));
 616
 617   const char fingerprint[HEX_DIGEST_LEN] =
 618     "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 619
 620   const char fingerprint2[HEX_DIGEST_LEN] =
 621     "ffffffffffffffffffffffffffffffffffffffff";
 622
 623   base16_decode(node_with_digest.identity, DIGEST_LEN,
 624                 fingerprint, HEX_DIGEST_LEN);
 625
 626   node_t node_ri_ipv4 = { .ri = &ri_ipv4 };
 627   base16_decode(node_ri_ipv4.identity, DIGEST_LEN,
 628                 fingerprint2, HEX_DIGEST_LEN);
 629   tt_assert(node_is_a_configured_bridge(&node_ri_ipv4));
 630
 631   /* This will still match bridge0, since bridge0 has no digest set. */
 632   memset(node_ri_ipv4.identity, 0x3f, DIGEST_LEN);
 633   tt_assert(node_is_a_configured_bridge(&node_ri_ipv4));
 634
 635   /* It won't match bridge1, though, since bridge1 has a digest, and this
 636      isn't it! */
 637   node_ri_ipv4.ri->addr = 0x06060607;
 638   node_ri_ipv4.ri->or_port = 6667;
 639   tt_assert(! node_is_a_configured_bridge(&node_ri_ipv4));
 640   /* If we set the fingerprint right, though, it will match. */
 641   base16_decode(node_ri_ipv4.identity, DIGEST_LEN,
 642                 "A10C4F666D27364036B562823E5830BC448E046A", HEX_DIGEST_LEN);
 643   tt_assert(node_is_a_configured_bridge(&node_ri_ipv4));
 644
 645   node_t node_rs_ipv4 = { .rs = &rs_ipv4 };
 646   base16_decode(node_rs_ipv4.identity, DIGEST_LEN,
 647                 fingerprint2, HEX_DIGEST_LEN);
 648   tt_assert(node_is_a_configured_bridge(&node_rs_ipv4));
 649
 650   node_t node_ri_ipv6 = { .ri = &ri_ipv6 };
 651   base16_decode(node_ri_ipv6.identity, DIGEST_LEN,
 652                 fingerprint2, HEX_DIGEST_LEN);
 653   tt_assert(node_is_a_configured_bridge(&node_ri_ipv6));
 654
 655   node_t node_rs_ipv6 = { .rs = &rs_ipv6 };
 656   base16_decode(node_rs_ipv6.identity, DIGEST_LEN,
 657                 fingerprint2, HEX_DIGEST_LEN);
 658   tt_assert(node_is_a_configured_bridge(&node_rs_ipv6));
 659
 660   node_t node_md_ipv6 = { .md = &md_ipv6 };
 661   base16_decode(node_md_ipv6.identity, DIGEST_LEN,
 662                 fingerprint2, HEX_DIGEST_LEN);
 663   tt_assert(node_is_a_configured_bridge(&node_md_ipv6));
 664
 665   mark_bridge_list();
 666   sweep_bridge_list();
 667
 668   tt_assert(!node_is_a_configured_bridge(&node_with_digest));
 669   tt_assert(!node_is_a_configured_bridge(&node_ri_ipv4));
 670   tt_assert(!node_is_a_configured_bridge(&node_ri_ipv6));
 671   tt_assert(!node_is_a_configured_bridge(&node_rs_ipv4));
 672   tt_assert(!node_is_a_configured_bridge(&node_rs_ipv6));
 673   tt_assert(!node_is_a_configured_bridge(&node_md_ipv6));
 674
 675  done:
 676   mark_bridge_list();
 677   sweep_bridge_list();
 678 }
 679
 680 #undef PT_PRIVATE /* defined(PT_PRIVATE) */
 681
 682 #define B_TEST(name, flags) \
 683   { #name, test_bridges_ ##name, (flags), NULL, NULL }
 684
 685 struct testcase_t bridges_tests[] = {
 686   B_TEST(helper_func_add_bridges_to_bridgelist, 0),
 687   B_TEST(bridge_list_get_creates_new_bridgelist, 0),
 688   B_TEST(clear_bridge_list, 0),
 689   B_TEST(bridge_get_addrport, 0),
 690   B_TEST(get_configured_bridge_by_orports_digest, 0),
 691   B_TEST(get_configured_bridge_by_addr_port_digest_digest_only, 0),
 692   B_TEST(get_configured_bridge_by_addr_port_digest_address_only, 0),
 693   B_TEST(get_configured_bridge_by_exact_addr_port_digest_donly, 0),
 694   B_TEST(get_configured_bridge_by_exact_addr_port_digest_both, 0),
 695   B_TEST(get_configured_bridge_by_exact_addr_port_digest_aonly, 0),
 696   B_TEST(find_bridge_by_digest_known, 0),
 697   B_TEST(find_bridge_by_digest_unknown, 0),
 698   B_TEST(bridge_resolve_conflicts, 0),
 699   B_TEST(get_transport_by_bridge_addrport_no_ptlist, 0),
 700   B_TEST(get_transport_by_bridge_addrport, 0),
 701   B_TEST(transport_is_needed, 0),
 702   B_TEST(node_is_a_configured_bridge, 0),
 703   END_OF_TESTCASES
 704 };