/* Basic functionality tests for inet6 option processing.

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

#include <netdb.h>

#include <resolv.h>

#include <stdio.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/xthread.h>

/* Handle IPv4 reverse lookup responses.  Product a PTR record

   A-B-C-D.v4.example.  */

static void

response_ptr_v4 (const struct resolv_response_context *ctx,

                 struct resolv_response_builder *b,

                 const char *qname, uint16_t qclass, uint16_t qtype)

{

  int bytes[4];

  int offset = -1;

  TEST_VERIFY (sscanf (qname, "%d.%d.%d.%d.in-addr.arpa%n",

                       bytes + 0, bytes + 1, bytes + 2, bytes + 3,

                       &offset) == 4);

  TEST_VERIFY (offset == strlen (qname));

  resolv_response_init (b, (struct resolv_response_flags) {});

  resolv_response_add_question (b, qname, qclass, qtype);

  resolv_response_section (b, ns_s_an);

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

  char *name = xasprintf ("%d-%d-%d-%d.v4.example",

                          bytes[3], bytes[2], bytes[1], bytes[0]);

  resolv_response_add_name (b, name);

  free (name);

  resolv_response_close_record (b);

}

/* Handle IPv6 reverse lookup responses.  Produce a PTR record

   <32 hex digits>.v6.example. */

static void

response_ptr_v6 (const struct resolv_response_context *ctx,

                 struct resolv_response_builder *b,

                 const char *qname, uint16_t qclass, uint16_t qtype)

{

  TEST_VERIFY_EXIT (strlen (qname) > 64);

  char bytes[33];

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

    if ((i % 2) == 0)

      {

        TEST_VERIFY (isxdigit ((unsigned char) qname[i]));

        bytes[31 - i / 2] = qname[i];

      }

    else

      TEST_VERIFY_EXIT (qname[i] == '.');

  bytes[32] = '\0';

    resolv_response_init (b, (struct resolv_response_flags) {});

  resolv_response_add_question (b, qname, qclass, qtype);

  resolv_response_section (b, ns_s_an);

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

  char *name = xasprintf ("%s.v6.example", bytes);

  resolv_response_add_name (b, name);

  free (name);

  resolv_response_close_record (b);

}

/* Produce a response based on QNAME: Certain characters in the first

   label of QNAME trigger the inclusion of resource records:

   'a'   A record (IPv4 address)

   'q'   AAAA record (quad A record, IPv6 address)

   'p'   PTR record

   'm'   record type must match QTYPE (no additional records)

   '6'   stop flag processing if QTYPE == AAAA

   For 'a' and 'q', QTYPE is ignored for record type selection if 'm'

   is not specified.

   in-addr.arpa and ip6.arpa queries are handled separately in

   response_ptr_v4 and response_ptr_v6.  */

static void

response (const struct resolv_response_context *ctx,

          struct resolv_response_builder *b,

          const char *qname, uint16_t qclass, uint16_t qtype)

{

  if (strstr (qname, ".in-addr.arpa") != NULL)

    return response_ptr_v4 (ctx, b, qname, qclass, qtype);

  else if (strstr (qname, ".ip6.arpa") != NULL)

    return response_ptr_v6 (ctx, b, qname, qclass, qtype);

  bool include_a = false;

  bool include_aaaa = false;

  bool include_match = false;

  bool include_ptr = false;

  for (const char *p = qname; *p != '.' && *p != '\0'; ++p)

    {

      if (*p == 'a')

        include_a = true;

      else if (*p == 'q')

        include_aaaa = true;

      else if (*p == 'm')

        include_match = true;

      else if (*p == 'p')

        include_ptr = true;

      else if (*p == '6' && qtype == T_AAAA)

        break;

    }

  if (include_match)

    {

      if (qtype == T_A)

        include_aaaa = false;

      else if (qtype == T_AAAA)

        include_a = false;

    }

  resolv_response_init (b, (struct resolv_response_flags) {});

  resolv_response_add_question (b, qname, qclass, qtype);

  resolv_response_section (b, ns_s_an);

  if (include_a)

    {

      char ipv4[4] = {192, 0, 2, 17};

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

      resolv_response_add_data (b, &ipv4, sizeof (ipv4));

      resolv_response_close_record (b);

    }

  if (include_aaaa)

    {

      char ipv6[16]

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

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

      resolv_response_add_data (b, &ipv6, sizeof (ipv6));

      resolv_response_close_record (b);

    }

  if (include_ptr)

    {

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

      resolv_response_add_name (b, "ptr-target.example");

      resolv_response_close_record (b);

    }

}

/* Test that getaddrinfo is not influenced by RES_USE_INET6.  */

static void

test_gai (void)

{

  {

    struct addrinfo hints =

      {

        .ai_family = AF_UNSPEC,

        .ai_socktype = SOCK_STREAM,

        .ai_protocol = IPPROTO_TCP,

      };

    struct addrinfo *ai;

    int ret = getaddrinfo ("qam.example", "80", &hints, &ai;;

    check_addrinfo ("getaddrinfo AF_UNSPEC qam.example", ai, ret,

                    "address: STREAM/TCP 192.0.2.17 80\n"

                    "address: STREAM/TCP 2001:db8::1 80\n");

    if (ret == 0)

      freeaddrinfo (ai);

    ret = getaddrinfo ("am.example", "80", &hints, &ai;;

    check_addrinfo ("getaddrinfo AF_UNSPEC am.example", ai, ret,

                    "address: STREAM/TCP 192.0.2.17 80\n");

    if (ret == 0)

      freeaddrinfo (ai);

    ret = getaddrinfo ("qa.example", "80", &hints, &ai;;

    /* Combined A/AAAA responses currently result in address

       duplication.  */

    check_addrinfo ("getaddrinfo AF_UNSPEC qa.example", ai, ret,

                    "address: STREAM/TCP 192.0.2.17 80\n"

                    "address: STREAM/TCP 192.0.2.17 80\n"

                    "address: STREAM/TCP 2001:db8::1 80\n"

                    "address: STREAM/TCP 2001:db8::1 80\n");

    if (ret == 0)

      freeaddrinfo (ai);

  }

  {

    struct addrinfo hints =

      {

        .ai_family = AF_INET,

        .ai_socktype = SOCK_STREAM,

        .ai_protocol = IPPROTO_TCP,

      };

    struct addrinfo *ai;

    int ret = getaddrinfo ("qam.example", "80", &hints, &ai;;

    check_addrinfo ("getaddrinfo AF_INET qam.example", ai, ret,

                    "address: STREAM/TCP 192.0.2.17 80\n");

    if (ret == 0)

      freeaddrinfo (ai);

    ret = getaddrinfo ("am.example", "80", &hints, &ai;;

    check_addrinfo ("getaddrinfo AF_INET am.example", ai, ret,

                    "address: STREAM/TCP 192.0.2.17 80\n");

    if (ret == 0)

      freeaddrinfo (ai);

    ret = getaddrinfo ("qa.example", "80", &hints, &ai;;

    check_addrinfo ("getaddrinfo AF_INET qa.example", ai, ret,

                    "address: STREAM/TCP 192.0.2.17 80\n");

    if (ret == 0)

      freeaddrinfo (ai);

  }

  {

    struct addrinfo hints =

      {

        .ai_family = AF_INET6,

        .ai_socktype = SOCK_STREAM,

        .ai_protocol = IPPROTO_TCP,

      };

    struct addrinfo *ai;

    int ret = getaddrinfo ("qa.example", "80", &hints, &ai;;

    check_addrinfo ("getaddrinfo (AF_INET6)", ai, ret,

                    "address: STREAM/TCP 2001:db8::1 80\n");

    if (ret == 0)

      freeaddrinfo (ai);

    ret = getaddrinfo ("am.example", "80", &hints, &ai;;

    check_addrinfo ("getaddrinfo AF_INET6 am.example", ai, ret,

                    "error: No address associated with hostname\n");

    if (ret == 0)

      freeaddrinfo (ai);

    ret = getaddrinfo ("qam.example", "80", &hints, &ai;;

    check_addrinfo ("getaddrinfo AF_INET6 qam.example", ai, ret,

                    "address: STREAM/TCP 2001:db8::1 80\n");

    if (ret == 0)

      freeaddrinfo (ai);

  }

}

/* Test gethostbyaddr and getnameinfo.  The results are independent of

   RES_USE_INET6.  */

static void

test_reverse (void)

{

  {

    char ipv4[4] = { 192, 0, 2, 17 };

    check_hostent ("gethostbyaddr AF_INET",

                   gethostbyaddr (ipv4, sizeof (ipv4), AF_INET),

                   "name: 192-0-2-17.v4.example\n"

                   "address: 192.0.2.17\n");

  }

  {

    char ipv6[16]

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

    check_hostent ("gethostbyaddr AF_INET",

                   gethostbyaddr (ipv6, sizeof (ipv6), AF_INET6),

                   "name: 20010db8000000000000000000000001.v6.example\n"

                   "address: 2001:db8::1\n");

  }

  {

    struct sockaddr_in addr =

      {

        .sin_family = AF_INET,

        .sin_addr = { .s_addr = htonl (0xc0000211) },

        .sin_port = htons (80)

      };

    char host[NI_MAXHOST];

    char service[NI_MAXSERV];

    int ret = getnameinfo ((struct sockaddr *) &addr, sizeof (addr),

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

                           NI_NUMERICSERV);

    TEST_VERIFY (ret == 0);

    TEST_VERIFY (strcmp (host, "192-0-2-17.v4.example") == 0);

    TEST_VERIFY (strcmp (service, "80") == 0);

  }

  {

    char ipv6[16]

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

    struct sockaddr_in6 addr =

      {

        .sin6_family = AF_INET6,

        .sin6_port = htons (80),

      };

    TEST_VERIFY (sizeof (ipv6) == sizeof (addr.sin6_addr));

    memcpy (&addr.sin6_addr, ipv6, sizeof (addr.sin6_addr));

    char host[NI_MAXHOST];

    char service[NI_MAXSERV];

    int ret = getnameinfo ((struct sockaddr *) &addr, sizeof (addr),

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

                           NI_NUMERICSERV);

    TEST_VERIFY (ret == 0);

    TEST_VERIFY

      (strcmp (host, "20010db8000000000000000000000001.v6.example") == 0);

    TEST_VERIFY (strcmp (service, "80") == 0);

  }

}

/* Test that gethostbyname2 is mostly not influenced by

   RES_USE_INET6.  */

static void

test_get2_any (void)

{

  check_hostent ("gethostbyname2 AF_INET am.example",

                 gethostbyname2 ("am.example", AF_INET),

                 "name: am.example\n"

                 "address: 192.0.2.17\n");

  check_hostent ("gethostbyname2 AF_INET a.example",

                 gethostbyname2 ("a.example", AF_INET),

                 "name: a.example\n"

                 "address: 192.0.2.17\n");

  check_hostent ("gethostbyname2 AF_INET qm.example",

                 gethostbyname2 ("qm.example", AF_INET),

                 "error: NO_ADDRESS\n");

  check_hostent ("gethostbyname2 AF_INET q.example",

                 gethostbyname2 ("q.example", AF_INET),

                 "error: NO_RECOVERY\n");

  check_hostent ("gethostbyname2 AF_INET qam.example",

                 gethostbyname2 ("qam.example", AF_INET),

                 "name: qam.example\n"

                 "address: 192.0.2.17\n");

  check_hostent ("gethostbyname2 AF_INET qa.example",

                 gethostbyname2 ("qa.example", AF_INET),

                 "name: qa.example\n"

                 "address: 192.0.2.17\n");

  check_hostent ("gethostbyname2 AF_INET6 qm.example",

                 gethostbyname2 ("qm.example", AF_INET6),

                 "name: qm.example\n"

                 "address: 2001:db8::1\n");

  check_hostent ("gethostbyname2 AF_INET6 q.example",

                 gethostbyname2 ("q.example", AF_INET6),

                 "name: q.example\n"

                 "address: 2001:db8::1\n");

  check_hostent ("gethostbyname2 AF_INET6 qam.example",

                 gethostbyname2 ("qam.example", AF_INET6),

                 "name: qam.example\n"

                 "address: 2001:db8::1\n");

  check_hostent ("gethostbyname2 AF_INET6 qa.example",

                 gethostbyname2 ("qa.example", AF_INET6),

                 "name: qa.example\n"

                 "address: 2001:db8::1\n");

  /* Additional AF_INET6 tests depend on RES_USE_INET6; see below.  */

  test_reverse ();

}

/* gethostbyname2 tests with RES_USE_INET6 disabled.  */

static void

test_get2_no_inet6 (void)

{

  test_get2_any ();

  check_hostent ("gethostbyname2 AF_INET6 am.example",

                 gethostbyname2 ("am.example", AF_INET6),

                 "error: NO_ADDRESS\n");

  check_hostent ("gethostbyname2 AF_INET6 a.example",

                 gethostbyname2 ("a.example", AF_INET6),

                 "error: NO_RECOVERY\n");

}

/* gethostbyname2 tests with RES_USE_INET6 enabled.  */

static void

test_get2_inet6 (void)

{

  test_get2_any ();

  check_hostent ("gethostbyname2 AF_INET6 am.example",

                 gethostbyname2 ("am.example", AF_INET6),

                 "name: am.example\n"

                 "address: ::ffff:192.0.2.17\n");

  check_hostent ("gethostbyname2 AF_INET6 a.example",

                 gethostbyname2 ("a.example", AF_INET6),

                 "error: NO_RECOVERY\n");

}

/* Collection of tests which assume no RES_USE_INET6 flag.  */

static void

test_no_inet6 (void)

{

  check_hostent ("gethostbyname (\"a.example\")",

                 gethostbyname ("a.example"),

                 "name: a.example\n"

                 "address: 192.0.2.17\n");

  check_hostent ("gethostbyname (\"qa.example\")",

                 gethostbyname ("qa.example"),

                 "name: qa.example\n"

                 "address: 192.0.2.17\n");

  check_hostent ("gethostbyname (\"am.example\")",

                 gethostbyname ("am.example"),

                 "name: am.example\n"

                 "address: 192.0.2.17\n");

  check_hostent ("gethostbyname (\"amp.example\")",

                 gethostbyname ("amp.example"),

                 "name: amp.example\n"

                 "address: 192.0.2.17\n");

  check_hostent ("gethostbyname (\"qam.example\")",

                 gethostbyname ("qam.example"),

                 "name: qam.example\n"

                 "address: 192.0.2.17\n");

  check_hostent ("gethostbyname (\"q.example\")",

                 gethostbyname ("q.example"),

                 "error: NO_RECOVERY\n");

  check_hostent ("gethostbyname (\"qm.example\")",

                 gethostbyname ("qm.example"),

                 "error: NO_ADDRESS\n");

  test_get2_no_inet6 ();

  test_get2_no_inet6 ();

  test_gai ();

  test_get2_no_inet6 ();

  test_get2_no_inet6 ();

}

static void *

threadfunc (void *ignored)

{

  struct resolv_test *obj = resolv_test_start

    ((struct resolv_redirect_config)

     {

       .response_callback = response

     });

  TEST_VERIFY ((_res.options & RES_USE_INET6) == 0);

  test_no_inet6 ();

  _res.options |= RES_USE_INET6;

  check_hostent ("gethostbyname (\"a.inet6.example\")",

                 gethostbyname ("a.inet6.example"),

                 "error: NO_RECOVERY\n");

  check_hostent ("gethostbyname (\"am.inet6.example\")",

                 gethostbyname ("am.inet6.example"),

                 "name: am.inet6.example\n"

                 "address: ::ffff:192.0.2.17\n");

  check_hostent ("gethostbyname (\"qa.inet6.example\")",

                 gethostbyname ("qa.inet6.example"),

                 "name: qa.inet6.example\n"

                 "address: 2001:db8::1\n");

  check_hostent ("gethostbyname (\"qam.inet6.example\")",

                 gethostbyname ("qam.inet6.example"),

                 "name: qam.inet6.example\n"

                 "address: 2001:db8::1\n");

  check_hostent ("gethostbyname (\"q.inet6.example\")",

                 gethostbyname ("q.inet6.example"),

                 "name: q.inet6.example\n"

                 "address: 2001:db8::1\n");

  check_hostent ("gethostbyname (\"qm.inet6.example\")",

                 gethostbyname ("qm.inet6.example"),

                 "name: qm.inet6.example\n"

                 "address: 2001:db8::1\n");

  check_hostent ("gethostbyname (\"amp.inet6.example\")",

                 gethostbyname ("amp.inet6.example"),

                 "error: NO_RECOVERY\n");

  check_hostent ("gethostbyname (\"qmp.inet6.example\")",

                 gethostbyname ("qmp.inet6.example"),

                 "name: qmp.inet6.example\n"

                 "address: 2001:db8::1\n");

  check_hostent ("gethostbyname (\"ap.inet6.example\")",

                 gethostbyname ("ap.inet6.example"),

                 "error: NO_RECOVERY\n");

  check_hostent ("gethostbyname (\"6ap.inet6.example\")",

                 gethostbyname ("6ap.inet6.example"),

                 "name: 6ap.inet6.example\n"

                 "address: ::ffff:192.0.2.17\n");

  check_hostent ("gethostbyname (\"am6p.inet6.example\")",

                 gethostbyname ("am6p.inet6.example"),

                 "name: am6p.inet6.example\n"

                 "address: ::ffff:192.0.2.17\n");

  check_hostent ("gethostbyname (\"qp.inet6.example\")",

                 gethostbyname ("qp.inet6.example"),

                 "name: qp.inet6.example\n"

                 "address: 2001:db8::1\n");

  test_get2_inet6 ();

  test_get2_inet6 ();

  test_gai ();

  test_get2_inet6 ();

  test_get2_inet6 ();

  TEST_VERIFY (_res.options & RES_USE_INET6);

  _res.options &= ~RES_USE_INET6;

  test_no_inet6 ();

  resolv_test_end (obj);

  return NULL;

}

static int

do_test (void)

{

  resolv_test_init ();

  /* Attempt to run on a non-main thread first.  */

  {

    pthread_t thr = xpthread_create (NULL, threadfunc, NULL);

    xpthread_join (thr);

  }

  /* Try the main thread next.  */

  threadfunc (NULL);

  return 0;

}

#include <support/test-driver.c>