nscd/aicache.c

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