curl_addrinfo.c 16 KB

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