text: 
  /* Copyright 1998 by the Massachusetts Institute of Technology.
   * Copyright (C) 2007-2011 by Daniel Stenberg
   *
   * Permission to use, copy, modify, and distribute this
   * software and its documentation for any purpose and without
   * fee is hereby granted, provided that the above copyright
   * notice appear in all copies and that both that copyright
   * notice and this permission notice appear in supporting
   * documentation, and that the name of M.I.T. not be used in
   * advertising or publicity pertaining to distribution of the
   * software without specific, written prior permission.
   * M.I.T. makes no representations about the suitability of
   * this software for any purpose.  It is provided "as is"
   * without express or implied warranty.
   */
  
  #include "ares_setup.h"
  
  #ifdef HAVE_SYS_PARAM_H
  #include <sys/param.h>
  #endif
  
  #ifdef HAVE_SYS_TIME_H
  #include <sys/time.h>
  #endif
  
  #ifdef HAVE_SYS_SOCKET_H
  #include <sys/socket.h>
  #endif
  
  #ifdef HAVE_NETINET_IN_H
  #include <netinet/in.h>
  #endif
  
  #ifdef HAVE_NETDB_H
  #include <netdb.h>
  #endif
  
  #ifdef HAVE_ARPA_INET_H
  #include <arpa/inet.h>
  #endif
  
  #ifdef HAVE_ARPA_NAMESER_H
  #  include <arpa/nameser.h>
  #else
  #  include "nameser.h"
  #endif
  #ifdef HAVE_ARPA_NAMESER_COMPAT_H
  #  include <arpa/nameser_compat.h>
  #endif
  
  #ifdef HAVE_UNISTD_H
  #include <unistd.h>
  #endif
  
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include <ctype.h>
  #include <time.h>
  
  #ifdef ANDROID
  #include <sys/system_properties.h>
  #endif
  
  #include "ares.h"
  #include "inet_net_pton.h"
  #include "ares_library_init.h"
  #include "ares_nowarn.h"
  #include "ares_platform.h"
  #include "inet_ntop.h"
  #include "ares_private.h"
  
  #ifdef WATT32
  #undef WIN32  /* Redefined in MingW/MSVC headers */
  #endif
  
  static int init_by_options(ares_channel channel, const struct ares_options *options,
                             int optmask);
  static int init_by_environment(ares_channel channel);
  static int init_by_resolv_conf(ares_channel channel);
  static int init_by_defaults(ares_channel channel);
  
  #ifndef WATT32
  static int config_nameserver(struct server_state **servers, int *nservers,
                               char *str);
  #endif
  static int set_search(ares_channel channel, const char *str);
  static int set_options(ares_channel channel, const char *str);
  static const char *try_option(const char *p, const char *q, const char *opt);
  static int init_id_key(rc4_key* key,int key_data_len);
  
  #if !defined(WIN32) && !defined(WATT32)
  static int sortlist_alloc(struct apattern **sortlist, int *nsort, struct apattern *pat);
  static int ip_addr(const char *s, ssize_t len, struct in_addr *addr);
  static void natural_mask(struct apattern *pat);
  static int config_domain(ares_channel channel, char *str);
  static int config_lookup(ares_channel channel, const char *str,
                           const char *bindch, const char *filech);
  static int config_sortlist(struct apattern **sortlist, int *nsort,
                             const char *str);
  static char *try_config(char *s, const char *opt, char scc);
  #endif
  
  #define ARES_CONFIG_CHECK(x) (x->lookups && x->nsort > -1 && \
                               x->nservers > -1 && \
                               x->ndomains > -1 && \
                               x->ndots > -1 && x->timeout > -1 && \
                               x->tries > -1)
  
  int ares_init(ares_channel *channelptr)
  {
    return ares_init_options(channelptr, NULL, 0);
  }
  
  int ares_init_options(ares_channel *channelptr, struct ares_options *options,
                        int optmask)
  {
    ares_channel channel;
    int i;
    int status = ARES_SUCCESS;
    struct timeval now;
  
  #ifdef CURLDEBUG
    const char *env = getenv("CARES_MEMDEBUG");
  
    if (env)
      curl_memdebug(env);
    env = getenv("CARES_MEMLIMIT");
    if (env) {
      char *endptr;
      long num = strtol(env, &endptr, 10);
      if((endptr != env) && (endptr == env + strlen(env)) && (num > 0))
        curl_memlimit(num);
    }
  #endif
  
    if (ares_library_initialized() != ARES_SUCCESS)
      return ARES_ENOTINITIALIZED;
  
    channel = malloc(sizeof(struct ares_channeldata));
    if (!channel) {
      *channelptr = NULL;
      return ARES_ENOMEM;
    }
  
    now = ares__tvnow();
  
    /* Set everything to distinguished values so we know they haven't
     * been set yet.
     */
    channel->flags = -1;
    channel->timeout = -1;
    channel->tries = -1;
    channel->ndots = -1;
    channel->rotate = -1;
    channel->udp_port = -1;
    channel->tcp_port = -1;
    channel->socket_send_buffer_size = -1;
    channel->socket_receive_buffer_size = -1;
    channel->nservers = -1;
    channel->ndomains = -1;
    channel->nsort = -1;
    channel->tcp_connection_generation = 0;
    channel->lookups = NULL;
    channel->domains = NULL;
    channel->sortlist = NULL;
    channel->servers = NULL;
    channel->sock_state_cb = NULL;
    channel->sock_state_cb_data = NULL;
    channel->sock_create_cb = NULL;
    channel->sock_create_cb_data = NULL;
  
    channel->last_server = 0;
    channel->last_timeout_processed = (time_t)now.tv_sec;
  
    memset(&channel->local_dev_name, 0, sizeof(channel->local_dev_name));
    channel->local_ip4 = 0;
    memset(&channel->local_ip6, 0, sizeof(channel->local_ip6));
  
    /* Initialize our lists of queries */
    ares__init_list_head(&(channel->all_queries));
    for (i = 0; i < ARES_QID_TABLE_SIZE; i++)
      {
        ares__init_list_head(&(channel->queries_by_qid[i]));
      }
    for (i = 0; i < ARES_TIMEOUT_TABLE_SIZE; i++)
      {
        ares__init_list_head(&(channel->queries_by_timeout[i]));
      }
  
    /* Initialize configuration by each of the four sources, from highest
     * precedence to lowest.
     */
  
    if (status == ARES_SUCCESS) {
      status = init_by_options(channel, options, optmask);
      if (status != ARES_SUCCESS)
        DEBUGF(fprintf(stderr, "Error: init_by_options failed: %s\n",
                       ares_strerror(status)));
    }
    if (status == ARES_SUCCESS) {
      status = init_by_environment(channel);
      if (status != ARES_SUCCESS)
        DEBUGF(fprintf(stderr, "Error: init_by_environment failed: %s\n",
                       ares_strerror(status)));
    }
    if (status == ARES_SUCCESS) {
      status = init_by_resolv_conf(channel);
      if (status != ARES_SUCCESS)
        DEBUGF(fprintf(stderr, "Error: init_by_resolv_conf failed: %s\n",
                       ares_strerror(status)));
    }
  
    /*
     * No matter what failed or succeeded, seed defaults to provide
     * useful behavior for things that we missed.
     */
    status = init_by_defaults(channel);
    if (status != ARES_SUCCESS)
      DEBUGF(fprintf(stderr, "Error: init_by_defaults failed: %s\n",
                     ares_strerror(status)));
  
    /* Generate random key */
  
    if (status == ARES_SUCCESS) {
      status = init_id_key(&channel->id_key, ARES_ID_KEY_LEN);
      if (status == ARES_SUCCESS)
        channel->next_id = ares__generate_new_id(&channel->id_key);
      else
        DEBUGF(fprintf(stderr, "Error: init_id_key failed: %s\n",
                       ares_strerror(status)));
    }
  
    if (status != ARES_SUCCESS)
      {
        /* Something failed; clean up memory we may have allocated. */
        if (channel->servers)
          free(channel->servers);
        if (channel->domains)
          {
            for (i = 0; i < channel->ndomains; i++)
              free(channel->domains[i]);
            free(channel->domains);
          }
        if (channel->sortlist)
          free(channel->sortlist);
        if(channel->lookups)
          free(channel->lookups);
        free(channel);
        return status;
      }
  
    /* Trim to one server if ARES_FLAG_PRIMARY is set. */
    if ((channel->flags & ARES_FLAG_PRIMARY) && channel->nservers > 1)
      channel->nservers = 1;
  
    ares__init_servers_state(channel);
  
    *channelptr = channel;
    return ARES_SUCCESS;
  }
  
  /* ares_dup() duplicates a channel handle with all its options and returns a
     new channel handle */
  int ares_dup(ares_channel *dest, ares_channel src)
  {
    struct ares_options opts;
    struct ares_addr_node *servers;
    int ipv6_nservers = 0;
    int i, rc;
    int optmask;
  
    *dest = NULL; /* in case of failure return NULL explicitly */
  
    /* First get the options supported by the old ares_save_options() function,
       which is most of them */
    rc = ares_save_options(src, &opts, &optmask);
    if(rc)
      return rc;
  
    /* Then create the new channel with those options */
    rc = ares_init_options(dest, &opts, optmask);
  
    /* destroy the options copy to not leak any memory */
    ares_destroy_options(&opts);
  
    if(rc)
      return rc;
  
    /* Now clone the options that ares_save_options() doesn't support. */
    (*dest)->sock_create_cb      = src->sock_create_cb;
    (*dest)->sock_create_cb_data = src->sock_create_cb_data;
  
    strncpy((*dest)->local_dev_name, src->local_dev_name, sizeof(src->local_dev_name));
    (*dest)->local_ip4 = src->local_ip4;
    memcpy((*dest)->local_ip6, src->local_ip6, sizeof(src->local_ip6));
  
    /* Full name server cloning required when not all are IPv4 */
    for (i = 0; i < src->nservers; i++)
      {
        if (src->servers[i].addr.family != AF_INET) {
          ipv6_nservers++;
          break;
        }
      }
    if (ipv6_nservers) {
      rc = ares_get_servers(src, &servers);
      if (rc != ARES_SUCCESS)
        return rc;
      rc = ares_set_servers(*dest, servers);
      ares_free_data(servers);
      if (rc != ARES_SUCCESS)
        return rc;
    }
  
    return ARES_SUCCESS; /* everything went fine */
  }
  
  /* Save options from initialized channel */
  int ares_save_options(ares_channel channel, struct ares_options *options,
                        int *optmask)
  {
    int i, j;
    int ipv4_nservers = 0;
  
    /* Zero everything out */
    memset(options, 0, sizeof(struct ares_options));
  
    if (!ARES_CONFIG_CHECK(channel))
      return ARES_ENODATA;
  
    /* Traditionally the optmask wasn't saved in the channel struct so it was
       recreated here. ROTATE is the first option that has no struct field of
       its own in the public config struct */
    (*optmask) = (ARES_OPT_FLAGS|ARES_OPT_TRIES|ARES_OPT_NDOTS|
                  ARES_OPT_UDP_PORT|ARES_OPT_TCP_PORT|ARES_OPT_SOCK_STATE_CB|
                  ARES_OPT_SERVERS|ARES_OPT_DOMAINS|ARES_OPT_LOOKUPS|
                  ARES_OPT_SORTLIST|ARES_OPT_TIMEOUTMS) |
      (channel->optmask & ARES_OPT_ROTATE);
  
    /* Copy easy stuff */
    options->flags   = channel->flags;
  
    /* We return full millisecond resolution but that's only because we don't
       set the ARES_OPT_TIMEOUT anymore, only the new ARES_OPT_TIMEOUTMS */
    options->timeout = channel->timeout;
    options->tries   = channel->tries;
    options->ndots   = channel->ndots;
    options->udp_port = (unsigned short)channel->udp_port;
    options->tcp_port = (unsigned short)channel->tcp_port;
    options->sock_state_cb     = channel->sock_state_cb;
    options->sock_state_cb_data = channel->sock_state_cb_data;
  
    /* Copy IPv4 servers */
    if (channel->nservers) {
      for (i = 0; i < channel->nservers; i++)
      {
        if (channel->servers[i].addr.family == AF_INET)
          ipv4_nservers++;
      }
      if (ipv4_nservers) {
        options->servers = malloc(ipv4_nservers * sizeof(struct in_addr));
        if (!options->servers)
          return ARES_ENOMEM;
        for (i = j = 0; i < channel->nservers; i++)
        {
          if (channel->servers[i].addr.family == AF_INET)
            memcpy(&options->servers[j++],
                   &channel->servers[i].addr.addrV4,
                   sizeof(channel->servers[i].addr.addrV4));
        }
      }
    }
    options->nservers = ipv4_nservers;
  
    /* copy domains */
    if (channel->ndomains) {
      options->domains = malloc(channel->ndomains * sizeof(char *));
      if (!options->domains)
        return ARES_ENOMEM;
  
      for (i = 0; i < channel->ndomains; i++)
      {
        options->ndomains = i;
        options->domains[i] = strdup(channel->domains[i]);
        if (!options->domains[i])
          return ARES_ENOMEM;
      }
    }
    options->ndomains = channel->ndomains;
  
    /* copy lookups */
    if (channel->lookups) {
      options->lookups = strdup(channel->lookups);
      if (!options->lookups && channel->lookups)
        return ARES_ENOMEM;
    }
  
    /* copy sortlist */
    if (channel->nsort) {
      options->sortlist = malloc(channel->nsort * sizeof(struct apattern));
      if (!options->sortlist)
        return ARES_ENOMEM;
      for (i = 0; i < channel->nsort; i++)
        options->sortlist[i] = channel->sortlist[i];
    }
    options->nsort = channel->nsort;
  
    return ARES_SUCCESS;
  }
  
  static int init_by_options(ares_channel channel,
                             const struct ares_options *options,
                             int optmask)
  {
    int i;
  
    /* Easy stuff. */
    if ((optmask & ARES_OPT_FLAGS) && channel->flags == -1)
      channel->flags = options->flags;
    if ((optmask & ARES_OPT_TIMEOUTMS) && channel->timeout == -1)
      channel->timeout = options->timeout;
    else if ((optmask & ARES_OPT_TIMEOUT) && channel->timeout == -1)
      channel->timeout = options->timeout * 1000;
    if ((optmask & ARES_OPT_TRIES) && channel->tries == -1)
      channel->tries = options->tries;
    if ((optmask & ARES_OPT_NDOTS) && channel->ndots == -1)
      channel->ndots = options->ndots;
    if ((optmask & ARES_OPT_ROTATE) && channel->rotate == -1)
      channel->rotate = 1;
    if ((optmask & ARES_OPT_UDP_PORT) && channel->udp_port == -1)
      channel->udp_port = options->udp_port;
    if ((optmask & ARES_OPT_TCP_PORT) && channel->tcp_port == -1)
      channel->tcp_port = options->tcp_port;
    if ((optmask & ARES_OPT_SOCK_STATE_CB) && channel->sock_state_cb == NULL)
      {
        channel->sock_state_cb = options->sock_state_cb;
        channel->sock_state_cb_data = options->sock_state_cb_data;
      }
    if ((optmask & ARES_OPT_SOCK_SNDBUF)
        && channel->socket_send_buffer_size == -1)
      channel->socket_send_buffer_size = options->socket_send_buffer_size;
    if ((optmask & ARES_OPT_SOCK_RCVBUF)
        && channel->socket_receive_buffer_size == -1)
      channel->socket_receive_buffer_size = options->socket_receive_buffer_size;
  
    /* Copy the IPv4 servers, if given. */
    if ((optmask & ARES_OPT_SERVERS) && channel->nservers == -1)
      {
        /* Avoid zero size allocations at any cost */
        if (options->nservers > 0)
          {
            channel->servers =
              malloc(options->nservers * sizeof(struct server_state));
            if (!channel->servers)
              return ARES_ENOMEM;
            for (i = 0; i < options->nservers; i++)
              {
                channel->servers[i].addr.family = AF_INET;
                memcpy(&channel->servers[i].addr.addrV4,
                       &options->servers[i],
                       sizeof(channel->servers[i].addr.addrV4));
              }
          }
        channel->nservers = options->nservers;
      }
  
    /* Copy the domains, if given.  Keep channel->ndomains consistent so
     * we can clean up in case of error.
     */
    if ((optmask & ARES_OPT_DOMAINS) && channel->ndomains == -1)
      {
        /* Avoid zero size allocations at any cost */
        if (options->ndomains > 0)
        {
          channel->domains = malloc(options->ndomains * sizeof(char *));
          if (!channel->domains)
            return ARES_ENOMEM;
          for (i = 0; i < options->ndomains; i++)
            {
              channel->ndomains = i;
              channel->domains[i] = strdup(options->domains[i]);
              if (!channel->domains[i])
                return ARES_ENOMEM;
            }
        }
        channel->ndomains = options->ndomains;
      }
  
    /* Set lookups, if given. */
    if ((optmask & ARES_OPT_LOOKUPS) && !channel->lookups)
      {
        channel->lookups = strdup(options->lookups);
        if (!channel->lookups)
          return ARES_ENOMEM;
      }
  
    /* copy sortlist */
    if ((optmask & ARES_OPT_SORTLIST) && (channel->nsort == -1) &&
        (options->nsort>0)) {
      channel->sortlist = malloc(options->nsort * sizeof(struct apattern));
      if (!channel->sortlist)
        return ARES_ENOMEM;
      for (i = 0; i < options->nsort; i++)
        channel->sortlist[i] = options->sortlist[i];
      channel->nsort = options->nsort;
    }
  
    channel->optmask = optmask;
  
    return ARES_SUCCESS;
  }
  
  static int init_by_environment(ares_channel channel)
  {
    const char *localdomain, *res_options;
    int status;
  
    localdomain = getenv("LOCALDOMAIN");
    if (localdomain && channel->ndomains == -1)
      {
        status = set_search(channel, localdomain);
        if (status != ARES_SUCCESS)
          return status;
      }
  
    res_options = getenv("RES_OPTIONS");
    if (res_options)
      {
        status = set_options(channel, res_options);
        if (status != ARES_SUCCESS)
          return status;
      }
  
    return ARES_SUCCESS;
  }
  
  #ifdef WIN32
  /*
   * Warning: returns a dynamically allocated buffer, the user MUST
   * use free() if the function returns 1
   */
  static int get_res_nt(HKEY hKey, const char *subkey, char **obuf)
  {
    /* Test for the size we need */
    DWORD size = 0;
    int result;
  
    result = RegQueryValueEx(hKey, subkey, 0, NULL, NULL, &size);
    if ((result != ERROR_SUCCESS && result != ERROR_MORE_DATA) || !size)
      return 0;
    *obuf = malloc(size+1);
    if (!*obuf)
      return 0;
  
    if (RegQueryValueEx(hKey, subkey, 0, NULL,
                        (LPBYTE)*obuf, &size) != ERROR_SUCCESS)
    {
      free(*obuf);
      return 0;
    }
    if (size == 1)
    {
      free(*obuf);
      return 0;
    }
    return 1;
  }
  
  static int get_res_interfaces_nt(HKEY hKey, const char *subkey, char **obuf)
  {
    char enumbuf[39]; /* GUIDs are 38 chars + 1 for NULL */
    DWORD enum_size = 39;
    int idx = 0;
    HKEY hVal;
  
    while (RegEnumKeyEx(hKey, idx++, enumbuf, &enum_size, 0,
                        NULL, NULL, NULL) != ERROR_NO_MORE_ITEMS)
    {
      int rc;
  
      enum_size = 39;
      if (RegOpenKeyEx(hKey, enumbuf, 0, KEY_QUERY_VALUE, &hVal) !=
          ERROR_SUCCESS)
        continue;
      rc = get_res_nt(hVal, subkey, obuf);
        RegCloseKey(hVal);
      if (rc)
        return 1;
      }
    return 0;
  }
  
  /**
   * The desired output for this method is that we set "ret_buf" to
   * something like:
   *
   * 192.168.0.1,dns01.my.domain,fe80::200:f8ff:fe21:67cf
   *
   * The only ordering requirement is that primary servers are listed
   * before secondary. There is no requirement that IPv4 addresses should
   * necessarily be before IPv6.
   *
   * Note that ret_size should ideally be big enough to hold around
   * 2-3 IPv4 and 2-3 IPv6 addresses.
   *
   * Finally, we need to return the total number of DNS servers located.
   */
  static int get_iphlpapi_dns_info (char *ret_buf, size_t ret_size)
  {
    const size_t  ipv4_size = INET_ADDRSTRLEN  + 1;  /* +1 for ',' at end */
    const size_t  ipv6_size = INET6_ADDRSTRLEN + 12; /* +12 for "%0123456789," at end */
    size_t        left = ret_size;
    char         *ret  = ret_buf;
    int           count = 0;
  
    /* Use the GetAdaptersAddresses method if it's available, otherwise
       fall back to GetNetworkParams. */
    if (ares_fpGetAdaptersAddresses != ZERO_NULL)
    {
      const ULONG            working_buf_size = 15000;
      IP_ADAPTER_ADDRESSES   *pFirstEntry = NULL;
      IP_ADAPTER_ADDRESSES   *pEntry = NULL;
      ULONG                  bufSize = 0;
      ULONG                  result = 0;
  
      /* According to MSDN, the recommended way to do this is to use a temporary
         buffer of 15K, to "dramatically reduce the chance that the GetAdaptersAddresses
         method returns ERROR_BUFFER_OVERFLOW" */
      pFirstEntry  = ( IP_ADAPTER_ADDRESSES * ) malloc( working_buf_size );
      bufSize = working_buf_size;
      if( !pFirstEntry )
        return 0;
  
      /* Call the method one time */
      result = ( *ares_fpGetAdaptersAddresses )( AF_UNSPEC, 0, 0, pFirstEntry, &bufSize );
      if( result == ERROR_BUFFER_OVERFLOW )
      {
        /* Reallocate, bufSize should now be set to the required size */
        pFirstEntry = ( IP_ADAPTER_ADDRESSES * ) realloc( pFirstEntry, bufSize );
        if( !pFirstEntry )
          return 0;
  
        /* Call the method a second time */
        result = ( *ares_fpGetAdaptersAddresses )( AF_UNSPEC, 0, 0, pFirstEntry, &bufSize );
        if( result == ERROR_BUFFER_OVERFLOW )
        {
          /* Reallocate, bufSize should now be set to the required size */
          pFirstEntry = ( IP_ADAPTER_ADDRESSES * ) realloc( pFirstEntry, bufSize );
          if( !pFirstEntry )
            return 0;
  
          /* Call the method a third time. The maximum number of times we're going to do
             this is 3. Three shall be the number thou shalt count, and the number of the
             counting shall be three.  Five is right out. */
          result = ( *ares_fpGetAdaptersAddresses )( AF_UNSPEC, 0, 0, pFirstEntry, &bufSize );
        }
      }
  
      /* Check the current result for failure */
      if( result != ERROR_SUCCESS )
      {
        free( pFirstEntry );
        return 0;
      }
  
      /* process the results */
      for( pEntry = pFirstEntry ; pEntry != NULL ; pEntry = pEntry->Next )
      {
        IP_ADAPTER_DNS_SERVER_ADDRESS* pDNSAddr = pEntry->FirstDnsServerAddress;
        for( ; pDNSAddr != NULL ; pDNSAddr = pDNSAddr->Next )
        {
          struct sockaddr *pGenericAddr = pDNSAddr->Address.lpSockaddr;
          size_t stringlen = 0;
  
          if( pGenericAddr->sa_family == AF_INET && left > ipv4_size )
          {
            /* Handle the v4 case */
            struct sockaddr_in *pIPv4Addr = ( struct sockaddr_in * ) pGenericAddr;
            ares_inet_ntop( AF_INET, &pIPv4Addr->sin_addr, ret, ipv4_size - 1 ); /* -1 for comma */
  
            /* Append a comma to the end, THEN NULL. Should be OK because we
               already tested the size at the top of the if statement. */
            stringlen = strlen( ret );
            ret[ stringlen ] = ',';
            ret[ stringlen + 1 ] = '\0';
            ret += stringlen + 1;
            left -= ret - ret_buf;
            ++count;
          }
          else if( pGenericAddr->sa_family == AF_INET6 && left > ipv6_size )
          {
            /* Handle the v6 case */
            struct sockaddr_in6 *pIPv6Addr = ( struct sockaddr_in6 * ) pGenericAddr;
            ares_inet_ntop( AF_INET6, &pIPv6Addr->sin6_addr, ret, ipv6_size - 1 ); /* -1 for comma */
  
            /* Append a comma to the end, THEN NULL. Should be OK because we
               already tested the size at the top of the if statement. */
            stringlen = strlen( ret );
            ret[ stringlen ] = ',';
            ret[ stringlen + 1 ] = '\0';
            ret += stringlen + 1;
            left -= ret - ret_buf;
            ++count;
  
            /* NB on Windows this also returns stuff in the fec0::/10 range,
               seems to be hard-coded somehow. Do we need to ignore them? */
          }
        }
      }
  
      if( pFirstEntry )
        free( pFirstEntry );
      if (ret > ret_buf)
        ret[-1] = '\0';
      return count;
    }
    else
    {
      FIXED_INFO    *fi, *newfi;
      DWORD          size = sizeof (*fi);
      IP_ADDR_STRING *ipAddr;
      int            i;
      int            debug  = 0;
      HRESULT        res;
  
      fi = malloc(size);
      if (!fi)
        return 0;
  
      res = (*ares_fpGetNetworkParams) (fi, &size);
      if ((res != ERROR_BUFFER_OVERFLOW) && (res != ERROR_SUCCESS))
        goto quit;
  
      newfi = realloc(fi, size);
      if (!newfi)
        goto quit;
  
      fi = newfi;
      res = (*ares_fpGetNetworkParams) (fi, &size);
      if (res != ERROR_SUCCESS)
        goto quit;
  
      if (debug)
      {
        printf ("Host Name: %s\n", fi->HostName);
        printf ("Domain Name: %s\n", fi->DomainName);
        printf ("DNS Servers:\n"
                "    %s (primary)\n", fi->DnsServerList.IpAddress.String);
      }
      if (strlen(fi->DnsServerList.IpAddress.String) > 0 &&
          inet_addr(fi->DnsServerList.IpAddress.String) != INADDR_NONE &&
          left > ipv4_size)
      {
        ret += sprintf (ret, "%s,", fi->DnsServerList.IpAddress.String);
        left -= ret - ret_buf;
        ++count;
      }
  
      for (i = 0, ipAddr = fi->DnsServerList.Next; ipAddr && left > ipv4_size;
           ipAddr = ipAddr->Next, i++)
      {
        if (inet_addr(ipAddr->IpAddress.String) != INADDR_NONE)
        {
           ret += sprintf (ret, "%s,", ipAddr->IpAddress.String);
           left -= ret - ret_buf;
           ++count;
        }
        if (debug)
           printf ("    %s (secondary %d)\n", ipAddr->IpAddress.String, i+1);
      }
  
  quit:
      if (fi)
        free(fi);
  
      if (debug && left <= ipv4_size)
        printf ("Too many nameservers. Truncating to %d addressess", count);
      if (ret > ret_buf)
        ret[-1] = '\0';
      return count;
    }
  }
  #endif
  
  static int init_by_resolv_conf(ares_channel channel)
  {
  #ifndef WATT32
    char *line = NULL;
  #endif
    int status = -1, nservers = 0, nsort = 0;
    struct server_state *servers = NULL;
    struct apattern *sortlist = NULL;
  
  #ifdef WIN32
  
      /*
    NameServer info via IPHLPAPI (IP helper API):
      GetNetworkParams() should be the trusted source for this.
      Available in Win-98/2000 and later. If that fail, fall-back to
      registry information.
  
    NameServer Registry:
  
     On Windows 9X, the DNS server can be found in:
  HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\VxD\MSTCP\NameServer
  
          On Windows NT/2000/XP/2003:
  HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\NameServer
          or
  HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\DhcpNameServer
          or
  HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\{AdapterID}\
  NameServer
          or
  HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\{AdapterID}\
  DhcpNameServer
     */
  
    HKEY mykey;
    HKEY subkey;
    DWORD data_type;
    DWORD bytes;
    DWORD result;
    char  buf[512];
    win_platform platform;
  
    if (channel->nservers > -1)  /* don't override ARES_OPT_SERVER */
       return ARES_SUCCESS;
  
    if (get_iphlpapi_dns_info(buf,sizeof(buf)) > 0)
    {
      status = config_nameserver(&servers, &nservers, buf);
      if (status == ARES_SUCCESS)
        goto okay;
    }
  
    platform = ares__getplatform();
  
    if (platform == WIN_NT)
    {
      if (RegOpenKeyEx(
            HKEY_LOCAL_MACHINE, WIN_NS_NT_KEY, 0,
            KEY_READ, &mykey
            ) == ERROR_SUCCESS)
      {
        RegOpenKeyEx(mykey, "Interfaces", 0,
                     KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS, &subkey);
        if (get_res_nt(mykey, NAMESERVER, &line))
        {
          status = config_nameserver(&servers, &nservers, line);
          free(line);
        }
        else if (get_res_nt(mykey, DHCPNAMESERVER, &line))
        {
          status = config_nameserver(&servers, &nservers, line);
          free(line);
        }
        /* Try the interfaces */
        else if (get_res_interfaces_nt(subkey, NAMESERVER, &line))
        {
          status = config_nameserver(&servers, &nservers, line);
          free(line);
        }
        else if (get_res_interfaces_nt(subkey, DHCPNAMESERVER, &line))
        {
          status = config_nameserver(&servers, &nservers, line);
          free(line);
        }
        RegCloseKey(subkey);
        RegCloseKey(mykey);
      }
    }
    else if (platform == WIN_9X)
    {
      if (RegOpenKeyEx(
            HKEY_LOCAL_MACHINE, WIN_NS_9X, 0,
            KEY_READ, &mykey
            ) == ERROR_SUCCESS)
      {
        if ((result = RegQueryValueEx(
               mykey, NAMESERVER, NULL, &data_type,
               NULL, &bytes
               )
              ) == ERROR_SUCCESS ||
            result == ERROR_MORE_DATA)
        {
          if (bytes)
          {
            line = malloc(bytes+1);
            if (RegQueryValueEx(mykey, NAMESERVER, NULL, &data_type,
                                (unsigned char *)line, &bytes) ==
                ERROR_SUCCESS)
            {
              status = config_nameserver(&servers, &nservers, line);
            }
            free(line);
          }
        }
      }
      RegCloseKey(mykey);
    }
  
    if (status == ARES_SUCCESS)
      status = ARES_EOF;
    else
      /* Catch the case when all the above checks fail (which happens when there
         is no network card or the cable is unplugged) */
      status = ARES_EFILE;
  
  #elif defined(__riscos__)
  
    /* Under RISC OS, name servers are listed in the
       system variable Inet$Resolvers, space separated. */
  
    line = getenv("Inet$Resolvers");
    status = ARES_EOF;
    if (line) {
      char *resolvers = strdup(line), *pos, *space;
  
      if (!resolvers)
        return ARES_ENOMEM;
  
      pos = resolvers;
      do {
        space = strchr(pos, ' ');
        if (space)
          *space = '\0';
        status = config_nameserver(&servers, &nservers, pos);
        if (status != ARES_SUCCESS)
          break;
        pos = space + 1;
      } while (space);
  
      if (status == ARES_SUCCESS)
        status = ARES_EOF;
  
      free(resolvers);
    }
  
  #elif defined(WATT32)
    int i;
  
    sock_init();
    for (i = 0; def_nameservers[i]; i++)
        ;
    if (i == 0)
      return ARES_SUCCESS; /* use localhost DNS server */
  
    nservers = i;
    servers = calloc(i, sizeof(struct server_state));
    if (!servers)
       return ARES_ENOMEM;
  
    for (i = 0; def_nameservers[i]; i++)
    {
      servers[i].addr.addrV4.s_addr = htonl(def_nameservers[i]);
      servers[i].addr.family = AF_INET;
    }
    status = ARES_EOF;
  
  #elif defined(ANDROID)
    char value[PROP_VALUE_MAX]="";
    __system_property_get("net.dns1", value);
    status = config_nameserver(&servers, &nservers, value);
    if (status == ARES_SUCCESS)
      status = ARES_EOF;
  #else
    {
      char *p;
      FILE *fp;
      size_t linesize;
      int error;
  
      /* Don't read resolv.conf and friends if we don't have to */
      if (ARES_CONFIG_CHECK(channel))
          return ARES_SUCCESS;
  
      fp = fopen(PATH_RESOLV_CONF, "r");
      if (fp) {
        while ((status = ares__read_line(fp, &line, &linesize)) == ARES_SUCCESS)
        {
          if ((p = try_config(line, "domain", ';')))
            status = config_domain(channel, p);
          else if ((p = try_config(line, "lookup", ';')) && !channel->lookups)
            status = config_lookup(channel, p, "bind", "file");
          else if ((p = try_config(line, "search", ';')))
            status = set_search(channel, p);
          else if ((p = try_config(line, "nameserver", ';')) &&
                   channel->nservers == -1)
            status = config_nameserver(&servers, &nservers, p);
          else if ((p = try_config(line, "sortlist", ';')) &&
                   channel->nsort == -1)
            status = config_sortlist(&sortlist, &nsort, p);
          else if ((p = try_config(line, "options", ';')))
            status = set_options(channel, p);
          else
            status = ARES_SUCCESS;
          if (status != ARES_SUCCESS)
            break;
        }
        fclose(fp);
      }
      else {
        error = ERRNO;
        switch(error) {
        case ENOENT:
        case ESRCH:
          status = ARES_EOF;
          break;
        default:
          DEBUGF(fprintf(stderr, "fopen() failed with error: %d %s\n",
                         error, strerror(error)));
          DEBUGF(fprintf(stderr, "Error opening file: %s\n", PATH_RESOLV_CONF));
          status = ARES_EFILE;
        }
      }
  
      if ((status == ARES_EOF) && (!channel->lookups)) {
        /* Many systems (Solaris, Linux, BSD's) use nsswitch.conf */
        fp = fopen("/etc/nsswitch.conf", "r");
        if (fp) {
          while ((status = ares__read_line(fp, &line, &linesize)) == ARES_SUCCESS)
          {
            if ((p = try_config(line, "hosts:", '\0')) && !channel->lookups)
              /* ignore errors */
              (void)config_lookup(channel, p, "dns", "files");
          }
          fclose(fp);
        }
        else {
          error = ERRNO;
          switch(error) {
          case ENOENT:
          case ESRCH:
            status = ARES_EOF;
            break;
          default:
            DEBUGF(fprintf(stderr, "fopen() failed with error: %d %s\n",
                           error, strerror(error)));
            DEBUGF(fprintf(stderr, "Error opening file: %s\n", "/etc/nsswitch.conf"));
            status = ARES_EFILE;
          }
        }
      }
  
      if ((status == ARES_EOF) && (!channel->lookups)) {
        /* Linux / GNU libc 2.x and possibly others have host.conf */
        fp = fopen("/etc/host.conf", "r");
        if (fp) {
          while ((status = ares__read_line(fp, &line, &linesize)) == ARES_SUCCESS)
          {
            if ((p = try_config(line, "order", '\0')) && !channel->lookups)
              /* ignore errors */
              (void)config_lookup(channel, p, "bind", "hosts");
          }
          fclose(fp);
        }
        else {
          error = ERRNO;
          switch(error) {
          case ENOENT:
          case ESRCH:
            status = ARES_EOF;
            break;
          default:
            DEBUGF(fprintf(stderr, "fopen() failed with error: %d %s\n",
                           error, strerror(error)));
            DEBUGF(fprintf(stderr, "Error opening file: %s\n", "/etc/host.conf"));
            status = ARES_EFILE;
          }
        }
      }
  
      if ((status == ARES_EOF) && (!channel->lookups)) {
        /* Tru64 uses /etc/svc.conf */
        fp = fopen("/etc/svc.conf", "r");
        if (fp) {
          while ((status = ares__read_line(fp, &line, &linesize)) == ARES_SUCCESS)
          {
            if ((p = try_config(line, "hosts=", '\0')) && !channel->lookups)
              /* ignore errors */
              (void)config_lookup(channel, p, "bind", "local");
          }
          fclose(fp);
        }
        else {
          error = ERRNO;
          switch(error) {
          case ENOENT:
          case ESRCH:
            status = ARES_EOF;
            break;
          default:
            DEBUGF(fprintf(stderr, "fopen() failed with error: %d %s\n",
                           error, strerror(error)));
            DEBUGF(fprintf(stderr, "Error opening file: %s\n", "/etc/svc.conf"));
            status = ARES_EFILE;
          }
        }
      }
  
      if(line)
        free(line);
    }
  
  #endif
  
    /* Handle errors. */
    if (status != ARES_EOF)
      {
        if (servers != NULL)
          free(servers);
        if (sortlist != NULL)
          free(sortlist);
        return status;
      }
  
    /* If we got any name server entries, fill them in. */
  #ifdef WIN32
  okay:
  #endif
    if (servers)
      {
        channel->servers = servers;
        channel->nservers = nservers;
      }
  
    /* If we got any sortlist entries, fill them in. */
    if (sortlist)
      {
        channel->sortlist = sortlist;
        channel->nsort = nsort;
      }
  
    return ARES_SUCCESS;
  }
  
  static int init_by_defaults(ares_channel channel)
  {
    char *hostname = NULL;
    int rc = ARES_SUCCESS;
  #ifdef HAVE_GETHOSTNAME
    char *dot;
  #endif
  
    if (channel->flags == -1)
      channel->flags = 0;
    if (channel->timeout == -1)
      channel->timeout = DEFAULT_TIMEOUT;
    if (channel->tries == -1)
      channel->tries = DEFAULT_TRIES;
    if (channel->ndots == -1)
      channel->ndots = 1;
    if (channel->rotate == -1)
      channel->rotate = 0;
    if (channel->udp_port == -1)
      channel->udp_port = htons(NAMESERVER_PORT);
    if (channel->tcp_port == -1)
      channel->tcp_port = htons(NAMESERVER_PORT);
  
    if (channel->nservers == -1) {
      /* If nobody specified servers, try a local named. */
      channel->servers = malloc(sizeof(struct server_state));
      if (!channel->servers) {
        rc = ARES_ENOMEM;
        goto error;
      }
      channel->servers[0].addr.family = AF_INET;
      channel->servers[0].addr.addrV4.s_addr = htonl(INADDR_LOOPBACK);
      channel->nservers = 1;
    }
  
  #if defined(USE_WINSOCK)
  #define toolong(x) (x == -1) &&  (SOCKERRNO == WSAEFAULT)
  #elif defined(ENAMETOOLONG)
  #define toolong(x) (x == -1) && ((SOCKERRNO == ENAMETOOLONG) || \
                                   (SOCKERRNO == EINVAL))
  #else
  #define toolong(x) (x == -1) &&  (SOCKERRNO == EINVAL)
  #endif
  
    if (channel->ndomains == -1) {
      /* Derive a default domain search list from the kernel hostname,
       * or set it to empty if the hostname isn't helpful.
       */
      size_t len = 64;
      int res;
      channel->ndomains = 0; /* default to none */
  
  #ifdef HAVE_GETHOSTNAME
      hostname = malloc(len);
      if(!hostname) {
        rc = ARES_ENOMEM;
        goto error;
      }
  
      do {
        res = gethostname(hostname, len);
  
        if(toolong(res)) {
          char *p;
          len *= 2;
          p = realloc(hostname, len);
          if(!p) {
            rc = ARES_ENOMEM;
            goto error;
          }
          hostname = p;
          continue;
        }
        else if(res) {
          rc = ARES_EBADNAME;
          goto error;
        }
  
      } while(0);
  
      dot = strchr(hostname, '.');
      if (dot) {
        /* a dot was found */
        channel->domains = malloc(sizeof(char *));
        if (!channel->domains) {
          rc = ARES_ENOMEM;
          goto error;
        }
        channel->domains[0] = strdup(dot + 1);
        if (!channel->domains[0]) {
          rc = ARES_ENOMEM;
          goto error;
        }
        channel->ndomains = 1;
      }
  #endif
    }
  
    if (channel->nsort == -1) {
      channel->sortlist = NULL;
      channel->nsort = 0;
    }
  
    if (!channel->lookups) {
      channel->lookups = strdup("fb");
      if (!channel->lookups)
        rc = ARES_ENOMEM;
    }
  
    error:
    if(rc) {
      if(channel->servers)
        free(channel->servers);
  
      if(channel->domains && channel->domains[0])
        free(channel->domains[0]);
      if(channel->domains)
        free(channel->domains);
      if(channel->lookups)
        free(channel->lookups);
    }
  
    if(hostname)
      free(hostname);
  
    return rc;
  }
  
  #if !defined(WIN32) && !defined(WATT32)
  static int config_domain(ares_channel channel, char *str)
  {
    char *q;
  
    /* Set a single search domain. */
    q = str;
    while (*q && !ISSPACE(*q))
      q++;
    *q = '\0';
    return set_search(channel, str);
  }
  
  #if defined(__INTEL_COMPILER) && (__INTEL_COMPILER == 910) && \
      defined(__OPTIMIZE__) && defined(__unix__) &&  defined(__i386__)
    /* workaround icc 9.1 optimizer issue */
  # define vqualifier volatile
  #else
  # define vqualifier
  #endif
  
  static int config_lookup(ares_channel channel, const char *str,
                           const char *bindch, const char *filech)
  {
    char lookups[3], *l;
    const char *vqualifier p;
  
    /* Set the lookup order.  Only the first letter of each work
     * is relevant, and it has to be "b" for DNS or "f" for the
     * host file.  Ignore everything else.
     */
    l = lookups;
    p = str;
    while (*p)
      {
        if ((*p == *bindch || *p == *filech) && l < lookups + 2) {
          if (*p == *bindch) *l++ = 'b';
          else *l++ = 'f';
        }
        while (*p && !ISSPACE(*p) && (*p != ','))
          p++;
        while (*p && (ISSPACE(*p) || (*p == ',')))
          p++;
      }
    *l = '\0';
    channel->lookups = strdup(lookups);
    return (channel->lookups) ? ARES_SUCCESS : ARES_ENOMEM;
  }
  #endif  /* !WIN32 & !WATT32 */
  
  #ifndef WATT32
  static int config_nameserver(struct server_state **servers, int *nservers,
                               char *str)
  {
    struct ares_addr host;
    struct server_state *newserv;
    char *p, *txtaddr;
    /* On Windows, there may be more than one nameserver specified in the same
     * registry key, so we parse input as a space or comma seperated list.
     */
    for (p = str; p;)
      {
        /* Skip whitespace and commas. */
        while (*p && (ISSPACE(*p) || (*p == ',')))
          p++;
        if (!*p)
          /* No more input, done. */
          break;
  
        /* Pointer to start of IPv4 or IPv6 address part. */
        txtaddr = p;
  
        /* Advance past this address. */
        while (*p && !ISSPACE(*p) && (*p != ','))
          p++;
        if (*p)
          /* Null terminate this address. */
          *p++ = '\0';
        else
          /* Reached end of input, done when this address is processed. */
          p = NULL;
  
        /* Convert textual address to binary format. */
        if (ares_inet_pton(AF_INET, txtaddr, &host.addrV4) == 1)
          host.family = AF_INET;
        else if (ares_inet_pton(AF_INET6, txtaddr, &host.addrV6) == 1)
          host.family = AF_INET6;
        else
          continue;
  
        /* Resize servers state array. */
        newserv = realloc(*servers, (*nservers + 1) *
                          sizeof(struct server_state));
        if (!newserv)
          return ARES_ENOMEM;
  
        /* Store address data. */
        newserv[*nservers].addr.family = host.family;
        if (host.family == AF_INET)
          memcpy(&newserv[*nservers].addr.addrV4, &host.addrV4,
                 sizeof(host.addrV4));
        else
          memcpy(&newserv[*nservers].addr.addrV6, &host.addrV6,
                 sizeof(host.addrV6));
  
        /* Update arguments. */
        *servers = newserv;
        *nservers += 1;
      }
  
    return ARES_SUCCESS;
  }
  
  #ifndef WIN32
  static int config_sortlist(struct apattern **sortlist, int *nsort,
                             const char *str)
  {
    struct apattern pat;
    const char *q;
  
    /* Add sortlist entries. */
    while (*str && *str != ';')
      {
        int bits;
        char ipbuf[16], ipbufpfx[32];
        /* Find just the IP */
        q = str;
        while (*q && *q != '/' && *q != ';' && !ISSPACE(*q))
          q++;
        memcpy(ipbuf, str, q-str);
        ipbuf[q-str] = '\0';
        /* Find the prefix */
        if (*q == '/')
          {
            const char *str2 = q+1;
            while (*q && *q != ';' && !ISSPACE(*q))
              q++;
            memcpy(ipbufpfx, str, q-str);
            ipbufpfx[q-str] = '\0';
            str = str2;
          }
        else
          ipbufpfx[0] = '\0';
        /* Lets see if it is CIDR */
        /* First we'll try IPv6 */
        if ((bits = ares_inet_net_pton(AF_INET6, ipbufpfx[0] ? ipbufpfx : ipbuf,
                                       &pat.addrV6,
                                       sizeof(pat.addrV6))) > 0)
          {
            pat.type = PATTERN_CIDR;
            pat.mask.bits = (unsigned short)bits;
            pat.family = AF_INET6;
            if (!sortlist_alloc(sortlist, nsort, &pat))
              return ARES_ENOMEM;
          }
        else if (ipbufpfx[0] &&
                 (bits = ares_inet_net_pton(AF_INET, ipbufpfx, &pat.addrV4,
                                            sizeof(pat.addrV4))) > 0)
          {
            pat.type = PATTERN_CIDR;
            pat.mask.bits = (unsigned short)bits;
            pat.family = AF_INET;
            if (!sortlist_alloc(sortlist, nsort, &pat))
              return ARES_ENOMEM;
          }
        /* See if it is just a regular IP */
        else if (ip_addr(ipbuf, q-str, &pat.addrV4) == 0)
          {
            if (ipbufpfx[0])
              {
                memcpy(ipbuf, str, q-str);
                ipbuf[q-str] = '\0';
                if (ip_addr(ipbuf, q-str, &pat.mask.addr4) != 0)
                  natural_mask(&pat);
              }
            else
              natural_mask(&pat);
            pat.family = AF_INET;
            pat.type = PATTERN_MASK;
            if (!sortlist_alloc(sortlist, nsort, &pat))
              return ARES_ENOMEM;
          }
        else
          {
            while (*q && *q != ';' && !ISSPACE(*q))
              q++;
          }
        str = q;
        while (ISSPACE(*str))
          str++;
      }
  
    return ARES_SUCCESS;
  }
  #endif  /* !WIN32 */
  #endif  /* !WATT32 */
  
  static int set_search(ares_channel channel, const char *str)
  {
    int n;
    const char *p, *q;
  
    if(channel->ndomains != -1) {
      /* if we already have some domains present, free them first */
      for(n=0; n < channel->ndomains; n++)
        free(channel->domains[n]);
      free(channel->domains);
      channel->domains = NULL;
      channel->ndomains = -1;
    }
  
    /* Count the domains given. */
    n = 0;
    p = str;
    while (*p)
      {
        while (*p && !ISSPACE(*p))
          p++;
        while (ISSPACE(*p))
          p++;
        n++;
      }
  
    if (!n)
      {
        channel->ndomains = 0;
        return ARES_SUCCESS;
      }
  
    channel->domains = malloc(n * sizeof(char *));
    if (!channel->domains)
      return ARES_ENOMEM;
  
    /* Now copy the domains. */
    n = 0;
    p = str;
    while (*p)
      {
        channel->ndomains = n;
        q = p;
        while (*q && !ISSPACE(*q))
          q++;
        channel->domains[n] = malloc(q - p + 1);
        if (!channel->domains[n])
          return ARES_ENOMEM;
        memcpy(channel->domains[n], p, q - p);
        channel->domains[n][q - p] = 0;
        p = q;
        while (ISSPACE(*p))
          p++;
        n++;
      }
    channel->ndomains = n;
  
    return ARES_SUCCESS;
  }
  
  static int set_options(ares_channel channel, const char *str)
  {
    const char *p, *q, *val;
  
    p = str;
    while (*p)
      {
        q = p;
        while (*q && !ISSPACE(*q))
          q++;
        val = try_option(p, q, "ndots:");
        if (val && channel->ndots == -1)
          channel->ndots = aresx_sltosi(strtol(val, NULL, 10));
        val = try_option(p, q, "retrans:");
        if (val && channel->timeout == -1)
          channel->timeout = aresx_sltosi(strtol(val, NULL, 10));
        val = try_option(p, q, "retry:");
        if (val && channel->tries == -1)
          channel->tries = aresx_sltosi(strtol(val, NULL, 10));
        val = try_option(p, q, "rotate");
        if (val && channel->rotate == -1)
          channel->rotate = 1;
        p = q;
        while (ISSPACE(*p))
          p++;
      }
  
    return ARES_SUCCESS;
  }
  
  static const char *try_option(const char *p, const char *q, const char *opt)
  {
    size_t len = strlen(opt);
    return ((size_t)(q - p) >= len && !strncmp(p, opt, len)) ? &p[len] : NULL;
  }
  
  #if !defined(WIN32) && !defined(WATT32)
  static char *try_config(char *s, const char *opt, char scc)
  {
    size_t len;
    char *p;
    char *q;
  
    if (!s || !opt)
      /* no line or no option */
      return NULL;
  
    /* Hash '#' character is always used as primary comment char, additionally
       a not-NUL secondary comment char will be considered when specified. */
  
    /* trim line comment */
    p = s;
    if(scc)
      while (*p && (*p != '#') && (*p != scc))
        p++;
    else
      while (*p && (*p != '#'))
        p++;
    *p = '\0';
  
    /* trim trailing whitespace */
    q = p - 1;
    while ((q >= s) && ISSPACE(*q))
      q--;
    *++q = '\0';
  
    /* skip leading whitespace */
    p = s;
    while (*p && ISSPACE(*p))
      p++;
  
    if (!*p)
      /* empty line */
      return NULL;
  
    if ((len = strlen(opt)) == 0)
      /* empty option */
      return NULL;
  
    if (strncmp(p, opt, len) != 0)
      /* line and option do not match */
      return NULL;
  
    /* skip over given option name */
    p += len;
  
    if (!*p)
      /* no option value */
      return NULL;
  
    if ((opt[len-1] != ':') && (opt[len-1] != '=') && !ISSPACE(*p))
      /* whitespace between option name and value is mandatory
         for given option names which do not end with ':' or '=' */
      return NULL;
  
    /* skip over whitespace */
    while (*p && ISSPACE(*p))
      p++;
  
    if (!*p)
      /* no option value */
      return NULL;
  
    /* return pointer to option value */
    return p;
  }
  
  static int sortlist_alloc(struct apattern **sortlist, int *nsort,
                            struct apattern *pat)
  {
    struct apattern *newsort;
    newsort = realloc(*sortlist, (*nsort + 1) * sizeof(struct apattern));
    if (!newsort)
      return 0;
    newsort[*nsort] = *pat;
    *sortlist = newsort;
    (*nsort)++;
    return 1;
  }
  
  static int ip_addr(const char *ipbuf, ssize_t len, struct in_addr *addr)
  {
  
    /* Four octets and three periods yields at most 15 characters. */
    if (len > 15)
      return -1;
  
    addr->s_addr = inet_addr(ipbuf);
    if (addr->s_addr == INADDR_NONE && strcmp(ipbuf, "255.255.255.255") != 0)
      return -1;
    return 0;
  }
  
  static void natural_mask(struct apattern *pat)
  {
    struct in_addr addr;
  
    /* Store a host-byte-order copy of pat in a struct in_addr.  Icky,
     * but portable.
     */
    addr.s_addr = ntohl(pat->addrV4.s_addr);
  
    /* This is out of date in the CIDR world, but some people might
     * still rely on it.
     */
    if (IN_CLASSA(addr.s_addr))
      pat->mask.addr4.s_addr = htonl(IN_CLASSA_NET);
    else if (IN_CLASSB(addr.s_addr))
      pat->mask.addr4.s_addr = htonl(IN_CLASSB_NET);
    else
      pat->mask.addr4.s_addr = htonl(IN_CLASSC_NET);
  }
  #endif /* !WIN32 && !WATT32 */
  
  /* initialize an rc4 key. If possible a cryptographically secure random key
     is generated using a suitable function (for example win32's RtlGenRandom as
     described in
     http://blogs.msdn.com/michael_howard/archive/2005/01/14/353379.aspx
     otherwise the code defaults to cross-platform albeit less secure mechanism
     using rand
  */
  static void randomize_key(unsigned char* key,int key_data_len)
  {
    int randomized = 0;
    int counter=0;
  #ifdef WIN32
    BOOLEAN res;
    if (ares_fpSystemFunction036)
      {
        res = (*ares_fpSystemFunction036) (key, key_data_len);
        if (res)
          randomized = 1;
      }
  #else /* !WIN32 */
  #ifdef RANDOM_FILE
    FILE *f = fopen(RANDOM_FILE, "rb");
    if(f) {
      counter = aresx_uztosi(fread(key, 1, key_data_len, f));
      fclose(f);
    }
  #endif
  #endif /* WIN32 */
  
    if ( !randomized ) {
      for (;counter<key_data_len;counter++)
        key[counter]=(unsigned char)(rand() % 256);
    }
  }
  
  static int init_id_key(rc4_key* key,int key_data_len)
  {
    unsigned char index1;
    unsigned char index2;
    unsigned char* state;
    short counter;
    unsigned char *key_data_ptr = 0;
  
    key_data_ptr = calloc(1,key_data_len);
    if (!key_data_ptr)
      return ARES_ENOMEM;
  
    state = &key->state[0];
    for(counter = 0; counter < 256; counter++)
      /* unnecessary AND but it keeps some compilers happier */
      state[counter] = (unsigned char)(counter & 0xff);
    randomize_key(key->state,key_data_len);
    key->x = 0;
    key->y = 0;
    index1 = 0;
    index2 = 0;
    for(counter = 0; counter < 256; counter++)
    {
      index2 = (unsigned char)((key_data_ptr[index1] + state[counter] +
                                index2) % 256);
      ARES_SWAP_BYTE(&state[counter], &state[index2]);
  
      index1 = (unsigned char)((index1 + 1) % key_data_len);
    }
    free(key_data_ptr);
    return ARES_SUCCESS;
  }
  
  unsigned short ares__generate_new_id(rc4_key* key)
  {
    unsigned short r=0;
    ares__rc4(key, (unsigned char *)&r, sizeof(r));
    return r;
  }
  
  void ares_set_local_ip4(ares_channel channel, unsigned int local_ip)
  {
    channel->local_ip4 = local_ip;
  }
  
  /* local_ip6 should be 16 bytes in length */
  void ares_set_local_ip6(ares_channel channel,
                          const unsigned char* local_ip6)
  {
    memcpy(&channel->local_ip6, local_ip6, sizeof(channel->local_ip6));
  }
  
  /* local_dev_name should be null terminated. */
  void ares_set_local_dev(ares_channel channel,
                          const char* local_dev_name)
  {
    strncpy(channel->local_dev_name, local_dev_name,
            sizeof(channel->local_dev_name));
    channel->local_dev_name[sizeof(channel->local_dev_name) - 1] = 0;
  }
  
  
  void ares_set_socket_callback(ares_channel channel,
                                ares_sock_create_callback cb,
                                void *data)
  {
    channel->sock_create_cb = cb;
    channel->sock_create_cb_data = data;
  }
  
  void ares__init_servers_state(ares_channel channel)
  {
    struct server_state *server;
    int i;
  
    for (i = 0; i < channel->nservers; i++)
      {
        server = &channel->servers[i];
        server->udp_socket = ARES_SOCKET_BAD;
        server->tcp_socket = ARES_SOCKET_BAD;
        server->tcp_connection_generation = ++channel->tcp_connection_generation;
        server->tcp_lenbuf_pos = 0;
        server->tcp_buffer_pos = 0;
        server->tcp_buffer = NULL;
        server->tcp_length = 0;
        server->qhead = NULL;
        server->qtail = NULL;
        ares__init_list_head(&server->queries_to_server);
        server->channel = channel;
        server->is_broken = 0;
      }
  }
  