nscd/servicescache.c

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