resolv/tst-resolv-canonname.c

   1 /* Test _nss_dns_getcanonname_r corner cases.
   2    Copyright (C) 2017-2024 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <dlfcn.h>
  20 #include <errno.h>
  21 #include <gnu/lib-names.h>
  22 #include <netdb.h>
  23 #include <nss.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <support/check.h>
  28 #include <support/resolv_test.h>
  29 #include <support/support.h>
  30
  31 /* _nss_dns_getcanonname_r is not called during regular operation
  32    because nss_dns directly provides a canonical name, so we have to
  33    test it directly.  The function pointer is initialized by do_test
  34    below.  */
  35 static enum nss_status
  36 (*getcanonname) (const char *name, char *buffer, size_t buflen,
  37                  char **result, int *errnop, int *h_errnop);
  38
  39 static void
  40 response (const struct resolv_response_context *ctx,
  41           struct resolv_response_builder *b,
  42           const char *qname, uint16_t qclass, uint16_t qtype)
  43 {
  44   int code;
  45   {
  46     char *tail;
  47     if (sscanf (qname, "code%d.%ms", &code, &tail) != 2
  48         || strcmp (tail, "example") != 0)
  49       FAIL_EXIT1 ("error: invalid QNAME: %s\n", qname);
  50     free (tail);
  51   }
  52
  53   switch (code)
  54     {
  55     case 1:
  56       resolv_response_init (b, (struct resolv_response_flags) {});
  57       resolv_response_add_question (b, qname, qclass, qtype);
  58       resolv_response_section (b, ns_s_an);
  59       resolv_response_open_record (b, "www.example", qclass, qtype, 0);
  60       resolv_response_add_data (b, "\xC0\x00\x02\x01", 4);
  61       resolv_response_close_record (b);
  62       break;
  63     case 2:
  64       resolv_response_init (b, (struct resolv_response_flags) {});
  65       resolv_response_add_question (b, qname, qclass, qtype);
  66       resolv_response_section (b, ns_s_an);
  67       if (qtype == T_AAAA)
  68         {
  69           resolv_response_open_record (b, "www.example", qclass, qtype, 0);
  70           resolv_response_add_data (b, "\xC0\x00\x02\x01", 4);
  71           resolv_response_close_record (b);
  72           for (int i = 0; i < 30000; ++i)
  73             resolv_response_add_data (b, "", 1);
  74         }
  75       break;
  76     case 3:
  77       resolv_response_init (b, (struct resolv_response_flags) {});
  78       resolv_response_add_question (b, qname, qclass, qtype);
  79       resolv_response_section (b, ns_s_an);
  80       if (qtype == T_AAAA)
  81         {
  82           resolv_response_open_record (b, "www.example", qclass, qtype, 0);
  83           resolv_response_add_data (b, "\xC0\x00\x02\x01", 4);
  84           resolv_response_close_record (b);
  85         }
  86       else
  87         {
  88           for (int i = 0; i < 30000; ++i)
  89             resolv_response_add_data (b, "", 1);
  90         }
  91       break;
  92     case 4:
  93       resolv_response_init (b, (struct resolv_response_flags) {});
  94       resolv_response_add_question (b, qname, qclass, qtype);
  95       resolv_response_section (b, ns_s_an);
  96       resolv_response_open_record (b, qname, qclass, T_CNAME, 0);
  97       resolv_response_add_name (b, "www.example");
  98       resolv_response_close_record (b);
  99       resolv_response_open_record (b, "www.example", qclass, qtype, 0);
 100       resolv_response_add_data (b, "\xC0\x00\x02\x01", 4);
 101       resolv_response_close_record (b);
 102       break;
 103     case 5:
 104       resolv_response_init (b, (struct resolv_response_flags) {});
 105       resolv_response_add_question (b, qname, qclass, qtype);
 106       resolv_response_section (b, ns_s_an);
 107       resolv_response_open_record (b, qname, qclass, T_CNAME, 0);
 108       resolv_response_add_name (b, "www.example");
 109       resolv_response_close_record (b);
 110       resolv_response_open_record (b, qname, qclass, T_CNAME, 0);
 111       resolv_response_add_name (b, "www1.example");
 112       resolv_response_close_record (b);
 113       resolv_response_open_record (b, "www1.example", qclass, qtype, 0);
 114       resolv_response_add_data (b, "\xC0\x00\x02\x01", 4);
 115       resolv_response_close_record (b);
 116       break;
 117     case 6:
 118       resolv_response_init (b, (struct resolv_response_flags) {});
 119       resolv_response_add_question (b, qname, qclass, qtype);
 120       resolv_response_section (b, ns_s_an);
 121       resolv_response_open_record (b, qname, qclass, T_CNAME, 0);
 122       resolv_response_add_name (b, "www.example");
 123       resolv_response_close_record (b);
 124       resolv_response_open_record (b, qname, qclass, 46 /* RRSIG */, 0);
 125       resolv_response_add_name (b, ".");
 126       resolv_response_close_record (b);
 127       resolv_response_open_record (b, "www.example", qclass, qtype, 0);
 128       resolv_response_add_data (b, "\xC0\x00\x02\x01", 4);
 129       resolv_response_close_record (b);
 130       break;
 131     case 102:
 132       if (!ctx->tcp)
 133         {
 134           resolv_response_init (b, (struct resolv_response_flags) {.tc = true});
 135           resolv_response_add_question (b, qname, qclass, qtype);
 136         }
 137       else
 138         {
 139           resolv_response_init
 140             (b, (struct resolv_response_flags) {.ancount = 1});
 141           resolv_response_add_question (b, qname, qclass, qtype);
 142           resolv_response_section (b, ns_s_an);
 143           resolv_response_open_record (b, qname, qclass, T_CNAME, 0);
 144           size_t to_fill = 65535 - resolv_response_length (b)
 145             - 2 /* length, "n" */ - 2 /* compression reference */
 146             - 2 /* RR type */;
 147           for (size_t i = 0; i < to_fill; ++i)
 148             resolv_response_add_data (b, "", 1);
 149           resolv_response_close_record (b);
 150           resolv_response_add_name (b, "n.example");
 151           uint16_t rrtype = htons (T_CNAME);
 152           resolv_response_add_data (b, &rrtype, sizeof (rrtype));
 153         }
 154       break;
 155     case 103:
 156       /* NODATA response.  */
 157       resolv_response_init (b, (struct resolv_response_flags) {});
 158       resolv_response_add_question (b, qname, qclass, qtype);
 159       break;
 160     case 104:
 161       resolv_response_init (b, (struct resolv_response_flags) {.ancount = 1});
 162       resolv_response_add_question (b, qname, qclass, qtype);
 163       /* No RR metadata.  */
 164       resolv_response_add_name (b, "www.example");
 165       break;
 166     case 105:
 167       if (qtype == T_A)
 168         {
 169           resolv_response_init (b, (struct resolv_response_flags) {});
 170           resolv_response_add_question (b, qname, qclass, qtype);
 171           /* No data, trigger AAAA query.  */
 172         }
 173       else
 174         {
 175           resolv_response_init
 176             (b, (struct resolv_response_flags) {.ancount = 1});
 177           resolv_response_add_question (b, qname, qclass, qtype);
 178           /* No RR metadata.  */
 179           resolv_response_add_name
 180             (b, "long-name-exceed-previously-initialized-buffer.example");
 181         }
 182       break;
 183     case 106:
 184       resolv_response_init (b, (struct resolv_response_flags) {.ancount = 1});
 185       resolv_response_add_question (b, qname, qclass, qtype);
 186       /* No RR metadata.  */
 187       resolv_response_add_name (b, "www.example");
 188       resolv_response_add_data (b, "\xff\xff", 2);
 189       break;
 190     case 107:
 191       if (qtype == T_A)
 192         {
 193           resolv_response_init (b, (struct resolv_response_flags) {});
 194           resolv_response_add_question (b, qname, qclass, qtype);
 195           /* No data, trigger AAAA query.  */
 196         }
 197       else
 198         {
 199           resolv_response_init
 200             (b, (struct resolv_response_flags) {.ancount = 1});
 201           resolv_response_add_question (b, qname, qclass, qtype);
 202           /* No RR metadata.  */
 203           resolv_response_add_name (b, "www.example");
 204           resolv_response_add_data (b, "\xff\xff", 2);
 205         }
 206       break;
 207     default:
 208       FAIL_EXIT1 ("error: invalid QNAME: %s (code %d)\n", qname, code);
 209     }
 210 }
 211
 212 static void
 213 check (int code, const char *expected)
 214 {
 215   char qname[200];
 216   snprintf (qname, sizeof (qname), "code%d.example", code);
 217   char *result;
 218   enum nss_status status;
 219   {
 220     enum { buffer_size = 4096 };
 221     char *buffer = xmalloc (buffer_size);
 222     char *temp_result;
 223     int temp_errno;
 224     int temp_herrno;
 225     status = getcanonname
 226       (qname, buffer, buffer_size, &temp_result, &temp_errno, &temp_herrno);
 227     if (status == NSS_STATUS_SUCCESS)
 228       result = xstrdup (temp_result);
 229     else
 230       {
 231         errno = temp_errno;
 232         h_errno = temp_herrno;
 233       }
 234     free (buffer);
 235   }
 236
 237   if (status == NSS_STATUS_SUCCESS)
 238     {
 239       if (expected != NULL)
 240         {
 241           if (strcmp (result, expected) != 0)
 242             {
 243               support_record_failure ();
 244               printf ("error: getcanonname (%s) failed\n", qname);
 245               printf ("error:  expected: %s\n", expected);
 246               printf ("error:  actual:   %s\n", result);
 247               free (result);
 248               return;
 249             }
 250         }
 251       else
 252         {
 253           support_record_failure ();
 254           printf ("error: getcanonname (%s) unexpected success\n", qname);
 255           printf ("error:  actual:   %s\n", result);
 256           free (result);
 257           return;
 258         }
 259       free (result);
 260     }
 261   else
 262     {
 263       if (expected != NULL)
 264         {
 265           support_record_failure ();
 266           printf ("error: getcanonname (%s) failed\n", qname);
 267           printf ("error:  expected: %s\n", expected);
 268           return;
 269         }
 270     }
 271 }
 272
 273
 274 static int
 275 do_test (void)
 276 {
 277   void *nss_dns_handle = dlopen (LIBNSS_DNS_SO, RTLD_LAZY);
 278   if (nss_dns_handle == NULL)
 279     FAIL_EXIT1 ("could not dlopen %s: %s", LIBNSS_DNS_SO, dlerror ());
 280   {
 281     const char *func = "_nss_dns_getcanonname_r";
 282     void *ptr = dlsym (nss_dns_handle, func);
 283     if (ptr == NULL)
 284       FAIL_EXIT1 ("could not look up %s: %s", func, dlerror ());
 285     getcanonname = ptr;
 286   }
 287
 288   struct resolv_test *aux = resolv_test_start
 289     ((struct resolv_redirect_config)
 290      {
 291        .response_callback = response,
 292      });
 293
 294   check (1, "www.example");
 295   check (2, "www.example");
 296   check (3, "www.example");
 297   check (4, "www.example");
 298   check (5, "www1.example");
 299
 300   /* This should really result in "www.example", but the fake RRSIG
 301      record causes the current implementation to stop parsing.  */
 302   check (6, NULL);
 303
 304   for (int i = 102; i <= 107; ++i)
 305   check (i, NULL);
 306
 307   resolv_test_end (aux);
 308
 309   TEST_VERIFY (dlclose (nss_dns_handle) == 0);
 310   return 0;
 311 }
 312
 313 #include <support/test-driver.c>