nscd/pwdcache.c

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