1 /* Copyright (c) 2014-2021, The Tor Project, Inc. */
2 /* See LICENSE for licensing information */
4 #define ADDRESS_PRIVATE
10 /* For access to structs needed by GetAdaptersAddresses */
14 #ifdef HAVE_IFADDRS_TO_SMARTLIST
19 #ifdef HAVE_IFCONF_TO_SMARTLIST
20 #ifdef HAVE_SYS_IOCTL_H
21 #include <sys/ioctl.h>
24 #endif /* defined(HAVE_IFCONF_TO_SMARTLIST) */
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"
36 /** Return 1 iff <b>sockaddr1</b> and <b>sockaddr2</b> represent
37 * the same IP address and port combination. Otherwise, return 0.
40 sockaddr_in_are_equal(struct sockaddr_in
*sockaddr1
,
41 struct sockaddr_in
*sockaddr2
)
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
));
48 /** Return 1 iff <b>sockaddr1</b> and <b>sockaddr2</b> represent
49 * the same IP address and port combination. Otherwise, return 0.
52 sockaddr_in6_are_equal(struct sockaddr_in6
*sockaddr1
,
53 struct sockaddr_in6
*sockaddr2
)
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)));
61 /** Create a sockaddr_in structure from IP address string <b>ip_str</b>.
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
68 static struct sockaddr_in
*
69 sockaddr_in_from_string(const char *ip_str
, struct sockaddr_in
*out
)
71 // [FIXME: add some error checking?]
73 out
= tor_malloc_zero(sizeof(struct sockaddr_in
));
75 out
->sin_family
= AF_INET
;
77 tor_inet_pton(AF_INET
,ip_str
,&(out
->sin_addr
));
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.
86 smartlist_contains_localhost_tor_addr(smartlist_t
*smartlist
)
88 SMARTLIST_FOREACH_BEGIN(smartlist
, tor_addr_t
*, tor_addr
) {
89 if (tor_addr_is_loopback(tor_addr
)) {
92 } SMARTLIST_FOREACH_END(tor_addr
);
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.
101 smartlist_contains_multicast_tor_addr(smartlist_t
*smartlist
)
103 SMARTLIST_FOREACH_BEGIN(smartlist
, tor_addr_t
*, tor_addr
) {
104 if (tor_addr_is_multicast(tor_addr
)) {
107 } SMARTLIST_FOREACH_END(tor_addr
);
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.
116 smartlist_contains_internal_tor_addr(smartlist_t
*smartlist
)
118 SMARTLIST_FOREACH_BEGIN(smartlist
, tor_addr_t
*, tor_addr
) {
119 if (tor_addr_is_internal(tor_addr
, 0)) {
122 } SMARTLIST_FOREACH_END(tor_addr
);
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.
131 smartlist_contains_null_tor_addr(smartlist_t
*smartlist
)
133 SMARTLIST_FOREACH_BEGIN(smartlist
, tor_addr_t
*, tor_addr
) {
134 if (tor_addr
== NULL
|| tor_addr_is_null(tor_addr
)) {
137 } SMARTLIST_FOREACH_END(tor_addr
);
142 /** Return 1 iff <b>smartlist</b> contains a tor_addr_t structure
143 * that is an IPv4 address. Otherwise, return 0.
146 smartlist_contains_ipv4_tor_addr(smartlist_t
*smartlist
)
148 SMARTLIST_FOREACH_BEGIN(smartlist
, tor_addr_t
*, tor_addr
) {
149 if (tor_addr_is_v4(tor_addr
)) {
152 } SMARTLIST_FOREACH_END(tor_addr
);
157 /** Return 1 iff <b>smartlist</b> contains a tor_addr_t structure
158 * that is an IPv6 address. Otherwise, return 0.
161 smartlist_contains_ipv6_tor_addr(smartlist_t
*smartlist
)
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
)) {
168 } SMARTLIST_FOREACH_END(tor_addr
);
173 #ifdef HAVE_IFADDRS_TO_SMARTLIST
175 test_address_ifaddrs_to_smartlist(void *arg
)
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
;
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
);
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
));
201 ifa
= tor_malloc(sizeof(struct ifaddrs
));
202 ifa_ipv4
= tor_malloc(sizeof(struct ifaddrs
));
203 ifa_ipv6
= tor_malloc(sizeof(struct ifaddrs
));
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
;
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
;
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
;
229 smartlist
= ifaddrs_to_smartlist(ifa
, AF_UNSPEC
);
231 tt_assert(smartlist
);
232 tt_int_op(smartlist_len(smartlist
), OP_EQ
, 3);
234 sockaddr_to_check
= tor_malloc(sizeof(struct sockaddr_in6
));
236 tor_addr
= smartlist_get(smartlist
,0);
238 tor_addr_to_sockaddr(tor_addr
,0,sockaddr_to_check
,
239 sizeof(struct sockaddr_in
));
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
));
245 tor_addr
= smartlist_get(smartlist
,1);
247 tor_addr_to_sockaddr(tor_addr
,0,sockaddr_to_check
,
248 sizeof(struct sockaddr_in
));
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
));
254 tor_addr
= smartlist_get(smartlist
,2);
256 tor_addr_to_sockaddr(tor_addr
,0,sockaddr_to_check
,
257 sizeof(struct sockaddr_in6
));
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
,
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
);
274 tor_free(sockaddr_to_check
);
276 SMARTLIST_FOREACH(smartlist
, tor_addr_t
*, t
, tor_free(t
));
277 smartlist_free(smartlist
);
283 test_address_get_if_addrs_ifaddrs(void *arg
)
286 smartlist_t
*results
= NULL
;
290 results
= get_interface_addresses_ifaddrs(LOG_ERR
, AF_UNSPEC
);
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
297 tt_assert(!smartlist_contains_null_tor_addr(results
));
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
));
307 SMARTLIST_FOREACH(results
, tor_addr_t
*, t
, tor_free(t
));
309 smartlist_free(results
);
313 #endif /* defined(HAVE_IFADDRS_TO_SMARTLIST) */
315 #ifdef HAVE_IP_ADAPTER_TO_SMARTLIST
318 test_address_get_if_addrs_win32(void *arg
)
321 smartlist_t
*results
= NULL
;
325 results
= get_interface_addresses_win32(LOG_ERR
, AF_UNSPEC
);
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
));
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
));
338 SMARTLIST_FOREACH(results
, tor_addr_t
*, t
, tor_free(t
));
344 test_address_ip_adapter_addresses_to_smartlist(void *arg
)
347 IP_ADAPTER_ADDRESSES
*addrs1
;
348 IP_ADAPTER_ADDRESSES
*addrs2
;
350 IP_ADAPTER_UNICAST_ADDRESS
*unicast11
;
351 IP_ADAPTER_UNICAST_ADDRESS
*unicast12
;
352 IP_ADAPTER_UNICAST_ADDRESS
*unicast21
;
354 smartlist_t
*result
= NULL
;
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
;
361 tor_addr_t
*tor_addr
;
364 (void)sockaddr_in6_are_equal
;
366 sockaddr_to_check
= tor_malloc_zero(sizeof(struct sockaddr_in
));
369 tor_malloc_zero(sizeof(IP_ADAPTER_ADDRESSES
));
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
;
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
;
381 addrs1
->Next
= addrs2
=
382 tor_malloc_zero(sizeof(IP_ADAPTER_ADDRESSES
));
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
;
389 result
= ip_adapter_addresses_to_smartlist(addrs1
);
392 tt_int_op(smartlist_len(result
), OP_EQ
, 3);
394 tor_addr
= smartlist_get(result
,0);
396 tor_addr_to_sockaddr(tor_addr
,0,(struct sockaddr
*)sockaddr_to_check
,
397 sizeof(struct sockaddr_in
));
399 tt_assert(sockaddr_in_are_equal(sockaddr_test1
,sockaddr_to_check
));
401 tor_addr
= smartlist_get(result
,1);
403 tor_addr_to_sockaddr(tor_addr
,0,(struct sockaddr
*)sockaddr_to_check
,
404 sizeof(struct sockaddr_in
));
406 tt_assert(sockaddr_in_are_equal(sockaddr_test2
,sockaddr_to_check
));
408 tor_addr
= smartlist_get(result
,2);
410 tor_addr_to_sockaddr(tor_addr
,0,(struct sockaddr
*)sockaddr_to_check
,
411 sizeof(struct sockaddr_in
));
413 tt_assert(sockaddr_in_are_equal(sockaddr_localhost
,sockaddr_to_check
));
416 SMARTLIST_FOREACH(result
, tor_addr_t
*, t
, tor_free(t
));
417 smartlist_free(result
);
420 tor_free(unicast11
->Address
.lpSockaddr
);
422 tor_free(unicast12
->Address
.lpSockaddr
);
424 tor_free(unicast21
->Address
.lpSockaddr
);
426 tor_free(sockaddr_to_check
);
429 #endif /* defined(HAVE_IP_ADAPTER_TO_SMARTLIST) */
431 #ifdef HAVE_IFCONF_TO_SMARTLIST
434 test_address_ifreq_to_smartlist(void *arg
)
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
;
444 struct ifreq
*ifr_next
;
450 sockaddr_to_check
= tor_malloc(sizeof(struct sockaddr_in
));
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
);
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
;
463 results
= ifreq_to_smartlist((const uint8_t *)ifc
->ifc_buf
,ifc
->ifc_len
);
464 tt_int_op(smartlist_len(results
),OP_EQ
,1);
466 tor_addr
= smartlist_get(results
, 0);
468 tor_addr_to_sockaddr(tor_addr
,0,(struct sockaddr
*)sockaddr_to_check
,
469 sizeof(struct sockaddr_in
));
471 tt_int_op(addr_len
,OP_EQ
,sizeof(struct sockaddr_in
));
472 tt_assert(sockaddr_in_are_equal(sockaddr
,sockaddr_to_check
));
474 ifr
= tor_realloc(ifr
,2*sizeof(struct ifreq
));
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
);
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
);
486 results
= ifreq_to_smartlist((const uint8_t *)ifc
->ifc_buf
,ifc
->ifc_len
);
487 tt_int_op(smartlist_len(results
),OP_EQ
,2);
489 tor_addr
= smartlist_get(results
, 0);
491 tor_addr_to_sockaddr(tor_addr
,0,(struct sockaddr
*)sockaddr_to_check
,
492 sizeof(struct sockaddr_in
));
494 tt_int_op(addr_len
,OP_EQ
,sizeof(struct sockaddr_in
));
495 tt_assert(sockaddr_in_are_equal(sockaddr
,sockaddr_to_check
));
497 tor_addr
= smartlist_get(results
, 1);
499 tor_addr_to_sockaddr(tor_addr
,0,(struct sockaddr
*)sockaddr_to_check
,
500 sizeof(struct sockaddr_in
));
502 tt_int_op(addr_len
,OP_EQ
,sizeof(struct sockaddr_in
));
503 tt_assert(sockaddr_in_are_equal(sockaddr_eth1
,sockaddr_to_check
));
506 tor_free(sockaddr_to_check
);
507 SMARTLIST_FOREACH(results
, tor_addr_t
*, t
, tor_free(t
));
508 smartlist_free(results
);
515 test_address_get_if_addrs_ioctl(void *arg
)
518 smartlist_t
*result
= NULL
;
522 result
= get_interface_addresses_ioctl(LOG_ERR
, AF_INET
);
524 /* On an IPv6-only system, this will fail and return NULL
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
533 tt_assert(!smartlist_contains_null_tor_addr(result
));
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
));
545 SMARTLIST_FOREACH(result
, tor_addr_t
*, t
, tor_free(t
));
546 smartlist_free(result
);
551 #endif /* defined(HAVE_IFCONF_TO_SMARTLIST) */
553 #define FAKE_SOCKET_FD (42)
556 fake_open_socket(int domain
, int type
, int protocol
)
562 return FAKE_SOCKET_FD
;
566 fake_close_socket(tor_socket_t s
)
572 static int last_connected_socket_fd
= 0;
574 static int connect_retval
= 0;
577 pretend_to_connect(tor_socket_t sock
, const struct sockaddr
*address
,
578 socklen_t address_len
)
583 last_connected_socket_fd
= sock
;
585 return connect_retval
;
588 static struct sockaddr
*mock_addr
= NULL
;
591 fake_getsockname(tor_socket_t sock
, struct sockaddr
*address
,
592 socklen_t
*address_len
)
594 socklen_t bytes_to_copy
= 0;
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
);
608 if (*address_len
< bytes_to_copy
) {
612 memcpy(address
,mock_addr
,bytes_to_copy
);
613 *address_len
= bytes_to_copy
;
619 test_address_udp_socket_trick_whitebox(void *arg
)
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
));
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
);
634 mock_addr
= tor_malloc_zero(sizeof(struct sockaddr_storage
));
635 sockaddr_in_from_string("23.32.246.118",(struct sockaddr_in
*)mock_addr
);
638 get_interface_address6_via_udp_socket_hack(LOG_DEBUG
,
639 AF_INET
, addr_from_hack
);
641 tt_int_op(hack_retval
,OP_EQ
,0);
642 tt_assert(tor_addr_eq_ipv4h(addr_from_hack
, 0x1720f676));
644 /* Now, lets do an IPv6 case. */
645 memset(mock_addr
,0,sizeof(struct sockaddr_storage
));
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
));
653 get_interface_address6_via_udp_socket_hack(LOG_DEBUG
,
654 AF_INET6
, addr_from_hack
);
656 tt_int_op(hack_retval
,OP_EQ
,0);
658 tor_addr_to_sockaddr(addr_from_hack
,0,(struct sockaddr
*)ipv6_to_check
,
659 sizeof(struct sockaddr_in6
));
661 tt_assert(sockaddr_in6_are_equal(mock_addr6
,ipv6_to_check
));
664 UNMOCK(tor_open_socket
);
665 UNMOCK(tor_connect_socket
);
666 UNMOCK(tor_getsockname
);
667 UNMOCK(tor_close_socket
);
669 tor_free(ipv6_to_check
);
671 tor_free(addr_from_hack
);
676 test_address_udp_socket_trick_blackbox(void *arg
)
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.
683 * Furthermore, we want _hack() never to crash, even if
684 * get_interface_addresses_raw() is returning NULL.
688 tor_addr_t addr4_to_check
;
690 tor_addr_t addr6_to_check
;
691 int retval
, retval_reference
;
696 retval_reference
= get_interface_address6(LOG_DEBUG
,AF_INET
,&addr4
);
697 retval
= get_interface_address6_via_udp_socket_hack(LOG_DEBUG
,
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) );
705 retval_reference
= get_interface_address6(LOG_DEBUG
,AF_INET6
,&addr6
);
706 retval
= get_interface_address6_via_udp_socket_hack(LOG_DEBUG
,
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) );
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.
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.
725 (void)addr4_to_check
;
726 (void)addr6_to_check
;
728 (void) retval_reference
;
731 /* When family is neither AF_INET nor AF_INET6, we want _hack to
732 * fail and return -1.
735 retval
= get_interface_address6_via_udp_socket_hack(LOG_DEBUG
,
736 AF_INET
+AF_INET6
,&addr4
);
738 tt_int_op(retval
, OP_EQ
, -1);
745 test_address_get_if_addrs_list_internal(void *arg
)
747 smartlist_t
*results
= NULL
;
751 results
= get_interface_address_list(LOG_WARN
, 1);
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);
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
));
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
));
768 tt_assert(!smartlist_contains_ipv6_tor_addr(results
));
771 interface_address_list_free(results
);
776 test_address_get_if_addrs_list_no_internal(void *arg
)
778 smartlist_t
*results
= NULL
;
782 results
= get_interface_address_list(LOG_WARN
, 0);
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);
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
));
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
));
797 tt_assert(!smartlist_contains_ipv6_tor_addr(results
));
800 interface_address_list_free(results
);
805 test_address_get_if_addrs6_list_internal(void *arg
)
807 smartlist_t
*results
= NULL
;
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 "
821 "getsockname() to determine interface "
824 teardown_capture_of_logs();
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);
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
));
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
));
842 interface_address6_list_free(results
);
843 teardown_capture_of_logs();
848 test_address_get_if_addrs6_list_no_internal(void *arg
)
850 smartlist_t
*results
= NULL
;
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 "
864 "getsockname() to determine interface "
867 teardown_capture_of_logs();
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);
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
));
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
));
885 teardown_capture_of_logs();
886 interface_address6_list_free(results
);
890 static int called_get_interface_addresses_raw
= 0;
893 mock_get_interface_addresses_raw_fail(int severity
, sa_family_t family
)
898 called_get_interface_addresses_raw
++;
899 return smartlist_new();
902 static int called_get_interface_address6_via_udp_socket_hack
= 0;
905 mock_get_interface_address6_via_udp_socket_hack_fail(int severity
,
913 called_get_interface_address6_via_udp_socket_hack
++;
918 test_address_get_if_addrs_internal_fail(void *arg
)
920 smartlist_t
*results1
= NULL
, *results2
= NULL
;
922 uint32_t ipv4h_addr
= 0;
923 tor_addr_t ipv6_addr
;
925 memset(&ipv6_addr
, 0, sizeof(tor_addr_t
));
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
);
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);
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);
942 rv
= get_interface_address6(LOG_ERR
, AF_INET6
, &ipv6_addr
);
943 tt_int_op(rv
, OP_EQ
, -1);
945 rv
= get_interface_address(LOG_ERR
, &ipv4h_addr
);
946 tt_int_op(rv
, OP_EQ
, -1);
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
);
957 test_address_get_if_addrs_no_internal_fail(void *arg
)
959 smartlist_t
*results1
= NULL
, *results2
= NULL
;
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
);
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);
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);
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
);
985 test_address_get_if_addrs(void *arg
)
993 rv
= get_interface_address(LOG_WARN
, &addr_h
);
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. */
999 tor_addr_from_ipv4h(&tor_addr
, addr_h
);
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 */
1005 tt_assert(tor_addr_is_v4(&tor_addr
));
1013 test_address_get_if_addrs6(void *arg
)
1016 tor_addr_t tor_addr
;
1020 rv
= get_interface_address6(LOG_WARN
, AF_INET6
, &tor_addr
);
1022 /* Work even on systems without IPv6 interfaces */
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 */
1028 tt_assert(!tor_addr_is_v4(&tor_addr
));
1036 test_address_tor_addr_to_in6(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};
1044 a
->family
= AF_INET
;
1045 res
= tor_addr_to_in6(a
);
1048 a
->family
= AF_INET6
;
1049 memcpy(a
->addr
.in6_addr
.s6_addr
, expected
, 16);
1050 res
= tor_addr_to_in6(a
);
1052 tt_mem_op(res
->s6_addr
, OP_EQ
, expected
, 16);
1059 test_address_tor_addr_to_in(void *ignored
)
1062 tor_addr_t
*a
= tor_malloc_zero(sizeof(tor_addr_t
));
1063 const struct in_addr
*res
;
1065 a
->family
= AF_INET6
;
1066 res
= tor_addr_to_in(a
);
1069 a
->family
= AF_INET
;
1070 a
->addr
.in_addr
.s_addr
= 44;
1071 res
= tor_addr_to_in(a
);
1073 tt_int_op(res
->s_addr
, OP_EQ
, 44);
1080 test_address_tor_addr_to_ipv4n(void *ignored
)
1083 tor_addr_t
*a
= tor_malloc_zero(sizeof(tor_addr_t
));
1086 a
->family
= AF_INET6
;
1087 res
= tor_addr_to_ipv4n(a
);
1090 a
->family
= AF_INET
;
1091 a
->addr
.in_addr
.s_addr
= 43;
1092 res
= tor_addr_to_ipv4n(a
);
1094 tt_int_op(res
, OP_EQ
, 43);
1101 test_address_tor_addr_to_mapped_ipv4h(void *ignored
)
1104 tor_addr_t
*a
= tor_malloc_zero(sizeof(tor_addr_t
));
1106 uint8_t toset
[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 42};
1108 a
->family
= AF_INET
;
1109 res
= tor_addr_to_mapped_ipv4h(a
);
1112 a
->family
= AF_INET6
;
1114 memcpy(a
->addr
.in6_addr
.s6_addr
, toset
, 16);
1115 res
= tor_addr_to_mapped_ipv4h(a
);
1117 tt_int_op(res
, OP_EQ
, 42);
1124 test_address_tor_addr_eq_ipv4h(void *ignored
)
1127 tor_addr_t
*a
= tor_malloc_zero(sizeof(tor_addr_t
));
1130 a
->family
= AF_INET6
;
1131 res
= tor_addr_eq_ipv4h(a
, 42);
1134 a
->family
= AF_INET
;
1135 a
->addr
.in_addr
.s_addr
= 52;
1136 res
= tor_addr_eq_ipv4h(a
, 42);
1139 a
->addr
.in_addr
.s_addr
= 52;
1140 res
= tor_addr_eq_ipv4h(a
, ntohl(52));
1148 test_address_tor_addr_in_same_network_family(void *ignored
)
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);
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);
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);
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);
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);
1178 helper_create_mock_node(char id_char
)
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
);
1184 memset(node
->identity
, id_char
, sizeof(node
->identity
));
1189 helper_free_mock_node(node_t
*node
)
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; \
1202 #define NODE_CLEAR_IPV4(node) { \
1203 tor_addr_make_unspec(&node->ri->ipv4_addr); \
1204 node->ri->ipv4_orport = 0; \
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; \
1213 test_address_tor_node_in_same_network_family(void *ignored
)
1216 node_t
*node_a
= helper_create_mock_node('a');
1217 node_t
*node_b
= helper_create_mock_node('b');
1219 NODE_SET_IPV4(node_a
, "8.8.8.8", 1);
1220 NODE_SET_IPV4(node_b
, "8.8.4.4", 1);
1222 tt_int_op(nodes_in_same_family(node_a
, node_b
), OP_EQ
, 1);
1224 NODE_SET_IPV4(node_a
, "8.8.8.8", 1);
1225 NODE_SET_IPV4(node_b
, "1.1.1.1", 1);
1227 tt_int_op(nodes_in_same_family(node_a
, node_b
), OP_EQ
, 0);
1229 NODE_CLEAR_IPV4(node_a
);
1230 NODE_SET_IPV6(node_a
, "2001:470:20::2", 1);
1232 tt_int_op(nodes_in_same_family(node_a
, node_b
), OP_EQ
, 0);
1234 NODE_CLEAR_IPV4(node_b
);
1235 NODE_SET_IPV6(node_b
, "2606:4700:4700::1111", 1);
1237 tt_int_op(nodes_in_same_family(node_a
, node_b
), OP_EQ
, 0);
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);
1243 helper_free_mock_node(node_a
);
1244 helper_free_mock_node(node_b
);
1247 static or_options_t mock_options
;
1249 static const or_options_t
*
1250 mock_get_options(void)
1252 return &mock_options
;
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) \
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)); \
1267 /* Like TEST_ROUTER_VALID_ADDRESS_HELPER(), but always passes a null
1269 #define CHECK_RI_ADDR(ipv4_addr_str, rv) \
1270 TEST_ROUTER_VALID_ADDRESS_HELPER(ipv4_addr_str, "::", rv)
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)
1278 test_address_dirserv_router_addr_private(void *opt_dir_allow_private
)
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;
1286 memset(&mock_options
, 0, sizeof(or_options_t
));
1287 MOCK(get_options
, mock_get_options
);
1289 if (opt_dir_allow_private
) {
1290 mock_options
.DirAllowPrivateAddresses
= 1;
1294 CHECK_RI_ADDR("1.0.0.1", 0);
1295 CHECK_RI_ADDR("10.0.0.1", private_rv
);
1297 CHECK_RI_ADDR6("2600::1", 0);
1298 CHECK_RI_ADDR6("fe80::1", private_rv
);
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
);
1305 /* IPv6 null succeeds, because IPv4 is not null */
1306 CHECK_RI_ADDR6("::", 0);
1308 /* Byte-zeroed null addresses */
1309 /* IPv4 null fails, regardless of IPv6 */
1311 ri
= tor_malloc_zero(sizeof(routerinfo_t
));
1312 tt_int_op(dirserv_router_has_valid_address(ri
), OP_EQ
, private_rv
);
1316 /* IPv6 null succeeds, because IPv4 is not internal */
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);
1326 UNMOCK(get_options
);
1330 test_address_parse_port_range(void *arg
)
1333 uint16_t min_out
= 0;
1334 uint16_t max_out
= 0;
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);
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);
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);
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, \
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),
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),
1390 #ifdef HAVE_IFCONF_TO_SMARTLIST
1391 ADDRESS_TEST(get_if_addrs_ioctl
, TT_FORK
),
1392 ADDRESS_TEST(ifreq_to_smartlist
, 0),
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),