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 = INT32_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 == INT32_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 = __gethostbyaddr2_r (addr, addrlen, addrfamily,
 237                                                    &he_mem, tmpbuf, tmpbuflen,
 238                                                    &he, &herrno, NULL);
 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) + (ttl == INT32_MAX
 289                                                      ? db->postimeout : ttl);
 290
 291               dataset->resp.version = NSCD_VERSION;
 292               dataset->resp.found = 1;
 293               dataset->resp.naddrs = naddrs;
 294               dataset->resp.addrslen = addrslen;
 295               dataset->resp.canonlen = canonlen;
 296               dataset->resp.error = NETDB_SUCCESS;
 297
 298               char *addrs = (char *) (&dataset->resp + 1);
 299               uint8_t *family = (uint8_t *) (addrs + addrslen);
 300
 301               for (int j = 0; j < 2; ++j)
 302                 if (status[j] == NSS_STATUS_SUCCESS)
 303                   for (int i = 0; th[j].h_addr_list[i] != NULL; ++i)
 304                     {
 305                       addrs = mempcpy (addrs, th[j].h_addr_list[i],
 306                                        th[j].h_length);
 307                       *family++ = th[j].h_addrtype;
 308                     }
 309
 310               void *cp = family;
 311               if (canon != NULL)
 312                 cp = mempcpy (cp, canon, canonlen);
 313
 314               key_copy = memcpy (cp, key, req->key_len);
 315
 316               /* Now we can determine whether on refill we have to
 317                  create a new record or not.  */
 318               if (he != NULL)
 319                 {
 320                   assert (fd == -1);
 321
 322                   if (total + req->key_len == dh->allocsize
 323                       && total - offsetof (struct dataset, resp) == dh->recsize
 324                       && memcmp (&dataset->resp, dh->data,
 325                                  dh->allocsize
 326                                  - offsetof (struct dataset, resp)) == 0)
 327                     {
 328                       /* The data has not changed.  We will just bump the
 329                          timeout value.  Note that the new record has been
 330                          allocated on the stack and need not be freed.  */
 331                       dh->timeout = dataset->head.timeout;
 332                       ++dh->nreloads;
 333                     }
 334                   else
 335                     {
 336                       /* We have to create a new record.  Just allocate
 337                          appropriate memory and copy it.  */
 338                       struct dataset *newp
 339                         = (struct dataset *) mempool_alloc (db,
 340                                                             total
 341                                                             + req->key_len);
 342                       if (newp != NULL)
 343                         {
 344                           /* Adjust pointer into the memory block.  */
 345                           key_copy = (char *) newp + (key_copy
 346                                                       - (char *) dataset);
 347
 348                           dataset = memcpy (newp, dataset,
 349                                             total + req->key_len);
 350                           alloca_used = false;
 351                         }
 352
 353                       /* Mark the old record as obsolete.  */
 354                       dh->usable = false;
 355                     }
 356                 }
 357               else
 358                 {
 359                   /* We write the dataset before inserting it to the
 360                      database since while inserting this thread might
 361                      block and so would unnecessarily let the receiver
 362                      wait.  */
 363                   assert (fd != -1);
 364
 365 #ifdef HAVE_SENDFILE
 366                   if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
 367                     {
 368                       assert (db->wr_fd != -1);
 369                       assert ((char *) &dataset->resp > (char *) db->data);
 370                       assert ((char *) &dataset->resp - (char *) db->head
 371                               + total
 372                               <= (sizeof (struct database_pers_head)
 373                                   + db->head->module * sizeof (ref_t)
 374                                   + db->head->data_size));
 375                       ssize_t written;
 376                       written = sendfileall (fd, db->wr_fd,
 377                                              (char *) &dataset->resp
 378                                              - (char *) db->head, total);
 379 # ifndef __ASSUME_SENDFILE
 380                       if (written == -1 && errno == ENOSYS)
 381                         goto use_write;
 382 # endif
 383                     }
 384                   else
 385 # ifndef __ASSUME_SENDFILE
 386                   use_write:
 387 # endif
 388 #endif
 389                     writeall (fd, &dataset->resp, total);
 390                 }
 391
 392               goto out;
 393             }
 394
 395         }
 396
 397       if (nss_next_action (nip, status[1]) == NSS_ACTION_RETURN)
 398         break;
 399
 400       if (nip->next == NULL)
 401         no_more = -1;
 402       else
 403         nip = nip->next;
 404     }
 405
 406   /* No result found.  Create a negative result record.  */
 407   if (he != NULL && rc4 == EAGAIN)
 408     {
 409       /* If we have an old record available but cannot find one now
 410          because the service is not available we keep the old record
 411          and make sure it does not get removed.  */
 412       if (reload_count != UINT_MAX && dh->nreloads == reload_count)
 413         /* Do not reset the value if we never not reload the record.  */
 414         dh->nreloads = reload_count - 1;
 415     }
 416   else
 417     {
 418       /* We have no data.  This means we send the standard reply for
 419          this case.  */
 420       total = sizeof (notfound);
 421
 422       if (fd != -1)
 423         TEMP_FAILURE_RETRY (send (fd, &notfound, total, MSG_NOSIGNAL));
 424
 425       dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len);
 426       /* If we cannot permanently store the result, so be it.  */
 427       if (dataset != NULL)
 428         {
 429           dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
 430           dataset->head.recsize = total;
 431           dataset->head.notfound = true;
 432           dataset->head.nreloads = 0;
 433           dataset->head.usable = true;
 434
 435           /* Compute the timeout time.  */
 436           dataset->head.timeout = time (NULL) + db->negtimeout;
 437
 438           /* This is the reply.  */
 439           memcpy (&dataset->resp, &notfound, total);
 440
 441           /* Copy the key data.  */
 442           key_copy = memcpy (dataset->strdata, key, req->key_len);
 443         }
 444       else
 445         ++db->head->addfailed;
 446    }
 447
 448  out:
 449   _res.options = old_res_options;
 450
 451   if (dataset != NULL && !alloca_used)
 452     {
 453       /* If necessary, we also propagate the data to disk.  */
 454       if (db->persistent)
 455         {
 456           // XXX async OK?
 457           uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
 458           msync ((void *) pval,
 459                  ((uintptr_t) dataset & pagesize_m1) + total + req->key_len,
 460                  MS_ASYNC);
 461         }
 462
 463       /* Now get the lock to safely insert the records.  */
 464       pthread_rwlock_rdlock (&db->lock);
 465
 466       if (cache_add (req->type, key_copy, req->key_len, &dataset->head, true,
 467                      db, uid) < 0)
 468         /* Ensure the data can be recovered.  */
 469         dataset->head.usable = false;
 470
 471       pthread_rwlock_unlock (&db->lock);
 472
 473       /* Mark the old entry as obsolete.  */
 474       if (dh != NULL)
 475         dh->usable = false;
 476     }
 477 }
 478
 479
 480 void
 481 addhstai (struct database_dyn *db, int fd, request_header *req, void *key,
 482           uid_t uid)
 483 {
 484   addhstaiX (db, fd, req, key, uid, NULL, NULL);
 485 }
 486
 487
 488 void
 489 readdhstai (struct database_dyn *db, struct hashentry *he, struct datahead *dh)
 490 {
 491   request_header req =
 492     {
 493       .type = GETAI,
 494       .key_len = he->len
 495     };
 496
 497   addhstaiX (db, -1, &req, db->data + he->key, he->owner, he, dh);
 498 }