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