address.h 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182
  1. /* Copyright (c) 2003-2004, Roger Dingledine
  2. * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  3. * Copyright (c) 2007-2011, The Tor Project, Inc. */
  4. /* See LICENSE for licensing information */
  5. /**
  6. * \file address.h
  7. * \brief Headers for address.h
  8. **/
  9. #ifndef _TOR_ADDRESS_H
  10. #define _TOR_ADDRESS_H
  11. #include "orconfig.h"
  12. #include "torint.h"
  13. #include "compat.h"
  14. /** The number of bits from an address to consider while doing a masked
  15. * comparison. */
  16. typedef uint8_t maskbits_t;
  17. struct in_addr;
  18. /** Holds an IPv4 or IPv6 address. (Uses less memory than struct
  19. * sockaddr_storage.) */
  20. typedef struct tor_addr_t
  21. {
  22. sa_family_t family;
  23. union {
  24. struct in_addr in_addr;
  25. struct in6_addr in6_addr;
  26. } addr;
  27. } tor_addr_t;
  28. static INLINE const struct in6_addr *tor_addr_to_in6(const tor_addr_t *a);
  29. static INLINE uint32_t tor_addr_to_ipv4n(const tor_addr_t *a);
  30. static INLINE uint32_t tor_addr_to_ipv4h(const tor_addr_t *a);
  31. static INLINE uint32_t tor_addr_to_mapped_ipv4h(const tor_addr_t *a);
  32. static INLINE sa_family_t tor_addr_family(const tor_addr_t *a);
  33. static INLINE const struct in_addr *tor_addr_to_in(const tor_addr_t *a);
  34. static INLINE int tor_addr_eq_ipv4h(const tor_addr_t *a, uint32_t u);
  35. int tor_addr_to_sockaddr(const tor_addr_t *a, uint16_t port,
  36. struct sockaddr *sa_out, socklen_t len);
  37. int tor_addr_from_sockaddr(tor_addr_t *a, const struct sockaddr *sa,
  38. uint16_t *port_out);
  39. void tor_addr_make_unspec(tor_addr_t *a);
  40. /** Return an in6_addr* equivalent to <b>a</b>, or NULL if <b>a</b> is not
  41. * an IPv6 address. */
  42. static INLINE const struct in6_addr *
  43. tor_addr_to_in6(const tor_addr_t *a)
  44. {
  45. return a->family == AF_INET6 ? &a->addr.in6_addr : NULL;
  46. }
  47. #define tor_addr_to_in6_addr8(x) tor_addr_to_in6(x)->s6_addr
  48. #define tor_addr_to_in6_addr16(x) S6_ADDR16(*tor_addr_to_in6(x))
  49. #define tor_addr_to_in6_addr32(x) S6_ADDR32(*tor_addr_to_in6(x))
  50. /** Return an IPv4 address in network order for <b>a</b>, or 0 if
  51. * <b>a</b> is not an IPv4 address. */
  52. static INLINE uint32_t
  53. tor_addr_to_ipv4n(const tor_addr_t *a)
  54. {
  55. return a->family == AF_INET ? a->addr.in_addr.s_addr : 0;
  56. }
  57. /** Return an IPv4 address in host order for <b>a</b>, or 0 if
  58. * <b>a</b> is not an IPv4 address. */
  59. static INLINE uint32_t
  60. tor_addr_to_ipv4h(const tor_addr_t *a)
  61. {
  62. return ntohl(tor_addr_to_ipv4n(a));
  63. }
  64. /* Given an IPv6 address, return its mapped IPv4 address in host order, or
  65. * 0 if <b>a</b> is not an IPv6 address.
  66. *
  67. * (Does not check whether the address is really a mapped address */
  68. static INLINE uint32_t
  69. tor_addr_to_mapped_ipv4h(const tor_addr_t *a)
  70. {
  71. return a->family == AF_INET6 ? ntohl(tor_addr_to_in6_addr32(a)[3]) : 0;
  72. }
  73. /** Return the address family of <b>a</b>. Possible values are:
  74. * AF_INET6, AF_INET, AF_UNSPEC. */
  75. static INLINE sa_family_t
  76. tor_addr_family(const tor_addr_t *a)
  77. {
  78. return a->family;
  79. }
  80. /** Return an in_addr* equivalent to <b>a</b>, or NULL if <b>a</b> is not
  81. * an IPv4 address. */
  82. static INLINE const struct in_addr *
  83. tor_addr_to_in(const tor_addr_t *a)
  84. {
  85. return a->family == AF_INET ? &a->addr.in_addr : NULL;
  86. }
  87. /** Return true iff <b>a</b> is an IPv4 address equal to the host-ordered
  88. * address in <b>u</b>. */
  89. static INLINE int
  90. tor_addr_eq_ipv4h(const tor_addr_t *a, uint32_t u)
  91. {
  92. return a->family == AF_INET ? (tor_addr_to_ipv4h(a) == u) : 0;
  93. }
  94. #define TOR_ADDR_BUF_LEN 48 /* [ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255]
  95. */
  96. int tor_addr_lookup(const char *name, uint16_t family, tor_addr_t *addr_out);
  97. char *tor_dup_addr(const tor_addr_t *addr) ATTR_MALLOC;
  98. const char *fmt_addr(const tor_addr_t *addr);
  99. const char * fmt_addr32(uint32_t addr);
  100. int get_interface_address6(int severity, sa_family_t family, tor_addr_t *addr);
  101. /** Flag to specify how to do a comparison between addresses. In an "exact"
  102. * comparison, addresses are equivalent only if they are in the same family
  103. * with the same value. In a "semantic" comparison, IPv4 addresses match all
  104. * IPv6 encodings of those addresses. */
  105. typedef enum {
  106. CMP_EXACT,
  107. CMP_SEMANTIC,
  108. } tor_addr_comparison_t;
  109. int tor_addr_compare(const tor_addr_t *addr1, const tor_addr_t *addr2,
  110. tor_addr_comparison_t how);
  111. int tor_addr_compare_masked(const tor_addr_t *addr1, const tor_addr_t *addr2,
  112. maskbits_t mask, tor_addr_comparison_t how);
  113. /** Return true iff a and b are the same address. The comparison is done
  114. * "exactly". */
  115. #define tor_addr_eq(a,b) (0==tor_addr_compare((a),(b),CMP_EXACT))
  116. unsigned int tor_addr_hash(const tor_addr_t *addr);
  117. int tor_addr_is_v4(const tor_addr_t *addr);
  118. int tor_addr_is_internal(const tor_addr_t *ip, int for_listening) ATTR_PURE;
  119. /** Longest length that can be required for a reverse lookup name. */
  120. /* 32 nybbles, 32 dots, 8 characters of "ip6.arpa", 1 NUL: 73 characters. */
  121. #define REVERSE_LOOKUP_NAME_BUF_LEN 73
  122. int tor_addr_to_reverse_lookup_name(char *out, size_t outlen,
  123. const tor_addr_t *addr);
  124. int tor_addr_parse_reverse_lookup_name(tor_addr_t *result, const char *address,
  125. int family, int accept_regular);
  126. int tor_addr_port_parse(const char *s, tor_addr_t *addr_out,
  127. uint16_t *port_out);
  128. int tor_addr_parse_mask_ports(const char *s,
  129. tor_addr_t *addr_out, maskbits_t *mask_out,
  130. uint16_t *port_min_out, uint16_t *port_max_out);
  131. const char * tor_addr_to_str(char *dest, const tor_addr_t *addr, size_t len,
  132. int decorate);
  133. int tor_addr_from_str(tor_addr_t *addr, const char *src);
  134. void tor_addr_copy(tor_addr_t *dest, const tor_addr_t *src);
  135. void tor_addr_from_ipv4n(tor_addr_t *dest, uint32_t v4addr);
  136. /** Set <b>dest</b> to the IPv4 address encoded in <b>v4addr</b> in host
  137. * order. */
  138. #define tor_addr_from_ipv4h(dest, v4addr) \
  139. tor_addr_from_ipv4n((dest), htonl(v4addr))
  140. void tor_addr_from_ipv6_bytes(tor_addr_t *dest, const char *bytes);
  141. #define tor_addr_from_in(dest, in) \
  142. tor_addr_from_ipv4n((dest), (in)->s_addr);
  143. void tor_addr_from_in6(tor_addr_t *dest, const struct in6_addr *in6);
  144. int tor_addr_is_null(const tor_addr_t *addr);
  145. int tor_addr_is_loopback(const tor_addr_t *addr);
  146. /* IPv4 helpers */
  147. int is_internal_IP(uint32_t ip, int for_listening) ATTR_PURE;
  148. int parse_addr_port(int severity, const char *addrport, char **address,
  149. uint32_t *addr, uint16_t *port_out);
  150. int parse_port_range(const char *port, uint16_t *port_min_out,
  151. uint16_t *port_max_out);
  152. int parse_addr_and_port_range(const char *s, uint32_t *addr_out,
  153. maskbits_t *maskbits_out, uint16_t *port_min_out,
  154. uint16_t *port_max_out);
  155. int addr_mask_get_bits(uint32_t mask);
  156. int addr_mask_cmp_bits(uint32_t a1, uint32_t a2, maskbits_t bits);
  157. /** Length of a buffer to allocate to hold the results of tor_inet_ntoa.*/
  158. #define INET_NTOA_BUF_LEN 16
  159. int tor_inet_ntoa(const struct in_addr *in, char *buf, size_t buf_len);
  160. char *tor_dup_ip(uint32_t addr) ATTR_MALLOC;
  161. int get_interface_address(int severity, uint32_t *addr);
  162. #endif