CSE2410 Spring 2015 Slaking

/* 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;

  int srvr_first = 0;

  // If no open channel, no active conncetions, return end data. -----------------------------------------------------------------

  if (!channel) {

    return ARES_ENODATA;

  } else if (channel->num_servers_change > 0) {

    // Or, if true, then there must be at least 1 change to process

    srvr_first = channel->last_server;

  }

  // Modify loop to use list of tasks in ares_server_switch.c

  // for (i = 0; i < channel->nservers; i++)

  for (i = srvr_first; 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_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;

  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 = 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;

          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 */

int ares_set_servers_csv(ares_channel channel,

                         const char* _csv)

{

  size_t i;

  char* csv = NULL;

  char* ptr;

  char* start_host;

  int cc = 0;

  int rv = ARES_SUCCESS;

  struct ares_addr_node *servers = NULL;

  struct ares_addr_node *last = NULL;

  if (ares_library_initialized() != ARES_SUCCESS)

    return ARES_ENOTINITIALIZED;

  if (!channel)

    return ARES_ENODATA;

  ares__destroy_servers_state(channel);

  i = strlen(_csv);

  if (i == 0)

     return ARES_SUCCESS; /* blank all servers */

  csv = malloc(i + 2);

  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;

      struct in_addr in4;

      struct ares_in6_addr in6;

      struct ares_addr_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 */

          (void)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 = 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 = malloc(sizeof(*s));

        if (!s) {

          rv = ARES_ENOMEM;

          goto out;

        }

        s->family = AF_INET;

        memcpy(&s->addr, &in4, sizeof(struct in_addr));

      }

      if (s) {

        /* TODO:  Add port to ares_addr_node and assign it here. */

        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(channel, servers);

  out:

  if (csv)

    free(csv);

  while (servers) {

    struct ares_addr_node *s = servers;

    servers = servers->next;

    free(s);

  }

  return rv;

}