/* Copyright 1998 by the Massachusetts Institute of Technology.

 * Copyright 2005 Dominick Meglio

 * Copyright (C) 2019 by Andrew Selivanov

 * Copyright (C) 2021 by Brad House

 *

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

 *

 * SPDX-License-Identifier: MIT

 */

#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

#include "ares_nameser.h"

#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_inet_net_pton.h"

#include "ares_private.h"

int ares__addrinfo2hostent(const struct ares_addrinfo *ai, int family,

                           struct hostent **host)

{

  struct ares_addrinfo_node *next;

  struct ares_addrinfo_cname *next_cname;

  char **aliases = NULL;

  char *addrs = NULL;

  int naliases = 0, naddrs = 0, alias = 0, i;

  if (ai == NULL || host == NULL)

    return ARES_EBADQUERY;

  *host = ares_malloc(sizeof(**host));

  if (!(*host))

    {

      goto enomem;

    }

  memset(*host, 0, sizeof(**host));

  /* Use the first node of the response as the family, since hostent can only

   * represent one family.  We assume getaddrinfo() returned a sorted list if

   * the user requested AF_UNSPEC. */

  if (family == AF_UNSPEC && ai->nodes)

    family = ai->nodes->ai_family;

  next = ai->nodes;

  while (next)

    {

      if(next->ai_family == family)

        {

          ++naddrs;

        }

      next = next->ai_next;

    }

  next_cname = ai->cnames;

  while (next_cname)

    {

      if(next_cname->alias)

        ++naliases;

      next_cname = next_cname->next;

    }

  aliases = ares_malloc((naliases + 1) * sizeof(char *));

  if (!aliases)

    {

      goto enomem;

    }

  (*host)->h_aliases = aliases;

  memset(aliases, 0, (naliases + 1) * sizeof(char *));

  if (naliases)

    {

      next_cname = ai->cnames;

      while (next_cname)

        {

          if(next_cname->alias) {

            aliases[alias] = ares_strdup(next_cname->alias);

            if (!aliases[alias]) {

              goto enomem;

            }

            alias++;

          }

          next_cname = next_cname->next;

        }

    }

  (*host)->h_addr_list = ares_malloc((naddrs + 1) * sizeof(char *));

  if (!(*host)->h_addr_list)

    {

      goto enomem;

    }

  memset((*host)->h_addr_list, 0, (naddrs + 1) * sizeof(char *));

  if (ai->cnames)

    {

      (*host)->h_name = ares_strdup(ai->cnames->name);

      if ((*host)->h_name == NULL && ai->cnames->name)

        {

          goto enomem;

        }

    }

  else

    {

      (*host)->h_name = ares_strdup(ai->name);

      if ((*host)->h_name == NULL && ai->name)

        {

          goto enomem;

        }

    }

  (*host)->h_addrtype = family;

  (*host)->h_length = (family == AF_INET)?

     sizeof(struct in_addr):sizeof(struct ares_in6_addr);

  if (naddrs)

    {

      addrs = ares_malloc(naddrs * (*host)->h_length);

      if (!addrs)

        {

          goto enomem;

        }

      i = 0;

      next = ai->nodes;

      while (next)

        {

          if(next->ai_family == family)

            {

              (*host)->h_addr_list[i] = addrs + (i * (*host)->h_length);

              if (family == AF_INET6)

                {

                  memcpy((*host)->h_addr_list[i],

                     &(CARES_INADDR_CAST(struct sockaddr_in6 *, next->ai_addr)->sin6_addr),

                     (*host)->h_length);

                }

              else

                {

                  memcpy((*host)->h_addr_list[i],

                     &(CARES_INADDR_CAST(struct sockaddr_in *, next->ai_addr)->sin_addr),

                     (*host)->h_length);

                }

              ++i;

            }

          next = next->ai_next;

        }

      if (i == 0)

        {

          ares_free(addrs);

        }

    }

  if (naddrs == 0 && naliases == 0)

    {

      ares_free_hostent(*host);

      *host = NULL;

      return ARES_ENODATA;

    }

  return ARES_SUCCESS;

enomem:

  ares_free_hostent(*host);

  *host = NULL;

  return ARES_ENOMEM;

}

int ares__addrinfo2addrttl(const struct ares_addrinfo *ai, int family,

                           int req_naddrttls, struct ares_addrttl *addrttls,

                           struct ares_addr6ttl *addr6ttls, int *naddrttls)

{

  struct ares_addrinfo_node *next;

  struct ares_addrinfo_cname *next_cname;

  int cname_ttl = INT_MAX;

  if (family != AF_INET && family != AF_INET6)

    return ARES_EBADQUERY;

  if (ai == NULL || naddrttls == NULL)

    return ARES_EBADQUERY;

  if (family == AF_INET && addrttls == NULL)

    return ARES_EBADQUERY;

  if (family == AF_INET6 && addr6ttls == NULL)

    return ARES_EBADQUERY;

  if (req_naddrttls == 0)

    return ARES_EBADQUERY;

  *naddrttls = 0;

  next_cname = ai->cnames;

  while (next_cname)

    {

      if(next_cname->ttl < cname_ttl)

        cname_ttl = next_cname->ttl;

      next_cname = next_cname->next;

    }

  next = ai->nodes;

  while (next)

    {

      if(next->ai_family == family)

        {

          if (*naddrttls < req_naddrttls)

            {

                if (family == AF_INET6)

                  {

                    if(next->ai_ttl > cname_ttl)

                      addr6ttls[*naddrttls].ttl = cname_ttl;

                    else

                      addr6ttls[*naddrttls].ttl = next->ai_ttl;

                    memcpy(&addr6ttls[*naddrttls].ip6addr,

                           &(CARES_INADDR_CAST(struct sockaddr_in6 *, next->ai_addr)->sin6_addr),

                           sizeof(struct ares_in6_addr));

                  }

                else

                  {

                    if(next->ai_ttl > cname_ttl)

                      addrttls[*naddrttls].ttl = cname_ttl;

                    else

                      addrttls[*naddrttls].ttl = next->ai_ttl;

                    memcpy(&addrttls[*naddrttls].ipaddr,

                           &(CARES_INADDR_CAST(struct sockaddr_in *, next->ai_addr)->sin_addr),

                           sizeof(struct in_addr));

                  }

                (*naddrttls)++;

             }

        }

      next = next->ai_next;

    }

  return ARES_SUCCESS;

}