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.  */
 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 (__builtin_expect (newp != NULL, 1))
 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                       else
 353                         ++db->head->addfailed;
 354
 355                       /* Mark the old record as obsolete.  */
 356                       dh->usable = false;
 357                     }
 358                 }
 359               else
 360                 {
 361                   /* We write the dataset before inserting it to the
 362                      database since while inserting this thread might
 363                      block and so would unnecessarily let the receiver
 364                      wait.  */
 365                   assert (fd != -1);
 366
 367 #ifdef HAVE_SENDFILE
 368                   if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
 369                     {
 370                       assert (db->wr_fd != -1);
 371                       assert ((char *) &dataset->resp > (char *) db->data);
 372                       assert ((char *) &dataset->resp - (char *) db->head
 373                               + total
 374                               <= (sizeof (struct database_pers_head)
 375                                   + db->head->module * sizeof (ref_t)
 376                                   + db->head->data_size));
 377                       ssize_t written;
 378                       written = sendfileall (fd, db->wr_fd,
 379                                              (char *) &dataset->resp
 380                                              - (char *) db->head, total);
 381 # ifndef __ASSUME_SENDFILE
 382                       if (written == -1 && errno == ENOSYS)
 383                         goto use_write;
 384 # endif
 385                     }
 386                   else
 387 # ifndef __ASSUME_SENDFILE
 388                   use_write:
 389 # endif
 390 #endif
 391                     writeall (fd, &dataset->resp, total);
 392                 }
 393
 394               goto out;
 395             }
 396
 397         }
 398
 399       if (nss_next_action (nip, status[1]) == NSS_ACTION_RETURN)
 400         break;
 401
 402       if (nip->next == NULL)
 403         no_more = -1;
 404       else
 405         nip = nip->next;
 406     }
 407
 408   /* No result found.  Create a negative result record.  */
 409   if (he != NULL && rc4 == EAGAIN)
 410     {
 411       /* If we have an old record available but cannot find one now
 412          because the service is not available we keep the old record
 413          and make sure it does not get removed.  */
 414       if (reload_count != UINT_MAX && dh->nreloads == reload_count)
 415         /* Do not reset the value if we never not reload the record.  */
 416         dh->nreloads = reload_count - 1;
 417     }
 418   else
 419     {
 420       /* We have no data.  This means we send the standard reply for
 421          this case.  */
 422       total = sizeof (notfound);
 423
 424       if (fd != -1)
 425         TEMP_FAILURE_RETRY (send (fd, &notfound, total, MSG_NOSIGNAL));
 426
 427       dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len);
 428       /* If we cannot permanently store the result, so be it.  */
 429       if (dataset != NULL)
 430         {
 431           dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
 432           dataset->head.recsize = total;
 433           dataset->head.notfound = true;
 434           dataset->head.nreloads = 0;
 435           dataset->head.usable = true;
 436
 437           /* Compute the timeout time.  */
 438           dataset->head.timeout = time (NULL) + db->negtimeout;
 439
 440           /* This is the reply.  */
 441           memcpy (&dataset->resp, &notfound, total);
 442
 443           /* Copy the key data.  */
 444           key_copy = memcpy (dataset->strdata, key, req->key_len);
 445         }
 446       else
 447         ++db->head->addfailed;
 448    }
 449
 450  out:
 451   _res.options = old_res_options;
 452
 453   if (dataset != NULL && !alloca_used)
 454     {
 455       /* If necessary, we also propagate the data to disk.  */
 456       if (db->persistent)
 457         {
 458           // XXX async OK?
 459           uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
 460           msync ((void *) pval,
 461                  ((uintptr_t) dataset & pagesize_m1) + total + req->key_len,
 462                  MS_ASYNC);
 463         }
 464
 465       /* Now get the lock to safely insert the records.  */
 466       pthread_rwlock_rdlock (&db->lock);
 467
 468       if (cache_add (req->type, key_copy, req->key_len, &dataset->head, true,
 469                      db, uid) < 0)
 470         /* Ensure the data can be recovered.  */
 471         dataset->head.usable = false;
 472
 473       pthread_rwlock_unlock (&db->lock);
 474
 475       /* Mark the old entry as obsolete.  */
 476       if (dh != NULL)
 477         dh->usable = false;
 478     }
 479 }
 480
 481
 482 void
 483 addhstai (struct database_dyn *db, int fd, request_header *req, void *key,
 484           uid_t uid)
 485 {
 486   addhstaiX (db, fd, req, key, uid, NULL, NULL);
 487 }
 488
 489
 490 void
 491 readdhstai (struct database_dyn *db, struct hashentry *he, struct datahead *dh)
 492 {
 493   request_header req =
 494     {
 495       .type = GETAI,
 496       .key_len = he->len
 497     };
 498
 499   addhstaiX (db, -1, &req, db->data + he->key, he->owner, he, dh);
 500 }