1
2 /* Copyright 1998 by the Massachusetts Institute of Technology.
3 * Copyright (C) 2007-2013 by Daniel Stenberg
4 *
5 * Permission to use, copy, modify, and distribute this
6 * software and its documentation for any purpose and without
7 * fee is hereby granted, provided that the above copyright
8 * notice appear in all copies and that both that copyright
9 * notice and this permission notice appear in supporting
10 * documentation, and that the name of M.I.T. not be used in
11 * advertising or publicity pertaining to distribution of the
12 * software without specific, written prior permission.
13 * M.I.T. makes no representations about the suitability of
14 * this software for any purpose. It is provided "as is"
15 * without express or implied warranty.
16 */
17
18 #include "ares_setup.h"
19
20 #ifdef HAVE_SYS_PARAM_H
21 #include <sys/param.h>
22 #endif
23
24 #ifdef HAVE_NETINET_IN_H
25 #include <netinet/in.h>
26 #endif
27
28 #ifdef HAVE_NETDB_H
29 #include <netdb.h>
30 #endif
31
32 #ifdef HAVE_ARPA_INET_H
33 #include <arpa/inet.h>
34 #endif
35
36 #ifdef HAVE_ARPA_NAMESER_H
37 # include <arpa/nameser.h>
38 #else
39 # include "nameser.h"
40 #endif
41 #ifdef HAVE_ARPA_NAMESER_COMPAT_H
42 # include <arpa/nameser_compat.h>
43 #endif
44
45 #if defined(ANDROID) || defined(__ANDROID__)
46 #include <sys/system_properties.h>
47 #include "ares_android.h"
48 /* From the Bionic sources */
49 #define DNS_PROP_NAME_PREFIX "net.dns"
50 #define MAX_DNS_PROPERTIES 8
51 #endif
52
53 #if defined(CARES_USE_LIBRESOLV)
54 #include <resolv.h>
55 #endif
56
57 #include "ares.h"
58 #include "ares_inet_net_pton.h"
59 #include "ares_library_init.h"
60 #include "ares_nowarn.h"
61 #include "ares_platform.h"
62 #include "ares_private.h"
63
64 #ifdef WATT32
65 #undef WIN32 /* Redefined in MingW/MSVC headers */
66 #endif
67
68 static int init_by_options(ares_channel channel,
69 const struct ares_options *options,
70 int optmask);
71 static int init_by_environment(ares_channel channel);
72 static int init_by_resolv_conf(ares_channel channel);
73 static int init_by_defaults(ares_channel channel);
74
75 #ifndef WATT32
76 static int config_nameserver(struct server_state **servers, int *nservers,
77 char *str);
78 #endif
79 static int set_search(ares_channel channel, const char *str);
80 static int set_options(ares_channel channel, const char *str);
81 static const char *try_option(const char *p, const char *q, const char *opt);
82 static int init_id_key(rc4_key* key,int key_data_len);
83
84 static int config_sortlist(struct apattern **sortlist, int *nsort,
85 const char *str);
86 static int sortlist_alloc(struct apattern **sortlist, int *nsort,
87 struct apattern *pat);
88 static int ip_addr(const char *s, ares_ssize_t len, struct in_addr *addr);
89 static void natural_mask(struct apattern *pat);
90 #if !defined(WIN32) && !defined(WATT32) && \
91 !defined(ANDROID) && !defined(__ANDROID__) && !defined(CARES_USE_LIBRESOLV)
92 static int config_domain(ares_channel channel, char *str);
93 static int config_lookup(ares_channel channel, const char *str,
94 const char *bindch, const char *altbindch,
95 const char *filech);
96 static char *try_config(char *s, const char *opt, char scc);
97 #endif
98
99 #define ARES_CONFIG_CHECK(x) (x->lookups && x->nsort > -1 && \
100 x->nservers > -1 && \
101 x->ndomains > -1 && \
102 x->ndots > -1 && x->timeout > -1 && \
103 x->tries > -1)
104
ares_init(ares_channel * channelptr)105 int ares_init(ares_channel *channelptr)
106 {
107 return ares_init_options(channelptr, NULL, 0);
108 }
109
ares_init_options(ares_channel * channelptr,struct ares_options * options,int optmask)110 int ares_init_options(ares_channel *channelptr, struct ares_options *options,
111 int optmask)
112 {
113 ares_channel channel;
114 int i;
115 int status = ARES_SUCCESS;
116 struct timeval now;
117
118 #ifdef CURLDEBUG
119 const char *env = getenv("CARES_MEMDEBUG");
120
121 if (env)
122 curl_memdebug(env);
123 env = getenv("CARES_MEMLIMIT");
124 if (env) {
125 char *endptr;
126 long num = strtol(env, &endptr, 10);
127 if((endptr != env) && (endptr == env + strlen(env)) && (num > 0))
128 curl_memlimit(num);
129 }
130 #endif
131
132 if (ares_library_initialized() != ARES_SUCCESS)
133 return ARES_ENOTINITIALIZED; /* LCOV_EXCL_LINE: n/a on non-WinSock */
134
135 channel = ares_malloc(sizeof(struct ares_channeldata));
136 if (!channel) {
137 *channelptr = NULL;
138 return ARES_ENOMEM;
139 }
140
141 now = ares__tvnow();
142
143 /* Set everything to distinguished values so we know they haven't
144 * been set yet.
145 */
146 channel->flags = -1;
147 channel->timeout = -1;
148 channel->tries = -1;
149 channel->ndots = -1;
150 channel->rotate = -1;
151 channel->udp_port = -1;
152 channel->tcp_port = -1;
153 channel->ednspsz = -1;
154 channel->socket_send_buffer_size = -1;
155 channel->socket_receive_buffer_size = -1;
156 channel->nservers = -1;
157 channel->ndomains = -1;
158 channel->nsort = -1;
159 channel->tcp_connection_generation = 0;
160 channel->lookups = NULL;
161 channel->domains = NULL;
162 channel->sortlist = NULL;
163 channel->servers = NULL;
164 channel->sock_state_cb = NULL;
165 channel->sock_state_cb_data = NULL;
166 channel->sock_create_cb = NULL;
167 channel->sock_create_cb_data = NULL;
168 channel->sock_config_cb = NULL;
169 channel->sock_config_cb_data = NULL;
170 channel->sock_funcs = NULL;
171 channel->sock_func_cb_data = NULL;
172 channel->resolvconf_path = NULL;
173
174 channel->last_server = 0;
175 channel->last_timeout_processed = (time_t)now.tv_sec;
176
177 memset(&channel->local_dev_name, 0, sizeof(channel->local_dev_name));
178 channel->local_ip4 = 0;
179 memset(&channel->local_ip6, 0, sizeof(channel->local_ip6));
180
181 /* Initialize our lists of queries */
182 ares__init_list_head(&(channel->all_queries));
183 for (i = 0; i < ARES_QID_TABLE_SIZE; i++)
184 {
185 ares__init_list_head(&(channel->queries_by_qid[i]));
186 }
187 for (i = 0; i < ARES_TIMEOUT_TABLE_SIZE; i++)
188 {
189 ares__init_list_head(&(channel->queries_by_timeout[i]));
190 }
191
192 /* Initialize configuration by each of the four sources, from highest
193 * precedence to lowest.
194 */
195
196 status = init_by_options(channel, options, optmask);
197 if (status != ARES_SUCCESS) {
198 DEBUGF(fprintf(stderr, "Error: init_by_options failed: %s\n",
199 ares_strerror(status)));
200 /* If we fail to apply user-specified options, fail the whole init process */
201 goto done;
202 }
203 status = init_by_environment(channel);
204 if (status != ARES_SUCCESS)
205 DEBUGF(fprintf(stderr, "Error: init_by_environment failed: %s\n",
206 ares_strerror(status)));
207 if (status == ARES_SUCCESS) {
208 status = init_by_resolv_conf(channel);
209 if (status != ARES_SUCCESS)
210 DEBUGF(fprintf(stderr, "Error: init_by_resolv_conf failed: %s\n",
211 ares_strerror(status)));
212 }
213
214 /*
215 * No matter what failed or succeeded, seed defaults to provide
216 * useful behavior for things that we missed.
217 */
218 status = init_by_defaults(channel);
219 if (status != ARES_SUCCESS)
220 DEBUGF(fprintf(stderr, "Error: init_by_defaults failed: %s\n",
221 ares_strerror(status)));
222
223 /* Generate random key */
224
225 if (status == ARES_SUCCESS) {
226 status = init_id_key(&channel->id_key, ARES_ID_KEY_LEN);
227 if (status == ARES_SUCCESS)
228 channel->next_id = ares__generate_new_id(&channel->id_key);
229 else
230 DEBUGF(fprintf(stderr, "Error: init_id_key failed: %s\n",
231 ares_strerror(status)));
232 }
233
234 done:
235 if (status != ARES_SUCCESS)
236 {
237 /* Something failed; clean up memory we may have allocated. */
238 if (channel->servers)
239 ares_free(channel->servers);
240 if (channel->ndomains != -1)
241 ares_strsplit_free(channel->domains, channel->ndomains);
242 if (channel->sortlist)
243 ares_free(channel->sortlist);
244 if(channel->lookups)
245 ares_free(channel->lookups);
246 if(channel->resolvconf_path)
247 ares_free(channel->resolvconf_path);
248 ares_free(channel);
249 return status;
250 }
251
252 /* Trim to one server if ARES_FLAG_PRIMARY is set. */
253 if ((channel->flags & ARES_FLAG_PRIMARY) && channel->nservers > 1)
254 channel->nservers = 1;
255
256 ares__init_servers_state(channel);
257
258 *channelptr = channel;
259 return ARES_SUCCESS;
260 }
261
262 /* ares_dup() duplicates a channel handle with all its options and returns a
263 new channel handle */
ares_dup(ares_channel * dest,ares_channel src)264 int ares_dup(ares_channel *dest, ares_channel src)
265 {
266 struct ares_options opts;
267 struct ares_addr_port_node *servers;
268 int non_v4_default_port = 0;
269 int i, rc;
270 int optmask;
271
272 *dest = NULL; /* in case of failure return NULL explicitly */
273
274 /* First get the options supported by the old ares_save_options() function,
275 which is most of them */
276 rc = ares_save_options(src, &opts, &optmask);
277 if(rc)
278 {
279 ares_destroy_options(&opts);
280 return rc;
281 }
282
283 /* Then create the new channel with those options */
284 rc = ares_init_options(dest, &opts, optmask);
285
286 /* destroy the options copy to not leak any memory */
287 ares_destroy_options(&opts);
288
289 if(rc)
290 return rc;
291
292 /* Now clone the options that ares_save_options() doesn't support. */
293 (*dest)->sock_create_cb = src->sock_create_cb;
294 (*dest)->sock_create_cb_data = src->sock_create_cb_data;
295 (*dest)->sock_config_cb = src->sock_config_cb;
296 (*dest)->sock_config_cb_data = src->sock_config_cb_data;
297 (*dest)->sock_funcs = src->sock_funcs;
298 (*dest)->sock_func_cb_data = src->sock_func_cb_data;
299
300 strncpy((*dest)->local_dev_name, src->local_dev_name,
301 sizeof((*dest)->local_dev_name));
302 (*dest)->local_ip4 = src->local_ip4;
303 memcpy((*dest)->local_ip6, src->local_ip6, sizeof(src->local_ip6));
304
305 /* Full name server cloning required if there is a non-IPv4, or non-default port, nameserver */
306 for (i = 0; i < src->nservers; i++)
307 {
308 if ((src->servers[i].addr.family != AF_INET) ||
309 (src->servers[i].addr.udp_port != 0) ||
310 (src->servers[i].addr.tcp_port != 0)) {
311 non_v4_default_port++;
312 break;
313 }
314 }
315 if (non_v4_default_port) {
316 rc = ares_get_servers_ports(src, &servers);
317 if (rc != ARES_SUCCESS) {
318 ares_destroy(*dest);
319 *dest = NULL;
320 return rc;
321 }
322 rc = ares_set_servers_ports(*dest, servers);
323 ares_free_data(servers);
324 if (rc != ARES_SUCCESS) {
325 ares_destroy(*dest);
326 *dest = NULL;
327 return rc;
328 }
329 }
330
331 return ARES_SUCCESS; /* everything went fine */
332 }
333
334 /* Save options from initialized channel */
ares_save_options(ares_channel channel,struct ares_options * options,int * optmask)335 int ares_save_options(ares_channel channel, struct ares_options *options,
336 int *optmask)
337 {
338 int i, j;
339 int ipv4_nservers = 0;
340
341 /* Zero everything out */
342 memset(options, 0, sizeof(struct ares_options));
343
344 if (!ARES_CONFIG_CHECK(channel))
345 return ARES_ENODATA;
346
347 /* Traditionally the optmask wasn't saved in the channel struct so it was
348 recreated here. ROTATE is the first option that has no struct field of
349 its own in the public config struct */
350 (*optmask) = (ARES_OPT_FLAGS|ARES_OPT_TRIES|ARES_OPT_NDOTS|
351 ARES_OPT_UDP_PORT|ARES_OPT_TCP_PORT|ARES_OPT_SOCK_STATE_CB|
352 ARES_OPT_SERVERS|ARES_OPT_DOMAINS|ARES_OPT_LOOKUPS|
353 ARES_OPT_SORTLIST|ARES_OPT_TIMEOUTMS);
354 (*optmask) |= (channel->rotate ? ARES_OPT_ROTATE : ARES_OPT_NOROTATE);
355
356 if (channel->resolvconf_path)
357 (*optmask) |= ARES_OPT_RESOLVCONF;
358
359 /* Copy easy stuff */
360 options->flags = channel->flags;
361
362 /* We return full millisecond resolution but that's only because we don't
363 set the ARES_OPT_TIMEOUT anymore, only the new ARES_OPT_TIMEOUTMS */
364 options->timeout = channel->timeout;
365 options->tries = channel->tries;
366 options->ndots = channel->ndots;
367 options->udp_port = ntohs(aresx_sitous(channel->udp_port));
368 options->tcp_port = ntohs(aresx_sitous(channel->tcp_port));
369 options->sock_state_cb = channel->sock_state_cb;
370 options->sock_state_cb_data = channel->sock_state_cb_data;
371
372 /* Copy IPv4 servers that use the default port */
373 if (channel->nservers) {
374 for (i = 0; i < channel->nservers; i++)
375 {
376 if ((channel->servers[i].addr.family == AF_INET) &&
377 (channel->servers[i].addr.udp_port == 0) &&
378 (channel->servers[i].addr.tcp_port == 0))
379 ipv4_nservers++;
380 }
381 if (ipv4_nservers) {
382 options->servers = ares_malloc(ipv4_nservers * sizeof(struct in_addr));
383 if (!options->servers)
384 return ARES_ENOMEM;
385 for (i = j = 0; i < channel->nservers; i++)
386 {
387 if ((channel->servers[i].addr.family == AF_INET) &&
388 (channel->servers[i].addr.udp_port == 0) &&
389 (channel->servers[i].addr.tcp_port == 0))
390 memcpy(&options->servers[j++],
391 &channel->servers[i].addr.addrV4,
392 sizeof(channel->servers[i].addr.addrV4));
393 }
394 }
395 }
396 options->nservers = ipv4_nservers;
397
398 /* copy domains */
399 if (channel->ndomains) {
400 options->domains = ares_malloc(channel->ndomains * sizeof(char *));
401 if (!options->domains)
402 return ARES_ENOMEM;
403
404 for (i = 0; i < channel->ndomains; i++)
405 {
406 options->ndomains = i;
407 options->domains[i] = ares_strdup(channel->domains[i]);
408 if (!options->domains[i])
409 return ARES_ENOMEM;
410 }
411 }
412 options->ndomains = channel->ndomains;
413
414 /* copy lookups */
415 if (channel->lookups) {
416 options->lookups = ares_strdup(channel->lookups);
417 if (!options->lookups && channel->lookups)
418 return ARES_ENOMEM;
419 }
420
421 /* copy sortlist */
422 if (channel->nsort) {
423 options->sortlist = ares_malloc(channel->nsort * sizeof(struct apattern));
424 if (!options->sortlist)
425 return ARES_ENOMEM;
426 for (i = 0; i < channel->nsort; i++)
427 options->sortlist[i] = channel->sortlist[i];
428 }
429 options->nsort = channel->nsort;
430
431 /* copy path for resolv.conf file */
432 if (channel->resolvconf_path) {
433 options->resolvconf_path = ares_strdup(channel->resolvconf_path);
434 if (!options->resolvconf_path)
435 return ARES_ENOMEM;
436 }
437
438 return ARES_SUCCESS;
439 }
440
init_by_options(ares_channel channel,const struct ares_options * options,int optmask)441 static int init_by_options(ares_channel channel,
442 const struct ares_options *options,
443 int optmask)
444 {
445 int i;
446
447 /* Easy stuff. */
448 if ((optmask & ARES_OPT_FLAGS) && channel->flags == -1)
449 channel->flags = options->flags;
450 if ((optmask & ARES_OPT_TIMEOUTMS) && channel->timeout == -1)
451 channel->timeout = options->timeout;
452 else if ((optmask & ARES_OPT_TIMEOUT) && channel->timeout == -1)
453 channel->timeout = options->timeout * 1000;
454 if ((optmask & ARES_OPT_TRIES) && channel->tries == -1)
455 channel->tries = options->tries;
456 if ((optmask & ARES_OPT_NDOTS) && channel->ndots == -1)
457 channel->ndots = options->ndots;
458 if ((optmask & ARES_OPT_ROTATE) && channel->rotate == -1)
459 channel->rotate = 1;
460 if ((optmask & ARES_OPT_NOROTATE) && channel->rotate == -1)
461 channel->rotate = 0;
462 if ((optmask & ARES_OPT_UDP_PORT) && channel->udp_port == -1)
463 channel->udp_port = htons(options->udp_port);
464 if ((optmask & ARES_OPT_TCP_PORT) && channel->tcp_port == -1)
465 channel->tcp_port = htons(options->tcp_port);
466 if ((optmask & ARES_OPT_SOCK_STATE_CB) && channel->sock_state_cb == NULL)
467 {
468 channel->sock_state_cb = options->sock_state_cb;
469 channel->sock_state_cb_data = options->sock_state_cb_data;
470 }
471 if ((optmask & ARES_OPT_SOCK_SNDBUF)
472 && channel->socket_send_buffer_size == -1)
473 channel->socket_send_buffer_size = options->socket_send_buffer_size;
474 if ((optmask & ARES_OPT_SOCK_RCVBUF)
475 && channel->socket_receive_buffer_size == -1)
476 channel->socket_receive_buffer_size = options->socket_receive_buffer_size;
477
478 if ((optmask & ARES_OPT_EDNSPSZ) && channel->ednspsz == -1)
479 channel->ednspsz = options->ednspsz;
480
481 /* Copy the IPv4 servers, if given. */
482 if ((optmask & ARES_OPT_SERVERS) && channel->nservers == -1)
483 {
484 /* Avoid zero size allocations at any cost */
485 if (options->nservers > 0)
486 {
487 channel->servers =
488 ares_malloc(options->nservers * sizeof(struct server_state));
489 if (!channel->servers)
490 return ARES_ENOMEM;
491 for (i = 0; i < options->nservers; i++)
492 {
493 channel->servers[i].addr.family = AF_INET;
494 channel->servers[i].addr.udp_port = 0;
495 channel->servers[i].addr.tcp_port = 0;
496 memcpy(&channel->servers[i].addr.addrV4,
497 &options->servers[i],
498 sizeof(channel->servers[i].addr.addrV4));
499 }
500 }
501 channel->nservers = options->nservers;
502 }
503
504 /* Copy the domains, if given. Keep channel->ndomains consistent so
505 * we can clean up in case of error.
506 */
507 if ((optmask & ARES_OPT_DOMAINS) && channel->ndomains == -1)
508 {
509 /* Avoid zero size allocations at any cost */
510 if (options->ndomains > 0)
511 {
512 channel->domains = ares_malloc(options->ndomains * sizeof(char *));
513 if (!channel->domains)
514 return ARES_ENOMEM;
515 for (i = 0; i < options->ndomains; i++)
516 {
517 channel->ndomains = i;
518 channel->domains[i] = ares_strdup(options->domains[i]);
519 if (!channel->domains[i])
520 return ARES_ENOMEM;
521 }
522 }
523 channel->ndomains = options->ndomains;
524 }
525
526 /* Set lookups, if given. */
527 if ((optmask & ARES_OPT_LOOKUPS) && !channel->lookups)
528 {
529 channel->lookups = ares_strdup(options->lookups);
530 if (!channel->lookups)
531 return ARES_ENOMEM;
532 }
533
534 /* copy sortlist */
535 if ((optmask & ARES_OPT_SORTLIST) && (channel->nsort == -1)) {
536 if (options->nsort > 0) {
537 channel->sortlist = ares_malloc(options->nsort * sizeof(struct apattern));
538 if (!channel->sortlist)
539 return ARES_ENOMEM;
540 for (i = 0; i < options->nsort; i++)
541 channel->sortlist[i] = options->sortlist[i];
542 }
543 channel->nsort = options->nsort;
544 }
545
546 /* Set path for resolv.conf file, if given. */
547 if ((optmask & ARES_OPT_RESOLVCONF) && !channel->resolvconf_path)
548 {
549 channel->resolvconf_path = ares_strdup(options->resolvconf_path);
550 if (!channel->resolvconf_path && options->resolvconf_path)
551 return ARES_ENOMEM;
552 }
553
554 channel->optmask = optmask;
555
556 return ARES_SUCCESS;
557 }
558
init_by_environment(ares_channel channel)559 static int init_by_environment(ares_channel channel)
560 {
561 const char *localdomain, *res_options;
562 int status;
563
564 localdomain = getenv("LOCALDOMAIN");
565 if (localdomain && channel->ndomains == -1)
566 {
567 status = set_search(channel, localdomain);
568 if (status != ARES_SUCCESS)
569 return status;
570 }
571
572 res_options = getenv("RES_OPTIONS");
573 if (res_options)
574 {
575 status = set_options(channel, res_options);
576 if (status != ARES_SUCCESS)
577 return status; /* LCOV_EXCL_LINE: set_options() never fails */
578 }
579
580 return ARES_SUCCESS;
581 }
582
583 #ifdef WIN32
584 /*
585 * get_REG_SZ()
586 *
587 * Given a 'hKey' handle to an open registry key and a 'leafKeyName' pointer
588 * to the name of the registry leaf key to be queried, fetch it's string
589 * value and return a pointer in *outptr to a newly allocated memory area
590 * holding it as a null-terminated string.
591 *
592 * Returns 0 and nullifies *outptr upon inability to return a string value.
593 *
594 * Returns 1 and sets *outptr when returning a dynamically allocated string.
595 *
596 * Supported on Windows NT 3.5 and newer.
597 */
get_REG_SZ(HKEY hKey,const char * leafKeyName,char ** outptr)598 static int get_REG_SZ(HKEY hKey, const char *leafKeyName, char **outptr)
599 {
600 DWORD size = 0;
601 int res;
602
603 *outptr = NULL;
604
605 /* Find out size of string stored in registry */
606 res = RegQueryValueExA(hKey, leafKeyName, 0, NULL, NULL, &size);
607 if ((res != ERROR_SUCCESS && res != ERROR_MORE_DATA) || !size)
608 return 0;
609
610 /* Allocate buffer of indicated size plus one given that string
611 might have been stored without null termination */
612 *outptr = ares_malloc(size+1);
613 if (!*outptr)
614 return 0;
615
616 /* Get the value for real */
617 res = RegQueryValueExA(hKey, leafKeyName, 0, NULL,
618 (unsigned char *)*outptr, &size);
619 if ((res != ERROR_SUCCESS) || (size == 1))
620 {
621 ares_free(*outptr);
622 *outptr = NULL;
623 return 0;
624 }
625
626 /* Null terminate buffer allways */
627 *(*outptr + size) = '\0';
628
629 return 1;
630 }
631
632 /*
633 * get_REG_SZ_9X()
634 *
635 * Functionally identical to get_REG_SZ()
636 *
637 * Supported on Windows 95, 98 and ME.
638 */
get_REG_SZ_9X(HKEY hKey,const char * leafKeyName,char ** outptr)639 static int get_REG_SZ_9X(HKEY hKey, const char *leafKeyName, char **outptr)
640 {
641 DWORD dataType = 0;
642 DWORD size = 0;
643 int res;
644
645 *outptr = NULL;
646
647 /* Find out size of string stored in registry */
648 res = RegQueryValueExA(hKey, leafKeyName, 0, &dataType, NULL, &size);
649 if ((res != ERROR_SUCCESS && res != ERROR_MORE_DATA) || !size)
650 return 0;
651
652 /* Allocate buffer of indicated size plus one given that string
653 might have been stored without null termination */
654 *outptr = ares_malloc(size+1);
655 if (!*outptr)
656 return 0;
657
658 /* Get the value for real */
659 res = RegQueryValueExA(hKey, leafKeyName, 0, &dataType,
660 (unsigned char *)*outptr, &size);
661 if ((res != ERROR_SUCCESS) || (size == 1))
662 {
663 ares_free(*outptr);
664 *outptr = NULL;
665 return 0;
666 }
667
668 /* Null terminate buffer allways */
669 *(*outptr + size) = '\0';
670
671 return 1;
672 }
673
674 /*
675 * get_enum_REG_SZ()
676 *
677 * Given a 'hKeyParent' handle to an open registry key and a 'leafKeyName'
678 * pointer to the name of the registry leaf key to be queried, parent key
679 * is enumerated searching in child keys for given leaf key name and its
680 * associated string value. When located, this returns a pointer in *outptr
681 * to a newly allocated memory area holding it as a null-terminated string.
682 *
683 * Returns 0 and nullifies *outptr upon inability to return a string value.
684 *
685 * Returns 1 and sets *outptr when returning a dynamically allocated string.
686 *
687 * Supported on Windows NT 3.5 and newer.
688 */
get_enum_REG_SZ(HKEY hKeyParent,const char * leafKeyName,char ** outptr)689 static int get_enum_REG_SZ(HKEY hKeyParent, const char *leafKeyName,
690 char **outptr)
691 {
692 char enumKeyName[256];
693 DWORD enumKeyNameBuffSize;
694 DWORD enumKeyIdx = 0;
695 HKEY hKeyEnum;
696 int gotString;
697 int res;
698
699 *outptr = NULL;
700
701 for(;;)
702 {
703 enumKeyNameBuffSize = sizeof(enumKeyName);
704 res = RegEnumKeyExA(hKeyParent, enumKeyIdx++, enumKeyName,
705 &enumKeyNameBuffSize, 0, NULL, NULL, NULL);
706 if (res != ERROR_SUCCESS)
707 break;
708 res = RegOpenKeyExA(hKeyParent, enumKeyName, 0, KEY_QUERY_VALUE,
709 &hKeyEnum);
710 if (res != ERROR_SUCCESS)
711 continue;
712 gotString = get_REG_SZ(hKeyEnum, leafKeyName, outptr);
713 RegCloseKey(hKeyEnum);
714 if (gotString)
715 break;
716 }
717
718 if (!*outptr)
719 return 0;
720
721 return 1;
722 }
723
724 /*
725 * get_DNS_Registry_9X()
726 *
727 * Functionally identical to get_DNS_Registry()
728 *
729 * Implementation supports Windows 95, 98 and ME.
730 */
get_DNS_Registry_9X(char ** outptr)731 static int get_DNS_Registry_9X(char **outptr)
732 {
733 HKEY hKey_VxD_MStcp;
734 int gotString;
735 int res;
736
737 *outptr = NULL;
738
739 res = RegOpenKeyExA(HKEY_LOCAL_MACHINE, WIN_NS_9X, 0, KEY_READ,
740 &hKey_VxD_MStcp);
741 if (res != ERROR_SUCCESS)
742 return 0;
743
744 gotString = get_REG_SZ_9X(hKey_VxD_MStcp, NAMESERVER, outptr);
745 RegCloseKey(hKey_VxD_MStcp);
746
747 if (!gotString || !*outptr)
748 return 0;
749
750 return 1;
751 }
752
753 /*
754 * get_DNS_Registry_NT()
755 *
756 * Functionally identical to get_DNS_Registry()
757 *
758 * Refs: Microsoft Knowledge Base articles KB120642 and KB314053.
759 *
760 * Implementation supports Windows NT 3.5 and newer.
761 */
get_DNS_Registry_NT(char ** outptr)762 static int get_DNS_Registry_NT(char **outptr)
763 {
764 HKEY hKey_Interfaces = NULL;
765 HKEY hKey_Tcpip_Parameters;
766 int gotString;
767 int res;
768
769 *outptr = NULL;
770
771 res = RegOpenKeyExA(HKEY_LOCAL_MACHINE, WIN_NS_NT_KEY, 0, KEY_READ,
772 &hKey_Tcpip_Parameters);
773 if (res != ERROR_SUCCESS)
774 return 0;
775
776 /*
777 ** Global DNS settings override adapter specific parameters when both
778 ** are set. Additionally static DNS settings override DHCP-configured
779 ** parameters when both are set.
780 */
781
782 /* Global DNS static parameters */
783 gotString = get_REG_SZ(hKey_Tcpip_Parameters, NAMESERVER, outptr);
784 if (gotString)
785 goto done;
786
787 /* Global DNS DHCP-configured parameters */
788 gotString = get_REG_SZ(hKey_Tcpip_Parameters, DHCPNAMESERVER, outptr);
789 if (gotString)
790 goto done;
791
792 /* Try adapter specific parameters */
793 res = RegOpenKeyExA(hKey_Tcpip_Parameters, "Interfaces", 0,
794 KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS,
795 &hKey_Interfaces);
796 if (res != ERROR_SUCCESS)
797 {
798 hKey_Interfaces = NULL;
799 goto done;
800 }
801
802 /* Adapter specific DNS static parameters */
803 gotString = get_enum_REG_SZ(hKey_Interfaces, NAMESERVER, outptr);
804 if (gotString)
805 goto done;
806
807 /* Adapter specific DNS DHCP-configured parameters */
808 gotString = get_enum_REG_SZ(hKey_Interfaces, DHCPNAMESERVER, outptr);
809
810 done:
811 if (hKey_Interfaces)
812 RegCloseKey(hKey_Interfaces);
813
814 RegCloseKey(hKey_Tcpip_Parameters);
815
816 if (!gotString || !*outptr)
817 return 0;
818
819 return 1;
820 }
821
822 /*
823 * get_DNS_Registry()
824 *
825 * Locates DNS info in the registry. When located, this returns a pointer
826 * in *outptr to a newly allocated memory area holding a null-terminated
827 * string with a space or comma seperated list of DNS IP addresses.
828 *
829 * Returns 0 and nullifies *outptr upon inability to return DNSes string.
830 *
831 * Returns 1 and sets *outptr when returning a dynamically allocated string.
832 */
get_DNS_Registry(char ** outptr)833 static int get_DNS_Registry(char **outptr)
834 {
835 win_platform platform;
836 int gotString = 0;
837
838 *outptr = NULL;
839
840 platform = ares__getplatform();
841
842 if (platform == WIN_NT)
843 gotString = get_DNS_Registry_NT(outptr);
844 else if (platform == WIN_9X)
845 gotString = get_DNS_Registry_9X(outptr);
846
847 if (!gotString)
848 return 0;
849
850 return 1;
851 }
852
commanjoin(char ** dst,const char * const src,const size_t len)853 static void commanjoin(char** dst, const char* const src, const size_t len)
854 {
855 char *newbuf;
856 size_t newsize;
857
858 /* 1 for terminating 0 and 2 for , and terminating 0 */
859 newsize = len + (*dst ? (strlen(*dst) + 2) : 1);
860 newbuf = ares_realloc(*dst, newsize);
861 if (!newbuf)
862 return;
863 if (*dst == NULL)
864 *newbuf = '\0';
865 *dst = newbuf;
866 if (strlen(*dst) != 0)
867 strcat(*dst, ",");
868 strncat(*dst, src, len);
869 }
870
871 /*
872 * commajoin()
873 *
874 * RTF code.
875 */
commajoin(char ** dst,const char * src)876 static void commajoin(char **dst, const char *src)
877 {
878 commanjoin(dst, src, strlen(src));
879 }
880
881 /*
882 * get_DNS_NetworkParams()
883 *
884 * Locates DNS info using GetNetworkParams() function from the Internet
885 * Protocol Helper (IP Helper) API. When located, this returns a pointer
886 * in *outptr to a newly allocated memory area holding a null-terminated
887 * string with a space or comma seperated list of DNS IP addresses.
888 *
889 * Returns 0 and nullifies *outptr upon inability to return DNSes string.
890 *
891 * Returns 1 and sets *outptr when returning a dynamically allocated string.
892 *
893 * Implementation supports Windows 98 and newer.
894 *
895 * Note: Ancient PSDK required in order to build a W98 target.
896 */
get_DNS_NetworkParams(char ** outptr)897 static int get_DNS_NetworkParams(char **outptr)
898 {
899 FIXED_INFO *fi, *newfi;
900 struct ares_addr namesrvr;
901 char *txtaddr;
902 IP_ADDR_STRING *ipAddr;
903 int res;
904 DWORD size = sizeof (*fi);
905
906 *outptr = NULL;
907
908 /* Verify run-time availability of GetNetworkParams() */
909 if (ares_fpGetNetworkParams == ZERO_NULL)
910 return 0;
911
912 fi = ares_malloc(size);
913 if (!fi)
914 return 0;
915
916 res = (*ares_fpGetNetworkParams) (fi, &size);
917 if ((res != ERROR_BUFFER_OVERFLOW) && (res != ERROR_SUCCESS))
918 goto done;
919
920 newfi = ares_realloc(fi, size);
921 if (!newfi)
922 goto done;
923
924 fi = newfi;
925 res = (*ares_fpGetNetworkParams) (fi, &size);
926 if (res != ERROR_SUCCESS)
927 goto done;
928
929 for (ipAddr = &fi->DnsServerList; ipAddr; ipAddr = ipAddr->Next)
930 {
931 txtaddr = &ipAddr->IpAddress.String[0];
932
933 /* Validate converting textual address to binary format. */
934 if (ares_inet_pton(AF_INET, txtaddr, &namesrvr.addrV4) == 1)
935 {
936 if ((namesrvr.addrV4.S_un.S_addr == INADDR_ANY) ||
937 (namesrvr.addrV4.S_un.S_addr == INADDR_NONE))
938 continue;
939 }
940 else if (ares_inet_pton(AF_INET6, txtaddr, &namesrvr.addrV6) == 1)
941 {
942 if (memcmp(&namesrvr.addrV6, &ares_in6addr_any,
943 sizeof(namesrvr.addrV6)) == 0)
944 continue;
945 }
946 else
947 continue;
948
949 commajoin(outptr, txtaddr);
950
951 if (!*outptr)
952 break;
953 }
954
955 done:
956 if (fi)
957 ares_free(fi);
958
959 if (!*outptr)
960 return 0;
961
962 return 1;
963 }
964
ares_IsWindowsVistaOrGreater(void)965 static BOOL ares_IsWindowsVistaOrGreater(void)
966 {
967 OSVERSIONINFO vinfo;
968 memset(&vinfo, 0, sizeof(vinfo));
969 vinfo.dwOSVersionInfoSize = sizeof(vinfo);
970 #ifdef _MSC_VER
971 #pragma warning(push)
972 #pragma warning(disable:4996) /* warning C4996: 'GetVersionExW': was declared deprecated */
973 #endif
974 if (!GetVersionEx(&vinfo) || vinfo.dwMajorVersion < 6)
975 return FALSE;
976 return TRUE;
977 #ifdef _MSC_VER
978 #pragma warning(pop)
979 #endif
980 }
981
982 /* A structure to hold the string form of IPv4 and IPv6 addresses so we can
983 * sort them by a metric.
984 */
985 typedef struct
986 {
987 /* The metric we sort them by. */
988 ULONG metric;
989
990 /* Original index of the item, used as a secondary sort parameter to make
991 * qsort() stable if the metrics are equal */
992 size_t orig_idx;
993
994 /* Room enough for the string form of any IPv4 or IPv6 address that
995 * ares_inet_ntop() will create. Based on the existing c-ares practice.
996 */
997 char text[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")];
998 } Address;
999
1000 /* Sort Address values \a left and \a right by metric, returning the usual
1001 * indicators for qsort().
1002 */
compareAddresses(const void * arg1,const void * arg2)1003 static int compareAddresses(const void *arg1,
1004 const void *arg2)
1005 {
1006 const Address * const left = arg1;
1007 const Address * const right = arg2;
1008 /* Lower metric the more preferred */
1009 if(left->metric < right->metric) return -1;
1010 if(left->metric > right->metric) return 1;
1011 /* If metrics are equal, lower original index more preferred */
1012 if(left->orig_idx < right->orig_idx) return -1;
1013 if(left->orig_idx > right->orig_idx) return 1;
1014 return 0;
1015 }
1016
1017 /* There can be multiple routes to "the Internet". And there can be different
1018 * DNS servers associated with each of the interfaces that offer those routes.
1019 * We have to assume that any DNS server can serve any request. But, some DNS
1020 * servers may only respond if requested over their associated interface. But
1021 * we also want to use "the preferred route to the Internet" whenever possible
1022 * (and not use DNS servers on a non-preferred route even by forcing request
1023 * to go out on the associated non-preferred interface). i.e. We want to use
1024 * the DNS servers associated with the same interface that we would use to
1025 * make a general request to anything else.
1026 *
1027 * But, Windows won't sort the DNS servers by the metrics associated with the
1028 * routes and interfaces _even_ though it obviously sends IP packets based on
1029 * those same routes and metrics. So, we must do it ourselves.
1030 *
1031 * So, we sort the DNS servers by the same metric values used to determine how
1032 * an outgoing IP packet will go, thus effectively using the DNS servers
1033 * associated with the interface that the DNS requests themselves will
1034 * travel. This gives us optimal routing and avoids issues where DNS servers
1035 * won't respond to requests that don't arrive via some specific subnetwork
1036 * (and thus some specific interface).
1037 *
1038 * This function computes the metric we use to sort. On the interface
1039 * identified by \a luid, it determines the best route to \a dest and combines
1040 * that route's metric with \a interfaceMetric to compute a metric for the
1041 * destination address on that interface. This metric can be used as a weight
1042 * to sort the DNS server addresses associated with each interface (lower is
1043 * better).
1044 *
1045 * Note that by restricting the route search to the specific interface with
1046 * which the DNS servers are associated, this function asks the question "What
1047 * is the metric for sending IP packets to this DNS server?" which allows us
1048 * to sort the DNS servers correctly.
1049 */
getBestRouteMetric(IF_LUID * const luid,const SOCKADDR_INET * const dest,const ULONG interfaceMetric)1050 static ULONG getBestRouteMetric(IF_LUID * const luid, /* Can't be const :( */
1051 const SOCKADDR_INET * const dest,
1052 const ULONG interfaceMetric)
1053 {
1054 /* On this interface, get the best route to that destination. */
1055 MIB_IPFORWARD_ROW2 row;
1056 SOCKADDR_INET ignored;
1057 if(!ares_fpGetBestRoute2 ||
1058 ares_fpGetBestRoute2(/* The interface to use. The index is ignored since we are
1059 * passing a LUID.
1060 */
1061 luid, 0,
1062 /* No specific source address. */
1063 NULL,
1064 /* Our destination address. */
1065 dest,
1066 /* No options. */
1067 0,
1068 /* The route row. */
1069 &row,
1070 /* The best source address, which we don't need. */
1071 &ignored) != NO_ERROR
1072 /* If the metric is "unused" (-1) or too large for us to add the two
1073 * metrics, use the worst possible, thus sorting this last.
1074 */
1075 || row.Metric == (ULONG)-1
1076 || row.Metric > ((ULONG)-1) - interfaceMetric) {
1077 /* Return the worst possible metric. */
1078 return (ULONG)-1;
1079 }
1080
1081 /* Return the metric value from that row, plus the interface metric.
1082 *
1083 * See
1084 * http://msdn.microsoft.com/en-us/library/windows/desktop/aa814494(v=vs.85).aspx
1085 * which describes the combination as a "sum".
1086 */
1087 return row.Metric + interfaceMetric;
1088 }
1089
1090 /*
1091 * get_DNS_AdaptersAddresses()
1092 *
1093 * Locates DNS info using GetAdaptersAddresses() function from the Internet
1094 * Protocol Helper (IP Helper) API. When located, this returns a pointer
1095 * in *outptr to a newly allocated memory area holding a null-terminated
1096 * string with a space or comma seperated list of DNS IP addresses.
1097 *
1098 * Returns 0 and nullifies *outptr upon inability to return DNSes string.
1099 *
1100 * Returns 1 and sets *outptr when returning a dynamically allocated string.
1101 *
1102 * Implementation supports Windows XP and newer.
1103 */
1104 #define IPAA_INITIAL_BUF_SZ 15 * 1024
1105 #define IPAA_MAX_TRIES 3
get_DNS_AdaptersAddresses(char ** outptr)1106 static int get_DNS_AdaptersAddresses(char **outptr)
1107 {
1108 IP_ADAPTER_DNS_SERVER_ADDRESS *ipaDNSAddr;
1109 IP_ADAPTER_ADDRESSES *ipaa, *newipaa, *ipaaEntry;
1110 ULONG ReqBufsz = IPAA_INITIAL_BUF_SZ;
1111 ULONG Bufsz = IPAA_INITIAL_BUF_SZ;
1112 ULONG AddrFlags = 0;
1113 int trying = IPAA_MAX_TRIES;
1114 int res;
1115
1116 /* The capacity of addresses, in elements. */
1117 size_t addressesSize;
1118 /* The number of elements in addresses. */
1119 size_t addressesIndex = 0;
1120 /* The addresses we will sort. */
1121 Address *addresses;
1122
1123 union {
1124 struct sockaddr *sa;
1125 struct sockaddr_in *sa4;
1126 struct sockaddr_in6 *sa6;
1127 } namesrvr;
1128
1129 *outptr = NULL;
1130
1131 /* Verify run-time availability of GetAdaptersAddresses() */
1132 if (ares_fpGetAdaptersAddresses == ZERO_NULL)
1133 return 0;
1134
1135 ipaa = ares_malloc(Bufsz);
1136 if (!ipaa)
1137 return 0;
1138
1139 /* Start with enough room for a few DNS server addresses and we'll grow it
1140 * as we encounter more.
1141 */
1142 addressesSize = 4;
1143 addresses = (Address*)ares_malloc(sizeof(Address) * addressesSize);
1144 if(addresses == NULL) {
1145 /* We need room for at least some addresses to function. */
1146 ares_free(ipaa);
1147 return 0;
1148 }
1149
1150 /* Usually this call suceeds with initial buffer size */
1151 res = (*ares_fpGetAdaptersAddresses) (AF_UNSPEC, AddrFlags, NULL,
1152 ipaa, &ReqBufsz);
1153 if ((res != ERROR_BUFFER_OVERFLOW) && (res != ERROR_SUCCESS))
1154 goto done;
1155
1156 while ((res == ERROR_BUFFER_OVERFLOW) && (--trying))
1157 {
1158 if (Bufsz < ReqBufsz)
1159 {
1160 newipaa = ares_realloc(ipaa, ReqBufsz);
1161 if (!newipaa)
1162 goto done;
1163 Bufsz = ReqBufsz;
1164 ipaa = newipaa;
1165 }
1166 res = (*ares_fpGetAdaptersAddresses) (AF_UNSPEC, AddrFlags, NULL,
1167 ipaa, &ReqBufsz);
1168 if (res == ERROR_SUCCESS)
1169 break;
1170 }
1171 if (res != ERROR_SUCCESS)
1172 goto done;
1173
1174 for (ipaaEntry = ipaa; ipaaEntry; ipaaEntry = ipaaEntry->Next)
1175 {
1176 if(ipaaEntry->OperStatus != IfOperStatusUp)
1177 continue;
1178
1179 /* For each interface, find any associated DNS servers as IPv4 or IPv6
1180 * addresses. For each found address, find the best route to that DNS
1181 * server address _on_ _that_ _interface_ (at this moment in time) and
1182 * compute the resulting total metric, just as Windows routing will do.
1183 * Then, sort all the addresses found by the metric.
1184 */
1185 for (ipaDNSAddr = ipaaEntry->FirstDnsServerAddress;
1186 ipaDNSAddr;
1187 ipaDNSAddr = ipaDNSAddr->Next)
1188 {
1189 namesrvr.sa = ipaDNSAddr->Address.lpSockaddr;
1190
1191 if (namesrvr.sa->sa_family == AF_INET)
1192 {
1193 if ((namesrvr.sa4->sin_addr.S_un.S_addr == INADDR_ANY) ||
1194 (namesrvr.sa4->sin_addr.S_un.S_addr == INADDR_NONE))
1195 continue;
1196
1197 /* Allocate room for another address, if necessary, else skip. */
1198 if(addressesIndex == addressesSize) {
1199 const size_t newSize = addressesSize + 4;
1200 Address * const newMem =
1201 (Address*)ares_realloc(addresses, sizeof(Address) * newSize);
1202 if(newMem == NULL) {
1203 continue;
1204 }
1205 addresses = newMem;
1206 addressesSize = newSize;
1207 }
1208
1209 /* Vista required for Luid or Ipv4Metric */
1210 if (ares_IsWindowsVistaOrGreater())
1211 {
1212 /* Save the address as the next element in addresses. */
1213 addresses[addressesIndex].metric =
1214 getBestRouteMetric(&ipaaEntry->Luid,
1215 (SOCKADDR_INET*)(namesrvr.sa),
1216 ipaaEntry->Ipv4Metric);
1217 }
1218 else
1219 {
1220 addresses[addressesIndex].metric = (ULONG)-1;
1221 }
1222
1223 /* Record insertion index to make qsort stable */
1224 addresses[addressesIndex].orig_idx = addressesIndex;
1225
1226 if (! ares_inet_ntop(AF_INET, &namesrvr.sa4->sin_addr,
1227 addresses[addressesIndex].text,
1228 sizeof(addresses[0].text))) {
1229 continue;
1230 }
1231 ++addressesIndex;
1232 }
1233 else if (namesrvr.sa->sa_family == AF_INET6)
1234 {
1235 if (memcmp(&namesrvr.sa6->sin6_addr, &ares_in6addr_any,
1236 sizeof(namesrvr.sa6->sin6_addr)) == 0)
1237 continue;
1238
1239 /* Allocate room for another address, if necessary, else skip. */
1240 if(addressesIndex == addressesSize) {
1241 const size_t newSize = addressesSize + 4;
1242 Address * const newMem =
1243 (Address*)ares_realloc(addresses, sizeof(Address) * newSize);
1244 if(newMem == NULL) {
1245 continue;
1246 }
1247 addresses = newMem;
1248 addressesSize = newSize;
1249 }
1250
1251 /* Vista required for Luid or Ipv4Metric */
1252 if (ares_IsWindowsVistaOrGreater())
1253 {
1254 /* Save the address as the next element in addresses. */
1255 addresses[addressesIndex].metric =
1256 getBestRouteMetric(&ipaaEntry->Luid,
1257 (SOCKADDR_INET*)(namesrvr.sa),
1258 ipaaEntry->Ipv6Metric);
1259 }
1260 else
1261 {
1262 addresses[addressesIndex].metric = (ULONG)-1;
1263 }
1264
1265 /* Record insertion index to make qsort stable */
1266 addresses[addressesIndex].orig_idx = addressesIndex;
1267
1268 if (! ares_inet_ntop(AF_INET6, &namesrvr.sa6->sin6_addr,
1269 addresses[addressesIndex].text,
1270 sizeof(addresses[0].text))) {
1271 continue;
1272 }
1273 ++addressesIndex;
1274 }
1275 else {
1276 /* Skip non-IPv4/IPv6 addresses completely. */
1277 continue;
1278 }
1279 }
1280 }
1281
1282 /* Sort all of the textual addresses by their metric (and original index if
1283 * metrics are equal). */
1284 qsort(addresses, addressesIndex, sizeof(*addresses), compareAddresses);
1285
1286 /* Join them all into a single string, removing duplicates. */
1287 {
1288 size_t i;
1289 for(i = 0; i < addressesIndex; ++i) {
1290 size_t j;
1291 /* Look for this address text appearing previously in the results. */
1292 for(j = 0; j < i; ++j) {
1293 if(strcmp(addresses[j].text, addresses[i].text) == 0) {
1294 break;
1295 }
1296 }
1297 /* Iff we didn't emit this address already, emit it now. */
1298 if(j == i) {
1299 /* Add that to outptr (if we can). */
1300 commajoin(outptr, addresses[i].text);
1301 }
1302 }
1303 }
1304
1305 done:
1306 ares_free(addresses);
1307
1308 if (ipaa)
1309 ares_free(ipaa);
1310
1311 if (!*outptr) {
1312 return 0;
1313 }
1314
1315 return 1;
1316 }
1317
1318 /*
1319 * get_DNS_Windows()
1320 *
1321 * Locates DNS info from Windows employing most suitable methods available at
1322 * run-time no matter which Windows version it is. When located, this returns
1323 * a pointer in *outptr to a newly allocated memory area holding a string with
1324 * a space or comma seperated list of DNS IP addresses, null-terminated.
1325 *
1326 * Returns 0 and nullifies *outptr upon inability to return DNSes string.
1327 *
1328 * Returns 1 and sets *outptr when returning a dynamically allocated string.
1329 *
1330 * Implementation supports Windows 95 and newer.
1331 */
get_DNS_Windows(char ** outptr)1332 static int get_DNS_Windows(char **outptr)
1333 {
1334 /* Try using IP helper API GetAdaptersAddresses(). IPv4 + IPv6, also sorts
1335 * DNS servers by interface route metrics to try to use the best DNS server. */
1336 if (get_DNS_AdaptersAddresses(outptr))
1337 return 1;
1338
1339 /* Try using IP helper API GetNetworkParams(). IPv4 only. */
1340 if (get_DNS_NetworkParams(outptr))
1341 return 1;
1342
1343 /* Fall-back to registry information */
1344 return get_DNS_Registry(outptr);
1345 }
1346
1347 /*
1348 * get_SuffixList_Windows()
1349 *
1350 * Reads the "DNS Suffix Search List" from registry and writes the list items
1351 * whitespace separated to outptr. If the Search List is empty, the
1352 * "Primary Dns Suffix" is written to outptr.
1353 *
1354 * Returns 0 and nullifies *outptr upon inability to return the suffix list.
1355 *
1356 * Returns 1 and sets *outptr when returning a dynamically allocated string.
1357 *
1358 * Implementation supports Windows Server 2003 and newer
1359 */
get_SuffixList_Windows(char ** outptr)1360 static int get_SuffixList_Windows(char **outptr)
1361 {
1362 HKEY hKey, hKeyEnum;
1363 char keyName[256];
1364 DWORD keyNameBuffSize;
1365 DWORD keyIdx = 0;
1366 char *p = NULL;
1367
1368 *outptr = NULL;
1369
1370 if (ares__getplatform() != WIN_NT)
1371 return 0;
1372
1373 /* 1. Global DNS Suffix Search List */
1374 if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, WIN_NS_NT_KEY, 0,
1375 KEY_READ, &hKey) == ERROR_SUCCESS)
1376 {
1377 get_REG_SZ(hKey, SEARCHLIST_KEY, outptr);
1378 if (get_REG_SZ(hKey, DOMAIN_KEY, &p))
1379 {
1380 commajoin(outptr, p);
1381 ares_free(p);
1382 p = NULL;
1383 }
1384 RegCloseKey(hKey);
1385 }
1386
1387 if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, WIN_NT_DNSCLIENT, 0,
1388 KEY_READ, &hKey) == ERROR_SUCCESS)
1389 {
1390 if (get_REG_SZ(hKey, SEARCHLIST_KEY, &p))
1391 {
1392 commajoin(outptr, p);
1393 ares_free(p);
1394 p = NULL;
1395 }
1396 RegCloseKey(hKey);
1397 }
1398
1399 /* 2. Connection Specific Search List composed of:
1400 * a. Primary DNS Suffix */
1401 if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, WIN_DNSCLIENT, 0,
1402 KEY_READ, &hKey) == ERROR_SUCCESS)
1403 {
1404 if (get_REG_SZ(hKey, PRIMARYDNSSUFFIX_KEY, &p))
1405 {
1406 commajoin(outptr, p);
1407 ares_free(p);
1408 p = NULL;
1409 }
1410 RegCloseKey(hKey);
1411 }
1412
1413 /* b. Interface SearchList, Domain, DhcpDomain */
1414 if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, WIN_NS_NT_KEY "\\" INTERFACES_KEY, 0,
1415 KEY_READ, &hKey) == ERROR_SUCCESS)
1416 {
1417 for(;;)
1418 {
1419 keyNameBuffSize = sizeof(keyName);
1420 if (RegEnumKeyExA(hKey, keyIdx++, keyName, &keyNameBuffSize,
1421 0, NULL, NULL, NULL)
1422 != ERROR_SUCCESS)
1423 break;
1424 if (RegOpenKeyExA(hKey, keyName, 0, KEY_QUERY_VALUE, &hKeyEnum)
1425 != ERROR_SUCCESS)
1426 continue;
1427 /* p can be comma separated (SearchList) */
1428 if (get_REG_SZ(hKeyEnum, SEARCHLIST_KEY, &p))
1429 {
1430 commajoin(outptr, p);
1431 ares_free(p);
1432 p = NULL;
1433 }
1434 if (get_REG_SZ(hKeyEnum, DOMAIN_KEY, &p))
1435 {
1436 commajoin(outptr, p);
1437 ares_free(p);
1438 p = NULL;
1439 }
1440 if (get_REG_SZ(hKeyEnum, DHCPDOMAIN_KEY, &p))
1441 {
1442 commajoin(outptr, p);
1443 ares_free(p);
1444 p = NULL;
1445 }
1446 RegCloseKey(hKeyEnum);
1447 }
1448 RegCloseKey(hKey);
1449 }
1450
1451 return *outptr != NULL;
1452 }
1453
1454 #endif
1455
init_by_resolv_conf(ares_channel channel)1456 static int init_by_resolv_conf(ares_channel channel)
1457 {
1458 #if !defined(ANDROID) && !defined(__ANDROID__) && !defined(WATT32) && \
1459 !defined(CARES_USE_LIBRESOLV)
1460 char *line = NULL;
1461 #endif
1462 int status = -1, nservers = 0, nsort = 0;
1463 struct server_state *servers = NULL;
1464 struct apattern *sortlist = NULL;
1465
1466 #ifdef WIN32
1467
1468 if (channel->nservers > -1) /* don't override ARES_OPT_SERVER */
1469 return ARES_SUCCESS;
1470
1471 if (get_DNS_Windows(&line))
1472 {
1473 status = config_nameserver(&servers, &nservers, line);
1474 ares_free(line);
1475 }
1476
1477 if (channel->ndomains == -1 && get_SuffixList_Windows(&line))
1478 {
1479 status = set_search(channel, line);
1480 ares_free(line);
1481 }
1482
1483 if (status == ARES_SUCCESS)
1484 status = ARES_EOF;
1485 else
1486 /* Catch the case when all the above checks fail (which happens when there
1487 is no network card or the cable is unplugged) */
1488 status = ARES_EFILE;
1489
1490 #elif defined(__riscos__)
1491
1492 /* Under RISC OS, name servers are listed in the
1493 system variable Inet$Resolvers, space separated. */
1494
1495 line = getenv("Inet$Resolvers");
1496 status = ARES_EOF;
1497 if (line) {
1498 char *resolvers = ares_strdup(line), *pos, *space;
1499
1500 if (!resolvers)
1501 return ARES_ENOMEM;
1502
1503 pos = resolvers;
1504 do {
1505 space = strchr(pos, ' ');
1506 if (space)
1507 *space = '\0';
1508 status = config_nameserver(&servers, &nservers, pos);
1509 if (status != ARES_SUCCESS)
1510 break;
1511 pos = space + 1;
1512 } while (space);
1513
1514 if (status == ARES_SUCCESS)
1515 status = ARES_EOF;
1516
1517 ares_free(resolvers);
1518 }
1519
1520 #elif defined(WATT32)
1521 int i;
1522
1523 sock_init();
1524 for (i = 0; def_nameservers[i]; i++)
1525 ;
1526 if (i == 0)
1527 return ARES_SUCCESS; /* use localhost DNS server */
1528
1529 nservers = i;
1530 servers = ares_malloc(sizeof(struct server_state));
1531 if (!servers)
1532 return ARES_ENOMEM;
1533 memset(servers, 0, sizeof(struct server_state));
1534
1535 for (i = 0; def_nameservers[i]; i++)
1536 {
1537 servers[i].addr.addrV4.s_addr = htonl(def_nameservers[i]);
1538 servers[i].addr.family = AF_INET;
1539 servers[i].addr.udp_port = 0;
1540 servers[i].addr.tcp_port = 0;
1541 }
1542 status = ARES_EOF;
1543
1544 #elif defined(ANDROID) || defined(__ANDROID__)
1545 unsigned int i;
1546 char propname[PROP_NAME_MAX];
1547 char propvalue[PROP_VALUE_MAX]="";
1548 char **dns_servers;
1549 char *domains;
1550 size_t num_servers;
1551
1552 /* Use the Android connectivity manager to get a list
1553 * of DNS servers. As of Android 8 (Oreo) net.dns#
1554 * system properties are no longer available. Google claims this
1555 * improves privacy. Apps now need the ACCESS_NETWORK_STATE
1556 * permission and must use the ConnectivityManager which
1557 * is Java only. */
1558 dns_servers = ares_get_android_server_list(MAX_DNS_PROPERTIES, &num_servers);
1559 if (dns_servers != NULL)
1560 {
1561 for (i = 0; i < num_servers; i++)
1562 {
1563 status = config_nameserver(&servers, &nservers, dns_servers[i]);
1564 if (status != ARES_SUCCESS)
1565 break;
1566 status = ARES_EOF;
1567 }
1568 for (i = 0; i < num_servers; i++)
1569 {
1570 ares_free(dns_servers[i]);
1571 }
1572 ares_free(dns_servers);
1573 }
1574 if (channel->ndomains == -1)
1575 {
1576 domains = ares_get_android_search_domains_list();
1577 set_search(channel, domains);
1578 ares_free(domains);
1579 }
1580
1581 # ifdef HAVE___SYSTEM_PROPERTY_GET
1582 /* Old way using the system property still in place as
1583 * a fallback. Older android versions can still use this.
1584 * it's possible for older apps not not have added the new
1585 * permission and we want to try to avoid breaking those.
1586 *
1587 * We'll only run this if we don't have any dns servers
1588 * because this will get the same ones (if it works). */
1589 if (status != ARES_EOF) {
1590 for (i = 1; i <= MAX_DNS_PROPERTIES; i++) {
1591 snprintf(propname, sizeof(propname), "%s%u", DNS_PROP_NAME_PREFIX, i);
1592 if (__system_property_get(propname, propvalue) < 1) {
1593 status = ARES_EOF;
1594 break;
1595 }
1596
1597 status = config_nameserver(&servers, &nservers, propvalue);
1598 if (status != ARES_SUCCESS)
1599 break;
1600 status = ARES_EOF;
1601 }
1602 }
1603 # endif /* HAVE___SYSTEM_PROPERTY_GET */
1604 #elif defined(CARES_USE_LIBRESOLV)
1605 struct __res_state res;
1606 memset(&res, 0, sizeof(res));
1607 int result = res_ninit(&res);
1608 if (result == 0 && (res.options & RES_INIT)) {
1609 status = ARES_EOF;
1610
1611 if (channel->nservers == -1) {
1612 union res_sockaddr_union addr[MAXNS];
1613 int nscount = res_getservers(&res, addr, MAXNS);
1614 for (int i = 0; i < nscount; ++i) {
1615 char str[INET6_ADDRSTRLEN];
1616 int config_status;
1617 sa_family_t family = addr[i].sin.sin_family;
1618 if (family == AF_INET) {
1619 ares_inet_ntop(family, &addr[i].sin.sin_addr, str, sizeof(str));
1620 } else if (family == AF_INET6) {
1621 ares_inet_ntop(family, &addr[i].sin6.sin6_addr, str, sizeof(str));
1622 } else {
1623 continue;
1624 }
1625
1626 config_status = config_nameserver(&servers, &nservers, str);
1627 if (config_status != ARES_SUCCESS) {
1628 status = config_status;
1629 break;
1630 }
1631 }
1632 }
1633 if (channel->ndomains == -1) {
1634 int entries = 0;
1635 while ((entries < MAXDNSRCH) && res.dnsrch[entries])
1636 entries++;
1637
1638 channel->domains = ares_malloc(entries * sizeof(char *));
1639 if (!channel->domains) {
1640 status = ARES_ENOMEM;
1641 } else {
1642 channel->ndomains = entries;
1643 for (int i = 0; i < channel->ndomains; ++i) {
1644 channel->domains[i] = ares_strdup(res.dnsrch[i]);
1645 if (!channel->domains[i])
1646 status = ARES_ENOMEM;
1647 }
1648 }
1649 }
1650 if (channel->ndots == -1)
1651 channel->ndots = res.ndots;
1652 if (channel->tries == -1)
1653 channel->tries = res.retry;
1654 if (channel->rotate == -1)
1655 channel->rotate = res.options & RES_ROTATE;
1656 if (channel->timeout == -1)
1657 channel->timeout = res.retrans * 1000;
1658
1659 res_ndestroy(&res);
1660 }
1661 #else
1662 {
1663 char *p;
1664 FILE *fp;
1665 size_t linesize;
1666 int error;
1667 int update_domains;
1668 const char *resolvconf_path;
1669
1670 /* Don't read resolv.conf and friends if we don't have to */
1671 if (ARES_CONFIG_CHECK(channel))
1672 return ARES_SUCCESS;
1673
1674 /* Only update search domains if they're not already specified */
1675 update_domains = (channel->ndomains == -1);
1676
1677 /* Support path for resolvconf filename set by ares_init_options */
1678 if(channel->resolvconf_path) {
1679 resolvconf_path = channel->resolvconf_path;
1680 } else {
1681 resolvconf_path = PATH_RESOLV_CONF;
1682 }
1683
1684 fp = fopen(resolvconf_path, "r");
1685 if (fp) {
1686 while ((status = ares__read_line(fp, &line, &linesize)) == ARES_SUCCESS)
1687 {
1688 if ((p = try_config(line, "domain", ';')) && update_domains)
1689 status = config_domain(channel, p);
1690 else if ((p = try_config(line, "lookup", ';')) && !channel->lookups)
1691 status = config_lookup(channel, p, "bind", NULL, "file");
1692 else if ((p = try_config(line, "search", ';')) && update_domains)
1693 status = set_search(channel, p);
1694 else if ((p = try_config(line, "nameserver", ';')) &&
1695 channel->nservers == -1)
1696 status = config_nameserver(&servers, &nservers, p);
1697 else if ((p = try_config(line, "sortlist", ';')) &&
1698 channel->nsort == -1)
1699 status = config_sortlist(&sortlist, &nsort, p);
1700 else if ((p = try_config(line, "options", ';')))
1701 status = set_options(channel, p);
1702 else
1703 status = ARES_SUCCESS;
1704 if (status != ARES_SUCCESS)
1705 break;
1706 }
1707 fclose(fp);
1708 }
1709 else {
1710 error = ERRNO;
1711 switch(error) {
1712 case ENOENT:
1713 case ESRCH:
1714 status = ARES_EOF;
1715 break;
1716 default:
1717 DEBUGF(fprintf(stderr, "fopen() failed with error: %d %s\n",
1718 error, strerror(error)));
1719 DEBUGF(fprintf(stderr, "Error opening file: %s\n", PATH_RESOLV_CONF));
1720 status = ARES_EFILE;
1721 }
1722 }
1723
1724 if ((status == ARES_EOF) && (!channel->lookups)) {
1725 /* Many systems (Solaris, Linux, BSD's) use nsswitch.conf */
1726 fp = fopen("/etc/nsswitch.conf", "r");
1727 if (fp) {
1728 while ((status = ares__read_line(fp, &line, &linesize)) ==
1729 ARES_SUCCESS)
1730 {
1731 if ((p = try_config(line, "hosts:", '\0')) && !channel->lookups)
1732 (void)config_lookup(channel, p, "dns", "resolve", "files");
1733 }
1734 fclose(fp);
1735 }
1736 else {
1737 error = ERRNO;
1738 switch(error) {
1739 case ENOENT:
1740 case ESRCH:
1741 break;
1742 default:
1743 DEBUGF(fprintf(stderr, "fopen() failed with error: %d %s\n",
1744 error, strerror(error)));
1745 DEBUGF(fprintf(stderr, "Error opening file: %s\n",
1746 "/etc/nsswitch.conf"));
1747 }
1748
1749 /* ignore error, maybe we will get luck in next if clause */
1750 status = ARES_EOF;
1751 }
1752 }
1753
1754 if ((status == ARES_EOF) && (!channel->lookups)) {
1755 /* Linux / GNU libc 2.x and possibly others have host.conf */
1756 fp = fopen("/etc/host.conf", "r");
1757 if (fp) {
1758 while ((status = ares__read_line(fp, &line, &linesize)) ==
1759 ARES_SUCCESS)
1760 {
1761 if ((p = try_config(line, "order", '\0')) && !channel->lookups)
1762 /* ignore errors */
1763 (void)config_lookup(channel, p, "bind", NULL, "hosts");
1764 }
1765 fclose(fp);
1766 }
1767 else {
1768 error = ERRNO;
1769 switch(error) {
1770 case ENOENT:
1771 case ESRCH:
1772 break;
1773 default:
1774 DEBUGF(fprintf(stderr, "fopen() failed with error: %d %s\n",
1775 error, strerror(error)));
1776 DEBUGF(fprintf(stderr, "Error opening file: %s\n",
1777 "/etc/host.conf"));
1778 }
1779
1780 /* ignore error, maybe we will get luck in next if clause */
1781 status = ARES_EOF;
1782 }
1783 }
1784
1785 if ((status == ARES_EOF) && (!channel->lookups)) {
1786 /* Tru64 uses /etc/svc.conf */
1787 fp = fopen("/etc/svc.conf", "r");
1788 if (fp) {
1789 while ((status = ares__read_line(fp, &line, &linesize)) ==
1790 ARES_SUCCESS)
1791 {
1792 if ((p = try_config(line, "hosts=", '\0')) && !channel->lookups)
1793 /* ignore errors */
1794 (void)config_lookup(channel, p, "bind", NULL, "local");
1795 }
1796 fclose(fp);
1797 }
1798 else {
1799 error = ERRNO;
1800 switch(error) {
1801 case ENOENT:
1802 case ESRCH:
1803 break;
1804 default:
1805 DEBUGF(fprintf(stderr, "fopen() failed with error: %d %s\n",
1806 error, strerror(error)));
1807 DEBUGF(fprintf(stderr, "Error opening file: %s\n", "/etc/svc.conf"));
1808 }
1809
1810 /* ignore error, default value will be chosen for `channel->lookups` */
1811 status = ARES_EOF;
1812 }
1813 }
1814
1815 if(line)
1816 ares_free(line);
1817 }
1818
1819 #endif
1820
1821 /* Handle errors. */
1822 if (status != ARES_EOF)
1823 {
1824 if (servers != NULL)
1825 ares_free(servers);
1826 if (sortlist != NULL)
1827 ares_free(sortlist);
1828 return status;
1829 }
1830
1831 /* If we got any name server entries, fill them in. */
1832 if (servers)
1833 {
1834 channel->servers = servers;
1835 channel->nservers = nservers;
1836 }
1837
1838 /* If we got any sortlist entries, fill them in. */
1839 if (sortlist)
1840 {
1841 channel->sortlist = sortlist;
1842 channel->nsort = nsort;
1843 }
1844
1845 return ARES_SUCCESS;
1846 }
1847
init_by_defaults(ares_channel channel)1848 static int init_by_defaults(ares_channel channel)
1849 {
1850 char *hostname = NULL;
1851 int rc = ARES_SUCCESS;
1852 #ifdef HAVE_GETHOSTNAME
1853 char *dot;
1854 #endif
1855
1856 if (channel->flags == -1)
1857 channel->flags = 0;
1858 if (channel->timeout == -1)
1859 channel->timeout = DEFAULT_TIMEOUT;
1860 if (channel->tries == -1)
1861 channel->tries = DEFAULT_TRIES;
1862 if (channel->ndots == -1)
1863 channel->ndots = 1;
1864 if (channel->rotate == -1)
1865 channel->rotate = 0;
1866 if (channel->udp_port == -1)
1867 channel->udp_port = htons(NAMESERVER_PORT);
1868 if (channel->tcp_port == -1)
1869 channel->tcp_port = htons(NAMESERVER_PORT);
1870
1871 if (channel->ednspsz == -1)
1872 channel->ednspsz = EDNSPACKETSZ;
1873
1874 if (channel->nservers == -1) {
1875 /* If nobody specified servers, try a local named. */
1876 channel->servers = ares_malloc(sizeof(struct server_state));
1877 if (!channel->servers) {
1878 rc = ARES_ENOMEM;
1879 goto error;
1880 }
1881 channel->servers[0].addr.family = AF_INET;
1882 channel->servers[0].addr.addrV4.s_addr = htonl(INADDR_LOOPBACK);
1883 channel->servers[0].addr.udp_port = 0;
1884 channel->servers[0].addr.tcp_port = 0;
1885 channel->nservers = 1;
1886 }
1887
1888 #if defined(USE_WINSOCK)
1889 #define toolong(x) (x == -1) && (SOCKERRNO == WSAEFAULT)
1890 #elif defined(ENAMETOOLONG)
1891 #define toolong(x) (x == -1) && ((SOCKERRNO == ENAMETOOLONG) || \
1892 (SOCKERRNO == EINVAL))
1893 #else
1894 #define toolong(x) (x == -1) && (SOCKERRNO == EINVAL)
1895 #endif
1896
1897 if (channel->ndomains == -1) {
1898 /* Derive a default domain search list from the kernel hostname,
1899 * or set it to empty if the hostname isn't helpful.
1900 */
1901 #ifndef HAVE_GETHOSTNAME
1902 channel->ndomains = 0; /* default to none */
1903 #else
1904 GETHOSTNAME_TYPE_ARG2 lenv = 64;
1905 size_t len = 64;
1906 int res;
1907 channel->ndomains = 0; /* default to none */
1908
1909 hostname = ares_malloc(len);
1910 if(!hostname) {
1911 rc = ARES_ENOMEM;
1912 goto error;
1913 }
1914
1915 do {
1916 res = gethostname(hostname, lenv);
1917
1918 if(toolong(res)) {
1919 char *p;
1920 len *= 2;
1921 lenv *= 2;
1922 p = ares_realloc(hostname, len);
1923 if(!p) {
1924 rc = ARES_ENOMEM;
1925 goto error;
1926 }
1927 hostname = p;
1928 continue;
1929 }
1930 else if(res) {
1931 /* Lets not treat a gethostname failure as critical, since we
1932 * are ok if gethostname doesn't even exist */
1933 *hostname = '\0';
1934 break;
1935 }
1936
1937 } while (res != 0);
1938
1939 dot = strchr(hostname, '.');
1940 if (dot) {
1941 /* a dot was found */
1942 channel->domains = ares_malloc(sizeof(char *));
1943 if (!channel->domains) {
1944 rc = ARES_ENOMEM;
1945 goto error;
1946 }
1947 channel->domains[0] = ares_strdup(dot + 1);
1948 if (!channel->domains[0]) {
1949 rc = ARES_ENOMEM;
1950 goto error;
1951 }
1952 channel->ndomains = 1;
1953 }
1954 #endif
1955 }
1956
1957 if (channel->nsort == -1) {
1958 channel->sortlist = NULL;
1959 channel->nsort = 0;
1960 }
1961
1962 if (!channel->lookups) {
1963 channel->lookups = ares_strdup("fb");
1964 if (!channel->lookups)
1965 rc = ARES_ENOMEM;
1966 }
1967
1968 error:
1969 if(rc) {
1970 if(channel->servers) {
1971 ares_free(channel->servers);
1972 channel->servers = NULL;
1973 }
1974
1975 if(channel->domains && channel->domains[0])
1976 ares_free(channel->domains[0]);
1977 if(channel->domains) {
1978 ares_free(channel->domains);
1979 channel->domains = NULL;
1980 }
1981
1982 if(channel->lookups) {
1983 ares_free(channel->lookups);
1984 channel->lookups = NULL;
1985 }
1986
1987 if(channel->resolvconf_path) {
1988 ares_free(channel->resolvconf_path);
1989 channel->resolvconf_path = NULL;
1990 }
1991 }
1992
1993 if(hostname)
1994 ares_free(hostname);
1995
1996 return rc;
1997 }
1998
1999 #if !defined(WIN32) && !defined(WATT32) && \
2000 !defined(ANDROID) && !defined(__ANDROID__) && !defined(CARES_USE_LIBRESOLV)
config_domain(ares_channel channel,char * str)2001 static int config_domain(ares_channel channel, char *str)
2002 {
2003 char *q;
2004
2005 /* Set a single search domain. */
2006 q = str;
2007 while (*q && !ISSPACE(*q))
2008 q++;
2009 *q = '\0';
2010 return set_search(channel, str);
2011 }
2012
2013 #if defined(__INTEL_COMPILER) && (__INTEL_COMPILER == 910) && \
2014 defined(__OPTIMIZE__) && defined(__unix__) && defined(__i386__)
2015 /* workaround icc 9.1 optimizer issue */
2016 # define vqualifier volatile
2017 #else
2018 # define vqualifier
2019 #endif
2020
config_lookup(ares_channel channel,const char * str,const char * bindch,const char * altbindch,const char * filech)2021 static int config_lookup(ares_channel channel, const char *str,
2022 const char *bindch, const char *altbindch,
2023 const char *filech)
2024 {
2025 char lookups[3], *l;
2026 const char *vqualifier p;
2027
2028 if (altbindch == NULL)
2029 altbindch = bindch;
2030
2031 /* Set the lookup order. Only the first letter of each work
2032 * is relevant, and it has to be "b" for DNS or "f" for the
2033 * host file. Ignore everything else.
2034 */
2035 l = lookups;
2036 p = str;
2037 while (*p)
2038 {
2039 if ((*p == *bindch || *p == *altbindch || *p == *filech) && l < lookups + 2) {
2040 if (*p == *bindch || *p == *altbindch) *l++ = 'b';
2041 else *l++ = 'f';
2042 }
2043 while (*p && !ISSPACE(*p) && (*p != ','))
2044 p++;
2045 while (*p && (ISSPACE(*p) || (*p == ',')))
2046 p++;
2047 }
2048 *l = '\0';
2049 channel->lookups = ares_strdup(lookups);
2050 return (channel->lookups) ? ARES_SUCCESS : ARES_ENOMEM;
2051 }
2052 #endif /* !WIN32 & !WATT32 & !ANDROID & !__ANDROID__ & !CARES_USE_LIBRESOLV */
2053
2054 #ifndef WATT32
2055 /* Validate that the ip address matches the subnet (network base and network
2056 * mask) specified. Addresses are specified in standard Network Byte Order as
2057 * 16 bytes, and the netmask is 0 to 128 (bits).
2058 */
ares_ipv6_subnet_matches(const unsigned char netbase[16],unsigned char netmask,const unsigned char ipaddr[16])2059 static int ares_ipv6_subnet_matches(const unsigned char netbase[16],
2060 unsigned char netmask,
2061 const unsigned char ipaddr[16])
2062 {
2063 unsigned char mask[16] = { 0 };
2064 unsigned char i;
2065
2066 /* Misuse */
2067 if (netmask > 128)
2068 return 0;
2069
2070 /* Quickly set whole bytes */
2071 memset(mask, 0xFF, netmask / 8);
2072
2073 /* Set remaining bits */
2074 if(netmask % 8) {
2075 mask[netmask / 8] = (unsigned char)(0xff << (8 - (netmask % 8)));
2076 }
2077
2078 for (i=0; i<16; i++) {
2079 if ((netbase[i] & mask[i]) != (ipaddr[i] & mask[i]))
2080 return 0;
2081 }
2082
2083 return 1;
2084 }
2085
2086 /* Return true iff the IPv6 ipaddr is blacklisted. */
ares_ipv6_server_blacklisted(const unsigned char ipaddr[16])2087 static int ares_ipv6_server_blacklisted(const unsigned char ipaddr[16])
2088 {
2089 /* A list of blacklisted IPv6 subnets. */
2090 const struct {
2091 const unsigned char netbase[16];
2092 unsigned char netmask;
2093 } blacklist[] = {
2094 /* fec0::/10 was deprecated by [RFC3879] in September 2004. Formerly a
2095 * Site-Local scoped address prefix. These are never valid DNS servers,
2096 * but are known to be returned at least sometimes on Windows and Android.
2097 */
2098 {
2099 {
2100 0xfe, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2101 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2102 },
2103 10
2104 }
2105 };
2106 size_t i;
2107
2108 /* See if ipaddr matches any of the entries in the blacklist. */
2109 for (i = 0; i < sizeof(blacklist) / sizeof(blacklist[0]); ++i) {
2110 if (ares_ipv6_subnet_matches(
2111 blacklist[i].netbase, blacklist[i].netmask, ipaddr))
2112 return 1;
2113 }
2114 return 0;
2115 }
2116
2117 /* Add the IPv4 or IPv6 nameservers in str (separated by commas) to the
2118 * servers list, updating servers and nservers as required.
2119 *
2120 * This will silently ignore blacklisted IPv6 nameservers as detected by
2121 * ares_ipv6_server_blacklisted().
2122 *
2123 * Returns an error code on failure, else ARES_SUCCESS.
2124 */
config_nameserver(struct server_state ** servers,int * nservers,char * str)2125 static int config_nameserver(struct server_state **servers, int *nservers,
2126 char *str)
2127 {
2128 struct ares_addr host;
2129 struct server_state *newserv;
2130 char *p, *txtaddr;
2131 /* On Windows, there may be more than one nameserver specified in the same
2132 * registry key, so we parse input as a space or comma seperated list.
2133 */
2134 for (p = str; p;)
2135 {
2136 /* Skip whitespace and commas. */
2137 while (*p && (ISSPACE(*p) || (*p == ',')))
2138 p++;
2139 if (!*p)
2140 /* No more input, done. */
2141 break;
2142
2143 /* Pointer to start of IPv4 or IPv6 address part. */
2144 txtaddr = p;
2145
2146 /* Advance past this address. */
2147 while (*p && !ISSPACE(*p) && (*p != ','))
2148 p++;
2149 if (*p)
2150 /* Null terminate this address. */
2151 *p++ = '\0';
2152 else
2153 /* Reached end of input, done when this address is processed. */
2154 p = NULL;
2155
2156 /* Convert textual address to binary format. */
2157 if (ares_inet_pton(AF_INET, txtaddr, &host.addrV4) == 1)
2158 host.family = AF_INET;
2159 else if (ares_inet_pton(AF_INET6, txtaddr, &host.addrV6) == 1
2160 /* Silently skip blacklisted IPv6 servers. */
2161 && !ares_ipv6_server_blacklisted(
2162 (const unsigned char *)&host.addrV6))
2163 host.family = AF_INET6;
2164 else
2165 continue;
2166
2167 /* Resize servers state array. */
2168 newserv = ares_realloc(*servers, (*nservers + 1) *
2169 sizeof(struct server_state));
2170 if (!newserv)
2171 return ARES_ENOMEM;
2172
2173 /* Store address data. */
2174 newserv[*nservers].addr.family = host.family;
2175 newserv[*nservers].addr.udp_port = 0;
2176 newserv[*nservers].addr.tcp_port = 0;
2177 if (host.family == AF_INET)
2178 memcpy(&newserv[*nservers].addr.addrV4, &host.addrV4,
2179 sizeof(host.addrV4));
2180 else
2181 memcpy(&newserv[*nservers].addr.addrV6, &host.addrV6,
2182 sizeof(host.addrV6));
2183
2184 /* Update arguments. */
2185 *servers = newserv;
2186 *nservers += 1;
2187 }
2188
2189 return ARES_SUCCESS;
2190 }
2191 #endif /* !WATT32 */
2192
config_sortlist(struct apattern ** sortlist,int * nsort,const char * str)2193 static int config_sortlist(struct apattern **sortlist, int *nsort,
2194 const char *str)
2195 {
2196 struct apattern pat;
2197 const char *q;
2198
2199 /* Add sortlist entries. */
2200 while (*str && *str != ';')
2201 {
2202 int bits;
2203 char ipbuf[16], ipbufpfx[32];
2204 /* Find just the IP */
2205 q = str;
2206 while (*q && *q != '/' && *q != ';' && !ISSPACE(*q))
2207 q++;
2208 memcpy(ipbuf, str, q-str);
2209 ipbuf[q-str] = '\0';
2210 /* Find the prefix */
2211 if (*q == '/')
2212 {
2213 const char *str2 = q+1;
2214 while (*q && *q != ';' && !ISSPACE(*q))
2215 q++;
2216 memcpy(ipbufpfx, str, q-str);
2217 ipbufpfx[q-str] = '\0';
2218 str = str2;
2219 }
2220 else
2221 ipbufpfx[0] = '\0';
2222 /* Lets see if it is CIDR */
2223 /* First we'll try IPv6 */
2224 if ((bits = ares_inet_net_pton(AF_INET6, ipbufpfx[0] ? ipbufpfx : ipbuf,
2225 &pat.addrV6,
2226 sizeof(pat.addrV6))) > 0)
2227 {
2228 pat.type = PATTERN_CIDR;
2229 pat.mask.bits = (unsigned short)bits;
2230 pat.family = AF_INET6;
2231 if (!sortlist_alloc(sortlist, nsort, &pat)) {
2232 ares_free(*sortlist);
2233 *sortlist = NULL;
2234 return ARES_ENOMEM;
2235 }
2236 }
2237 else if (ipbufpfx[0] &&
2238 (bits = ares_inet_net_pton(AF_INET, ipbufpfx, &pat.addrV4,
2239 sizeof(pat.addrV4))) > 0)
2240 {
2241 pat.type = PATTERN_CIDR;
2242 pat.mask.bits = (unsigned short)bits;
2243 pat.family = AF_INET;
2244 if (!sortlist_alloc(sortlist, nsort, &pat)) {
2245 ares_free(*sortlist);
2246 *sortlist = NULL;
2247 return ARES_ENOMEM;
2248 }
2249 }
2250 /* See if it is just a regular IP */
2251 else if (ip_addr(ipbuf, q-str, &pat.addrV4) == 0)
2252 {
2253 if (ipbufpfx[0])
2254 {
2255 memcpy(ipbuf, str, q-str);
2256 ipbuf[q-str] = '\0';
2257 if (ip_addr(ipbuf, q-str, &pat.mask.addr4) != 0)
2258 natural_mask(&pat);
2259 }
2260 else
2261 natural_mask(&pat);
2262 pat.family = AF_INET;
2263 pat.type = PATTERN_MASK;
2264 if (!sortlist_alloc(sortlist, nsort, &pat)) {
2265 ares_free(*sortlist);
2266 *sortlist = NULL;
2267 return ARES_ENOMEM;
2268 }
2269 }
2270 else
2271 {
2272 while (*q && *q != ';' && !ISSPACE(*q))
2273 q++;
2274 }
2275 str = q;
2276 while (ISSPACE(*str))
2277 str++;
2278 }
2279
2280 return ARES_SUCCESS;
2281 }
2282
set_search(ares_channel channel,const char * str)2283 static int set_search(ares_channel channel, const char *str)
2284 {
2285 size_t cnt;
2286
2287 if(channel->ndomains != -1) {
2288 /* LCOV_EXCL_START: all callers check ndomains == -1 */
2289 /* if we already have some domains present, free them first */
2290 ares_strsplit_free(channel->domains, channel->ndomains);
2291 channel->domains = NULL;
2292 channel->ndomains = -1;
2293 } /* LCOV_EXCL_STOP */
2294
2295 channel->domains = ares_strsplit(str, ", ", 1, &cnt);
2296 channel->ndomains = (int)cnt;
2297 if (channel->domains == NULL || channel->ndomains == 0) {
2298 channel->domains = NULL;
2299 channel->ndomains = -1;
2300 }
2301
2302 return ARES_SUCCESS;
2303 }
2304
set_options(ares_channel channel,const char * str)2305 static int set_options(ares_channel channel, const char *str)
2306 {
2307 const char *p, *q, *val;
2308
2309 p = str;
2310 while (*p)
2311 {
2312 q = p;
2313 while (*q && !ISSPACE(*q))
2314 q++;
2315 val = try_option(p, q, "ndots:");
2316 if (val && channel->ndots == -1)
2317 channel->ndots = aresx_sltosi(strtol(val, NULL, 10));
2318 val = try_option(p, q, "retrans:");
2319 if (val && channel->timeout == -1)
2320 channel->timeout = aresx_sltosi(strtol(val, NULL, 10));
2321 val = try_option(p, q, "retry:");
2322 if (val && channel->tries == -1)
2323 channel->tries = aresx_sltosi(strtol(val, NULL, 10));
2324 val = try_option(p, q, "rotate");
2325 if (val && channel->rotate == -1)
2326 channel->rotate = 1;
2327 p = q;
2328 while (ISSPACE(*p))
2329 p++;
2330 }
2331
2332 return ARES_SUCCESS;
2333 }
2334
try_option(const char * p,const char * q,const char * opt)2335 static const char *try_option(const char *p, const char *q, const char *opt)
2336 {
2337 size_t len = strlen(opt);
2338 return ((size_t)(q - p) >= len && !strncmp(p, opt, len)) ? &p[len] : NULL;
2339 }
2340
2341 #if !defined(WIN32) && !defined(WATT32) && \
2342 !defined(ANDROID) && !defined(__ANDROID__) && !defined(CARES_USE_LIBRESOLV)
try_config(char * s,const char * opt,char scc)2343 static char *try_config(char *s, const char *opt, char scc)
2344 {
2345 size_t len;
2346 char *p;
2347 char *q;
2348
2349 if (!s || !opt)
2350 /* no line or no option */
2351 return NULL; /* LCOV_EXCL_LINE */
2352
2353 /* Hash '#' character is always used as primary comment char, additionally
2354 a not-NUL secondary comment char will be considered when specified. */
2355
2356 /* trim line comment */
2357 p = s;
2358 if(scc)
2359 while (*p && (*p != '#') && (*p != scc))
2360 p++;
2361 else
2362 while (*p && (*p != '#'))
2363 p++;
2364 *p = '\0';
2365
2366 /* trim trailing whitespace */
2367 q = p - 1;
2368 while ((q >= s) && ISSPACE(*q))
2369 q--;
2370 *++q = '\0';
2371
2372 /* skip leading whitespace */
2373 p = s;
2374 while (*p && ISSPACE(*p))
2375 p++;
2376
2377 if (!*p)
2378 /* empty line */
2379 return NULL;
2380
2381 if ((len = strlen(opt)) == 0)
2382 /* empty option */
2383 return NULL; /* LCOV_EXCL_LINE */
2384
2385 if (strncmp(p, opt, len) != 0)
2386 /* line and option do not match */
2387 return NULL;
2388
2389 /* skip over given option name */
2390 p += len;
2391
2392 if (!*p)
2393 /* no option value */
2394 return NULL; /* LCOV_EXCL_LINE */
2395
2396 if ((opt[len-1] != ':') && (opt[len-1] != '=') && !ISSPACE(*p))
2397 /* whitespace between option name and value is mandatory
2398 for given option names which do not end with ':' or '=' */
2399 return NULL;
2400
2401 /* skip over whitespace */
2402 while (*p && ISSPACE(*p))
2403 p++;
2404
2405 if (!*p)
2406 /* no option value */
2407 return NULL;
2408
2409 /* return pointer to option value */
2410 return p;
2411 }
2412 #endif /* !WIN32 & !WATT32 & !ANDROID & !__ANDROID__ */
2413
ip_addr(const char * ipbuf,ares_ssize_t len,struct in_addr * addr)2414 static int ip_addr(const char *ipbuf, ares_ssize_t len, struct in_addr *addr)
2415 {
2416
2417 /* Four octets and three periods yields at most 15 characters. */
2418 if (len > 15)
2419 return -1;
2420
2421 addr->s_addr = inet_addr(ipbuf);
2422 if (addr->s_addr == INADDR_NONE && strcmp(ipbuf, "255.255.255.255") != 0)
2423 return -1;
2424 return 0;
2425 }
2426
natural_mask(struct apattern * pat)2427 static void natural_mask(struct apattern *pat)
2428 {
2429 struct in_addr addr;
2430
2431 /* Store a host-byte-order copy of pat in a struct in_addr. Icky,
2432 * but portable.
2433 */
2434 addr.s_addr = ntohl(pat->addrV4.s_addr);
2435
2436 /* This is out of date in the CIDR world, but some people might
2437 * still rely on it.
2438 */
2439 if (IN_CLASSA(addr.s_addr))
2440 pat->mask.addr4.s_addr = htonl(IN_CLASSA_NET);
2441 else if (IN_CLASSB(addr.s_addr))
2442 pat->mask.addr4.s_addr = htonl(IN_CLASSB_NET);
2443 else
2444 pat->mask.addr4.s_addr = htonl(IN_CLASSC_NET);
2445 }
2446
sortlist_alloc(struct apattern ** sortlist,int * nsort,struct apattern * pat)2447 static int sortlist_alloc(struct apattern **sortlist, int *nsort,
2448 struct apattern *pat)
2449 {
2450 struct apattern *newsort;
2451 newsort = ares_realloc(*sortlist, (*nsort + 1) * sizeof(struct apattern));
2452 if (!newsort)
2453 return 0;
2454 newsort[*nsort] = *pat;
2455 *sortlist = newsort;
2456 (*nsort)++;
2457 return 1;
2458 }
2459
2460 /* initialize an rc4 key. If possible a cryptographically secure random key
2461 is generated using a suitable function (for example win32's RtlGenRandom as
2462 described in
2463 http://blogs.msdn.com/michael_howard/archive/2005/01/14/353379.aspx
2464 otherwise the code defaults to cross-platform albeit less secure mechanism
2465 using rand
2466 */
randomize_key(unsigned char * key,int key_data_len)2467 static void randomize_key(unsigned char* key,int key_data_len)
2468 {
2469 int randomized = 0;
2470 int counter=0;
2471 #ifdef WIN32
2472 BOOLEAN res;
2473 if (ares_fpSystemFunction036)
2474 {
2475 res = (*ares_fpSystemFunction036) (key, key_data_len);
2476 if (res)
2477 randomized = 1;
2478 }
2479 #else /* !WIN32 */
2480 #ifdef RANDOM_FILE
2481 FILE *f = fopen(RANDOM_FILE, "rb");
2482 if(f) {
2483 counter = aresx_uztosi(fread(key, 1, key_data_len, f));
2484 fclose(f);
2485 }
2486 #endif
2487 #endif /* WIN32 */
2488
2489 if (!randomized) {
2490 for (;counter<key_data_len;counter++)
2491 key[counter]=(unsigned char)(rand() % 256); /* LCOV_EXCL_LINE */
2492 }
2493 }
2494
init_id_key(rc4_key * key,int key_data_len)2495 static int init_id_key(rc4_key* key,int key_data_len)
2496 {
2497 unsigned char index1;
2498 unsigned char index2;
2499 unsigned char* state;
2500 short counter;
2501 unsigned char *key_data_ptr = 0;
2502
2503 key_data_ptr = ares_malloc(key_data_len);
2504 if (!key_data_ptr)
2505 return ARES_ENOMEM;
2506 memset(key_data_ptr, 0, key_data_len);
2507
2508 state = &key->state[0];
2509 for(counter = 0; counter < 256; counter++)
2510 /* unnecessary AND but it keeps some compilers happier */
2511 state[counter] = (unsigned char)(counter & 0xff);
2512 randomize_key(key->state,key_data_len);
2513 key->x = 0;
2514 key->y = 0;
2515 index1 = 0;
2516 index2 = 0;
2517 for(counter = 0; counter < 256; counter++)
2518 {
2519 index2 = (unsigned char)((key_data_ptr[index1] + state[counter] +
2520 index2) % 256);
2521 ARES_SWAP_BYTE(&state[counter], &state[index2]);
2522
2523 index1 = (unsigned char)((index1 + 1) % key_data_len);
2524 }
2525 ares_free(key_data_ptr);
2526 return ARES_SUCCESS;
2527 }
2528
ares_set_local_ip4(ares_channel channel,unsigned int local_ip)2529 void ares_set_local_ip4(ares_channel channel, unsigned int local_ip)
2530 {
2531 channel->local_ip4 = local_ip;
2532 }
2533
2534 /* local_ip6 should be 16 bytes in length */
ares_set_local_ip6(ares_channel channel,const unsigned char * local_ip6)2535 void ares_set_local_ip6(ares_channel channel,
2536 const unsigned char* local_ip6)
2537 {
2538 memcpy(&channel->local_ip6, local_ip6, sizeof(channel->local_ip6));
2539 }
2540
2541 /* local_dev_name should be null terminated. */
ares_set_local_dev(ares_channel channel,const char * local_dev_name)2542 void ares_set_local_dev(ares_channel channel,
2543 const char* local_dev_name)
2544 {
2545 strncpy(channel->local_dev_name, local_dev_name,
2546 sizeof(channel->local_dev_name));
2547 channel->local_dev_name[sizeof(channel->local_dev_name) - 1] = 0;
2548 }
2549
2550
ares_set_socket_callback(ares_channel channel,ares_sock_create_callback cb,void * data)2551 void ares_set_socket_callback(ares_channel channel,
2552 ares_sock_create_callback cb,
2553 void *data)
2554 {
2555 channel->sock_create_cb = cb;
2556 channel->sock_create_cb_data = data;
2557 }
2558
ares_set_socket_configure_callback(ares_channel channel,ares_sock_config_callback cb,void * data)2559 void ares_set_socket_configure_callback(ares_channel channel,
2560 ares_sock_config_callback cb,
2561 void *data)
2562 {
2563 channel->sock_config_cb = cb;
2564 channel->sock_config_cb_data = data;
2565 }
2566
ares_set_socket_functions(ares_channel channel,const struct ares_socket_functions * funcs,void * data)2567 void ares_set_socket_functions(ares_channel channel,
2568 const struct ares_socket_functions * funcs,
2569 void *data)
2570 {
2571 channel->sock_funcs = funcs;
2572 channel->sock_func_cb_data = data;
2573 }
2574
ares_set_sortlist(ares_channel channel,const char * sortstr)2575 int ares_set_sortlist(ares_channel channel, const char *sortstr)
2576 {
2577 int nsort = 0;
2578 struct apattern *sortlist = NULL;
2579 int status;
2580
2581 if (!channel)
2582 return ARES_ENODATA;
2583
2584 status = config_sortlist(&sortlist, &nsort, sortstr);
2585 if (status == ARES_SUCCESS && sortlist) {
2586 if (channel->sortlist)
2587 ares_free(channel->sortlist);
2588 channel->sortlist = sortlist;
2589 channel->nsort = nsort;
2590 }
2591 return status;
2592 }
2593
ares__init_servers_state(ares_channel channel)2594 void ares__init_servers_state(ares_channel channel)
2595 {
2596 struct server_state *server;
2597 int i;
2598
2599 for (i = 0; i < channel->nservers; i++)
2600 {
2601 server = &channel->servers[i];
2602 server->udp_socket = ARES_SOCKET_BAD;
2603 server->tcp_socket = ARES_SOCKET_BAD;
2604 server->tcp_connection_generation = ++channel->tcp_connection_generation;
2605 server->tcp_lenbuf_pos = 0;
2606 server->tcp_buffer_pos = 0;
2607 server->tcp_buffer = NULL;
2608 server->tcp_length = 0;
2609 server->qhead = NULL;
2610 server->qtail = NULL;
2611 ares__init_list_head(&server->queries_to_server);
2612 server->channel = channel;
2613 server->is_broken = 0;
2614 }
2615 }
2616