/* Check that RES_ROTATE works with few nameserver entries (bug 13028).

   Copyright (C) 2017-2018 Free Software Foundation, Inc.

   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Lesser General Public

   License as published by the Free Software Foundation; either

   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public

   License along with the GNU C Library; if not, see

   <http://www.gnu.org/licenses/>.  */

#include <netdb.h>

#include <resolv.h>

#include <stdlib.h>

#include <string.h>

#include <support/check.h>

#include <support/check_nss.h>

#include <support/resolv_test.h>

#include <support/test-driver.h>

static volatile int drop_server = -1;

static volatile unsigned int query_counts[resolv_max_test_servers];

static const char address_ipv4[4] = {192, 0, 2, 1};

static const char address_ipv6[16]

  = {0x20, 0x01, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};

static void

response (const struct resolv_response_context *ctx,

          struct resolv_response_builder *b,

          const char *qname, uint16_t qclass, uint16_t qtype)

{

  if (ctx->server_index == drop_server)

    {

      resolv_response_drop (b);

      resolv_response_close (b);

      return;

    }

  bool force_tcp = strncmp (qname, "2.", 2) == 0;

  struct resolv_response_flags flags = {.tc = force_tcp && !ctx->tcp};

  resolv_response_init (b, flags);

  resolv_response_add_question (b, qname, qclass, qtype);

  if (flags.tc)

    return;

  TEST_VERIFY_EXIT (ctx->server_index < resolv_max_test_servers);

  ++query_counts[ctx->server_index];

  resolv_response_section (b, ns_s_an);

  resolv_response_open_record (b, qname, qclass, qtype, 0);

  switch (qtype)

    {

    case T_A:

      {

        char addr[sizeof (address_ipv4)];

        memcpy (addr, address_ipv4, sizeof (address_ipv4));

        addr[3] = 1 + ctx->tcp;

        resolv_response_add_data (b, addr, sizeof (addr));

      }

      break;

    case T_AAAA:

      {

        char addr[sizeof (address_ipv6)];

        memcpy (addr, address_ipv6, sizeof (address_ipv6));

        addr[15] = 1 + ctx->tcp;

        resolv_response_add_data (b, addr, sizeof (addr));

      }

      break;

    case T_PTR:

      if (force_tcp)

        resolv_response_add_name (b, "2.host.example");

      else

        resolv_response_add_name (b, "host.example");

      break;

    default:

      FAIL_EXIT1 ("unexpected QTYPE: %s/%u/%u", qname, qclass, qtype);

    }

  resolv_response_close_record (b);

}

static void

check_forward_1 (const char *name, int family)

{

  unsigned char lsb;

  if (strncmp (name, "2.", 2) == 0)

    lsb = 2;

  else

    lsb = 1;

  char expected_hostent_v4[200];

  snprintf (expected_hostent_v4, sizeof (expected_hostent_v4),

            "name: %s\naddress: 192.0.2.%d\n", name, lsb);

  char expected_hostent_v6[200];

  snprintf (expected_hostent_v6, sizeof (expected_hostent_v6),

            "name: %s\naddress: 2001:db8::%d\n", name, lsb);

  char expected_ai[200];

  unsigned char address[16];

  size_t address_length;

  char *expected_hostent;

  switch (family)

    {

    case AF_INET:

      expected_hostent = expected_hostent_v4;

      snprintf (expected_ai, sizeof (expected_ai),

                "address: STREAM/TCP 192.0.2.%d 80\n", lsb);

      TEST_VERIFY_EXIT (sizeof (address_ipv4) == sizeof (struct in_addr));

      memcpy (address, address_ipv4, sizeof (address_ipv4));

      address_length = sizeof (address_ipv4);

      break;

    case AF_INET6:

      expected_hostent = expected_hostent_v6;

      snprintf (expected_ai, sizeof (expected_ai),

                "address: STREAM/TCP 2001:db8::%d 80\n", lsb);

      TEST_VERIFY_EXIT (sizeof (address_ipv6) == sizeof (struct in6_addr));

      memcpy (address, address_ipv6, sizeof (address_ipv6));

      address_length = sizeof (address_ipv6);

      break;

    case AF_UNSPEC:

      expected_hostent = NULL;

      snprintf (expected_ai, sizeof (expected_ai),

                "address: STREAM/TCP 192.0.2.%d 80\n"

                "address: STREAM/TCP 2001:db8::%d 80\n",

                lsb, lsb);

      address_length = 0;

      break;

    default:

      FAIL_EXIT1 ("unknown address family %d", family);

    }

  if (family == AF_INET)

    {

      struct hostent *e = gethostbyname (name);

      check_hostent (name, e, expected_hostent_v4);

    }

  if (family != AF_UNSPEC)

    {

      struct hostent *e = gethostbyname2 (name, family);

      check_hostent (name, e, expected_hostent);

    }

  if (address_length > 0)

    {

      address[address_length - 1] = lsb;

      struct hostent *e = gethostbyaddr (address, address_length, family);

      check_hostent (name, e, expected_hostent);

    }

  struct addrinfo hints =

    {

      .ai_family = family,

      .ai_socktype = SOCK_STREAM,

      .ai_protocol = IPPROTO_TCP,

    };

  struct addrinfo *ai;

  int ret = getaddrinfo (name, "80", &hints, &ai;;

  check_addrinfo (name, ai, ret, expected_ai);

  if (ret == 0)

    {

      for (struct addrinfo *p = ai; p != NULL; p = p->ai_next)

        {

          char host[200];

          ret = getnameinfo (p->ai_addr, p->ai_addrlen,

                             host, sizeof (host),

                             NULL, 0, /* service */

                             0);

          if (ret != 0)

            {

              support_record_failure ();

              printf ("error: getnameinfo: %d\n", ret);

            }

          else

            {

              if (lsb == 1)

                TEST_VERIFY (strcmp (host, "host.example") == 0);

              else

                TEST_VERIFY (strcmp (host, "2.host.example") == 0);

            }

        }

      freeaddrinfo (ai);

    }

}

static void

check_forward (int family)

{

  check_forward_1 ("host.example", family);

  check_forward_1 ("2.host.example", family);

}

static int

do_test (void)

{

  for (int force_tcp = 0; force_tcp < 2; ++force_tcp)

    for (int nscount = 1; nscount <= 3; ++nscount)

      for (int disable_server = -1; disable_server < nscount; ++disable_server)

        for (drop_server = -1; drop_server < nscount; ++drop_server)

          {

            /* A disabled server will never receive queries and

               therefore cannot drop them.  */

            if (drop_server >= 0 && drop_server == disable_server)

              continue;

            /* No servers remaining to query, all queries are expected

               to fail.  */

            int broken_servers = (disable_server >= 0) + (drop_server >= 0);

            if (nscount <= broken_servers)

              continue;

            if (test_verbose > 0)

              printf ("info: tcp=%d nscount=%d disable=%d drop=%d\n",

                      force_tcp, nscount, disable_server, drop_server);

            struct resolv_redirect_config config =

              {

                .response_callback = response,

                .nscount = nscount

              };

            if (disable_server >= 0)

              {

                config.servers[disable_server].disable_udp = true;

                config.servers[disable_server].disable_tcp = true;

              }

            struct resolv_test *aux = resolv_test_start (config);

            _res.options |= RES_ROTATE;

            /* Run a few queries to make sure that all of them

               succeed.  We always perform more than nscount queries,

               so we cover all active servers due to RES_ROTATE.  */

            for (size_t i = 0; i < resolv_max_test_servers; ++i)

              query_counts[i] = 0;

            check_forward (AF_INET);

            check_forward (AF_INET6);

            check_forward (AF_UNSPEC);

            for (int i = 0; i < nscount; ++i)

              {

                if (i != disable_server && i != drop_server

                    && query_counts[i] == 0)

                  {

                    support_record_failure ();

                    printf ("error: nscount=%d, but no query to server %d\n",

                            nscount, i);

                  }

              }

            resolv_test_end (aux);

          }

  return 0;

}

#define TIMEOUT 300

#include <support/test-driver.c>