/* Test parsing of /etc/resolv.conf.  Genric version.

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

/* Before including this file, TEST_THREAD has to be defined to 0 or

   1, depending on whether the threading tests should be compiled

   in.  */

#include <arpa/inet.h>

#include <errno.h>

#include <gnu/lib-names.h>

#include <netdb.h>

#include <resolv/resolv-internal.h> /* For DEPRECATED_RES_USE_INET6.  */

#include <resolv/resolv_context.h>

#include <stdio.h>

#include <stdlib.h>

#include <support/capture_subprocess.h>

#include <support/check.h>

#include <support/namespace.h>

#include <support/run_diff.h>

#include <support/support.h>

#include <support/temp_file.h>

#include <support/test-driver.h>

#include <support/xsocket.h>

#include <support/xstdio.h>

#include <support/xunistd.h>

#if TEST_THREAD

# include <support/xthread.h>

#endif

/* This is the host name used to ensure predictable behavior of

   res_init.  */

static const char *const test_hostname = "www.example.com";

struct support_chroot *chroot_env;

static void

prepare (int argc, char **argv)

{

  chroot_env = support_chroot_create

    ((struct support_chroot_configuration)

     {

       .resolv_conf = "",

     });

}

/* Verify that the chroot environment has been set up.  */

static void

check_chroot_working (void *closure)

{

  xchroot (chroot_env->path_chroot);

  FILE *fp = xfopen (_PATH_RESCONF, "r");

  xfclose (fp);

  TEST_VERIFY_EXIT (res_init () == 0);

  TEST_VERIFY (_res.options & RES_INIT);

  char buf[100];

  if (gethostname (buf, sizeof (buf)) < 0)

    FAIL_EXIT1 ("gethostname: %m");

  if (strcmp (buf, test_hostname) != 0)

    FAIL_EXIT1 ("unexpected host name: %s", buf);

}

/* If FLAG is set in *OPTIONS, write NAME to FP, and clear it in

   *OPTIONS.  */

static void

print_option_flag (FILE *fp, int *options, int flag, const char *name)

{

  if (*options & flag)

    {

      fprintf (fp, " %s", name);

      *options &= ~flag;

    }

}

/* Write a decoded version of the resolver configuration *RESP to the

   stream FP.  */

static void

print_resp (FILE *fp, res_state resp)

{

  struct resolv_context *ctx = __resolv_context_get_override (resp);

  TEST_VERIFY_EXIT (ctx != NULL);

  if (ctx->conf == NULL)

    fprintf (fp, "; extended resolver state missing\n");

  /* The options directive.  */

  {

    /* RES_INIT is used internally for tracking initialization.  */

    TEST_VERIFY (resp->options & RES_INIT);

    /* Also mask out other default flags which cannot be set through

       the options directive.  */

    int options

      = resp->options & ~(RES_INIT | RES_RECURSE | RES_DEFNAMES | RES_DNSRCH);

    if (options != 0

        || resp->ndots != 1

        || resp->retrans != RES_TIMEOUT

        || resp->retry != RES_DFLRETRY)

      {

        fputs ("options", fp);

        if (resp->ndots != 1)

          fprintf (fp, " ndots:%d", resp->ndots);

        if (resp->retrans != RES_TIMEOUT)

          fprintf (fp, " timeout:%d", resp->retrans);

        if (resp->retry != RES_DFLRETRY)

          fprintf (fp, " attempts:%d", resp->retry);

        print_option_flag (fp, &options, RES_USEVC, "use-vc");

        print_option_flag (fp, &options, DEPRECATED_RES_USE_INET6, "inet6");

        print_option_flag (fp, &options, RES_ROTATE, "rotate");

        print_option_flag (fp, &options, RES_USE_EDNS0, "edns0");

        print_option_flag (fp, &options, RES_SNGLKUP,

                           "single-request");

        print_option_flag (fp, &options, RES_SNGLKUPREOP,

                           "single-request-reopen");

        print_option_flag (fp, &options, RES_NOTLDQUERY, "no-tld-query");

        print_option_flag (fp, &options, RES_NORELOAD, "no-reload");

        fputc ('\n', fp);

        if (options != 0)

          fprintf (fp, "; error: unresolved option bits: 0x%x\n", options);

      }

  }

  /* The search and domain directives.  */

  if (resp->dnsrch[0] != NULL)

    {

      fputs ("search", fp);

      for (int i = 0; i < MAXDNSRCH && resp->dnsrch[i] != NULL; ++i)

        {

          fputc (' ', fp);

          fputs (resp->dnsrch[i], fp);

        }

      fputc ('\n', fp);

    }

  else if (resp->defdname[0] != '\0')

    fprintf (fp, "domain %s\n", resp->defdname);

  /* The extended search path.  */

  {

    size_t i = 0;

    while (true)

      {

        const char *name = __resolv_context_search_list (ctx, i);

        if (name == NULL)

          break;

        fprintf (fp, "; search[%zu]: %s\n", i, name);

        ++i;

      }

  }

  /* The sortlist directive.  */

  if (resp->nsort > 0)

    {

      fputs ("sortlist", fp);

      for (int i = 0; i < resp->nsort && i < MAXRESOLVSORT; ++i)

        {

          char net[20];

          if (inet_ntop (AF_INET, &resp->sort_list[i].addr,

                         net, sizeof (net)) == NULL)

            FAIL_EXIT1 ("inet_ntop: %m\n");

          char mask[20];

          if (inet_ntop (AF_INET, &resp->sort_list[i].mask,

                         mask, sizeof (mask)) == NULL)

            FAIL_EXIT1 ("inet_ntop: %m\n");

          fprintf (fp, " %s/%s", net, mask);

        }

      fputc ('\n', fp);

    }

  /* The nameserver directives.  */

  for (size_t i = 0; i < resp->nscount; ++i)

    {

      char host[NI_MAXHOST];

      char service[NI_MAXSERV];

      /* See get_nsaddr in res_send.c.  */

      void *addr;

      size_t addrlen;

      if (resp->nsaddr_list[i].sin_family == 0

          && resp->_u._ext.nsaddrs[i] != NULL)

        {

          addr = resp->_u._ext.nsaddrs[i];

          addrlen = sizeof (*resp->_u._ext.nsaddrs[i]);

        }

      else

        {

          addr = &resp->nsaddr_list[i];

          addrlen = sizeof (resp->nsaddr_list[i]);

        }

      int ret = getnameinfo (addr, addrlen,

                             host, sizeof (host), service, sizeof (service),

                             NI_NUMERICHOST | NI_NUMERICSERV);

      if (ret != 0)

        {

          if (ret == EAI_SYSTEM)

            fprintf (fp, "; error: getnameinfo: %m\n");

          else

            fprintf (fp, "; error: getnameinfo: %s\n", gai_strerror (ret));

        }

      else

        {

          fprintf (fp, "nameserver %s\n", host);

          if (strcmp (service, "53") != 0)

            fprintf (fp, "; unrepresentable port number %s\n\n", service);

        }

    }

  /* The extended name server list.  */

  {

    size_t i = 0;

    while (true)

      {

        const struct sockaddr *addr = __resolv_context_nameserver (ctx, i);

        if (addr == NULL)

          break;

        size_t addrlen;

        switch (addr->sa_family)

          {

          case AF_INET:

            addrlen = sizeof (struct sockaddr_in);

            break;

          case AF_INET6:

            addrlen = sizeof (struct sockaddr_in6);

            break;

          default:

            FAIL_EXIT1 ("invalid address family %d", addr->sa_family);

          }

        char host[NI_MAXHOST];

        char service[NI_MAXSERV];

        int ret = getnameinfo (addr, addrlen,

                               host, sizeof (host), service, sizeof (service),

                               NI_NUMERICHOST | NI_NUMERICSERV);

        if (ret != 0)

          {

            if (ret == EAI_SYSTEM)

              fprintf (fp, "; error: getnameinfo: %m\n");

            else

              fprintf (fp, "; error: getnameinfo: %s\n", gai_strerror (ret));

          }

        else

          fprintf (fp, "; nameserver[%zu]: [%s]:%s\n", i, host, service);

        ++i;

      }

  }

  TEST_VERIFY (!ferror (fp));

  __resolv_context_put (ctx);

}

/* Parameters of one test case.  */

struct test_case

{

  /* A short, descriptive name of the test.  */

  const char *name;

  /* The contents of the /etc/resolv.conf file.  */

  const char *conf;

  /* The expected output from print_resp.  */

  const char *expected;

  /* Setting for the LOCALDOMAIN environment variable.  NULL if the

     variable is not to be set.  */

  const char *localdomain;

  /* Setting for the RES_OPTIONS environment variable.  NULL if the

     variable is not to be set.  */

  const char *res_options;

  /* Override the system host name.  NULL means that no change is made

     and the default is used (test_hostname).  */

  const char *hostname;

};

enum test_init

{

  test_init,

  test_ninit,

  test_mkquery,

  test_gethostbyname,

  test_getaddrinfo,

  test_init_method_last = test_getaddrinfo

};

static const char *const test_init_names[] =

  {

    [test_init] = "res_init",

    [test_ninit] = "res_ninit",

    [test_mkquery] = "res_mkquery",

    [test_gethostbyname] = "gethostbyname",

    [test_getaddrinfo] = "getaddrinfo",

  };

/* Closure argument for run_res_init.  */

struct test_context

{

  enum test_init init;

  const struct test_case *t;

};

static void

setup_nss_dns_and_chroot (void)

{

  /* Load nss_dns outside of the chroot.  */

  if (dlopen (LIBNSS_DNS_SO, RTLD_LAZY) == NULL)

    FAIL_EXIT1 ("could not load " LIBNSS_DNS_SO ": %s", dlerror ());

  xchroot (chroot_env->path_chroot);

  /* Force the use of nss_dns.  */

  __nss_configure_lookup ("hosts", "dns");

}

/* Run res_ninit or res_init in a subprocess and dump the parsed

   resolver state to standard output.  */

static void

run_res_init (void *closure)

{

  struct test_context *ctx = closure;

  TEST_VERIFY (getenv ("LOCALDOMAIN") == NULL);

  TEST_VERIFY (getenv ("RES_OPTIONS") == NULL);

  if (ctx->t->localdomain != NULL)

    setenv ("LOCALDOMAIN", ctx->t->localdomain, 1);

  if (ctx->t->res_options != NULL)

    setenv ("RES_OPTIONS", ctx->t->res_options, 1);

  if (ctx->t->hostname != NULL)

    {

#ifdef CLONE_NEWUTS

      /* This test needs its own namespace, to avoid changing the host

         name for the parent, too.  */

      TEST_VERIFY_EXIT (unshare (CLONE_NEWUTS) == 0);

      if (sethostname (ctx->t->hostname, strlen (ctx->t->hostname)) != 0)

        FAIL_EXIT1 ("sethostname (\"%s\"): %m", ctx->t->hostname);

#else

      FAIL_UNSUPPORTED ("clone (CLONE_NEWUTS) not supported");

#endif

    }

  switch (ctx->init)

    {

    case test_init:

      xchroot (chroot_env->path_chroot);

      TEST_VERIFY (res_init () == 0);

      print_resp (stdout, &_res);

      return;

    case test_ninit:

      xchroot (chroot_env->path_chroot);

      res_state resp = xmalloc (sizeof (*resp));

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

      TEST_VERIFY (res_ninit (resp) == 0);

      print_resp (stdout, resp);

      res_nclose (resp);

      free (resp);

      return;

    case test_mkquery:

      xchroot (chroot_env->path_chroot);

      unsigned char buf[512];

      TEST_VERIFY (res_mkquery (QUERY, "www.example",

                                C_IN, ns_t_a, NULL, 0,

                                NULL, buf, sizeof (buf)) > 0);

      print_resp (stdout, &_res);

      return;

    case test_gethostbyname:

      setup_nss_dns_and_chroot ();

      /* Trigger implicit initialization of the _res structure.  The

         actual lookup result is immaterial.  */

      (void )gethostbyname ("www.example");

      print_resp (stdout, &_res);

      return;

    case test_getaddrinfo:

      setup_nss_dns_and_chroot ();

      /* Trigger implicit initialization of the _res structure.  The

         actual lookup result is immaterial.  */

      struct addrinfo *ai;

      (void) getaddrinfo ("www.example", NULL, NULL, &ai;;

      print_resp (stdout, &_res);

      return;

    }

  FAIL_EXIT1 ("invalid init method %d", ctx->init);

}

#if TEST_THREAD

/* Helper function which calls run_res_init from a thread.  */

static void *

run_res_init_thread_func (void *closure)

{

  run_res_init (closure);

  return NULL;

}

/* Variant of res_run_init which runs the function on a non-main

   thread.  */

static void

run_res_init_on_thread (void *closure)

{

  xpthread_join (xpthread_create (NULL, run_res_init_thread_func, closure));

}

#endif /* TEST_THREAD */

struct test_case test_cases[] =

  {

    {.name = "empty file",

     .conf = "",

     .expected = "search example.com\n"

     "; search[0]: example.com\n"

     "nameserver 127.0.0.1\n"

     "; nameserver[0]: [127.0.0.1]:53\n"

    },

    {.name = "empty file, no-dot hostname",

     .conf = "",

     .expected = "nameserver 127.0.0.1\n"

     "; nameserver[0]: [127.0.0.1]:53\n",

     .hostname = "example",

    },

    {.name = "empty file with LOCALDOMAIN",

     .conf = "",

     .expected = "search example.net\n"

     "; search[0]: example.net\n"

     "nameserver 127.0.0.1\n"

     "; nameserver[0]: [127.0.0.1]:53\n",

     .localdomain = "example.net",

    },

    {.name = "empty file with RES_OPTIONS",

     .conf = "",

     .expected = "options attempts:5 edns0\n"

     "search example.com\n"

     "; search[0]: example.com\n"

     "nameserver 127.0.0.1\n"

     "; nameserver[0]: [127.0.0.1]:53\n",

     .res_options = "edns0 attempts:5",

    },

    {.name = "empty file with RES_OPTIONS and LOCALDOMAIN",

     .conf = "",

     .expected = "options attempts:5 edns0\n"

     "search example.org\n"

     "; search[0]: example.org\n"

     "nameserver 127.0.0.1\n"

     "; nameserver[0]: [127.0.0.1]:53\n",

     .localdomain = "example.org",

     .res_options = "edns0 attempts:5",

    },

    {.name = "basic",

     .conf =  "search corp.example.com example.com\n"

     "nameserver 192.0.2.1\n",

     .expected = "search corp.example.com example.com\n"

     "; search[0]: corp.example.com\n"

     "; search[1]: example.com\n"

     "nameserver 192.0.2.1\n"

     "; nameserver[0]: [192.0.2.1]:53\n"

    },

    {.name = "basic with no-dot hostname",

     .conf = "search corp.example.com example.com\n"

     "nameserver 192.0.2.1\n",

     .expected = "search corp.example.com example.com\n"

     "; search[0]: corp.example.com\n"

     "; search[1]: example.com\n"

     "nameserver 192.0.2.1\n"

     "; nameserver[0]: [192.0.2.1]:53\n",

     .hostname = "example",

    },

    {.name = "basic no-reload",

     .conf = "options no-reload\n"

     "search corp.example.com example.com\n"

     "nameserver 192.0.2.1\n",

     .expected = "options no-reload\n"

     "search corp.example.com example.com\n"

     "; search[0]: corp.example.com\n"

     "; search[1]: example.com\n"

     "nameserver 192.0.2.1\n"

     "; nameserver[0]: [192.0.2.1]:53\n"

    },

    {.name = "basic no-reload via RES_OPTIONS",

     .conf = "search corp.example.com example.com\n"

     "nameserver 192.0.2.1\n",

     .expected = "options no-reload\n"

     "search corp.example.com example.com\n"

     "; search[0]: corp.example.com\n"

     "; search[1]: example.com\n"

     "nameserver 192.0.2.1\n"

     "; nameserver[0]: [192.0.2.1]:53\n",

     .res_options = "no-reload"

    },

    {.name = "whitespace",

     .conf = "# This test covers comment and whitespace processing "

     " (trailing whitespace,\n"

     "# missing newline at end of file).\n"

     "\n"

     ";search commented out\n"

     "search corp.example.com\texample.com \n"

     "#nameserver 192.0.2.3\n"

     "nameserver 192.0.2.1 \n"

     "nameserver 192.0.2.2",    /* No \n at end of file.  */

     .expected = "search corp.example.com example.com\n"

     "; search[0]: corp.example.com\n"

     "; search[1]: example.com\n"

     "nameserver 192.0.2.1\n"

     "nameserver 192.0.2.2\n"

     "; nameserver[0]: [192.0.2.1]:53\n"

     "; nameserver[1]: [192.0.2.2]:53\n"

    },

    {.name = "domain",

     .conf = "domain example.net\n"

     "nameserver 192.0.2.1\n",

     .expected = "search example.net\n"

     "; search[0]: example.net\n"

     "nameserver 192.0.2.1\n"

     "; nameserver[0]: [192.0.2.1]:53\n"

    },

    {.name = "domain space",

     .conf = "domain example.net \n"

     "nameserver 192.0.2.1\n",

     .expected = "search example.net\n"

     "; search[0]: example.net\n"

     "nameserver 192.0.2.1\n"

     "; nameserver[0]: [192.0.2.1]:53\n"

    },

    {.name = "domain tab",

     .conf = "domain example.net\t\n"

     "nameserver 192.0.2.1\n",

     .expected = "search example.net\n"

     "; search[0]: example.net\n"

     "nameserver 192.0.2.1\n"

     "; nameserver[0]: [192.0.2.1]:53\n"

    },

    {.name = "domain override",

     .conf = "search example.com example.org\n"

     "nameserver 192.0.2.1\n"

     "domain example.net",      /* No \n at end of file.  */

     .expected = "search example.net\n"

     "; search[0]: example.net\n"

     "nameserver 192.0.2.1\n"

     "; nameserver[0]: [192.0.2.1]:53\n"

    },

    {.name = "option values, multiple servers",

     .conf = "options\tinet6\tndots:3 edns0\tattempts:5\ttimeout:19\n"

     "domain  example.net\n"

     ";domain comment\n"

     "search corp.example.com\texample.com\n"

     "nameserver 192.0.2.1\n"

     "nameserver ::1\n"

     "nameserver 192.0.2.2\n",

     .expected = "options ndots:3 timeout:19 attempts:5 inet6 edns0\n"

     "search corp.example.com example.com\n"

     "; search[0]: corp.example.com\n"

     "; search[1]: example.com\n"

     "nameserver 192.0.2.1\n"

     "nameserver ::1\n"

     "nameserver 192.0.2.2\n"

     "; nameserver[0]: [192.0.2.1]:53\n"

     "; nameserver[1]: [::1]:53\n"

     "; nameserver[2]: [192.0.2.2]:53\n"

    },

    {.name = "out-of-range option vales",

     .conf = "options use-vc timeout:999 attempts:999 ndots:99\n"

     "search example.com\n",

     .expected = "options ndots:15 timeout:30 attempts:5 use-vc\n"

     "search example.com\n"

     "; search[0]: example.com\n"

     "nameserver 127.0.0.1\n"

     "; nameserver[0]: [127.0.0.1]:53\n"

    },

    {.name = "repeated directives",

     .conf = "options ndots:3 use-vc\n"

     "options edns0 ndots:2\n"

     "domain corp.example\n"

     "search example.net corp.example.com example.com\n"

     "search example.org\n"

     "search\n",

     .expected = "options ndots:2 use-vc edns0\n"

     "search example.org\n"

     "; search[0]: example.org\n"

     "nameserver 127.0.0.1\n"

     "; nameserver[0]: [127.0.0.1]:53\n"

    },

    {.name = "many name servers, sortlist",

     .conf = "options single-request\n"

     "search example.org example.com example.net corp.example.com\n"

     "sortlist 192.0.2.0/255.255.255.0\n"

     "nameserver 192.0.2.1\n"

     "nameserver 192.0.2.2\n"

     "nameserver 192.0.2.3\n"

     "nameserver 192.0.2.4\n"

     "nameserver 192.0.2.5\n"

     "nameserver 192.0.2.6\n"

     "nameserver 192.0.2.7\n"

     "nameserver 192.0.2.8\n",

     .expected = "options single-request\n"

     "search example.org example.com example.net corp.example.com\n"

     "; search[0]: example.org\n"

     "; search[1]: example.com\n"

     "; search[2]: example.net\n"

     "; search[3]: corp.example.com\n"

     "sortlist 192.0.2.0/255.255.255.0\n"

     "nameserver 192.0.2.1\n"

     "nameserver 192.0.2.2\n"

     "nameserver 192.0.2.3\n"

     "; nameserver[0]: [192.0.2.1]:53\n"

     "; nameserver[1]: [192.0.2.2]:53\n"

     "; nameserver[2]: [192.0.2.3]:53\n"

     "; nameserver[3]: [192.0.2.4]:53\n"

     "; nameserver[4]: [192.0.2.5]:53\n"

     "; nameserver[5]: [192.0.2.6]:53\n"

     "; nameserver[6]: [192.0.2.7]:53\n"

     "; nameserver[7]: [192.0.2.8]:53\n"

    },

    {.name = "IPv4 and IPv6 nameservers",

     .conf = "options single-request\n"

     "search example.org example.com example.net corp.example.com"

     " legacy.example.com\n"

     "sortlist 192.0.2.0\n"

     "nameserver 192.0.2.1\n"

     "nameserver 2001:db8::2\n"

     "nameserver 192.0.2.3\n"

     "nameserver 2001:db8::4\n"

     "nameserver 192.0.2.5\n"

     "nameserver 2001:db8::6\n"

     "nameserver 192.0.2.7\n"

     "nameserver 2001:db8::8\n",

     .expected = "options single-request\n"

     "search example.org example.com example.net corp.example.com"

     " legacy.example.com\n"

     "; search[0]: example.org\n"

     "; search[1]: example.com\n"

     "; search[2]: example.net\n"

     "; search[3]: corp.example.com\n"

     "; search[4]: legacy.example.com\n"

     "sortlist 192.0.2.0/255.255.255.0\n"

     "nameserver 192.0.2.1\n"

     "nameserver 2001:db8::2\n"

     "nameserver 192.0.2.3\n"

     "; nameserver[0]: [192.0.2.1]:53\n"

     "; nameserver[1]: [2001:db8::2]:53\n"

     "; nameserver[2]: [192.0.2.3]:53\n"

     "; nameserver[3]: [2001:db8::4]:53\n"

     "; nameserver[4]: [192.0.2.5]:53\n"

     "; nameserver[5]: [2001:db8::6]:53\n"

     "; nameserver[6]: [192.0.2.7]:53\n"

     "; nameserver[7]: [2001:db8::8]:53\n",

    },

    {.name = "garbage after nameserver",

     .conf = "nameserver 192.0.2.1 garbage\n"

     "nameserver 192.0.2.2:5353\n"

     "nameserver 192.0.2.3 5353\n",

     .expected = "search example.com\n"

     "; search[0]: example.com\n"

     "nameserver 192.0.2.1\n"

     "nameserver 192.0.2.3\n"

     "; nameserver[0]: [192.0.2.1]:53\n"

     "; nameserver[1]: [192.0.2.3]:53\n"

    },

    {.name = "RES_OPTIONS is cummulative",

     .conf = "options timeout:7 ndots:2 use-vc\n"

     "nameserver 192.0.2.1\n",

     .expected = "options ndots:3 timeout:7 attempts:5 use-vc edns0\n"

     "search example.com\n"

     "; search[0]: example.com\n"

     "nameserver 192.0.2.1\n"

     "; nameserver[0]: [192.0.2.1]:53\n",

     .res_options = "attempts:5 ndots:3 edns0 ",

    },

    {.name = "many search list entries (bug 19569)",

     .conf = "nameserver 192.0.2.1\n"

     "search corp.example.com support.example.com"

     " community.example.org wan.example.net vpn.example.net"

     " example.com example.org example.net\n",

     .expected = "search corp.example.com support.example.com"

     " community.example.org wan.example.net vpn.example.net example.com\n"

     "; search[0]: corp.example.com\n"

     "; search[1]: support.example.com\n"

     "; search[2]: community.example.org\n"

     "; search[3]: wan.example.net\n"

     "; search[4]: vpn.example.net\n"

     "; search[5]: example.com\n"

     "; search[6]: example.org\n"

     "; search[7]: example.net\n"

     "nameserver 192.0.2.1\n"

     "; nameserver[0]: [192.0.2.1]:53\n"

    },

    {.name = "very long search list entries (bug 21475)",

     .conf = "nameserver 192.0.2.1\n"

     "search example.com "

#define H63 "this-host-name-is-longer-than-yours-yes-I-really-really-mean-it"

#define D63 "this-domain-name-is-as-long-as-the-previous-name--63-characters"

     " " H63 "." D63 ".example.org"

     " " H63 "." D63 ".example.net\n",

     .expected = "search example.com " H63 "." D63 ".example.org\n"

     "; search[0]: example.com\n"

     "; search[1]: " H63 "." D63 ".example.org\n"

     "; search[2]: " H63 "." D63 ".example.net\n"

#undef H63

#undef D63

     "nameserver 192.0.2.1\n"

     "; nameserver[0]: [192.0.2.1]:53\n"

    },

    { NULL }

  };

/* Run the indicated test case.  This function assumes that the chroot

   contents has already been set up.  */

static void

test_file_contents (const struct test_case *t)

{

#if TEST_THREAD

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

#endif

    for (int init_method = 0; init_method <= test_init_method_last;

         ++init_method)

      {

        if (test_verbose > 0)

          printf ("info:  testing init method %s\n",

                  test_init_names[init_method]);

        struct test_context ctx = { .init = init_method, .t = t };

        void (*func) (void *) = run_res_init;

#if TEST_THREAD

        if (do_thread)

          func = run_res_init_on_thread;

#endif

        struct support_capture_subprocess proc

          = support_capture_subprocess (func, &ctx;;

        if (strcmp (proc.out.buffer, t->expected) != 0)

          {

            support_record_failure ();

            printf ("error: output mismatch for %s (init method %s)\n",

                    t->name, test_init_names[init_method]);

            support_run_diff ("expected", t->expected,

                              "actual", proc.out.buffer);

          }

        support_capture_subprocess_check (&proc, t->name, 0,

                                          sc_allow_stdout);

        support_capture_subprocess_free (&proc;;

      }

}

/* Special tests which do not follow the general pattern.  */

enum { special_tests_count = 11 };

/* Implementation of special tests.  */

static void

special_test_callback (void *closure)

{

  unsigned int *test_indexp = closure;

  unsigned test_index = *test_indexp;

  TEST_VERIFY (test_index < special_tests_count);

  if (test_verbose > 0)

    printf ("info: special test %u\n", test_index);

  xchroot (chroot_env->path_chroot);

  switch (test_index)

    {

    case 0:

    case 1:

      /* Second res_init with missing or empty file preserves

         flags.  */

      if (test_index == 1)

        TEST_VERIFY (unlink (_PATH_RESCONF) == 0);

      _res.options = RES_USE_EDNS0;

      TEST_VERIFY (res_init () == 0);

      /* First res_init clears flag.  */

      TEST_VERIFY (!(_res.options & RES_USE_EDNS0));

      _res.options |= RES_USE_EDNS0;

      TEST_VERIFY (res_init () == 0);

      /* Second res_init preserves flag.  */

      TEST_VERIFY (_res.options & RES_USE_EDNS0);

      if (test_index == 1)

        /* Restore empty file.  */

        support_write_file_string (_PATH_RESCONF, "");

      break;

    case 2:

      /* Second res_init is cumulative.  */

      support_write_file_string (_PATH_RESCONF,

                                 "options rotate\n"

                                 "nameserver 192.0.2.1\n");

      _res.options = RES_USE_EDNS0;

      TEST_VERIFY (res_init () == 0);

      /* First res_init clears flag.  */

      TEST_VERIFY (!(_res.options & RES_USE_EDNS0));

      /* And sets RES_ROTATE.  */

      TEST_VERIFY (_res.options & RES_ROTATE);

      _res.options |= RES_USE_EDNS0;

      TEST_VERIFY (res_init () == 0);

      /* Second res_init preserves flag.  */

      TEST_VERIFY (_res.options & RES_USE_EDNS0);

      TEST_VERIFY (_res.options & RES_ROTATE);

      /* Reloading the configuration does not clear the explicitly set

         flag.  */

      support_write_file_string (_PATH_RESCONF,

                                 "nameserver 192.0.2.1\n"

                                 "nameserver 192.0.2.2\n");

      TEST_VERIFY (res_init () == 0);

      TEST_VERIFY (_res.nscount == 2);

      TEST_VERIFY (_res.options & RES_USE_EDNS0);

      /* Whether RES_ROTATE (originally in resolv.conf, now removed)

         should be preserved is subject to debate.  See bug 21701.  */

      /* TEST_VERIFY (!(_res.options & RES_ROTATE)); */

      break;

    case 3:

    case 4:

    case 5:

    case 6:

      support_write_file_string (_PATH_RESCONF,

                                 "options edns0\n"

                                 "nameserver 192.0.2.1\n");

      goto reload_tests;

    case 7: /* 7 and the following tests are with no-reload.  */

    case 8:

    case 9:

    case 10:

        support_write_file_string (_PATH_RESCONF,

                                   "options edns0 no-reload\n"

                                   "nameserver 192.0.2.1\n");

        /* Fall through.  */

    reload_tests:

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

        {

          switch (test_index)

            {

            case 3:

            case 7:

              TEST_VERIFY (res_init () == 0);

              break;

            case 4:

            case 8:

              {

                unsigned char buf[512];

                TEST_VERIFY

                  (res_mkquery (QUERY, test_hostname, C_IN, T_A,

                                NULL, 0, NULL, buf, sizeof (buf)) > 0);

              }

              break;

            case 5:

            case 9:

              gethostbyname (test_hostname);

              break;

            case 6:

            case 10:

              {

                struct addrinfo *ai;

                (void) getaddrinfo (test_hostname, NULL, NULL, &ai;;

              }

              break;

            }

          /* test_index == 7 is res_init and performs a reload even

             with no-reload.  */

          if (iteration == 0 || test_index > 7)

            {

              TEST_VERIFY (_res.options & RES_USE_EDNS0);

              TEST_VERIFY (!(_res.options & RES_ROTATE));

              if (test_index < 7)

                TEST_VERIFY (!(_res.options & RES_NORELOAD));

              else

                TEST_VERIFY (_res.options & RES_NORELOAD);

              TEST_VERIFY (_res.nscount == 1);

              /* File change triggers automatic reloading.  */

              support_write_file_string (_PATH_RESCONF,

                                         "options rotate\n"

                                         "nameserver 192.0.2.1\n"

                                         "nameserver 192.0.2.2\n");