nscd/grpcache.c

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