nscd/aicache.c

   1 /* Cache handling for host lookup.
   2    Copyright (C) 2004, 2005, 2006, 2007 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 <string.h>
  25 #include <time.h>
  26 #include <unistd.h>
  27 #include <sys/mman.h>
  28
  29 #include "dbg_log.h"
  30 #include "nscd.h"
  31 #ifdef HAVE_SENDFILE
  32 # include <kernel-features.h>
  33 #endif
  34
  35
  36 typedef enum nss_status (*nss_gethostbyname3_r)
  37   (const char *name, int af, struct hostent *host,
  38    char *buffer, size_t buflen, int *errnop,
  39    int *h_errnop, int32_t *, char **);
  40 typedef enum nss_status (*nss_getcanonname_r)
  41   (const char *name, char *buffer, size_t buflen, char **result,
  42    int *errnop, int *h_errnop);
  43
  44
  45 static const ai_response_header notfound =
  46 {
  47   .version = NSCD_VERSION,
  48   .found = 0,
  49   .naddrs = 0,
  50   .addrslen = 0,
  51   .canonlen = 0,
  52   .error = 0
  53 };
  54
  55
  56 static void
  57 addhstaiX (struct database_dyn *db, int fd, request_header *req,
  58            void *key, uid_t uid, struct hashentry *he, struct datahead *dh)
  59 {
  60   /* Search for the entry matching the key.  Please note that we don't
  61      look again in the table whether the dataset is now available.  We
  62      simply insert it.  It does not matter if it is in there twice.  The
  63      pruning function only will look at the timestamp.  */
  64
  65   /* We allocate all data in one memory block: the iov vector,
  66      the response header and the dataset itself.  */
  67   struct dataset
  68   {
  69     struct datahead head;
  70     ai_response_header resp;
  71     char strdata[0];
  72   } *dataset = NULL;
  73
  74   if (__builtin_expect (debug_level > 0, 0))
  75     {
  76       if (he == NULL)
  77         dbg_log (_("Haven't found \"%s\" in hosts cache!"), (char *) key);
  78       else
  79         dbg_log (_("Reloading \"%s\" in hosts cache!"), (char *) key);
  80     }
  81
  82   static service_user *hosts_database;
  83   service_user *nip = NULL;
  84   int no_more;
  85   int rc6 = 0;
  86   int rc4 = 0;
  87   int herrno = 0;
  88
  89   if (hosts_database != NULL)
  90     {
  91       nip = hosts_database;
  92       no_more = 0;
  93     }
  94   else
  95     no_more = __nss_database_lookup ("hosts", NULL,
  96                                      "dns [!UNAVAIL=return] files", &nip);
  97
  98   if (__res_maybe_init (&_res, 0) == -1)
  99             no_more = 1;
 100
 101   /* If we are looking for both IPv4 and IPv6 address we don't want
 102      the lookup functions to automatically promote IPv4 addresses to
 103      IPv6 addresses.  Currently this is decided by setting the
 104      RES_USE_INET6 bit in _res.options.  */
 105   int old_res_options = _res.options;
 106   _res.options &= ~RES_USE_INET6;
 107
 108   size_t tmpbuf6len = 512;
 109   char *tmpbuf6 = alloca (tmpbuf6len);
 110   size_t tmpbuf4len = 0;
 111   char *tmpbuf4 = NULL;
 112   char *canon = NULL;
 113   int32_t ttl = UINT32_MAX;
 114   ssize_t total = 0;
 115   char *key_copy = NULL;
 116   bool alloca_used = false;
 117
 118   while (!no_more)
 119     {
 120       int status[2] = { NSS_STATUS_UNAVAIL, NSS_STATUS_UNAVAIL };
 121
 122       /* Prefer the function which also returns the TTL and canonical name.  */
 123       nss_gethostbyname3_r fct = __nss_lookup_function (nip,
 124                                                         "gethostbyname3_r");
 125       if (fct == NULL)
 126         fct = __nss_lookup_function (nip, "gethostbyname2_r");
 127
 128       if (fct != NULL)
 129         {
 130           struct hostent th[2];
 131
 132           /* Collect IPv6 information first.  */
 133           while (1)
 134             {
 135               rc6 = 0;
 136               status[0] = DL_CALL_FCT (fct, (key, AF_INET6, &th[0], tmpbuf6,
 137                                              tmpbuf6len, &rc6, &herrno,
 138                                              &ttl, &canon));
 139               if (rc6 != ERANGE || herrno != NETDB_INTERNAL)
 140                 break;
 141               tmpbuf6 = extend_alloca (tmpbuf6, tmpbuf6len, 2 * tmpbuf6len);
 142             }
 143
 144           if (rc6 != 0 && herrno == NETDB_INTERNAL)
 145             goto out;
 146
 147           /* If the IPv6 lookup has been successful do not use the
 148              buffer used in that lookup, use a new one.  */
 149           if (status[0] == NSS_STATUS_SUCCESS && rc6 == 0)
 150             {
 151               tmpbuf4len = 512;
 152               tmpbuf4 = alloca (tmpbuf4len);
 153             }
 154           else
 155             {
 156               tmpbuf4len = tmpbuf6len;
 157               tmpbuf4 = tmpbuf6;
 158             }
 159
 160           /* Next collect IPv4 information first.  */
 161           while (1)
 162             {
 163               rc4 = 0;
 164               status[1] = DL_CALL_FCT (fct, (key, AF_INET, &th[1], tmpbuf4,
 165                                              tmpbuf4len, &rc4, &herrno,
 166                                              ttl == UINT32_MAX ? &ttl : NULL,
 167                                              canon == NULL ? &canon : NULL));
 168               if (rc4 != ERANGE || herrno != NETDB_INTERNAL)
 169                 break;
 170               tmpbuf4 = extend_alloca (tmpbuf4, tmpbuf4len, 2 * tmpbuf4len);
 171             }
 172
 173           if (rc4 != 0 || herrno == NETDB_INTERNAL)
 174             goto out;
 175
 176           if (status[0] == NSS_STATUS_SUCCESS
 177               || status[1] == NSS_STATUS_SUCCESS)
 178             {
 179               /* We found the data.  Count the addresses and the size.  */
 180               int naddrs = 0;
 181               size_t addrslen = 0;
 182               for (int j = 0; j < 2; ++j)
 183                 if (status[j] == NSS_STATUS_SUCCESS)
 184                   for (int i = 0; th[j].h_addr_list[i] != NULL; ++i)
 185                     {
 186                       ++naddrs;
 187                       addrslen += th[j].h_length;
 188                     }
 189
 190               if (canon == NULL)
 191                 {
 192                   /* Determine the canonical name.  */
 193                   nss_getcanonname_r cfct;
 194                   cfct = __nss_lookup_function (nip, "getcanonname_r");
 195                   if (cfct != NULL)
 196                     {
 197                       const size_t max_fqdn_len = 256;
 198                       char *buf = alloca (max_fqdn_len);
 199                       char *s;
 200                       int rc;
 201
 202                       if (DL_CALL_FCT (cfct, (key, buf, max_fqdn_len, &s, &rc,
 203                                               &herrno)) == NSS_STATUS_SUCCESS)
 204                         canon = s;
 205                       else
 206                         /* Set to name now to avoid using gethostbyaddr.  */
 207                         canon = key;
 208                     }
 209                   else
 210                     {
 211                       struct hostent *he = NULL;
 212                       int herrno;
 213                       struct hostent he_mem;
 214                       void *addr;
 215                       size_t addrlen;
 216                       int addrfamily;
 217
 218                       if (status[1] == NSS_STATUS_SUCCESS)
 219                         {
 220                           addr = th[1].h_addr_list[0];
 221                           addrlen = sizeof (struct in_addr);
 222                           addrfamily = AF_INET;
 223                         }
 224                       else
 225                         {
 226                           addr = th[0].h_addr_list[0];
 227                           addrlen = sizeof (struct in6_addr);
 228                           addrfamily = AF_INET6;
 229                         }
 230
 231                       size_t tmpbuflen = 512;
 232                       char *tmpbuf = alloca (tmpbuflen);
 233                       int rc;
 234                       while (1)
 235                         {
 236                           rc = __gethostbyaddr_r (addr, addrlen, addrfamily,
 237                                                   &he_mem, tmpbuf, tmpbuflen,
 238                                                   &he, &herrno);
 239                           if (rc != ERANGE || herrno != NETDB_INTERNAL)
 240                             break;
 241                           tmpbuf = extend_alloca (tmpbuf, tmpbuflen,
 242                                                   tmpbuflen * 2);
 243                         }
 244
 245                       if (rc == 0)
 246                         {
 247                           if (he != NULL)
 248                             canon = he->h_name;
 249                           else
 250                             canon = key;
 251                         }
 252                     }
 253                 }
 254               size_t canonlen = canon == NULL ? 0 : (strlen (canon) + 1);
 255
 256               total = sizeof (*dataset) + naddrs + addrslen + canonlen;
 257
 258               /* Now we can allocate the data structure.  If the TTL
 259                  of the entry is reported as zero do not cache the
 260                  entry at all.  */
 261               if (ttl != 0 && he == NULL)
 262                 {
 263                   dataset = (struct dataset *) mempool_alloc (db,
 264                                                               total
 265                                                               + req->key_len);
 266                   if (dataset == NULL)
 267                     ++db->head->addfailed;
 268                 }
 269
 270               if (dataset == NULL)
 271                 {
 272                   /* We cannot permanently add the result in the moment.  But
 273                      we can provide the result as is.  Store the data in some
 274                      temporary memory.  */
 275                   dataset = (struct dataset *) alloca (total + req->key_len);
 276
 277                   /* We cannot add this record to the permanent database.  */
 278                   alloca_used = true;
 279                 }
 280
 281               dataset->head.allocsize = total + req->key_len;
 282               dataset->head.recsize = total - offsetof (struct dataset, resp);
 283               dataset->head.notfound = false;
 284               dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
 285               dataset->head.usable = true;
 286
 287               /* Compute the timeout time.  */
 288               dataset->head.timeout = time (NULL) + MIN (db->postimeout, ttl);
 289
 290               dataset->resp.version = NSCD_VERSION;
 291               dataset->resp.found = 1;
 292               dataset->resp.naddrs = naddrs;
 293               dataset->resp.addrslen = addrslen;
 294               dataset->resp.canonlen = canonlen;
 295               dataset->resp.error = NETDB_SUCCESS;
 296
 297               char *addrs = (char *) (&dataset->resp + 1);
 298               uint8_t *family = (uint8_t *) (addrs + addrslen);
 299
 300               for (int j = 0; j < 2; ++j)
 301                 if (status[j] == NSS_STATUS_SUCCESS)
 302                   for (int i = 0; th[j].h_addr_list[i] != NULL; ++i)
 303                     {
 304                       addrs = mempcpy (addrs, th[j].h_addr_list[i],
 305                                        th[j].h_length);
 306                       *family++ = th[j].h_addrtype;
 307                     }
 308
 309               void *cp = family;
 310               if (canon != NULL)
 311                 cp = mempcpy (cp, canon, canonlen);
 312
 313               key_copy = memcpy (cp, key, req->key_len);
 314
 315               /* Now we can determine whether on refill we have to
 316                  create a new record or not.  */
 317               if (he != NULL)
 318                 {
 319                   assert (fd == -1);
 320
 321                   if (total + req->key_len == dh->allocsize
 322                       && total - offsetof (struct dataset, resp) == dh->recsize
 323                       && memcmp (&dataset->resp, dh->data,
 324                                  dh->allocsize
 325                                  - offsetof (struct dataset, resp)) == 0)
 326                     {
 327                       /* The data has not changed.  We will just bump the
 328                          timeout value.  Note that the new record has been
 329                          allocated on the stack and need not be freed.  */
 330                       dh->timeout = dataset->head.timeout;
 331                       ++dh->nreloads;
 332                     }
 333                   else
 334                     {
 335                       /* We have to create a new record.  Just allocate
 336                          appropriate memory and copy it.  */
 337                       struct dataset *newp
 338                         = (struct dataset *) mempool_alloc (db,
 339                                                             total
 340                                                             + req->key_len);
 341                       if (newp != NULL)
 342                         {
 343                           /* Adjust pointer into the memory block.  */
 344                           key_copy = (char *) newp + (key_copy
 345                                                       - (char *) dataset);
 346
 347                           dataset = memcpy (newp, dataset,
 348                                             total + req->key_len);
 349                           alloca_used = false;
 350                         }
 351
 352                       /* Mark the old record as obsolete.  */
 353                       dh->usable = false;
 354                     }
 355                 }
 356               else
 357                 {
 358                   /* We write the dataset before inserting it to the
 359                      database since while inserting this thread might
 360                      block and so would unnecessarily let the receiver
 361                      wait.  */
 362                   assert (fd != -1);
 363
 364 #ifdef HAVE_SENDFILE
 365                   if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
 366                     {
 367                       assert (db->wr_fd != -1);
 368                       assert ((char *) &dataset->resp > (char *) db->data);
 369                       assert ((char *) &dataset->resp - (char *) db->head
 370                               + total
 371                               <= (sizeof (struct database_pers_head)
 372                                   + db->head->module * sizeof (ref_t)
 373                                   + db->head->data_size));
 374                       ssize_t written;
 375                       written = sendfileall (fd, db->wr_fd,
 376                                              (char *) &dataset->resp
 377                                              - (char *) db->head, total);
 378 # ifndef __ASSUME_SENDFILE
 379                       if (written == -1 && errno == ENOSYS)
 380                         goto use_write;
 381 # endif
 382                     }
 383                   else
 384 # ifndef __ASSUME_SENDFILE
 385                   use_write:
 386 # endif
 387 #endif
 388                     writeall (fd, &dataset->resp, total);
 389                 }
 390
 391               goto out;
 392             }
 393
 394         }
 395
 396       if (nss_next_action (nip, status[1]) == NSS_ACTION_RETURN)
 397         break;
 398
 399       if (nip->next == NULL)
 400         no_more = -1;
 401       else
 402         nip = nip->next;
 403     }
 404
 405   /* No result found.  Create a negative result record.  */
 406   if (he != NULL && rc4 == EAGAIN)
 407     {
 408       /* If we have an old record available but cannot find one now
 409          because the service is not available we keep the old record
 410          and make sure it does not get removed.  */
 411       if (reload_count != UINT_MAX && dh->nreloads == reload_count)
 412         /* Do not reset the value if we never not reload the record.  */
 413         dh->nreloads = reload_count - 1;
 414     }
 415   else
 416     {
 417       /* We have no data.  This means we send the standard reply for
 418          this case.  */
 419       total = sizeof (notfound);
 420
 421       if (fd != -1)
 422         TEMP_FAILURE_RETRY (send (fd, &notfound, total, MSG_NOSIGNAL));
 423
 424       dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len);
 425       /* If we cannot permanently store the result, so be it.  */
 426       if (dataset != NULL)
 427         {
 428           dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
 429           dataset->head.recsize = total;
 430           dataset->head.notfound = true;
 431           dataset->head.nreloads = 0;
 432           dataset->head.usable = true;
 433
 434           /* Compute the timeout time.  */
 435           dataset->head.timeout = time (NULL) + db->negtimeout;
 436
 437           /* This is the reply.  */
 438           memcpy (&dataset->resp, &notfound, total);
 439
 440           /* Copy the key data.  */
 441           key_copy = memcpy (dataset->strdata, key, req->key_len);
 442         }
 443       else
 444         ++db->head->addfailed;
 445    }
 446
 447  out:
 448   _res.options = old_res_options;
 449
 450   if (dataset != NULL && !alloca_used)
 451     {
 452       /* If necessary, we also propagate the data to disk.  */
 453       if (db->persistent)
 454         {
 455           // XXX async OK?
 456           uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
 457           msync ((void *) pval,
 458                  ((uintptr_t) dataset & pagesize_m1) + total + req->key_len,
 459                  MS_ASYNC);
 460         }
 461
 462       /* Now get the lock to safely insert the records.  */
 463       pthread_rwlock_rdlock (&db->lock);
 464
 465       if (cache_add (req->type, key_copy, req->key_len, &dataset->head, true,
 466                      db, uid) < 0)
 467         /* Ensure the data can be recovered.  */
 468         dataset->head.usable = false;
 469
 470       pthread_rwlock_unlock (&db->lock);
 471
 472       /* Mark the old entry as obsolete.  */
 473       if (dh != NULL)
 474         dh->usable = false;
 475     }
 476 }
 477
 478
 479 void
 480 addhstai (struct database_dyn *db, int fd, request_header *req, void *key,
 481           uid_t uid)
 482 {
 483   addhstaiX (db, fd, req, key, uid, NULL, NULL);
 484 }
 485
 486
 487 void
 488 readdhstai (struct database_dyn *db, struct hashentry *he, struct datahead *dh)
 489 {
 490   request_header req =
 491     {
 492       .type = GETAI,
 493       .key_len = he->len
 494     };
 495
 496   addhstaiX (db, -1, &req, db->data + he->key, he->owner, he, dh);
 497 }