test_address.c (39936B)
1 /* Copyright (c) 2014-2021, The Tor Project, Inc. */ 2 /* See LICENSE for licensing information */ 3 4 #define ADDRESS_PRIVATE 5 6 #include "orconfig.h" 7 8 #ifdef _WIN32 9 #include <winsock2.h> 10 /* For access to structs needed by GetAdaptersAddresses */ 11 #include <iphlpapi.h> 12 #endif 13 14 #ifdef HAVE_IFADDRS_TO_SMARTLIST 15 #include <net/if.h> 16 #include <ifaddrs.h> 17 #endif 18 19 #ifdef HAVE_IFCONF_TO_SMARTLIST 20 #ifdef HAVE_SYS_IOCTL_H 21 #include <sys/ioctl.h> 22 #endif 23 #include <net/if.h> 24 #endif /* defined(HAVE_IFCONF_TO_SMARTLIST) */ 25 26 #include "core/or/or.h" 27 #include "app/config/config.h" 28 #include "feature/dirauth/process_descs.h" 29 #include "feature/nodelist/routerinfo_st.h" 30 #include "feature/nodelist/node_st.h" 31 #include "feature/nodelist/nodelist.h" 32 #include "lib/net/address.h" 33 #include "test/test.h" 34 #include "test/log_test_helpers.h" 35 36 /** Return 1 iff <b>sockaddr1</b> and <b>sockaddr2</b> represent 37 * the same IP address and port combination. Otherwise, return 0. 38 */ 39 static uint8_t 40 sockaddr_in_are_equal(struct sockaddr_in *sockaddr1, 41 struct sockaddr_in *sockaddr2) 42 { 43 return ((sockaddr1->sin_family == sockaddr2->sin_family) && 44 (sockaddr1->sin_port == sockaddr2->sin_port) && 45 (sockaddr1->sin_addr.s_addr == sockaddr2->sin_addr.s_addr)); 46 } 47 48 /** Return 1 iff <b>sockaddr1</b> and <b>sockaddr2</b> represent 49 * the same IP address and port combination. Otherwise, return 0. 50 */ 51 static uint8_t 52 sockaddr_in6_are_equal(struct sockaddr_in6 *sockaddr1, 53 struct sockaddr_in6 *sockaddr2) 54 { 55 return ((sockaddr1->sin6_family == sockaddr2->sin6_family) && 56 (sockaddr1->sin6_port == sockaddr2->sin6_port) && 57 (tor_memeq(sockaddr1->sin6_addr.s6_addr, 58 sockaddr2->sin6_addr.s6_addr,16))); 59 } 60 61 /** Create a sockaddr_in structure from IP address string <b>ip_str</b>. 62 * 63 * If <b>out</b> is not NULL, write the result 64 * to the memory address in <b>out</b>. Otherwise, allocate the memory 65 * for result. On success, return pointer to result. Otherwise, return 66 * NULL. 67 */ 68 static struct sockaddr_in * 69 sockaddr_in_from_string(const char *ip_str, struct sockaddr_in *out) 70 { 71 // [FIXME: add some error checking?] 72 if (!out) 73 out = tor_malloc_zero(sizeof(struct sockaddr_in)); 74 75 out->sin_family = AF_INET; 76 out->sin_port = 0; 77 tor_inet_pton(AF_INET,ip_str,&(out->sin_addr)); 78 79 return out; 80 } 81 82 /** Return 1 iff <b>smartlist</b> contains a tor_addr_t structure 83 * that is an IPv4 or IPv6 localhost address. Otherwise, return 0. 84 */ 85 static int 86 smartlist_contains_localhost_tor_addr(smartlist_t *smartlist) 87 { 88 SMARTLIST_FOREACH_BEGIN(smartlist, tor_addr_t *, tor_addr) { 89 if (tor_addr_is_loopback(tor_addr)) { 90 return 1; 91 } 92 } SMARTLIST_FOREACH_END(tor_addr); 93 94 return 0; 95 } 96 97 /** Return 1 iff <b>smartlist</b> contains a tor_addr_t structure 98 * that is an IPv4 or IPv6 multicast address. Otherwise, return 0. 99 */ 100 static int 101 smartlist_contains_multicast_tor_addr(smartlist_t *smartlist) 102 { 103 SMARTLIST_FOREACH_BEGIN(smartlist, tor_addr_t *, tor_addr) { 104 if (tor_addr_is_multicast(tor_addr)) { 105 return 1; 106 } 107 } SMARTLIST_FOREACH_END(tor_addr); 108 109 return 0; 110 } 111 112 /** Return 1 iff <b>smartlist</b> contains a tor_addr_t structure 113 * that is an IPv4 or IPv6 internal address. Otherwise, return 0. 114 */ 115 static int 116 smartlist_contains_internal_tor_addr(smartlist_t *smartlist) 117 { 118 SMARTLIST_FOREACH_BEGIN(smartlist, tor_addr_t *, tor_addr) { 119 if (tor_addr_is_internal(tor_addr, 0)) { 120 return 1; 121 } 122 } SMARTLIST_FOREACH_END(tor_addr); 123 124 return 0; 125 } 126 127 /** Return 1 iff <b>smartlist</b> contains a tor_addr_t structure 128 * that is NULL or the null tor_addr_t. Otherwise, return 0. 129 */ 130 static int 131 smartlist_contains_null_tor_addr(smartlist_t *smartlist) 132 { 133 SMARTLIST_FOREACH_BEGIN(smartlist, tor_addr_t *, tor_addr) { 134 if (tor_addr == NULL || tor_addr_is_null(tor_addr)) { 135 return 1; 136 } 137 } SMARTLIST_FOREACH_END(tor_addr); 138 139 return 0; 140 } 141 142 /** Return 1 iff <b>smartlist</b> contains a tor_addr_t structure 143 * that is an IPv4 address. Otherwise, return 0. 144 */ 145 static int 146 smartlist_contains_ipv4_tor_addr(smartlist_t *smartlist) 147 { 148 SMARTLIST_FOREACH_BEGIN(smartlist, tor_addr_t *, tor_addr) { 149 if (tor_addr_is_v4(tor_addr)) { 150 return 1; 151 } 152 } SMARTLIST_FOREACH_END(tor_addr); 153 154 return 0; 155 } 156 157 /** Return 1 iff <b>smartlist</b> contains a tor_addr_t structure 158 * that is an IPv6 address. Otherwise, return 0. 159 */ 160 static int 161 smartlist_contains_ipv6_tor_addr(smartlist_t *smartlist) 162 { 163 SMARTLIST_FOREACH_BEGIN(smartlist, tor_addr_t *, tor_addr) { 164 /* Since there's no tor_addr_is_v6, assume all non-v4s are v6 */ 165 if (!tor_addr_is_v4(tor_addr)) { 166 return 1; 167 } 168 } SMARTLIST_FOREACH_END(tor_addr); 169 170 return 0; 171 } 172 173 #ifdef HAVE_IFADDRS_TO_SMARTLIST 174 static void 175 test_address_ifaddrs_to_smartlist(void *arg) 176 { 177 struct ifaddrs *ifa = NULL; 178 struct ifaddrs *ifa_ipv4 = NULL; 179 struct ifaddrs *ifa_ipv6 = NULL; 180 struct sockaddr_in *ipv4_sockaddr_local = NULL; 181 struct sockaddr_in *netmask_slash8 = NULL; 182 struct sockaddr_in *ipv4_sockaddr_remote = NULL; 183 struct sockaddr_in6 *ipv6_sockaddr = NULL; 184 smartlist_t *smartlist = NULL; 185 tor_addr_t *tor_addr = NULL; 186 struct sockaddr *sockaddr_to_check = NULL; 187 socklen_t addr_len; 188 189 (void)arg; 190 191 netmask_slash8 = sockaddr_in_from_string("255.0.0.0",NULL); 192 ipv4_sockaddr_local = sockaddr_in_from_string("127.0.0.1",NULL); 193 ipv4_sockaddr_remote = sockaddr_in_from_string("128.52.160.20",NULL); 194 195 ipv6_sockaddr = tor_malloc(sizeof(struct sockaddr_in6)); 196 ipv6_sockaddr->sin6_family = AF_INET6; 197 ipv6_sockaddr->sin6_port = 0; 198 tor_inet_pton(AF_INET6, "2001:db8:8714:3a90::12", 199 &(ipv6_sockaddr->sin6_addr)); 200 201 ifa = tor_malloc(sizeof(struct ifaddrs)); 202 ifa_ipv4 = tor_malloc(sizeof(struct ifaddrs)); 203 ifa_ipv6 = tor_malloc(sizeof(struct ifaddrs)); 204 205 ifa->ifa_next = ifa_ipv4; 206 ifa->ifa_name = tor_strdup("eth0"); 207 ifa->ifa_flags = IFF_UP | IFF_RUNNING; 208 ifa->ifa_addr = (struct sockaddr *)ipv4_sockaddr_local; 209 ifa->ifa_netmask = (struct sockaddr *)netmask_slash8; 210 ifa->ifa_dstaddr = NULL; 211 ifa->ifa_data = NULL; 212 213 ifa_ipv4->ifa_next = ifa_ipv6; 214 ifa_ipv4->ifa_name = tor_strdup("eth1"); 215 ifa_ipv4->ifa_flags = IFF_UP | IFF_RUNNING; 216 ifa_ipv4->ifa_addr = (struct sockaddr *)ipv4_sockaddr_remote; 217 ifa_ipv4->ifa_netmask = (struct sockaddr *)netmask_slash8; 218 ifa_ipv4->ifa_dstaddr = NULL; 219 ifa_ipv4->ifa_data = NULL; 220 221 ifa_ipv6->ifa_next = NULL; 222 ifa_ipv6->ifa_name = tor_strdup("eth2"); 223 ifa_ipv6->ifa_flags = IFF_UP | IFF_RUNNING; 224 ifa_ipv6->ifa_addr = (struct sockaddr *)ipv6_sockaddr; 225 ifa_ipv6->ifa_netmask = NULL; 226 ifa_ipv6->ifa_dstaddr = NULL; 227 ifa_ipv6->ifa_data = NULL; 228 229 smartlist = ifaddrs_to_smartlist(ifa, AF_UNSPEC); 230 231 tt_assert(smartlist); 232 tt_int_op(smartlist_len(smartlist), OP_EQ, 3); 233 234 sockaddr_to_check = tor_malloc(sizeof(struct sockaddr_in6)); 235 236 tor_addr = smartlist_get(smartlist,0); 237 addr_len = 238 tor_addr_to_sockaddr(tor_addr,0,sockaddr_to_check, 239 sizeof(struct sockaddr_in)); 240 241 tt_int_op(addr_len,OP_EQ,sizeof(struct sockaddr_in)); 242 tt_assert(sockaddr_in_are_equal((struct sockaddr_in *)sockaddr_to_check, 243 ipv4_sockaddr_local)); 244 245 tor_addr = smartlist_get(smartlist,1); 246 addr_len = 247 tor_addr_to_sockaddr(tor_addr,0,sockaddr_to_check, 248 sizeof(struct sockaddr_in)); 249 250 tt_int_op(addr_len,OP_EQ,sizeof(struct sockaddr_in)); 251 tt_assert(sockaddr_in_are_equal((struct sockaddr_in *)sockaddr_to_check, 252 ipv4_sockaddr_remote)); 253 254 tor_addr = smartlist_get(smartlist,2); 255 addr_len = 256 tor_addr_to_sockaddr(tor_addr,0,sockaddr_to_check, 257 sizeof(struct sockaddr_in6)); 258 259 tt_int_op(addr_len,OP_EQ,sizeof(struct sockaddr_in6)); 260 tt_assert(sockaddr_in6_are_equal((struct sockaddr_in6*)sockaddr_to_check, 261 ipv6_sockaddr)); 262 263 done: 264 tor_free(netmask_slash8); 265 tor_free(ipv4_sockaddr_local); 266 tor_free(ipv4_sockaddr_remote); 267 tor_free(ipv6_sockaddr); 268 tor_free(ifa->ifa_name); 269 tor_free(ifa_ipv4->ifa_name); 270 tor_free(ifa_ipv6->ifa_name); 271 tor_free(ifa); 272 tor_free(ifa_ipv4); 273 tor_free(ifa_ipv6); 274 tor_free(sockaddr_to_check); 275 if (smartlist) { 276 SMARTLIST_FOREACH(smartlist, tor_addr_t *, t, tor_free(t)); 277 smartlist_free(smartlist); 278 } 279 return; 280 } 281 282 static void 283 test_address_get_if_addrs_ifaddrs(void *arg) 284 { 285 286 smartlist_t *results = NULL; 287 288 (void)arg; 289 290 results = get_interface_addresses_ifaddrs(LOG_ERR, AF_UNSPEC); 291 292 tt_assert(results); 293 /* Some FreeBSD jails don't have localhost IP address. Instead, they only 294 * have the address assigned to the jail (whatever that may be). 295 * And a jail without a network connection might not have any addresses at 296 * all. */ 297 tt_assert(!smartlist_contains_null_tor_addr(results)); 298 299 /* If there are addresses, they must be IPv4 or IPv6 */ 300 if (smartlist_len(results) > 0) { 301 tt_assert(smartlist_contains_ipv4_tor_addr(results) 302 || smartlist_contains_ipv6_tor_addr(results)); 303 } 304 305 done: 306 if (results) { 307 SMARTLIST_FOREACH(results, tor_addr_t *, t, tor_free(t)); 308 } 309 smartlist_free(results); 310 return; 311 } 312 313 #endif /* defined(HAVE_IFADDRS_TO_SMARTLIST) */ 314 315 #ifdef HAVE_IP_ADAPTER_TO_SMARTLIST 316 317 static void 318 test_address_get_if_addrs_win32(void *arg) 319 { 320 321 smartlist_t *results = NULL; 322 323 (void)arg; 324 325 results = get_interface_addresses_win32(LOG_ERR, AF_UNSPEC); 326 327 tt_int_op(smartlist_len(results),OP_GE,1); 328 tt_assert(smartlist_contains_localhost_tor_addr(results)); 329 tt_assert(!smartlist_contains_null_tor_addr(results)); 330 331 /* If there are addresses, they must be IPv4 or IPv6 */ 332 if (smartlist_len(results) > 0) { 333 tt_assert(smartlist_contains_ipv4_tor_addr(results) 334 || smartlist_contains_ipv6_tor_addr(results)); 335 } 336 337 done: 338 SMARTLIST_FOREACH(results, tor_addr_t *, t, tor_free(t)); 339 tor_free(results); 340 return; 341 } 342 343 static void 344 test_address_ip_adapter_addresses_to_smartlist(void *arg) 345 { 346 347 IP_ADAPTER_ADDRESSES *addrs1; 348 IP_ADAPTER_ADDRESSES *addrs2; 349 350 IP_ADAPTER_UNICAST_ADDRESS *unicast11; 351 IP_ADAPTER_UNICAST_ADDRESS *unicast12; 352 IP_ADAPTER_UNICAST_ADDRESS *unicast21; 353 354 smartlist_t *result = NULL; 355 356 struct sockaddr_in *sockaddr_test1; 357 struct sockaddr_in *sockaddr_test2; 358 struct sockaddr_in *sockaddr_localhost; 359 struct sockaddr_in *sockaddr_to_check; 360 361 tor_addr_t *tor_addr; 362 363 (void)arg; 364 (void)sockaddr_in6_are_equal; 365 366 sockaddr_to_check = tor_malloc_zero(sizeof(struct sockaddr_in)); 367 368 addrs1 = 369 tor_malloc_zero(sizeof(IP_ADAPTER_ADDRESSES)); 370 371 addrs1->FirstUnicastAddress = 372 unicast11 = tor_malloc_zero(sizeof(IP_ADAPTER_UNICAST_ADDRESS)); 373 sockaddr_test1 = sockaddr_in_from_string("86.59.30.40",NULL); 374 unicast11->Address.lpSockaddr = (LPSOCKADDR)sockaddr_test1; 375 376 unicast11->Next = unicast12 = 377 tor_malloc_zero(sizeof(IP_ADAPTER_UNICAST_ADDRESS)); 378 sockaddr_test2 = sockaddr_in_from_string("93.95.227.222", NULL); 379 unicast12->Address.lpSockaddr = (LPSOCKADDR)sockaddr_test2; 380 381 addrs1->Next = addrs2 = 382 tor_malloc_zero(sizeof(IP_ADAPTER_ADDRESSES)); 383 384 addrs2->FirstUnicastAddress = 385 unicast21 = tor_malloc_zero(sizeof(IP_ADAPTER_UNICAST_ADDRESS)); 386 sockaddr_localhost = sockaddr_in_from_string("127.0.0.1", NULL); 387 unicast21->Address.lpSockaddr = (LPSOCKADDR)sockaddr_localhost; 388 389 result = ip_adapter_addresses_to_smartlist(addrs1); 390 391 tt_assert(result); 392 tt_int_op(smartlist_len(result), OP_EQ, 3); 393 394 tor_addr = smartlist_get(result,0); 395 396 tor_addr_to_sockaddr(tor_addr,0,(struct sockaddr *)sockaddr_to_check, 397 sizeof(struct sockaddr_in)); 398 399 tt_assert(sockaddr_in_are_equal(sockaddr_test1,sockaddr_to_check)); 400 401 tor_addr = smartlist_get(result,1); 402 403 tor_addr_to_sockaddr(tor_addr,0,(struct sockaddr *)sockaddr_to_check, 404 sizeof(struct sockaddr_in)); 405 406 tt_assert(sockaddr_in_are_equal(sockaddr_test2,sockaddr_to_check)); 407 408 tor_addr = smartlist_get(result,2); 409 410 tor_addr_to_sockaddr(tor_addr,0,(struct sockaddr *)sockaddr_to_check, 411 sizeof(struct sockaddr_in)); 412 413 tt_assert(sockaddr_in_are_equal(sockaddr_localhost,sockaddr_to_check)); 414 415 done: 416 SMARTLIST_FOREACH(result, tor_addr_t *, t, tor_free(t)); 417 smartlist_free(result); 418 tor_free(addrs1); 419 tor_free(addrs2); 420 tor_free(unicast11->Address.lpSockaddr); 421 tor_free(unicast11); 422 tor_free(unicast12->Address.lpSockaddr); 423 tor_free(unicast12); 424 tor_free(unicast21->Address.lpSockaddr); 425 tor_free(unicast21); 426 tor_free(sockaddr_to_check); 427 return; 428 } 429 #endif /* defined(HAVE_IP_ADAPTER_TO_SMARTLIST) */ 430 431 #ifdef HAVE_IFCONF_TO_SMARTLIST 432 433 static void 434 test_address_ifreq_to_smartlist(void *arg) 435 { 436 smartlist_t *results = NULL; 437 const tor_addr_t *tor_addr = NULL; 438 struct sockaddr_in *sockaddr = NULL; 439 struct sockaddr_in *sockaddr_eth1 = NULL; 440 struct sockaddr_in *sockaddr_to_check = NULL; 441 442 struct ifconf *ifc; 443 struct ifreq *ifr; 444 struct ifreq *ifr_next; 445 446 socklen_t addr_len; 447 448 (void)arg; 449 450 sockaddr_to_check = tor_malloc(sizeof(struct sockaddr_in)); 451 452 ifr = tor_malloc(sizeof(struct ifreq)); 453 memset(ifr,0,sizeof(struct ifreq)); 454 strlcpy(ifr->ifr_name,"lo",3); 455 sockaddr = (struct sockaddr_in *) &(ifr->ifr_ifru.ifru_addr); 456 sockaddr_in_from_string("127.0.0.1",sockaddr); 457 458 ifc = tor_malloc(sizeof(struct ifconf)); 459 memset(ifc,0,sizeof(struct ifconf)); 460 ifc->ifc_len = sizeof(struct ifreq); 461 ifc->ifc_ifcu.ifcu_req = ifr; 462 463 results = ifreq_to_smartlist((const uint8_t *)ifc->ifc_buf,ifc->ifc_len); 464 tt_int_op(smartlist_len(results),OP_EQ,1); 465 466 tor_addr = smartlist_get(results, 0); 467 addr_len = 468 tor_addr_to_sockaddr(tor_addr,0,(struct sockaddr *)sockaddr_to_check, 469 sizeof(struct sockaddr_in)); 470 471 tt_int_op(addr_len,OP_EQ,sizeof(struct sockaddr_in)); 472 tt_assert(sockaddr_in_are_equal(sockaddr,sockaddr_to_check)); 473 474 ifr = tor_realloc(ifr,2*sizeof(struct ifreq)); 475 ifr_next = ifr+1; 476 strlcpy(ifr_next->ifr_name,"eth1",5); 477 ifc->ifc_len = 2*sizeof(struct ifreq); 478 ifc->ifc_ifcu.ifcu_req = ifr; 479 sockaddr = (struct sockaddr_in *) &(ifr->ifr_ifru.ifru_addr); 480 481 sockaddr_eth1 = (struct sockaddr_in *) &(ifr_next->ifr_ifru.ifru_addr); 482 sockaddr_in_from_string("192.168.10.55",sockaddr_eth1); 483 SMARTLIST_FOREACH(results, tor_addr_t *, t, tor_free(t)); 484 smartlist_free(results); 485 486 results = ifreq_to_smartlist((const uint8_t *)ifc->ifc_buf,ifc->ifc_len); 487 tt_int_op(smartlist_len(results),OP_EQ,2); 488 489 tor_addr = smartlist_get(results, 0); 490 addr_len = 491 tor_addr_to_sockaddr(tor_addr,0,(struct sockaddr *)sockaddr_to_check, 492 sizeof(struct sockaddr_in)); 493 494 tt_int_op(addr_len,OP_EQ,sizeof(struct sockaddr_in)); 495 tt_assert(sockaddr_in_are_equal(sockaddr,sockaddr_to_check)); 496 497 tor_addr = smartlist_get(results, 1); 498 addr_len = 499 tor_addr_to_sockaddr(tor_addr,0,(struct sockaddr *)sockaddr_to_check, 500 sizeof(struct sockaddr_in)); 501 502 tt_int_op(addr_len,OP_EQ,sizeof(struct sockaddr_in)); 503 tt_assert(sockaddr_in_are_equal(sockaddr_eth1,sockaddr_to_check)); 504 505 done: 506 tor_free(sockaddr_to_check); 507 SMARTLIST_FOREACH(results, tor_addr_t *, t, tor_free(t)); 508 smartlist_free(results); 509 tor_free(ifc); 510 tor_free(ifr); 511 return; 512 } 513 514 static void 515 test_address_get_if_addrs_ioctl(void *arg) 516 { 517 518 smartlist_t *result = NULL; 519 520 (void)arg; 521 522 result = get_interface_addresses_ioctl(LOG_ERR, AF_INET); 523 524 /* On an IPv6-only system, this will fail and return NULL 525 tt_assert(result); 526 */ 527 528 /* Some FreeBSD jails don't have localhost IP address. Instead, they only 529 * have the address assigned to the jail (whatever that may be). 530 * And a jail without a network connection might not have any addresses at 531 * all. */ 532 if (result) { 533 tt_assert(!smartlist_contains_null_tor_addr(result)); 534 535 /* If there are addresses, they must be IPv4 or IPv6. 536 * (AIX supports IPv6 from SIOCGIFCONF.) */ 537 if (smartlist_len(result) > 0) { 538 tt_assert(smartlist_contains_ipv4_tor_addr(result) 539 || smartlist_contains_ipv6_tor_addr(result)); 540 } 541 } 542 543 done: 544 if (result) { 545 SMARTLIST_FOREACH(result, tor_addr_t *, t, tor_free(t)); 546 smartlist_free(result); 547 } 548 return; 549 } 550 551 #endif /* defined(HAVE_IFCONF_TO_SMARTLIST) */ 552 553 #define FAKE_SOCKET_FD (42) 554 555 static tor_socket_t 556 fake_open_socket(int domain, int type, int protocol) 557 { 558 (void)domain; 559 (void)type; 560 (void)protocol; 561 562 return FAKE_SOCKET_FD; 563 } 564 565 static int 566 fake_close_socket(tor_socket_t s) 567 { 568 (void)s; 569 return 0; 570 } 571 572 static int last_connected_socket_fd = 0; 573 574 static int connect_retval = 0; 575 576 static tor_socket_t 577 pretend_to_connect(tor_socket_t sock, const struct sockaddr *address, 578 socklen_t address_len) 579 { 580 (void)address; 581 (void)address_len; 582 583 last_connected_socket_fd = sock; 584 585 return connect_retval; 586 } 587 588 static struct sockaddr *mock_addr = NULL; 589 590 static int 591 fake_getsockname(tor_socket_t sock, struct sockaddr *address, 592 socklen_t *address_len) 593 { 594 socklen_t bytes_to_copy = 0; 595 (void) sock; 596 597 if (!mock_addr) 598 return -1; 599 600 if (mock_addr->sa_family == AF_INET) { 601 bytes_to_copy = sizeof(struct sockaddr_in); 602 } else if (mock_addr->sa_family == AF_INET6) { 603 bytes_to_copy = sizeof(struct sockaddr_in6); 604 } else { 605 return -1; 606 } 607 608 if (*address_len < bytes_to_copy) { 609 return -1; 610 } 611 612 memcpy(address,mock_addr,bytes_to_copy); 613 *address_len = bytes_to_copy; 614 615 return 0; 616 } 617 618 static void 619 test_address_udp_socket_trick_whitebox(void *arg) 620 { 621 int hack_retval; 622 tor_addr_t *addr_from_hack = tor_malloc_zero(sizeof(tor_addr_t)); 623 struct sockaddr_in6 *mock_addr6; 624 struct sockaddr_in6 *ipv6_to_check = 625 tor_malloc_zero(sizeof(struct sockaddr_in6)); 626 627 (void)arg; 628 629 MOCK(tor_open_socket,fake_open_socket); 630 MOCK(tor_connect_socket,pretend_to_connect); 631 MOCK(tor_getsockname,fake_getsockname); 632 MOCK(tor_close_socket,fake_close_socket); 633 634 mock_addr = tor_malloc_zero(sizeof(struct sockaddr_storage)); 635 sockaddr_in_from_string("23.32.246.118",(struct sockaddr_in *)mock_addr); 636 637 hack_retval = 638 get_interface_address6_via_udp_socket_hack(LOG_DEBUG, 639 AF_INET, addr_from_hack); 640 641 tt_int_op(hack_retval,OP_EQ,0); 642 tt_assert(tor_addr_eq_ipv4h(addr_from_hack, 0x1720f676)); 643 644 /* Now, lets do an IPv6 case. */ 645 memset(mock_addr,0,sizeof(struct sockaddr_storage)); 646 647 mock_addr6 = (struct sockaddr_in6 *)mock_addr; 648 mock_addr6->sin6_family = AF_INET6; 649 mock_addr6->sin6_port = 0; 650 tor_inet_pton(AF_INET6,"2001:cdba::3257:9652",&(mock_addr6->sin6_addr)); 651 652 hack_retval = 653 get_interface_address6_via_udp_socket_hack(LOG_DEBUG, 654 AF_INET6, addr_from_hack); 655 656 tt_int_op(hack_retval,OP_EQ,0); 657 658 tor_addr_to_sockaddr(addr_from_hack,0,(struct sockaddr *)ipv6_to_check, 659 sizeof(struct sockaddr_in6)); 660 661 tt_assert(sockaddr_in6_are_equal(mock_addr6,ipv6_to_check)); 662 663 done: 664 UNMOCK(tor_open_socket); 665 UNMOCK(tor_connect_socket); 666 UNMOCK(tor_getsockname); 667 UNMOCK(tor_close_socket); 668 669 tor_free(ipv6_to_check); 670 tor_free(mock_addr); 671 tor_free(addr_from_hack); 672 return; 673 } 674 675 static void 676 test_address_udp_socket_trick_blackbox(void *arg) 677 { 678 /* We want get_interface_address6_via_udp_socket_hack() to yield 679 * the same valid address that get_interface_address6() returns. 680 * If the latter is unable to find a valid address, we want 681 * _hack() to fail and return-1. 682 * 683 * Furthermore, we want _hack() never to crash, even if 684 * get_interface_addresses_raw() is returning NULL. 685 */ 686 687 tor_addr_t addr4; 688 tor_addr_t addr4_to_check; 689 tor_addr_t addr6; 690 tor_addr_t addr6_to_check; 691 int retval, retval_reference; 692 693 (void)arg; 694 695 #if 0 696 retval_reference = get_interface_address6(LOG_DEBUG,AF_INET,&addr4); 697 retval = get_interface_address6_via_udp_socket_hack(LOG_DEBUG, 698 AF_INET, 699 &addr4_to_check); 700 701 tt_int_op(retval,OP_EQ,retval_reference); 702 tt_assert( (retval == -1 && retval_reference == -1) || 703 (tor_addr_compare(&addr4,&addr4_to_check,CMP_EXACT) == 0) ); 704 705 retval_reference = get_interface_address6(LOG_DEBUG,AF_INET6,&addr6); 706 retval = get_interface_address6_via_udp_socket_hack(LOG_DEBUG, 707 AF_INET6, 708 &addr6_to_check); 709 710 tt_int_op(retval,OP_EQ,retval_reference); 711 tt_assert( (retval == -1 && retval_reference == -1) || 712 (tor_addr_compare(&addr6,&addr6_to_check,CMP_EXACT) == 0) ); 713 714 #else /* !(0) */ 715 /* Both of the blackbox test cases fail horribly if: 716 * * The host has no external addresses. 717 * * There are multiple interfaces with either AF_INET or AF_INET6. 718 * * The last address isn't the one associated with the default route. 719 * 720 * The tests SHOULD be re-enabled when #12377 is fixed correctly, but till 721 * then this fails a lot, in situations we expect failures due to knowing 722 * about the code being broken. 723 */ 724 725 (void)addr4_to_check; 726 (void)addr6_to_check; 727 (void)addr6; 728 (void) retval_reference; 729 #endif /* 0 */ 730 731 /* When family is neither AF_INET nor AF_INET6, we want _hack to 732 * fail and return -1. 733 */ 734 735 retval = get_interface_address6_via_udp_socket_hack(LOG_DEBUG, 736 AF_INET+AF_INET6,&addr4); 737 738 tt_int_op(retval, OP_EQ, -1); 739 740 done: 741 return; 742 } 743 744 static void 745 test_address_get_if_addrs_list_internal(void *arg) 746 { 747 smartlist_t *results = NULL; 748 749 (void)arg; 750 751 results = get_interface_address_list(LOG_WARN, 1); 752 753 tt_ptr_op(results, OP_NE, NULL); 754 /* When the network is down, a system might not have any non-local 755 * non-multicast addresseses, not even internal ones. 756 * Unit tests shouldn't fail because of this. */ 757 tt_int_op(smartlist_len(results),OP_GE,0); 758 759 tt_assert(!smartlist_contains_localhost_tor_addr(results)); 760 tt_assert(!smartlist_contains_multicast_tor_addr(results)); 761 /* The list may or may not contain internal addresses */ 762 tt_assert(!smartlist_contains_null_tor_addr(results)); 763 764 /* if there are any addresses, they must be IPv4 */ 765 if (smartlist_len(results) > 0) { 766 tt_assert(smartlist_contains_ipv4_tor_addr(results)); 767 } 768 tt_assert(!smartlist_contains_ipv6_tor_addr(results)); 769 770 done: 771 interface_address_list_free(results); 772 return; 773 } 774 775 static void 776 test_address_get_if_addrs_list_no_internal(void *arg) 777 { 778 smartlist_t *results = NULL; 779 780 (void)arg; 781 782 results = get_interface_address_list(LOG_WARN, 0); 783 784 tt_ptr_op(results, OP_NE, NULL); 785 /* Work even on systems with only internal IPv4 addresses */ 786 tt_int_op(smartlist_len(results),OP_GE,0); 787 788 tt_assert(!smartlist_contains_localhost_tor_addr(results)); 789 tt_assert(!smartlist_contains_multicast_tor_addr(results)); 790 tt_assert(!smartlist_contains_internal_tor_addr(results)); 791 tt_assert(!smartlist_contains_null_tor_addr(results)); 792 793 /* if there are any addresses, they must be IPv4 */ 794 if (smartlist_len(results) > 0) { 795 tt_assert(smartlist_contains_ipv4_tor_addr(results)); 796 } 797 tt_assert(!smartlist_contains_ipv6_tor_addr(results)); 798 799 done: 800 interface_address_list_free(results); 801 return; 802 } 803 804 static void 805 test_address_get_if_addrs6_list_internal(void *arg) 806 { 807 smartlist_t *results = NULL; 808 809 (void)arg; 810 811 /* We might drop a log_err */ 812 setup_full_capture_of_logs(LOG_ERR); 813 results = get_interface_address6_list(LOG_ERR, AF_INET6, 1); 814 tt_int_op(smartlist_len(mock_saved_logs()), OP_LE, 1); 815 if (smartlist_len(mock_saved_logs()) == 1) { 816 expect_log_msg_containing_either4("connect() failed", 817 "unable to create socket", 818 "Address that we determined via UDP " 819 "socket magic is unsuitable for public " 820 "comms.", 821 "getsockname() to determine interface " 822 "failed"); 823 } 824 teardown_capture_of_logs(); 825 826 tt_ptr_op(results, OP_NE, NULL); 827 /* Work even on systems without IPv6 interfaces */ 828 tt_int_op(smartlist_len(results),OP_GE,0); 829 830 tt_assert(!smartlist_contains_localhost_tor_addr(results)); 831 tt_assert(!smartlist_contains_multicast_tor_addr(results)); 832 /* The list may or may not contain internal addresses */ 833 tt_assert(!smartlist_contains_null_tor_addr(results)); 834 835 /* if there are any addresses, they must be IPv6 */ 836 tt_assert(!smartlist_contains_ipv4_tor_addr(results)); 837 if (smartlist_len(results) > 0) { 838 tt_assert(smartlist_contains_ipv6_tor_addr(results)); 839 } 840 841 done: 842 interface_address6_list_free(results); 843 teardown_capture_of_logs(); 844 return; 845 } 846 847 static void 848 test_address_get_if_addrs6_list_no_internal(void *arg) 849 { 850 smartlist_t *results = NULL; 851 852 (void)arg; 853 854 /* We might drop a log_err */ 855 setup_full_capture_of_logs(LOG_ERR); 856 results = get_interface_address6_list(LOG_ERR, AF_INET6, 0); 857 tt_int_op(smartlist_len(mock_saved_logs()), OP_LE, 1); 858 if (smartlist_len(mock_saved_logs()) == 1) { 859 expect_log_msg_containing_either4("connect() failed", 860 "unable to create socket", 861 "Address that we determined via UDP " 862 "socket magic is unsuitable for public " 863 "comms.", 864 "getsockname() to determine interface " 865 "failed"); 866 } 867 teardown_capture_of_logs(); 868 869 tt_ptr_op(results, OP_NE, NULL); 870 /* Work even on systems without IPv6 interfaces */ 871 tt_int_op(smartlist_len(results),OP_GE,0); 872 873 tt_assert(!smartlist_contains_localhost_tor_addr(results)); 874 tt_assert(!smartlist_contains_multicast_tor_addr(results)); 875 tt_assert(!smartlist_contains_internal_tor_addr(results)); 876 tt_assert(!smartlist_contains_null_tor_addr(results)); 877 878 /* if there are any addresses, they must be IPv6 */ 879 tt_assert(!smartlist_contains_ipv4_tor_addr(results)); 880 if (smartlist_len(results) > 0) { 881 tt_assert(smartlist_contains_ipv6_tor_addr(results)); 882 } 883 884 done: 885 teardown_capture_of_logs(); 886 interface_address6_list_free(results); 887 return; 888 } 889 890 static int called_get_interface_addresses_raw = 0; 891 892 static smartlist_t * 893 mock_get_interface_addresses_raw_fail(int severity, sa_family_t family) 894 { 895 (void)severity; 896 (void)family; 897 898 called_get_interface_addresses_raw++; 899 return smartlist_new(); 900 } 901 902 static int called_get_interface_address6_via_udp_socket_hack = 0; 903 904 static int 905 mock_get_interface_address6_via_udp_socket_hack_fail(int severity, 906 sa_family_t family, 907 tor_addr_t *addr) 908 { 909 (void)severity; 910 (void)family; 911 (void)addr; 912 913 called_get_interface_address6_via_udp_socket_hack++; 914 return -1; 915 } 916 917 static void 918 test_address_get_if_addrs_internal_fail(void *arg) 919 { 920 smartlist_t *results1 = NULL, *results2 = NULL; 921 int rv = 0; 922 uint32_t ipv4h_addr = 0; 923 tor_addr_t ipv6_addr; 924 925 memset(&ipv6_addr, 0, sizeof(tor_addr_t)); 926 927 (void)arg; 928 929 MOCK(get_interface_addresses_raw, 930 mock_get_interface_addresses_raw_fail); 931 MOCK(get_interface_address6_via_udp_socket_hack, 932 mock_get_interface_address6_via_udp_socket_hack_fail); 933 934 results1 = get_interface_address6_list(LOG_ERR, AF_INET6, 1); 935 tt_ptr_op(results1, OP_NE, NULL); 936 tt_int_op(smartlist_len(results1),OP_EQ,0); 937 938 results2 = get_interface_address_list(LOG_ERR, 1); 939 tt_ptr_op(results2, OP_NE, NULL); 940 tt_int_op(smartlist_len(results2),OP_EQ,0); 941 942 rv = get_interface_address6(LOG_ERR, AF_INET6, &ipv6_addr); 943 tt_int_op(rv, OP_EQ, -1); 944 945 rv = get_interface_address(LOG_ERR, &ipv4h_addr); 946 tt_int_op(rv, OP_EQ, -1); 947 948 done: 949 UNMOCK(get_interface_addresses_raw); 950 UNMOCK(get_interface_address6_via_udp_socket_hack); 951 interface_address6_list_free(results1); 952 interface_address6_list_free(results2); 953 return; 954 } 955 956 static void 957 test_address_get_if_addrs_no_internal_fail(void *arg) 958 { 959 smartlist_t *results1 = NULL, *results2 = NULL; 960 961 (void)arg; 962 963 MOCK(get_interface_addresses_raw, 964 mock_get_interface_addresses_raw_fail); 965 MOCK(get_interface_address6_via_udp_socket_hack, 966 mock_get_interface_address6_via_udp_socket_hack_fail); 967 968 results1 = get_interface_address6_list(LOG_ERR, AF_INET6, 0); 969 tt_ptr_op(results1, OP_NE, NULL); 970 tt_int_op(smartlist_len(results1),OP_EQ,0); 971 972 results2 = get_interface_address_list(LOG_ERR, 0); 973 tt_ptr_op(results2, OP_NE, NULL); 974 tt_int_op(smartlist_len(results2),OP_EQ,0); 975 976 done: 977 UNMOCK(get_interface_addresses_raw); 978 UNMOCK(get_interface_address6_via_udp_socket_hack); 979 interface_address6_list_free(results1); 980 interface_address6_list_free(results2); 981 return; 982 } 983 984 static void 985 test_address_get_if_addrs(void *arg) 986 { 987 int rv; 988 uint32_t addr_h = 0; 989 tor_addr_t tor_addr; 990 991 (void)arg; 992 993 rv = get_interface_address(LOG_WARN, &addr_h); 994 995 /* When the network is down, a system might not have any non-local 996 * non-multicast IPv4 addresses, not even internal ones. 997 * Unit tests shouldn't fail because of this. */ 998 if (rv == 0) { 999 tor_addr_from_ipv4h(&tor_addr, addr_h); 1000 1001 tt_assert(!tor_addr_is_loopback(&tor_addr)); 1002 tt_assert(!tor_addr_is_multicast(&tor_addr)); 1003 /* The address may or may not be an internal address */ 1004 1005 tt_assert(tor_addr_is_v4(&tor_addr)); 1006 } 1007 1008 done: 1009 return; 1010 } 1011 1012 static void 1013 test_address_get_if_addrs6(void *arg) 1014 { 1015 int rv; 1016 tor_addr_t tor_addr; 1017 1018 (void)arg; 1019 1020 rv = get_interface_address6(LOG_WARN, AF_INET6, &tor_addr); 1021 1022 /* Work even on systems without IPv6 interfaces */ 1023 if (rv == 0) { 1024 tt_assert(!tor_addr_is_loopback(&tor_addr)); 1025 tt_assert(!tor_addr_is_multicast(&tor_addr)); 1026 /* The address may or may not be an internal address */ 1027 1028 tt_assert(!tor_addr_is_v4(&tor_addr)); 1029 } 1030 1031 done: 1032 return; 1033 } 1034 1035 static void 1036 test_address_tor_addr_to_in6(void *ignored) 1037 { 1038 (void)ignored; 1039 tor_addr_t *a = tor_malloc_zero(sizeof(tor_addr_t)); 1040 const struct in6_addr *res; 1041 uint8_t expected[16] = {42, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1042 10, 11, 12, 13, 14, 15}; 1043 1044 a->family = AF_INET; 1045 res = tor_addr_to_in6(a); 1046 tt_assert(!res); 1047 1048 a->family = AF_INET6; 1049 memcpy(a->addr.in6_addr.s6_addr, expected, 16); 1050 res = tor_addr_to_in6(a); 1051 tt_assert(res); 1052 tt_mem_op(res->s6_addr, OP_EQ, expected, 16); 1053 1054 done: 1055 tor_free(a); 1056 } 1057 1058 static void 1059 test_address_tor_addr_to_in(void *ignored) 1060 { 1061 (void)ignored; 1062 tor_addr_t *a = tor_malloc_zero(sizeof(tor_addr_t)); 1063 const struct in_addr *res; 1064 1065 a->family = AF_INET6; 1066 res = tor_addr_to_in(a); 1067 tt_assert(!res); 1068 1069 a->family = AF_INET; 1070 a->addr.in_addr.s_addr = 44; 1071 res = tor_addr_to_in(a); 1072 tt_assert(res); 1073 tt_int_op(res->s_addr, OP_EQ, 44); 1074 1075 done: 1076 tor_free(a); 1077 } 1078 1079 static void 1080 test_address_tor_addr_to_ipv4n(void *ignored) 1081 { 1082 (void)ignored; 1083 tor_addr_t *a = tor_malloc_zero(sizeof(tor_addr_t)); 1084 uint32_t res; 1085 1086 a->family = AF_INET6; 1087 res = tor_addr_to_ipv4n(a); 1088 tt_assert(!res); 1089 1090 a->family = AF_INET; 1091 a->addr.in_addr.s_addr = 43; 1092 res = tor_addr_to_ipv4n(a); 1093 tt_assert(res); 1094 tt_int_op(res, OP_EQ, 43); 1095 1096 done: 1097 tor_free(a); 1098 } 1099 1100 static void 1101 test_address_tor_addr_to_mapped_ipv4h(void *ignored) 1102 { 1103 (void)ignored; 1104 tor_addr_t *a = tor_malloc_zero(sizeof(tor_addr_t)); 1105 uint32_t res; 1106 uint8_t toset[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 42}; 1107 1108 a->family = AF_INET; 1109 res = tor_addr_to_mapped_ipv4h(a); 1110 tt_assert(!res); 1111 1112 a->family = AF_INET6; 1113 1114 memcpy(a->addr.in6_addr.s6_addr, toset, 16); 1115 res = tor_addr_to_mapped_ipv4h(a); 1116 tt_assert(res); 1117 tt_int_op(res, OP_EQ, 42); 1118 1119 done: 1120 tor_free(a); 1121 } 1122 1123 static void 1124 test_address_tor_addr_eq_ipv4h(void *ignored) 1125 { 1126 (void)ignored; 1127 tor_addr_t *a = tor_malloc_zero(sizeof(tor_addr_t)); 1128 int res; 1129 1130 a->family = AF_INET6; 1131 res = tor_addr_eq_ipv4h(a, 42); 1132 tt_assert(!res); 1133 1134 a->family = AF_INET; 1135 a->addr.in_addr.s_addr = 52; 1136 res = tor_addr_eq_ipv4h(a, 42); 1137 tt_assert(!res); 1138 1139 a->addr.in_addr.s_addr = 52; 1140 res = tor_addr_eq_ipv4h(a, ntohl(52)); 1141 tt_assert(res); 1142 1143 done: 1144 tor_free(a); 1145 } 1146 1147 static void 1148 test_address_tor_addr_in_same_network_family(void *ignored) 1149 { 1150 (void)ignored; 1151 tor_addr_t a, b; 1152 1153 tor_addr_parse(&a, "8.8.8.8"); 1154 tor_addr_parse(&b, "8.8.4.4"); 1155 tt_int_op(router_addrs_in_same_network(&a, &b), OP_EQ, 1); 1156 1157 tor_addr_parse(&a, "8.8.8.8"); 1158 tor_addr_parse(&b, "1.1.1.1"); 1159 tt_int_op(router_addrs_in_same_network(&a, &b), OP_EQ, 0); 1160 1161 tor_addr_parse(&a, "8.8.8.8"); 1162 tor_addr_parse(&b, "2001:4860:4860::8844"); 1163 tt_int_op(router_addrs_in_same_network(&a, &b), OP_EQ, 0); 1164 1165 tor_addr_parse(&a, "2001:4860:4860::8888"); 1166 tor_addr_parse(&b, "2001:4860:4860::8844"); 1167 tt_int_op(router_addrs_in_same_network(&a, &b), OP_EQ, 1); 1168 1169 tor_addr_parse(&a, "2001:4860:4860::8888"); 1170 tor_addr_parse(&b, "2001:470:20::2"); 1171 tt_int_op(router_addrs_in_same_network(&a, &b), OP_EQ, 0); 1172 1173 done: 1174 return; 1175 } 1176 1177 static node_t * 1178 helper_create_mock_node(char id_char) 1179 { 1180 node_t *node = tor_malloc_zero(sizeof(node_t)); 1181 routerinfo_t *ri = tor_malloc_zero(sizeof(routerinfo_t)); 1182 tor_addr_make_null(&ri->ipv6_addr, AF_INET6); 1183 node->ri = ri; 1184 memset(node->identity, id_char, sizeof(node->identity)); 1185 return node; 1186 } 1187 1188 static void 1189 helper_free_mock_node(node_t *node) 1190 { 1191 if (!node) 1192 return; 1193 tor_free(node->ri); 1194 tor_free(node); 1195 } 1196 1197 #define NODE_SET_IPV4(node, ipv4_addr_str, ipv4_port) { \ 1198 tor_addr_parse(&(node)->ri->ipv4_addr, ipv4_addr_str); \ 1199 node->ri->ipv4_orport = ipv4_port; \ 1200 } 1201 1202 #define NODE_CLEAR_IPV4(node) { \ 1203 tor_addr_make_unspec(&node->ri->ipv4_addr); \ 1204 node->ri->ipv4_orport = 0; \ 1205 } 1206 1207 #define NODE_SET_IPV6(node, ipv6_addr_str, ipv6_port) { \ 1208 tor_addr_parse(&node->ri->ipv6_addr, ipv6_addr_str); \ 1209 node->ri->ipv6_orport = ipv6_port; \ 1210 } 1211 1212 static void 1213 test_address_tor_node_in_same_network_family(void *ignored) 1214 { 1215 (void)ignored; 1216 node_t *node_a = helper_create_mock_node('a'); 1217 node_t *node_b = helper_create_mock_node('b'); 1218 1219 NODE_SET_IPV4(node_a, "8.8.8.8", 1); 1220 NODE_SET_IPV4(node_b, "8.8.4.4", 1); 1221 1222 tt_int_op(nodes_in_same_family(node_a, node_b), OP_EQ, 1); 1223 1224 NODE_SET_IPV4(node_a, "8.8.8.8", 1); 1225 NODE_SET_IPV4(node_b, "1.1.1.1", 1); 1226 1227 tt_int_op(nodes_in_same_family(node_a, node_b), OP_EQ, 0); 1228 1229 NODE_CLEAR_IPV4(node_a); 1230 NODE_SET_IPV6(node_a, "2001:470:20::2", 1); 1231 1232 tt_int_op(nodes_in_same_family(node_a, node_b), OP_EQ, 0); 1233 1234 NODE_CLEAR_IPV4(node_b); 1235 NODE_SET_IPV6(node_b, "2606:4700:4700::1111", 1); 1236 1237 tt_int_op(nodes_in_same_family(node_a, node_b), OP_EQ, 0); 1238 1239 NODE_SET_IPV6(node_a, "2606:4700:4700::1001", 1); 1240 tt_int_op(nodes_in_same_family(node_a, node_b), OP_EQ, 1); 1241 1242 done: 1243 helper_free_mock_node(node_a); 1244 helper_free_mock_node(node_b); 1245 } 1246 1247 static or_options_t mock_options; 1248 1249 static const or_options_t * 1250 mock_get_options(void) 1251 { 1252 return &mock_options; 1253 } 1254 1255 /* Test dirserv_router_has_valid_address() on a stub routerinfo, with only its 1256 * address fields set. Use IPv4 ipv4_addr_str and IPv6 ipv6_addr_str. 1257 * Fail if it does not return rv. */ 1258 #define TEST_ROUTER_VALID_ADDRESS_HELPER(ipv4_addr_str, ipv6_addr_str, rv) \ 1259 STMT_BEGIN \ 1260 ri = tor_malloc_zero(sizeof(routerinfo_t)); \ 1261 tor_addr_parse(&ri->ipv4_addr, (ipv4_addr_str)); \ 1262 tor_addr_parse(&ri->ipv6_addr, (ipv6_addr_str)); \ 1263 tt_int_op(dirserv_router_has_valid_address(ri), OP_EQ, (rv)); \ 1264 tor_free(ri); \ 1265 STMT_END 1266 1267 /* Like TEST_ROUTER_VALID_ADDRESS_HELPER(), but always passes a null 1268 * IPv6 address. */ 1269 #define CHECK_RI_ADDR(ipv4_addr_str, rv) \ 1270 TEST_ROUTER_VALID_ADDRESS_HELPER(ipv4_addr_str, "::", rv) 1271 1272 /* Like TEST_ROUTER_VALID_ADDRESS_HELPER(), but always passes a non-internal 1273 * IPv4 address, so that the IPv6 check is reached. */ 1274 #define CHECK_RI_ADDR6(ipv6_addr_str, rv) \ 1275 TEST_ROUTER_VALID_ADDRESS_HELPER("1.0.0.1", ipv6_addr_str, rv) 1276 1277 static void 1278 test_address_dirserv_router_addr_private(void *opt_dir_allow_private) 1279 { 1280 /* A stub routerinfo structure, with only its address fields set. */ 1281 routerinfo_t *ri = NULL; 1282 /* The expected return value for private addresses. 1283 * Modified if DirAllowPrivateAddresses is 1. */ 1284 int private_rv = -1; 1285 1286 memset(&mock_options, 0, sizeof(or_options_t)); 1287 MOCK(get_options, mock_get_options); 1288 1289 if (opt_dir_allow_private) { 1290 mock_options.DirAllowPrivateAddresses = 1; 1291 private_rv = 0; 1292 } 1293 1294 CHECK_RI_ADDR("1.0.0.1", 0); 1295 CHECK_RI_ADDR("10.0.0.1", private_rv); 1296 1297 CHECK_RI_ADDR6("2600::1", 0); 1298 CHECK_RI_ADDR6("fe80::1", private_rv); 1299 1300 /* Null addresses */ 1301 /* IPv4 null fails, regardless of IPv6 */ 1302 CHECK_RI_ADDR("0.0.0.0", private_rv); 1303 TEST_ROUTER_VALID_ADDRESS_HELPER("0.0.0.0", "::", private_rv); 1304 1305 /* IPv6 null succeeds, because IPv4 is not null */ 1306 CHECK_RI_ADDR6("::", 0); 1307 1308 /* Byte-zeroed null addresses */ 1309 /* IPv4 null fails, regardless of IPv6 */ 1310 { 1311 ri = tor_malloc_zero(sizeof(routerinfo_t)); 1312 tt_int_op(dirserv_router_has_valid_address(ri), OP_EQ, private_rv); 1313 tor_free(ri); 1314 } 1315 1316 /* IPv6 null succeeds, because IPv4 is not internal */ 1317 { 1318 ri = tor_malloc_zero(sizeof(routerinfo_t)); 1319 tor_addr_parse(&ri->ipv4_addr, "1.0.0.1"); 1320 tt_int_op(dirserv_router_has_valid_address(ri), OP_EQ, 0); 1321 tor_free(ri); 1322 } 1323 1324 done: 1325 tor_free(ri); 1326 UNMOCK(get_options); 1327 } 1328 1329 static void 1330 test_address_parse_port_range(void *arg) 1331 { 1332 int ret; 1333 uint16_t min_out = 0; 1334 uint16_t max_out = 0; 1335 1336 (void) arg; 1337 1338 /* Invalid. */ 1339 ret = parse_port_range("0x00", &min_out, &max_out); 1340 tt_int_op(ret, OP_EQ, -1); 1341 ret = parse_port_range("0x01", &min_out, &max_out); 1342 tt_int_op(ret, OP_EQ, -1); 1343 ret = parse_port_range("1817161", &min_out, &max_out); 1344 tt_int_op(ret, OP_EQ, -1); 1345 ret = parse_port_range("65536", &min_out, &max_out); 1346 tt_int_op(ret, OP_EQ, -1); 1347 ret = parse_port_range("1-65536", &min_out, &max_out); 1348 tt_int_op(ret, OP_EQ, -1); 1349 1350 /* Valid. */ 1351 ret = parse_port_range("65535", &min_out, &max_out); 1352 tt_int_op(ret, OP_EQ, 0); 1353 tt_int_op(min_out, OP_EQ, 65535); 1354 tt_int_op(max_out, OP_EQ, 65535); 1355 1356 ret = parse_port_range("1-65535", &min_out, &max_out); 1357 tt_int_op(ret, OP_EQ, 0); 1358 tt_int_op(min_out, OP_EQ, 1); 1359 tt_int_op(max_out, OP_EQ, 65535); 1360 1361 done: 1362 ; 1363 } 1364 1365 #define ADDRESS_TEST(name, flags) \ 1366 { #name, test_address_ ## name, flags, NULL, NULL } 1367 #define ADDRESS_TEST_STR_ARG(name, flags, str_arg) \ 1368 { #name "/" str_arg, test_address_ ## name, flags, &passthrough_setup, \ 1369 (void *)(str_arg) } 1370 1371 struct testcase_t address_tests[] = { 1372 ADDRESS_TEST(udp_socket_trick_whitebox, TT_FORK), 1373 ADDRESS_TEST(udp_socket_trick_blackbox, TT_FORK), 1374 ADDRESS_TEST(get_if_addrs_list_internal, 0), 1375 ADDRESS_TEST(get_if_addrs_list_no_internal, 0), 1376 ADDRESS_TEST(get_if_addrs6_list_internal, 0), 1377 ADDRESS_TEST(get_if_addrs6_list_no_internal, TT_FORK), 1378 ADDRESS_TEST(get_if_addrs_internal_fail, 0), 1379 ADDRESS_TEST(get_if_addrs_no_internal_fail, 0), 1380 ADDRESS_TEST(get_if_addrs, 0), 1381 ADDRESS_TEST(get_if_addrs6, 0), 1382 #ifdef HAVE_IFADDRS_TO_SMARTLIST 1383 ADDRESS_TEST(get_if_addrs_ifaddrs, TT_FORK), 1384 ADDRESS_TEST(ifaddrs_to_smartlist, 0), 1385 #endif 1386 #ifdef HAVE_IP_ADAPTER_TO_SMARTLIST 1387 ADDRESS_TEST(get_if_addrs_win32, TT_FORK), 1388 ADDRESS_TEST(ip_adapter_addresses_to_smartlist, 0), 1389 #endif 1390 #ifdef HAVE_IFCONF_TO_SMARTLIST 1391 ADDRESS_TEST(get_if_addrs_ioctl, TT_FORK), 1392 ADDRESS_TEST(ifreq_to_smartlist, 0), 1393 #endif 1394 ADDRESS_TEST(tor_addr_to_in6, 0), 1395 ADDRESS_TEST(tor_addr_to_in, 0), 1396 ADDRESS_TEST(tor_addr_to_ipv4n, 0), 1397 ADDRESS_TEST(tor_addr_to_mapped_ipv4h, 0), 1398 ADDRESS_TEST(tor_addr_eq_ipv4h, 0), 1399 ADDRESS_TEST(tor_addr_in_same_network_family, 0), 1400 ADDRESS_TEST(tor_node_in_same_network_family, 0), 1401 ADDRESS_TEST(dirserv_router_addr_private, 0), 1402 ADDRESS_TEST_STR_ARG(dirserv_router_addr_private, 0, "allow_private"), 1403 ADDRESS_TEST(parse_port_range, 0), 1404 END_OF_TESTCASES 1405 };