/* Parse /etc/hosts in multi mode with many addresses/aliases.

   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 <dlfcn.h>

#include <errno.h>

#include <gnu/lib-names.h>

#include <netdb.h>

#include <nss.h>

#include <stdbool.h>

#include <stdlib.h>

#include <string.h>

#include <support/check.h>

#include <support/check_nss.h>

#include <support/namespace.h>

#include <support/support.h>

#include <support/test-driver.h>

#include <support/test-driver.h>

#include <support/xmemstream.h>

#include <support/xstdio.h>

#include <support/xunistd.h>

#include <sys/resource.h>

struct support_chroot *chroot_env;

static void

prepare (int argc, char **argv)

{

  chroot_env = support_chroot_create

    ((struct support_chroot_configuration)

     {

       .resolv_conf = "",

       .hosts = "",             /* See write_hosts below.  */

       .host_conf = "multi on\n",

     });

}

/* Create the /etc/hosts file from outside the chroot.  */

static void

write_hosts (int count)

{

  TEST_VERIFY (count > 0 && count <= 65535);

  FILE *fp = xfopen (chroot_env->path_hosts, "w");

  fputs ("127.0.0.1   localhost localhost.localdomain\n"

         "::1         localhost localhost.localdomain\n",

         fp);

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

    {

      fprintf (fp, "10.4.%d.%d www4.example.com\n",

               (i / 256) & 0xff, i & 0xff);

      fprintf (fp, "10.46.%d.%d www.example.com\n",

               (i / 256) & 0xff, i & 0xff);

      fprintf (fp, "192.0.2.1 alias.example.com v4-%d.example.com\n", i);

      fprintf (fp, "2001:db8::6:%x www6.example.com\n", i);

      fprintf (fp, "2001:db8::46:%x www.example.com\n", i);

      fprintf (fp, "2001:db8::1 alias.example.com v6-%d.example.com\n", i);

    }

  xfclose (fp);

}

/* Parameters of a single test.  */

struct test_params

{

  const char *name;             /* Name to query.  */

  const char *marker;           /* Address marker for the name.  */

  int count;                    /* Number of addresses/aliases.  */

  int family;                   /* AF_INET, AF_INET_6 or AF_UNSPEC.  */

  bool canonname;               /* True if AI_CANONNAME should be enabled.  */

};

/* Expected result of gethostbyname/gethostbyname2.  */

static char *

expected_ghbn (const struct test_params *params)

{

  TEST_VERIFY (params->family == AF_INET || params->family == AF_INET6);

  struct xmemstream expected;

  xopen_memstream (&expected);

  if (strcmp (params->name, "alias.example.com") == 0)

    {

      fprintf (expected.out, "name: %s\n", params->name);

      char af;

      if (params->family == AF_INET)

        af = '4';

      else

        af = '6';

      for (int i = 0; i < params->count; ++i)

        fprintf (expected.out, "alias: v%c-%d.example.com\n", af, i);

      for (int i = 0; i < params->count; ++i)

        if (params->family == AF_INET)

          fputs ("address: 192.0.2.1\n", expected.out);

        else

          fputs ("address: 2001:db8::1\n", expected.out);

    }

  else /* www/www4/www6 name.  */

    {

      bool do_ipv4 = params->family == AF_INET

        && strncmp (params->name, "www6", 4) != 0;

      bool do_ipv6 = params->family == AF_INET6

        && strncmp (params->name, "www4", 4) != 0;

      if (do_ipv4 || do_ipv6)

        {

          fprintf (expected.out, "name: %s\n", params->name);

          if (do_ipv4)

            for (int i = 0; i < params->count; ++i)

              fprintf (expected.out, "address: 10.%s.%d.%d\n",

                       params->marker, i / 256, i % 256);

          if (do_ipv6)

            for (int i = 0; i < params->count; ++i)

              fprintf (expected.out, "address: 2001:db8::%s:%x\n",

                       params->marker, i);

        }

      else

        fputs ("error: HOST_NOT_FOUND\n", expected.out);

    }

  xfclose_memstream (&expected);

  return expected.buffer;

}

/* Expected result of getaddrinfo.  */

static char *

expected_gai (const struct test_params *params)

{

  bool do_ipv4 = false;

  bool do_ipv6 = false;

  if (params->family == AF_UNSPEC)

    do_ipv4 = do_ipv6 = true;

  else if (params->family == AF_INET)

    do_ipv4 = true;

  else if (params->family == AF_INET6)

    do_ipv6 = true;

  struct xmemstream expected;

  xopen_memstream (&expected);

  if (strcmp (params->name, "alias.example.com") == 0)

    {

      if (params->canonname)

        fprintf (expected.out,

                 "flags: AI_CANONNAME\n"

                 "canonname: %s\n",

                 params->name);

      if (do_ipv4)

        for (int i = 0; i < params->count; ++i)

          fputs ("address: STREAM/TCP 192.0.2.1 80\n", expected.out);

      if (do_ipv6)

        for (int i = 0; i < params->count; ++i)

          fputs ("address: STREAM/TCP 2001:db8::1 80\n", expected.out);

    }

  else /* www/www4/www6 name.  */

    {

      if (strncmp (params->name, "www4", 4) == 0)

        do_ipv6 = false;

      else if (strncmp (params->name, "www6", 4) == 0)

        do_ipv4 = false;

      /* Otherwise, we have www as the name, so we do both.  */

      if (do_ipv4 || do_ipv6)

        {

          if (params->canonname)

            fprintf (expected.out,

                     "flags: AI_CANONNAME\n"

                     "canonname: %s\n",

                     params->name);

          if (do_ipv4)

            for (int i = 0; i < params->count; ++i)

              fprintf (expected.out, "address: STREAM/TCP 10.%s.%d.%d 80\n",

                       params->marker, i / 256, i % 256);

          if (do_ipv6)

            for (int i = 0; i < params->count; ++i)

              fprintf (expected.out,

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

                       params->marker, i);

        }

      else

        fputs ("error: Name or service not known\n", expected.out);

    }

  xfclose_memstream (&expected);

  return expected.buffer;

}

static void

run_gbhn_gai (struct test_params *params)

{

  char *ctx = xasprintf ("name=%s marker=%s count=%d family=%d",

                         params->name, params->marker, params->count,

                         params->family);

  if (test_verbose > 0)

    printf ("info: %s\n", ctx);

  /* Check gethostbyname, gethostbyname2.  */

  if (params->family == AF_INET)

    {

      char *expected = expected_ghbn (params);

      check_hostent (ctx, gethostbyname (params->name), expected);

      free (expected);

    }

  if (params->family != AF_UNSPEC)

    {

      char *expected = expected_ghbn (params);

      check_hostent (ctx, gethostbyname2 (params->name, params->family),

                     expected);

      free (expected);

    }

  /* Check getaddrinfo.  */

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

    {

      params->canonname = do_canonical;

      char *expected = expected_gai (params);

      struct addrinfo hints =

        {

          .ai_family = params->family,

          .ai_socktype = SOCK_STREAM,

          .ai_protocol = IPPROTO_TCP,

        };

      if (do_canonical)

        hints.ai_flags |= AI_CANONNAME;

      struct addrinfo *ai;

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

      check_addrinfo (ctx, ai, ret, expected);

      if (ret == 0)

        freeaddrinfo (ai);

      free (expected);

    }

  free (ctx);

}

/* Callback for the subprocess which runs the test in a chroot.  */

static void

subprocess (void *closure)

{

  struct test_params *params = closure;

  xchroot (chroot_env->path_chroot);

  static const int families[] = { AF_INET, AF_INET6, AF_UNSPEC, -1 };

  static const char *const names[] =

    {

      "www.example.com", "www4.example.com", "www6.example.com",

      "alias.example.com",

      NULL

    };

  static const char *const names_marker[] = { "46", "4", "6", "" };

  for (int family_idx = 0; families[family_idx] >= 0; ++family_idx)

    {

      params->family = families[family_idx];

      for (int names_idx = 0; names[names_idx] != NULL; ++names_idx)

        {

          params->name = names[names_idx];

          params->marker = names_marker[names_idx];

          run_gbhn_gai (params);

        }

    }

}

/* Run the test for a specific number of addresses/aliases.  */

static void

run_test (int count)

{

  write_hosts (count);

  struct test_params params =

    {

      .count = count,

    };

  support_isolate_in_subprocess (subprocess, &params);

}

static int

do_test (void)

{

  support_become_root ();

  if (!support_can_chroot ())

    return EXIT_UNSUPPORTED;

  /* This test should not use gigabytes of memory.   */

  {

    struct rlimit limit;

    if (getrlimit (RLIMIT_AS, &limit) != 0)

      {

        printf ("getrlimit (RLIMIT_AS) failed: %m\n");

        return 1;

      }

    long target = 200 * 1024 * 1024;

    if (limit.rlim_cur == RLIM_INFINITY || limit.rlim_cur > target)

      {

        limit.rlim_cur = target;

        if (setrlimit (RLIMIT_AS, &limit) != 0)

          {

            printf ("setrlimit (RLIMIT_AS) failed: %m\n");

            return 1;

          }

      }

  }

  __nss_configure_lookup ("hosts", "files");

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

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

  /* Run the tests with a few different address/alias counts.  */

  for (int count = 1; count <= 111; ++count)

    run_test (count);

  run_test (1111);

  run_test (22222);

  support_chroot_free (chroot_env);

  return 0;

}

#define PREPARE prepare

#include <support/test-driver.c>