nscd/pwdcache.c

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