nscd/servicescache.c

   1 /* Cache handling for services lookup.
   2    Copyright (C) 2007 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@drepper.com>, 2007.
   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 <alloca.h>
  21 #include <assert.h>
  22 #include <errno.h>
  23 #include <libintl.h>
  24 #include <netdb.h>
  25 #include <unistd.h>
  26 #include <sys/mman.h>
  27 #include <kernel-features.h>
  28
  29 #include "nscd.h"
  30 #include "dbg_log.h"
  31
  32
  33 /* This is the standard reply in case the service is disabled.  */
  34 static const serv_response_header disabled =
  35 {
  36   .version = NSCD_VERSION,
  37   .found = -1,
  38   .s_name_len = 0,
  39   .s_proto_len = 0,
  40   .s_aliases_cnt = 0,
  41   .s_port = -1
  42 };
  43
  44 /* This is the struct describing how to write this record.  */
  45 const struct iovec serv_iov_disabled =
  46 {
  47   .iov_base = (void *) &disabled,
  48   .iov_len = sizeof (disabled)
  49 };
  50
  51
  52 /* This is the standard reply in case we haven't found the dataset.  */
  53 static const serv_response_header notfound =
  54 {
  55   .version = NSCD_VERSION,
  56   .found = 0,
  57   .s_name_len = 0,
  58   .s_proto_len = 0,
  59   .s_aliases_cnt = 0,
  60   .s_port = -1
  61 };
  62
  63
  64 static void
  65 cache_addserv (struct database_dyn *db, int fd, request_header *req,
  66                const void *key, struct servent *serv, uid_t owner,
  67                struct hashentry *he, struct datahead *dh, int errval)
  68 {
  69   ssize_t total;
  70   ssize_t written;
  71   time_t t = time (NULL);
  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     serv_response_header resp;
  79     char strdata[0];
  80   } *dataset;
  81
  82   assert (offsetof (struct dataset, resp) == offsetof (struct datahead, data));
  83
  84   if (serv == NULL)
  85     {
  86       if (he != NULL && errval == EAGAIN)
  87         {
  88           /* If we have an old record available but cannot find one
  89              now because the service is not available we keep the old
  90              record and make sure it does not get removed.  */
  91           if (reload_count != UINT_MAX)
  92             /* Do not reset the value if we never not reload the record.  */
  93             dh->nreloads = reload_count - 1;
  94
  95           written = total = 0;
  96         }
  97       else
  98         {
  99           /* We have no data.  This means we send the standard reply for this
 100              case.  */
 101           total = sizeof (notfound);
 102
 103           written = TEMP_FAILURE_RETRY (send (fd, &notfound, total,
 104                                               MSG_NOSIGNAL));
 105
 106           dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len);
 107           /* If we cannot permanently store the result, so be it.  */
 108           if (dataset != NULL)
 109             {
 110               dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
 111               dataset->head.recsize = total;
 112               dataset->head.notfound = true;
 113               dataset->head.nreloads = 0;
 114               dataset->head.usable = true;
 115
 116               /* Compute the timeout time.  */
 117               dataset->head.timeout = t + db->negtimeout;
 118
 119               /* This is the reply.  */
 120               memcpy (&dataset->resp, &notfound, total);
 121
 122               /* Copy the key data.  */
 123               memcpy (dataset->strdata, key, req->key_len);
 124
 125               /* If necessary, we also propagate the data to disk.  */
 126               if (db->persistent)
 127                 {
 128                   // XXX async OK?
 129                   uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
 130                   msync ((void *) pval,
 131                          ((uintptr_t) dataset & pagesize_m1)
 132                          + sizeof (struct dataset) + req->key_len, MS_ASYNC);
 133                 }
 134
 135               /* Now get the lock to safely insert the records.  */
 136               pthread_rwlock_rdlock (&db->lock);
 137
 138               if (cache_add (req->type, &dataset->strdata, req->key_len,
 139                              &dataset->head, true, db, owner) < 0)
 140                 /* Ensure the data can be recovered.  */
 141                 dataset->head.usable = false;
 142
 143               pthread_rwlock_unlock (&db->lock);
 144
 145               /* Mark the old entry as obsolete.  */
 146               if (dh != NULL)
 147                 dh->usable = false;
 148             }
 149           else
 150             ++db->head->addfailed;
 151         }
 152     }
 153   else
 154     {
 155       /* Determine the I/O structure.  */
 156       size_t s_name_len = strlen (serv->s_name) + 1;
 157       size_t s_proto_len = strlen (serv->s_proto) + 1;
 158       uint32_t *s_aliases_len;
 159       size_t s_aliases_cnt;
 160       char *aliases;
 161       char *cp;
 162       size_t cnt;
 163
 164       /* Determine the number of aliases.  */
 165       s_aliases_cnt = 0;
 166       for (cnt = 0; serv->s_aliases[cnt] != NULL; ++cnt)
 167         ++s_aliases_cnt;
 168       /* Determine the length of all aliases.  */
 169       s_aliases_len = (uint32_t *) alloca (s_aliases_cnt * sizeof (uint32_t));
 170       total = 0;
 171       for (cnt = 0; cnt < s_aliases_cnt; ++cnt)
 172         {
 173           s_aliases_len[cnt] = strlen (serv->s_aliases[cnt]) + 1;
 174           total += s_aliases_len[cnt];
 175         }
 176
 177       total += (sizeof (struct dataset)
 178                 + s_name_len
 179                 + s_proto_len
 180                 + s_aliases_cnt * sizeof (uint32_t));
 181       written = total;
 182
 183       /* If we refill the cache, first assume the reconrd did not
 184          change.  Allocate memory on the cache since it is likely
 185          discarded anyway.  If it turns out to be necessary to have a
 186          new record we can still allocate real memory.  */
 187       bool alloca_used = false;
 188       dataset = NULL;
 189
 190       if (he == NULL)
 191         {
 192           dataset = (struct dataset *) mempool_alloc (db,
 193                                                       total + req->key_len);
 194           if (dataset == NULL)
 195             ++db->head->addfailed;
 196         }
 197
 198       if (dataset == NULL)
 199         {
 200           /* We cannot permanently add the result in the moment.  But
 201              we can provide the result as is.  Store the data in some
 202              temporary memory.  */
 203           dataset = (struct dataset *) alloca (total + req->key_len);
 204
 205           /* We cannot add this record to the permanent database.  */
 206           alloca_used = true;
 207         }
 208
 209       dataset->head.allocsize = total + req->key_len;
 210       dataset->head.recsize = total - offsetof (struct dataset, resp);
 211       dataset->head.notfound = false;
 212       dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
 213       dataset->head.usable = true;
 214
 215       /* Compute the timeout time.  */
 216       dataset->head.timeout = t + db->postimeout;
 217
 218       dataset->resp.version = NSCD_VERSION;
 219       dataset->resp.found = 1;
 220       dataset->resp.s_name_len = s_name_len;
 221       dataset->resp.s_proto_len = s_proto_len;
 222       dataset->resp.s_port = serv->s_port;
 223       dataset->resp.s_aliases_cnt = s_aliases_cnt;
 224
 225       cp = dataset->strdata;
 226
 227       cp = mempcpy (cp, serv->s_name, s_name_len);
 228       cp = mempcpy (cp, serv->s_proto, s_proto_len);
 229       cp = mempcpy (cp, s_aliases_len, s_aliases_cnt * sizeof (uint32_t));
 230
 231       /* Then the aliases.  */
 232       aliases = cp;
 233       for (cnt = 0; cnt < s_aliases_cnt; ++cnt)
 234         cp = mempcpy (cp, serv->s_aliases[cnt], s_aliases_len[cnt]);
 235
 236       assert (cp
 237               == dataset->strdata + total - offsetof (struct dataset,
 238                                                       strdata));
 239
 240       char *key_copy = memcpy (cp, key, req->key_len);
 241
 242       /* Now we can determine whether on refill we have to create a new
 243          record or not.  */
 244       if (he != NULL)
 245         {
 246           assert (fd == -1);
 247
 248           if (total + req->key_len == dh->allocsize
 249               && total - offsetof (struct dataset, resp) == dh->recsize
 250               && memcmp (&dataset->resp, dh->data,
 251                          dh->allocsize - offsetof (struct dataset, resp)) == 0)
 252             {
 253               /* The data has not changed.  We will just bump the
 254                  timeout value.  Note that the new record has been
 255                  allocated on the stack and need not be freed.  */
 256               dh->timeout = dataset->head.timeout;
 257               ++dh->nreloads;
 258             }
 259           else
 260             {
 261               /* We have to create a new record.  Just allocate
 262                  appropriate memory and copy it.  */
 263               struct dataset *newp
 264                 = (struct dataset *) mempool_alloc (db, total + req->key_len);
 265               if (newp != NULL)
 266                 {
 267                   /* Adjust pointers into the memory block.  */
 268                   aliases = (char *) newp + (aliases - (char *) dataset);
 269                   assert (key_copy != NULL);
 270                   key_copy = (char *) newp + (key_copy - (char *) dataset);
 271
 272                   dataset = memcpy (newp, dataset, total + req->key_len);
 273                   alloca_used = false;
 274                 }
 275
 276               /* Mark the old record as obsolete.  */
 277               dh->usable = false;
 278             }
 279         }
 280       else
 281         {
 282           /* We write the dataset before inserting it to the database
 283              since while inserting this thread might block and so would
 284              unnecessarily keep the receiver waiting.  */
 285           assert (fd != -1);
 286
 287 #ifdef HAVE_SENDFILE
 288           if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
 289             {
 290               assert (db->wr_fd != -1);
 291               assert ((char *) &dataset->resp > (char *) db->data);
 292               assert ((char *) &dataset->resp - (char *) db->head
 293                       + total
 294                       <= (sizeof (struct database_pers_head)
 295                           + db->head->module * sizeof (ref_t)
 296                           + db->head->data_size));
 297               written = sendfileall (fd, db->wr_fd,
 298                                      (char *) &dataset->resp
 299                                      - (char *) db->head, total);
 300 # ifndef __ASSUME_SENDFILE
 301               if (written == -1 && errno == ENOSYS)
 302                 goto use_write;
 303 # endif
 304             }
 305           else
 306 # ifndef __ASSUME_SENDFILE
 307           use_write:
 308 # endif
 309 #endif
 310             written = writeall (fd, &dataset->resp, total);
 311         }
 312
 313       /* Add the record to the database.  But only if it has not been
 314          stored on the stack.  */
 315       if (! alloca_used)
 316         {
 317           /* If necessary, we also propagate the data to disk.  */
 318           if (db->persistent)
 319             {
 320               // XXX async OK?
 321               uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
 322               msync ((void *) pval,
 323                      ((uintptr_t) dataset & pagesize_m1)
 324                      + total + req->key_len, MS_ASYNC);
 325             }
 326
 327           /* Now get the lock to safely insert the records.  */
 328           pthread_rwlock_rdlock (&db->lock);
 329
 330           if (cache_add (req->type, key_copy, req->key_len,
 331                          &dataset->head, true, db, owner) < 0)
 332             /* Could not allocate memory.  Make sure the
 333                data gets discarded.  */
 334             dataset->head.usable = false;
 335
 336           pthread_rwlock_unlock (&db->lock);
 337         }
 338     }
 339
 340   if (__builtin_expect (written != total, 0) && debug_level > 0)
 341     {
 342       char buf[256];
 343       dbg_log (_("short write in %s: %s"),  __FUNCTION__,
 344                strerror_r (errno, buf, sizeof (buf)));
 345     }
 346 }
 347
 348
 349 static int
 350 lookup (int type, char *key, struct servent *resultbufp, char *buffer,
 351         size_t buflen, struct servent **serv)
 352 {
 353   char *proto = strrchr (key, '/');
 354   if (proto != NULL && proto != key)
 355     {
 356       key = strndupa (key, proto - key);
 357       if (proto[1] == '\0')
 358         proto = NULL;
 359       else
 360         ++proto;
 361     }
 362
 363   if (type == GETSERVBYNAME)
 364     return __getservbyname_r (key, proto, resultbufp, buffer, buflen, serv);
 365
 366   assert (type == GETSERVBYPORT);
 367   return __getservbyport_r (atol (key), proto, resultbufp, buffer, buflen,
 368                             serv);
 369 }
 370
 371
 372 static void
 373 addservbyX (struct database_dyn *db, int fd, request_header *req,
 374             char *key, uid_t uid, struct hashentry *he, struct datahead *dh)
 375 {
 376   /* Search for the entry matching the key.  Please note that we don't
 377      look again in the table whether the dataset is now available.  We
 378      simply insert it.  It does not matter if it is in there twice.  The
 379      pruning function only will look at the timestamp.  */
 380   size_t buflen = 1024;
 381   char *buffer = (char *) alloca (buflen);
 382   struct servent resultbuf;
 383   struct servent *serv;
 384   bool use_malloc = false;
 385   int errval = 0;
 386
 387   if (__builtin_expect (debug_level > 0, 0))
 388     {
 389       if (he == NULL)
 390         dbg_log (_("Haven't found \"%s\" in services cache!"), key);
 391       else
 392         dbg_log (_("Reloading \"%s\" in services cache!"), key);
 393     }
 394
 395   while (lookup (req->type, key, &resultbuf, buffer, buflen, &serv) != 0
 396          && (errval = errno) == ERANGE)
 397     {
 398       errno = 0;
 399
 400       if (__builtin_expect (buflen > 32768, 0))
 401         {
 402           char *old_buffer = buffer;
 403           buflen *= 2;
 404           buffer = (char *) realloc (use_malloc ? buffer : NULL, buflen);
 405           if (buffer == NULL)
 406             {
 407               /* We ran out of memory.  We cannot do anything but
 408                  sending a negative response.  In reality this should
 409                  never happen.  */
 410               serv = NULL;
 411               buffer = old_buffer;
 412
 413               /* We set the error to indicate this is (possibly) a
 414                  temporary error and that it does not mean the entry
 415                  is not available at all.  */
 416               errval = EAGAIN;
 417               break;
 418             }
 419           use_malloc = true;
 420         }
 421       else
 422         /* Allocate a new buffer on the stack.  If possible combine it
 423            with the previously allocated buffer.  */
 424         buffer = (char *) extend_alloca (buffer, buflen, 2 * buflen);
 425     }
 426
 427   cache_addserv (db, fd, req, key, serv, uid, he, dh, errval);
 428
 429   if (use_malloc)
 430     free (buffer);
 431 }
 432
 433
 434 void
 435 addservbyname (struct database_dyn *db, int fd, request_header *req,
 436                void *key, uid_t uid)
 437 {
 438   addservbyX (db, fd, req, key, uid, NULL, NULL);
 439 }
 440
 441
 442 void
 443 readdservbyname (struct database_dyn *db, struct hashentry *he,
 444                  struct datahead *dh)
 445 {
 446   request_header req =
 447     {
 448       .type = GETSERVBYNAME,
 449       .key_len = he->len
 450     };
 451
 452   addservbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
 453 }
 454
 455
 456 void
 457 addservbyport (struct database_dyn *db, int fd, request_header *req,
 458                void *key, uid_t uid)
 459 {
 460   addservbyX (db, fd, req, key, uid, NULL, NULL);
 461 }
 462
 463
 464 void
 465 readdservbyport (struct database_dyn *db, struct hashentry *he,
 466                  struct datahead *dh)
 467 {
 468   request_header req =
 469     {
 470       .type = GETSERVBYPORT,
 471       .key_len = he->len
 472     };
 473
 474   addservbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
 475 }