nscd/grpcache.c

   1 /* Cache handling for group lookup.
   2    Copyright (C) 1998-2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library 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 GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 #include <alloca.h>
  22 #include <assert.h>
  23 #include <errno.h>
  24 #include <error.h>
  25 #include <grp.h>
  26 #include <libintl.h>
  27 #include <stdbool.h>
  28 #include <stddef.h>
  29 #include <stdio.h>
  30 #include <stdint.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <unistd.h>
  34 #include <sys/mman.h>
  35 #include <stackinfo.h>
  36
  37 #include "nscd.h"
  38 #include "dbg_log.h"
  39
  40 /* This is the standard reply in case the service is disabled.  */
  41 static const gr_response_header disabled =
  42 {
  43   .version = NSCD_VERSION,
  44   .found = -1,
  45   .gr_name_len = 0,
  46   .gr_passwd_len = 0,
  47   .gr_gid = -1,
  48   .gr_mem_cnt = 0,
  49 };
  50
  51 /* This is the struct describing how to write this record.  */
  52 const struct iovec grp_iov_disabled =
  53 {
  54   .iov_base = (void *) &disabled,
  55   .iov_len = sizeof (disabled)
  56 };
  57
  58
  59 /* This is the standard reply in case we haven't found the dataset.  */
  60 static const gr_response_header notfound =
  61 {
  62   .version = NSCD_VERSION,
  63   .found = 0,
  64   .gr_name_len = 0,
  65   .gr_passwd_len = 0,
  66   .gr_gid = -1,
  67   .gr_mem_cnt = 0,
  68 };
  69
  70
  71 static void
  72 cache_addgr (struct database_dyn *db, int fd, request_header *req,
  73              const void *key, struct group *grp, uid_t owner,
  74              struct hashentry *he, struct datahead *dh, int errval)
  75 {
  76   ssize_t total;
  77   ssize_t written;
  78   time_t t = time (NULL);
  79
  80   /* We allocate all data in one memory block: the iov vector,
  81      the response header and the dataset itself.  */
  82   struct dataset
  83   {
  84     struct datahead head;
  85     gr_response_header resp;
  86     char strdata[0];
  87   } *dataset;
  88
  89   assert (offsetof (struct dataset, resp) == offsetof (struct datahead, data));
  90
  91   if (grp == NULL)
  92     {
  93       if (he != NULL && errval == EAGAIN)
  94         {
  95           /* If we have an old record available but cannot find one
  96              now because the service is not available we keep the old
  97              record and make sure it does not get removed.  */
  98           if (reload_count != UINT_MAX)
  99             /* Do not reset the value if we never not reload the record.  */
 100             dh->nreloads = reload_count - 1;
 101
 102           written = total = 0;
 103         }
 104       else
 105         {
 106           /* We have no data.  This means we send the standard reply for this
 107              case.  */
 108           total = sizeof (notfound);
 109
 110           written = TEMP_FAILURE_RETRY (send (fd, &notfound, total,
 111                                               MSG_NOSIGNAL));
 112
 113           dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len);
 114           /* If we cannot permanently store the result, so be it.  */
 115           if (dataset != NULL)
 116             {
 117               dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
 118               dataset->head.recsize = total;
 119               dataset->head.notfound = true;
 120               dataset->head.nreloads = 0;
 121               dataset->head.usable = true;
 122
 123               /* Compute the timeout time.  */
 124               dataset->head.timeout = t + db->negtimeout;
 125
 126               /* This is the reply.  */
 127               memcpy (&dataset->resp, &notfound, total);
 128
 129               /* Copy the key data.  */
 130               memcpy (dataset->strdata, key, req->key_len);
 131
 132               /* If necessary, we also propagate the data to disk.  */
 133               if (db->persistent)
 134                 {
 135                   // XXX async OK?
 136                   uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
 137                   msync ((void *) pval,
 138                          ((uintptr_t) dataset & pagesize_m1)
 139                          + sizeof (struct dataset) + req->key_len, MS_ASYNC);
 140                 }
 141
 142               /* Now get the lock to safely insert the records.  */
 143               pthread_rwlock_rdlock (&db->lock);
 144
 145               if (cache_add (req->type, &dataset->strdata, req->key_len,
 146                              &dataset->head, true, db, owner) < 0)
 147                 /* Ensure the data can be recovered.  */
 148                 dataset->head.usable = false;
 149
 150               pthread_rwlock_unlock (&db->lock);
 151
 152               /* Mark the old entry as obsolete.  */
 153               if (dh != NULL)
 154                 dh->usable = false;
 155             }
 156           else
 157             ++db->head->addfailed;
 158         }
 159     }
 160   else
 161     {
 162       /* Determine the I/O structure.  */
 163       size_t gr_name_len = strlen (grp->gr_name) + 1;
 164       size_t gr_passwd_len = strlen (grp->gr_passwd) + 1;
 165       size_t gr_mem_cnt = 0;
 166       uint32_t *gr_mem_len;
 167       size_t gr_mem_len_total = 0;
 168       char *gr_name;
 169       char *cp;
 170       const size_t key_len = strlen (key);
 171       const size_t buf_len = 3 * sizeof (grp->gr_gid) + key_len + 1;
 172       char *buf = alloca (buf_len);
 173       ssize_t n;
 174       size_t cnt;
 175
 176       /* We need this to insert the `bygid' entry.  */
 177       int key_offset;
 178       n = snprintf (buf, buf_len, "%d%c%n%s", grp->gr_gid, '\0',
 179                     &key_offset, (char *) key) + 1;
 180
 181       /* Determine the length of all members.  */
 182       while (grp->gr_mem[gr_mem_cnt])
 183         ++gr_mem_cnt;
 184       gr_mem_len = (uint32_t *) alloca (gr_mem_cnt * sizeof (uint32_t));
 185       for (gr_mem_cnt = 0; grp->gr_mem[gr_mem_cnt]; ++gr_mem_cnt)
 186         {
 187           gr_mem_len[gr_mem_cnt] = strlen (grp->gr_mem[gr_mem_cnt]) + 1;
 188           gr_mem_len_total += gr_mem_len[gr_mem_cnt];
 189         }
 190
 191       written = total = (sizeof (struct dataset)
 192                          + gr_mem_cnt * sizeof (uint32_t)
 193                          + gr_name_len + gr_passwd_len + gr_mem_len_total);
 194
 195       /* If we refill the cache, first assume the reconrd did not
 196          change.  Allocate memory on the cache since it is likely
 197          discarded anyway.  If it turns out to be necessary to have a
 198          new record we can still allocate real memory.  */
 199       bool alloca_used = false;
 200       dataset = NULL;
 201
 202       if (he == NULL)
 203         {
 204           dataset = (struct dataset *) mempool_alloc (db, total + n);
 205           if (dataset == NULL)
 206             ++db->head->addfailed;
 207         }
 208
 209       if (dataset == NULL)
 210         {
 211           /* We cannot permanently add the result in the moment.  But
 212              we can provide the result as is.  Store the data in some
 213              temporary memory.  */
 214           dataset = (struct dataset *) alloca (total + n);
 215
 216           /* We cannot add this record to the permanent database.  */
 217           alloca_used = true;
 218         }
 219
 220       dataset->head.allocsize = total + n;
 221       dataset->head.recsize = total - offsetof (struct dataset, resp);
 222       dataset->head.notfound = false;
 223       dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
 224       dataset->head.usable = true;
 225
 226       /* Compute the timeout time.  */
 227       dataset->head.timeout = t + db->postimeout;
 228
 229       dataset->resp.version = NSCD_VERSION;
 230       dataset->resp.found = 1;
 231       dataset->resp.gr_name_len = gr_name_len;
 232       dataset->resp.gr_passwd_len = gr_passwd_len;
 233       dataset->resp.gr_gid = grp->gr_gid;
 234       dataset->resp.gr_mem_cnt = gr_mem_cnt;
 235
 236       cp = dataset->strdata;
 237
 238       /* This is the member string length array.  */
 239       cp = mempcpy (cp, gr_mem_len, gr_mem_cnt * sizeof (uint32_t));
 240       gr_name = cp;
 241       cp = mempcpy (cp, grp->gr_name, gr_name_len);
 242       cp = mempcpy (cp, grp->gr_passwd, gr_passwd_len);
 243
 244       for (cnt = 0; cnt < gr_mem_cnt; ++cnt)
 245         cp = mempcpy (cp, grp->gr_mem[cnt], gr_mem_len[cnt]);
 246
 247       /* Finally the stringified GID value.  */
 248       memcpy (cp, buf, n);
 249       char *key_copy = cp + key_offset;
 250       assert (key_copy == (char *) rawmemchr (cp, '\0') + 1);
 251
 252       /* Now we can determine whether on refill we have to create a new
 253          record or not.  */
 254       if (he != NULL)
 255         {
 256           assert (fd == -1);
 257
 258           if (total + n == dh->allocsize
 259               && total - offsetof (struct dataset, resp) == dh->recsize
 260               && memcmp (&dataset->resp, dh->data,
 261                          dh->allocsize - offsetof (struct dataset, resp)) == 0)
 262             {
 263               /* The data has not changed.  We will just bump the
 264                  timeout value.  Note that the new record has been
 265                  allocated on the stack and need not be freed.  */
 266               dh->timeout = dataset->head.timeout;
 267               ++dh->nreloads;
 268             }
 269           else
 270             {
 271               /* We have to create a new record.  Just allocate
 272                  appropriate memory and copy it.  */
 273               struct dataset *newp
 274                 = (struct dataset *) mempool_alloc (db, total + n);
 275               if (newp != NULL)
 276                 {
 277                   /* Adjust pointers into the memory block.  */
 278                   gr_name = (char *) newp + (gr_name - (char *) dataset);
 279                   cp = (char *) newp + (cp - (char *) dataset);
 280
 281                   dataset = memcpy (newp, dataset, total + n);
 282                   alloca_used = false;
 283                 }
 284
 285               /* Mark the old record as obsolete.  */
 286               dh->usable = false;
 287             }
 288         }
 289       else
 290         {
 291           /* We write the dataset before inserting it to the database
 292              since while inserting this thread might block and so would
 293              unnecessarily let the receiver wait.  */
 294           assert (fd != -1);
 295
 296           written = writeall (fd, &dataset->resp, total);
 297         }
 298
 299       /* Add the record to the database.  But only if it has not been
 300          stored on the stack.  */
 301       if (! alloca_used)
 302         {
 303           /* If necessary, we also propagate the data to disk.  */
 304           if (db->persistent)
 305             {
 306               // XXX async OK?
 307               uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
 308               msync ((void *) pval,
 309                      ((uintptr_t) dataset & pagesize_m1) + total + n,
 310                      MS_ASYNC);
 311             }
 312
 313           /* Now get the lock to safely insert the records.  */
 314           pthread_rwlock_rdlock (&db->lock);
 315
 316           /* NB: in the following code we always must add the entry
 317              marked with FIRST first.  Otherwise we end up with
 318              dangling "pointers" in case a latter hash entry cannot be
 319              added.  */
 320           bool first = req->type == GETGRBYNAME;
 321
 322           /* If the request was by GID, add that entry first.  */
 323           if (req->type != GETGRBYNAME)
 324             {
 325               if (cache_add (GETGRBYGID, cp, key_offset, &dataset->head, true,
 326                              db, owner) < 0)
 327                 {
 328                   /* Could not allocate memory.  Make sure the data gets
 329                      discarded.  */
 330                   dataset->head.usable = false;
 331                   goto out;
 332                 }
 333             }
 334           /* If the key is different from the name add a separate entry.  */
 335           else if (strcmp (key_copy, gr_name) != 0)
 336             {
 337               if (cache_add (GETGRBYNAME, key_copy, key_len + 1,
 338                              &dataset->head, first, db, owner) < 0)
 339                 {
 340                   /* Could not allocate memory.  Make sure the data gets
 341                      discarded.  */
 342                   dataset->head.usable = false;
 343                   goto out;
 344                 }
 345
 346               first = false;
 347             }
 348
 349           /* We have to add the value for both, byname and byuid.  */
 350           if (__builtin_expect (cache_add (GETGRBYNAME, gr_name, gr_name_len,
 351                                            &dataset->head, first, db, owner)
 352                                 == 0, 1))
 353             {
 354               if (req->type == GETGRBYNAME)
 355                 (void) cache_add (GETGRBYGID, cp, key_offset, &dataset->head,
 356                                   req->type != GETGRBYNAME, db, owner);
 357             }
 358           else if (first)
 359             /* Could not allocate memory.  Make sure the data gets
 360                discarded.  */
 361             dataset->head.usable = false;
 362
 363         out:
 364           pthread_rwlock_unlock (&db->lock);
 365         }
 366     }
 367
 368   if (__builtin_expect (written != total, 0) && debug_level > 0)
 369     {
 370       char buf[256];
 371       dbg_log (_("short write in %s: %s"),  __FUNCTION__,
 372                strerror_r (errno, buf, sizeof (buf)));
 373     }
 374 }
 375
 376
 377 union keytype
 378 {
 379   void *v;
 380   gid_t g;
 381 };
 382
 383
 384 static int
 385 lookup (int type, union keytype key, struct group *resultbufp, char *buffer,
 386         size_t buflen, struct group **grp)
 387 {
 388   if (type == GETGRBYNAME)
 389     return __getgrnam_r (key.v, resultbufp, buffer, buflen, grp);
 390   else
 391     return __getgrgid_r (key.g, resultbufp, buffer, buflen, grp);
 392 }
 393
 394
 395 static void
 396 addgrbyX (struct database_dyn *db, int fd, request_header *req,
 397           union keytype key, const char *keystr, uid_t uid,
 398           struct hashentry *he, struct datahead *dh)
 399 {
 400   /* Search for the entry matching the key.  Please note that we don't
 401      look again in the table whether the dataset is now available.  We
 402      simply insert it.  It does not matter if it is in there twice.  The
 403      pruning function only will look at the timestamp.  */
 404   size_t buflen = 1024;
 405   char *buffer = (char *) alloca (buflen);
 406   struct group resultbuf;
 407   struct group *grp;
 408   bool use_malloc = false;
 409   int errval = 0;
 410
 411   if (__builtin_expect (debug_level > 0, 0))
 412     {
 413       if (he == NULL)
 414         dbg_log (_("Haven't found \"%s\" in group cache!"), keystr);
 415       else
 416         dbg_log (_("Reloading \"%s\" in group cache!"), keystr);
 417     }
 418
 419 #if 0
 420   uid_t oldeuid = 0;
 421   if (db->secure)
 422     {
 423       oldeuid = geteuid ();
 424       pthread_seteuid_np (uid);
 425     }
 426 #endif
 427
 428   while (lookup (req->type, key, &resultbuf, buffer, buflen, &grp) != 0
 429          && (errval = errno) == ERANGE)
 430     {
 431       char *old_buffer = buffer;
 432       errno = 0;
 433
 434       if (__builtin_expect (buflen > 32768, 0))
 435         {
 436           buflen *= 2;
 437           buffer = (char *) realloc (use_malloc ? buffer : NULL, buflen);
 438           if (buffer == NULL)
 439             {
 440               /* We ran out of memory.  We cannot do anything but
 441                  sending a negative response.  In reality this should
 442                  never happen.  */
 443               grp = NULL;
 444               buffer = old_buffer;
 445
 446               /* We set the error to indicate this is (possibly) a
 447                  temporary error and that it does not mean the entry
 448                  is not available at all.  */
 449               errval = EAGAIN;
 450               break;
 451             }
 452           use_malloc = true;
 453         }
 454       else
 455         /* Allocate a new buffer on the stack.  If possible combine it
 456            with the previously allocated buffer.  */
 457         buffer = (char *) extend_alloca (buffer, buflen, 2 * buflen);
 458     }
 459
 460 #if 0
 461   if (db->secure)
 462     pthread_seteuid_np (oldeuid);
 463 #endif
 464
 465   cache_addgr (db, fd, req, keystr, grp, uid, he, dh, errval);
 466
 467   if (use_malloc)
 468     free (buffer);
 469 }
 470
 471
 472 void
 473 addgrbyname (struct database_dyn *db, int fd, request_header *req,
 474              void *key, uid_t uid)
 475 {
 476   union keytype u = { .v = key };
 477
 478   addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
 479 }
 480
 481
 482 void
 483 readdgrbyname (struct database_dyn *db, struct hashentry *he,
 484                struct datahead *dh)
 485 {
 486   request_header req =
 487     {
 488       .type = GETGRBYNAME,
 489       .key_len = he->len
 490     };
 491   union keytype u = { .v = db->data + he->key };
 492
 493   addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);
 494 }
 495
 496
 497 void
 498 addgrbygid (struct database_dyn *db, int fd, request_header *req,
 499             void *key, uid_t uid)
 500 {
 501   char *ep;
 502   gid_t gid = strtoul ((char *) key, &ep, 10);
 503
 504   if (*(char *) key == '\0' || *ep != '\0')  /* invalid numeric uid */
 505     {
 506       if (debug_level > 0)
 507         dbg_log (_("Invalid numeric gid \"%s\"!"), (char *) key);
 508
 509       errno = EINVAL;
 510       return;
 511     }
 512
 513   union keytype u = { .g = gid };
 514
 515   addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
 516 }
 517
 518
 519 void
 520 readdgrbygid (struct database_dyn *db, struct hashentry *he,
 521               struct datahead *dh)
 522 {
 523   char *ep;
 524   gid_t gid = strtoul (db->data + he->key, &ep, 10);
 525
 526   /* Since the key has been added before it must be OK.  */
 527   assert (*(db->data + he->key) != '\0' && *ep == '\0');
 528
 529   request_header req =
 530     {
 531       .type = GETGRBYGID,
 532       .key_len = he->len
 533     };
 534   union keytype u = { .g = gid };
 535
 536   addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);
 537 }