1 2 /* Copyright 1998 by the Massachusetts Institute of Technology. 3 * Copyright (C) 2007-2011 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_SYS_TIME_H 25 #include <sys/time.h> 26 #endif 27 28 #ifdef HAVE_SYS_SOCKET_H 29 #include <sys/socket.h> 30 #endif 31 32 #ifdef HAVE_NETINET_IN_H 33 #include <netinet/in.h> 34 #endif 35 36 #ifdef HAVE_NETDB_H 37 #include <netdb.h> 38 #endif 39 40 #ifdef HAVE_ARPA_INET_H 41 #include <arpa/inet.h> 42 #endif 43 44 #ifdef HAVE_ARPA_NAMESER_H 45 # include <arpa/nameser.h> 46 #else 47 # include "nameser.h" 48 #endif 49 #ifdef HAVE_ARPA_NAMESER_COMPAT_H 50 # include <arpa/nameser_compat.h> 51 #endif 52 53 #ifdef HAVE_UNISTD_H 54 #include <unistd.h> 55 #endif 56 57 #include <stdio.h> 58 #include <stdlib.h> 59 #include <string.h> 60 #include <ctype.h> 61 #include <time.h> 62 63 #ifdef ANDROID 64 #include <sys/system_properties.h> 65 #endif 66 67 #include "ares.h" 68 #include "inet_net_pton.h" 69 #include "ares_library_init.h" 70 #include "ares_nowarn.h" 71 #include "ares_platform.h" 72 #include "inet_ntop.h" 73 #include "ares_private.h" 74 75 #ifdef WATT32 76 #undef WIN32 /* Redefined in MingW/MSVC headers */ 77 #endif 78 79 static int init_by_options(ares_channel channel, const struct ares_options *options, 80 int optmask); 81 static int init_by_environment(ares_channel channel); 82 static int init_by_resolv_conf(ares_channel channel); 83 static int init_by_defaults(ares_channel channel); 84 85 #ifndef WATT32 86 static int config_nameserver(struct server_state **servers, int *nservers, 87 char *str); 88 #endif 89 static int set_search(ares_channel channel, const char *str); 90 static int set_options(ares_channel channel, const char *str); 91 static const char *try_option(const char *p, const char *q, const char *opt); 92 static int init_id_key(rc4_key* key,int key_data_len); 93 94 #if !defined(WIN32) && !defined(WATT32) 95 static int sortlist_alloc(struct apattern **sortlist, int *nsort, struct apattern *pat); 96 static int ip_addr(const char *s, ssize_t len, struct in_addr *addr); 97 static void natural_mask(struct apattern *pat); 98 static int config_domain(ares_channel channel, char *str); 99 static int config_lookup(ares_channel channel, const char *str, 100 const char *bindch, const char *filech); 101 static int config_sortlist(struct apattern **sortlist, int *nsort, 102 const char *str); 103 static char *try_config(char *s, const char *opt, char scc); 104 #endif 105 106 #define ARES_CONFIG_CHECK(x) (x->lookups && x->nsort > -1 && \ 107 x->nservers > -1 && \ 108 x->ndomains > -1 && \ 109 x->ndots > -1 && x->timeout > -1 && \ 110 x->tries > -1) 111 112 int ares_init(ares_channel *channelptr) 113 { 114 return ares_init_options(channelptr, NULL, 0); 115 } 116 117 int ares_init_options(ares_channel *channelptr, struct ares_options *options, 118 int optmask) 119 { 120 ares_channel channel; 121 int i; 122 int status = ARES_SUCCESS; 123 struct timeval now; 124 125 #ifdef CURLDEBUG 126 const char *env = getenv("CARES_MEMDEBUG"); 127 128 if (env) 129 curl_memdebug(env); 130 env = getenv("CARES_MEMLIMIT"); 131 if (env) { 132 char *endptr; 133 long num = strtol(env, &endptr, 10); 134 if((endptr != env) && (endptr == env + strlen(env)) && (num > 0)) 135 curl_memlimit(num); 136 } 137 #endif 138 139 if (ares_library_initialized() != ARES_SUCCESS) 140 return ARES_ENOTINITIALIZED; 141 142 channel = malloc(sizeof(struct ares_channeldata)); 143 if (!channel) { 144 *channelptr = NULL; 145 return ARES_ENOMEM; 146 } 147 148 now = ares__tvnow(); 149 150 /* Set everything to distinguished values so we know they haven't 151 * been set yet. 152 */ 153 channel->flags = -1; 154 channel->timeout = -1; 155 channel->tries = -1; 156 channel->ndots = -1; 157 channel->rotate = -1; 158 channel->udp_port = -1; 159 channel->tcp_port = -1; 160 channel->socket_send_buffer_size = -1; 161 channel->socket_receive_buffer_size = -1; 162 channel->nservers = -1; 163 channel->ndomains = -1; 164 channel->nsort = -1; 165 channel->tcp_connection_generation = 0; 166 channel->lookups = NULL; 167 channel->domains = NULL; 168 channel->sortlist = NULL; 169 channel->servers = NULL; 170 channel->sock_state_cb = NULL; 171 channel->sock_state_cb_data = NULL; 172 channel->sock_create_cb = NULL; 173 channel->sock_create_cb_data = NULL; 174 175 channel->last_server = 0; 176 channel->last_timeout_processed = (time_t)now.tv_sec; 177 178 memset(&channel->local_dev_name, 0, sizeof(channel->local_dev_name)); 179 channel->local_ip4 = 0; 180 memset(&channel->local_ip6, 0, sizeof(channel->local_ip6)); 181 182 /* Initialize our lists of queries */ 183 ares__init_list_head(&(channel->all_queries)); 184 for (i = 0; i < ARES_QID_TABLE_SIZE; i++) 185 { 186 ares__init_list_head(&(channel->queries_by_qid[i])); 187 } 188 for (i = 0; i < ARES_TIMEOUT_TABLE_SIZE; i++) 189 { 190 ares__init_list_head(&(channel->queries_by_timeout[i])); 191 } 192 193 /* Initialize configuration by each of the four sources, from highest 194 * precedence to lowest. 195 */ 196 197 if (status == ARES_SUCCESS) { 198 status = init_by_options(channel, options, optmask); 199 if (status != ARES_SUCCESS) 200 DEBUGF(fprintf(stderr, "Error: init_by_options failed: %s\n", 201 ares_strerror(status))); 202 } 203 if (status == ARES_SUCCESS) { 204 status = init_by_environment(channel); 205 if (status != ARES_SUCCESS) 206 DEBUGF(fprintf(stderr, "Error: init_by_environment failed: %s\n", 207 ares_strerror(status))); 208 } 209 if (status == ARES_SUCCESS) { 210 status = init_by_resolv_conf(channel); 211 if (status != ARES_SUCCESS) 212 DEBUGF(fprintf(stderr, "Error: init_by_resolv_conf failed: %s\n", 213 ares_strerror(status))); 214 } 215 216 /* 217 * No matter what failed or succeeded, seed defaults to provide 218 * useful behavior for things that we missed. 219 */ 220 status = init_by_defaults(channel); 221 if (status != ARES_SUCCESS) 222 DEBUGF(fprintf(stderr, "Error: init_by_defaults failed: %s\n", 223 ares_strerror(status))); 224 225 /* Generate random key */ 226 227 if (status == ARES_SUCCESS) { 228 status = init_id_key(&channel->id_key, ARES_ID_KEY_LEN); 229 if (status == ARES_SUCCESS) 230 channel->next_id = ares__generate_new_id(&channel->id_key); 231 else 232 DEBUGF(fprintf(stderr, "Error: init_id_key failed: %s\n", 233 ares_strerror(status))); 234 } 235 236 if (status != ARES_SUCCESS) 237 { 238 /* Something failed; clean up memory we may have allocated. */ 239 if (channel->servers) 240 free(channel->servers); 241 if (channel->domains) 242 { 243 for (i = 0; i < channel->ndomains; i++) 244 free(channel->domains[i]); 245 free(channel->domains); 246 } 247 if (channel->sortlist) 248 free(channel->sortlist); 249 if(channel->lookups) 250 free(channel->lookups); 251 free(channel); 252 return status; 253 } 254 255 /* Trim to one server if ARES_FLAG_PRIMARY is set. */ 256 if ((channel->flags & ARES_FLAG_PRIMARY) && channel->nservers > 1) 257 channel->nservers = 1; 258 259 ares__init_servers_state(channel); 260 261 *channelptr = channel; 262 return ARES_SUCCESS; 263 } 264 265 /* ares_dup() duplicates a channel handle with all its options and returns a 266 new channel handle */ 267 int ares_dup(ares_channel *dest, ares_channel src) 268 { 269 struct ares_options opts; 270 struct ares_addr_node *servers; 271 int ipv6_nservers = 0; 272 int i, rc; 273 int optmask; 274 275 *dest = NULL; /* in case of failure return NULL explicitly */ 276 277 /* First get the options supported by the old ares_save_options() function, 278 which is most of them */ 279 rc = ares_save_options(src, &opts, &optmask); 280 if(rc) 281 return rc; 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 296 strncpy((*dest)->local_dev_name, src->local_dev_name, sizeof(src->local_dev_name)); 297 (*dest)->local_ip4 = src->local_ip4; 298 memcpy((*dest)->local_ip6, src->local_ip6, sizeof(src->local_ip6)); 299 300 /* Full name server cloning required when not all are IPv4 */ 301 for (i = 0; i < src->nservers; i++) 302 { 303 if (src->servers[i].addr.family != AF_INET) { 304 ipv6_nservers++; 305 break; 306 } 307 } 308 if (ipv6_nservers) { 309 rc = ares_get_servers(src, &servers); 310 if (rc != ARES_SUCCESS) 311 return rc; 312 rc = ares_set_servers(*dest, servers); 313 ares_free_data(servers); 314 if (rc != ARES_SUCCESS) 315 return rc; 316 } 317 318 return ARES_SUCCESS; /* everything went fine */ 319 } 320 321 /* Save options from initialized channel */ 322 int ares_save_options(ares_channel channel, struct ares_options *options, 323 int *optmask) 324 { 325 int i, j; 326 int ipv4_nservers = 0; 327 328 /* Zero everything out */ 329 memset(options, 0, sizeof(struct ares_options)); 330 331 if (!ARES_CONFIG_CHECK(channel)) 332 return ARES_ENODATA; 333 334 /* Traditionally the optmask wasn't saved in the channel struct so it was 335 recreated here. ROTATE is the first option that has no struct field of 336 its own in the public config struct */ 337 (*optmask) = (ARES_OPT_FLAGS|ARES_OPT_TRIES|ARES_OPT_NDOTS| 338 ARES_OPT_UDP_PORT|ARES_OPT_TCP_PORT|ARES_OPT_SOCK_STATE_CB| 339 ARES_OPT_SERVERS|ARES_OPT_DOMAINS|ARES_OPT_LOOKUPS| 340 ARES_OPT_SORTLIST|ARES_OPT_TIMEOUTMS) | 341 (channel->optmask & ARES_OPT_ROTATE); 342 343 /* Copy easy stuff */ 344 options->flags = channel->flags; 345 346 /* We return full millisecond resolution but that's only because we don't 347 set the ARES_OPT_TIMEOUT anymore, only the new ARES_OPT_TIMEOUTMS */ 348 options->timeout = channel->timeout; 349 options->tries = channel->tries; 350 options->ndots = channel->ndots; 351 options->udp_port = (unsigned short)channel->udp_port; 352 options->tcp_port = (unsigned short)channel->tcp_port; 353 options->sock_state_cb = channel->sock_state_cb; 354 options->sock_state_cb_data = channel->sock_state_cb_data; 355 356 /* Copy IPv4 servers */ 357 if (channel->nservers) { 358 for (i = 0; i < channel->nservers; i++) 359 { 360 if (channel->servers[i].addr.family == AF_INET) 361 ipv4_nservers++; 362 } 363 if (ipv4_nservers) { 364 options->servers = malloc(ipv4_nservers * sizeof(struct in_addr)); 365 if (!options->servers) 366 return ARES_ENOMEM; 367 for (i = j = 0; i < channel->nservers; i++) 368 { 369 if (channel->servers[i].addr.family == AF_INET) 370 memcpy(&options->servers[j++], 371 &channel->servers[i].addr.addrV4, 372 sizeof(channel->servers[i].addr.addrV4)); 373 } 374 } 375 } 376 options->nservers = ipv4_nservers; 377 378 /* copy domains */ 379 if (channel->ndomains) { 380 options->domains = malloc(channel->ndomains * sizeof(char *)); 381 if (!options->domains) 382 return ARES_ENOMEM; 383 384 for (i = 0; i < channel->ndomains; i++) 385 { 386 options->ndomains = i; 387 options->domains[i] = strdup(channel->domains[i]); 388 if (!options->domains[i]) 389 return ARES_ENOMEM; 390 } 391 } 392 options->ndomains = channel->ndomains; 393 394 /* copy lookups */ 395 if (channel->lookups) { 396 options->lookups = strdup(channel->lookups); 397 if (!options->lookups && channel->lookups) 398 return ARES_ENOMEM; 399 } 400 401 /* copy sortlist */ 402 if (channel->nsort) { 403 options->sortlist = malloc(channel->nsort * sizeof(struct apattern)); 404 if (!options->sortlist) 405 return ARES_ENOMEM; 406 for (i = 0; i < channel->nsort; i++) 407 options->sortlist[i] = channel->sortlist[i]; 408 } 409 options->nsort = channel->nsort; 410 411 return ARES_SUCCESS; 412 } 413 414 static int init_by_options(ares_channel channel, 415 const struct ares_options *options, 416 int optmask) 417 { 418 int i; 419 420 /* Easy stuff. */ 421 if ((optmask & ARES_OPT_FLAGS) && channel->flags == -1) 422 channel->flags = options->flags; 423 if ((optmask & ARES_OPT_TIMEOUTMS) && channel->timeout == -1) 424 channel->timeout = options->timeout; 425 else if ((optmask & ARES_OPT_TIMEOUT) && channel->timeout == -1) 426 channel->timeout = options->timeout * 1000; 427 if ((optmask & ARES_OPT_TRIES) && channel->tries == -1) 428 channel->tries = options->tries; 429 if ((optmask & ARES_OPT_NDOTS) && channel->ndots == -1) 430 channel->ndots = options->ndots; 431 if ((optmask & ARES_OPT_ROTATE) && channel->rotate == -1) 432 channel->rotate = 1; 433 if ((optmask & ARES_OPT_UDP_PORT) && channel->udp_port == -1) 434 channel->udp_port = options->udp_port; 435 if ((optmask & ARES_OPT_TCP_PORT) && channel->tcp_port == -1) 436 channel->tcp_port = options->tcp_port; 437 if ((optmask & ARES_OPT_SOCK_STATE_CB) && channel->sock_state_cb == NULL) 438 { 439 channel->sock_state_cb = options->sock_state_cb; 440 channel->sock_state_cb_data = options->sock_state_cb_data; 441 } 442 if ((optmask & ARES_OPT_SOCK_SNDBUF) 443 && channel->socket_send_buffer_size == -1) 444 channel->socket_send_buffer_size = options->socket_send_buffer_size; 445 if ((optmask & ARES_OPT_SOCK_RCVBUF) 446 && channel->socket_receive_buffer_size == -1) 447 channel->socket_receive_buffer_size = options->socket_receive_buffer_size; 448 449 /* Copy the IPv4 servers, if given. */ 450 if ((optmask & ARES_OPT_SERVERS) && channel->nservers == -1) 451 { 452 /* Avoid zero size allocations at any cost */ 453 if (options->nservers > 0) 454 { 455 channel->servers = 456 malloc(options->nservers * sizeof(struct server_state)); 457 if (!channel->servers) 458 return ARES_ENOMEM; 459 for (i = 0; i < options->nservers; i++) 460 { 461 channel->servers[i].addr.family = AF_INET; 462 memcpy(&channel->servers[i].addr.addrV4, 463 &options->servers[i], 464 sizeof(channel->servers[i].addr.addrV4)); 465 } 466 } 467 channel->nservers = options->nservers; 468 } 469 470 /* Copy the domains, if given. Keep channel->ndomains consistent so 471 * we can clean up in case of error. 472 */ 473 if ((optmask & ARES_OPT_DOMAINS) && channel->ndomains == -1) 474 { 475 /* Avoid zero size allocations at any cost */ 476 if (options->ndomains > 0) 477 { 478 channel->domains = malloc(options->ndomains * sizeof(char *)); 479 if (!channel->domains) 480 return ARES_ENOMEM; 481 for (i = 0; i < options->ndomains; i++) 482 { 483 channel->ndomains = i; 484 channel->domains[i] = strdup(options->domains[i]); 485 if (!channel->domains[i]) 486 return ARES_ENOMEM; 487 } 488 } 489 channel->ndomains = options->ndomains; 490 } 491 492 /* Set lookups, if given. */ 493 if ((optmask & ARES_OPT_LOOKUPS) && !channel->lookups) 494 { 495 channel->lookups = strdup(options->lookups); 496 if (!channel->lookups) 497 return ARES_ENOMEM; 498 } 499 500 /* copy sortlist */ 501 if ((optmask & ARES_OPT_SORTLIST) && (channel->nsort == -1) && 502 (options->nsort>0)) { 503 channel->sortlist = malloc(options->nsort * sizeof(struct apattern)); 504 if (!channel->sortlist) 505 return ARES_ENOMEM; 506 for (i = 0; i < options->nsort; i++) 507 channel->sortlist[i] = options->sortlist[i]; 508 channel->nsort = options->nsort; 509 } 510 511 channel->optmask = optmask; 512 513 return ARES_SUCCESS; 514 } 515 516 static int init_by_environment(ares_channel channel) 517 { 518 const char *localdomain, *res_options; 519 int status; 520 521 localdomain = getenv("LOCALDOMAIN"); 522 if (localdomain && channel->ndomains == -1) 523 { 524 status = set_search(channel, localdomain); 525 if (status != ARES_SUCCESS) 526 return status; 527 } 528 529 res_options = getenv("RES_OPTIONS"); 530 if (res_options) 531 { 532 status = set_options(channel, res_options); 533 if (status != ARES_SUCCESS) 534 return status; 535 } 536 537 return ARES_SUCCESS; 538 } 539 540 #ifdef WIN32 541 /* 542 * Warning: returns a dynamically allocated buffer, the user MUST 543 * use free() if the function returns 1 544 */ 545 static int get_res_nt(HKEY hKey, const char *subkey, char **obuf) 546 { 547 /* Test for the size we need */ 548 DWORD size = 0; 549 int result; 550 551 result = RegQueryValueEx(hKey, subkey, 0, NULL, NULL, &size); 552 if ((result != ERROR_SUCCESS && result != ERROR_MORE_DATA) || !size) 553 return 0; 554 *obuf = malloc(size+1); 555 if (!*obuf) 556 return 0; 557 558 if (RegQueryValueEx(hKey, subkey, 0, NULL, 559 (LPBYTE)*obuf, &size) != ERROR_SUCCESS) 560 { 561 free(*obuf); 562 return 0; 563 } 564 if (size == 1) 565 { 566 free(*obuf); 567 return 0; 568 } 569 return 1; 570 } 571 572 static int get_res_interfaces_nt(HKEY hKey, const char *subkey, char **obuf) 573 { 574 char enumbuf[39]; /* GUIDs are 38 chars + 1 for NULL */ 575 DWORD enum_size = 39; 576 int idx = 0; 577 HKEY hVal; 578 579 while (RegEnumKeyEx(hKey, idx++, enumbuf, &enum_size, 0, 580 NULL, NULL, NULL) != ERROR_NO_MORE_ITEMS) 581 { 582 int rc; 583 584 enum_size = 39; 585 if (RegOpenKeyEx(hKey, enumbuf, 0, KEY_QUERY_VALUE, &hVal) != 586 ERROR_SUCCESS) 587 continue; 588 rc = get_res_nt(hVal, subkey, obuf); 589 RegCloseKey(hVal); 590 if (rc) 591 return 1; 592 } 593 return 0; 594 } 595 596 /** 597 * The desired output for this method is that we set "ret_buf" to 598 * something like: 599 * 600 * 192.168.0.1,dns01.my.domain,fe80::200:f8ff:fe21:67cf 601 * 602 * The only ordering requirement is that primary servers are listed 603 * before secondary. There is no requirement that IPv4 addresses should 604 * necessarily be before IPv6. 605 * 606 * Note that ret_size should ideally be big enough to hold around 607 * 2-3 IPv4 and 2-3 IPv6 addresses. 608 * 609 * Finally, we need to return the total number of DNS servers located. 610 */ 611 static int get_iphlpapi_dns_info (char *ret_buf, size_t ret_size) 612 { 613 const size_t ipv4_size = INET_ADDRSTRLEN + 1; /* +1 for ',' at end */ 614 const size_t ipv6_size = INET6_ADDRSTRLEN + 12; /* +12 for "%0123456789," at end */ 615 size_t left = ret_size; 616 char *ret = ret_buf; 617 int count = 0; 618 619 /* Use the GetAdaptersAddresses method if it's available, otherwise 620 fall back to GetNetworkParams. */ 621 if (ares_fpGetAdaptersAddresses != ZERO_NULL) 622 { 623 const ULONG working_buf_size = 15000; 624 IP_ADAPTER_ADDRESSES *pFirstEntry = NULL; 625 IP_ADAPTER_ADDRESSES *pEntry = NULL; 626 ULONG bufSize = 0; 627 ULONG result = 0; 628 629 /* According to MSDN, the recommended way to do this is to use a temporary 630 buffer of 15K, to "dramatically reduce the chance that the GetAdaptersAddresses 631 method returns ERROR_BUFFER_OVERFLOW" */ 632 pFirstEntry = ( IP_ADAPTER_ADDRESSES * ) malloc( working_buf_size ); 633 bufSize = working_buf_size; 634 if( !pFirstEntry ) 635 return 0; 636 637 /* Call the method one time */ 638 result = ( *ares_fpGetAdaptersAddresses )( AF_UNSPEC, 0, 0, pFirstEntry, &bufSize ); 639 if( result == ERROR_BUFFER_OVERFLOW ) 640 { 641 /* Reallocate, bufSize should now be set to the required size */ 642 pFirstEntry = ( IP_ADAPTER_ADDRESSES * ) realloc( pFirstEntry, bufSize ); 643 if( !pFirstEntry ) 644 return 0; 645 646 /* Call the method a second time */ 647 result = ( *ares_fpGetAdaptersAddresses )( AF_UNSPEC, 0, 0, pFirstEntry, &bufSize ); 648 if( result == ERROR_BUFFER_OVERFLOW ) 649 { 650 /* Reallocate, bufSize should now be set to the required size */ 651 pFirstEntry = ( IP_ADAPTER_ADDRESSES * ) realloc( pFirstEntry, bufSize ); 652 if( !pFirstEntry ) 653 return 0; 654 655 /* Call the method a third time. The maximum number of times we're going to do 656 this is 3. Three shall be the number thou shalt count, and the number of the 657 counting shall be three. Five is right out. */ 658 result = ( *ares_fpGetAdaptersAddresses )( AF_UNSPEC, 0, 0, pFirstEntry, &bufSize ); 659 } 660 } 661 662 /* Check the current result for failure */ 663 if( result != ERROR_SUCCESS ) 664 { 665 free( pFirstEntry ); 666 return 0; 667 } 668 669 /* process the results */ 670 for( pEntry = pFirstEntry ; pEntry != NULL ; pEntry = pEntry->Next ) 671 { 672 IP_ADAPTER_DNS_SERVER_ADDRESS* pDNSAddr = pEntry->FirstDnsServerAddress; 673 for( ; pDNSAddr != NULL ; pDNSAddr = pDNSAddr->Next ) 674 { 675 struct sockaddr *pGenericAddr = pDNSAddr->Address.lpSockaddr; 676 size_t stringlen = 0; 677 678 if( pGenericAddr->sa_family == AF_INET && left > ipv4_size ) 679 { 680 /* Handle the v4 case */ 681 struct sockaddr_in *pIPv4Addr = ( struct sockaddr_in * ) pGenericAddr; 682 ares_inet_ntop( AF_INET, &pIPv4Addr->sin_addr, ret, ipv4_size - 1 ); /* -1 for comma */ 683 684 /* Append a comma to the end, THEN NULL. Should be OK because we 685 already tested the size at the top of the if statement. */ 686 stringlen = strlen( ret ); 687 ret[ stringlen ] = ','; 688 ret[ stringlen + 1 ] = '\0'; 689 ret += stringlen + 1; 690 left -= ret - ret_buf; 691 ++count; 692 } 693 else if( pGenericAddr->sa_family == AF_INET6 && left > ipv6_size ) 694 { 695 /* Handle the v6 case */ 696 struct sockaddr_in6 *pIPv6Addr = ( struct sockaddr_in6 * ) pGenericAddr; 697 ares_inet_ntop( AF_INET6, &pIPv6Addr->sin6_addr, ret, ipv6_size - 1 ); /* -1 for comma */ 698 699 /* Append a comma to the end, THEN NULL. Should be OK because we 700 already tested the size at the top of the if statement. */ 701 stringlen = strlen( ret ); 702 ret[ stringlen ] = ','; 703 ret[ stringlen + 1 ] = '\0'; 704 ret += stringlen + 1; 705 left -= ret - ret_buf; 706 ++count; 707 708 /* NB on Windows this also returns stuff in the fec0::/10 range, 709 seems to be hard-coded somehow. Do we need to ignore them? */ 710 } 711 } 712 } 713 714 if( pFirstEntry ) 715 free( pFirstEntry ); 716 if (ret > ret_buf) 717 ret[-1] = '\0'; 718 return count; 719 } 720 else 721 { 722 FIXED_INFO *fi, *newfi; 723 DWORD size = sizeof (*fi); 724 IP_ADDR_STRING *ipAddr; 725 int i; 726 int debug = 0; 727 HRESULT res; 728 729 fi = malloc(size); 730 if (!fi) 731 return 0; 732 733 res = (*ares_fpGetNetworkParams) (fi, &size); 734 if ((res != ERROR_BUFFER_OVERFLOW) && (res != ERROR_SUCCESS)) 735 goto quit; 736 737 newfi = realloc(fi, size); 738 if (!newfi) 739 goto quit; 740 741 fi = newfi; 742 res = (*ares_fpGetNetworkParams) (fi, &size); 743 if (res != ERROR_SUCCESS) 744 goto quit; 745 746 if (debug) 747 { 748 printf ("Host Name: %s\n", fi->HostName); 749 printf ("Domain Name: %s\n", fi->DomainName); 750 printf ("DNS Servers:\n" 751 " %s (primary)\n", fi->DnsServerList.IpAddress.String); 752 } 753 if (strlen(fi->DnsServerList.IpAddress.String) > 0 && 754 inet_addr(fi->DnsServerList.IpAddress.String) != INADDR_NONE && 755 left > ipv4_size) 756 { 757 ret += sprintf (ret, "%s,", fi->DnsServerList.IpAddress.String); 758 left -= ret - ret_buf; 759 ++count; 760 } 761 762 for (i = 0, ipAddr = fi->DnsServerList.Next; ipAddr && left > ipv4_size; 763 ipAddr = ipAddr->Next, i++) 764 { 765 if (inet_addr(ipAddr->IpAddress.String) != INADDR_NONE) 766 { 767 ret += sprintf (ret, "%s,", ipAddr->IpAddress.String); 768 left -= ret - ret_buf; 769 ++count; 770 } 771 if (debug) 772 printf (" %s (secondary %d)\n", ipAddr->IpAddress.String, i+1); 773 } 774 775 quit: 776 if (fi) 777 free(fi); 778 779 if (debug && left <= ipv4_size) 780 printf ("Too many nameservers. Truncating to %d addressess", count); 781 if (ret > ret_buf) 782 ret[-1] = '\0'; 783 return count; 784 } 785 } 786 #endif 787 788 static int init_by_resolv_conf(ares_channel channel) 789 { 790 #ifndef WATT32 791 char *line = NULL; 792 #endif 793 int status = -1, nservers = 0, nsort = 0; 794 struct server_state *servers = NULL; 795 struct apattern *sortlist = NULL; 796 797 #ifdef WIN32 798 799 /* 800 NameServer info via IPHLPAPI (IP helper API): 801 GetNetworkParams() should be the trusted source for this. 802 Available in Win-98/2000 and later. If that fail, fall-back to 803 registry information. 804 805 NameServer Registry: 806 807 On Windows 9X, the DNS server can be found in: 808 HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\VxD\MSTCP\NameServer 809 810 On Windows NT/2000/XP/2003: 811 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\NameServer 812 or 813 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\DhcpNameServer 814 or 815 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\{AdapterID}\ 816 NameServer 817 or 818 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\{AdapterID}\ 819 DhcpNameServer 820 */ 821 822 HKEY mykey; 823 HKEY subkey; 824 DWORD data_type; 825 DWORD bytes; 826 DWORD result; 827 char buf[512]; 828 win_platform platform; 829 830 if (channel->nservers > -1) /* don't override ARES_OPT_SERVER */ 831 return ARES_SUCCESS; 832 833 if (get_iphlpapi_dns_info(buf,sizeof(buf)) > 0) 834 { 835 status = config_nameserver(&servers, &nservers, buf); 836 if (status == ARES_SUCCESS) 837 goto okay; 838 } 839 840 platform = ares__getplatform(); 841 842 if (platform == WIN_NT) 843 { 844 if (RegOpenKeyEx( 845 HKEY_LOCAL_MACHINE, WIN_NS_NT_KEY, 0, 846 KEY_READ, &mykey 847 ) == ERROR_SUCCESS) 848 { 849 RegOpenKeyEx(mykey, "Interfaces", 0, 850 KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS, &subkey); 851 if (get_res_nt(mykey, NAMESERVER, &line)) 852 { 853 status = config_nameserver(&servers, &nservers, line); 854 free(line); 855 } 856 else if (get_res_nt(mykey, DHCPNAMESERVER, &line)) 857 { 858 status = config_nameserver(&servers, &nservers, line); 859 free(line); 860 } 861 /* Try the interfaces */ 862 else if (get_res_interfaces_nt(subkey, NAMESERVER, &line)) 863 { 864 status = config_nameserver(&servers, &nservers, line); 865 free(line); 866 } 867 else if (get_res_interfaces_nt(subkey, DHCPNAMESERVER, &line)) 868 { 869 status = config_nameserver(&servers, &nservers, line); 870 free(line); 871 } 872 RegCloseKey(subkey); 873 RegCloseKey(mykey); 874 } 875 } 876 else if (platform == WIN_9X) 877 { 878 if (RegOpenKeyEx( 879 HKEY_LOCAL_MACHINE, WIN_NS_9X, 0, 880 KEY_READ, &mykey 881 ) == ERROR_SUCCESS) 882 { 883 if ((result = RegQueryValueEx( 884 mykey, NAMESERVER, NULL, &data_type, 885 NULL, &bytes 886 ) 887 ) == ERROR_SUCCESS || 888 result == ERROR_MORE_DATA) 889 { 890 if (bytes) 891 { 892 line = malloc(bytes+1); 893 if (RegQueryValueEx(mykey, NAMESERVER, NULL, &data_type, 894 (unsigned char *)line, &bytes) == 895 ERROR_SUCCESS) 896 { 897 status = config_nameserver(&servers, &nservers, line); 898 } 899 free(line); 900 } 901 } 902 } 903 RegCloseKey(mykey); 904 } 905 906 if (status == ARES_SUCCESS) 907 status = ARES_EOF; 908 else 909 /* Catch the case when all the above checks fail (which happens when there 910 is no network card or the cable is unplugged) */ 911 status = ARES_EFILE; 912 913 #elif defined(__riscos__) 914 915 /* Under RISC OS, name servers are listed in the 916 system variable Inet$Resolvers, space separated. */ 917 918 line = getenv("Inet$Resolvers"); 919 status = ARES_EOF; 920 if (line) { 921 char *resolvers = strdup(line), *pos, *space; 922 923 if (!resolvers) 924 return ARES_ENOMEM; 925 926 pos = resolvers; 927 do { 928 space = strchr(pos, ' '); 929 if (space) 930 *space = '\0'; 931 status = config_nameserver(&servers, &nservers, pos); 932 if (status != ARES_SUCCESS) 933 break; 934 pos = space + 1; 935 } while (space); 936 937 if (status == ARES_SUCCESS) 938 status = ARES_EOF; 939 940 free(resolvers); 941 } 942 943 #elif defined(WATT32) 944 int i; 945 946 sock_init(); 947 for (i = 0; def_nameservers[i]; i++) 948 ; 949 if (i == 0) 950 return ARES_SUCCESS; /* use localhost DNS server */ 951 952 nservers = i; 953 servers = calloc(i, sizeof(struct server_state)); 954 if (!servers) 955 return ARES_ENOMEM; 956 957 for (i = 0; def_nameservers[i]; i++) 958 { 959 servers[i].addr.addrV4.s_addr = htonl(def_nameservers[i]); 960 servers[i].addr.family = AF_INET; 961 } 962 status = ARES_EOF; 963 964 #elif defined(ANDROID) 965 char value[PROP_VALUE_MAX]=""; 966 __system_property_get("net.dns1", value); 967 status = config_nameserver(&servers, &nservers, value); 968 if (status == ARES_SUCCESS) 969 status = ARES_EOF; 970 #else 971 { 972 char *p; 973 FILE *fp; 974 size_t linesize; 975 int error; 976 977 /* Don't read resolv.conf and friends if we don't have to */ 978 if (ARES_CONFIG_CHECK(channel)) 979 return ARES_SUCCESS; 980 981 fp = fopen(PATH_RESOLV_CONF, "r"); 982 if (fp) { 983 while ((status = ares__read_line(fp, &line, &linesize)) == ARES_SUCCESS) 984 { 985 if ((p = try_config(line, "domain", ';'))) 986 status = config_domain(channel, p); 987 else if ((p = try_config(line, "lookup", ';')) && !channel->lookups) 988 status = config_lookup(channel, p, "bind", "file"); 989 else if ((p = try_config(line, "search", ';'))) 990 status = set_search(channel, p); 991 else if ((p = try_config(line, "nameserver", ';')) && 992 channel->nservers == -1) 993 status = config_nameserver(&servers, &nservers, p); 994 else if ((p = try_config(line, "sortlist", ';')) && 995 channel->nsort == -1) 996 status = config_sortlist(&sortlist, &nsort, p); 997 else if ((p = try_config(line, "options", ';'))) 998 status = set_options(channel, p); 999 else 1000 status = ARES_SUCCESS; 1001 if (status != ARES_SUCCESS) 1002 break; 1003 } 1004 fclose(fp); 1005 } 1006 else { 1007 error = ERRNO; 1008 switch(error) { 1009 case ENOENT: 1010 case ESRCH: 1011 status = ARES_EOF; 1012 break; 1013 default: 1014 DEBUGF(fprintf(stderr, "fopen() failed with error: %d %s\n", 1015 error, strerror(error))); 1016 DEBUGF(fprintf(stderr, "Error opening file: %s\n", PATH_RESOLV_CONF)); 1017 status = ARES_EFILE; 1018 } 1019 } 1020 1021 if ((status == ARES_EOF) && (!channel->lookups)) { 1022 /* Many systems (Solaris, Linux, BSD's) use nsswitch.conf */ 1023 fp = fopen("/etc/nsswitch.conf", "r"); 1024 if (fp) { 1025 while ((status = ares__read_line(fp, &line, &linesize)) == ARES_SUCCESS) 1026 { 1027 if ((p = try_config(line, "hosts:", '\0')) && !channel->lookups) 1028 /* ignore errors */ 1029 (void)config_lookup(channel, p, "dns", "files"); 1030 } 1031 fclose(fp); 1032 } 1033 else { 1034 error = ERRNO; 1035 switch(error) { 1036 case ENOENT: 1037 case ESRCH: 1038 status = ARES_EOF; 1039 break; 1040 default: 1041 DEBUGF(fprintf(stderr, "fopen() failed with error: %d %s\n", 1042 error, strerror(error))); 1043 DEBUGF(fprintf(stderr, "Error opening file: %s\n", "/etc/nsswitch.conf")); 1044 status = ARES_EFILE; 1045 } 1046 } 1047 } 1048 1049 if ((status == ARES_EOF) && (!channel->lookups)) { 1050 /* Linux / GNU libc 2.x and possibly others have host.conf */ 1051 fp = fopen("/etc/host.conf", "r"); 1052 if (fp) { 1053 while ((status = ares__read_line(fp, &line, &linesize)) == ARES_SUCCESS) 1054 { 1055 if ((p = try_config(line, "order", '\0')) && !channel->lookups) 1056 /* ignore errors */ 1057 (void)config_lookup(channel, p, "bind", "hosts"); 1058 } 1059 fclose(fp); 1060 } 1061 else { 1062 error = ERRNO; 1063 switch(error) { 1064 case ENOENT: 1065 case ESRCH: 1066 status = ARES_EOF; 1067 break; 1068 default: 1069 DEBUGF(fprintf(stderr, "fopen() failed with error: %d %s\n", 1070 error, strerror(error))); 1071 DEBUGF(fprintf(stderr, "Error opening file: %s\n", "/etc/host.conf")); 1072 status = ARES_EFILE; 1073 } 1074 } 1075 } 1076 1077 if ((status == ARES_EOF) && (!channel->lookups)) { 1078 /* Tru64 uses /etc/svc.conf */ 1079 fp = fopen("/etc/svc.conf", "r"); 1080 if (fp) { 1081 while ((status = ares__read_line(fp, &line, &linesize)) == ARES_SUCCESS) 1082 { 1083 if ((p = try_config(line, "hosts=", '\0')) && !channel->lookups) 1084 /* ignore errors */ 1085 (void)config_lookup(channel, p, "bind", "local"); 1086 } 1087 fclose(fp); 1088 } 1089 else { 1090 error = ERRNO; 1091 switch(error) { 1092 case ENOENT: 1093 case ESRCH: 1094 status = ARES_EOF; 1095 break; 1096 default: 1097 DEBUGF(fprintf(stderr, "fopen() failed with error: %d %s\n", 1098 error, strerror(error))); 1099 DEBUGF(fprintf(stderr, "Error opening file: %s\n", "/etc/svc.conf")); 1100 status = ARES_EFILE; 1101 } 1102 } 1103 } 1104 1105 if(line) 1106 free(line); 1107 } 1108 1109 #endif 1110 1111 /* Handle errors. */ 1112 if (status != ARES_EOF) 1113 { 1114 if (servers != NULL) 1115 free(servers); 1116 if (sortlist != NULL) 1117 free(sortlist); 1118 return status; 1119 } 1120 1121 /* If we got any name server entries, fill them in. */ 1122 #ifdef WIN32 1123 okay: 1124 #endif 1125 if (servers) 1126 { 1127 channel->servers = servers; 1128 channel->nservers = nservers; 1129 } 1130 1131 /* If we got any sortlist entries, fill them in. */ 1132 if (sortlist) 1133 { 1134 channel->sortlist = sortlist; 1135 channel->nsort = nsort; 1136 } 1137 1138 return ARES_SUCCESS; 1139 } 1140 1141 static int init_by_defaults(ares_channel channel) 1142 { 1143 char *hostname = NULL; 1144 int rc = ARES_SUCCESS; 1145 #ifdef HAVE_GETHOSTNAME 1146 char *dot; 1147 #endif 1148 1149 if (channel->flags == -1) 1150 channel->flags = 0; 1151 if (channel->timeout == -1) 1152 channel->timeout = DEFAULT_TIMEOUT; 1153 if (channel->tries == -1) 1154 channel->tries = DEFAULT_TRIES; 1155 if (channel->ndots == -1) 1156 channel->ndots = 1; 1157 if (channel->rotate == -1) 1158 channel->rotate = 0; 1159 if (channel->udp_port == -1) 1160 channel->udp_port = htons(NAMESERVER_PORT); 1161 if (channel->tcp_port == -1) 1162 channel->tcp_port = htons(NAMESERVER_PORT); 1163 1164 if (channel->nservers == -1) { 1165 /* If nobody specified servers, try a local named. */ 1166 channel->servers = malloc(sizeof(struct server_state)); 1167 if (!channel->servers) { 1168 rc = ARES_ENOMEM; 1169 goto error; 1170 } 1171 channel->servers[0].addr.family = AF_INET; 1172 channel->servers[0].addr.addrV4.s_addr = htonl(INADDR_LOOPBACK); 1173 channel->nservers = 1; 1174 } 1175 1176 #if defined(USE_WINSOCK) 1177 #define toolong(x) (x == -1) && (SOCKERRNO == WSAEFAULT) 1178 #elif defined(ENAMETOOLONG) 1179 #define toolong(x) (x == -1) && ((SOCKERRNO == ENAMETOOLONG) || \ 1180 (SOCKERRNO == EINVAL)) 1181 #else 1182 #define toolong(x) (x == -1) && (SOCKERRNO == EINVAL) 1183 #endif 1184 1185 if (channel->ndomains == -1) { 1186 /* Derive a default domain search list from the kernel hostname, 1187 * or set it to empty if the hostname isn't helpful. 1188 */ 1189 size_t len = 64; 1190 int res; 1191 channel->ndomains = 0; /* default to none */ 1192 1193 #ifdef HAVE_GETHOSTNAME 1194 hostname = malloc(len); 1195 if(!hostname) { 1196 rc = ARES_ENOMEM; 1197 goto error; 1198 } 1199 1200 do { 1201 res = gethostname(hostname, len); 1202 1203 if(toolong(res)) { 1204 char *p; 1205 len *= 2; 1206 p = realloc(hostname, len); 1207 if(!p) { 1208 rc = ARES_ENOMEM; 1209 goto error; 1210 } 1211 hostname = p; 1212 continue; 1213 } 1214 else if(res) { 1215 rc = ARES_EBADNAME; 1216 goto error; 1217 } 1218 1219 } while(0); 1220 1221 dot = strchr(hostname, '.'); 1222 if (dot) { 1223 /* a dot was found */ 1224 channel->domains = malloc(sizeof(char *)); 1225 if (!channel->domains) { 1226 rc = ARES_ENOMEM; 1227 goto error; 1228 } 1229 channel->domains[0] = strdup(dot + 1); 1230 if (!channel->domains[0]) { 1231 rc = ARES_ENOMEM; 1232 goto error; 1233 } 1234 channel->ndomains = 1; 1235 } 1236 #endif 1237 } 1238 1239 if (channel->nsort == -1) { 1240 channel->sortlist = NULL; 1241 channel->nsort = 0; 1242 } 1243 1244 if (!channel->lookups) { 1245 channel->lookups = strdup("fb"); 1246 if (!channel->lookups) 1247 rc = ARES_ENOMEM; 1248 } 1249 1250 error: 1251 if(rc) { 1252 if(channel->servers) 1253 free(channel->servers); 1254 1255 if(channel->domains && channel->domains[0]) 1256 free(channel->domains[0]); 1257 if(channel->domains) 1258 free(channel->domains); 1259 if(channel->lookups) 1260 free(channel->lookups); 1261 } 1262 1263 if(hostname) 1264 free(hostname); 1265 1266 return rc; 1267 } 1268 1269 #if !defined(WIN32) && !defined(WATT32) 1270 static int config_domain(ares_channel channel, char *str) 1271 { 1272 char *q; 1273 1274 /* Set a single search domain. */ 1275 q = str; 1276 while (*q && !ISSPACE(*q)) 1277 q++; 1278 *q = '\0'; 1279 return set_search(channel, str); 1280 } 1281 1282 #if defined(__INTEL_COMPILER) && (__INTEL_COMPILER == 910) && \ 1283 defined(__OPTIMIZE__) && defined(__unix__) && defined(__i386__) 1284 /* workaround icc 9.1 optimizer issue */ 1285 # define vqualifier volatile 1286 #else 1287 # define vqualifier 1288 #endif 1289 1290 static int config_lookup(ares_channel channel, const char *str, 1291 const char *bindch, const char *filech) 1292 { 1293 char lookups[3], *l; 1294 const char *vqualifier p; 1295 1296 /* Set the lookup order. Only the first letter of each work 1297 * is relevant, and it has to be "b" for DNS or "f" for the 1298 * host file. Ignore everything else. 1299 */ 1300 l = lookups; 1301 p = str; 1302 while (*p) 1303 { 1304 if ((*p == *bindch || *p == *filech) && l < lookups + 2) { 1305 if (*p == *bindch) *l++ = 'b'; 1306 else *l++ = 'f'; 1307 } 1308 while (*p && !ISSPACE(*p) && (*p != ',')) 1309 p++; 1310 while (*p && (ISSPACE(*p) || (*p == ','))) 1311 p++; 1312 } 1313 *l = '\0'; 1314 channel->lookups = strdup(lookups); 1315 return (channel->lookups) ? ARES_SUCCESS : ARES_ENOMEM; 1316 } 1317 #endif /* !WIN32 & !WATT32 */ 1318 1319 #ifndef WATT32 1320 static int config_nameserver(struct server_state **servers, int *nservers, 1321 char *str) 1322 { 1323 struct ares_addr host; 1324 struct server_state *newserv; 1325 char *p, *txtaddr; 1326 /* On Windows, there may be more than one nameserver specified in the same 1327 * registry key, so we parse input as a space or comma seperated list. 1328 */ 1329 for (p = str; p;) 1330 { 1331 /* Skip whitespace and commas. */ 1332 while (*p && (ISSPACE(*p) || (*p == ','))) 1333 p++; 1334 if (!*p) 1335 /* No more input, done. */ 1336 break; 1337 1338 /* Pointer to start of IPv4 or IPv6 address part. */ 1339 txtaddr = p; 1340 1341 /* Advance past this address. */ 1342 while (*p && !ISSPACE(*p) && (*p != ',')) 1343 p++; 1344 if (*p) 1345 /* Null terminate this address. */ 1346 *p++ = '\0'; 1347 else 1348 /* Reached end of input, done when this address is processed. */ 1349 p = NULL; 1350 1351 /* Convert textual address to binary format. */ 1352 if (ares_inet_pton(AF_INET, txtaddr, &host.addrV4) == 1) 1353 host.family = AF_INET; 1354 else if (ares_inet_pton(AF_INET6, txtaddr, &host.addrV6) == 1) 1355 host.family = AF_INET6; 1356 else 1357 continue; 1358 1359 /* Resize servers state array. */ 1360 newserv = realloc(*servers, (*nservers + 1) * 1361 sizeof(struct server_state)); 1362 if (!newserv) 1363 return ARES_ENOMEM; 1364 1365 /* Store address data. */ 1366 newserv[*nservers].addr.family = host.family; 1367 if (host.family == AF_INET) 1368 memcpy(&newserv[*nservers].addr.addrV4, &host.addrV4, 1369 sizeof(host.addrV4)); 1370 else 1371 memcpy(&newserv[*nservers].addr.addrV6, &host.addrV6, 1372 sizeof(host.addrV6)); 1373 1374 /* Update arguments. */ 1375 *servers = newserv; 1376 *nservers += 1; 1377 } 1378 1379 return ARES_SUCCESS; 1380 } 1381 1382 #ifndef WIN32 1383 static int config_sortlist(struct apattern **sortlist, int *nsort, 1384 const char *str) 1385 { 1386 struct apattern pat; 1387 const char *q; 1388 1389 /* Add sortlist entries. */ 1390 while (*str && *str != ';') 1391 { 1392 int bits; 1393 char ipbuf[16], ipbufpfx[32]; 1394 /* Find just the IP */ 1395 q = str; 1396 while (*q && *q != '/' && *q != ';' && !ISSPACE(*q)) 1397 q++; 1398 memcpy(ipbuf, str, q-str); 1399 ipbuf[q-str] = '\0'; 1400 /* Find the prefix */ 1401 if (*q == '/') 1402 { 1403 const char *str2 = q+1; 1404 while (*q && *q != ';' && !ISSPACE(*q)) 1405 q++; 1406 memcpy(ipbufpfx, str, q-str); 1407 ipbufpfx[q-str] = '\0'; 1408 str = str2; 1409 } 1410 else 1411 ipbufpfx[0] = '\0'; 1412 /* Lets see if it is CIDR */ 1413 /* First we'll try IPv6 */ 1414 if ((bits = ares_inet_net_pton(AF_INET6, ipbufpfx[0] ? ipbufpfx : ipbuf, 1415 &pat.addrV6, 1416 sizeof(pat.addrV6))) > 0) 1417 { 1418 pat.type = PATTERN_CIDR; 1419 pat.mask.bits = (unsigned short)bits; 1420 pat.family = AF_INET6; 1421 if (!sortlist_alloc(sortlist, nsort, &pat)) 1422 return ARES_ENOMEM; 1423 } 1424 else if (ipbufpfx[0] && 1425 (bits = ares_inet_net_pton(AF_INET, ipbufpfx, &pat.addrV4, 1426 sizeof(pat.addrV4))) > 0) 1427 { 1428 pat.type = PATTERN_CIDR; 1429 pat.mask.bits = (unsigned short)bits; 1430 pat.family = AF_INET; 1431 if (!sortlist_alloc(sortlist, nsort, &pat)) 1432 return ARES_ENOMEM; 1433 } 1434 /* See if it is just a regular IP */ 1435 else if (ip_addr(ipbuf, q-str, &pat.addrV4) == 0) 1436 { 1437 if (ipbufpfx[0]) 1438 { 1439 memcpy(ipbuf, str, q-str); 1440 ipbuf[q-str] = '\0'; 1441 if (ip_addr(ipbuf, q-str, &pat.mask.addr4) != 0) 1442 natural_mask(&pat); 1443 } 1444 else 1445 natural_mask(&pat); 1446 pat.family = AF_INET; 1447 pat.type = PATTERN_MASK; 1448 if (!sortlist_alloc(sortlist, nsort, &pat)) 1449 return ARES_ENOMEM; 1450 } 1451 else 1452 { 1453 while (*q && *q != ';' && !ISSPACE(*q)) 1454 q++; 1455 } 1456 str = q; 1457 while (ISSPACE(*str)) 1458 str++; 1459 } 1460 1461 return ARES_SUCCESS; 1462 } 1463 #endif /* !WIN32 */ 1464 #endif /* !WATT32 */ 1465 1466 static int set_search(ares_channel channel, const char *str) 1467 { 1468 int n; 1469 const char *p, *q; 1470 1471 if(channel->ndomains != -1) { 1472 /* if we already have some domains present, free them first */ 1473 for(n=0; n < channel->ndomains; n++) 1474 free(channel->domains[n]); 1475 free(channel->domains); 1476 channel->domains = NULL; 1477 channel->ndomains = -1; 1478 } 1479 1480 /* Count the domains given. */ 1481 n = 0; 1482 p = str; 1483 while (*p) 1484 { 1485 while (*p && !ISSPACE(*p)) 1486 p++; 1487 while (ISSPACE(*p)) 1488 p++; 1489 n++; 1490 } 1491 1492 if (!n) 1493 { 1494 channel->ndomains = 0; 1495 return ARES_SUCCESS; 1496 } 1497 1498 channel->domains = malloc(n * sizeof(char *)); 1499 if (!channel->domains) 1500 return ARES_ENOMEM; 1501 1502 /* Now copy the domains. */ 1503 n = 0; 1504 p = str; 1505 while (*p) 1506 { 1507 channel->ndomains = n; 1508 q = p; 1509 while (*q && !ISSPACE(*q)) 1510 q++; 1511 channel->domains[n] = malloc(q - p + 1); 1512 if (!channel->domains[n]) 1513 return ARES_ENOMEM; 1514 memcpy(channel->domains[n], p, q - p); 1515 channel->domains[n][q - p] = 0; 1516 p = q; 1517 while (ISSPACE(*p)) 1518 p++; 1519 n++; 1520 } 1521 channel->ndomains = n; 1522 1523 return ARES_SUCCESS; 1524 } 1525 1526 static int set_options(ares_channel channel, const char *str) 1527 { 1528 const char *p, *q, *val; 1529 1530 p = str; 1531 while (*p) 1532 { 1533 q = p; 1534 while (*q && !ISSPACE(*q)) 1535 q++; 1536 val = try_option(p, q, "ndots:"); 1537 if (val && channel->ndots == -1) 1538 channel->ndots = aresx_sltosi(strtol(val, NULL, 10)); 1539 val = try_option(p, q, "retrans:"); 1540 if (val && channel->timeout == -1) 1541 channel->timeout = aresx_sltosi(strtol(val, NULL, 10)); 1542 val = try_option(p, q, "retry:"); 1543 if (val && channel->tries == -1) 1544 channel->tries = aresx_sltosi(strtol(val, NULL, 10)); 1545 val = try_option(p, q, "rotate"); 1546 if (val && channel->rotate == -1) 1547 channel->rotate = 1; 1548 p = q; 1549 while (ISSPACE(*p)) 1550 p++; 1551 } 1552 1553 return ARES_SUCCESS; 1554 } 1555 1556 static const char *try_option(const char *p, const char *q, const char *opt) 1557 { 1558 size_t len = strlen(opt); 1559 return ((size_t)(q - p) >= len && !strncmp(p, opt, len)) ? &p[len] : NULL; 1560 } 1561 1562 #if !defined(WIN32) && !defined(WATT32) 1563 static char *try_config(char *s, const char *opt, char scc) 1564 { 1565 size_t len; 1566 char *p; 1567 char *q; 1568 1569 if (!s || !opt) 1570 /* no line or no option */ 1571 return NULL; 1572 1573 /* Hash '#' character is always used as primary comment char, additionally 1574 a not-NUL secondary comment char will be considered when specified. */ 1575 1576 /* trim line comment */ 1577 p = s; 1578 if(scc) 1579 while (*p && (*p != '#') && (*p != scc)) 1580 p++; 1581 else 1582 while (*p && (*p != '#')) 1583 p++; 1584 *p = '\0'; 1585 1586 /* trim trailing whitespace */ 1587 q = p - 1; 1588 while ((q >= s) && ISSPACE(*q)) 1589 q--; 1590 *++q = '\0'; 1591 1592 /* skip leading whitespace */ 1593 p = s; 1594 while (*p && ISSPACE(*p)) 1595 p++; 1596 1597 if (!*p) 1598 /* empty line */ 1599 return NULL; 1600 1601 if ((len = strlen(opt)) == 0) 1602 /* empty option */ 1603 return NULL; 1604 1605 if (strncmp(p, opt, len) != 0) 1606 /* line and option do not match */ 1607 return NULL; 1608 1609 /* skip over given option name */ 1610 p += len; 1611 1612 if (!*p) 1613 /* no option value */ 1614 return NULL; 1615 1616 if ((opt[len-1] != ':') && (opt[len-1] != '=') && !ISSPACE(*p)) 1617 /* whitespace between option name and value is mandatory 1618 for given option names which do not end with ':' or '=' */ 1619 return NULL; 1620 1621 /* skip over whitespace */ 1622 while (*p && ISSPACE(*p)) 1623 p++; 1624 1625 if (!*p) 1626 /* no option value */ 1627 return NULL; 1628 1629 /* return pointer to option value */ 1630 return p; 1631 } 1632 1633 static int sortlist_alloc(struct apattern **sortlist, int *nsort, 1634 struct apattern *pat) 1635 { 1636 struct apattern *newsort; 1637 newsort = realloc(*sortlist, (*nsort + 1) * sizeof(struct apattern)); 1638 if (!newsort) 1639 return 0; 1640 newsort[*nsort] = *pat; 1641 *sortlist = newsort; 1642 (*nsort)++; 1643 return 1; 1644 } 1645 1646 static int ip_addr(const char *ipbuf, ssize_t len, struct in_addr *addr) 1647 { 1648 1649 /* Four octets and three periods yields at most 15 characters. */ 1650 if (len > 15) 1651 return -1; 1652 1653 addr->s_addr = inet_addr(ipbuf); 1654 if (addr->s_addr == INADDR_NONE && strcmp(ipbuf, "255.255.255.255") != 0) 1655 return -1; 1656 return 0; 1657 } 1658 1659 static void natural_mask(struct apattern *pat) 1660 { 1661 struct in_addr addr; 1662 1663 /* Store a host-byte-order copy of pat in a struct in_addr. Icky, 1664 * but portable. 1665 */ 1666 addr.s_addr = ntohl(pat->addrV4.s_addr); 1667 1668 /* This is out of date in the CIDR world, but some people might 1669 * still rely on it. 1670 */ 1671 if (IN_CLASSA(addr.s_addr)) 1672 pat->mask.addr4.s_addr = htonl(IN_CLASSA_NET); 1673 else if (IN_CLASSB(addr.s_addr)) 1674 pat->mask.addr4.s_addr = htonl(IN_CLASSB_NET); 1675 else 1676 pat->mask.addr4.s_addr = htonl(IN_CLASSC_NET); 1677 } 1678 #endif /* !WIN32 && !WATT32 */ 1679 1680 /* initialize an rc4 key. If possible a cryptographically secure random key 1681 is generated using a suitable function (for example win32's RtlGenRandom as 1682 described in 1683 http://blogs.msdn.com/michael_howard/archive/2005/01/14/353379.aspx 1684 otherwise the code defaults to cross-platform albeit less secure mechanism 1685 using rand 1686 */ 1687 static void randomize_key(unsigned char* key,int key_data_len) 1688 { 1689 int randomized = 0; 1690 int counter=0; 1691 #ifdef WIN32 1692 BOOLEAN res; 1693 if (ares_fpSystemFunction036) 1694 { 1695 res = (*ares_fpSystemFunction036) (key, key_data_len); 1696 if (res) 1697 randomized = 1; 1698 } 1699 #else /* !WIN32 */ 1700 #ifdef RANDOM_FILE 1701 FILE *f = fopen(RANDOM_FILE, "rb"); 1702 if(f) { 1703 counter = aresx_uztosi(fread(key, 1, key_data_len, f)); 1704 fclose(f); 1705 } 1706 #endif 1707 #endif /* WIN32 */ 1708 1709 if ( !randomized ) { 1710 for (;counter<key_data_len;counter++) 1711 key[counter]=(unsigned char)(rand() % 256); 1712 } 1713 } 1714 1715 static int init_id_key(rc4_key* key,int key_data_len) 1716 { 1717 unsigned char index1; 1718 unsigned char index2; 1719 unsigned char* state; 1720 short counter; 1721 unsigned char *key_data_ptr = 0; 1722 1723 key_data_ptr = calloc(1,key_data_len); 1724 if (!key_data_ptr) 1725 return ARES_ENOMEM; 1726 1727 state = &key->state[0]; 1728 for(counter = 0; counter < 256; counter++) 1729 /* unnecessary AND but it keeps some compilers happier */ 1730 state[counter] = (unsigned char)(counter & 0xff); 1731 randomize_key(key->state,key_data_len); 1732 key->x = 0; 1733 key->y = 0; 1734 index1 = 0; 1735 index2 = 0; 1736 for(counter = 0; counter < 256; counter++) 1737 { 1738 index2 = (unsigned char)((key_data_ptr[index1] + state[counter] + 1739 index2) % 256); 1740 ARES_SWAP_BYTE(&state[counter], &state[index2]); 1741 1742 index1 = (unsigned char)((index1 + 1) % key_data_len); 1743 } 1744 free(key_data_ptr); 1745 return ARES_SUCCESS; 1746 } 1747 1748 unsigned short ares__generate_new_id(rc4_key* key) 1749 { 1750 unsigned short r=0; 1751 ares__rc4(key, (unsigned char *)&r, sizeof(r)); 1752 return r; 1753 } 1754 1755 void ares_set_local_ip4(ares_channel channel, unsigned int local_ip) 1756 { 1757 channel->local_ip4 = local_ip; 1758 } 1759 1760 /* local_ip6 should be 16 bytes in length */ 1761 void ares_set_local_ip6(ares_channel channel, 1762 const unsigned char* local_ip6) 1763 { 1764 memcpy(&channel->local_ip6, local_ip6, sizeof(channel->local_ip6)); 1765 } 1766 1767 /* local_dev_name should be null terminated. */ 1768 void ares_set_local_dev(ares_channel channel, 1769 const char* local_dev_name) 1770 { 1771 strncpy(channel->local_dev_name, local_dev_name, 1772 sizeof(channel->local_dev_name)); 1773 channel->local_dev_name[sizeof(channel->local_dev_name) - 1] = 0; 1774 } 1775 1776 1777 void ares_set_socket_callback(ares_channel channel, 1778 ares_sock_create_callback cb, 1779 void *data) 1780 { 1781 channel->sock_create_cb = cb; 1782 channel->sock_create_cb_data = data; 1783 } 1784 1785 void ares__init_servers_state(ares_channel channel) 1786 { 1787 struct server_state *server; 1788 int i; 1789 1790 for (i = 0; i < channel->nservers; i++) 1791 { 1792 server = &channel->servers[i]; 1793 server->udp_socket = ARES_SOCKET_BAD; 1794 server->tcp_socket = ARES_SOCKET_BAD; 1795 server->tcp_connection_generation = ++channel->tcp_connection_generation; 1796 server->tcp_lenbuf_pos = 0; 1797 server->tcp_buffer_pos = 0; 1798 server->tcp_buffer = NULL; 1799 server->tcp_length = 0; 1800 server->qhead = NULL; 1801 server->qtail = NULL; 1802 ares__init_list_head(&server->queries_to_server); 1803 server->channel = channel; 1804 server->is_broken = 0; 1805 } 1806 } 1807
