/* Test search/default domain name behavior.

   Copyright (C) 2016-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 <resolv.h>

#include <stdlib.h>

#include <string.h>

#include <support/check.h>

#include <support/check_nss.h>

#include <support/resolv_test.h>

#include <support/support.h>

#include <support/xmemstream.h>

struct item

{

  const char *name;

  int response;

};

const struct item items[] =

  {

    {"hostname.usersys.example.com", 1},

    {"hostname.corp.example.com", 1},

    {"hostname.example.com", 1},

    {"mail.corp.example.com", 1},

    {"mail.example.com", 1},

    {"file.corp.example.com", 2},

    {"file.corp", 1},

    {"file.example.com", 1},

    {"servfail-usersys.usersys.example.com", -ns_r_servfail},

    {"servfail-usersys.corp.example.com", 1},

    {"servfail-usersys.example.com", 1},

    {"servfail-corp.usersys.example.com", 1},

    {"servfail-corp.corp.example.com", -ns_r_servfail},

    {"servfail-corp.example.com", 1},

    {"www.example.com", 1},

    {"large.example.com", 200},

    /* Test query amplification with a SERVFAIL response combined with

       a large RRset.  */

    {"large-servfail.usersys.example.com", -ns_r_servfail},

    {"large-servfail.example.com", 2000},

    {}

  };

enum

  {

    name_not_found = -1,

    name_no_data = -2

  };

static int

find_name (const char *name)

{

  for (int i = 0; items[i].name != NULL; ++i)

    {

      if (strcmp (name, items[i].name) == 0)

        return i;

    }

  if (strcmp (name, "example.com") == 0

      || strcmp (name, "usersys.example.com") == 0

      || strcmp (name, "corp.example.com") == 0)

    return name_no_data;

  return name_not_found;

}

static int rcode_override_server_index = -1;

static int rcode_override;

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 == rcode_override_server_index)

    {

      struct resolv_response_flags flags = {.rcode = rcode_override};

      resolv_response_init (b, flags);

      resolv_response_add_question (b, qname, qclass, qtype);

      return;

    }

  int index = find_name (qname);

  struct resolv_response_flags flags = {};

  if (index == name_not_found)

    flags.rcode = ns_r_nxdomain;

  else if (index >= 0 && items[index].response < 0)

    flags.rcode = -items[index].response;

  else if (index >= 0 && items[index].response > 5 && !ctx->tcp)

    /* Force TCP if more than 5 addresses where requested.  */

    flags.tc = true;

  resolv_response_init (b, flags);

  resolv_response_add_question (b, qname, qclass, qtype);

  if (flags.tc || index < 0 || items[index].response < 0)

    return;

  resolv_response_section (b, ns_s_an);

  for (int i = 0; i < items[index].response; ++i)

    {

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

      switch (qtype)

        {

        case T_A:

          {

            char addr[4] = {10, index, i >> 8, i};

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

          }

          break;

        case T_AAAA:

          {

            char addr[16]

              = {0x20, 0x01, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0,

                 0, index + 1, (i + 1) >> 8, i + 1};

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

          }

          break;

        default:

          support_record_failure ();

          printf ("error: unexpected QTYPE: %s/%u/%u\n",

                  qname, qclass, qtype);

        }

      resolv_response_close_record (b);

    }

}

enum output_format

  {

    format_get, format_gai

  };

static void

format_expected_1 (FILE *out, int family, enum output_format format, int index)

{

  for (int i = 0; i < items[index].response; ++i)

    {

      char address[200];

      switch (family)

        {

        case AF_INET:

          snprintf (address, sizeof (address), "10.%d.%d.%d",

                    index, (i >> 8) & 0xff, i & 0xff);

          break;

        case AF_INET6:

          snprintf (address, sizeof (address), "2001:db8::%x:%x",

                    index + 1, i + 1);

          break;

        default:

          FAIL_EXIT1 ("unreachable");

        }

      switch (format)

        {

        case format_get:

          fprintf (out, "address: %s\n", address);

          break;

        case format_gai:

          fprintf (out, "address: STREAM/TCP %s 80\n", address);

        }

    }

}

static char *

format_expected (const char *fqdn, int family, enum output_format format)

{

  int index = find_name (fqdn);

  TEST_VERIFY_EXIT (index >= 0);

  struct xmemstream stream;

  xopen_memstream (&stream);

  TEST_VERIFY_EXIT (items[index].response >= 0);

  if (format == format_get)

    fprintf (stream.out, "name: %s\n", items[index].name);

  if (family == AF_INET || family == AF_UNSPEC)

    format_expected_1 (stream.out, AF_INET, format, index);

  if (family == AF_INET6 || family == AF_UNSPEC)

    format_expected_1 (stream.out, AF_INET6, format, index);

  xfclose_memstream (&stream);

  return stream.buffer;

}

static void

do_get (const char *name, const char *fqdn, int family)

{

  char *expected = format_expected (fqdn, family, format_get);

  if (family == AF_INET)

    {

      char *query = xasprintf ("gethostbyname (\"%s\")", name);

      check_hostent (query, gethostbyname (name), expected);

      free (query);

    }

  char *query = xasprintf ("gethostbyname2 (\"%s\", %d)", name, family);

  check_hostent (query, gethostbyname2 (name, family), expected);

  /* Test res_search.  */

  int qtype;

  switch (family)

    {

    case AF_INET:

      qtype = T_A;

      break;

    case AF_INET6:

      qtype = T_AAAA;

      break;

    default:

      qtype = -1;

    }

  if (qtype >= 0)

    {

      int sz = 512;

      unsigned char *response = xmalloc (sz);

      int ret = res_search (name, C_IN, qtype, response, sz);

      TEST_VERIFY_EXIT (ret >= 0);

      if (ret > sz)

        {

          /* Truncation.  Retry with a larger buffer.  */

          sz = 65535;

          unsigned char *newptr = xrealloc (response, sz);

          response = newptr;

          ret = res_search (name, C_IN, qtype, response, sz);

          TEST_VERIFY_EXIT (ret >= 0);

          TEST_VERIFY_EXIT (ret < sz);

        }

      check_dns_packet (query, response, ret, expected);

      free (response);

    }

  free (query);

  free (expected);

}

static void

do_gai (const char *name, const char *fqdn, int family)

{

  struct addrinfo hints =

    {

      .ai_family = family,

      .ai_protocol = IPPROTO_TCP,

      .ai_socktype = SOCK_STREAM

    };

  struct addrinfo *ai;

  char *query = xasprintf ("%s:80 [%d]", name, family);

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

  char *expected = format_expected (fqdn, family, format_gai);

  check_addrinfo (query, ai, ret, expected);

  if (ret == 0)

    freeaddrinfo (ai);

  free (expected);

  free (query);

}

static void

do_both (const char *name, const char *fqdn)

{

  do_get (name, fqdn, AF_INET);

  do_get (name, fqdn, AF_INET6);

  do_gai (name, fqdn, AF_INET);

  do_gai (name, fqdn, AF_INET6);

  do_gai (name, fqdn, AF_UNSPEC);

}

static void

do_test_all (bool unconnectable_server)

{

  struct resolv_redirect_config config =

    {

      .response_callback = response,

      .search = {"usersys.example.com", "corp.example.com", "example.com"},

    };

  struct resolv_test *obj = resolv_test_start (config);

  if (unconnectable_server)

    {

      /* 255.255.255.255 results in an immediate connect failure.  The

         next server will supply the answer instead.  This is a

         triggering condition for bug 19791.  */

      _res.nsaddr_list[0].sin_addr.s_addr = -1;

      _res.nsaddr_list[0].sin_port = htons (53);

    }

  do_both ("file", "file.corp.example.com");

  do_both ("www", "www.example.com");

  do_both ("servfail-usersys", "servfail-usersys.corp.example.com");

  do_both ("servfail-corp", "servfail-corp.usersys.example.com");

  do_both ("large", "large.example.com");

  do_both ("large-servfail", "large-servfail.example.com");

  do_both ("file.corp", "file.corp");

  /* Check that SERVFAIL and REFUSED responses do not alter the search

     path resolution.  */

  rcode_override_server_index = 0;

  rcode_override = ns_r_servfail;

  do_both ("hostname", "hostname.usersys.example.com");

  do_both ("large", "large.example.com");

  do_both ("large-servfail", "large-servfail.example.com");

  rcode_override = ns_r_refused;

  do_both ("hostname", "hostname.usersys.example.com");

  do_both ("large", "large.example.com");

  do_both ("large-servfail", "large-servfail.example.com");

  /* Likewise, but with an NXDOMAIN for the first search path

     entry.  */

  rcode_override = ns_r_servfail;

  do_both ("mail", "mail.corp.example.com");

  rcode_override = ns_r_refused;

  do_both ("mail", "mail.corp.example.com");

  /* Likewise, but with ndots handling.  */

  rcode_override = ns_r_servfail;

  do_both ("file.corp", "file.corp");

  rcode_override = ns_r_refused;

  do_both ("file.corp", "file.corp");

  resolv_test_end (obj);

}

static int

do_test (void)

{

  for (int unconnectable_server = 0; unconnectable_server < 2;

       ++unconnectable_server)

    do_test_all (unconnectable_server);

  return 0;

}

#include <support/test-driver.c>