visaljs 0.0.10 → 0.0.11

package/node/third_party/c-ares/src/lib/ares_sysconfig_files.c

@@ -0,0 +1,851 @@
+/* MIT License
+ *
+ * Copyright (c) 1998 Massachusetts Institute of Technology
+ * Copyright (c) 2007 Daniel Stenberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "ares_private.h"
+
+#include <limits.h>
+
+#ifdef HAVE_SYS_PARAM_H
+#  include <sys/param.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
+
+#if defined(ANDROID) || defined(__ANDROID__)
+#  include <sys/system_properties.h>
+#  include "ares_android.h"
+/* From the Bionic sources */
+#  define DNS_PROP_NAME_PREFIX "net.dns"
+#  define MAX_DNS_PROPERTIES   8
+#endif
+
+#if defined(CARES_USE_LIBRESOLV)
+#  include <resolv.h>
+#endif
+
+#if defined(USE_WINSOCK) && defined(HAVE_IPHLPAPI_H)
+#  include <iphlpapi.h>
+#endif
+
+#include "ares_inet_net_pton.h"
+
+static unsigned char ip_natural_mask(const struct ares_addr *addr)
+{
+  const unsigned char *ptr = NULL;
+  /* This is an odd one.  If a raw ipv4 address is specified, then we take
+   * what is called a natural mask, which means we look at the first octet
+   * of the ip address and for values 0-127 we assume it is a class A (/8),
+   * for values 128-191 we assume it is a class B (/16), and for 192-223
+   * we assume it is a class C (/24).  223-239 is Class D which and 240-255 is
+   * Class E, however, there is no pre-defined mask for this, so we'll use
+   * /24 as well as that's what the old code did.
+   *
+   * For IPv6, we'll use /64.
+   */
+
+  if (addr->family == AF_INET6) {
+    return 64;
+  }
+
+  ptr = (const unsigned char *)&addr->addr.addr4;
+  if (*ptr < 128) {
+    return 8;
+  }
+
+  if (*ptr < 192) {
+    return 16;
+  }
+
+  return 24;
+}
+
+static ares_bool_t sortlist_append(struct apattern **sortlist, size_t *nsort,
+                                   const struct apattern *pat)
+{
+  struct apattern *newsort;
+
+  newsort = ares_realloc(*sortlist, (*nsort + 1) * sizeof(*newsort));
+  if (newsort == NULL) {
+    return ARES_FALSE; /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  *sortlist = newsort;
+
+  memcpy(&(*sortlist)[*nsort], pat, sizeof(**sortlist));
+  (*nsort)++;
+
+  return ARES_TRUE;
+}
+
+static ares_status_t parse_sort(ares_buf_t *buf, struct apattern *pat)
+{
+  ares_status_t       status;
+  const unsigned char ip_charset[]             = "ABCDEFabcdef0123456789.:";
+  char                ipaddr[INET6_ADDRSTRLEN] = "";
+  size_t              addrlen;
+
+  memset(pat, 0, sizeof(*pat));
+
+  /* Consume any leading whitespace */
+  ares_buf_consume_whitespace(buf, ARES_TRUE);
+
+  /* If no length, just ignore, return ENOTFOUND as an indicator */
+  if (ares_buf_len(buf) == 0) {
+    return ARES_ENOTFOUND;
+  }
+
+  ares_buf_tag(buf);
+
+  /* Consume ip address */
+  if (ares_buf_consume_charset(buf, ip_charset, sizeof(ip_charset) - 1) == 0) {
+    return ARES_EBADSTR;
+  }
+
+  /* Fetch ip address */
+  status = ares_buf_tag_fetch_string(buf, ipaddr, sizeof(ipaddr));
+  if (status != ARES_SUCCESS) {
+    return status;
+  }
+
+  /* Parse it to make sure its valid */
+  pat->addr.family = AF_UNSPEC;
+  if (ares_dns_pton(ipaddr, &pat->addr, &addrlen) == NULL) {
+    return ARES_EBADSTR;
+  }
+
+  /* See if there is a subnet mask */
+  if (ares_buf_begins_with(buf, (const unsigned char *)"/", 1)) {
+    char                maskstr[16];
+    const unsigned char ipv4_charset[] = "0123456789.";
+
+
+    /* Consume / */
+    ares_buf_consume(buf, 1);
+
+    ares_buf_tag(buf);
+
+    /* Consume mask */
+    if (ares_buf_consume_charset(buf, ipv4_charset, sizeof(ipv4_charset) - 1) ==
+        0) {
+      return ARES_EBADSTR;
+    }
+
+    /* Fetch mask */
+    status = ares_buf_tag_fetch_string(buf, maskstr, sizeof(maskstr));
+    if (status != ARES_SUCCESS) {
+      return status;
+    }
+
+    if (ares_str_isnum(maskstr)) {
+      /* Numeric mask */
+      unsigned int mask;
+      if (!ares_str_parse_uint(maskstr, 128, &mask)) {
+        return ARES_EBADSTR;
+      }
+      if (pat->addr.family == AF_INET && mask > 32) {
+        return ARES_EBADSTR;
+      }
+      pat->mask = (unsigned char)mask;
+    } else {
+      /* Ipv4 subnet style mask */
+      struct ares_addr     maskaddr;
+      const unsigned char *ptr;
+
+      memset(&maskaddr, 0, sizeof(maskaddr));
+      maskaddr.family = AF_INET;
+      if (ares_dns_pton(maskstr, &maskaddr, &addrlen) == NULL) {
+        return ARES_EBADSTR;
+      }
+      ptr       = (const unsigned char *)&maskaddr.addr.addr4;
+      pat->mask = (unsigned char)(ares_count_bits_u8(ptr[0]) +
+                                  ares_count_bits_u8(ptr[1]) +
+                                  ares_count_bits_u8(ptr[2]) +
+                                  ares_count_bits_u8(ptr[3]));
+    }
+  } else {
+    pat->mask = ip_natural_mask(&pat->addr);
+  }
+
+  /* Consume any trailing whitespace */
+  ares_buf_consume_whitespace(buf, ARES_TRUE);
+
+  /* If we have any trailing bytes other than whitespace, its a parse failure */
+  if (ares_buf_len(buf) != 0) {
+    return ARES_EBADSTR;
+  }
+
+  return ARES_SUCCESS;
+}
+
+ares_status_t ares_parse_sortlist(struct apattern **sortlist, size_t *nsort,
+                                  const char *str)
+{
+  ares_buf_t   *buf    = NULL;
+  ares_status_t status = ARES_SUCCESS;
+  ares_array_t *arr    = NULL;
+  size_t        num    = 0;
+  size_t        i;
+
+  if (sortlist == NULL || nsort == NULL || str == NULL) {
+    return ARES_EFORMERR; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
+
+  if (*sortlist != NULL) {
+    ares_free(*sortlist);
+  }
+
+  *sortlist = NULL;
+  *nsort    = 0;
+
+  buf = ares_buf_create_const((const unsigned char *)str, ares_strlen(str));
+  if (buf == NULL) {
+    status = ARES_ENOMEM;
+    goto done;
+  }
+
+  /* Split on space or semicolon */
+  status = ares_buf_split(buf, (const unsigned char *)" ;", 2,
+                          ARES_BUF_SPLIT_NONE, 0, &arr);
+  if (status != ARES_SUCCESS) {
+    goto done;
+  }
+
+  num = ares_array_len(arr);
+  for (i = 0; i < num; i++) {
+    ares_buf_t    **bufptr = ares_array_at(arr, i);
+    ares_buf_t     *entry  = *bufptr;
+
+    struct apattern pat;
+
+    status = parse_sort(entry, &pat);
+    if (status != ARES_SUCCESS && status != ARES_ENOTFOUND) {
+      goto done;
+    }
+
+    if (status != ARES_SUCCESS) {
+      continue;
+    }
+
+    if (!sortlist_append(sortlist, nsort, &pat)) {
+      status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+      goto done;            /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+  }
+
+  status = ARES_SUCCESS;
+
+done:
+  ares_buf_destroy(buf);
+  ares_array_destroy(arr);
+
+  if (status != ARES_SUCCESS) {
+    ares_free(*sortlist);
+    *sortlist = NULL;
+    *nsort    = 0;
+  }
+
+  return status;
+}
+
+static ares_status_t config_search(ares_sysconfig_t *sysconfig, const char *str,
+                                   size_t max_domains)
+{
+  if (sysconfig->domains && sysconfig->ndomains > 0) {
+    /* if we already have some domains present, free them first */
+    ares_strsplit_free(sysconfig->domains, sysconfig->ndomains);
+    sysconfig->domains  = NULL;
+    sysconfig->ndomains = 0;
+  }
+
+  sysconfig->domains = ares_strsplit(str, ", ", &sysconfig->ndomains);
+  if (sysconfig->domains == NULL) {
+    return ARES_ENOMEM;
+  }
+
+  /* Truncate if necessary */
+  if (max_domains && sysconfig->ndomains > max_domains) {
+    size_t i;
+    for (i = max_domains; i < sysconfig->ndomains; i++) {
+      ares_free(sysconfig->domains[i]);
+      sysconfig->domains[i] = NULL;
+    }
+    sysconfig->ndomains = max_domains;
+  }
+
+  return ARES_SUCCESS;
+}
+
+static ares_status_t buf_fetch_string(ares_buf_t *buf, char *str,
+                                      size_t str_len)
+{
+  ares_status_t status;
+  ares_buf_tag(buf);
+  ares_buf_consume(buf, ares_buf_len(buf));
+
+  status = ares_buf_tag_fetch_string(buf, str, str_len);
+  return status;
+}
+
+static ares_status_t config_lookup(ares_sysconfig_t *sysconfig, ares_buf_t *buf,
+                                   const char *separators)
+{
+  ares_status_t status;
+  char          lookupstr[32];
+  size_t        lookupstr_cnt = 0;
+  char        **lookups       = NULL;
+  size_t        num           = 0;
+  size_t        i;
+  size_t        separators_len = ares_strlen(separators);
+
+  status =
+    ares_buf_split_str(buf, (const unsigned char *)separators, separators_len,
+                       ARES_BUF_SPLIT_TRIM, 0, &lookups, &num);
+  if (status != ARES_SUCCESS) {
+    goto done;
+  }
+
+  for (i = 0; i < num; i++) {
+    const char *value = lookups[i];
+    char        ch;
+
+    /* AIX /etc/netsvc.conf uses address-family-suffixed tokens such as
+     * "bind4"/"bind6" and "local4"/"local6" in addition to the bare forms. */
+    if (ares_strcaseeq(value, "dns") || ares_strcaseeq(value, "bind") ||
+        ares_strcaseeq(value, "bind4") || ares_strcaseeq(value, "bind6") ||
+        ares_strcaseeq(value, "resolv") || ares_strcaseeq(value, "resolve")) {
+      ch = 'b';
+    } else if (ares_strcaseeq(value, "files") ||
+               ares_strcaseeq(value, "file") ||
+               ares_strcaseeq(value, "local") ||
+               ares_strcaseeq(value, "local4") ||
+               ares_strcaseeq(value, "local6")) {
+      ch = 'f';
+    } else {
+      continue;
+    }
+
+    /* Look for a duplicate and ignore */
+    if (memchr(lookupstr, ch, lookupstr_cnt) == NULL) {
+      lookupstr[lookupstr_cnt++] = ch;
+    }
+  }
+
+  if (lookupstr_cnt) {
+    lookupstr[lookupstr_cnt] = 0;
+    ares_free(sysconfig->lookups);
+    sysconfig->lookups = ares_strdup(lookupstr);
+    if (sysconfig->lookups == NULL) {
+      status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+      goto done;            /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+  }
+
+  status = ARES_SUCCESS;
+
+done:
+  if (status != ARES_ENOMEM) {
+    status = ARES_SUCCESS;
+  }
+  ares_free_array(lookups, num, ares_free);
+  return status;
+}
+
+static ares_status_t process_option(ares_sysconfig_t *sysconfig,
+                                    ares_buf_t       *option)
+{
+  char        **kv  = NULL;
+  size_t        num = 0;
+  const char   *key;
+  const char   *val;
+  unsigned int  valint = 0;
+  ares_status_t status;
+
+  /* Split on : */
+  status = ares_buf_split_str(option, (const unsigned char *)":", 1,
+                              ARES_BUF_SPLIT_TRIM, 2, &kv, &num);
+  if (status != ARES_SUCCESS) {
+    goto done;
+  }
+
+  if (num < 1) {
+    status = ARES_EBADSTR;
+    goto done;
+  }
+
+  key = kv[0];
+  if (num == 2) {
+    val = kv[1];
+    if (!ares_str_parse_uint(val, UINT_MAX, &valint)) {
+      status = ARES_EBADSTR;
+      goto done;
+    }
+  }
+
+  if (ares_streq(key, "ndots")) {
+    sysconfig->ndots = valint;
+  } else if (ares_streq(key, "retrans") || ares_streq(key, "timeout")) {
+    if (valint == 0) {
+      status = ARES_EFORMERR;
+      goto done;
+    }
+    sysconfig->timeout_ms = valint * 1000;
+  } else if (ares_streq(key, "retry") || ares_streq(key, "attempts")) {
+    if (valint == 0) {
+      status = ARES_EFORMERR;
+      goto done;
+    }
+    sysconfig->tries = valint;
+  } else if (ares_streq(key, "rotate")) {
+    sysconfig->rotate = ARES_TRUE;
+  } else if (ares_streq(key, "use-vc") || ares_streq(key, "usevc")) {
+    sysconfig->usevc = ARES_TRUE;
+  }
+
+done:
+  ares_free_array(kv, num, ares_free);
+  return status;
+}
+
+ares_status_t ares_sysconfig_set_options(ares_sysconfig_t *sysconfig,
+                                         const char       *str)
+{
+  ares_buf_t   *buf     = NULL;
+  ares_array_t *options = NULL;
+  size_t        num;
+  size_t        i;
+  ares_status_t status;
+
+  buf = ares_buf_create_const((const unsigned char *)str, ares_strlen(str));
+  if (buf == NULL) {
+    return ARES_ENOMEM;
+  }
+
+  status = ares_buf_split(buf, (const unsigned char *)" \t", 2,
+                          ARES_BUF_SPLIT_TRIM, 0, &options);
+  if (status != ARES_SUCCESS) {
+    goto done;
+  }
+
+  num = ares_array_len(options);
+  for (i = 0; i < num; i++) {
+    ares_buf_t **bufptr = ares_array_at(options, i);
+    ares_buf_t  *valbuf = *bufptr;
+
+    status = process_option(sysconfig, valbuf);
+    /* Out of memory is the only fatal condition */
+    if (status == ARES_ENOMEM) {
+      goto done; /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+  }
+
+  status = ARES_SUCCESS;
+
+done:
+  ares_array_destroy(options);
+  ares_buf_destroy(buf);
+  return status;
+}
+
+ares_status_t ares_init_by_environment(ares_sysconfig_t *sysconfig)
+{
+  const char   *localdomain;
+  const char   *res_options;
+  ares_status_t status;
+
+  localdomain = getenv("LOCALDOMAIN");
+  if (localdomain) {
+    char *temp = ares_strdup(localdomain);
+    if (temp == NULL) {
+      return ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+    }
+    status = config_search(sysconfig, temp, 1);
+    ares_free(temp);
+    if (status != ARES_SUCCESS) {
+      return status;
+    }
+  }
+
+  res_options = getenv("RES_OPTIONS");
+  if (res_options) {
+    status = ares_sysconfig_set_options(sysconfig, res_options);
+    if (status != ARES_SUCCESS) {
+      return status;
+    }
+  }
+
+  return ARES_SUCCESS;
+}
+
+/* Configuration Files:
+ *  /etc/resolv.conf
+ *    - All Unix-like systems
+ *    - Comments start with ; or #
+ *    - Lines have a keyword followed by a value that is interpreted specific
+ *      to the keyword:
+ *    - Keywords:
+ *      - nameserver - IP address of nameserver with optional port (using a :
+ *        prefix). If using an ipv6 address and specifying a port, the ipv6
+ *        address must be encapsulated in brackets. For link-local ipv6
+ *        addresses, the interface can also be specified with a % prefix. e.g.:
+ *          "nameserver [fe80::1]:1234%iface"
+ *        This keyword may be specified multiple times.
+ *      - search - whitespace separated list of domains
+ *      - domain - obsolete, same as search except only a single domain
+ *      - lookup / hostresorder - local, bind, file, files
+ *      - sortlist - whitespace separated ip-address/netmask pairs
+ *      - options - options controlling resolver variables
+ *        - ndots:n - set ndots option
+ *        - timeout:n (retrans:n) - timeout per query attempt in seconds
+ *        - attempts:n (retry:n) - number of times resolver will send query
+ *        - rotate - round-robin selection of name servers
+ *        - use-vc / usevc - force tcp
+ *  /etc/nsswitch.conf
+ *    - Modern Linux, FreeBSD, HP-UX, Solaris
+ *    - Search order set via:
+ *      "hosts: files dns mdns4_minimal mdns4"
+ *      - files is /etc/hosts
+ *      - dns is dns
+ *      - mdns4_minimal does mdns only if ending in .local
+ *      - mdns4 does not limit to domains ending in .local
+ *  /etc/netsvc.conf
+ *    - AIX
+ *    - Search order set via:
+ *      "hosts = local , bind"
+ *      - bind is dns
+ *      - local is /etc/hosts
+ *  /etc/svc.conf
+ *    - Tru64
+ *    - Same format as /etc/netsvc.conf
+ *  /etc/host.conf
+ *    - Early FreeBSD, Early Linux
+ *    - Not worth supporting, format varied based on system, FreeBSD used
+ *      just a line per search order, Linux used "order " and a comma
+ *      delimited list of "bind" and "hosts"
+ */
+
+
+/* This function will only return ARES_SUCCESS or ARES_ENOMEM.  Any other
+ * conditions are ignored.  Users may mess up config files, but we want to
+ * process anything we can. */
+ares_status_t ares_sysconfig_parse_resolv_line(const ares_channel_t *channel,
+                                               ares_sysconfig_t     *sysconfig,
+                                               ares_buf_t           *line)
+{
+  char          option[32];
+  char          value[512];
+  ares_status_t status = ARES_SUCCESS;
+
+  /* Ignore lines beginning with a comment */
+  if (ares_buf_begins_with(line, (const unsigned char *)"#", 1) ||
+      ares_buf_begins_with(line, (const unsigned char *)";", 1)) {
+    return ARES_SUCCESS;
+  }
+
+  ares_buf_tag(line);
+
+  /* Shouldn't be possible, but if it happens, ignore the line. */
+  if (ares_buf_consume_nonwhitespace(line) == 0) {
+    return ARES_SUCCESS;
+  }
+
+  status = ares_buf_tag_fetch_string(line, option, sizeof(option));
+  if (status != ARES_SUCCESS) {
+    return ARES_SUCCESS;
+  }
+
+  ares_buf_consume_whitespace(line, ARES_TRUE);
+
+  status = buf_fetch_string(line, value, sizeof(value));
+  if (status != ARES_SUCCESS) {
+    return ARES_SUCCESS;
+  }
+
+  ares_str_trim(value);
+  if (*value == 0) {
+    return ARES_SUCCESS;
+  }
+
+  /* At this point we have a string option and a string value, both trimmed
+   * of leading and trailing whitespace.  Lets try to evaluate them */
+  if (ares_streq(option, "domain")) {
+    /* Domain is legacy, don't overwrite an existing config set by search */
+    if (sysconfig->domains == NULL) {
+      status = config_search(sysconfig, value, 1);
+    }
+  } else if (ares_streq(option, "lookup") ||
+             ares_streq(option, "hostresorder")) {
+    ares_buf_tag_rollback(line);
+    status = config_lookup(sysconfig, line, " \t");
+  } else if (ares_streq(option, "search")) {
+    status = config_search(sysconfig, value, 0);
+  } else if (ares_streq(option, "nameserver")) {
+    status = ares_sconfig_append_fromstr(channel, &sysconfig->sconfig, value,
+                                         ARES_TRUE);
+  } else if (ares_streq(option, "sortlist")) {
+    /* Ignore all failures except ENOMEM.  If the sysadmin set a bad
+     * sortlist, just ignore the sortlist, don't cause an inoperable
+     * channel */
+    status =
+      ares_parse_sortlist(&sysconfig->sortlist, &sysconfig->nsortlist, value);
+    if (status != ARES_ENOMEM) {
+      status = ARES_SUCCESS;
+    }
+  } else if (ares_streq(option, "options")) {
+    status = ares_sysconfig_set_options(sysconfig, value);
+  }
+
+  return status;
+}
+
+/* This function will only return ARES_SUCCESS or ARES_ENOMEM.  Any other
+ * conditions are ignored.  Users may mess up config files, but we want to
+ * process anything we can. */
+static ares_status_t parse_nsswitch_line(const ares_channel_t *channel,
+                                         ares_sysconfig_t     *sysconfig,
+                                         ares_buf_t           *line)
+{
+  char          option[32];
+  ares_status_t status = ARES_SUCCESS;
+  ares_array_t *sects  = NULL;
+  ares_buf_t  **bufptr;
+  ares_buf_t   *buf;
+
+  (void)channel;
+
+  /* Ignore lines beginning with a comment */
+  if (ares_buf_begins_with(line, (const unsigned char *)"#", 1)) {
+    return ARES_SUCCESS;
+  }
+
+  /* database : values (space delimited) */
+  status = ares_buf_split(line, (const unsigned char *)":", 1,
+                          ARES_BUF_SPLIT_TRIM, 2, &sects);
+
+  if (status != ARES_SUCCESS || ares_array_len(sects) != 2) {
+    goto done;
+  }
+
+  bufptr = ares_array_at(sects, 0);
+  buf    = *bufptr;
+
+  status = buf_fetch_string(buf, option, sizeof(option));
+  if (status != ARES_SUCCESS) {
+    goto done;
+  }
+
+  /* Only support "hosts:" */
+  if (!ares_streq(option, "hosts")) {
+    goto done;
+  }
+
+  /* Values are space separated */
+  bufptr = ares_array_at(sects, 1);
+  buf    = *bufptr;
+  status = config_lookup(sysconfig, buf, " \t");
+
+done:
+  ares_array_destroy(sects);
+  if (status != ARES_ENOMEM) {
+    status = ARES_SUCCESS;
+  }
+  return status;
+}
+
+/* This function will only return ARES_SUCCESS or ARES_ENOMEM.  Any other
+ * conditions are ignored.  Users may mess up config files, but we want to
+ * process anything we can. */
+static ares_status_t parse_svcconf_line(const ares_channel_t *channel,
+                                        ares_sysconfig_t     *sysconfig,
+                                        ares_buf_t           *line)
+{
+  char          option[32];
+  ares_buf_t  **bufptr;
+  ares_buf_t   *buf;
+  ares_status_t status = ARES_SUCCESS;
+  ares_array_t *sects  = NULL;
+
+  (void)channel;
+
+  /* Ignore lines beginning with a comment */
+  if (ares_buf_begins_with(line, (const unsigned char *)"#", 1)) {
+    return ARES_SUCCESS;
+  }
+
+  /* database = values (comma delimited)*/
+  status = ares_buf_split(line, (const unsigned char *)"=", 1,
+                          ARES_BUF_SPLIT_TRIM, 2, &sects);
+
+  if (status != ARES_SUCCESS || ares_array_len(sects) != 2) {
+    goto done;
+  }
+
+  bufptr = ares_array_at(sects, 0);
+  buf    = *bufptr;
+  status = buf_fetch_string(buf, option, sizeof(option));
+  if (status != ARES_SUCCESS) {
+    goto done;
+  }
+
+  /* Only support "hosts=" */
+  if (!ares_streq(option, "hosts")) {
+    goto done;
+  }
+
+  /* Values are comma separated */
+  bufptr = ares_array_at(sects, 1);
+  buf    = *bufptr;
+  status = config_lookup(sysconfig, buf, ",");
+
+done:
+  ares_array_destroy(sects);
+  if (status != ARES_ENOMEM) {
+    status = ARES_SUCCESS;
+  }
+  return status;
+}
+
+
+ares_status_t ares_sysconfig_process_buf(const ares_channel_t    *channel,
+                                         ares_sysconfig_t        *sysconfig,
+                                         ares_buf_t              *buf,
+                                         ares_sysconfig_line_cb_t cb)
+{
+  ares_array_t *lines  = NULL;
+  size_t        num;
+  size_t        i;
+  ares_status_t status;
+
+  status = ares_buf_split(buf, (const unsigned char *)"\n", 1,
+                          ARES_BUF_SPLIT_TRIM, 0, &lines);
+  if (status != ARES_SUCCESS) {
+    goto done;
+  }
+
+  num = ares_array_len(lines);
+  for (i = 0; i < num; i++) {
+    ares_buf_t **bufptr = ares_array_at(lines, i);
+    ares_buf_t  *line   = *bufptr;
+
+    status = cb(channel, sysconfig, line);
+    if (status != ARES_SUCCESS) {
+      goto done;
+    }
+  }
+
+done:
+  ares_array_destroy(lines);
+  return status;
+}
+
+/* Should only return:
+ *  ARES_ENOTFOUND - file not found
+ *  ARES_EFILE     - error reading file (perms)
+ *  ARES_ENOMEM    - out of memory
+ *  ARES_SUCCESS   - file processed, doesn't necessarily mean it was a good
+ *                   file, but we're not erroring out if we can't parse
+ *                   something (or anything at all) */
+static ares_status_t process_config_lines(const ares_channel_t    *channel,
+                                          const char              *filename,
+                                          ares_sysconfig_t        *sysconfig,
+                                          ares_sysconfig_line_cb_t cb)
+{
+  ares_status_t status = ARES_SUCCESS;
+  ares_buf_t   *buf    = NULL;
+
+  buf = ares_buf_create();
+  if (buf == NULL) {
+    status = ARES_ENOMEM;
+    goto done;
+  }
+
+  status = ares_buf_load_file(filename, buf);
+  if (status != ARES_SUCCESS) {
+    goto done;
+  }
+
+  status = ares_sysconfig_process_buf(channel, sysconfig, buf, cb);
+
+done:
+  ares_buf_destroy(buf);
+
+  return status;
+}
+
+ares_status_t ares_init_sysconfig_files(const ares_channel_t *channel,
+                                        ares_sysconfig_t     *sysconfig,
+                                        ares_bool_t process_resolvconf)
+{
+  ares_status_t status = ARES_SUCCESS;
+
+  /* Resolv.conf */
+  if (process_resolvconf) {
+    status = process_config_lines(channel,
+                                  (channel->resolvconf_path != NULL)
+                                    ? channel->resolvconf_path
+                                    : PATH_RESOLV_CONF,
+                                  sysconfig, ares_sysconfig_parse_resolv_line);
+    if (status != ARES_SUCCESS && status != ARES_ENOTFOUND) {
+      goto done;
+    }
+  }
+
+  /* Nsswitch.conf */
+  status = process_config_lines(channel, "/etc/nsswitch.conf", sysconfig,
+                                parse_nsswitch_line);
+  if (status != ARES_SUCCESS && status != ARES_ENOTFOUND) {
+    goto done;
+  }
+
+  /* netsvc.conf */
+  status = process_config_lines(channel, "/etc/netsvc.conf", sysconfig,
+                                parse_svcconf_line);
+  if (status != ARES_SUCCESS && status != ARES_ENOTFOUND) {
+    goto done;
+  }
+
+  /* svc.conf */
+  status = process_config_lines(channel, "/etc/svc.conf", sysconfig,
+                                parse_svcconf_line);
+  if (status != ARES_SUCCESS && status != ARES_ENOTFOUND) {
+    goto done;
+  }
+
+  status = ARES_SUCCESS;
+
+done:
+  return status;
+}