nscd/aicache.c

   1 /* Cache handling for host lookup.
   2    Copyright (C) 2004-2018 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@redhat.com>, 2004.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published
   8    by the Free Software Foundation; version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include <assert.h>
  20 #include <errno.h>
  21 #include <libintl.h>
  22 #include <netdb.h>
  23 #include <nss.h>
  24 #include <string.h>
  25 #include <time.h>
  26 #include <unistd.h>
  27 #include <sys/mman.h>
  28 #include <resolv/resolv-internal.h>
  29 #include <resolv/resolv_context.h>
  30 #include <resolv/res_use_inet6.h>
  31
  32 #include "dbg_log.h"
  33 #include "nscd.h"
  34 #ifdef HAVE_SENDFILE
  35 # include <kernel-features.h>
  36 #endif
  37
  38
  39 typedef enum nss_status (*nss_gethostbyname4_r)
  40   (const char *name, struct gaih_addrtuple **pat,
  41    char *buffer, size_t buflen, int *errnop,
  42    int *h_errnop, int32_t *ttlp);
  43 typedef enum nss_status (*nss_gethostbyname3_r)
  44   (const char *name, int af, struct hostent *host,
  45    char *buffer, size_t buflen, int *errnop,
  46    int *h_errnop, int32_t *, char **);
  47 typedef enum nss_status (*nss_getcanonname_r)
  48   (const char *name, char *buffer, size_t buflen, char **result,
  49    int *errnop, int *h_errnop);
  50
  51
  52 static const ai_response_header notfound =
  53 {
  54   .version = NSCD_VERSION,
  55   .found = 0,
  56   .naddrs = 0,
  57   .addrslen = 0,
  58   .canonlen = 0,
  59   .error = 0
  60 };
  61
  62
  63 static time_t
  64 addhstaiX (struct database_dyn *db, int fd, request_header *req,
  65            void *key, uid_t uid, struct hashentry *const he,
  66            struct datahead *dh)
  67 {
  68   /* Search for the entry matching the key.  Please note that we don't
  69      look again in the table whether the dataset is now available.  We
  70      simply insert it.  It does not matter if it is in there twice.  The
  71      pruning function only will look at the timestamp.  */
  72
  73   /* We allocate all data in one memory block: the iov vector,
  74      the response header and the dataset itself.  */
  75   struct dataset
  76   {
  77     struct datahead head;
  78     ai_response_header resp;
  79     char strdata[0];
  80   } *dataset = NULL;
  81
  82   if (__glibc_unlikely (debug_level > 0))
  83     {
  84       if (he == NULL)
  85         dbg_log (_("Haven't found \"%s\" in hosts cache!"), (char *) key);
  86       else
  87         dbg_log (_("Reloading \"%s\" in hosts cache!"), (char *) key);
  88     }
  89
  90   static service_user *hosts_database;
  91   service_user *nip;
  92   int no_more;
  93   int rc6 = 0;
  94   int rc4 = 0;
  95   int herrno = 0;
  96
  97   if (hosts_database == NULL)
  98     no_more = __nss_database_lookup ("hosts", NULL,
  99                                      "dns [!UNAVAIL=return] files",
 100                                      &hosts_database);
 101   else
 102     no_more = 0;
 103   nip = hosts_database;
 104
 105   /* Initialize configurations.  If we are looking for both IPv4 and
 106      IPv6 address we don't want the lookup functions to automatically
 107      promote IPv4 addresses to IPv6 addresses.  Therefore, use the
 108      _no_inet6 variant.  */
 109   struct resolv_context *ctx = __resolv_context_get ();
 110   bool enable_inet6 = __resolv_context_disable_inet6 (ctx);
 111   if (ctx == NULL)
 112     no_more = 1;
 113
 114   size_t tmpbuf6len = 1024;
 115   char *tmpbuf6 = alloca (tmpbuf6len);
 116   size_t tmpbuf4len = 0;
 117   char *tmpbuf4 = NULL;
 118   int32_t ttl = INT32_MAX;
 119   ssize_t total = 0;
 120   char *key_copy = NULL;
 121   bool alloca_used = false;
 122   time_t timeout = MAX_TIMEOUT_VALUE;
 123
 124   while (!no_more)
 125     {
 126       void *cp;
 127       int status[2] = { NSS_STATUS_UNAVAIL, NSS_STATUS_UNAVAIL };
 128       int naddrs = 0;
 129       size_t addrslen = 0;
 130       char *canon = NULL;
 131       size_t canonlen;
 132
 133       nss_gethostbyname4_r fct4 = __nss_lookup_function (nip,
 134                                                          "gethostbyname4_r");
 135       if (fct4 != NULL)
 136         {
 137           struct gaih_addrtuple atmem;
 138           struct gaih_addrtuple *at;
 139           while (1)
 140             {
 141               at = &atmem;
 142               rc6 = 0;
 143               herrno = 0;
 144               status[1] = DL_CALL_FCT (fct4, (key, &at, tmpbuf6, tmpbuf6len,
 145                                               &rc6, &herrno, &ttl));
 146               if (rc6 != ERANGE || (herrno != NETDB_INTERNAL
 147                                     && herrno != TRY_AGAIN))
 148                 break;
 149               tmpbuf6 = extend_alloca (tmpbuf6, tmpbuf6len, 2 * tmpbuf6len);
 150             }
 151
 152           if (rc6 != 0 && herrno == NETDB_INTERNAL)
 153             goto out;
 154
 155           if (status[1] != NSS_STATUS_SUCCESS)
 156             goto next_nip;
 157
 158           /* We found the data.  Count the addresses and the size.  */
 159           for (const struct gaih_addrtuple *at2 = at = &atmem; at2 != NULL;
 160                at2 = at2->next)
 161             {
 162               ++naddrs;
 163               /* We do not handle anything other than IPv4 and IPv6
 164                  addresses.  The getaddrinfo implementation does not
 165                  either so it is not worth trying to do more.  */
 166               if (at2->family == AF_INET)
 167                 addrslen += INADDRSZ;
 168               else if (at2->family == AF_INET6)
 169                 addrslen += IN6ADDRSZ;
 170             }
 171           canon = at->name;
 172           canonlen = strlen (canon) + 1;
 173
 174           total = sizeof (*dataset) + naddrs + addrslen + canonlen;
 175
 176           /* Now we can allocate the data structure.  If the TTL of the
 177              entry is reported as zero do not cache the entry at all.  */
 178           if (ttl != 0 && he == NULL)
 179             dataset = (struct dataset *) mempool_alloc (db, total
 180                                                         + req->key_len, 1);
 181
 182           if (dataset == NULL)
 183             {
 184               /* We cannot permanently add the result in the moment.  But
 185                  we can provide the result as is.  Store the data in some
 186                  temporary memory.  */
 187               dataset = (struct dataset *) alloca (total + req->key_len);
 188
 189               /* We cannot add this record to the permanent database.  */
 190               alloca_used = true;
 191             }
 192
 193           /* Fill in the address and address families.  */
 194           char *addrs = dataset->strdata;
 195           uint8_t *family = (uint8_t *) (addrs + addrslen);
 196
 197           for (const struct gaih_addrtuple *at2 = at; at2 != NULL;
 198                at2 = at2->next)
 199             {
 200               *family++ = at2->family;
 201               if (at2->family == AF_INET)
 202                 addrs = mempcpy (addrs, at2->addr, INADDRSZ);
 203               else if (at2->family == AF_INET6)
 204                 addrs = mempcpy (addrs, at2->addr, IN6ADDRSZ);
 205             }
 206
 207           cp = family;
 208         }
 209       else
 210         {
 211           /* Prefer the function which also returns the TTL and
 212              canonical name.  */
 213           nss_gethostbyname3_r fct = __nss_lookup_function (nip,
 214                                                             "gethostbyname3_r");
 215           if (fct == NULL)
 216             fct = __nss_lookup_function (nip, "gethostbyname2_r");
 217
 218           if (fct == NULL)
 219             goto next_nip;
 220
 221           struct hostent th[2];
 222
 223           /* Collect IPv6 information first.  */
 224           while (1)
 225             {
 226               rc6 = 0;
 227               status[0] = DL_CALL_FCT (fct, (key, AF_INET6, &th[0], tmpbuf6,
 228                                              tmpbuf6len, &rc6, &herrno, &ttl,
 229                                              &canon));
 230               if (rc6 != ERANGE || herrno != NETDB_INTERNAL)
 231                 break;
 232               tmpbuf6 = extend_alloca (tmpbuf6, tmpbuf6len, 2 * tmpbuf6len);
 233             }
 234
 235           if (rc6 != 0 && herrno == NETDB_INTERNAL)
 236             goto out;
 237
 238           /* If the IPv6 lookup has been successful do not use the
 239              buffer used in that lookup, use a new one.  */
 240           if (status[0] == NSS_STATUS_SUCCESS && rc6 == 0)
 241             {
 242               tmpbuf4len = 512;
 243               tmpbuf4 = alloca (tmpbuf4len);
 244             }
 245           else
 246             {
 247               tmpbuf4len = tmpbuf6len;
 248               tmpbuf4 = tmpbuf6;
 249             }
 250
 251           /* Next collect IPv4 information.  */
 252           while (1)
 253             {
 254               rc4 = 0;
 255               status[1] = DL_CALL_FCT (fct, (key, AF_INET, &th[1], tmpbuf4,
 256                                              tmpbuf4len, &rc4, &herrno,
 257                                              ttl == INT32_MAX ? &ttl : NULL,
 258                                              canon == NULL ? &canon : NULL));
 259               if (rc4 != ERANGE || herrno != NETDB_INTERNAL)
 260                 break;
 261               tmpbuf4 = extend_alloca (tmpbuf4, tmpbuf4len, 2 * tmpbuf4len);
 262             }
 263
 264           if (rc4 != 0 && herrno == NETDB_INTERNAL)
 265             goto out;
 266
 267           if (status[0] != NSS_STATUS_SUCCESS
 268               && status[1] != NSS_STATUS_SUCCESS)
 269             goto next_nip;
 270
 271           /* We found the data.  Count the addresses and the size.  */
 272           for (int j = 0; j < 2; ++j)
 273             if (status[j] == NSS_STATUS_SUCCESS)
 274               for (int i = 0; th[j].h_addr_list[i] != NULL; ++i)
 275                 {
 276                   ++naddrs;
 277                   addrslen += th[j].h_length;
 278                 }
 279
 280           if (canon == NULL)
 281             {
 282               /* Determine the canonical name.  */
 283               nss_getcanonname_r cfct;
 284               cfct = __nss_lookup_function (nip, "getcanonname_r");
 285               if (cfct != NULL)
 286                 {
 287                   const size_t max_fqdn_len = 256;
 288                   char *buf = alloca (max_fqdn_len);
 289                   char *s;
 290                   int rc;
 291
 292                   if (DL_CALL_FCT (cfct, (key, buf, max_fqdn_len, &s,
 293                                           &rc, &herrno))
 294                       == NSS_STATUS_SUCCESS)
 295                     canon = s;
 296                   else
 297                     /* Set to name now to avoid using gethostbyaddr.  */
 298                     canon = key;
 299                 }
 300               else
 301                 {
 302                   struct hostent *hstent = NULL;
 303                   int herrno;
 304                   struct hostent hstent_mem;
 305                   void *addr;
 306                   size_t addrlen;
 307                   int addrfamily;
 308
 309                   if (status[1] == NSS_STATUS_SUCCESS)
 310                     {
 311                       addr = th[1].h_addr_list[0];
 312                       addrlen = sizeof (struct in_addr);
 313                       addrfamily = AF_INET;
 314                     }
 315                   else
 316                     {
 317                       addr = th[0].h_addr_list[0];
 318                       addrlen = sizeof (struct in6_addr);
 319                       addrfamily = AF_INET6;
 320                     }
 321
 322                   size_t tmpbuflen = 512;
 323                   char *tmpbuf = alloca (tmpbuflen);
 324                   int rc;
 325                   while (1)
 326                     {
 327                       rc = __gethostbyaddr2_r (addr, addrlen, addrfamily,
 328                                                &hstent_mem, tmpbuf, tmpbuflen,
 329                                                &hstent, &herrno, NULL);
 330                       if (rc != ERANGE || herrno != NETDB_INTERNAL)
 331                         break;
 332                       tmpbuf = extend_alloca (tmpbuf, tmpbuflen,
 333                                               tmpbuflen * 2);
 334                     }
 335
 336                   if (rc == 0)
 337                     {
 338                       if (hstent != NULL)
 339                         canon = hstent->h_name;
 340                       else
 341                         canon = key;
 342                     }
 343                 }
 344             }
 345
 346           canonlen = canon == NULL ? 0 : (strlen (canon) + 1);
 347
 348           total = sizeof (*dataset) + naddrs + addrslen + canonlen;
 349
 350
 351           /* Now we can allocate the data structure.  If the TTL of the
 352              entry is reported as zero do not cache the entry at all.  */
 353           if (ttl != 0 && he == NULL)
 354             dataset = (struct dataset *) mempool_alloc (db, total
 355                                                         + req->key_len, 1);
 356
 357           if (dataset == NULL)
 358             {
 359               /* We cannot permanently add the result in the moment.  But
 360                  we can provide the result as is.  Store the data in some
 361                  temporary memory.  */
 362               dataset = (struct dataset *) alloca (total + req->key_len);
 363
 364               /* We cannot add this record to the permanent database.  */
 365               alloca_used = true;
 366             }
 367
 368           /* Fill in the address and address families.  */
 369           char *addrs = dataset->strdata;
 370           uint8_t *family = (uint8_t *) (addrs + addrslen);
 371
 372           for (int j = 0; j < 2; ++j)
 373             if (status[j] == NSS_STATUS_SUCCESS)
 374               for (int i = 0; th[j].h_addr_list[i] != NULL; ++i)
 375                 {
 376                   addrs = mempcpy (addrs, th[j].h_addr_list[i],
 377                                    th[j].h_length);
 378                   *family++ = th[j].h_addrtype;
 379                 }
 380
 381           cp = family;
 382         }
 383
 384       timeout = datahead_init_pos (&dataset->head, total + req->key_len,
 385                                    total - offsetof (struct dataset, resp),
 386                                    he == NULL ? 0 : dh->nreloads + 1,
 387                                    ttl == INT32_MAX ? db->postimeout : ttl);
 388
 389       /* Fill in the rest of the dataset.  */
 390       dataset->resp.version = NSCD_VERSION;
 391       dataset->resp.found = 1;
 392       dataset->resp.naddrs = naddrs;
 393       dataset->resp.addrslen = addrslen;
 394       dataset->resp.canonlen = canonlen;
 395       dataset->resp.error = NETDB_SUCCESS;
 396
 397       if (canon != NULL)
 398         cp = mempcpy (cp, canon, canonlen);
 399
 400       key_copy = memcpy (cp, key, req->key_len);
 401
 402       assert (cp == (char *) dataset + total);
 403
 404       /* Now we can determine whether on refill we have to create a
 405          new record or not.  */
 406       if (he != NULL)
 407         {
 408           assert (fd == -1);
 409
 410           if (total + req->key_len == dh->allocsize
 411               && total - offsetof (struct dataset, resp) == dh->recsize
 412               && memcmp (&dataset->resp, dh->data,
 413                          dh->allocsize - offsetof (struct dataset,
 414                                                    resp)) == 0)
 415             {
 416               /* The data has not changed.  We will just bump the
 417                  timeout value.  Note that the new record has been
 418                  allocated on the stack and need not be freed.  */
 419               dh->timeout = dataset->head.timeout;
 420               dh->ttl = dataset->head.ttl;
 421               ++dh->nreloads;
 422             }
 423           else
 424             {
 425               /* We have to create a new record.  Just allocate
 426                  appropriate memory and copy it.  */
 427               struct dataset *newp
 428                 = (struct dataset *) mempool_alloc (db, total + req->key_len,
 429                                                     1);
 430               if (__glibc_likely (newp != NULL))
 431                 {
 432                   /* Adjust pointer into the memory block.  */
 433                   key_copy = (char *) newp + (key_copy - (char *) dataset);
 434
 435                   dataset = memcpy (newp, dataset, total + req->key_len);
 436                   alloca_used = false;
 437                 }
 438
 439               /* Mark the old record as obsolete.  */
 440               dh->usable = false;
 441             }
 442         }
 443       else
 444         {
 445           /* We write the dataset before inserting it to the database
 446              since while inserting this thread might block and so
 447              would unnecessarily let the receiver wait.  */
 448           assert (fd != -1);
 449
 450 #ifdef HAVE_SENDFILE
 451           if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
 452             {
 453               assert (db->wr_fd != -1);
 454               assert ((char *) &dataset->resp > (char *) db->data);
 455               assert ((char *) dataset - (char *) db->head + total
 456                       <= (sizeof (struct database_pers_head)
 457                           + db->head->module * sizeof (ref_t)
 458                           + db->head->data_size));
 459 # ifndef __ASSUME_SENDFILE
 460               ssize_t written;
 461               written =
 462 # endif
 463                 sendfileall (fd, db->wr_fd, (char *) &dataset->resp
 464                              - (char *) db->head, dataset->head.recsize);
 465 # ifndef __ASSUME_SENDFILE
 466               if (written == -1 && errno == ENOSYS)
 467                 goto use_write;
 468 # endif
 469             }
 470           else
 471 # ifndef __ASSUME_SENDFILE
 472           use_write:
 473 # endif
 474 #endif
 475             writeall (fd, &dataset->resp, dataset->head.recsize);
 476         }
 477
 478       goto out;
 479
 480 next_nip:
 481       if (nss_next_action (nip, status[1]) == NSS_ACTION_RETURN)
 482         break;
 483
 484       if (nip->next == NULL)
 485         no_more = -1;
 486       else
 487         nip = nip->next;
 488     }
 489
 490   /* No result found.  Create a negative result record.  */
 491   if (he != NULL && rc4 == EAGAIN)
 492     {
 493       /* If we have an old record available but cannot find one now
 494          because the service is not available we keep the old record
 495          and make sure it does not get removed.  */
 496       if (reload_count != UINT_MAX && dh->nreloads == reload_count)
 497         /* Do not reset the value if we never not reload the record.  */
 498         dh->nreloads = reload_count - 1;
 499
 500       /* Reload with the same time-to-live value.  */
 501       timeout = dh->timeout = time (NULL) + dh->ttl;
 502     }
 503   else
 504     {
 505       /* We have no data.  This means we send the standard reply for
 506          this case.  */
 507       total = sizeof (notfound);
 508
 509       if (fd != -1)
 510         TEMP_FAILURE_RETRY (send (fd, &notfound, total, MSG_NOSIGNAL));
 511
 512       /* If we have a transient error or cannot permanently store the
 513          result, so be it.  */
 514       if (rc4 == EAGAIN || __builtin_expect (db->negtimeout == 0, 0))
 515         {
 516           /* Mark the old entry as obsolete.  */
 517           if (dh != NULL)
 518             dh->usable = false;
 519           dataset = NULL;
 520         }
 521       else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
 522                                               + req->key_len), 1)) != NULL)
 523         {
 524           timeout = datahead_init_neg (&dataset->head,
 525                                        sizeof (struct dataset) + req->key_len,
 526                                        total, db->negtimeout);
 527
 528           /* This is the reply.  */
 529           memcpy (&dataset->resp, &notfound, total);
 530
 531           /* Copy the key data.  */
 532           key_copy = memcpy (dataset->strdata, key, req->key_len);
 533         }
 534    }
 535
 536  out:
 537   __resolv_context_enable_inet6 (ctx, enable_inet6);
 538   __resolv_context_put (ctx);
 539
 540   if (dataset != NULL && !alloca_used)
 541     {
 542       /* If necessary, we also propagate the data to disk.  */
 543       if (db->persistent)
 544         {
 545           // XXX async OK?
 546           uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
 547           msync ((void *) pval,
 548                  ((uintptr_t) dataset & pagesize_m1) + total + req->key_len,
 549                  MS_ASYNC);
 550         }
 551
 552       (void) cache_add (req->type, key_copy, req->key_len, &dataset->head,
 553                         true, db, uid, he == NULL);
 554
 555       pthread_rwlock_unlock (&db->lock);
 556
 557       /* Mark the old entry as obsolete.  */
 558       if (dh != NULL)
 559         dh->usable = false;
 560     }
 561
 562   return timeout;
 563 }
 564
 565
 566 void
 567 addhstai (struct database_dyn *db, int fd, request_header *req, void *key,
 568           uid_t uid)
 569 {
 570   addhstaiX (db, fd, req, key, uid, NULL, NULL);
 571 }
 572
 573
 574 time_t
 575 readdhstai (struct database_dyn *db, struct hashentry *he, struct datahead *dh)
 576 {
 577   request_header req =
 578     {
 579       .type = GETAI,
 580       .key_len = he->len
 581     };
 582
 583   return addhstaiX (db, -1, &req, db->data + he->key, he->owner, he, dh);
 584 }