google3/third_party/grte/v5_src/glibc-2.27/resolv/tst-resolv-canonname.c

/* Test _nss_dns_getcanonname_r corner cases.
   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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <support/check.h>
#include <support/resolv_test.h>
#include <support/support.h>

/* _nss_dns_getcanonname_r is not called during regular operation
   because nss_dns directly provides a canonical name, so we have to
   test it directly.  The function pointer is initialized by do_test
   below.  */
static enum nss_status
(*getcanonname) (const char *name, char *buffer, size_t buflen,
                 char **result, int *errnop, int *h_errnop);

static void
response (const struct resolv_response_context *ctx,
          struct resolv_response_builder *b,
          const char *qname, uint16_t qclass, uint16_t qtype)
{
  int code;
  {
    char *tail;
    if (sscanf (qname, "code%d.%ms", &code, &tail) != 2
        || strcmp (tail, "example") != 0)
      FAIL_EXIT1 ("error: invalid QNAME: %s\n", qname);
    free (tail);
  }

  switch (code)
    {
    case 1:
      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, "www.example", qclass, qtype, 0);
      resolv_response_add_data (b, "\xC0\x00\x02\x01", 4);
      resolv_response_close_record (b);
      break;
    case 2:
      resolv_response_init (b, (struct resolv_response_flags) {});
      resolv_response_add_question (b, qname, qclass, qtype);
      resolv_response_section (b, ns_s_an);
      if (qtype == T_AAAA)
        {
          resolv_response_open_record (b, "www.example", qclass, qtype, 0);
          resolv_response_add_data (b, "\xC0\x00\x02\x01", 4);
          resolv_response_close_record (b);
          for (int i = 0; i < 30000; ++i)
            resolv_response_add_data (b, "", 1);
        }
      break;
    case 3:
      resolv_response_init (b, (struct resolv_response_flags) {});
      resolv_response_add_question (b, qname, qclass, qtype);
      resolv_response_section (b, ns_s_an);
      if (qtype == T_AAAA)
        {
          resolv_response_open_record (b, "www.example", qclass, qtype, 0);
          resolv_response_add_data (b, "\xC0\x00\x02\x01", 4);
          resolv_response_close_record (b);
        }
      else
        {
          for (int i = 0; i < 30000; ++i)
            resolv_response_add_data (b, "", 1);
        }
      break;
    case 4:
      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_CNAME, 0);
      resolv_response_add_name (b, "www.example");
      resolv_response_close_record (b);
      resolv_response_open_record (b, "www.example", qclass, qtype, 0);
      resolv_response_add_data (b, "\xC0\x00\x02\x01", 4);
      resolv_response_close_record (b);
      break;
    case 5:
      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_CNAME, 0);
      resolv_response_add_name (b, "www.example");
      resolv_response_close_record (b);
      resolv_response_open_record (b, qname, qclass, T_CNAME, 0);
      resolv_response_add_name (b, "www1.example");
      resolv_response_close_record (b);
      resolv_response_open_record (b, "www1.example", qclass, qtype, 0);
      resolv_response_add_data (b, "\xC0\x00\x02\x01", 4);
      resolv_response_close_record (b);
      break;
    case 6:
      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_CNAME, 0);
      resolv_response_add_name (b, "www.example");
      resolv_response_close_record (b);
      resolv_response_open_record (b, qname, qclass, 46 /* RRSIG */, 0);
      resolv_response_add_name (b, ".");
      resolv_response_close_record (b);
      resolv_response_open_record (b, "www.example", qclass, qtype, 0);
      resolv_response_add_data (b, "\xC0\x00\x02\x01", 4);
      resolv_response_close_record (b);
      break;
    case 102:
      if (!ctx->tcp)
        {
          resolv_response_init (b, (struct resolv_response_flags) {.tc = true});
          resolv_response_add_question (b, qname, qclass, qtype);
        }
      else
        {
          resolv_response_init
            (b, (struct resolv_response_flags) {.ancount = 1});
          resolv_response_add_question (b, qname, qclass, qtype);
          resolv_response_section (b, ns_s_an);
          resolv_response_open_record (b, qname, qclass, T_CNAME, 0);
          size_t to_fill = 65535 - resolv_response_length (b)
            - 2 /* length, "n" */ - 2 /* compression reference */
            - 2 /* RR type */;
          for (size_t i = 0; i < to_fill; ++i)
            resolv_response_add_data (b, "", 1);
          resolv_response_close_record (b);
          resolv_response_add_name (b, "n.example");
          uint16_t rrtype = htons (T_CNAME);
          resolv_response_add_data (b, &rrtype, sizeof (rrtype));
        }
      break;
    case 103:
      /* NODATA repsonse.  */
      resolv_response_init (b, (struct resolv_response_flags) {});
      resolv_response_add_question (b, qname, qclass, qtype);
      break;
    case 104:
      resolv_response_init (b, (struct resolv_response_flags) {.ancount = 1});
      resolv_response_add_question (b, qname, qclass, qtype);
      /* No RR metadata.  */
      resolv_response_add_name (b, "www.example");
      break;
    case 105:
      if (qtype == T_A)
        {
          resolv_response_init (b, (struct resolv_response_flags) {});
          resolv_response_add_question (b, qname, qclass, qtype);
          /* No data, trigger AAAA query.  */
        }
      else
        {
          resolv_response_init
            (b, (struct resolv_response_flags) {.ancount = 1});
          resolv_response_add_question (b, qname, qclass, qtype);
          /* No RR metadata.  */
          resolv_response_add_name
            (b, "long-name-exceed-previously-initialized-buffer.example");
        }
      break;
    case 106:
      resolv_response_init (b, (struct resolv_response_flags) {.ancount = 1});
      resolv_response_add_question (b, qname, qclass, qtype);
      /* No RR metadata.  */
      resolv_response_add_name (b, "www.example");
      resolv_response_add_data (b, "\xff\xff", 2);
      break;
    case 107:
      if (qtype == T_A)
        {
          resolv_response_init (b, (struct resolv_response_flags) {});
          resolv_response_add_question (b, qname, qclass, qtype);
          /* No data, trigger AAAA query.  */
        }
      else
        {
          resolv_response_init
            (b, (struct resolv_response_flags) {.ancount = 1});
          resolv_response_add_question (b, qname, qclass, qtype);
          /* No RR metadata.  */
          resolv_response_add_name (b, "www.example");
          resolv_response_add_data (b, "\xff\xff", 2);
        }
      break;
    default:
      FAIL_EXIT1 ("error: invalid QNAME: %s (code %d)\n", qname, code);
    }
}

static void
check (int code, const char *expected)
{
  char qname[200];
  snprintf (qname, sizeof (qname), "code%d.example", code);
  char *result;
  enum nss_status status;
  {
    enum { buffer_size = 4096 };
    char *buffer = xmalloc (buffer_size);
    char *temp_result;
    int temp_errno;
    int temp_herrno;
    status = getcanonname
      (qname, buffer, buffer_size, &temp_result, &temp_errno, &temp_herrno);
    if (status == NSS_STATUS_SUCCESS)
      result = xstrdup (temp_result);
    else
      {
        errno = temp_errno;
        h_errno = temp_herrno;
      }
    free (buffer);
  }

  if (status == NSS_STATUS_SUCCESS)
    {
      if (expected != NULL)
        {
          if (strcmp (result, expected) != 0)
            {
              support_record_failure ();
              printf ("error: getcanonname (%s) failed\n", qname);
              printf ("error:  expected: %s\n", expected);
              printf ("error:  actual:   %s\n", result);
              free (result);
              return;
            }
        }
      else
        {
          support_record_failure ();
          printf ("error: getcanonname (%s) unexpected success\n", qname);
          printf ("error:  actual:   %s\n", result);
          free (result);
          return;
        }
      free (result);
    }
  else
    {
      if (expected != NULL)
        {
          support_record_failure ();
          printf ("error: getcanonname (%s) failed\n", qname);
          printf ("error:  expected: %s\n", expected);
          return;
        }
    }
}


static int
do_test (void)
{
  void *nss_dns_handle = dlopen (LIBNSS_DNS_SO, RTLD_LAZY);
  if (nss_dns_handle == NULL)
    FAIL_EXIT1 ("could not dlopen %s: %s", LIBNSS_DNS_SO, dlerror ());
  {
    const char *func = "_nss_dns_getcanonname_r";
    void *ptr = dlsym (nss_dns_handle, func);
    if (ptr == NULL)
      FAIL_EXIT1 ("could not look up %s: %s", func, dlerror ());
    getcanonname = ptr;
  }

  struct resolv_test *aux = resolv_test_start
    ((struct resolv_redirect_config)
     {
       .response_callback = response,
     });

  check (1, "www.example");
  check (2, "www.example");
  check (3, "www.example");
  check (4, "www.example");
  check (5, "www1.example");

  /* This should really result in "www.example", but the fake RRSIG
     record causes the current implementation to stop parsing.  */
  check (6, NULL);

  for (int i = 102; i <= 107; ++i)
  check (i, NULL);

  resolv_test_end (aux);

  TEST_VERIFY (dlclose (nss_dns_handle) == 0);
  return 0;
}

#include <support/test-driver.c>