2
0

asyn-ares.c 29 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958
  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. /***********************************************************************
  26. * Only for ares-enabled builds
  27. * And only for functions that fulfill the asynch resolver backend API
  28. * as defined in asyn.h, nothing else belongs in this file!
  29. **********************************************************************/
  30. #ifdef CURLRES_ARES
  31. #include <limits.h>
  32. #ifdef HAVE_NETINET_IN_H
  33. #include <netinet/in.h>
  34. #endif
  35. #ifdef HAVE_NETDB_H
  36. #include <netdb.h>
  37. #endif
  38. #ifdef HAVE_ARPA_INET_H
  39. #include <arpa/inet.h>
  40. #endif
  41. #ifdef __VMS
  42. #include <in.h>
  43. #include <inet.h>
  44. #endif
  45. #include "urldata.h"
  46. #include "sendf.h"
  47. #include "hostip.h"
  48. #include "hash.h"
  49. #include "share.h"
  50. #include "url.h"
  51. #include "multiif.h"
  52. #include "inet_pton.h"
  53. #include "connect.h"
  54. #include "select.h"
  55. #include "progress.h"
  56. #include "timediff.h"
  57. #if defined(CURL_STATICLIB) && !defined(CARES_STATICLIB) && \
  58. defined(_WIN32)
  59. # define CARES_STATICLIB
  60. #endif
  61. #include <ares.h>
  62. #include <ares_version.h> /* really old c-ares didn't include this by
  63. itself */
  64. #if ARES_VERSION >= 0x010500
  65. /* c-ares 1.5.0 or later, the callback proto is modified */
  66. #define HAVE_CARES_CALLBACK_TIMEOUTS 1
  67. #endif
  68. #if ARES_VERSION >= 0x010601
  69. /* IPv6 supported since 1.6.1 */
  70. #define HAVE_CARES_IPV6 1
  71. #endif
  72. #if ARES_VERSION >= 0x010704
  73. #define HAVE_CARES_SERVERS_CSV 1
  74. #define HAVE_CARES_LOCAL_DEV 1
  75. #define HAVE_CARES_SET_LOCAL 1
  76. #endif
  77. #if ARES_VERSION >= 0x010b00
  78. #define HAVE_CARES_PORTS_CSV 1
  79. #endif
  80. #if ARES_VERSION >= 0x011000
  81. /* 1.16.0 or later has ares_getaddrinfo */
  82. #define HAVE_CARES_GETADDRINFO 1
  83. #endif
  84. /* The last 3 #include files should be in this order */
  85. #include "curl_printf.h"
  86. #include "curl_memory.h"
  87. #include "memdebug.h"
  88. struct thread_data {
  89. int num_pending; /* number of outstanding c-ares requests */
  90. struct Curl_addrinfo *temp_ai; /* intermediary result while fetching c-ares
  91. parts */
  92. int last_status;
  93. #ifndef HAVE_CARES_GETADDRINFO
  94. struct curltime happy_eyeballs_dns_time; /* when this timer started, or 0 */
  95. #endif
  96. char hostname[1];
  97. };
  98. /* How long we are willing to wait for additional parallel responses after
  99. obtaining a "definitive" one. For old c-ares without getaddrinfo.
  100. This is intended to equal the c-ares default timeout. cURL always uses that
  101. default value. Unfortunately, c-ares doesn't expose its default timeout in
  102. its API, but it is officially documented as 5 seconds.
  103. See query_completed_cb() for an explanation of how this is used.
  104. */
  105. #define HAPPY_EYEBALLS_DNS_TIMEOUT 5000
  106. #define CARES_TIMEOUT_PER_ATTEMPT 2000
  107. static int ares_ver = 0;
  108. /*
  109. * Curl_resolver_global_init() - the generic low-level asynchronous name
  110. * resolve API. Called from curl_global_init() to initialize global resolver
  111. * environment. Initializes ares library.
  112. */
  113. int Curl_resolver_global_init(void)
  114. {
  115. #ifdef CARES_HAVE_ARES_LIBRARY_INIT
  116. if(ares_library_init(ARES_LIB_INIT_ALL)) {
  117. return CURLE_FAILED_INIT;
  118. }
  119. #endif
  120. ares_version(&ares_ver);
  121. return CURLE_OK;
  122. }
  123. /*
  124. * Curl_resolver_global_cleanup()
  125. *
  126. * Called from curl_global_cleanup() to destroy global resolver environment.
  127. * Deinitializes ares library.
  128. */
  129. void Curl_resolver_global_cleanup(void)
  130. {
  131. #ifdef CARES_HAVE_ARES_LIBRARY_CLEANUP
  132. ares_library_cleanup();
  133. #endif
  134. }
  135. static void sock_state_cb(void *data, ares_socket_t socket_fd,
  136. int readable, int writable)
  137. {
  138. struct Curl_easy *easy = data;
  139. if(!readable && !writable) {
  140. DEBUGASSERT(easy);
  141. Curl_multi_closed(easy, socket_fd);
  142. }
  143. }
  144. /*
  145. * Curl_resolver_init()
  146. *
  147. * Called from curl_easy_init() -> Curl_open() to initialize resolver
  148. * URL-state specific environment ('resolver' member of the UrlState
  149. * structure). Fills the passed pointer by the initialized ares_channel.
  150. */
  151. CURLcode Curl_resolver_init(struct Curl_easy *easy, void **resolver)
  152. {
  153. int status;
  154. struct ares_options options;
  155. int optmask = ARES_OPT_SOCK_STATE_CB;
  156. options.sock_state_cb = sock_state_cb;
  157. options.sock_state_cb_data = easy;
  158. /*
  159. if c ares < 1.20.0: curl set timeout to CARES_TIMEOUT_PER_ATTEMPT (2s)
  160. if c-ares >= 1.20.0 it already has the timeout to 2s, curl does not need
  161. to set the timeout value;
  162. if c-ares >= 1.24.0, user can set the timeout via /etc/resolv.conf to
  163. overwrite c-ares' timeout.
  164. */
  165. DEBUGASSERT(ares_ver);
  166. if(ares_ver < 0x011400) {
  167. options.timeout = CARES_TIMEOUT_PER_ATTEMPT;
  168. optmask |= ARES_OPT_TIMEOUTMS;
  169. }
  170. status = ares_init_options((ares_channel*)resolver, &options, optmask);
  171. if(status != ARES_SUCCESS) {
  172. if(status == ARES_ENOMEM)
  173. return CURLE_OUT_OF_MEMORY;
  174. else
  175. return CURLE_FAILED_INIT;
  176. }
  177. return CURLE_OK;
  178. /* make sure that all other returns from this function should destroy the
  179. ares channel before returning error! */
  180. }
  181. /*
  182. * Curl_resolver_cleanup()
  183. *
  184. * Called from curl_easy_cleanup() -> Curl_close() to cleanup resolver
  185. * URL-state specific environment ('resolver' member of the UrlState
  186. * structure). Destroys the ares channel.
  187. */
  188. void Curl_resolver_cleanup(void *resolver)
  189. {
  190. ares_destroy((ares_channel)resolver);
  191. }
  192. /*
  193. * Curl_resolver_duphandle()
  194. *
  195. * Called from curl_easy_duphandle() to duplicate resolver URL-state specific
  196. * environment ('resolver' member of the UrlState structure). Duplicates the
  197. * 'from' ares channel and passes the resulting channel to the 'to' pointer.
  198. */
  199. CURLcode Curl_resolver_duphandle(struct Curl_easy *easy, void **to, void *from)
  200. {
  201. (void)from;
  202. /*
  203. * it would be better to call ares_dup instead, but right now
  204. * it is not possible to set 'sock_state_cb_data' outside of
  205. * ares_init_options
  206. */
  207. return Curl_resolver_init(easy, to);
  208. }
  209. static void destroy_async_data(struct Curl_async *async);
  210. /*
  211. * Cancel all possibly still on-going resolves for this connection.
  212. */
  213. void Curl_resolver_cancel(struct Curl_easy *data)
  214. {
  215. DEBUGASSERT(data);
  216. if(data->state.async.resolver)
  217. ares_cancel((ares_channel)data->state.async.resolver);
  218. destroy_async_data(&data->state.async);
  219. }
  220. /*
  221. * We're equivalent to Curl_resolver_cancel() for the c-ares resolver. We
  222. * never block.
  223. */
  224. void Curl_resolver_kill(struct Curl_easy *data)
  225. {
  226. /* We don't need to check the resolver state because we can be called safely
  227. at any time and we always do the same thing. */
  228. Curl_resolver_cancel(data);
  229. }
  230. /*
  231. * destroy_async_data() cleans up async resolver data.
  232. */
  233. static void destroy_async_data(struct Curl_async *async)
  234. {
  235. if(async->tdata) {
  236. struct thread_data *res = async->tdata;
  237. if(res) {
  238. if(res->temp_ai) {
  239. Curl_freeaddrinfo(res->temp_ai);
  240. res->temp_ai = NULL;
  241. }
  242. free(res);
  243. }
  244. async->tdata = NULL;
  245. }
  246. }
  247. /*
  248. * Curl_resolver_getsock() is called when someone from the outside world
  249. * (using curl_multi_fdset()) wants to get our fd_set setup and we're talking
  250. * with ares. The caller must make sure that this function is only called when
  251. * we have a working ares channel.
  252. *
  253. * Returns: sockets-in-use-bitmap
  254. */
  255. int Curl_resolver_getsock(struct Curl_easy *data,
  256. curl_socket_t *socks)
  257. {
  258. struct timeval maxtime;
  259. struct timeval timebuf;
  260. struct timeval *timeout;
  261. long milli;
  262. int max = ares_getsock((ares_channel)data->state.async.resolver,
  263. (ares_socket_t *)socks, MAX_SOCKSPEREASYHANDLE);
  264. maxtime.tv_sec = CURL_TIMEOUT_RESOLVE;
  265. maxtime.tv_usec = 0;
  266. timeout = ares_timeout((ares_channel)data->state.async.resolver, &maxtime,
  267. &timebuf);
  268. milli = (long)curlx_tvtoms(timeout);
  269. if(milli == 0)
  270. milli += 10;
  271. Curl_expire(data, milli, EXPIRE_ASYNC_NAME);
  272. return max;
  273. }
  274. /*
  275. * waitperform()
  276. *
  277. * 1) Ask ares what sockets it currently plays with, then
  278. * 2) wait for the timeout period to check for action on ares' sockets.
  279. * 3) tell ares to act on all the sockets marked as "with action"
  280. *
  281. * return number of sockets it worked on, or -1 on error
  282. */
  283. static int waitperform(struct Curl_easy *data, timediff_t timeout_ms)
  284. {
  285. int nfds;
  286. int bitmask;
  287. ares_socket_t socks[ARES_GETSOCK_MAXNUM];
  288. struct pollfd pfd[ARES_GETSOCK_MAXNUM];
  289. int i;
  290. int num = 0;
  291. bitmask = ares_getsock((ares_channel)data->state.async.resolver, socks,
  292. ARES_GETSOCK_MAXNUM);
  293. for(i = 0; i < ARES_GETSOCK_MAXNUM; i++) {
  294. pfd[i].events = 0;
  295. pfd[i].revents = 0;
  296. if(ARES_GETSOCK_READABLE(bitmask, i)) {
  297. pfd[i].fd = socks[i];
  298. pfd[i].events |= POLLRDNORM|POLLIN;
  299. }
  300. if(ARES_GETSOCK_WRITABLE(bitmask, i)) {
  301. pfd[i].fd = socks[i];
  302. pfd[i].events |= POLLWRNORM|POLLOUT;
  303. }
  304. if(pfd[i].events)
  305. num++;
  306. else
  307. break;
  308. }
  309. if(num) {
  310. nfds = Curl_poll(pfd, num, timeout_ms);
  311. if(nfds < 0)
  312. return -1;
  313. }
  314. else
  315. nfds = 0;
  316. if(!nfds)
  317. /* Call ares_process() unconditionally here, even if we simply timed out
  318. above, as otherwise the ares name resolve won't timeout! */
  319. ares_process_fd((ares_channel)data->state.async.resolver, ARES_SOCKET_BAD,
  320. ARES_SOCKET_BAD);
  321. else {
  322. /* move through the descriptors and ask for processing on them */
  323. for(i = 0; i < num; i++)
  324. ares_process_fd((ares_channel)data->state.async.resolver,
  325. (pfd[i].revents & (POLLRDNORM|POLLIN))?
  326. pfd[i].fd:ARES_SOCKET_BAD,
  327. (pfd[i].revents & (POLLWRNORM|POLLOUT))?
  328. pfd[i].fd:ARES_SOCKET_BAD);
  329. }
  330. return nfds;
  331. }
  332. /*
  333. * Curl_resolver_is_resolved() is called repeatedly to check if a previous
  334. * name resolve request has completed. It should also make sure to time-out if
  335. * the operation seems to take too long.
  336. *
  337. * Returns normal CURLcode errors.
  338. */
  339. CURLcode Curl_resolver_is_resolved(struct Curl_easy *data,
  340. struct Curl_dns_entry **dns)
  341. {
  342. struct thread_data *res = data->state.async.tdata;
  343. CURLcode result = CURLE_OK;
  344. DEBUGASSERT(dns);
  345. *dns = NULL;
  346. if(waitperform(data, 0) < 0)
  347. return CURLE_UNRECOVERABLE_POLL;
  348. #ifndef HAVE_CARES_GETADDRINFO
  349. /* Now that we've checked for any last minute results above, see if there are
  350. any responses still pending when the EXPIRE_HAPPY_EYEBALLS_DNS timer
  351. expires. */
  352. if(res
  353. && res->num_pending
  354. /* This is only set to non-zero if the timer was started. */
  355. && (res->happy_eyeballs_dns_time.tv_sec
  356. || res->happy_eyeballs_dns_time.tv_usec)
  357. && (Curl_timediff(Curl_now(), res->happy_eyeballs_dns_time)
  358. >= HAPPY_EYEBALLS_DNS_TIMEOUT)) {
  359. /* Remember that the EXPIRE_HAPPY_EYEBALLS_DNS timer is no longer
  360. running. */
  361. memset(
  362. &res->happy_eyeballs_dns_time, 0, sizeof(res->happy_eyeballs_dns_time));
  363. /* Cancel the raw c-ares request, which will fire query_completed_cb() with
  364. ARES_ECANCELLED synchronously for all pending responses. This will
  365. leave us with res->num_pending == 0, which is perfect for the next
  366. block. */
  367. ares_cancel((ares_channel)data->state.async.resolver);
  368. DEBUGASSERT(res->num_pending == 0);
  369. }
  370. #endif
  371. if(res && !res->num_pending) {
  372. (void)Curl_addrinfo_callback(data, res->last_status, res->temp_ai);
  373. /* temp_ai ownership is moved to the connection, so we need not free-up
  374. them */
  375. res->temp_ai = NULL;
  376. if(!data->state.async.dns)
  377. result = Curl_resolver_error(data);
  378. else
  379. *dns = data->state.async.dns;
  380. destroy_async_data(&data->state.async);
  381. }
  382. return result;
  383. }
  384. /*
  385. * Curl_resolver_wait_resolv()
  386. *
  387. * Waits for a resolve to finish. This function should be avoided since using
  388. * this risk getting the multi interface to "hang".
  389. *
  390. * 'entry' MUST be non-NULL.
  391. *
  392. * Returns CURLE_COULDNT_RESOLVE_HOST if the host was not resolved,
  393. * CURLE_OPERATION_TIMEDOUT if a time-out occurred, or other errors.
  394. */
  395. CURLcode Curl_resolver_wait_resolv(struct Curl_easy *data,
  396. struct Curl_dns_entry **entry)
  397. {
  398. CURLcode result = CURLE_OK;
  399. timediff_t timeout;
  400. struct curltime now = Curl_now();
  401. DEBUGASSERT(entry);
  402. *entry = NULL; /* clear on entry */
  403. timeout = Curl_timeleft(data, &now, TRUE);
  404. if(timeout < 0) {
  405. /* already expired! */
  406. connclose(data->conn, "Timed out before name resolve started");
  407. return CURLE_OPERATION_TIMEDOUT;
  408. }
  409. if(!timeout)
  410. timeout = CURL_TIMEOUT_RESOLVE * 1000; /* default name resolve timeout */
  411. /* Wait for the name resolve query to complete. */
  412. while(!result) {
  413. struct timeval *tvp, tv, store;
  414. int itimeout;
  415. timediff_t timeout_ms;
  416. #if TIMEDIFF_T_MAX > INT_MAX
  417. itimeout = (timeout > INT_MAX) ? INT_MAX : (int)timeout;
  418. #else
  419. itimeout = (int)timeout;
  420. #endif
  421. store.tv_sec = itimeout/1000;
  422. store.tv_usec = (itimeout%1000)*1000;
  423. tvp = ares_timeout((ares_channel)data->state.async.resolver, &store, &tv);
  424. /* use the timeout period ares returned to us above if less than one
  425. second is left, otherwise just use 1000ms to make sure the progress
  426. callback gets called frequent enough */
  427. if(!tvp->tv_sec)
  428. timeout_ms = (timediff_t)(tvp->tv_usec/1000);
  429. else
  430. timeout_ms = 1000;
  431. if(waitperform(data, timeout_ms) < 0)
  432. return CURLE_UNRECOVERABLE_POLL;
  433. result = Curl_resolver_is_resolved(data, entry);
  434. if(result || data->state.async.done)
  435. break;
  436. if(Curl_pgrsUpdate(data))
  437. result = CURLE_ABORTED_BY_CALLBACK;
  438. else {
  439. struct curltime now2 = Curl_now();
  440. timediff_t timediff = Curl_timediff(now2, now); /* spent time */
  441. if(timediff <= 0)
  442. timeout -= 1; /* always deduct at least 1 */
  443. else if(timediff > timeout)
  444. timeout = -1;
  445. else
  446. timeout -= timediff;
  447. now = now2; /* for next loop */
  448. }
  449. if(timeout < 0)
  450. result = CURLE_OPERATION_TIMEDOUT;
  451. }
  452. if(result)
  453. /* failure, so we cancel the ares operation */
  454. ares_cancel((ares_channel)data->state.async.resolver);
  455. /* Operation complete, if the lookup was successful we now have the entry
  456. in the cache. */
  457. if(entry)
  458. *entry = data->state.async.dns;
  459. if(result)
  460. /* close the connection, since we can't return failure here without
  461. cleaning up this connection properly. */
  462. connclose(data->conn, "c-ares resolve failed");
  463. return result;
  464. }
  465. #ifndef HAVE_CARES_GETADDRINFO
  466. /* Connects results to the list */
  467. static void compound_results(struct thread_data *res,
  468. struct Curl_addrinfo *ai)
  469. {
  470. if(!ai)
  471. return;
  472. #ifdef USE_IPV6 /* CURLRES_IPV6 */
  473. if(res->temp_ai && res->temp_ai->ai_family == PF_INET6) {
  474. /* We have results already, put the new IPv6 entries at the head of the
  475. list. */
  476. struct Curl_addrinfo *temp_ai_tail = res->temp_ai;
  477. while(temp_ai_tail->ai_next)
  478. temp_ai_tail = temp_ai_tail->ai_next;
  479. temp_ai_tail->ai_next = ai;
  480. }
  481. else
  482. #endif /* CURLRES_IPV6 */
  483. {
  484. /* Add the new results to the list of old results. */
  485. struct Curl_addrinfo *ai_tail = ai;
  486. while(ai_tail->ai_next)
  487. ai_tail = ai_tail->ai_next;
  488. ai_tail->ai_next = res->temp_ai;
  489. res->temp_ai = ai;
  490. }
  491. }
  492. /*
  493. * ares_query_completed_cb() is the callback that ares will call when
  494. * the host query initiated by ares_gethostbyname() from Curl_getaddrinfo(),
  495. * when using ares, is completed either successfully or with failure.
  496. */
  497. static void query_completed_cb(void *arg, /* (struct connectdata *) */
  498. int status,
  499. #ifdef HAVE_CARES_CALLBACK_TIMEOUTS
  500. int timeouts,
  501. #endif
  502. struct hostent *hostent)
  503. {
  504. struct Curl_easy *data = (struct Curl_easy *)arg;
  505. struct thread_data *res;
  506. #ifdef HAVE_CARES_CALLBACK_TIMEOUTS
  507. (void)timeouts; /* ignored */
  508. #endif
  509. if(ARES_EDESTRUCTION == status)
  510. /* when this ares handle is getting destroyed, the 'arg' pointer may not
  511. be valid so only defer it when we know the 'status' says its fine! */
  512. return;
  513. res = data->state.async.tdata;
  514. if(res) {
  515. res->num_pending--;
  516. if(CURL_ASYNC_SUCCESS == status) {
  517. struct Curl_addrinfo *ai = Curl_he2ai(hostent, data->state.async.port);
  518. if(ai) {
  519. compound_results(res, ai);
  520. }
  521. }
  522. /* A successful result overwrites any previous error */
  523. if(res->last_status != ARES_SUCCESS)
  524. res->last_status = status;
  525. /* If there are responses still pending, we presume they must be the
  526. complementary IPv4 or IPv6 lookups that we started in parallel in
  527. Curl_resolver_getaddrinfo() (for Happy Eyeballs). If we've got a
  528. "definitive" response from one of a set of parallel queries, we need to
  529. think about how long we're willing to wait for more responses. */
  530. if(res->num_pending
  531. /* Only these c-ares status values count as "definitive" for these
  532. purposes. For example, ARES_ENODATA is what we expect when there is
  533. no IPv6 entry for a domain name, and that's not a reason to get more
  534. aggressive in our timeouts for the other response. Other errors are
  535. either a result of bad input (which should affect all parallel
  536. requests), local or network conditions, non-definitive server
  537. responses, or us cancelling the request. */
  538. && (status == ARES_SUCCESS || status == ARES_ENOTFOUND)) {
  539. /* Right now, there can only be up to two parallel queries, so don't
  540. bother handling any other cases. */
  541. DEBUGASSERT(res->num_pending == 1);
  542. /* It's possible that one of these parallel queries could succeed
  543. quickly, but the other could always fail or timeout (when we're
  544. talking to a pool of DNS servers that can only successfully resolve
  545. IPv4 address, for example).
  546. It's also possible that the other request could always just take
  547. longer because it needs more time or only the second DNS server can
  548. fulfill it successfully. But, to align with the philosophy of Happy
  549. Eyeballs, we don't want to wait _too_ long or users will think
  550. requests are slow when IPv6 lookups don't actually work (but IPv4 ones
  551. do).
  552. So, now that we have a usable answer (some IPv4 addresses, some IPv6
  553. addresses, or "no such domain"), we start a timeout for the remaining
  554. pending responses. Even though it is typical that this resolved
  555. request came back quickly, that needn't be the case. It might be that
  556. this completing request didn't get a result from the first DNS server
  557. or even the first round of the whole DNS server pool. So it could
  558. already be quite some time after we issued the DNS queries in the
  559. first place. Without modifying c-ares, we can't know exactly where in
  560. its retry cycle we are. We could guess based on how much time has
  561. gone by, but it doesn't really matter. Happy Eyeballs tells us that,
  562. given usable information in hand, we simply don't want to wait "too
  563. much longer" after we get a result.
  564. We simply wait an additional amount of time equal to the default
  565. c-ares query timeout. That is enough time for a typical parallel
  566. response to arrive without being "too long". Even on a network
  567. where one of the two types of queries is failing or timing out
  568. constantly, this will usually mean we wait a total of the default
  569. c-ares timeout (5 seconds) plus the round trip time for the successful
  570. request, which seems bearable. The downside is that c-ares might race
  571. with us to issue one more retry just before we give up, but it seems
  572. better to "waste" that request instead of trying to guess the perfect
  573. timeout to prevent it. After all, we don't even know where in the
  574. c-ares retry cycle each request is.
  575. */
  576. res->happy_eyeballs_dns_time = Curl_now();
  577. Curl_expire(data, HAPPY_EYEBALLS_DNS_TIMEOUT,
  578. EXPIRE_HAPPY_EYEBALLS_DNS);
  579. }
  580. }
  581. }
  582. #else
  583. /* c-ares 1.16.0 or later */
  584. /*
  585. * ares2addr() converts an address list provided by c-ares to an internal
  586. * libcurl compatible list
  587. */
  588. static struct Curl_addrinfo *ares2addr(struct ares_addrinfo_node *node)
  589. {
  590. /* traverse the ares_addrinfo_node list */
  591. struct ares_addrinfo_node *ai;
  592. struct Curl_addrinfo *cafirst = NULL;
  593. struct Curl_addrinfo *calast = NULL;
  594. int error = 0;
  595. for(ai = node; ai != NULL; ai = ai->ai_next) {
  596. size_t ss_size;
  597. struct Curl_addrinfo *ca;
  598. /* ignore elements with unsupported address family, */
  599. /* settle family-specific sockaddr structure size. */
  600. if(ai->ai_family == AF_INET)
  601. ss_size = sizeof(struct sockaddr_in);
  602. #ifdef USE_IPV6
  603. else if(ai->ai_family == AF_INET6)
  604. ss_size = sizeof(struct sockaddr_in6);
  605. #endif
  606. else
  607. continue;
  608. /* ignore elements without required address info */
  609. if(!ai->ai_addr || !(ai->ai_addrlen > 0))
  610. continue;
  611. /* ignore elements with bogus address size */
  612. if((size_t)ai->ai_addrlen < ss_size)
  613. continue;
  614. ca = malloc(sizeof(struct Curl_addrinfo) + ss_size);
  615. if(!ca) {
  616. error = EAI_MEMORY;
  617. break;
  618. }
  619. /* copy each structure member individually, member ordering, */
  620. /* size, or padding might be different for each platform. */
  621. ca->ai_flags = ai->ai_flags;
  622. ca->ai_family = ai->ai_family;
  623. ca->ai_socktype = ai->ai_socktype;
  624. ca->ai_protocol = ai->ai_protocol;
  625. ca->ai_addrlen = (curl_socklen_t)ss_size;
  626. ca->ai_addr = NULL;
  627. ca->ai_canonname = NULL;
  628. ca->ai_next = NULL;
  629. ca->ai_addr = (void *)((char *)ca + sizeof(struct Curl_addrinfo));
  630. memcpy(ca->ai_addr, ai->ai_addr, ss_size);
  631. /* if the return list is empty, this becomes the first element */
  632. if(!cafirst)
  633. cafirst = ca;
  634. /* add this element last in the return list */
  635. if(calast)
  636. calast->ai_next = ca;
  637. calast = ca;
  638. }
  639. /* if we failed, destroy the Curl_addrinfo list */
  640. if(error) {
  641. Curl_freeaddrinfo(cafirst);
  642. cafirst = NULL;
  643. }
  644. return cafirst;
  645. }
  646. static void addrinfo_cb(void *arg, int status, int timeouts,
  647. struct ares_addrinfo *result)
  648. {
  649. struct Curl_easy *data = (struct Curl_easy *)arg;
  650. struct thread_data *res = data->state.async.tdata;
  651. (void)timeouts;
  652. if(ARES_SUCCESS == status) {
  653. res->temp_ai = ares2addr(result->nodes);
  654. res->last_status = CURL_ASYNC_SUCCESS;
  655. ares_freeaddrinfo(result);
  656. }
  657. res->num_pending--;
  658. }
  659. #endif
  660. /*
  661. * Curl_resolver_getaddrinfo() - when using ares
  662. *
  663. * Returns name information about the given hostname and port number. If
  664. * successful, the 'hostent' is returned and the fourth argument will point to
  665. * memory we need to free after use. That memory *MUST* be freed with
  666. * Curl_freeaddrinfo(), nothing else.
  667. */
  668. struct Curl_addrinfo *Curl_resolver_getaddrinfo(struct Curl_easy *data,
  669. const char *hostname,
  670. int port,
  671. int *waitp)
  672. {
  673. struct thread_data *res = NULL;
  674. size_t namelen = strlen(hostname);
  675. *waitp = 0; /* default to synchronous response */
  676. res = calloc(1, sizeof(struct thread_data) + namelen);
  677. if(res) {
  678. strcpy(res->hostname, hostname);
  679. data->state.async.hostname = res->hostname;
  680. data->state.async.port = port;
  681. data->state.async.done = FALSE; /* not done */
  682. data->state.async.status = 0; /* clear */
  683. data->state.async.dns = NULL; /* clear */
  684. data->state.async.tdata = res;
  685. /* initial status - failed */
  686. res->last_status = ARES_ENOTFOUND;
  687. #ifdef HAVE_CARES_GETADDRINFO
  688. {
  689. struct ares_addrinfo_hints hints;
  690. char service[12];
  691. int pf = PF_INET;
  692. memset(&hints, 0, sizeof(hints));
  693. #ifdef CURLRES_IPV6
  694. if((data->conn->ip_version != CURL_IPRESOLVE_V4) &&
  695. Curl_ipv6works(data)) {
  696. /* The stack seems to be IPv6-enabled */
  697. if(data->conn->ip_version == CURL_IPRESOLVE_V6)
  698. pf = PF_INET6;
  699. else
  700. pf = PF_UNSPEC;
  701. }
  702. #endif /* CURLRES_IPV6 */
  703. hints.ai_family = pf;
  704. hints.ai_socktype = (data->conn->transport == TRNSPRT_TCP)?
  705. SOCK_STREAM : SOCK_DGRAM;
  706. /* Since the service is a numerical one, set the hint flags
  707. * accordingly to save a call to getservbyname in inside C-Ares
  708. */
  709. hints.ai_flags = ARES_AI_NUMERICSERV;
  710. msnprintf(service, sizeof(service), "%d", port);
  711. res->num_pending = 1;
  712. ares_getaddrinfo((ares_channel)data->state.async.resolver, hostname,
  713. service, &hints, addrinfo_cb, data);
  714. }
  715. #else
  716. #ifdef HAVE_CARES_IPV6
  717. if((data->conn->ip_version != CURL_IPRESOLVE_V4) && Curl_ipv6works(data)) {
  718. /* The stack seems to be IPv6-enabled */
  719. res->num_pending = 2;
  720. /* areschannel is already setup in the Curl_open() function */
  721. ares_gethostbyname((ares_channel)data->state.async.resolver, hostname,
  722. PF_INET, query_completed_cb, data);
  723. ares_gethostbyname((ares_channel)data->state.async.resolver, hostname,
  724. PF_INET6, query_completed_cb, data);
  725. }
  726. else
  727. #endif
  728. {
  729. res->num_pending = 1;
  730. /* areschannel is already setup in the Curl_open() function */
  731. ares_gethostbyname((ares_channel)data->state.async.resolver,
  732. hostname, PF_INET,
  733. query_completed_cb, data);
  734. }
  735. #endif
  736. *waitp = 1; /* expect asynchronous response */
  737. }
  738. return NULL; /* no struct yet */
  739. }
  740. CURLcode Curl_set_dns_servers(struct Curl_easy *data,
  741. char *servers)
  742. {
  743. CURLcode result = CURLE_NOT_BUILT_IN;
  744. int ares_result;
  745. /* If server is NULL or empty, this would purge all DNS servers
  746. * from ares library, which will cause any and all queries to fail.
  747. * So, just return OK if none are configured and don't actually make
  748. * any changes to c-ares. This lets c-ares use its defaults, which
  749. * it gets from the OS (for instance from /etc/resolv.conf on Linux).
  750. */
  751. if(!(servers && servers[0]))
  752. return CURLE_OK;
  753. #ifdef HAVE_CARES_SERVERS_CSV
  754. #ifdef HAVE_CARES_PORTS_CSV
  755. ares_result = ares_set_servers_ports_csv(data->state.async.resolver,
  756. servers);
  757. #else
  758. ares_result = ares_set_servers_csv(data->state.async.resolver, servers);
  759. #endif
  760. switch(ares_result) {
  761. case ARES_SUCCESS:
  762. result = CURLE_OK;
  763. break;
  764. case ARES_ENOMEM:
  765. result = CURLE_OUT_OF_MEMORY;
  766. break;
  767. case ARES_ENOTINITIALIZED:
  768. case ARES_ENODATA:
  769. case ARES_EBADSTR:
  770. default:
  771. DEBUGF(infof(data, "bad servers set"));
  772. result = CURLE_BAD_FUNCTION_ARGUMENT;
  773. break;
  774. }
  775. #else /* too old c-ares version! */
  776. (void)data;
  777. (void)(ares_result);
  778. #endif
  779. return result;
  780. }
  781. CURLcode Curl_set_dns_interface(struct Curl_easy *data,
  782. const char *interf)
  783. {
  784. #ifdef HAVE_CARES_LOCAL_DEV
  785. if(!interf)
  786. interf = "";
  787. ares_set_local_dev((ares_channel)data->state.async.resolver, interf);
  788. return CURLE_OK;
  789. #else /* c-ares version too old! */
  790. (void)data;
  791. (void)interf;
  792. return CURLE_NOT_BUILT_IN;
  793. #endif
  794. }
  795. CURLcode Curl_set_dns_local_ip4(struct Curl_easy *data,
  796. const char *local_ip4)
  797. {
  798. #ifdef HAVE_CARES_SET_LOCAL
  799. struct in_addr a4;
  800. if((!local_ip4) || (local_ip4[0] == 0)) {
  801. a4.s_addr = 0; /* disabled: do not bind to a specific address */
  802. }
  803. else {
  804. if(Curl_inet_pton(AF_INET, local_ip4, &a4) != 1) {
  805. DEBUGF(infof(data, "bad DNS IPv4 address"));
  806. return CURLE_BAD_FUNCTION_ARGUMENT;
  807. }
  808. }
  809. ares_set_local_ip4((ares_channel)data->state.async.resolver,
  810. ntohl(a4.s_addr));
  811. return CURLE_OK;
  812. #else /* c-ares version too old! */
  813. (void)data;
  814. (void)local_ip4;
  815. return CURLE_NOT_BUILT_IN;
  816. #endif
  817. }
  818. CURLcode Curl_set_dns_local_ip6(struct Curl_easy *data,
  819. const char *local_ip6)
  820. {
  821. #if defined(HAVE_CARES_SET_LOCAL) && defined(USE_IPV6)
  822. unsigned char a6[INET6_ADDRSTRLEN];
  823. if((!local_ip6) || (local_ip6[0] == 0)) {
  824. /* disabled: do not bind to a specific address */
  825. memset(a6, 0, sizeof(a6));
  826. }
  827. else {
  828. if(Curl_inet_pton(AF_INET6, local_ip6, a6) != 1) {
  829. DEBUGF(infof(data, "bad DNS IPv6 address"));
  830. return CURLE_BAD_FUNCTION_ARGUMENT;
  831. }
  832. }
  833. ares_set_local_ip6((ares_channel)data->state.async.resolver, a6);
  834. return CURLE_OK;
  835. #else /* c-ares version too old! */
  836. (void)data;
  837. (void)local_ip6;
  838. return CURLE_NOT_BUILT_IN;
  839. #endif
  840. }
  841. #endif /* CURLRES_ARES */