grpc 1.2.5 → 1.3.4

data/third_party/cares/cares/ares_options.c

@@ -0,0 +1,402 @@
+
+/* Copyright 1998 by the Massachusetts Institute of Technology.
+ * Copyright (C) 2008-2013 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_ARPA_INET_H
+#  include <arpa/inet.h>
+#endif
+
+#include "ares.h"
+#include "ares_data.h"
+#include "ares_inet_net_pton.h"
+#include "ares_private.h"
+
+
+int ares_get_servers(ares_channel channel,
+                     struct ares_addr_node **servers)
+{
+  struct ares_addr_node *srvr_head = NULL;
+  struct ares_addr_node *srvr_last = NULL;
+  struct ares_addr_node *srvr_curr;
+  int status = ARES_SUCCESS;
+  int i;
+
+  if (!channel)
+    return ARES_ENODATA;
+
+  for (i = 0; i < channel->nservers; i++)
+    {
+      /* Allocate storage for this server node appending it to the list */
+      srvr_curr = ares_malloc_data(ARES_DATATYPE_ADDR_NODE);
+      if (!srvr_curr)
+        {
+          status = ARES_ENOMEM;
+          break;
+        }
+      if (srvr_last)
+        {
+          srvr_last->next = srvr_curr;
+        }
+      else
+        {
+          srvr_head = srvr_curr;
+        }
+      srvr_last = srvr_curr;
+
+      /* Fill this server node data */
+      srvr_curr->family = channel->servers[i].addr.family;
+      if (srvr_curr->family == AF_INET)
+        memcpy(&srvr_curr->addrV4, &channel->servers[i].addr.addrV4,
+               sizeof(srvr_curr->addrV4));
+      else
+        memcpy(&srvr_curr->addrV6, &channel->servers[i].addr.addrV6,
+               sizeof(srvr_curr->addrV6));
+    }
+
+  if (status != ARES_SUCCESS)
+    {
+      if (srvr_head)
+        {
+          ares_free_data(srvr_head);
+          srvr_head = NULL;
+        }
+    }
+
+  *servers = srvr_head;
+
+  return status;
+}
+
+int ares_get_servers_ports(ares_channel channel,
+                           struct ares_addr_port_node **servers)
+{
+  struct ares_addr_port_node *srvr_head = NULL;
+  struct ares_addr_port_node *srvr_last = NULL;
+  struct ares_addr_port_node *srvr_curr;
+  int status = ARES_SUCCESS;
+  int i;
+
+  if (!channel)
+    return ARES_ENODATA;
+
+  for (i = 0; i < channel->nservers; i++)
+    {
+      /* Allocate storage for this server node appending it to the list */
+      srvr_curr = ares_malloc_data(ARES_DATATYPE_ADDR_PORT_NODE);
+      if (!srvr_curr)
+        {
+          status = ARES_ENOMEM;
+          break;
+        }
+      if (srvr_last)
+        {
+          srvr_last->next = srvr_curr;
+        }
+      else
+        {
+          srvr_head = srvr_curr;
+        }
+      srvr_last = srvr_curr;
+
+      /* Fill this server node data */
+      srvr_curr->family = channel->servers[i].addr.family;
+      srvr_curr->udp_port = ntohs((unsigned short)channel->servers[i].addr.udp_port);
+      srvr_curr->tcp_port = ntohs((unsigned short)channel->servers[i].addr.tcp_port);
+      if (srvr_curr->family == AF_INET)
+        memcpy(&srvr_curr->addrV4, &channel->servers[i].addr.addrV4,
+               sizeof(srvr_curr->addrV4));
+      else
+        memcpy(&srvr_curr->addrV6, &channel->servers[i].addr.addrV6,
+               sizeof(srvr_curr->addrV6));
+    }
+
+  if (status != ARES_SUCCESS)
+    {
+      if (srvr_head)
+        {
+          ares_free_data(srvr_head);
+          srvr_head = NULL;
+        }
+    }
+
+  *servers = srvr_head;
+
+  return status;
+}
+
+int ares_set_servers(ares_channel channel,
+                     struct ares_addr_node *servers)
+{
+  struct ares_addr_node *srvr;
+  int num_srvrs = 0;
+  int i;
+
+  if (ares_library_initialized() != ARES_SUCCESS)
+    return ARES_ENOTINITIALIZED;  /* LCOV_EXCL_LINE: n/a on non-WinSock */
+
+  if (!channel)
+    return ARES_ENODATA;
+
+  ares__destroy_servers_state(channel);
+
+  for (srvr = servers; srvr; srvr = srvr->next)
+    {
+      num_srvrs++;
+    }
+
+  if (num_srvrs > 0)
+    {
+      /* Allocate storage for servers state */
+      channel->servers = ares_malloc(num_srvrs * sizeof(struct server_state));
+      if (!channel->servers)
+        {
+          return ARES_ENOMEM;
+        }
+      channel->nservers = num_srvrs;
+      /* Fill servers state address data */
+      for (i = 0, srvr = servers; srvr; i++, srvr = srvr->next)
+        {
+          channel->servers[i].addr.family = srvr->family;
+          channel->servers[i].addr.udp_port = 0;
+          channel->servers[i].addr.tcp_port = 0;
+          if (srvr->family == AF_INET)
+            memcpy(&channel->servers[i].addr.addrV4, &srvr->addrV4,
+                   sizeof(srvr->addrV4));
+          else
+            memcpy(&channel->servers[i].addr.addrV6, &srvr->addrV6,
+                   sizeof(srvr->addrV6));
+        }
+      /* Initialize servers state remaining data */
+      ares__init_servers_state(channel);
+    }
+
+  return ARES_SUCCESS;
+}
+
+int ares_set_servers_ports(ares_channel channel,
+                           struct ares_addr_port_node *servers)
+{
+  struct ares_addr_port_node *srvr;
+  int num_srvrs = 0;
+  int i;
+
+  if (ares_library_initialized() != ARES_SUCCESS)
+    return ARES_ENOTINITIALIZED;  /* LCOV_EXCL_LINE: n/a on non-WinSock */
+
+  if (!channel)
+    return ARES_ENODATA;
+
+  ares__destroy_servers_state(channel);
+
+  for (srvr = servers; srvr; srvr = srvr->next)
+    {
+      num_srvrs++;
+    }
+
+  if (num_srvrs > 0)
+    {
+      /* Allocate storage for servers state */
+      channel->servers = ares_malloc(num_srvrs * sizeof(struct server_state));
+      if (!channel->servers)
+        {
+          return ARES_ENOMEM;
+        }
+      channel->nservers = num_srvrs;
+      /* Fill servers state address data */
+      for (i = 0, srvr = servers; srvr; i++, srvr = srvr->next)
+        {
+          channel->servers[i].addr.family = srvr->family;
+          channel->servers[i].addr.udp_port = htons((unsigned short)srvr->udp_port);
+          channel->servers[i].addr.tcp_port = htons((unsigned short)srvr->tcp_port);
+          if (srvr->family == AF_INET)
+            memcpy(&channel->servers[i].addr.addrV4, &srvr->addrV4,
+                   sizeof(srvr->addrV4));
+          else
+            memcpy(&channel->servers[i].addr.addrV6, &srvr->addrV6,
+                   sizeof(srvr->addrV6));
+        }
+      /* Initialize servers state remaining data */
+      ares__init_servers_state(channel);
+    }
+
+  return ARES_SUCCESS;
+}
+
+/* Incomming string format: host[:port][,host[:port]]... */
+/* IPv6 addresses with ports require square brackets [fe80::1%lo0]:53 */
+static int set_servers_csv(ares_channel channel,
+                           const char* _csv, int use_port)
+{
+  size_t i;
+  char* csv = NULL;
+  char* ptr;
+  char* start_host;
+  int cc = 0;
+  int rv = ARES_SUCCESS;
+  struct ares_addr_port_node *servers = NULL;
+  struct ares_addr_port_node *last = NULL;
+
+  if (ares_library_initialized() != ARES_SUCCESS)
+    return ARES_ENOTINITIALIZED;  /* LCOV_EXCL_LINE: n/a on non-WinSock */
+
+  if (!channel)
+    return ARES_ENODATA;
+
+  ares__destroy_servers_state(channel);
+
+  i = strlen(_csv);
+  if (i == 0)
+     return ARES_SUCCESS; /* blank all servers */
+
+  csv = ares_malloc(i + 2);
+  if (!csv)
+    return ARES_ENOMEM;
+
+  strcpy(csv, _csv);
+  if (csv[i-1] != ',') { /* make parsing easier by ensuring ending ',' */
+    csv[i] = ',';
+    csv[i+1] = 0;
+  }
+
+  start_host = csv;
+  for (ptr = csv; *ptr; ptr++) {
+    if (*ptr == ':') {
+      /* count colons to determine if we have an IPv6 number or IPv4 with
+         port */
+      cc++;
+    }
+    else if (*ptr == '[') {
+      /* move start_host if an open square bracket is found wrapping an IPv6
+         address */
+      start_host = ptr + 1;
+    }
+    else if (*ptr == ',') {
+      char* pp = ptr - 1;
+      char* p = ptr;
+      int port = 0;
+      struct in_addr in4;
+      struct ares_in6_addr in6;
+      struct ares_addr_port_node *s = NULL;
+
+      *ptr = 0; /* null terminate host:port string */
+      /* Got an entry..see if the port was specified. */
+      if (cc > 0) {
+        while (pp > start_host) {
+          /* a single close square bracket followed by a colon, ']:' indicates
+             an IPv6 address with port */
+          if ((*pp == ']') && (*p == ':'))
+            break; /* found port */
+          /* a single colon, ':' indicates an IPv4 address with port */
+          if ((*pp == ':') && (cc == 1))
+            break; /* found port */
+          if (!(ISDIGIT(*pp) || (*pp == ':'))) {
+            /* Found end of digits before we found :, so wasn't a port */
+            /* must allow ':' for IPv6 case of ']:' indicates we found a port */
+            pp = p = ptr;
+            break;
+          }
+          pp--;
+          p--;
+        }
+        if ((pp != start_host) && ((pp + 1) < ptr)) {
+          /* Found it. Parse over the port number */
+          /* when an IPv6 address is wrapped with square brackets the port
+             starts at pp + 2 */
+          if (*pp == ']')
+            p++; /* move p before ':' */
+          /* p will point to the start of the port */
+          port = (int)strtol(p, NULL, 10);
+          *pp = 0; /* null terminate host */
+        }
+      }
+      /* resolve host, try ipv4 first, rslt is in network byte order */
+      rv = ares_inet_pton(AF_INET, start_host, &in4);
+      if (!rv) {
+        /* Ok, try IPv6 then */
+        rv = ares_inet_pton(AF_INET6, start_host, &in6);
+        if (!rv) {
+          rv = ARES_EBADSTR;
+          goto out;
+        }
+        /* was ipv6, add new server */
+        s = ares_malloc(sizeof(*s));
+        if (!s) {
+          rv = ARES_ENOMEM;
+          goto out;
+        }
+        s->family = AF_INET6;
+        memcpy(&s->addr, &in6, sizeof(struct ares_in6_addr));
+      }
+      else {
+        /* was ipv4, add new server */
+        s = ares_malloc(sizeof(*s));
+        if (!s) {
+          rv = ARES_ENOMEM;
+          goto out;
+        }
+        s->family = AF_INET;
+        memcpy(&s->addr, &in4, sizeof(struct in_addr));
+      }
+      if (s) {
+        s->udp_port = use_port ? port: 0;
+        s->tcp_port = s->udp_port;
+        s->next = NULL;
+        if (last) {
+          last->next = s;
+          /* need to move last to maintain the linked list */
+          last = last->next;
+        }
+        else {
+          servers = s;
+          last = s;
+        }
+      }
+
+      /* Set up for next one */
+      start_host = ptr + 1;
+      cc = 0;
+    }
+  }
+
+  rv = ares_set_servers_ports(channel, servers);
+
+  out:
+  if (csv)
+    ares_free(csv);
+  while (servers) {
+    struct ares_addr_port_node *s = servers;
+    servers = servers->next;
+    ares_free(s);
+  }
+
+  return rv;
+}
+
+int ares_set_servers_csv(ares_channel channel,
+                         const char* _csv)
+{
+  return set_servers_csv(channel, _csv, FALSE);
+}
+
+int ares_set_servers_ports_csv(ares_channel channel,
+                               const char* _csv)
+{
+  return set_servers_csv(channel, _csv, TRUE);
+}
+

data/third_party/cares/cares/ares_parse_a_reply.c

@@ -0,0 +1,264 @@
+
+/* Copyright 1998 by the Massachusetts Institute of Technology.
+ *
+ * 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_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_STRINGS_H
+#  include <strings.h>
+#endif
+
+#ifdef HAVE_LIMITS_H
+#  include <limits.h>
+#endif
+
+#include "ares.h"
+#include "ares_dns.h"
+#include "ares_private.h"
+
+int ares_parse_a_reply(const unsigned char *abuf, int alen,
+                       struct hostent **host,
+                       struct ares_addrttl *addrttls, int *naddrttls)
+{
+  unsigned int qdcount, ancount;
+  int status, i, rr_type, rr_class, rr_len, rr_ttl, naddrs;
+  int cname_ttl = INT_MAX;  /* the TTL imposed by the CNAME chain */
+  int naliases;
+  long len;
+  const unsigned char *aptr;
+  char *hostname, *rr_name, *rr_data, **aliases;
+  struct in_addr *addrs;
+  struct hostent *hostent;
+  const int max_addr_ttls = (addrttls && naddrttls) ? *naddrttls : 0;
+
+  /* Set *host to NULL for all failure cases. */
+  if (host)
+    *host = NULL;
+  /* Same with *naddrttls. */
+  if (naddrttls)
+    *naddrttls = 0;
+
+  /* Give up if abuf doesn't have room for a header. */
+  if (alen < HFIXEDSZ)
+    return ARES_EBADRESP;
+
+  /* Fetch the question and answer count from the header. */
+  qdcount = DNS_HEADER_QDCOUNT(abuf);
+  ancount = DNS_HEADER_ANCOUNT(abuf);
+  if (qdcount != 1)
+    return ARES_EBADRESP;
+
+  /* Expand the name from the question, and skip past the question. */
+  aptr = abuf + HFIXEDSZ;
+  status = ares__expand_name_for_response(aptr, abuf, alen, &hostname, &len);
+  if (status != ARES_SUCCESS)
+    return status;
+  if (aptr + len + QFIXEDSZ > abuf + alen)
+    {
+      ares_free(hostname);
+      return ARES_EBADRESP;
+    }
+  aptr += len + QFIXEDSZ;
+
+  if (host)
+    {
+      /* Allocate addresses and aliases; ancount gives an upper bound for
+         both. */
+      addrs = ares_malloc(ancount * sizeof(struct in_addr));
+      if (!addrs)
+        {
+          ares_free(hostname);
+          return ARES_ENOMEM;
+        }
+      aliases = ares_malloc((ancount + 1) * sizeof(char *));
+      if (!aliases)
+        {
+          ares_free(hostname);
+          ares_free(addrs);
+          return ARES_ENOMEM;
+        }
+    }
+  else
+    {
+      addrs = NULL;
+      aliases = NULL;
+    }
+
+  naddrs = 0;
+  naliases = 0;
+
+  /* Examine each answer resource record (RR) in turn. */
+  for (i = 0; i < (int)ancount; i++)
+    {
+      /* Decode the RR up to the data field. */
+      status = ares__expand_name_for_response(aptr, abuf, alen, &rr_name, &len);
+      if (status != ARES_SUCCESS)
+        break;
+      aptr += len;
+      if (aptr + RRFIXEDSZ > abuf + alen)
+        {
+          ares_free(rr_name);
+          status = ARES_EBADRESP;
+          break;
+        }
+      rr_type = DNS_RR_TYPE(aptr);
+      rr_class = DNS_RR_CLASS(aptr);
+      rr_len = DNS_RR_LEN(aptr);
+      rr_ttl = DNS_RR_TTL(aptr);
+      aptr += RRFIXEDSZ;
+      if (aptr + rr_len > abuf + alen)
+        {
+          ares_free(rr_name);
+          status = ARES_EBADRESP;
+          break;
+        }
+
+      if (rr_class == C_IN && rr_type == T_A
+          && rr_len == sizeof(struct in_addr)
+          && strcasecmp(rr_name, hostname) == 0)
+        {
+          if (addrs)
+            {
+              if (aptr + sizeof(struct in_addr) > abuf + alen)
+              {  /* LCOV_EXCL_START: already checked above */
+                ares_free(rr_name);
+                status = ARES_EBADRESP;
+                break;
+              }  /* LCOV_EXCL_STOP */
+              memcpy(&addrs[naddrs], aptr, sizeof(struct in_addr));
+            }
+          if (naddrs < max_addr_ttls)
+            {
+              struct ares_addrttl * const at = &addrttls[naddrs];
+              if (aptr + sizeof(struct in_addr) > abuf + alen)
+              {  /* LCOV_EXCL_START: already checked above */
+                ares_free(rr_name);
+                status = ARES_EBADRESP;
+                break;
+              }  /* LCOV_EXCL_STOP */
+              memcpy(&at->ipaddr, aptr,  sizeof(struct in_addr));
+              at->ttl = rr_ttl;
+            }
+          naddrs++;
+          status = ARES_SUCCESS;
+        }
+
+      if (rr_class == C_IN && rr_type == T_CNAME)
+        {
+          /* Record the RR name as an alias. */
+          if (aliases)
+            aliases[naliases] = rr_name;
+          else
+            ares_free(rr_name);
+          naliases++;
+
+          /* Decode the RR data and replace the hostname with it. */
+          status = ares__expand_name_for_response(aptr, abuf, alen, &rr_data,
+                                                  &len);
+          if (status != ARES_SUCCESS)
+            break;
+          ares_free(hostname);
+          hostname = rr_data;
+
+          /* Take the min of the TTLs we see in the CNAME chain. */
+          if (cname_ttl > rr_ttl)
+            cname_ttl = rr_ttl;
+        }
+      else
+        ares_free(rr_name);
+
+      aptr += rr_len;
+      if (aptr > abuf + alen)
+        {  /* LCOV_EXCL_START: already checked above */
+          status = ARES_EBADRESP;
+          break;
+        }  /* LCOV_EXCL_STOP */
+    }
+
+  if (status == ARES_SUCCESS && naddrs == 0 && naliases == 0)
+    /* the check for naliases to be zero is to make sure CNAME responses
+       don't get caught here */
+    status = ARES_ENODATA;
+  if (status == ARES_SUCCESS)
+    {
+      /* We got our answer. */
+      if (naddrttls)
+        {
+          const int n = naddrs < max_addr_ttls ? naddrs : max_addr_ttls;
+          for (i = 0; i < n; i++)
+            {
+              /* Ensure that each A TTL is no larger than the CNAME TTL. */
+              if (addrttls[i].ttl > cname_ttl)
+                addrttls[i].ttl = cname_ttl;
+            }
+          *naddrttls = n;
+        }
+      if (aliases)
+        aliases[naliases] = NULL;
+      if (host)
+        {
+          /* Allocate memory to build the host entry. */
+          hostent = ares_malloc(sizeof(struct hostent));
+          if (hostent)
+            {
+              hostent->h_addr_list = ares_malloc((naddrs + 1) * sizeof(char *));
+              if (hostent->h_addr_list)
+                {
+                  /* Fill in the hostent and return successfully. */
+                  hostent->h_name = hostname;
+                  hostent->h_aliases = aliases;
+                  hostent->h_addrtype = AF_INET;
+                  hostent->h_length = sizeof(struct in_addr);
+                  for (i = 0; i < naddrs; i++)
+                    hostent->h_addr_list[i] = (char *) &addrs[i];
+                  hostent->h_addr_list[naddrs] = NULL;
+                  if (!naddrs && addrs)
+                    ares_free(addrs);
+                  *host = hostent;
+                  return ARES_SUCCESS;
+                }
+              ares_free(hostent);
+            }
+          status = ARES_ENOMEM;
+        }
+     }
+  if (aliases)
+    {
+      for (i = 0; i < naliases; i++)
+        ares_free(aliases[i]);
+      ares_free(aliases);
+    }
+  ares_free(addrs);
+  ares_free(hostname);
+  return status;
+}