address.c 63 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150
  1. /* Copyright (c) 2003-2004, Roger Dingledine
  2. * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  3. * Copyright (c) 2007-2017, The Tor Project, Inc. */
  4. /* See LICENSE for licensing information */
  5. /**
  6. * \file address.c
  7. * \brief Functions to use and manipulate the tor_addr_t structure.
  8. **/
  9. #define ADDRESS_PRIVATE
  10. #include "orconfig.h"
  11. #ifdef _WIN32
  12. /* For access to structs needed by GetAdaptersAddresses */
  13. #ifndef WIN32_LEAN_AND_MEAN
  14. #error "orconfig.h didn't define WIN32_LEAN_AND_MEAN"
  15. #endif
  16. #ifndef WINVER
  17. #error "orconfig.h didn't define WINVER"
  18. #endif
  19. #ifndef _WIN32_WINNT
  20. #error "orconfig.h didn't define _WIN32_WINNT"
  21. #endif
  22. #if WINVER < 0x0501
  23. #error "winver too low"
  24. #endif
  25. #if _WIN32_WINNT < 0x0501
  26. #error "winver too low"
  27. #endif
  28. #include <winsock2.h>
  29. #include <process.h>
  30. #include <windows.h>
  31. #include <iphlpapi.h>
  32. #endif /* defined(_WIN32) */
  33. #include "compat.h"
  34. #include "util.h"
  35. #include "util_format.h"
  36. #include "address.h"
  37. #include "torlog.h"
  38. #include "container.h"
  39. #include "sandbox.h"
  40. #ifdef HAVE_SYS_TIME_H
  41. #include <sys/time.h>
  42. #endif
  43. #ifdef HAVE_UNISTD_H
  44. #include <unistd.h>
  45. #endif
  46. #ifdef HAVE_ERRNO_H
  47. #include <errno.h>
  48. #endif
  49. #ifdef HAVE_NETINET_IN_H
  50. #include <netinet/in.h>
  51. #endif
  52. #ifdef HAVE_ARPA_INET_H
  53. #include <arpa/inet.h>
  54. #endif
  55. #ifdef HAVE_SYS_SOCKET_H
  56. #include <sys/socket.h>
  57. #endif
  58. #ifdef HAVE_NETDB_H
  59. #include <netdb.h>
  60. #endif
  61. #ifdef HAVE_SYS_PARAM_H
  62. #include <sys/param.h> /* FreeBSD needs this to know what version it is */
  63. #endif
  64. #ifdef HAVE_SYS_UN_H
  65. #include <sys/un.h>
  66. #endif
  67. #ifdef HAVE_IFADDRS_H
  68. #include <ifaddrs.h>
  69. #endif
  70. #ifdef HAVE_SYS_IOCTL_H
  71. #include <sys/ioctl.h>
  72. #endif
  73. #ifdef HAVE_NET_IF_H
  74. #include <net/if.h>
  75. #endif
  76. #include <stdarg.h>
  77. #include <stdio.h>
  78. #include <stdlib.h>
  79. #include <string.h>
  80. #include <assert.h>
  81. /* tor_addr_is_null() and maybe other functions rely on AF_UNSPEC being 0 to
  82. * work correctly. Bail out here if we've found a platform where AF_UNSPEC
  83. * isn't 0. */
  84. #if AF_UNSPEC != 0
  85. #error We rely on AF_UNSPEC being 0. Let us know about your platform, please!
  86. #endif
  87. /** Convert the tor_addr_t in <b>a</b>, with port in <b>port</b>, into a
  88. * sockaddr object in *<b>sa_out</b> of object size <b>len</b>. If not enough
  89. * room is available in sa_out, or on error, return 0. On success, return
  90. * the length of the sockaddr.
  91. *
  92. * Interface note: ordinarily, we return -1 for error. We can't do that here,
  93. * since socklen_t is unsigned on some platforms.
  94. **/
  95. socklen_t
  96. tor_addr_to_sockaddr(const tor_addr_t *a,
  97. uint16_t port,
  98. struct sockaddr *sa_out,
  99. socklen_t len)
  100. {
  101. memset(sa_out, 0, len);
  102. sa_family_t family = tor_addr_family(a);
  103. if (family == AF_INET) {
  104. struct sockaddr_in *sin;
  105. if (len < (int)sizeof(struct sockaddr_in))
  106. return 0;
  107. sin = (struct sockaddr_in *)sa_out;
  108. #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
  109. sin->sin_len = sizeof(struct sockaddr_in);
  110. #endif
  111. sin->sin_family = AF_INET;
  112. sin->sin_port = htons(port);
  113. sin->sin_addr.s_addr = tor_addr_to_ipv4n(a);
  114. return sizeof(struct sockaddr_in);
  115. } else if (family == AF_INET6) {
  116. struct sockaddr_in6 *sin6;
  117. if (len < (int)sizeof(struct sockaddr_in6))
  118. return 0;
  119. sin6 = (struct sockaddr_in6 *)sa_out;
  120. #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_LEN
  121. sin6->sin6_len = sizeof(struct sockaddr_in6);
  122. #endif
  123. sin6->sin6_family = AF_INET6;
  124. sin6->sin6_port = htons(port);
  125. memcpy(&sin6->sin6_addr, tor_addr_to_in6_assert(a),
  126. sizeof(struct in6_addr));
  127. return sizeof(struct sockaddr_in6);
  128. } else {
  129. return 0;
  130. }
  131. }
  132. /** Set address <b>a</b> to zero. This address belongs to
  133. * the AF_UNIX family. */
  134. static void
  135. tor_addr_make_af_unix(tor_addr_t *a)
  136. {
  137. memset(a, 0, sizeof(*a));
  138. a->family = AF_UNIX;
  139. }
  140. /** Set the tor_addr_t in <b>a</b> to contain the socket address contained in
  141. * <b>sa</b>. IF <b>port_out</b> is non-NULL and <b>sa</b> contains a port,
  142. * set *<b>port_out</b> to that port. Return 0 on success and -1 on
  143. * failure. */
  144. int
  145. tor_addr_from_sockaddr(tor_addr_t *a, const struct sockaddr *sa,
  146. uint16_t *port_out)
  147. {
  148. tor_assert(a);
  149. tor_assert(sa);
  150. /* This memset is redundant; leaving it in to avoid any future accidents,
  151. however. */
  152. memset(a, 0, sizeof(*a));
  153. if (sa->sa_family == AF_INET) {
  154. struct sockaddr_in *sin = (struct sockaddr_in *) sa;
  155. tor_addr_from_ipv4n(a, sin->sin_addr.s_addr);
  156. if (port_out)
  157. *port_out = ntohs(sin->sin_port);
  158. } else if (sa->sa_family == AF_INET6) {
  159. struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) sa;
  160. tor_addr_from_in6(a, &sin6->sin6_addr);
  161. if (port_out)
  162. *port_out = ntohs(sin6->sin6_port);
  163. } else if (sa->sa_family == AF_UNIX) {
  164. tor_addr_make_af_unix(a);
  165. return 0;
  166. } else {
  167. tor_addr_make_unspec(a);
  168. return -1;
  169. }
  170. return 0;
  171. }
  172. /** Return a newly allocated string holding the address described in
  173. * <b>sa</b>. AF_UNIX, AF_UNSPEC, AF_INET, and AF_INET6 are supported. */
  174. char *
  175. tor_sockaddr_to_str(const struct sockaddr *sa)
  176. {
  177. char address[TOR_ADDR_BUF_LEN];
  178. char *result;
  179. tor_addr_t addr;
  180. uint16_t port;
  181. #ifdef HAVE_SYS_UN_H
  182. if (sa->sa_family == AF_UNIX) {
  183. struct sockaddr_un *s_un = (struct sockaddr_un *)sa;
  184. tor_asprintf(&result, "unix:%s", s_un->sun_path);
  185. return result;
  186. }
  187. #endif /* defined(HAVE_SYS_UN_H) */
  188. if (sa->sa_family == AF_UNSPEC)
  189. return tor_strdup("unspec");
  190. if (tor_addr_from_sockaddr(&addr, sa, &port) < 0)
  191. return NULL;
  192. if (! tor_addr_to_str(address, &addr, sizeof(address), 1))
  193. return NULL;
  194. tor_asprintf(&result, "%s:%d", address, (int)port);
  195. return result;
  196. }
  197. /** Set address <b>a</b> to the unspecified address. This address belongs to
  198. * no family. */
  199. void
  200. tor_addr_make_unspec(tor_addr_t *a)
  201. {
  202. memset(a, 0, sizeof(*a));
  203. a->family = AF_UNSPEC;
  204. }
  205. /** Set address <b>a</b> to the null address in address family <b>family</b>.
  206. * The null address for AF_INET is 0.0.0.0. The null address for AF_INET6 is
  207. * [::]. AF_UNSPEC is all null. */
  208. void
  209. tor_addr_make_null(tor_addr_t *a, sa_family_t family)
  210. {
  211. memset(a, 0, sizeof(*a));
  212. a->family = family;
  213. }
  214. /** Similar behavior to Unix gethostbyname: resolve <b>name</b>, and set
  215. * *<b>addr</b> to the proper IP address and family. The <b>family</b>
  216. * argument (which must be AF_INET, AF_INET6, or AF_UNSPEC) declares a
  217. * <i>preferred</i> family, though another one may be returned if only one
  218. * family is implemented for this address.
  219. *
  220. * Return 0 on success, -1 on failure; 1 on transient failure.
  221. */
  222. MOCK_IMPL(int,
  223. tor_addr_lookup,(const char *name, uint16_t family, tor_addr_t *addr))
  224. {
  225. /* Perhaps eventually this should be replaced by a tor_getaddrinfo or
  226. * something.
  227. */
  228. struct in_addr iaddr;
  229. struct in6_addr iaddr6;
  230. tor_assert(name);
  231. tor_assert(addr);
  232. tor_assert(family == AF_INET || family == AF_INET6 || family == AF_UNSPEC);
  233. if (!*name) {
  234. /* Empty address is an error. */
  235. return -1;
  236. } else if (tor_inet_pton(AF_INET, name, &iaddr)) {
  237. /* It's an IPv4 IP. */
  238. if (family == AF_INET6)
  239. return -1;
  240. tor_addr_from_in(addr, &iaddr);
  241. return 0;
  242. } else if (tor_inet_pton(AF_INET6, name, &iaddr6)) {
  243. if (family == AF_INET)
  244. return -1;
  245. tor_addr_from_in6(addr, &iaddr6);
  246. return 0;
  247. } else {
  248. #ifdef HAVE_GETADDRINFO
  249. int err;
  250. struct addrinfo *res=NULL, *res_p;
  251. struct addrinfo *best=NULL;
  252. struct addrinfo hints;
  253. int result = -1;
  254. memset(&hints, 0, sizeof(hints));
  255. hints.ai_family = family;
  256. hints.ai_socktype = SOCK_STREAM;
  257. err = sandbox_getaddrinfo(name, NULL, &hints, &res);
  258. /* The check for 'res' here shouldn't be necessary, but it makes static
  259. * analysis tools happy. */
  260. if (!err && res) {
  261. best = NULL;
  262. for (res_p = res; res_p; res_p = res_p->ai_next) {
  263. if (family == AF_UNSPEC) {
  264. if (res_p->ai_family == AF_INET) {
  265. best = res_p;
  266. break;
  267. } else if (res_p->ai_family == AF_INET6 && !best) {
  268. best = res_p;
  269. }
  270. } else if (family == res_p->ai_family) {
  271. best = res_p;
  272. break;
  273. }
  274. }
  275. if (!best)
  276. best = res;
  277. if (best->ai_family == AF_INET) {
  278. tor_addr_from_in(addr,
  279. &((struct sockaddr_in*)best->ai_addr)->sin_addr);
  280. result = 0;
  281. } else if (best->ai_family == AF_INET6) {
  282. tor_addr_from_in6(addr,
  283. &((struct sockaddr_in6*)best->ai_addr)->sin6_addr);
  284. result = 0;
  285. }
  286. sandbox_freeaddrinfo(res);
  287. return result;
  288. }
  289. return (err == EAI_AGAIN) ? 1 : -1;
  290. #else /* !(defined(HAVE_GETADDRINFO)) */
  291. struct hostent *ent;
  292. int err;
  293. #ifdef HAVE_GETHOSTBYNAME_R_6_ARG
  294. char buf[2048];
  295. struct hostent hostent;
  296. int r;
  297. r = gethostbyname_r(name, &hostent, buf, sizeof(buf), &ent, &err);
  298. #elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
  299. char buf[2048];
  300. struct hostent hostent;
  301. ent = gethostbyname_r(name, &hostent, buf, sizeof(buf), &err);
  302. #elif defined(HAVE_GETHOSTBYNAME_R_3_ARG)
  303. struct hostent_data data;
  304. struct hostent hent;
  305. memset(&data, 0, sizeof(data));
  306. err = gethostbyname_r(name, &hent, &data);
  307. ent = err ? NULL : &hent;
  308. #else
  309. ent = gethostbyname(name);
  310. #ifdef _WIN32
  311. err = WSAGetLastError();
  312. #else
  313. err = h_errno;
  314. #endif
  315. #endif /* defined(HAVE_GETHOSTBYNAME_R_6_ARG) || ... */
  316. if (ent) {
  317. if (ent->h_addrtype == AF_INET) {
  318. tor_addr_from_in(addr, (struct in_addr*) ent->h_addr);
  319. } else if (ent->h_addrtype == AF_INET6) {
  320. tor_addr_from_in6(addr, (struct in6_addr*) ent->h_addr);
  321. } else {
  322. tor_assert(0); // LCOV_EXCL_LINE: gethostbyname() returned bizarre type
  323. }
  324. return 0;
  325. }
  326. #ifdef _WIN32
  327. return (err == WSATRY_AGAIN) ? 1 : -1;
  328. #else
  329. return (err == TRY_AGAIN) ? 1 : -1;
  330. #endif
  331. #endif /* defined(HAVE_GETADDRINFO) */
  332. }
  333. }
  334. /** Return true iff <b>ip</b> is an IP reserved to localhost or local networks
  335. * in RFC1918 or RFC4193 or RFC4291. (fec0::/10, deprecated by RFC3879, is
  336. * also treated as internal for now.)
  337. */
  338. int
  339. tor_addr_is_internal_(const tor_addr_t *addr, int for_listening,
  340. const char *filename, int lineno)
  341. {
  342. uint32_t iph4 = 0;
  343. uint32_t iph6[4];
  344. tor_assert(addr);
  345. sa_family_t v_family = tor_addr_family(addr);
  346. if (v_family == AF_INET) {
  347. iph4 = tor_addr_to_ipv4h(addr);
  348. } else if (v_family == AF_INET6) {
  349. if (tor_addr_is_v4(addr)) { /* v4-mapped */
  350. uint32_t *addr32 = NULL;
  351. v_family = AF_INET;
  352. // Work around an incorrect NULL pointer dereference warning in
  353. // "clang --analyze" due to limited analysis depth
  354. addr32 = tor_addr_to_in6_addr32(addr);
  355. // To improve performance, wrap this assertion in:
  356. // #if !defined(__clang_analyzer__) || PARANOIA
  357. tor_assert(addr32);
  358. iph4 = ntohl(addr32[3]);
  359. }
  360. }
  361. if (v_family == AF_INET6) {
  362. const uint32_t *a32 = tor_addr_to_in6_addr32(addr);
  363. iph6[0] = ntohl(a32[0]);
  364. iph6[1] = ntohl(a32[1]);
  365. iph6[2] = ntohl(a32[2]);
  366. iph6[3] = ntohl(a32[3]);
  367. if (for_listening && !iph6[0] && !iph6[1] && !iph6[2] && !iph6[3]) /* :: */
  368. return 0;
  369. if (((iph6[0] & 0xfe000000) == 0xfc000000) || /* fc00/7 - RFC4193 */
  370. ((iph6[0] & 0xffc00000) == 0xfe800000) || /* fe80/10 - RFC4291 */
  371. ((iph6[0] & 0xffc00000) == 0xfec00000)) /* fec0/10 D- RFC3879 */
  372. return 1;
  373. if (!iph6[0] && !iph6[1] && !iph6[2] &&
  374. ((iph6[3] & 0xfffffffe) == 0x00000000)) /* ::/127 */
  375. return 1;
  376. return 0;
  377. } else if (v_family == AF_INET) {
  378. if (for_listening && !iph4) /* special case for binding to 0.0.0.0 */
  379. return 0;
  380. if (((iph4 & 0xff000000) == 0x0a000000) || /* 10/8 */
  381. ((iph4 & 0xff000000) == 0x00000000) || /* 0/8 */
  382. ((iph4 & 0xff000000) == 0x7f000000) || /* 127/8 */
  383. ((iph4 & 0xffff0000) == 0xa9fe0000) || /* 169.254/16 */
  384. ((iph4 & 0xfff00000) == 0xac100000) || /* 172.16/12 */
  385. ((iph4 & 0xffff0000) == 0xc0a80000)) /* 192.168/16 */
  386. return 1;
  387. return 0;
  388. }
  389. /* unknown address family... assume it's not safe for external use */
  390. /* rather than tor_assert(0) */
  391. log_warn(LD_BUG, "tor_addr_is_internal() called from %s:%d with a "
  392. "non-IP address of type %d", filename, lineno, (int)v_family);
  393. tor_fragile_assert();
  394. return 1;
  395. }
  396. /** Convert a tor_addr_t <b>addr</b> into a string, and store it in
  397. * <b>dest</b> of size <b>len</b>. Returns a pointer to dest on success,
  398. * or NULL on failure. If <b>decorate</b>, surround IPv6 addresses with
  399. * brackets.
  400. */
  401. const char *
  402. tor_addr_to_str(char *dest, const tor_addr_t *addr, size_t len, int decorate)
  403. {
  404. const char *ptr;
  405. tor_assert(addr && dest);
  406. switch (tor_addr_family(addr)) {
  407. case AF_INET:
  408. /* Shortest addr x.x.x.x + \0 */
  409. if (len < 8)
  410. return NULL;
  411. ptr = tor_inet_ntop(AF_INET, &addr->addr.in_addr, dest, len);
  412. break;
  413. case AF_INET6:
  414. /* Shortest addr [ :: ] + \0 */
  415. if (len < (3 + (decorate ? 2 : 0)))
  416. return NULL;
  417. if (decorate)
  418. ptr = tor_inet_ntop(AF_INET6, &addr->addr.in6_addr, dest+1, len-2);
  419. else
  420. ptr = tor_inet_ntop(AF_INET6, &addr->addr.in6_addr, dest, len);
  421. if (ptr && decorate) {
  422. *dest = '[';
  423. memcpy(dest+strlen(dest), "]", 2);
  424. tor_assert(ptr == dest+1);
  425. ptr = dest;
  426. }
  427. break;
  428. case AF_UNIX:
  429. tor_snprintf(dest, len, "AF_UNIX");
  430. ptr = dest;
  431. break;
  432. default:
  433. return NULL;
  434. }
  435. return ptr;
  436. }
  437. /** Parse an .in-addr.arpa or .ip6.arpa address from <b>address</b>. Return 0
  438. * if this is not an .in-addr.arpa address or an .ip6.arpa address. Return -1
  439. * if this is an ill-formed .in-addr.arpa address or an .ip6.arpa address.
  440. * Also return -1 if <b>family</b> is not AF_UNSPEC, and the parsed address
  441. * family does not match <b>family</b>. On success, return 1, and store the
  442. * result, if any, into <b>result</b>, if provided.
  443. *
  444. * If <b>accept_regular</b> is set and the address is in neither recognized
  445. * reverse lookup hostname format, try parsing the address as a regular
  446. * IPv4 or IPv6 address too.
  447. */
  448. int
  449. tor_addr_parse_PTR_name(tor_addr_t *result, const char *address,
  450. int family, int accept_regular)
  451. {
  452. if (!strcasecmpend(address, ".in-addr.arpa")) {
  453. /* We have an in-addr.arpa address. */
  454. char buf[INET_NTOA_BUF_LEN];
  455. size_t len;
  456. struct in_addr inaddr;
  457. if (family == AF_INET6)
  458. return -1;
  459. len = strlen(address) - strlen(".in-addr.arpa");
  460. if (len >= INET_NTOA_BUF_LEN)
  461. return -1; /* Too long. */
  462. memcpy(buf, address, len);
  463. buf[len] = '\0';
  464. if (tor_inet_aton(buf, &inaddr) == 0)
  465. return -1; /* malformed. */
  466. /* reverse the bytes */
  467. inaddr.s_addr = (uint32_t)
  468. (((inaddr.s_addr & 0x000000ff) << 24)
  469. |((inaddr.s_addr & 0x0000ff00) << 8)
  470. |((inaddr.s_addr & 0x00ff0000) >> 8)
  471. |((inaddr.s_addr & 0xff000000) >> 24));
  472. if (result) {
  473. tor_addr_from_in(result, &inaddr);
  474. }
  475. return 1;
  476. }
  477. if (!strcasecmpend(address, ".ip6.arpa")) {
  478. const char *cp;
  479. int n0, n1;
  480. struct in6_addr in6;
  481. if (family == AF_INET)
  482. return -1;
  483. cp = address;
  484. for (int i = 0; i < 16; ++i) {
  485. n0 = hex_decode_digit(*cp++); /* The low-order nybble appears first. */
  486. if (*cp++ != '.') return -1; /* Then a dot. */
  487. n1 = hex_decode_digit(*cp++); /* The high-order nybble appears first. */
  488. if (*cp++ != '.') return -1; /* Then another dot. */
  489. if (n0<0 || n1 < 0) /* Both nybbles must be hex. */
  490. return -1;
  491. /* We don't check the length of the string in here. But that's okay,
  492. * since we already know that the string ends with ".ip6.arpa", and
  493. * there is no way to frameshift .ip6.arpa so it fits into the pattern
  494. * of hexdigit, period, hexdigit, period that we enforce above.
  495. */
  496. /* Assign from low-byte to high-byte. */
  497. in6.s6_addr[15-i] = n0 | (n1 << 4);
  498. }
  499. if (strcasecmp(cp, "ip6.arpa"))
  500. return -1;
  501. if (result) {
  502. tor_addr_from_in6(result, &in6);
  503. }
  504. return 1;
  505. }
  506. if (accept_regular) {
  507. tor_addr_t tmp;
  508. int r = tor_addr_parse(&tmp, address);
  509. if (r < 0)
  510. return 0;
  511. if (r != family && family != AF_UNSPEC)
  512. return -1;
  513. if (result)
  514. memcpy(result, &tmp, sizeof(tor_addr_t));
  515. return 1;
  516. }
  517. return 0;
  518. }
  519. /** Convert <b>addr</b> to an in-addr.arpa name or a .ip6.arpa name,
  520. * and store the result in the <b>outlen</b>-byte buffer at
  521. * <b>out</b>. Returns a non-negative integer on success.
  522. * Returns -1 on failure. */
  523. int
  524. tor_addr_to_PTR_name(char *out, size_t outlen,
  525. const tor_addr_t *addr)
  526. {
  527. tor_assert(out);
  528. tor_assert(addr);
  529. if (addr->family == AF_INET) {
  530. uint32_t a = tor_addr_to_ipv4h(addr);
  531. return tor_snprintf(out, outlen, "%d.%d.%d.%d.in-addr.arpa",
  532. (int)(uint8_t)((a )&0xff),
  533. (int)(uint8_t)((a>>8 )&0xff),
  534. (int)(uint8_t)((a>>16)&0xff),
  535. (int)(uint8_t)((a>>24)&0xff));
  536. } else if (addr->family == AF_INET6) {
  537. int i;
  538. char *cp = out;
  539. const uint8_t *bytes = tor_addr_to_in6_addr8(addr);
  540. if (outlen < REVERSE_LOOKUP_NAME_BUF_LEN)
  541. return -1;
  542. for (i = 15; i >= 0; --i) {
  543. uint8_t byte = bytes[i];
  544. *cp++ = "0123456789abcdef"[byte & 0x0f];
  545. *cp++ = '.';
  546. *cp++ = "0123456789abcdef"[byte >> 4];
  547. *cp++ = '.';
  548. }
  549. memcpy(cp, "ip6.arpa", 9); /* 8 characters plus NUL */
  550. return 32 * 2 + 8;
  551. }
  552. return -1;
  553. }
  554. /** Parse a string <b>s</b> containing an IPv4/IPv6 address, and possibly
  555. * a mask and port or port range. Store the parsed address in
  556. * <b>addr_out</b>, a mask (if any) in <b>mask_out</b>, and port(s) (if any)
  557. * in <b>port_min_out</b> and <b>port_max_out</b>.
  558. *
  559. * The syntax is:
  560. * Address OptMask OptPortRange
  561. * Address ::= IPv4Address / "[" IPv6Address "]" / "*"
  562. * OptMask ::= "/" Integer /
  563. * OptPortRange ::= ":*" / ":" Integer / ":" Integer "-" Integer /
  564. *
  565. * - If mask, minport, or maxport are NULL, we do not want these
  566. * options to be set; treat them as an error if present.
  567. * - If the string has no mask, the mask is set to /32 (IPv4) or /128 (IPv6).
  568. * - If the string has one port, it is placed in both min and max port
  569. * variables.
  570. * - If the string has no port(s), port_(min|max)_out are set to 1 and 65535.
  571. *
  572. * Return an address family on success, or -1 if an invalid address string is
  573. * provided.
  574. *
  575. * If 'flags & TAPMP_EXTENDED_STAR' is false, then the wildcard address '*'
  576. * yield an IPv4 wildcard.
  577. *
  578. * If 'flags & TAPMP_EXTENDED_STAR' is true, then the wildcard address '*'
  579. * yields an AF_UNSPEC wildcard address, which expands to corresponding
  580. * wildcard IPv4 and IPv6 rules, and the following change is made
  581. * in the grammar above:
  582. * Address ::= IPv4Address / "[" IPv6Address "]" / "*" / "*4" / "*6"
  583. * with the new "*4" and "*6" productions creating a wildcard to match
  584. * IPv4 or IPv6 addresses.
  585. *
  586. * If 'flags & TAPMP_EXTENDED_STAR' and 'flags & TAPMP_STAR_IPV4_ONLY' are
  587. * both true, then the wildcard address '*' yields an IPv4 wildcard.
  588. *
  589. * If 'flags & TAPMP_EXTENDED_STAR' and 'flags & TAPMP_STAR_IPV6_ONLY' are
  590. * both true, then the wildcard address '*' yields an IPv6 wildcard.
  591. *
  592. * TAPMP_STAR_IPV4_ONLY and TAPMP_STAR_IPV6_ONLY are mutually exclusive. */
  593. int
  594. tor_addr_parse_mask_ports(const char *s,
  595. unsigned flags,
  596. tor_addr_t *addr_out,
  597. maskbits_t *maskbits_out,
  598. uint16_t *port_min_out, uint16_t *port_max_out)
  599. {
  600. char *base = NULL, *address, *mask = NULL, *port = NULL, *rbracket = NULL;
  601. char *endptr;
  602. int any_flag=0, v4map=0;
  603. sa_family_t family;
  604. struct in6_addr in6_tmp;
  605. struct in_addr in_tmp = { .s_addr = 0 };
  606. tor_assert(s);
  607. tor_assert(addr_out);
  608. /* We can either only want an IPv4 address or only want an IPv6 address,
  609. * but we can't only want IPv4 & IPv6 at the same time. */
  610. tor_assert(!((flags & TAPMP_STAR_IPV4_ONLY)
  611. && (flags & TAPMP_STAR_IPV6_ONLY)));
  612. /** Longest possible length for an address, mask, and port-range combination.
  613. * Includes IP, [], /mask, :, ports */
  614. #define MAX_ADDRESS_LENGTH (TOR_ADDR_BUF_LEN+2+(1+INET_NTOA_BUF_LEN)+12+1)
  615. if (strlen(s) > MAX_ADDRESS_LENGTH) {
  616. log_warn(LD_GENERAL, "Impossibly long IP %s; rejecting", escaped(s));
  617. goto err;
  618. }
  619. base = tor_strdup(s);
  620. /* Break 'base' into separate strings. */
  621. address = base;
  622. if (*address == '[') { /* Probably IPv6 */
  623. address++;
  624. rbracket = strchr(address, ']');
  625. if (!rbracket) {
  626. log_warn(LD_GENERAL,
  627. "No closing IPv6 bracket in address pattern; rejecting.");
  628. goto err;
  629. }
  630. }
  631. mask = strchr((rbracket?rbracket:address),'/');
  632. port = strchr((mask?mask:(rbracket?rbracket:address)), ':');
  633. if (port)
  634. *port++ = '\0';
  635. if (mask)
  636. *mask++ = '\0';
  637. if (rbracket)
  638. *rbracket = '\0';
  639. if (port && mask)
  640. tor_assert(port > mask);
  641. if (mask && rbracket)
  642. tor_assert(mask > rbracket);
  643. /* Now "address" is the a.b.c.d|'*'|abcd::1 part...
  644. * "mask" is the Mask|Maskbits part...
  645. * and "port" is the *|port|min-max part.
  646. */
  647. /* Process the address portion */
  648. memset(addr_out, 0, sizeof(tor_addr_t));
  649. if (!strcmp(address, "*")) {
  650. if (flags & TAPMP_EXTENDED_STAR) {
  651. if (flags & TAPMP_STAR_IPV4_ONLY) {
  652. family = AF_INET;
  653. tor_addr_from_ipv4h(addr_out, 0);
  654. } else if (flags & TAPMP_STAR_IPV6_ONLY) {
  655. static char nil_bytes[16] = { [0]=0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0 };
  656. family = AF_INET6;
  657. tor_addr_from_ipv6_bytes(addr_out, nil_bytes);
  658. } else {
  659. family = AF_UNSPEC;
  660. tor_addr_make_unspec(addr_out);
  661. log_info(LD_GENERAL,
  662. "'%s' expands into rules which apply to all IPv4 and IPv6 "
  663. "addresses. (Use accept/reject *4:* for IPv4 or "
  664. "accept[6]/reject[6] *6:* for IPv6.)", s);
  665. }
  666. } else {
  667. family = AF_INET;
  668. tor_addr_from_ipv4h(addr_out, 0);
  669. }
  670. any_flag = 1;
  671. } else if (!strcmp(address, "*4") && (flags & TAPMP_EXTENDED_STAR)) {
  672. family = AF_INET;
  673. tor_addr_from_ipv4h(addr_out, 0);
  674. any_flag = 1;
  675. } else if (!strcmp(address, "*6") && (flags & TAPMP_EXTENDED_STAR)) {
  676. static char nil_bytes[16] = { [0]=0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0 };
  677. family = AF_INET6;
  678. tor_addr_from_ipv6_bytes(addr_out, nil_bytes);
  679. any_flag = 1;
  680. } else if (tor_inet_pton(AF_INET6, address, &in6_tmp) > 0) {
  681. family = AF_INET6;
  682. tor_addr_from_in6(addr_out, &in6_tmp);
  683. } else if (tor_inet_pton(AF_INET, address, &in_tmp) > 0) {
  684. family = AF_INET;
  685. tor_addr_from_in(addr_out, &in_tmp);
  686. } else {
  687. log_warn(LD_GENERAL, "Malformed IP %s in address pattern; rejecting.",
  688. escaped(address));
  689. goto err;
  690. }
  691. v4map = tor_addr_is_v4(addr_out);
  692. /* Parse mask */
  693. if (maskbits_out) {
  694. int bits = 0;
  695. struct in_addr v4mask;
  696. if (mask) { /* the caller (tried to) specify a mask */
  697. bits = (int) strtol(mask, &endptr, 10);
  698. if (!*endptr) { /* strtol converted everything, so it was an integer */
  699. if ((bits<0 || bits>128) ||
  700. (family == AF_INET && bits > 32)) {
  701. log_warn(LD_GENERAL,
  702. "Bad number of mask bits (%d) on address range; rejecting.",
  703. bits);
  704. goto err;
  705. }
  706. } else { /* mask might still be an address-style mask */
  707. if (tor_inet_pton(AF_INET, mask, &v4mask) > 0) {
  708. bits = addr_mask_get_bits(ntohl(v4mask.s_addr));
  709. if (bits < 0) {
  710. log_warn(LD_GENERAL,
  711. "IPv4-style mask %s is not a prefix address; rejecting.",
  712. escaped(mask));
  713. goto err;
  714. }
  715. } else { /* Not IPv4; we don't do address-style IPv6 masks. */
  716. log_warn(LD_GENERAL,
  717. "Malformed mask on address range %s; rejecting.",
  718. escaped(s));
  719. goto err;
  720. }
  721. }
  722. if (family == AF_INET6 && v4map) {
  723. if (bits > 32 && bits < 96) { /* Crazy */
  724. log_warn(LD_GENERAL,
  725. "Bad mask bits %d for V4-mapped V6 address; rejecting.",
  726. bits);
  727. goto err;
  728. }
  729. /* XXXX_IP6 is this really what we want? */
  730. bits = 96 + bits%32; /* map v4-mapped masks onto 96-128 bits */
  731. }
  732. if (any_flag) {
  733. log_warn(LD_GENERAL,
  734. "Found bit prefix with wildcard address; rejecting");
  735. goto err;
  736. }
  737. } else { /* pick an appropriate mask, as none was given */
  738. if (any_flag)
  739. bits = 0; /* This is okay whether it's V6 or V4 (FIX V4-mapped V6!) */
  740. else if (tor_addr_family(addr_out) == AF_INET)
  741. bits = 32;
  742. else if (tor_addr_family(addr_out) == AF_INET6)
  743. bits = 128;
  744. }
  745. *maskbits_out = (maskbits_t) bits;
  746. } else {
  747. if (mask) {
  748. log_warn(LD_GENERAL,
  749. "Unexpected mask in address %s; rejecting", escaped(s));
  750. goto err;
  751. }
  752. }
  753. /* Parse port(s) */
  754. if (port_min_out) {
  755. uint16_t port2;
  756. if (!port_max_out) /* caller specified one port; fake the second one */
  757. port_max_out = &port2;
  758. if (parse_port_range(port, port_min_out, port_max_out) < 0) {
  759. goto err;
  760. } else if ((*port_min_out != *port_max_out) && port_max_out == &port2) {
  761. log_warn(LD_GENERAL,
  762. "Wanted one port from address range, but there are two.");
  763. port_max_out = NULL; /* caller specified one port, so set this back */
  764. goto err;
  765. }
  766. } else {
  767. if (port) {
  768. log_warn(LD_GENERAL,
  769. "Unexpected ports in address %s; rejecting", escaped(s));
  770. goto err;
  771. }
  772. }
  773. tor_free(base);
  774. return tor_addr_family(addr_out);
  775. err:
  776. tor_free(base);
  777. return -1;
  778. }
  779. /** Determine whether an address is IPv4, either native or IPv4-mapped IPv6.
  780. * Note that this is about representation only, as any decent stack will
  781. * reject IPv4-mapped addresses received on the wire (and won't use them
  782. * on the wire either).
  783. */
  784. int
  785. tor_addr_is_v4(const tor_addr_t *addr)
  786. {
  787. tor_assert(addr);
  788. if (tor_addr_family(addr) == AF_INET)
  789. return 1;
  790. if (tor_addr_family(addr) == AF_INET6) {
  791. /* First two don't need to be ordered */
  792. uint32_t *a32 = tor_addr_to_in6_addr32(addr);
  793. if (a32[0] == 0 && a32[1] == 0 && ntohl(a32[2]) == 0x0000ffffu)
  794. return 1;
  795. }
  796. return 0; /* Not IPv4 - unknown family or a full-blood IPv6 address */
  797. }
  798. /** Determine whether an address <b>addr</b> is null, either all zeroes or
  799. * belonging to family AF_UNSPEC.
  800. */
  801. int
  802. tor_addr_is_null(const tor_addr_t *addr)
  803. {
  804. tor_assert(addr);
  805. switch (tor_addr_family(addr)) {
  806. case AF_INET6: {
  807. uint32_t *a32 = tor_addr_to_in6_addr32(addr);
  808. return (a32[0] == 0) && (a32[1] == 0) && (a32[2] == 0) && (a32[3] == 0);
  809. }
  810. case AF_INET:
  811. return (tor_addr_to_ipv4n(addr) == 0);
  812. case AF_UNIX:
  813. return 1;
  814. case AF_UNSPEC:
  815. return 1;
  816. default:
  817. log_warn(LD_BUG, "Called with unknown address family %d",
  818. (int)tor_addr_family(addr));
  819. return 0;
  820. }
  821. //return 1;
  822. }
  823. /** Return true iff <b>addr</b> is a loopback address */
  824. int
  825. tor_addr_is_loopback(const tor_addr_t *addr)
  826. {
  827. tor_assert(addr);
  828. switch (tor_addr_family(addr)) {
  829. case AF_INET6: {
  830. /* ::1 */
  831. uint32_t *a32 = tor_addr_to_in6_addr32(addr);
  832. return (a32[0] == 0) && (a32[1] == 0) && (a32[2] == 0) &&
  833. (ntohl(a32[3]) == 1);
  834. }
  835. case AF_INET:
  836. /* 127.0.0.1 */
  837. return (tor_addr_to_ipv4h(addr) & 0xff000000) == 0x7f000000;
  838. case AF_UNSPEC:
  839. return 0;
  840. /* LCOV_EXCL_START */
  841. default:
  842. tor_fragile_assert();
  843. return 0;
  844. /* LCOV_EXCL_STOP */
  845. }
  846. }
  847. /* Is addr valid?
  848. * Checks that addr is non-NULL and not tor_addr_is_null().
  849. * If for_listening is true, IPv4 addr 0.0.0.0 is allowed.
  850. * It means "bind to all addresses on the local machine". */
  851. int
  852. tor_addr_is_valid(const tor_addr_t *addr, int for_listening)
  853. {
  854. /* NULL addresses are invalid regardless of for_listening */
  855. if (addr == NULL) {
  856. return 0;
  857. }
  858. /* Only allow IPv4 0.0.0.0 for_listening. */
  859. if (for_listening && addr->family == AF_INET
  860. && tor_addr_to_ipv4h(addr) == 0) {
  861. return 1;
  862. }
  863. /* Otherwise, the address is valid if it's not tor_addr_is_null() */
  864. return !tor_addr_is_null(addr);
  865. }
  866. /* Is the network-order IPv4 address v4n_addr valid?
  867. * Checks that addr is not zero.
  868. * Except if for_listening is true, where IPv4 addr 0.0.0.0 is allowed. */
  869. int
  870. tor_addr_is_valid_ipv4n(uint32_t v4n_addr, int for_listening)
  871. {
  872. /* Any IPv4 address is valid with for_listening. */
  873. if (for_listening) {
  874. return 1;
  875. }
  876. /* Otherwise, zero addresses are invalid. */
  877. return v4n_addr != 0;
  878. }
  879. /* Is port valid?
  880. * Checks that port is not 0.
  881. * Except if for_listening is true, where port 0 is allowed.
  882. * It means "OS chooses a port". */
  883. int
  884. tor_port_is_valid(uint16_t port, int for_listening)
  885. {
  886. /* Any port value is valid with for_listening. */
  887. if (for_listening) {
  888. return 1;
  889. }
  890. /* Otherwise, zero ports are invalid. */
  891. return port != 0;
  892. }
  893. /** Set <b>dest</b> to equal the IPv4 address in <b>v4addr</b> (given in
  894. * network order). */
  895. void
  896. tor_addr_from_ipv4n(tor_addr_t *dest, uint32_t v4addr)
  897. {
  898. tor_assert(dest);
  899. memset(dest, 0, sizeof(tor_addr_t));
  900. dest->family = AF_INET;
  901. dest->addr.in_addr.s_addr = v4addr;
  902. }
  903. /** Set <b>dest</b> to equal the IPv6 address in the 16 bytes at
  904. * <b>ipv6_bytes</b>. */
  905. void
  906. tor_addr_from_ipv6_bytes(tor_addr_t *dest, const char *ipv6_bytes)
  907. {
  908. tor_assert(dest);
  909. tor_assert(ipv6_bytes);
  910. memset(dest, 0, sizeof(tor_addr_t));
  911. dest->family = AF_INET6;
  912. memcpy(dest->addr.in6_addr.s6_addr, ipv6_bytes, 16);
  913. }
  914. /** Set <b>dest</b> equal to the IPv6 address in the in6_addr <b>in6</b>. */
  915. void
  916. tor_addr_from_in6(tor_addr_t *dest, const struct in6_addr *in6)
  917. {
  918. tor_addr_from_ipv6_bytes(dest, (const char*)in6->s6_addr);
  919. }
  920. /** Copy a tor_addr_t from <b>src</b> to <b>dest</b>.
  921. */
  922. void
  923. tor_addr_copy(tor_addr_t *dest, const tor_addr_t *src)
  924. {
  925. if (src == dest)
  926. return;
  927. tor_assert(src);
  928. tor_assert(dest);
  929. memcpy(dest, src, sizeof(tor_addr_t));
  930. }
  931. /** Copy a tor_addr_t from <b>src</b> to <b>dest</b>, taking extra care to
  932. * copy only the well-defined portions. Used for computing hashes of
  933. * addresses.
  934. */
  935. void
  936. tor_addr_copy_tight(tor_addr_t *dest, const tor_addr_t *src)
  937. {
  938. tor_assert(src != dest);
  939. tor_assert(src);
  940. tor_assert(dest);
  941. memset(dest, 0, sizeof(tor_addr_t));
  942. dest->family = src->family;
  943. switch (tor_addr_family(src))
  944. {
  945. case AF_INET:
  946. dest->addr.in_addr.s_addr = src->addr.in_addr.s_addr;
  947. break;
  948. case AF_INET6:
  949. memcpy(dest->addr.in6_addr.s6_addr, src->addr.in6_addr.s6_addr, 16);
  950. case AF_UNSPEC:
  951. break;
  952. // LCOV_EXCL_START
  953. default:
  954. tor_fragile_assert();
  955. // LCOV_EXCL_STOP
  956. }
  957. }
  958. /** Given two addresses <b>addr1</b> and <b>addr2</b>, return 0 if the two
  959. * addresses are equivalent under the mask mbits, less than 0 if addr1
  960. * precedes addr2, and greater than 0 otherwise.
  961. *
  962. * Different address families (IPv4 vs IPv6) are always considered unequal if
  963. * <b>how</b> is CMP_EXACT; otherwise, IPv6-mapped IPv4 addresses are
  964. * considered equivalent to their IPv4 equivalents.
  965. *
  966. * As a special case, all pointer-wise distinct AF_UNIX addresses are always
  967. * considered unequal since tor_addr_t currently does not contain the
  968. * information required to make the comparison.
  969. */
  970. int
  971. tor_addr_compare(const tor_addr_t *addr1, const tor_addr_t *addr2,
  972. tor_addr_comparison_t how)
  973. {
  974. return tor_addr_compare_masked(addr1, addr2, 128, how);
  975. }
  976. /** As tor_addr_compare(), but only looks at the first <b>mask</b> bits of
  977. * the address.
  978. *
  979. * Reduce over-specific masks (>128 for ipv6, >32 for ipv4) to 128 or 32.
  980. *
  981. * The mask is interpreted relative to <b>addr1</b>, so that if a is
  982. * \::ffff:1.2.3.4, and b is 3.4.5.6,
  983. * tor_addr_compare_masked(a,b,100,CMP_SEMANTIC) is the same as
  984. * -tor_addr_compare_masked(b,a,4,CMP_SEMANTIC).
  985. *
  986. * We guarantee that the ordering from tor_addr_compare_masked is a total
  987. * order on addresses, but not that it is any particular order, or that it
  988. * will be the same from one version to the next.
  989. */
  990. int
  991. tor_addr_compare_masked(const tor_addr_t *addr1, const tor_addr_t *addr2,
  992. maskbits_t mbits, tor_addr_comparison_t how)
  993. {
  994. /** Helper: Evaluates to -1 if a is less than b, 0 if a equals b, or 1 if a
  995. * is greater than b. May evaluate a and b more than once. */
  996. #define TRISTATE(a,b) (((a)<(b))?-1: (((a)==(b))?0:1))
  997. sa_family_t family1, family2, v_family1, v_family2;
  998. tor_assert(addr1 && addr2);
  999. v_family1 = family1 = tor_addr_family(addr1);
  1000. v_family2 = family2 = tor_addr_family(addr2);
  1001. if (family1==family2) {
  1002. /* When the families are the same, there's only one way to do the
  1003. * comparison: exactly. */
  1004. int r;
  1005. switch (family1) {
  1006. case AF_UNSPEC:
  1007. return 0; /* All unspecified addresses are equal */
  1008. case AF_INET: {
  1009. uint32_t a1 = tor_addr_to_ipv4h(addr1);
  1010. uint32_t a2 = tor_addr_to_ipv4h(addr2);
  1011. if (mbits <= 0)
  1012. return 0;
  1013. if (mbits > 32)
  1014. mbits = 32;
  1015. a1 >>= (32-mbits);
  1016. a2 >>= (32-mbits);
  1017. r = TRISTATE(a1, a2);
  1018. return r;
  1019. }
  1020. case AF_INET6: {
  1021. if (mbits > 128)
  1022. mbits = 128;
  1023. const uint8_t *a1 = tor_addr_to_in6_addr8(addr1);
  1024. const uint8_t *a2 = tor_addr_to_in6_addr8(addr2);
  1025. const int bytes = mbits >> 3;
  1026. const int leftover_bits = mbits & 7;
  1027. if (bytes && (r = tor_memcmp(a1, a2, bytes))) {
  1028. return r;
  1029. } else if (leftover_bits) {
  1030. uint8_t b1 = a1[bytes] >> (8-leftover_bits);
  1031. uint8_t b2 = a2[bytes] >> (8-leftover_bits);
  1032. return TRISTATE(b1, b2);
  1033. } else {
  1034. return 0;
  1035. }
  1036. }
  1037. case AF_UNIX:
  1038. /* HACKHACKHACKHACKHACK:
  1039. * tor_addr_t doesn't contain a copy of sun_path, so it's not
  1040. * possible to compare this at all.
  1041. *
  1042. * Since the only time we currently actually should be comparing
  1043. * 2 AF_UNIX addresses is when dealing with ISO_CLIENTADDR (which
  1044. * is disabled for AF_UNIX SocksPorts anyway), this just does
  1045. * a pointer comparison.
  1046. *
  1047. * See: #20261.
  1048. */
  1049. if (addr1 < addr2)
  1050. return -1;
  1051. else if (addr1 == addr2)
  1052. return 0;
  1053. else
  1054. return 1;
  1055. /* LCOV_EXCL_START */
  1056. default:
  1057. tor_fragile_assert();
  1058. return 0;
  1059. /* LCOV_EXCL_STOP */
  1060. }
  1061. } else if (how == CMP_EXACT) {
  1062. /* Unequal families and an exact comparison? Stop now! */
  1063. return TRISTATE(family1, family2);
  1064. }
  1065. if (mbits == 0)
  1066. return 0;
  1067. if (family1 == AF_INET6 && tor_addr_is_v4(addr1))
  1068. v_family1 = AF_INET;
  1069. if (family2 == AF_INET6 && tor_addr_is_v4(addr2))
  1070. v_family2 = AF_INET;
  1071. if (v_family1 == v_family2) {
  1072. /* One or both addresses are a mapped ipv4 address. */
  1073. uint32_t a1, a2;
  1074. if (family1 == AF_INET6) {
  1075. a1 = tor_addr_to_mapped_ipv4h(addr1);
  1076. if (mbits <= 96)
  1077. return 0;
  1078. mbits -= 96; /* We just decided that the first 96 bits of a1 "match". */
  1079. } else {
  1080. a1 = tor_addr_to_ipv4h(addr1);
  1081. }
  1082. if (family2 == AF_INET6) {
  1083. a2 = tor_addr_to_mapped_ipv4h(addr2);
  1084. } else {
  1085. a2 = tor_addr_to_ipv4h(addr2);
  1086. }
  1087. if (mbits > 32) mbits = 32;
  1088. a1 >>= (32-mbits);
  1089. a2 >>= (32-mbits);
  1090. return TRISTATE(a1, a2);
  1091. } else {
  1092. /* Unequal families, and semantic comparison, and no semantic family
  1093. * matches. */
  1094. return TRISTATE(family1, family2);
  1095. }
  1096. }
  1097. /** Return a hash code based on the address addr. DOCDOC extra */
  1098. uint64_t
  1099. tor_addr_hash(const tor_addr_t *addr)
  1100. {
  1101. switch (tor_addr_family(addr)) {
  1102. case AF_INET:
  1103. return siphash24g(&addr->addr.in_addr.s_addr, 4);
  1104. case AF_UNSPEC:
  1105. return 0x4e4d5342;
  1106. case AF_INET6:
  1107. return siphash24g(&addr->addr.in6_addr.s6_addr, 16);
  1108. /* LCOV_EXCL_START */
  1109. default:
  1110. tor_fragile_assert();
  1111. return 0;
  1112. /* LCOV_EXCL_STOP */
  1113. }
  1114. }
  1115. /** Return a newly allocated string with a representation of <b>addr</b>. */
  1116. char *
  1117. tor_addr_to_str_dup(const tor_addr_t *addr)
  1118. {
  1119. char buf[TOR_ADDR_BUF_LEN];
  1120. if (tor_addr_to_str(buf, addr, sizeof(buf), 0)) {
  1121. return tor_strdup(buf);
  1122. } else {
  1123. return tor_strdup("<unknown address type>");
  1124. }
  1125. }
  1126. /** Return a string representing the address <b>addr</b>. This string
  1127. * is statically allocated, and must not be freed. Each call to
  1128. * <b>fmt_addr_impl</b> invalidates the last result of the function.
  1129. * This function is not thread-safe. If <b>decorate</b> is set, add
  1130. * brackets to IPv6 addresses.
  1131. *
  1132. * It's better to use the wrapper macros of this function:
  1133. * <b>fmt_addr()</b> and <b>fmt_and_decorate_addr()</b>.
  1134. */
  1135. const char *
  1136. fmt_addr_impl(const tor_addr_t *addr, int decorate)
  1137. {
  1138. static char buf[TOR_ADDR_BUF_LEN];
  1139. if (!addr) return "<null>";
  1140. if (tor_addr_to_str(buf, addr, sizeof(buf), decorate))
  1141. return buf;
  1142. else
  1143. return "???";
  1144. }
  1145. /** Return a string representing the pair <b>addr</b> and <b>port</b>.
  1146. * This calls fmt_and_decorate_addr internally, so IPv6 addresses will
  1147. * have brackets, and the caveats of fmt_addr_impl apply.
  1148. */
  1149. const char *
  1150. fmt_addrport(const tor_addr_t *addr, uint16_t port)
  1151. {
  1152. /* Add space for a colon and up to 5 digits. */
  1153. static char buf[TOR_ADDR_BUF_LEN + 6];
  1154. tor_snprintf(buf, sizeof(buf), "%s:%u", fmt_and_decorate_addr(addr), port);
  1155. return buf;
  1156. }
  1157. /** Like fmt_addr(), but takes <b>addr</b> as a host-order IPv4
  1158. * addresses. Also not thread-safe, also clobbers its return buffer on
  1159. * repeated calls. */
  1160. const char *
  1161. fmt_addr32(uint32_t addr)
  1162. {
  1163. static char buf[INET_NTOA_BUF_LEN];
  1164. struct in_addr in;
  1165. in.s_addr = htonl(addr);
  1166. tor_inet_ntoa(&in, buf, sizeof(buf));
  1167. return buf;
  1168. }
  1169. /** Convert the string in <b>src</b> to a tor_addr_t <b>addr</b>. The string
  1170. * may be an IPv4 address, an IPv6 address, or an IPv6 address surrounded by
  1171. * square brackets.
  1172. *
  1173. * Return an address family on success, or -1 if an invalid address string is
  1174. * provided. */
  1175. int
  1176. tor_addr_parse(tor_addr_t *addr, const char *src)
  1177. {
  1178. /* Holds substring of IPv6 address after removing square brackets */
  1179. char *tmp = NULL;
  1180. int result;
  1181. struct in_addr in_tmp;
  1182. struct in6_addr in6_tmp;
  1183. tor_assert(addr && src);
  1184. if (src[0] == '[' && src[1])
  1185. src = tmp = tor_strndup(src+1, strlen(src)-2);
  1186. if (tor_inet_pton(AF_INET6, src, &in6_tmp) > 0) {
  1187. result = AF_INET6;
  1188. tor_addr_from_in6(addr, &in6_tmp);
  1189. } else if (tor_inet_pton(AF_INET, src, &in_tmp) > 0) {
  1190. result = AF_INET;
  1191. tor_addr_from_in(addr, &in_tmp);
  1192. } else {
  1193. result = -1;
  1194. }
  1195. tor_free(tmp);
  1196. return result;
  1197. }
  1198. /** Parse an address or address-port combination from <b>s</b>, resolve the
  1199. * address as needed, and put the result in <b>addr_out</b> and (optionally)
  1200. * <b>port_out</b>. Return 0 on success, negative on failure. */
  1201. int
  1202. tor_addr_port_lookup(const char *s, tor_addr_t *addr_out, uint16_t *port_out)
  1203. {
  1204. const char *port;
  1205. tor_addr_t addr;
  1206. uint16_t portval;
  1207. char *tmp = NULL;
  1208. tor_assert(s);
  1209. tor_assert(addr_out);
  1210. s = eat_whitespace(s);
  1211. if (*s == '[') {
  1212. port = strstr(s, "]");
  1213. if (!port)
  1214. goto err;
  1215. tmp = tor_strndup(s+1, port-(s+1));
  1216. port = port+1;
  1217. if (*port == ':')
  1218. port++;
  1219. else
  1220. port = NULL;
  1221. } else {
  1222. port = strchr(s, ':');
  1223. if (port)
  1224. tmp = tor_strndup(s, port-s);
  1225. else
  1226. tmp = tor_strdup(s);
  1227. if (port)
  1228. ++port;
  1229. }
  1230. if (tor_addr_lookup(tmp, AF_UNSPEC, &addr) != 0)
  1231. goto err;
  1232. tor_free(tmp);
  1233. if (port) {
  1234. portval = (int) tor_parse_long(port, 10, 1, 65535, NULL, NULL);
  1235. if (!portval)
  1236. goto err;
  1237. } else {
  1238. portval = 0;
  1239. }
  1240. if (port_out)
  1241. *port_out = portval;
  1242. tor_addr_copy(addr_out, &addr);
  1243. return 0;
  1244. err:
  1245. tor_free(tmp);
  1246. return -1;
  1247. }
  1248. #ifdef _WIN32
  1249. typedef ULONG (WINAPI *GetAdaptersAddresses_fn_t)(
  1250. ULONG, ULONG, PVOID, PIP_ADAPTER_ADDRESSES, PULONG);
  1251. #endif
  1252. #ifdef HAVE_IFADDRS_TO_SMARTLIST
  1253. /*
  1254. * Convert a linked list consisting of <b>ifaddrs</b> structures
  1255. * into smartlist of <b>tor_addr_t</b> structures.
  1256. */
  1257. STATIC smartlist_t *
  1258. ifaddrs_to_smartlist(const struct ifaddrs *ifa, sa_family_t family)
  1259. {
  1260. smartlist_t *result = smartlist_new();
  1261. const struct ifaddrs *i;
  1262. for (i = ifa; i; i = i->ifa_next) {
  1263. tor_addr_t tmp;
  1264. if ((i->ifa_flags & (IFF_UP | IFF_RUNNING)) != (IFF_UP | IFF_RUNNING))
  1265. continue;
  1266. if (!i->ifa_addr)
  1267. continue;
  1268. if (i->ifa_addr->sa_family != AF_INET &&
  1269. i->ifa_addr->sa_family != AF_INET6)
  1270. continue;
  1271. if (family != AF_UNSPEC && i->ifa_addr->sa_family != family)
  1272. continue;
  1273. if (tor_addr_from_sockaddr(&tmp, i->ifa_addr, NULL) < 0)
  1274. continue;
  1275. smartlist_add(result, tor_memdup(&tmp, sizeof(tmp)));
  1276. }
  1277. return result;
  1278. }
  1279. /** Use getiffaddrs() function to get list of current machine
  1280. * network interface addresses. Represent the result by smartlist of
  1281. * <b>tor_addr_t</b> structures.
  1282. */
  1283. STATIC smartlist_t *
  1284. get_interface_addresses_ifaddrs(int severity, sa_family_t family)
  1285. {
  1286. /* Most free Unixy systems provide getifaddrs, which gives us a linked list
  1287. * of struct ifaddrs. */
  1288. struct ifaddrs *ifa = NULL;
  1289. smartlist_t *result;
  1290. if (getifaddrs(&ifa) < 0) {
  1291. log_fn(severity, LD_NET, "Unable to call getifaddrs(): %s",
  1292. strerror(errno));
  1293. return NULL;
  1294. }
  1295. result = ifaddrs_to_smartlist(ifa, family);
  1296. freeifaddrs(ifa);
  1297. return result;
  1298. }
  1299. #endif /* defined(HAVE_IFADDRS_TO_SMARTLIST) */
  1300. #ifdef HAVE_IP_ADAPTER_TO_SMARTLIST
  1301. /** Convert a Windows-specific <b>addresses</b> linked list into smartlist
  1302. * of <b>tor_addr_t</b> structures.
  1303. */
  1304. STATIC smartlist_t *
  1305. ip_adapter_addresses_to_smartlist(const IP_ADAPTER_ADDRESSES *addresses)
  1306. {
  1307. smartlist_t *result = smartlist_new();
  1308. const IP_ADAPTER_ADDRESSES *address;
  1309. for (address = addresses; address; address = address->Next) {
  1310. const IP_ADAPTER_UNICAST_ADDRESS *a;
  1311. for (a = address->FirstUnicastAddress; a; a = a->Next) {
  1312. /* Yes, it's a linked list inside a linked list */
  1313. const struct sockaddr *sa = a->Address.lpSockaddr;
  1314. tor_addr_t tmp;
  1315. if (sa->sa_family != AF_INET && sa->sa_family != AF_INET6)
  1316. continue;
  1317. if (tor_addr_from_sockaddr(&tmp, sa, NULL) < 0)
  1318. continue;
  1319. smartlist_add(result, tor_memdup(&tmp, sizeof(tmp)));
  1320. }
  1321. }
  1322. return result;
  1323. }
  1324. /** Windows only: use GetAdaptersInfo() function to retrieve network interface
  1325. * addresses of current machine and return them to caller as smartlist of
  1326. * <b>tor_addr_t</b> structures.
  1327. */
  1328. STATIC smartlist_t *
  1329. get_interface_addresses_win32(int severity, sa_family_t family)
  1330. {
  1331. /* Windows XP began to provide GetAdaptersAddresses. Windows 2000 had a
  1332. "GetAdaptersInfo", but that's deprecated; let's just try
  1333. GetAdaptersAddresses and fall back to connect+getsockname.
  1334. */
  1335. HANDLE lib = load_windows_system_library(TEXT("iphlpapi.dll"));
  1336. smartlist_t *result = NULL;
  1337. GetAdaptersAddresses_fn_t fn;
  1338. ULONG size, res;
  1339. IP_ADAPTER_ADDRESSES *addresses = NULL;
  1340. (void) severity;
  1341. #define FLAGS (GAA_FLAG_SKIP_ANYCAST | \
  1342. GAA_FLAG_SKIP_MULTICAST | \
  1343. GAA_FLAG_SKIP_DNS_SERVER)
  1344. if (!lib) {
  1345. log_fn(severity, LD_NET, "Unable to load iphlpapi.dll");
  1346. goto done;
  1347. }
  1348. if (!(fn = (GetAdaptersAddresses_fn_t)
  1349. GetProcAddress(lib, "GetAdaptersAddresses"))) {
  1350. log_fn(severity, LD_NET, "Unable to obtain pointer to "
  1351. "GetAdaptersAddresses");
  1352. goto done;
  1353. }
  1354. /* Guess how much space we need. */
  1355. size = 15*1024;
  1356. addresses = tor_malloc(size);
  1357. res = fn(family, FLAGS, NULL, addresses, &size);
  1358. if (res == ERROR_BUFFER_OVERFLOW) {
  1359. /* we didn't guess that we needed enough space; try again */
  1360. tor_free(addresses);
  1361. addresses = tor_malloc(size);
  1362. res = fn(AF_UNSPEC, FLAGS, NULL, addresses, &size);
  1363. }
  1364. if (res != NO_ERROR) {
  1365. log_fn(severity, LD_NET, "GetAdaptersAddresses failed (result: %lu)", res);
  1366. goto done;
  1367. }
  1368. result = ip_adapter_addresses_to_smartlist(addresses);
  1369. done:
  1370. if (lib)
  1371. FreeLibrary(lib);
  1372. tor_free(addresses);
  1373. return result;
  1374. }
  1375. #endif /* defined(HAVE_IP_ADAPTER_TO_SMARTLIST) */
  1376. #ifdef HAVE_IFCONF_TO_SMARTLIST
  1377. /* Guess how much space we need. There shouldn't be any struct ifreqs
  1378. * larger than this, even on OS X where the struct's size is dynamic. */
  1379. #define IFREQ_SIZE 4096
  1380. /* This is defined on Mac OS X */
  1381. #ifndef _SIZEOF_ADDR_IFREQ
  1382. #define _SIZEOF_ADDR_IFREQ sizeof
  1383. #endif
  1384. /* Free ifc->ifc_buf safely. */
  1385. static void
  1386. ifconf_free_ifc_buf(struct ifconf *ifc)
  1387. {
  1388. /* On macOS, tor_free() takes the address of ifc.ifc_buf, which leads to
  1389. * undefined behaviour, because pointer-to-pointers are expected to be
  1390. * aligned at 8-bytes, but the ifconf structure is packed. So we use
  1391. * raw_free() instead. */
  1392. raw_free(ifc->ifc_buf);
  1393. ifc->ifc_buf = NULL;
  1394. }
  1395. /** Convert <b>*buf</b>, an ifreq structure array of size <b>buflen</b>,
  1396. * into smartlist of <b>tor_addr_t</b> structures.
  1397. */
  1398. STATIC smartlist_t *
  1399. ifreq_to_smartlist(char *buf, size_t buflen)
  1400. {
  1401. smartlist_t *result = smartlist_new();
  1402. char *end = buf + buflen;
  1403. /* These acrobatics are due to alignment issues which trigger
  1404. * undefined behaviour traps on OSX. */
  1405. struct ifreq *r = tor_malloc(IFREQ_SIZE);
  1406. while (buf < end) {
  1407. /* Copy up to IFREQ_SIZE bytes into the struct ifreq, but don't overrun
  1408. * buf. */
  1409. memcpy(r, buf, end - buf < IFREQ_SIZE ? end - buf : IFREQ_SIZE);
  1410. const struct sockaddr *sa = &r->ifr_addr;
  1411. tor_addr_t tmp;
  1412. int valid_sa_family = (sa->sa_family == AF_INET ||
  1413. sa->sa_family == AF_INET6);
  1414. int conversion_success = (tor_addr_from_sockaddr(&tmp, sa, NULL) == 0);
  1415. if (valid_sa_family && conversion_success)
  1416. smartlist_add(result, tor_memdup(&tmp, sizeof(tmp)));
  1417. buf += _SIZEOF_ADDR_IFREQ(*r);
  1418. }
  1419. tor_free(r);
  1420. return result;
  1421. }
  1422. /** Use ioctl(.,SIOCGIFCONF,.) to get a list of current machine
  1423. * network interface addresses. Represent the result by smartlist of
  1424. * <b>tor_addr_t</b> structures.
  1425. */
  1426. STATIC smartlist_t *
  1427. get_interface_addresses_ioctl(int severity, sa_family_t family)
  1428. {
  1429. /* Some older unixy systems make us use ioctl(SIOCGIFCONF) */
  1430. struct ifconf ifc;
  1431. ifc.ifc_buf = NULL;
  1432. int fd;
  1433. smartlist_t *result = NULL;
  1434. /* This interface, AFAICT, only supports AF_INET addresses,
  1435. * except on AIX. For Solaris, we could use SIOCGLIFCONF. */
  1436. /* Bail out if family is neither AF_INET nor AF_UNSPEC since
  1437. * ioctl() technique supports non-IPv4 interface addresses on
  1438. * a small number of niche systems only. If family is AF_UNSPEC,
  1439. * fall back to getting AF_INET addresses only. */
  1440. if (family == AF_UNSPEC)
  1441. family = AF_INET;
  1442. else if (family != AF_INET)
  1443. return NULL;
  1444. fd = socket(family, SOCK_DGRAM, 0);
  1445. if (fd < 0) {
  1446. tor_log(severity, LD_NET, "socket failed: %s", strerror(errno));
  1447. goto done;
  1448. }
  1449. int mult = 1;
  1450. do {
  1451. mult *= 2;
  1452. ifc.ifc_len = mult * IFREQ_SIZE;
  1453. ifc.ifc_buf = tor_realloc(ifc.ifc_buf, ifc.ifc_len);
  1454. tor_assert(ifc.ifc_buf);
  1455. if (ioctl(fd, SIOCGIFCONF, &ifc) < 0) {
  1456. tor_log(severity, LD_NET, "ioctl failed: %s", strerror(errno));
  1457. goto done;
  1458. }
  1459. /* Ensure we have least IFREQ_SIZE bytes unused at the end. Otherwise, we
  1460. * don't know if we got everything during ioctl. */
  1461. } while (mult * IFREQ_SIZE - ifc.ifc_len <= IFREQ_SIZE);
  1462. result = ifreq_to_smartlist(ifc.ifc_buf, ifc.ifc_len);
  1463. done:
  1464. if (fd >= 0)
  1465. close(fd);
  1466. ifconf_free_ifc_buf(&ifc);
  1467. return result;
  1468. }
  1469. #endif /* defined(HAVE_IFCONF_TO_SMARTLIST) */
  1470. /** Try to ask our network interfaces what addresses they are bound to.
  1471. * Return a new smartlist of tor_addr_t on success, and NULL on failure.
  1472. * (An empty smartlist indicates that we successfully learned that we have no
  1473. * addresses.) Log failure messages at <b>severity</b>. Only return the
  1474. * interface addresses of requested <b>family</b> and ignore the addresses
  1475. * of other address families. */
  1476. MOCK_IMPL(smartlist_t *,
  1477. get_interface_addresses_raw,(int severity, sa_family_t family))
  1478. {
  1479. smartlist_t *result = NULL;
  1480. #if defined(HAVE_IFADDRS_TO_SMARTLIST)
  1481. if ((result = get_interface_addresses_ifaddrs(severity, family)))
  1482. return result;
  1483. #endif
  1484. #if defined(HAVE_IP_ADAPTER_TO_SMARTLIST)
  1485. if ((result = get_interface_addresses_win32(severity, family)))
  1486. return result;
  1487. #endif
  1488. #if defined(HAVE_IFCONF_TO_SMARTLIST)
  1489. if ((result = get_interface_addresses_ioctl(severity, family)))
  1490. return result;
  1491. #endif
  1492. (void) severity;
  1493. (void) result;
  1494. return NULL;
  1495. }
  1496. /** Return true iff <b>a</b> is a multicast address. */
  1497. int
  1498. tor_addr_is_multicast(const tor_addr_t *a)
  1499. {
  1500. sa_family_t family = tor_addr_family(a);
  1501. if (family == AF_INET) {
  1502. uint32_t ipv4h = tor_addr_to_ipv4h(a);
  1503. if ((ipv4h >> 24) == 0xe0)
  1504. return 1; /* Multicast */
  1505. } else if (family == AF_INET6) {
  1506. const uint8_t *a32 = tor_addr_to_in6_addr8(a);
  1507. if (a32[0] == 0xff)
  1508. return 1;
  1509. }
  1510. return 0;
  1511. }
  1512. /** Attempt to retrieve IP address of current host by utilizing some
  1513. * UDP socket trickery. Only look for address of given <b>family</b>
  1514. * (only AF_INET and AF_INET6 are supported). Set result to *<b>addr</b>.
  1515. * Return 0 on success, -1 on failure.
  1516. */
  1517. MOCK_IMPL(int,
  1518. get_interface_address6_via_udp_socket_hack,(int severity,
  1519. sa_family_t family,
  1520. tor_addr_t *addr))
  1521. {
  1522. struct sockaddr_storage my_addr, target_addr;
  1523. int sock=-1, r=-1;
  1524. socklen_t addr_len;
  1525. memset(addr, 0, sizeof(tor_addr_t));
  1526. memset(&target_addr, 0, sizeof(target_addr));
  1527. /* Don't worry: no packets are sent. We just need to use a real address
  1528. * on the actual Internet. */
  1529. if (family == AF_INET6) {
  1530. struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)&target_addr;
  1531. /* Use the "discard" service port */
  1532. sin6->sin6_port = htons(9);
  1533. sock = tor_open_socket(PF_INET6,SOCK_DGRAM,IPPROTO_UDP);
  1534. addr_len = (socklen_t)sizeof(struct sockaddr_in6);
  1535. sin6->sin6_family = AF_INET6;
  1536. S6_ADDR16(sin6->sin6_addr)[0] = htons(0x2002); /* 2002:: */
  1537. } else if (family == AF_INET) {
  1538. struct sockaddr_in *sin = (struct sockaddr_in*)&target_addr;
  1539. /* Use the "discard" service port */
  1540. sin->sin_port = htons(9);
  1541. sock = tor_open_socket(PF_INET,SOCK_DGRAM,IPPROTO_UDP);
  1542. addr_len = (socklen_t)sizeof(struct sockaddr_in);
  1543. sin->sin_family = AF_INET;
  1544. sin->sin_addr.s_addr = htonl(0x12000001); /* 18.0.0.1 */
  1545. } else {
  1546. return -1;
  1547. }
  1548. if (sock < 0) {
  1549. int e = tor_socket_errno(-1);
  1550. log_fn(severity, LD_NET, "unable to create socket: %s",
  1551. tor_socket_strerror(e));
  1552. goto err;
  1553. }
  1554. if (tor_connect_socket(sock,(struct sockaddr *)&target_addr,
  1555. addr_len) < 0) {
  1556. int e = tor_socket_errno(sock);
  1557. log_fn(severity, LD_NET, "connect() failed: %s", tor_socket_strerror(e));
  1558. goto err;
  1559. }
  1560. if (tor_getsockname(sock,(struct sockaddr*)&my_addr, &addr_len)) {
  1561. int e = tor_socket_errno(sock);
  1562. log_fn(severity, LD_NET, "getsockname() to determine interface failed: %s",
  1563. tor_socket_strerror(e));
  1564. goto err;
  1565. }
  1566. if (tor_addr_from_sockaddr(addr, (struct sockaddr*)&my_addr, NULL) == 0) {
  1567. if (tor_addr_is_loopback(addr) || tor_addr_is_multicast(addr)) {
  1568. log_fn(severity, LD_NET, "Address that we determined via UDP socket"
  1569. " magic is unsuitable for public comms.");
  1570. } else {
  1571. r=0;
  1572. }
  1573. }
  1574. err:
  1575. if (sock >= 0)
  1576. tor_close_socket(sock);
  1577. if (r == -1)
  1578. memset(addr, 0, sizeof(tor_addr_t));
  1579. return r;
  1580. }
  1581. /** Set *<b>addr</b> to an arbitrary IP address (if any) of an interface that
  1582. * connects to the Internet. Prefer public IP addresses to internal IP
  1583. * addresses. This address should only be used in checking whether our
  1584. * address has changed, as it may be an internal IP address. Return 0 on
  1585. * success, -1 on failure.
  1586. * Prefer get_interface_address6_list for a list of all addresses on all
  1587. * interfaces which connect to the Internet.
  1588. */
  1589. MOCK_IMPL(int,
  1590. get_interface_address6,(int severity, sa_family_t family, tor_addr_t *addr))
  1591. {
  1592. smartlist_t *addrs;
  1593. int rv = -1;
  1594. tor_assert(addr);
  1595. memset(addr, 0, sizeof(tor_addr_t));
  1596. /* Get a list of public or internal IPs in arbitrary order */
  1597. addrs = get_interface_address6_list(severity, family, 1);
  1598. /* Find the first non-internal address, or the last internal address
  1599. * Ideally, we want the default route, see #12377 for details */
  1600. SMARTLIST_FOREACH_BEGIN(addrs, tor_addr_t *, a) {
  1601. tor_addr_copy(addr, a);
  1602. rv = 0;
  1603. /* If we found a non-internal address, declare success. Otherwise,
  1604. * keep looking. */
  1605. if (!tor_addr_is_internal(a, 0))
  1606. break;
  1607. } SMARTLIST_FOREACH_END(a);
  1608. interface_address6_list_free(addrs);
  1609. return rv;
  1610. }
  1611. /** Free a smartlist of IP addresses returned by get_interface_address6_list.
  1612. */
  1613. void
  1614. interface_address6_list_free_(smartlist_t *addrs)
  1615. {
  1616. if (addrs != NULL) {
  1617. SMARTLIST_FOREACH(addrs, tor_addr_t *, a, tor_free(a));
  1618. smartlist_free(addrs);
  1619. }
  1620. }
  1621. /** Return a smartlist of the IP addresses of type family from all interfaces
  1622. * on the server. Excludes loopback and multicast addresses. Only includes
  1623. * internal addresses if include_internal is true. (Note that a relay behind
  1624. * NAT may use an internal address to connect to the Internet.)
  1625. * An empty smartlist means that there are no addresses of the selected type
  1626. * matching these criteria.
  1627. * Returns NULL on failure.
  1628. * Use interface_address6_list_free to free the returned list.
  1629. */
  1630. MOCK_IMPL(smartlist_t *,
  1631. get_interface_address6_list,(int severity,
  1632. sa_family_t family,
  1633. int include_internal))
  1634. {
  1635. smartlist_t *addrs;
  1636. tor_addr_t addr;
  1637. /* Try to do this the smart way if possible. */
  1638. if ((addrs = get_interface_addresses_raw(severity, family))) {
  1639. SMARTLIST_FOREACH_BEGIN(addrs, tor_addr_t *, a)
  1640. {
  1641. if (tor_addr_is_loopback(a) ||
  1642. tor_addr_is_multicast(a)) {
  1643. SMARTLIST_DEL_CURRENT_KEEPORDER(addrs, a);
  1644. tor_free(a);
  1645. continue;
  1646. }
  1647. if (!include_internal && tor_addr_is_internal(a, 0)) {
  1648. SMARTLIST_DEL_CURRENT_KEEPORDER(addrs, a);
  1649. tor_free(a);
  1650. continue;
  1651. }
  1652. } SMARTLIST_FOREACH_END(a);
  1653. }
  1654. if (addrs && smartlist_len(addrs) > 0) {
  1655. return addrs;
  1656. }
  1657. /* if we removed all entries as unsuitable */
  1658. if (addrs) {
  1659. smartlist_free(addrs);
  1660. }
  1661. /* Okay, the smart way is out. */
  1662. addrs = smartlist_new();
  1663. if (family == AF_INET || family == AF_UNSPEC) {
  1664. if (get_interface_address6_via_udp_socket_hack(severity,AF_INET,
  1665. &addr) == 0) {
  1666. if (include_internal || !tor_addr_is_internal(&addr, 0)) {
  1667. smartlist_add(addrs, tor_memdup(&addr, sizeof(addr)));
  1668. }
  1669. }
  1670. }
  1671. if (family == AF_INET6 || family == AF_UNSPEC) {
  1672. if (get_interface_address6_via_udp_socket_hack(severity,AF_INET6,
  1673. &addr) == 0) {
  1674. if (include_internal || !tor_addr_is_internal(&addr, 0)) {
  1675. smartlist_add(addrs, tor_memdup(&addr, sizeof(addr)));
  1676. }
  1677. }
  1678. }
  1679. return addrs;
  1680. }
  1681. /* ======
  1682. * IPv4 helpers
  1683. * XXXX IPv6 deprecate some of these.
  1684. */
  1685. /** Given an address of the form "ip:port", try to divide it into its
  1686. * ip and port portions, setting *<b>address_out</b> to a newly
  1687. * allocated string holding the address portion and *<b>port_out</b>
  1688. * to the port.
  1689. *
  1690. * Don't do DNS lookups and don't allow domain names in the "ip" field.
  1691. *
  1692. * If <b>default_port</b> is less than 0, don't accept <b>addrport</b> of the
  1693. * form "ip" or "ip:0". Otherwise, accept those forms, and set
  1694. * *<b>port_out</b> to <b>default_port</b>.
  1695. *
  1696. * Return 0 on success, -1 on failure. */
  1697. int
  1698. tor_addr_port_parse(int severity, const char *addrport,
  1699. tor_addr_t *address_out, uint16_t *port_out,
  1700. int default_port)
  1701. {
  1702. int retval = -1;
  1703. int r;
  1704. char *addr_tmp = NULL;
  1705. tor_assert(addrport);
  1706. tor_assert(address_out);
  1707. tor_assert(port_out);
  1708. r = tor_addr_port_split(severity, addrport, &addr_tmp, port_out);
  1709. if (r < 0)
  1710. goto done;
  1711. if (!*port_out) {
  1712. if (default_port >= 0)
  1713. *port_out = default_port;
  1714. else
  1715. goto done;
  1716. }
  1717. /* make sure that address_out is an IP address */
  1718. if (tor_addr_parse(address_out, addr_tmp) < 0)
  1719. goto done;
  1720. retval = 0;
  1721. done:
  1722. tor_free(addr_tmp);
  1723. return retval;
  1724. }
  1725. /** Given an address of the form "host[:port]", try to divide it into its host
  1726. * and port portions, setting *<b>address_out</b> to a newly allocated string
  1727. * holding the address portion and *<b>port_out</b> to the port (or 0 if no
  1728. * port is given). Return 0 on success, -1 on failure. */
  1729. int
  1730. tor_addr_port_split(int severity, const char *addrport,
  1731. char **address_out, uint16_t *port_out)
  1732. {
  1733. tor_addr_t a_tmp;
  1734. tor_assert(addrport);
  1735. tor_assert(address_out);
  1736. tor_assert(port_out);
  1737. /* We need to check for IPv6 manually because addr_port_lookup() doesn't
  1738. * do a good job on IPv6 addresses that lack a port. */
  1739. if (tor_addr_parse(&a_tmp, addrport) == AF_INET6) {
  1740. *port_out = 0;
  1741. *address_out = tor_strdup(addrport);
  1742. return 0;
  1743. }
  1744. return addr_port_lookup(severity, addrport, address_out, NULL, port_out);
  1745. }
  1746. /** Parse a string of the form "host[:port]" from <b>addrport</b>. If
  1747. * <b>address</b> is provided, set *<b>address</b> to a copy of the
  1748. * host portion of the string. If <b>addr</b> is provided, try to
  1749. * resolve the host portion of the string and store it into
  1750. * *<b>addr</b> (in host byte order). If <b>port_out</b> is provided,
  1751. * store the port number into *<b>port_out</b>, or 0 if no port is given.
  1752. * If <b>port_out</b> is NULL, then there must be no port number in
  1753. * <b>addrport</b>.
  1754. * Return 0 on success, -1 on failure.
  1755. */
  1756. int
  1757. addr_port_lookup(int severity, const char *addrport, char **address,
  1758. uint32_t *addr, uint16_t *port_out)
  1759. {
  1760. const char *colon;
  1761. char *address_ = NULL;
  1762. int port_;
  1763. int ok = 1;
  1764. tor_assert(addrport);
  1765. colon = strrchr(addrport, ':');
  1766. if (colon) {
  1767. address_ = tor_strndup(addrport, colon-addrport);
  1768. port_ = (int) tor_parse_long(colon+1,10,1,65535,NULL,NULL);
  1769. if (!port_) {
  1770. log_fn(severity, LD_GENERAL, "Port %s out of range", escaped(colon+1));
  1771. ok = 0;
  1772. }
  1773. if (!port_out) {
  1774. char *esc_addrport = esc_for_log(addrport);
  1775. log_fn(severity, LD_GENERAL,
  1776. "Port %s given on %s when not required",
  1777. escaped(colon+1), esc_addrport);
  1778. tor_free(esc_addrport);
  1779. ok = 0;
  1780. }
  1781. } else {
  1782. address_ = tor_strdup(addrport);
  1783. port_ = 0;
  1784. }
  1785. if (addr) {
  1786. /* There's an addr pointer, so we need to resolve the hostname. */
  1787. if (tor_lookup_hostname(address_,addr)) {
  1788. log_fn(severity, LD_NET, "Couldn't look up %s", escaped(address_));
  1789. ok = 0;
  1790. *addr = 0;
  1791. }
  1792. }
  1793. if (address && ok) {
  1794. *address = address_;
  1795. } else {
  1796. if (address)
  1797. *address = NULL;
  1798. tor_free(address_);
  1799. }
  1800. if (port_out)
  1801. *port_out = ok ? ((uint16_t) port_) : 0;
  1802. return ok ? 0 : -1;
  1803. }
  1804. /** If <b>mask</b> is an address mask for a bit-prefix, return the number of
  1805. * bits. Otherwise, return -1. */
  1806. int
  1807. addr_mask_get_bits(uint32_t mask)
  1808. {
  1809. int i;
  1810. if (mask == 0)
  1811. return 0;
  1812. if (mask == 0xFFFFFFFFu)
  1813. return 32;
  1814. for (i=1; i<=32; ++i) {
  1815. if (mask == (uint32_t) ~((1u<<(32-i))-1)) {
  1816. return i;
  1817. }
  1818. }
  1819. return -1;
  1820. }
  1821. /** Parse a string <b>s</b> in the format of (*|port(-maxport)?)?, setting the
  1822. * various *out pointers as appropriate. Return 0 on success, -1 on failure.
  1823. */
  1824. int
  1825. parse_port_range(const char *port, uint16_t *port_min_out,
  1826. uint16_t *port_max_out)
  1827. {
  1828. int port_min, port_max, ok;
  1829. tor_assert(port_min_out);
  1830. tor_assert(port_max_out);
  1831. if (!port || *port == '\0' || strcmp(port, "*") == 0) {
  1832. port_min = 1;
  1833. port_max = 65535;
  1834. } else {
  1835. char *endptr = NULL;
  1836. port_min = (int)tor_parse_long(port, 10, 0, 65535, &ok, &endptr);
  1837. if (!ok) {
  1838. log_warn(LD_GENERAL,
  1839. "Malformed port %s on address range; rejecting.",
  1840. escaped(port));
  1841. return -1;
  1842. } else if (endptr && *endptr == '-') {
  1843. port = endptr+1;
  1844. endptr = NULL;
  1845. port_max = (int)tor_parse_long(port, 10, 1, 65535, &ok, &endptr);
  1846. if (!ok) {
  1847. log_warn(LD_GENERAL,
  1848. "Malformed port %s on address range; rejecting.",
  1849. escaped(port));
  1850. return -1;
  1851. }
  1852. } else {
  1853. port_max = port_min;
  1854. }
  1855. if (port_min > port_max) {
  1856. log_warn(LD_GENERAL, "Insane port range on address policy; rejecting.");
  1857. return -1;
  1858. }
  1859. }
  1860. if (port_min < 1)
  1861. port_min = 1;
  1862. if (port_max > 65535)
  1863. port_max = 65535;
  1864. *port_min_out = (uint16_t) port_min;
  1865. *port_max_out = (uint16_t) port_max;
  1866. return 0;
  1867. }
  1868. /** Given an IPv4 in_addr struct *<b>in</b> (in network order, as usual),
  1869. * write it as a string into the <b>buf_len</b>-byte buffer in
  1870. * <b>buf</b>. Returns a non-negative integer on success.
  1871. * Returns -1 on failure.
  1872. */
  1873. int
  1874. tor_inet_ntoa(const struct in_addr *in, char *buf, size_t buf_len)
  1875. {
  1876. uint32_t a = ntohl(in->s_addr);
  1877. return tor_snprintf(buf, buf_len, "%d.%d.%d.%d",
  1878. (int)(uint8_t)((a>>24)&0xff),
  1879. (int)(uint8_t)((a>>16)&0xff),
  1880. (int)(uint8_t)((a>>8 )&0xff),
  1881. (int)(uint8_t)((a )&0xff));
  1882. }
  1883. /** Given a host-order <b>addr</b>, call tor_inet_ntop() on it
  1884. * and return a strdup of the resulting address.
  1885. */
  1886. char *
  1887. tor_dup_ip(uint32_t addr)
  1888. {
  1889. char buf[TOR_ADDR_BUF_LEN];
  1890. struct in_addr in;
  1891. in.s_addr = htonl(addr);
  1892. tor_inet_ntop(AF_INET, &in, buf, sizeof(buf));
  1893. return tor_strdup(buf);
  1894. }
  1895. /**
  1896. * Set *<b>addr</b> to a host-order IPv4 address (if any) of an
  1897. * interface that connects to the Internet. Prefer public IP addresses to
  1898. * internal IP addresses. This address should only be used in checking
  1899. * whether our address has changed, as it may be an internal IPv4 address.
  1900. * Return 0 on success, -1 on failure.
  1901. * Prefer get_interface_address_list6 for a list of all IPv4 and IPv6
  1902. * addresses on all interfaces which connect to the Internet.
  1903. */
  1904. MOCK_IMPL(int,
  1905. get_interface_address,(int severity, uint32_t *addr))
  1906. {
  1907. tor_addr_t local_addr;
  1908. int r;
  1909. memset(addr, 0, sizeof(uint32_t));
  1910. r = get_interface_address6(severity, AF_INET, &local_addr);
  1911. if (r>=0)
  1912. *addr = tor_addr_to_ipv4h(&local_addr);
  1913. return r;
  1914. }
  1915. /** Return true if we can tell that <b>name</b> is a canonical name for the
  1916. * loopback address. Return true also for *.local hostnames, which are
  1917. * multicast DNS names for hosts on the local network. */
  1918. int
  1919. tor_addr_hostname_is_local(const char *name)
  1920. {
  1921. return !strcasecmp(name, "localhost") ||
  1922. !strcasecmp(name, "local") ||
  1923. !strcasecmpend(name, ".local");
  1924. }
  1925. /** Return a newly allocated tor_addr_port_t with <b>addr</b> and
  1926. <b>port</b> filled in. */
  1927. tor_addr_port_t *
  1928. tor_addr_port_new(const tor_addr_t *addr, uint16_t port)
  1929. {
  1930. tor_addr_port_t *ap = tor_malloc_zero(sizeof(tor_addr_port_t));
  1931. if (addr)
  1932. tor_addr_copy(&ap->addr, addr);
  1933. ap->port = port;
  1934. return ap;
  1935. }
  1936. /** Return true iff <a>a</b> and <b>b</b> are the same address and port */
  1937. int
  1938. tor_addr_port_eq(const tor_addr_port_t *a,
  1939. const tor_addr_port_t *b)
  1940. {
  1941. return tor_addr_eq(&a->addr, &b->addr) && a->port == b->port;
  1942. }