test_dirvote.c (24524B)
1 /* Copyright (c) 2020-2021, The Tor Project, Inc. */ 2 /* See LICENSE for licensing information */ 3 4 /** 5 * \file test_dirvote.c 6 * \brief Unit tests for dirvote related functions 7 */ 8 #define DIRVOTE_PRIVATE 9 10 #include "core/or/or.h" 11 #include "feature/dirauth/dirvote.h" 12 #include "feature/nodelist/dirlist.h" 13 #include "feature/nodelist/node_st.h" 14 #include "feature/nodelist/nodelist.h" 15 #include "feature/nodelist/routerinfo_st.h" 16 #include "feature/nodelist/signed_descriptor_st.h" 17 18 #include "test/test.h" 19 20 /** 21 * This struct holds the various information that are needed for router 22 * comparison. Each router in the test function has one, and they are all 23 * put in a global digestmap, router_properties 24 */ 25 typedef struct router_values_t { 26 int is_running; 27 int is_auth; 28 int bw_kb; 29 char digest[DIGEST_LEN]; 30 } router_values_t; 31 /** 32 * This typedef makes declaring digests easier and less verbose 33 */ 34 typedef char sha1_digest_t[DIGEST_LEN]; 35 36 // Use of global variable is justified because the functions that have to be 37 // mocked take as arguments objects we have no control over 38 static digestmap_t *router_properties = NULL; 39 // Use of global variable is justified by its use in nodelist.c 40 // and is necessary to avoid memory leaks when mocking the 41 // function node_get_by_id 42 static node_t *running_node; 43 static node_t *non_running_node; 44 45 /* Allocate memory to the global variables that represent a running 46 * and non-running node 47 */ 48 #define ALLOCATE_MOCK_NODES() \ 49 running_node = tor_malloc(sizeof(node_t)); \ 50 running_node->is_running = 1; \ 51 non_running_node = tor_malloc(sizeof(node_t)); \ 52 non_running_node->is_running = 0; 53 54 /* Free the memory allocated to the mock nodes */ 55 #define FREE_MOCK_NODES() \ 56 tor_free(running_node); \ 57 tor_free(non_running_node); 58 59 static int 60 mock_router_digest_is_trusted(const char *digest, dirinfo_type_t type) 61 { 62 (void)type; 63 router_values_t *mock_status; 64 mock_status = digestmap_get(router_properties, digest); 65 if (!mock_status) { 66 return -1; 67 } 68 return mock_status->is_auth; 69 } 70 71 static const node_t * 72 mock_node_get_by_id(const char *identity_digest) 73 { 74 router_values_t *status; 75 status = digestmap_get(router_properties, identity_digest); 76 if (!status) { 77 return NULL; 78 } 79 if (status->is_running) 80 return running_node; 81 else 82 return non_running_node; 83 } 84 85 static uint32_t 86 mock_dirserv_get_bw(const routerinfo_t *ri) 87 { 88 const char *digest = ri->cache_info.identity_digest; 89 router_values_t *status; 90 status = digestmap_get(router_properties, digest); 91 if (!status) { 92 return -1; 93 } 94 return status->bw_kb; 95 } 96 97 /** Generate a pointer to a router_values_t struct with the arguments as 98 * field values, and return it 99 * The returned pointer has to be freed by the caller. 100 */ 101 static router_values_t * 102 router_values_new(int running, int auth, int bw, char *digest) 103 { 104 router_values_t *status = tor_malloc(sizeof(router_values_t)); 105 memcpy(status->digest, digest, sizeof(status->digest)); 106 status->is_running = running; 107 status->bw_kb = bw; 108 status->is_auth = auth; 109 return status; 110 } 111 112 /** Given a router_values_t struct, generate a pointer to a routerinfo struct. 113 * In the cache_info member, put the identity digest, and depending on 114 * the family argument, fill the IPv4 or IPv6 address. Return the pointer. 115 * The returned pointer has to be freed by the caller. 116 */ 117 static routerinfo_t * 118 routerinfo_new(router_values_t *status, int family, int addr) 119 { 120 routerinfo_t *ri = tor_malloc(sizeof(routerinfo_t)); 121 signed_descriptor_t cache_info; 122 memcpy(cache_info.identity_digest, status->digest, 123 sizeof(cache_info.identity_digest)); 124 ri->cache_info = cache_info; 125 tor_addr_t ipv6, ipv4; 126 ipv6.family = family; 127 ipv4.family = family; 128 // Set the address of the other IP version to 0 129 if (family == AF_INET) { 130 ipv4.addr.in_addr.s_addr = addr; 131 for (size_t i = 0; i < 16; i++) { 132 ipv6.addr.in6_addr.s6_addr[i] = 0; 133 } 134 } else { 135 for (size_t i = 0; i < 16; i++) { 136 ipv6.addr.in6_addr.s6_addr[i] = addr; 137 } 138 ipv4.addr.in_addr.s_addr = 0; 139 } 140 ri->ipv6_addr = ipv6; 141 ri->ipv4_addr = ipv4; 142 return ri; 143 } 144 145 static void 146 test_dirvote_compare_routerinfo_usefulness(void *arg) 147 { 148 (void)arg; 149 MOCK(router_digest_is_trusted_dir_type, mock_router_digest_is_trusted); 150 MOCK(node_get_by_id, mock_node_get_by_id); 151 MOCK(dirserv_get_bandwidth_for_router_kb, mock_dirserv_get_bw); 152 ALLOCATE_MOCK_NODES(); 153 router_properties = digestmap_new(); 154 155 // The router one is the "least useful" router, every router is compared to 156 // it 157 sha1_digest_t digest_one = "aaaa"; 158 router_values_t *status_one = router_values_new(0, 0, 0, digest_one); 159 digestmap_set(router_properties, status_one->digest, status_one); 160 sha1_digest_t digest_two = "bbbb"; 161 router_values_t *status_two = router_values_new(0, 1, 0, digest_two); 162 digestmap_set(router_properties, status_two->digest, status_two); 163 sha1_digest_t digest_three = "cccc"; 164 router_values_t *status_three = router_values_new(1, 0, 0, digest_three); 165 digestmap_set(router_properties, status_three->digest, status_three); 166 sha1_digest_t digest_four = "dddd"; 167 router_values_t *status_four = router_values_new(0, 0, 128, digest_four); 168 digestmap_set(router_properties, status_four->digest, status_four); 169 sha1_digest_t digest_five = "9999"; 170 router_values_t *status_five = router_values_new(0, 0, 0, digest_five); 171 digestmap_set(router_properties, status_five->digest, status_five); 172 173 // A router that has auth status is more useful than a non-auth one 174 routerinfo_t *first = routerinfo_new(status_one, AF_INET, 0xf); 175 routerinfo_t *second = routerinfo_new(status_two, AF_INET, 0xf); 176 int a = compare_routerinfo_usefulness(first, second); 177 tt_assert(a == 1); 178 tor_free(second); 179 180 // A running router is more useful than a non running one 181 routerinfo_t *third = routerinfo_new(status_three, AF_INET, 0xf); 182 a = compare_routerinfo_usefulness(first, third); 183 tt_assert(a == 1); 184 tor_free(third); 185 186 // A higher bandwidth is more useful 187 routerinfo_t *fourth = routerinfo_new(status_four, AF_INET, 0xf); 188 a = compare_routerinfo_usefulness(first, fourth); 189 tt_assert(a == 1); 190 tor_free(fourth); 191 192 // In case of tie, the digests are compared 193 routerinfo_t *fifth = routerinfo_new(status_five, AF_INET, 0xf); 194 a = compare_routerinfo_usefulness(first, fifth); 195 tt_assert(a > 0); 196 tor_free(fifth); 197 198 done: 199 UNMOCK(router_digest_is_trusted_dir_type); 200 UNMOCK(node_get_by_id); 201 UNMOCK(dirserv_get_bandwidth_for_router_kb); 202 FREE_MOCK_NODES(); 203 digestmap_free(router_properties, NULL); 204 tor_free(status_one); 205 tor_free(status_two); 206 tor_free(status_three); 207 tor_free(status_four); 208 tor_free(status_five); 209 tor_free(first); 210 } 211 212 static void 213 test_dirvote_compare_routerinfo_by_ipv4(void *arg) 214 { 215 (void)arg; 216 MOCK(router_digest_is_trusted_dir_type, mock_router_digest_is_trusted); 217 MOCK(node_get_by_id, mock_node_get_by_id); 218 MOCK(dirserv_get_bandwidth_for_router_kb, mock_dirserv_get_bw); 219 220 ALLOCATE_MOCK_NODES(); 221 router_properties = digestmap_new(); 222 sha1_digest_t digest_one = "aaaa"; 223 router_values_t *status_one = router_values_new(0, 0, 0, digest_one); 224 digestmap_set(router_properties, status_one->digest, status_one); 225 sha1_digest_t digest_two = "bbbb"; 226 router_values_t *status_two = router_values_new(0, 1, 0, digest_two); 227 digestmap_set(router_properties, status_two->digest, status_two); 228 229 // Both routers have an IPv4 address 230 routerinfo_t *first = routerinfo_new(status_one, AF_INET, 1); 231 routerinfo_t *second = routerinfo_new(status_two, AF_INET, 0xf); 232 233 // The first argument's address precedes the seconds' one 234 int a = compare_routerinfo_by_ipv4((const void **)&first, 235 (const void **)&second); 236 tt_assert(a < 0); 237 // The second argument's address precedes the first' one 238 a = compare_routerinfo_by_ipv4((const void **)&second, 239 (const void **)&first); 240 tt_assert(a > 0); 241 tor_addr_copy(&(second->ipv4_addr), &(first->ipv6_addr)); 242 // The addresses are equal, they are compared by usefulness, 243 // and first is less useful than second 244 a = compare_routerinfo_by_ipv4((const void **)&first, 245 (const void **)&second); 246 tt_assert(a == 1); 247 done: 248 UNMOCK(router_digest_is_trusted_dir_type); 249 UNMOCK(node_get_by_id); 250 UNMOCK(dirserv_get_bandwidth_for_router_kb); 251 FREE_MOCK_NODES(); 252 digestmap_free(router_properties, NULL); 253 tor_free(status_one); 254 tor_free(status_two); 255 tor_free(first); 256 tor_free(second); 257 } 258 259 static void 260 test_dirvote_compare_routerinfo_by_ipv6(void *arg) 261 { 262 (void)arg; 263 MOCK(router_digest_is_trusted_dir_type, mock_router_digest_is_trusted); 264 MOCK(node_get_by_id, mock_node_get_by_id); 265 MOCK(dirserv_get_bandwidth_for_router_kb, mock_dirserv_get_bw); 266 267 ALLOCATE_MOCK_NODES(); 268 router_properties = digestmap_new(); 269 char digest_one[DIGEST_LEN] = "aaaa"; 270 router_values_t *status_one = router_values_new(0, 0, 0, digest_one); 271 digestmap_set(router_properties, status_one->digest, status_one); 272 char digest_two[DIGEST_LEN] = "bbbb"; 273 router_values_t *status_two = router_values_new(0, 1, 0, digest_two); 274 digestmap_set(router_properties, status_two->digest, status_two); 275 276 // Both routers have an IPv6 address 277 routerinfo_t *first = routerinfo_new(status_one, AF_INET6, 1); 278 routerinfo_t *second = routerinfo_new(status_two, AF_INET6, 0xf); 279 280 // The first argument's address precedes the seconds' one 281 int a = compare_routerinfo_by_ipv6((const void **)&first, 282 (const void **)&second); 283 tt_assert(a < 0); 284 // The second argument's address precedes the first' one 285 a = compare_routerinfo_by_ipv6((const void **)&second, 286 (const void **)&first); 287 tt_assert(a > 0); 288 tor_addr_copy(&(first->ipv6_addr), &(second->ipv6_addr)); 289 // The addresses are equal, they are compared by usefulness, 290 // and first is less useful than second 291 a = compare_routerinfo_by_ipv6((const void **)&first, 292 (const void **)&second); 293 tt_assert(a == 1); 294 done: 295 UNMOCK(router_digest_is_trusted_dir_type); 296 UNMOCK(node_get_by_id); 297 UNMOCK(dirserv_get_bandwidth_for_router_kb); 298 FREE_MOCK_NODES(); 299 digestmap_free(router_properties, NULL); 300 tor_free(status_one); 301 tor_free(status_two); 302 tor_free(first); 303 tor_free(second); 304 } 305 306 /** Create routers values and routerinfos that always have the same 307 * characteristics, and add them to the global digestmap. This macro is here to 308 * avoid duplicated code fragments. 309 * The created name##_val pointer should be freed by the caller (and cannot 310 * be freed in the macro as it causes a heap-after-free error) 311 */ 312 #define CREATE_ROUTER(digest, name, addr, ip_version) \ 313 sha1_digest_t name##_digest = digest; \ 314 name##_val = router_values_new(1, 1, 1, name##_digest); \ 315 digestmap_set(router_properties, name##_digest, name##_val); \ 316 name##_ri = routerinfo_new(name##_val, ip_version, addr); 317 318 #define ROUTER_FREE(name) \ 319 tor_free(name##_val); \ 320 tor_free(name##_ri); 321 322 /** Test to see if the returned routers are exactly the ones that should be 323 * flagged as sybils : we test for inclusion then for number of elements 324 */ 325 #define TEST_SYBIL(true_sybil, possible_sybil) \ 326 DIGESTMAP_FOREACH (true_sybil, sybil_id, void *, ignore) { \ 327 (void)ignore; \ 328 tt_assert(digestmap_get(possible_sybil, sybil_id)); \ 329 } \ 330 DIGESTMAP_FOREACH_END; \ 331 tt_assert(digestmap_size(true_sybil) == digestmap_size(possible_sybil)); 332 333 static void 334 test_dirvote_get_sybil_by_ip_version_ipv4(void *arg) 335 { 336 // It is assumed that global_dirauth_options.AuthDirMaxServersPerAddr == 2 337 (void)arg; 338 router_values_t *aaaa_val=NULL, *bbbb_val=NULL, *cccc_val=NULL, 339 *dddd_val=NULL, *eeee_val=NULL, *ffff_val=NULL, *gggg_val=NULL, 340 *hhhh_val=NULL; 341 routerinfo_t *aaaa_ri=NULL, *bbbb_ri=NULL, *cccc_ri=NULL, 342 *dddd_ri=NULL, *eeee_ri=NULL, *ffff_ri=NULL, *gggg_ri=NULL, 343 *hhhh_ri=NULL; 344 345 MOCK(router_digest_is_trusted_dir_type, mock_router_digest_is_trusted); 346 MOCK(node_get_by_id, mock_node_get_by_id); 347 MOCK(dirserv_get_bandwidth_for_router_kb, mock_dirserv_get_bw); 348 ALLOCATE_MOCK_NODES(); 349 router_properties = digestmap_new(); 350 smartlist_t *routers_ipv4; 351 routers_ipv4 = smartlist_new(); 352 digestmap_t *true_sybil_routers = NULL; 353 true_sybil_routers = digestmap_new(); 354 digestmap_t *omit_as_sybil; 355 356 CREATE_ROUTER("aaaa", aaaa, 123, AF_INET); 357 smartlist_add(routers_ipv4, aaaa_ri); 358 CREATE_ROUTER("bbbb", bbbb, 123, AF_INET); 359 smartlist_add(routers_ipv4, bbbb_ri); 360 omit_as_sybil = get_sybil_list_by_ip_version(routers_ipv4, AF_INET); 361 tt_assert(digestmap_isempty(omit_as_sybil) == 1); 362 digestmap_free(omit_as_sybil, NULL); 363 364 CREATE_ROUTER("cccc", cccc, 123, AF_INET); 365 smartlist_add(routers_ipv4, cccc_ri); 366 digestmap_set(true_sybil_routers, cccc_digest, cccc_digest); 367 omit_as_sybil = get_sybil_list_by_ip_version(routers_ipv4, AF_INET); 368 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 369 digestmap_free(omit_as_sybil, NULL); 370 371 CREATE_ROUTER("dddd", dddd, 123, AF_INET); 372 smartlist_add(routers_ipv4, dddd_ri); 373 digestmap_set(true_sybil_routers, dddd_digest, dddd_digest); 374 omit_as_sybil = get_sybil_list_by_ip_version(routers_ipv4, AF_INET); 375 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 376 digestmap_free(omit_as_sybil, NULL); 377 378 CREATE_ROUTER("eeee", eeee, 456, AF_INET); 379 smartlist_add(routers_ipv4, eeee_ri); 380 omit_as_sybil = get_sybil_list_by_ip_version(routers_ipv4, AF_INET); 381 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 382 digestmap_free(omit_as_sybil, NULL); 383 384 CREATE_ROUTER("ffff", ffff, 456, AF_INET); 385 smartlist_add(routers_ipv4, ffff_ri); 386 omit_as_sybil = get_sybil_list_by_ip_version(routers_ipv4, AF_INET); 387 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 388 digestmap_free(omit_as_sybil, NULL); 389 390 CREATE_ROUTER("gggg", gggg, 456, AF_INET); 391 smartlist_add(routers_ipv4, gggg_ri); 392 digestmap_set(true_sybil_routers, gggg_digest, gggg_digest); 393 omit_as_sybil = get_sybil_list_by_ip_version(routers_ipv4, AF_INET); 394 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 395 digestmap_free(omit_as_sybil, NULL); 396 397 CREATE_ROUTER("hhhh", hhhh, 456, AF_INET); 398 smartlist_add(routers_ipv4, hhhh_ri); 399 digestmap_set(true_sybil_routers, hhhh_digest, hhhh_digest); 400 omit_as_sybil = get_sybil_list_by_ip_version(routers_ipv4, AF_INET); 401 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 402 403 done: 404 UNMOCK(router_digest_is_trusted_dir_type); 405 UNMOCK(node_get_by_id); 406 UNMOCK(dirserv_get_bandwidth_for_router_kb); 407 FREE_MOCK_NODES(); 408 digestmap_free(router_properties, NULL); 409 smartlist_free(routers_ipv4); 410 digestmap_free(omit_as_sybil, NULL); 411 digestmap_free(true_sybil_routers, NULL); 412 ROUTER_FREE(aaaa); 413 ROUTER_FREE(bbbb); 414 ROUTER_FREE(cccc); 415 ROUTER_FREE(dddd); 416 ROUTER_FREE(eeee); 417 ROUTER_FREE(ffff); 418 ROUTER_FREE(gggg); 419 ROUTER_FREE(hhhh); 420 } 421 422 static void 423 test_dirvote_get_sybil_by_ip_version_ipv6(void *arg) 424 { 425 router_values_t *aaaa_val=NULL, *bbbb_val=NULL, *cccc_val=NULL, 426 *dddd_val=NULL, *eeee_val=NULL, *ffff_val=NULL, *gggg_val=NULL, 427 *hhhh_val=NULL; 428 routerinfo_t *aaaa_ri=NULL, *bbbb_ri=NULL, *cccc_ri=NULL, 429 *dddd_ri=NULL, *eeee_ri=NULL, *ffff_ri=NULL, *gggg_ri=NULL, 430 *hhhh_ri=NULL; 431 432 // It is assumed that global_dirauth_options.AuthDirMaxServersPerAddr == 2 433 (void)arg; 434 MOCK(router_digest_is_trusted_dir_type, mock_router_digest_is_trusted); 435 MOCK(node_get_by_id, mock_node_get_by_id); 436 MOCK(dirserv_get_bandwidth_for_router_kb, mock_dirserv_get_bw); 437 ALLOCATE_MOCK_NODES(); 438 router_properties = digestmap_new(); 439 smartlist_t *routers_ipv6; 440 routers_ipv6 = smartlist_new(); 441 digestmap_t *true_sybil_routers = NULL; 442 true_sybil_routers = digestmap_new(); 443 digestmap_t *omit_as_sybil; 444 445 CREATE_ROUTER("aaaa", aaaa, 123, AF_INET6); 446 smartlist_add(routers_ipv6, aaaa_ri); 447 CREATE_ROUTER("bbbb", bbbb, 123, AF_INET6); 448 smartlist_add(routers_ipv6, bbbb_ri); 449 omit_as_sybil = get_sybil_list_by_ip_version(routers_ipv6, AF_INET6); 450 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 451 digestmap_free(omit_as_sybil, NULL); 452 453 CREATE_ROUTER("cccc", cccc, 123, AF_INET6); 454 smartlist_add(routers_ipv6, cccc_ri); 455 digestmap_set(true_sybil_routers, cccc_digest, cccc_digest); 456 omit_as_sybil = get_sybil_list_by_ip_version(routers_ipv6, AF_INET6); 457 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 458 digestmap_free(omit_as_sybil, NULL); 459 460 CREATE_ROUTER("dddd", dddd, 123, AF_INET6); 461 smartlist_add(routers_ipv6, dddd_ri); 462 digestmap_set(true_sybil_routers, dddd_digest, dddd_digest); 463 omit_as_sybil = get_sybil_list_by_ip_version(routers_ipv6, AF_INET6); 464 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 465 digestmap_free(omit_as_sybil, NULL); 466 467 CREATE_ROUTER("eeee", eeee, 456, AF_INET6); 468 smartlist_add(routers_ipv6, eeee_ri); 469 omit_as_sybil = get_sybil_list_by_ip_version(routers_ipv6, AF_INET6); 470 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 471 digestmap_free(omit_as_sybil, NULL); 472 473 CREATE_ROUTER("ffff", ffff, 456, AF_INET6); 474 smartlist_add(routers_ipv6, ffff_ri); 475 omit_as_sybil = get_sybil_list_by_ip_version(routers_ipv6, AF_INET6); 476 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 477 digestmap_free(omit_as_sybil, NULL); 478 479 CREATE_ROUTER("gggg", gggg, 456, AF_INET6); 480 smartlist_add(routers_ipv6, gggg_ri); 481 digestmap_set(true_sybil_routers, gggg_digest, gggg_digest); 482 omit_as_sybil = get_sybil_list_by_ip_version(routers_ipv6, AF_INET6); 483 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 484 digestmap_free(omit_as_sybil, NULL); 485 486 CREATE_ROUTER("hhhh", hhhh, 456, AF_INET6); 487 smartlist_add(routers_ipv6, hhhh_ri); 488 digestmap_set(true_sybil_routers, hhhh_digest, hhhh_digest); 489 omit_as_sybil = get_sybil_list_by_ip_version(routers_ipv6, AF_INET6); 490 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 491 done: 492 UNMOCK(router_digest_is_trusted_dir_type); 493 UNMOCK(node_get_by_id); 494 UNMOCK(dirserv_get_bandwidth_for_router_kb); 495 FREE_MOCK_NODES(); 496 digestmap_free(router_properties, NULL); 497 digestmap_free(true_sybil_routers, NULL); 498 smartlist_free(routers_ipv6); 499 digestmap_free(omit_as_sybil, NULL); 500 ROUTER_FREE(aaaa); 501 ROUTER_FREE(bbbb); 502 ROUTER_FREE(cccc); 503 ROUTER_FREE(dddd); 504 ROUTER_FREE(eeee); 505 ROUTER_FREE(ffff); 506 ROUTER_FREE(gggg); 507 ROUTER_FREE(hhhh); 508 } 509 510 static void 511 test_dirvote_get_all_possible_sybil(void *arg) 512 { 513 router_values_t *aaaa_val=NULL, *bbbb_val=NULL, *cccc_val=NULL, 514 *dddd_val=NULL, *eeee_val=NULL, *ffff_val=NULL, *gggg_val=NULL, 515 *hhhh_val=NULL, *iiii_val=NULL, *jjjj_val=NULL, *kkkk_val=NULL, 516 *llll_val=NULL, *mmmm_val=NULL, *nnnn_val=NULL, *oooo_val=NULL, 517 *pppp_val=NULL; 518 routerinfo_t *aaaa_ri=NULL, *bbbb_ri=NULL, *cccc_ri=NULL, 519 *dddd_ri=NULL, *eeee_ri=NULL, *ffff_ri=NULL, *gggg_ri=NULL, 520 *hhhh_ri=NULL, *iiii_ri=NULL, *jjjj_ri=NULL, *kkkk_ri=NULL, 521 *llll_ri=NULL, *mmmm_ri=NULL, *nnnn_ri=NULL, *oooo_ri=NULL, 522 *pppp_ri=NULL; 523 524 // It is assumed that global_dirauth_options.AuthDirMaxServersPerAddr == 2 525 (void)arg; 526 MOCK(router_digest_is_trusted_dir_type, mock_router_digest_is_trusted); 527 MOCK(node_get_by_id, mock_node_get_by_id); 528 MOCK(dirserv_get_bandwidth_for_router_kb, mock_dirserv_get_bw); 529 ALLOCATE_MOCK_NODES(); 530 router_properties = digestmap_new(); 531 smartlist_t *routers; 532 routers = smartlist_new(); 533 digestmap_t *true_sybil_routers = NULL; 534 true_sybil_routers = digestmap_new(); 535 digestmap_t *omit_as_sybil; 536 537 CREATE_ROUTER("aaaa", aaaa, 123, AF_INET); 538 smartlist_add(routers, aaaa_ri); 539 CREATE_ROUTER("bbbb", bbbb, 123, AF_INET); 540 smartlist_add(routers, bbbb_ri); 541 omit_as_sybil = get_all_possible_sybil(routers); 542 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 543 digestmap_free(omit_as_sybil, NULL); 544 545 CREATE_ROUTER("cccc", cccc, 123, AF_INET); 546 smartlist_add(routers, cccc_ri); 547 digestmap_set(true_sybil_routers, cccc_digest, cccc_digest); 548 omit_as_sybil = get_all_possible_sybil(routers); 549 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 550 digestmap_free(omit_as_sybil, NULL); 551 552 CREATE_ROUTER("dddd", dddd, 123, AF_INET); 553 smartlist_add(routers, dddd_ri); 554 digestmap_set(true_sybil_routers, dddd_digest, dddd_digest); 555 omit_as_sybil = get_all_possible_sybil(routers); 556 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 557 digestmap_free(omit_as_sybil, NULL); 558 559 CREATE_ROUTER("eeee", eeee, 456, AF_INET); 560 smartlist_add(routers, eeee_ri); 561 omit_as_sybil = get_all_possible_sybil(routers); 562 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 563 digestmap_free(omit_as_sybil, NULL); 564 565 CREATE_ROUTER("ffff", ffff, 456, AF_INET); 566 smartlist_add(routers, ffff_ri); 567 omit_as_sybil = get_all_possible_sybil(routers); 568 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 569 digestmap_free(omit_as_sybil, NULL); 570 571 CREATE_ROUTER("gggg", gggg, 456, AF_INET); 572 smartlist_add(routers, gggg_ri); 573 digestmap_set(true_sybil_routers, gggg_digest, gggg_digest); 574 omit_as_sybil = get_all_possible_sybil(routers); 575 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 576 digestmap_free(omit_as_sybil, NULL); 577 578 CREATE_ROUTER("hhhh", hhhh, 456, AF_INET); 579 smartlist_add(routers, hhhh_ri); 580 digestmap_set(true_sybil_routers, hhhh_digest, hhhh_digest); 581 omit_as_sybil = get_all_possible_sybil(routers); 582 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 583 digestmap_free(omit_as_sybil, NULL); 584 585 CREATE_ROUTER("iiii", iiii, 123, AF_INET6); 586 smartlist_add(routers, iiii_ri); 587 CREATE_ROUTER("jjjj", jjjj, 123, AF_INET6); 588 smartlist_add(routers, jjjj_ri); 589 omit_as_sybil = get_all_possible_sybil(routers); 590 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 591 digestmap_free(omit_as_sybil, NULL); 592 593 CREATE_ROUTER("kkkk", kkkk, 123, AF_INET6); 594 smartlist_add(routers, kkkk_ri); 595 digestmap_set(true_sybil_routers, kkkk_digest, kkkk_digest); 596 omit_as_sybil = get_all_possible_sybil(routers); 597 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 598 digestmap_free(omit_as_sybil,NULL); 599 600 CREATE_ROUTER("llll", llll, 123, AF_INET6); 601 smartlist_add(routers, llll_ri); 602 digestmap_set(true_sybil_routers, llll_digest, llll_digest); 603 omit_as_sybil = get_all_possible_sybil(routers); 604 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 605 digestmap_free(omit_as_sybil,NULL); 606 607 CREATE_ROUTER("mmmm", mmmm, 456, AF_INET6); 608 smartlist_add(routers, mmmm_ri); 609 omit_as_sybil = get_all_possible_sybil(routers); 610 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 611 digestmap_free(omit_as_sybil, NULL); 612 613 CREATE_ROUTER("nnnn", nnnn, 456, AF_INET6); 614 smartlist_add(routers, nnnn_ri); 615 omit_as_sybil = get_all_possible_sybil(routers); 616 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 617 digestmap_free(omit_as_sybil, NULL); 618 619 CREATE_ROUTER("oooo", oooo, 456, AF_INET6); 620 smartlist_add(routers, oooo_ri); 621 digestmap_set(true_sybil_routers, oooo_digest, oooo_digest); 622 omit_as_sybil = get_all_possible_sybil(routers); 623 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 624 digestmap_free(omit_as_sybil, NULL); 625 626 CREATE_ROUTER("pppp", pppp, 456, AF_INET6); 627 smartlist_add(routers, pppp_ri); 628 digestmap_set(true_sybil_routers, pppp_digest, pppp_digest); 629 omit_as_sybil = get_all_possible_sybil(routers); 630 TEST_SYBIL(true_sybil_routers, omit_as_sybil); 631 632 done: 633 UNMOCK(router_digest_is_trusted_dir_type); 634 UNMOCK(node_get_by_id); 635 UNMOCK(dirserv_get_bandwidth_for_router_kb); 636 FREE_MOCK_NODES(); 637 digestmap_free(router_properties, NULL); 638 smartlist_free(routers); 639 digestmap_free(omit_as_sybil, NULL); 640 digestmap_free(true_sybil_routers, NULL); 641 ROUTER_FREE(aaaa); 642 ROUTER_FREE(bbbb); 643 ROUTER_FREE(cccc); 644 ROUTER_FREE(dddd); 645 ROUTER_FREE(eeee); 646 ROUTER_FREE(ffff); 647 ROUTER_FREE(gggg); 648 ROUTER_FREE(hhhh); 649 ROUTER_FREE(iiii); 650 ROUTER_FREE(jjjj); 651 ROUTER_FREE(kkkk); 652 ROUTER_FREE(llll); 653 ROUTER_FREE(mmmm); 654 ROUTER_FREE(nnnn); 655 ROUTER_FREE(oooo); 656 ROUTER_FREE(pppp); 657 } 658 659 #define NODE(name, flags) \ 660 { \ 661 #name, test_dirvote_##name, (flags), NULL, NULL \ 662 } 663 664 struct testcase_t dirvote_tests[] = { 665 NODE(compare_routerinfo_usefulness, TT_FORK), 666 NODE(compare_routerinfo_by_ipv6, TT_FORK), 667 NODE(compare_routerinfo_by_ipv4, TT_FORK), 668 NODE(get_sybil_by_ip_version_ipv4, TT_FORK), 669 NODE(get_sybil_by_ip_version_ipv6, TT_FORK), 670 NODE(get_all_possible_sybil, TT_FORK), 671 END_OF_TESTCASES};