curl_addrinfo.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595
  1. /***************************************************************************
  2. * _ _ ____ _
  3. * Project ___| | | | _ \| |
  4. * / __| | | | |_) | |
  5. * | (__| |_| | _ <| |___
  6. * \___|\___/|_| \_\_____|
  7. *
  8. * Copyright (C) 1998 - 2021, Daniel Stenberg, <daniel@haxx.se>, et al.
  9. *
  10. * This software is licensed as described in the file COPYING, which
  11. * you should have received as part of this distribution. The terms
  12. * are also available at https://curl.se/docs/copyright.html.
  13. *
  14. * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15. * copies of the Software, and permit persons to whom the Software is
  16. * furnished to do so, under the terms of the COPYING file.
  17. *
  18. * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19. * KIND, either express or implied.
  20. *
  21. ***************************************************************************/
  22. #include "curl_setup.h"
  23. #include <curl/curl.h>
  24. #ifdef HAVE_NETINET_IN_H
  25. # include <netinet/in.h>
  26. #endif
  27. #ifdef HAVE_NETINET_IN6_H
  28. # include <netinet/in6.h>
  29. #endif
  30. #ifdef HAVE_NETDB_H
  31. # include <netdb.h>
  32. #endif
  33. #ifdef HAVE_ARPA_INET_H
  34. # include <arpa/inet.h>
  35. #endif
  36. #ifdef HAVE_SYS_UN_H
  37. # include <sys/un.h>
  38. #endif
  39. #ifdef __VMS
  40. # include <in.h>
  41. # include <inet.h>
  42. #endif
  43. #if defined(NETWARE) && defined(__NOVELL_LIBC__)
  44. # undef in_addr_t
  45. # define in_addr_t unsigned long
  46. #endif
  47. #include <stddef.h>
  48. #include "curl_addrinfo.h"
  49. #include "inet_pton.h"
  50. #include "warnless.h"
  51. /* The last 3 #include files should be in this order */
  52. #include "curl_printf.h"
  53. #include "curl_memory.h"
  54. #include "memdebug.h"
  55. /*
  56. * Curl_freeaddrinfo()
  57. *
  58. * This is used to free a linked list of Curl_addrinfo structs along
  59. * with all its associated allocated storage. This function should be
  60. * called once for each successful call to Curl_getaddrinfo_ex() or to
  61. * any function call which actually allocates a Curl_addrinfo struct.
  62. */
  63. #if defined(__INTEL_COMPILER) && (__INTEL_COMPILER == 910) && \
  64. defined(__OPTIMIZE__) && defined(__unix__) && defined(__i386__)
  65. /* workaround icc 9.1 optimizer issue */
  66. # define vqualifier volatile
  67. #else
  68. # define vqualifier
  69. #endif
  70. void
  71. Curl_freeaddrinfo(struct Curl_addrinfo *cahead)
  72. {
  73. struct Curl_addrinfo *vqualifier canext;
  74. struct Curl_addrinfo *ca;
  75. for(ca = cahead; ca; ca = canext) {
  76. canext = ca->ai_next;
  77. free(ca);
  78. }
  79. }
  80. #ifdef HAVE_GETADDRINFO
  81. /*
  82. * Curl_getaddrinfo_ex()
  83. *
  84. * This is a wrapper function around system's getaddrinfo(), with
  85. * the only difference that instead of returning a linked list of
  86. * addrinfo structs this one returns a linked list of Curl_addrinfo
  87. * ones. The memory allocated by this function *MUST* be free'd with
  88. * Curl_freeaddrinfo(). For each successful call to this function
  89. * there must be an associated call later to Curl_freeaddrinfo().
  90. *
  91. * There should be no single call to system's getaddrinfo() in the
  92. * whole library, any such call should be 'routed' through this one.
  93. */
  94. int
  95. Curl_getaddrinfo_ex(const char *nodename,
  96. const char *servname,
  97. const struct addrinfo *hints,
  98. struct Curl_addrinfo **result)
  99. {
  100. const struct addrinfo *ai;
  101. struct addrinfo *aihead;
  102. struct Curl_addrinfo *cafirst = NULL;
  103. struct Curl_addrinfo *calast = NULL;
  104. struct Curl_addrinfo *ca;
  105. size_t ss_size;
  106. int error;
  107. *result = NULL; /* assume failure */
  108. error = getaddrinfo(nodename, servname, hints, &aihead);
  109. if(error)
  110. return error;
  111. /* traverse the addrinfo list */
  112. for(ai = aihead; ai != NULL; ai = ai->ai_next) {
  113. size_t namelen = ai->ai_canonname ? strlen(ai->ai_canonname) + 1 : 0;
  114. /* ignore elements with unsupported address family, */
  115. /* settle family-specific sockaddr structure size. */
  116. if(ai->ai_family == AF_INET)
  117. ss_size = sizeof(struct sockaddr_in);
  118. #ifdef ENABLE_IPV6
  119. else if(ai->ai_family == AF_INET6)
  120. ss_size = sizeof(struct sockaddr_in6);
  121. #endif
  122. else
  123. continue;
  124. /* ignore elements without required address info */
  125. if(!ai->ai_addr || !(ai->ai_addrlen > 0))
  126. continue;
  127. /* ignore elements with bogus address size */
  128. if((size_t)ai->ai_addrlen < ss_size)
  129. continue;
  130. ca = malloc(sizeof(struct Curl_addrinfo) + ss_size + namelen);
  131. if(!ca) {
  132. error = EAI_MEMORY;
  133. break;
  134. }
  135. /* copy each structure member individually, member ordering, */
  136. /* size, or padding might be different for each platform. */
  137. ca->ai_flags = ai->ai_flags;
  138. ca->ai_family = ai->ai_family;
  139. ca->ai_socktype = ai->ai_socktype;
  140. ca->ai_protocol = ai->ai_protocol;
  141. ca->ai_addrlen = (curl_socklen_t)ss_size;
  142. ca->ai_addr = NULL;
  143. ca->ai_canonname = NULL;
  144. ca->ai_next = NULL;
  145. ca->ai_addr = (void *)((char *)ca + sizeof(struct Curl_addrinfo));
  146. memcpy(ca->ai_addr, ai->ai_addr, ss_size);
  147. if(namelen) {
  148. ca->ai_canonname = (void *)((char *)ca->ai_addr + ss_size);
  149. memcpy(ca->ai_canonname, ai->ai_canonname, namelen);
  150. }
  151. /* if the return list is empty, this becomes the first element */
  152. if(!cafirst)
  153. cafirst = ca;
  154. /* add this element last in the return list */
  155. if(calast)
  156. calast->ai_next = ca;
  157. calast = ca;
  158. }
  159. /* destroy the addrinfo list */
  160. if(aihead)
  161. freeaddrinfo(aihead);
  162. /* if we failed, also destroy the Curl_addrinfo list */
  163. if(error) {
  164. Curl_freeaddrinfo(cafirst);
  165. cafirst = NULL;
  166. }
  167. else if(!cafirst) {
  168. #ifdef EAI_NONAME
  169. /* rfc3493 conformant */
  170. error = EAI_NONAME;
  171. #else
  172. /* rfc3493 obsoleted */
  173. error = EAI_NODATA;
  174. #endif
  175. #ifdef USE_WINSOCK
  176. SET_SOCKERRNO(error);
  177. #endif
  178. }
  179. *result = cafirst;
  180. /* This is not a CURLcode */
  181. return error;
  182. }
  183. #endif /* HAVE_GETADDRINFO */
  184. /*
  185. * Curl_he2ai()
  186. *
  187. * This function returns a pointer to the first element of a newly allocated
  188. * Curl_addrinfo struct linked list filled with the data of a given hostent.
  189. * Curl_addrinfo is meant to work like the addrinfo struct does for a IPv6
  190. * stack, but usable also for IPv4, all hosts and environments.
  191. *
  192. * The memory allocated by this function *MUST* be free'd later on calling
  193. * Curl_freeaddrinfo(). For each successful call to this function there
  194. * must be an associated call later to Curl_freeaddrinfo().
  195. *
  196. * Curl_addrinfo defined in "lib/curl_addrinfo.h"
  197. *
  198. * struct Curl_addrinfo {
  199. * int ai_flags;
  200. * int ai_family;
  201. * int ai_socktype;
  202. * int ai_protocol;
  203. * curl_socklen_t ai_addrlen; * Follow rfc3493 struct addrinfo *
  204. * char *ai_canonname;
  205. * struct sockaddr *ai_addr;
  206. * struct Curl_addrinfo *ai_next;
  207. * };
  208. *
  209. * hostent defined in <netdb.h>
  210. *
  211. * struct hostent {
  212. * char *h_name;
  213. * char **h_aliases;
  214. * int h_addrtype;
  215. * int h_length;
  216. * char **h_addr_list;
  217. * };
  218. *
  219. * for backward compatibility:
  220. *
  221. * #define h_addr h_addr_list[0]
  222. */
  223. struct Curl_addrinfo *
  224. Curl_he2ai(const struct hostent *he, int port)
  225. {
  226. struct Curl_addrinfo *ai;
  227. struct Curl_addrinfo *prevai = NULL;
  228. struct Curl_addrinfo *firstai = NULL;
  229. struct sockaddr_in *addr;
  230. #ifdef ENABLE_IPV6
  231. struct sockaddr_in6 *addr6;
  232. #endif
  233. CURLcode result = CURLE_OK;
  234. int i;
  235. char *curr;
  236. if(!he)
  237. /* no input == no output! */
  238. return NULL;
  239. DEBUGASSERT((he->h_name != NULL) && (he->h_addr_list != NULL));
  240. for(i = 0; (curr = he->h_addr_list[i]) != NULL; i++) {
  241. size_t ss_size;
  242. size_t namelen = strlen(he->h_name) + 1; /* include zero termination */
  243. #ifdef ENABLE_IPV6
  244. if(he->h_addrtype == AF_INET6)
  245. ss_size = sizeof(struct sockaddr_in6);
  246. else
  247. #endif
  248. ss_size = sizeof(struct sockaddr_in);
  249. /* allocate memory to hold the struct, the address and the name */
  250. ai = calloc(1, sizeof(struct Curl_addrinfo) + ss_size + namelen);
  251. if(!ai) {
  252. result = CURLE_OUT_OF_MEMORY;
  253. break;
  254. }
  255. /* put the address after the struct */
  256. ai->ai_addr = (void *)((char *)ai + sizeof(struct Curl_addrinfo));
  257. /* then put the name after the address */
  258. ai->ai_canonname = (char *)ai->ai_addr + ss_size;
  259. memcpy(ai->ai_canonname, he->h_name, namelen);
  260. if(!firstai)
  261. /* store the pointer we want to return from this function */
  262. firstai = ai;
  263. if(prevai)
  264. /* make the previous entry point to this */
  265. prevai->ai_next = ai;
  266. ai->ai_family = he->h_addrtype;
  267. /* we return all names as STREAM, so when using this address for TFTP
  268. the type must be ignored and conn->socktype be used instead! */
  269. ai->ai_socktype = SOCK_STREAM;
  270. ai->ai_addrlen = (curl_socklen_t)ss_size;
  271. /* leave the rest of the struct filled with zero */
  272. switch(ai->ai_family) {
  273. case AF_INET:
  274. addr = (void *)ai->ai_addr; /* storage area for this info */
  275. memcpy(&addr->sin_addr, curr, sizeof(struct in_addr));
  276. addr->sin_family = (CURL_SA_FAMILY_T)(he->h_addrtype);
  277. addr->sin_port = htons((unsigned short)port);
  278. break;
  279. #ifdef ENABLE_IPV6
  280. case AF_INET6:
  281. addr6 = (void *)ai->ai_addr; /* storage area for this info */
  282. memcpy(&addr6->sin6_addr, curr, sizeof(struct in6_addr));
  283. addr6->sin6_family = (CURL_SA_FAMILY_T)(he->h_addrtype);
  284. addr6->sin6_port = htons((unsigned short)port);
  285. break;
  286. #endif
  287. }
  288. prevai = ai;
  289. }
  290. if(result) {
  291. Curl_freeaddrinfo(firstai);
  292. firstai = NULL;
  293. }
  294. return firstai;
  295. }
  296. struct namebuff {
  297. struct hostent hostentry;
  298. union {
  299. struct in_addr ina4;
  300. #ifdef ENABLE_IPV6
  301. struct in6_addr ina6;
  302. #endif
  303. } addrentry;
  304. char *h_addr_list[2];
  305. };
  306. /*
  307. * Curl_ip2addr()
  308. *
  309. * This function takes an internet address, in binary form, as input parameter
  310. * along with its address family and the string version of the address, and it
  311. * returns a Curl_addrinfo chain filled in correctly with information for the
  312. * given address/host
  313. */
  314. struct Curl_addrinfo *
  315. Curl_ip2addr(int af, const void *inaddr, const char *hostname, int port)
  316. {
  317. struct Curl_addrinfo *ai;
  318. #if defined(__VMS) && \
  319. defined(__INITIAL_POINTER_SIZE) && (__INITIAL_POINTER_SIZE == 64)
  320. #pragma pointer_size save
  321. #pragma pointer_size short
  322. #pragma message disable PTRMISMATCH
  323. #endif
  324. struct hostent *h;
  325. struct namebuff *buf;
  326. char *addrentry;
  327. char *hoststr;
  328. size_t addrsize;
  329. DEBUGASSERT(inaddr && hostname);
  330. buf = malloc(sizeof(struct namebuff));
  331. if(!buf)
  332. return NULL;
  333. hoststr = strdup(hostname);
  334. if(!hoststr) {
  335. free(buf);
  336. return NULL;
  337. }
  338. switch(af) {
  339. case AF_INET:
  340. addrsize = sizeof(struct in_addr);
  341. addrentry = (void *)&buf->addrentry.ina4;
  342. memcpy(addrentry, inaddr, sizeof(struct in_addr));
  343. break;
  344. #ifdef ENABLE_IPV6
  345. case AF_INET6:
  346. addrsize = sizeof(struct in6_addr);
  347. addrentry = (void *)&buf->addrentry.ina6;
  348. memcpy(addrentry, inaddr, sizeof(struct in6_addr));
  349. break;
  350. #endif
  351. default:
  352. free(hoststr);
  353. free(buf);
  354. return NULL;
  355. }
  356. h = &buf->hostentry;
  357. h->h_name = hoststr;
  358. h->h_aliases = NULL;
  359. h->h_addrtype = (short)af;
  360. h->h_length = (short)addrsize;
  361. h->h_addr_list = &buf->h_addr_list[0];
  362. h->h_addr_list[0] = addrentry;
  363. h->h_addr_list[1] = NULL; /* terminate list of entries */
  364. #if defined(__VMS) && \
  365. defined(__INITIAL_POINTER_SIZE) && (__INITIAL_POINTER_SIZE == 64)
  366. #pragma pointer_size restore
  367. #pragma message enable PTRMISMATCH
  368. #endif
  369. ai = Curl_he2ai(h, port);
  370. free(hoststr);
  371. free(buf);
  372. return ai;
  373. }
  374. /*
  375. * Given an IPv4 or IPv6 dotted string address, this converts it to a proper
  376. * allocated Curl_addrinfo struct and returns it.
  377. */
  378. struct Curl_addrinfo *Curl_str2addr(char *address, int port)
  379. {
  380. struct in_addr in;
  381. if(Curl_inet_pton(AF_INET, address, &in) > 0)
  382. /* This is a dotted IP address 123.123.123.123-style */
  383. return Curl_ip2addr(AF_INET, &in, address, port);
  384. #ifdef ENABLE_IPV6
  385. {
  386. struct in6_addr in6;
  387. if(Curl_inet_pton(AF_INET6, address, &in6) > 0)
  388. /* This is a dotted IPv6 address ::1-style */
  389. return Curl_ip2addr(AF_INET6, &in6, address, port);
  390. }
  391. #endif
  392. return NULL; /* bad input format */
  393. }
  394. #ifdef USE_UNIX_SOCKETS
  395. /**
  396. * Given a path to a Unix domain socket, return a newly allocated Curl_addrinfo
  397. * struct initialized with this path.
  398. * Set '*longpath' to TRUE if the error is a too long path.
  399. */
  400. struct Curl_addrinfo *Curl_unix2addr(const char *path, bool *longpath,
  401. bool abstract)
  402. {
  403. struct Curl_addrinfo *ai;
  404. struct sockaddr_un *sa_un;
  405. size_t path_len;
  406. *longpath = FALSE;
  407. ai = calloc(1, sizeof(struct Curl_addrinfo) + sizeof(struct sockaddr_un));
  408. if(!ai)
  409. return NULL;
  410. ai->ai_addr = (void *)((char *)ai + sizeof(struct Curl_addrinfo));
  411. sa_un = (void *) ai->ai_addr;
  412. sa_un->sun_family = AF_UNIX;
  413. /* sun_path must be able to store the NUL-terminated path */
  414. path_len = strlen(path) + 1;
  415. if(path_len > sizeof(sa_un->sun_path)) {
  416. free(ai);
  417. *longpath = TRUE;
  418. return NULL;
  419. }
  420. ai->ai_family = AF_UNIX;
  421. ai->ai_socktype = SOCK_STREAM; /* assume reliable transport for HTTP */
  422. ai->ai_addrlen = (curl_socklen_t)
  423. ((offsetof(struct sockaddr_un, sun_path) + path_len) & 0x7FFFFFFF);
  424. /* Abstract Unix domain socket have NULL prefix instead of suffix */
  425. if(abstract)
  426. memcpy(sa_un->sun_path + 1, path, path_len - 1);
  427. else
  428. memcpy(sa_un->sun_path, path, path_len); /* copy NUL byte */
  429. return ai;
  430. }
  431. #endif
  432. #if defined(CURLDEBUG) && defined(HAVE_GETADDRINFO) && \
  433. defined(HAVE_FREEADDRINFO)
  434. /*
  435. * curl_dbg_freeaddrinfo()
  436. *
  437. * This is strictly for memory tracing and are using the same style as the
  438. * family otherwise present in memdebug.c. I put these ones here since they
  439. * require a bunch of structs I didn't want to include in memdebug.c
  440. */
  441. void
  442. curl_dbg_freeaddrinfo(struct addrinfo *freethis,
  443. int line, const char *source)
  444. {
  445. curl_dbg_log("ADDR %s:%d freeaddrinfo(%p)\n",
  446. source, line, (void *)freethis);
  447. #ifdef USE_LWIPSOCK
  448. lwip_freeaddrinfo(freethis);
  449. #else
  450. (freeaddrinfo)(freethis);
  451. #endif
  452. }
  453. #endif /* defined(CURLDEBUG) && defined(HAVE_FREEADDRINFO) */
  454. #if defined(CURLDEBUG) && defined(HAVE_GETADDRINFO)
  455. /*
  456. * curl_dbg_getaddrinfo()
  457. *
  458. * This is strictly for memory tracing and are using the same style as the
  459. * family otherwise present in memdebug.c. I put these ones here since they
  460. * require a bunch of structs I didn't want to include in memdebug.c
  461. */
  462. int
  463. curl_dbg_getaddrinfo(const char *hostname,
  464. const char *service,
  465. const struct addrinfo *hints,
  466. struct addrinfo **result,
  467. int line, const char *source)
  468. {
  469. #ifdef USE_LWIPSOCK
  470. int res = lwip_getaddrinfo(hostname, service, hints, result);
  471. #else
  472. int res = (getaddrinfo)(hostname, service, hints, result);
  473. #endif
  474. if(0 == res)
  475. /* success */
  476. curl_dbg_log("ADDR %s:%d getaddrinfo() = %p\n",
  477. source, line, (void *)*result);
  478. else
  479. curl_dbg_log("ADDR %s:%d getaddrinfo() failed\n",
  480. source, line);
  481. return res;
  482. }
  483. #endif /* defined(CURLDEBUG) && defined(HAVE_GETADDRINFO) */
  484. #if defined(HAVE_GETADDRINFO) && defined(USE_RESOLVE_ON_IPS)
  485. /*
  486. * Work-arounds the sin6_port is always zero bug on iOS 9.3.2 and Mac OS X
  487. * 10.11.5.
  488. */
  489. void Curl_addrinfo_set_port(struct Curl_addrinfo *addrinfo, int port)
  490. {
  491. struct Curl_addrinfo *ca;
  492. struct sockaddr_in *addr;
  493. #ifdef ENABLE_IPV6
  494. struct sockaddr_in6 *addr6;
  495. #endif
  496. for(ca = addrinfo; ca != NULL; ca = ca->ai_next) {
  497. switch(ca->ai_family) {
  498. case AF_INET:
  499. addr = (void *)ca->ai_addr; /* storage area for this info */
  500. addr->sin_port = htons((unsigned short)port);
  501. break;
  502. #ifdef ENABLE_IPV6
  503. case AF_INET6:
  504. addr6 = (void *)ca->ai_addr; /* storage area for this info */
  505. addr6->sin6_port = htons((unsigned short)port);
  506. break;
  507. #endif
  508. }
  509. }
  510. }
  511. #endif