Line data Source code
1 : /* Copyright (c) 2003-2004, Roger Dingledine
2 : * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
3 : * Copyright (c) 2007-2021, The Tor Project, Inc. */
4 : /* See LICENSE for licensing information */
5 :
6 : /**
7 : * \file address.h
8 : * \brief Headers for address.h
9 : **/
10 :
11 : #ifndef TOR_ADDRESS_H
12 : #define TOR_ADDRESS_H
13 :
14 : #include "orconfig.h"
15 : #include "lib/cc/torint.h"
16 : #include "lib/log/util_bug.h"
17 : #include "lib/net/inaddr_st.h"
18 : #include "lib/net/nettypes.h"
19 :
20 : #ifdef HAVE_NETINET_IN_H
21 : #include <netinet/in.h>
22 : #endif
23 : #ifdef _WIN32
24 : #include <winsock2.h>
25 : #include <windows.h>
26 : #endif
27 :
28 : #include <stddef.h>
29 : #include <stdlib.h>
30 :
31 : #ifdef ADDRESS_PRIVATE
32 :
33 : #if defined(HAVE_SYS_IOCTL_H)
34 : #include <sys/ioctl.h>
35 : #endif
36 :
37 : #ifdef HAVE_GETIFADDRS
38 : #define HAVE_IFADDRS_TO_SMARTLIST
39 : #endif
40 :
41 : #ifdef _WIN32
42 : #define HAVE_IP_ADAPTER_TO_SMARTLIST
43 : #endif
44 :
45 : #if defined(SIOCGIFCONF) && defined(HAVE_IOCTL)
46 : #define HAVE_IFCONF_TO_SMARTLIST
47 : #endif
48 :
49 : #if defined(HAVE_NET_IF_H)
50 : #include <net/if.h> // for struct ifconf
51 : #endif
52 :
53 : #if defined(HAVE_IFADDRS_TO_SMARTLIST)
54 : #include <ifaddrs.h>
55 : #endif
56 :
57 : // TODO win32 specific includes
58 : #endif /* defined(ADDRESS_PRIVATE) */
59 :
60 : /** The number of bits from an address to consider while doing a masked
61 : * comparison. */
62 : typedef uint8_t maskbits_t;
63 :
64 : struct in_addr;
65 :
66 : /** Holds an IPv4 or IPv6 address. (Uses less memory than struct
67 : * sockaddr_storage.) */
68 : typedef struct tor_addr_t
69 : {
70 : sa_family_t family;
71 : union {
72 : uint32_t dummy_; /* This field is here so we have something to initialize
73 : * with a reliable cross-platform type. */
74 : struct in_addr in_addr;
75 : struct in6_addr in6_addr;
76 : } addr;
77 : } tor_addr_t;
78 :
79 : /** Holds an IP address and a TCP/UDP port. */
80 : typedef struct tor_addr_port_t
81 : {
82 : tor_addr_t addr;
83 : uint16_t port;
84 : } tor_addr_port_t;
85 :
86 : #define TOR_ADDR_NULL {AF_UNSPEC, {0}}
87 :
88 : /* XXXX To do: extract all of the functions here that can possibly invoke
89 : * XXXX resolver, and make sure they have distinctive names. */
90 :
91 : static inline const struct in6_addr *tor_addr_to_in6(const tor_addr_t *a);
92 : static inline const struct in6_addr *tor_addr_to_in6_assert(
93 : const tor_addr_t *a);
94 : static inline uint32_t tor_addr_to_ipv4n(const tor_addr_t *a);
95 : static inline uint32_t tor_addr_to_ipv4h(const tor_addr_t *a);
96 : static inline uint32_t tor_addr_to_mapped_ipv4h(const tor_addr_t *a);
97 : static inline sa_family_t tor_addr_family(const tor_addr_t *a);
98 : static inline bool tor_addr_is_unspec(const tor_addr_t *a);
99 : static inline const struct in_addr *tor_addr_to_in(const tor_addr_t *a);
100 : static inline int tor_addr_eq_ipv4h(const tor_addr_t *a, uint32_t u);
101 :
102 : socklen_t tor_addr_to_sockaddr(const tor_addr_t *a, uint16_t port,
103 : struct sockaddr *sa_out, socklen_t len);
104 : int tor_addr_from_sockaddr(tor_addr_t *a, const struct sockaddr *sa,
105 : uint16_t *port_out);
106 : void tor_addr_make_unspec(tor_addr_t *a);
107 : void tor_addr_make_null(tor_addr_t *a, sa_family_t family);
108 : #define tor_addr_port_make_null(addr, port, family) \
109 : (void)(tor_addr_make_null(addr, family), (port) = 0)
110 : #define tor_addr_port_make_null_ap(ap, family) \
111 : tor_addr_port_make_null(&(ap)->addr, (ap)->port, family)
112 : char *tor_sockaddr_to_str(const struct sockaddr *sa);
113 :
114 : /** Return an in6_addr* equivalent to <b>a</b>, or NULL if <b>a</b> is not
115 : * an IPv6 address. */
116 : static inline const struct in6_addr *
117 35 : tor_addr_to_in6(const tor_addr_t *a)
118 : {
119 35 : return a->family == AF_INET6 ? &a->addr.in6_addr : NULL;
120 : }
121 :
122 : /** As tor_addr_to_in6, but assert that the address truly is an IPv6
123 : * address. */
124 : static inline const struct in6_addr *
125 35058534 : tor_addr_to_in6_assert(const tor_addr_t *a)
126 : {
127 35058534 : tor_assert(a->family == AF_INET6);
128 35058534 : return &a->addr.in6_addr;
129 : }
130 :
131 : /** Given an IPv6 address <b>x</b>, yield it as an array of uint8_t.
132 : *
133 : * Requires that <b>x</b> is actually an IPv6 address.
134 : */
135 : #define tor_addr_to_in6_addr8(x) tor_addr_to_in6_assert(x)->s6_addr
136 :
137 : /** Given an IPv6 address <b>x</b>, yield it as an array of uint16_t.
138 : *
139 : * Requires that <b>x</b> is actually an IPv6 address.
140 : */
141 : #define tor_addr_to_in6_addr16(x) S6_ADDR16(*tor_addr_to_in6_assert(x))
142 :
143 : /** Given an IPv6 address <b>x</b>, yield it as an array of uint32_t.
144 : *
145 : * Requires that <b>x</b> is actually an IPv6 address.
146 : */
147 : #define tor_addr_to_in6_addr32(x) S6_ADDR32(*tor_addr_to_in6_assert(x))
148 :
149 : /** Return an IPv4 address in network order for <b>a</b>, or 0 if
150 : * <b>a</b> is not an IPv4 address. */
151 : static inline uint32_t
152 52376270 : tor_addr_to_ipv4n(const tor_addr_t *a)
153 : {
154 52376270 : return a->family == AF_INET ? a->addr.in_addr.s_addr : 0;
155 : }
156 :
157 : /** Return an IPv4 address in host order for <b>a</b>, or 0 if
158 : * <b>a</b> is not an IPv4 address. */
159 : static inline uint32_t
160 52313524 : tor_addr_to_ipv4h(const tor_addr_t *a)
161 : {
162 52313524 : return ntohl(tor_addr_to_ipv4n(a));
163 : }
164 :
165 : /** Given an IPv6 address, return its mapped IPv4 address in host order, or
166 : * 0 if <b>a</b> is not an IPv6 address.
167 : *
168 : * (Does not check whether the address is really a mapped address.) */
169 : static inline uint32_t
170 4 : tor_addr_to_mapped_ipv4h(const tor_addr_t *a)
171 : {
172 4 : if (a->family == AF_INET6) {
173 3 : uint32_t *addr32 = NULL;
174 : // Work around an incorrect NULL pointer dereference warning in
175 : // "clang --analyze" due to limited analysis depth
176 3 : addr32 = tor_addr_to_in6_addr32(a);
177 3 : tor_assert(addr32);
178 3 : return ntohl(addr32[3]);
179 : } else {
180 : return 0;
181 : }
182 : }
183 :
184 : /** Return the address family of <b>a</b>. Possible values are:
185 : * AF_INET6, AF_INET, AF_UNSPEC, AF_UNIX. */
186 : static inline sa_family_t
187 245511344 : tor_addr_family(const tor_addr_t *a)
188 : {
189 245511344 : return a->family;
190 : }
191 :
192 : /**
193 : * Return true if the address @a is in the UNSPEC family.
194 : **/
195 : static inline bool
196 240 : tor_addr_is_unspec(const tor_addr_t *a)
197 : {
198 240 : return a->family == AF_UNSPEC;
199 : }
200 :
201 : /** Return an in_addr* equivalent to <b>a</b>, or NULL if <b>a</b> is not
202 : * an IPv4 address. */
203 : static inline const struct in_addr *
204 2 : tor_addr_to_in(const tor_addr_t *a)
205 : {
206 2 : return a->family == AF_INET ? &a->addr.in_addr : NULL;
207 : }
208 :
209 : /** Return true iff <b>a</b> is an IPv4 address equal to the host-ordered
210 : * address in <b>u</b>. */
211 : static inline int
212 25 : tor_addr_eq_ipv4h(const tor_addr_t *a, uint32_t u)
213 : {
214 25 : return a->family == AF_INET ? (tor_addr_to_ipv4h(a) == u) : 0;
215 : }
216 :
217 : /** Length of a buffer that you need to allocate to be sure you can encode
218 : * any tor_addr_t.
219 : *
220 : * This allows enough space for
221 : * "[ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255]",
222 : * plus a terminating NUL.
223 : */
224 : #define TOR_ADDR_BUF_LEN 48
225 :
226 : /** Length of a buffer containing an IP address along with a port number and
227 : * a separating colon.
228 : *
229 : * This allows enough space for
230 : * "[ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255]:12345",
231 : * plus a terminating NUL.
232 : */
233 : #define TOR_ADDRPORT_BUF_LEN (TOR_ADDR_BUF_LEN + 6)
234 :
235 : char *tor_addr_to_str_dup(const tor_addr_t *addr) ATTR_MALLOC;
236 :
237 : /** Wrapper function of fmt_addr_impl(). It does not decorate IPv6
238 : * addresses. */
239 : #define fmt_addr(a) fmt_addr_impl((a), 0)
240 :
241 : /** Wrapper function of fmt_addr_impl(). It decorates IPv6
242 : * addresses. */
243 : #define fmt_and_decorate_addr(a) fmt_addr_impl((a), 1)
244 :
245 : const char *fmt_addr_impl(const tor_addr_t *addr, int decorate);
246 : const char *fmt_addrport(const tor_addr_t *addr, uint16_t port);
247 : #define fmt_addrport_ap(ap) fmt_addrport(&(ap)->addr, (ap)->port)
248 : const char *fmt_addr32(uint32_t addr);
249 : const char *fmt_addr32_port(uint32_t addr, uint16_t port);
250 : const char *fmt_af_family(sa_family_t family);
251 : const char *fmt_addr_family(const tor_addr_t *addr);
252 :
253 : MOCK_DECL(int,get_interface_address6,(int severity, sa_family_t family,
254 : tor_addr_t *addr));
255 :
256 : struct smartlist_t;
257 : void interface_address6_list_free_(struct smartlist_t * addrs);
258 : #define interface_address6_list_free(addrs) \
259 : FREE_AND_NULL(struct smartlist_t, interface_address6_list_free_, (addrs))
260 :
261 : MOCK_DECL(struct smartlist_t *,get_interface_address6_list,(int severity,
262 : sa_family_t family,
263 : int include_internal));
264 :
265 : /** Flag to specify how to do a comparison between addresses. In an "exact"
266 : * comparison, addresses are equivalent only if they are in the same family
267 : * with the same value. In a "semantic" comparison, IPv4 addresses match all
268 : * IPv6 encodings of those addresses. */
269 : typedef enum {
270 : CMP_EXACT,
271 : CMP_SEMANTIC,
272 : } tor_addr_comparison_t;
273 :
274 : int tor_addr_compare(const tor_addr_t *addr1, const tor_addr_t *addr2,
275 : tor_addr_comparison_t how);
276 : int tor_addr_compare_masked(const tor_addr_t *addr1, const tor_addr_t *addr2,
277 : maskbits_t mask, tor_addr_comparison_t how);
278 : /** Return true iff a and b are the same address. The comparison is done
279 : * "exactly". */
280 : #define tor_addr_eq(a,b) (0==tor_addr_compare((a),(b),CMP_EXACT))
281 :
282 : uint64_t tor_addr_hash(const tor_addr_t *addr);
283 : struct sipkey;
284 : uint64_t tor_addr_keyed_hash(const struct sipkey *key, const tor_addr_t *addr);
285 :
286 : int tor_addr_is_v4(const tor_addr_t *addr);
287 : int tor_addr_is_v6(const tor_addr_t *addr);
288 : int tor_addr_is_internal_(const tor_addr_t *ip, int for_listening,
289 : const char *filename, int lineno);
290 : #define tor_addr_is_internal(addr, for_listening) \
291 : tor_addr_is_internal_((addr), (for_listening), SHORT_FILE__, __LINE__)
292 : int tor_addr_is_multicast(const tor_addr_t *a);
293 :
294 : /** Longest length that can be required for a reverse lookup name. */
295 : /* 32 nybbles, 32 dots, 8 characters of "ip6.arpa", 1 NUL: 73 characters. */
296 : #define REVERSE_LOOKUP_NAME_BUF_LEN 73
297 : int tor_addr_to_PTR_name(char *out, size_t outlen,
298 : const tor_addr_t *addr);
299 : int tor_addr_parse_PTR_name(tor_addr_t *result, const char *address,
300 : int family, int accept_regular);
301 :
302 : /* Does the address * yield an AF_UNSPEC wildcard address (1),
303 : * which expands to corresponding wildcard IPv4 and IPv6 rules, and do we
304 : * allow *4 and *6 for IPv4 and IPv6 wildcards, respectively;
305 : * or does the address * yield IPv4 wildcard address (0). */
306 : #define TAPMP_EXTENDED_STAR 1
307 : /* Does the address * yield an IPv4 wildcard address rule (1);
308 : * or does it yield wildcard IPv4 and IPv6 rules (0) */
309 : #define TAPMP_STAR_IPV4_ONLY (1 << 1)
310 : /* Does the address * yield an IPv6 wildcard address rule (1);
311 : * or does it yield wildcard IPv4 and IPv6 rules (0) */
312 : #define TAPMP_STAR_IPV6_ONLY (1 << 2)
313 : /* TAPMP_STAR_IPV4_ONLY and TAPMP_STAR_IPV6_ONLY are mutually exclusive. */
314 : int tor_addr_parse_mask_ports(const char *s, unsigned flags,
315 : tor_addr_t *addr_out, maskbits_t *mask_out,
316 : uint16_t *port_min_out, uint16_t *port_max_out);
317 :
318 : const char * tor_addr_to_str(char *dest, const tor_addr_t *addr, size_t len,
319 : int decorate);
320 : int tor_addr_parse(tor_addr_t *addr, const char *src);
321 : void tor_addr_copy(tor_addr_t *dest, const tor_addr_t *src);
322 : void tor_addr_copy_tight(tor_addr_t *dest, const tor_addr_t *src);
323 :
324 : void tor_addr_from_ipv4n(tor_addr_t *dest, uint32_t v4addr);
325 : /** Set <b>dest</b> to the IPv4 address encoded in <b>v4addr</b> in host
326 : * order. */
327 : #define tor_addr_from_ipv4h(dest, v4addr) \
328 : tor_addr_from_ipv4n((dest), htonl(v4addr))
329 : void tor_addr_from_ipv6_bytes(tor_addr_t *dest, const uint8_t *bytes);
330 : /** Set <b>dest</b> to the IPv4 address incoded in <b>in</b>. */
331 : #define tor_addr_from_in(dest, in) \
332 : tor_addr_from_ipv4n((dest), (in)->s_addr);
333 : void tor_addr_from_in6(tor_addr_t *dest, const struct in6_addr *in6);
334 : void tor_addr_copy_ipv6_bytes(uint8_t *dest, const tor_addr_t *src);
335 :
336 : int tor_addr_is_null(const tor_addr_t *addr);
337 : int tor_addr_is_loopback(const tor_addr_t *addr);
338 :
339 : int tor_addr_is_valid(const tor_addr_t *addr, int for_listening);
340 : int tor_addr_is_valid_ipv4n(uint32_t v4n_addr, int for_listening);
341 : #define tor_addr_is_valid_ipv4h(v4h_addr, for_listening) \
342 : tor_addr_is_valid_ipv4n(htonl(v4h_addr), (for_listening))
343 : int tor_port_is_valid(uint16_t port, int for_listening);
344 :
345 : /* Are addr and port both valid? */
346 : #define tor_addr_port_is_valid(addr, port, for_listening) \
347 : (tor_addr_is_valid((addr), (for_listening)) && \
348 : tor_port_is_valid((port), (for_listening)))
349 : /* Are ap->addr and ap->port both valid? */
350 : #define tor_addr_port_is_valid_ap(ap, for_listening) \
351 : tor_addr_port_is_valid(&(ap)->addr, (ap)->port, (for_listening))
352 : /* Are the network-order v4addr and port both valid? */
353 : #define tor_addr_port_is_valid_ipv4n(v4n_addr, port, for_listening) \
354 : (tor_addr_is_valid_ipv4n((v4n_addr), (for_listening)) && \
355 : tor_port_is_valid((port), (for_listening)))
356 : /* Are the host-order v4addr and port both valid? */
357 : #define tor_addr_port_is_valid_ipv4h(v4h_addr, port, for_listening) \
358 : (tor_addr_is_valid_ipv4h((v4h_addr), (for_listening)) && \
359 : tor_port_is_valid((port), (for_listening)))
360 :
361 : int tor_addr_port_split(int severity, const char *addrport,
362 : char **address_out, uint16_t *port_out);
363 :
364 : int tor_addr_port_parse(int severity, const char *addrport,
365 : tor_addr_t *address_out, uint16_t *port_out,
366 : int default_port);
367 :
368 : int tor_addr_hostname_is_local(const char *name);
369 :
370 : /* IPv4 helpers */
371 : int parse_port_range(const char *port, uint16_t *port_min_out,
372 : uint16_t *port_max_out);
373 : int addr_mask_get_bits(uint32_t mask);
374 : char *tor_dup_ip(uint32_t addr) ATTR_MALLOC;
375 :
376 : MOCK_DECL(int,get_interface_address,(int severity, uint32_t *addr));
377 : #define interface_address_list_free(lst)\
378 : interface_address6_list_free(lst)
379 :
380 : /** Return a smartlist of the IPv4 addresses of all interfaces on the server.
381 : * Excludes loopback and multicast addresses. Only includes internal addresses
382 : * if include_internal is true. (Note that a relay behind NAT may use an
383 : * internal address to connect to the Internet.)
384 : * An empty smartlist means that there are no IPv4 addresses.
385 : * Returns NULL on failure.
386 : * Use free_interface_address_list to free the returned list.
387 : */
388 : static inline struct smartlist_t *
389 4 : get_interface_address_list(int severity, int include_internal)
390 : {
391 4 : return get_interface_address6_list(severity, AF_INET, include_internal);
392 : }
393 :
394 : tor_addr_port_t *tor_addr_port_new(const tor_addr_t *addr, uint16_t port);
395 : int tor_addr_port_eq(const tor_addr_port_t *a,
396 : const tor_addr_port_t *b);
397 : void tor_addr_port_copy(tor_addr_port_t *dest, const tor_addr_port_t *source);
398 :
399 : int string_is_valid_dest(const char *string);
400 : int string_is_valid_nonrfc_hostname(const char *string);
401 : int string_is_valid_ipv4_address(const char *string);
402 : int string_is_valid_ipv6_address(const char *string);
403 :
404 : #ifdef ADDRESS_PRIVATE
405 : MOCK_DECL(struct smartlist_t *,get_interface_addresses_raw,(int severity,
406 : sa_family_t family));
407 : MOCK_DECL(int,get_interface_address6_via_udp_socket_hack,(int severity,
408 : sa_family_t family,
409 : tor_addr_t *addr));
410 :
411 : #ifdef HAVE_IFADDRS_TO_SMARTLIST
412 : STATIC struct smartlist_t *ifaddrs_to_smartlist(const struct ifaddrs *ifa,
413 : sa_family_t family);
414 : STATIC struct smartlist_t *get_interface_addresses_ifaddrs(int severity,
415 : sa_family_t family);
416 : #endif /* defined(HAVE_IFADDRS_TO_SMARTLIST) */
417 :
418 : #ifdef HAVE_IP_ADAPTER_TO_SMARTLIST
419 : STATIC struct smartlist_t *ip_adapter_addresses_to_smartlist(
420 : const IP_ADAPTER_ADDRESSES *addresses);
421 : STATIC struct smartlist_t *get_interface_addresses_win32(int severity,
422 : sa_family_t family);
423 : #endif /* defined(HAVE_IP_ADAPTER_TO_SMARTLIST) */
424 :
425 : #ifdef HAVE_IFCONF_TO_SMARTLIST
426 : STATIC struct smartlist_t *ifreq_to_smartlist(const uint8_t *ifr,
427 : size_t buflen);
428 : STATIC struct smartlist_t *get_interface_addresses_ioctl(int severity,
429 : sa_family_t family);
430 : #endif /* defined(HAVE_IFCONF_TO_SMARTLIST) */
431 :
432 : #endif /* defined(ADDRESS_PRIVATE) */
433 :
434 : #endif /* !defined(TOR_ADDRESS_H) */
|
