nscd/initgrcache.c

   1 /* Cache handling for host lookup.
   2    Copyright (C) 2004-2013 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@redhat.com>, 2004.
   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, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include <assert.h>
  20 #include <errno.h>
  21 #include <grp.h>
  22 #include <libintl.h>
  23 #include <string.h>
  24 #include <time.h>
  25 #include <unistd.h>
  26 #include <sys/mman.h>
  27
  28 #include "dbg_log.h"
  29 #include "nscd.h"
  30 #ifdef HAVE_SENDFILE
  31 # include <kernel-features.h>
  32 #endif
  33
  34 #include "../nss/nsswitch.h"
  35
  36
  37 /* Type of the lookup function.  */
  38 typedef enum nss_status (*initgroups_dyn_function) (const char *, gid_t,
  39                                                     long int *, long int *,
  40                                                     gid_t **, long int, int *);
  41
  42
  43 static const initgr_response_header notfound =
  44 {
  45   .version = NSCD_VERSION,
  46   .found = 0,
  47   .ngrps = 0
  48 };
  49
  50
  51 #include "../grp/compat-initgroups.c"
  52
  53
  54 static time_t
  55 addinitgroupsX (struct database_dyn *db, int fd, request_header *req,
  56                 void *key, uid_t uid, struct hashentry *const he,
  57                 struct datahead *dh)
  58 {
  59   /* Search for the entry matching the key.  Please note that we don't
  60      look again in the table whether the dataset is now available.  We
  61      simply insert it.  It does not matter if it is in there twice.  The
  62      pruning function only will look at the timestamp.  */
  63
  64
  65   /* We allocate all data in one memory block: the iov vector,
  66      the response header and the dataset itself.  */
  67   struct dataset
  68   {
  69     struct datahead head;
  70     initgr_response_header resp;
  71     char strdata[0];
  72   } *dataset = NULL;
  73
  74   if (__builtin_expect (debug_level > 0, 0))
  75     {
  76       if (he == NULL)
  77         dbg_log (_("Haven't found \"%s\" in group cache!"), (char *) key);
  78       else
  79         dbg_log (_("Reloading \"%s\" in group cache!"), (char *) key);
  80     }
  81
  82   static service_user *group_database;
  83   service_user *nip = NULL;
  84   int no_more;
  85
  86   if (group_database != NULL)
  87     {
  88       nip = group_database;
  89       no_more = 0;
  90     }
  91   else
  92     no_more = __nss_database_lookup ("group", NULL,
  93                                      "compat [NOTFOUND=return] files", &nip);
  94
  95  /* We always use sysconf even if NGROUPS_MAX is defined.  That way, the
  96      limit can be raised in the kernel configuration without having to
  97      recompile libc.  */
  98   long int limit = __sysconf (_SC_NGROUPS_MAX);
  99
 100   long int size;
 101   if (limit > 0)
 102     /* We limit the size of the intially allocated array.  */
 103     size = MIN (limit, 64);
 104   else
 105     /* No fixed limit on groups.  Pick a starting buffer size.  */
 106     size = 16;
 107
 108   long int start = 0;
 109   bool all_tryagain = true;
 110   bool any_success = false;
 111
 112   /* This is temporary memory, we need not (and must not) call
 113      mempool_alloc.  */
 114   // XXX This really should use alloca.  need to change the backends.
 115   gid_t *groups = (gid_t *) malloc (size * sizeof (gid_t));
 116   if (__builtin_expect (groups == NULL, 0))
 117     /* No more memory.  */
 118     goto out;
 119
 120   /* Nothing added yet.  */
 121   while (! no_more)
 122     {
 123       long int prev_start = start;
 124       enum nss_status status;
 125       initgroups_dyn_function fct;
 126       fct = __nss_lookup_function (nip, "initgroups_dyn");
 127
 128       if (fct == NULL)
 129         {
 130           status = compat_call (nip, key, -1, &start, &size, &groups,
 131                                 limit, &errno);
 132
 133           if (nss_next_action (nip, NSS_STATUS_UNAVAIL) != NSS_ACTION_CONTINUE)
 134             break;
 135         }
 136       else
 137         status = DL_CALL_FCT (fct, (key, -1, &start, &size, &groups,
 138                                     limit, &errno));
 139
 140       /* Remove duplicates.  */
 141       long int cnt = prev_start;
 142       while (cnt < start)
 143         {
 144           long int inner;
 145           for (inner = 0; inner < prev_start; ++inner)
 146             if (groups[inner] == groups[cnt])
 147               break;
 148
 149           if (inner < prev_start)
 150             groups[cnt] = groups[--start];
 151           else
 152             ++cnt;
 153         }
 154
 155       if (status != NSS_STATUS_TRYAGAIN)
 156         all_tryagain = false;
 157
 158       /* This is really only for debugging.  */
 159       if (NSS_STATUS_TRYAGAIN > status || status > NSS_STATUS_RETURN)
 160         __libc_fatal ("illegal status in internal_getgrouplist");
 161
 162       any_success |= status == NSS_STATUS_SUCCESS;
 163
 164       if (status != NSS_STATUS_SUCCESS
 165           && nss_next_action (nip, status) == NSS_ACTION_RETURN)
 166          break;
 167
 168       if (nip->next == NULL)
 169         no_more = -1;
 170       else
 171         nip = nip->next;
 172     }
 173
 174   ssize_t total;
 175   ssize_t written;
 176   time_t timeout;
 177  out:
 178   timeout = MAX_TIMEOUT_VALUE;
 179   if (!any_success)
 180     {
 181       /* Nothing found.  Create a negative result record.  */
 182       written = total = sizeof (notfound);
 183
 184       if (he != NULL && all_tryagain)
 185         {
 186           /* If we have an old record available but cannot find one now
 187              because the service is not available we keep the old record
 188              and make sure it does not get removed.  */
 189           if (reload_count != UINT_MAX && dh->nreloads == reload_count)
 190             /* Do not reset the value if we never not reload the record.  */
 191             dh->nreloads = reload_count - 1;
 192
 193           /* Reload with the same time-to-live value.  */
 194           timeout = dh->timeout = time (NULL) + db->postimeout;
 195         }
 196       else
 197         {
 198           /* We have no data.  This means we send the standard reply for this
 199              case.  */
 200           if (fd != -1)
 201             written = TEMP_FAILURE_RETRY (send (fd, &notfound, total,
 202                                                 MSG_NOSIGNAL));
 203
 204           /* If we have a transient error or cannot permanently store
 205              the result, so be it.  */
 206           if (all_tryagain || __builtin_expect (db->negtimeout == 0, 0))
 207             {
 208               /* Mark the old entry as obsolete.  */
 209               if (dh != NULL)
 210                 dh->usable = false;
 211             }
 212           else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
 213                                                   + req->key_len), 1)) != NULL)
 214             {
 215               dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
 216               dataset->head.recsize = total;
 217               dataset->head.notfound = true;
 218               dataset->head.nreloads = 0;
 219               dataset->head.usable = true;
 220
 221               /* Compute the timeout time.  */
 222               timeout = dataset->head.timeout = time (NULL) + db->negtimeout;
 223
 224               /* This is the reply.  */
 225               memcpy (&dataset->resp, &notfound, total);
 226
 227               /* Copy the key data.  */
 228               char *key_copy = memcpy (dataset->strdata, key, req->key_len);
 229
 230               /* If necessary, we also propagate the data to disk.  */
 231               if (db->persistent)
 232                 {
 233                   // XXX async OK?
 234                   uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
 235                   msync ((void *) pval,
 236                          ((uintptr_t) dataset & pagesize_m1)
 237                          + sizeof (struct dataset) + req->key_len, MS_ASYNC);
 238                 }
 239
 240               (void) cache_add (req->type, key_copy, req->key_len,
 241                                 &dataset->head, true, db, uid, he == NULL);
 242
 243               pthread_rwlock_unlock (&db->lock);
 244
 245               /* Mark the old entry as obsolete.  */
 246               if (dh != NULL)
 247                 dh->usable = false;
 248             }
 249         }
 250     }
 251   else
 252     {
 253
 254       written = total = (offsetof (struct dataset, strdata)
 255                          + start * sizeof (int32_t));
 256
 257       /* If we refill the cache, first assume the reconrd did not
 258          change.  Allocate memory on the cache since it is likely
 259          discarded anyway.  If it turns out to be necessary to have a
 260          new record we can still allocate real memory.  */
 261       bool alloca_used = false;
 262       dataset = NULL;
 263
 264       if (he == NULL)
 265         dataset = (struct dataset *) mempool_alloc (db, total + req->key_len,
 266                                                     1);
 267
 268       if (dataset == NULL)
 269         {
 270           /* We cannot permanently add the result in the moment.  But
 271              we can provide the result as is.  Store the data in some
 272              temporary memory.  */
 273           dataset = (struct dataset *) alloca (total + req->key_len);
 274
 275           /* We cannot add this record to the permanent database.  */
 276           alloca_used = true;
 277         }
 278
 279       dataset->head.allocsize = total + req->key_len;
 280       dataset->head.recsize = total - offsetof (struct dataset, resp);
 281       dataset->head.notfound = false;
 282       dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
 283       dataset->head.usable = true;
 284
 285       /* Compute the timeout time.  */
 286       timeout = dataset->head.timeout = time (NULL) + db->postimeout;
 287
 288       dataset->resp.version = NSCD_VERSION;
 289       dataset->resp.found = 1;
 290       dataset->resp.ngrps = start;
 291
 292       char *cp = dataset->strdata;
 293
 294       /* Copy the GID values.  If the size of the types match this is
 295          very simple.  */
 296       if (sizeof (gid_t) == sizeof (int32_t))
 297         cp = mempcpy (cp, groups, start * sizeof (gid_t));
 298       else
 299         {
 300           gid_t *gcp = (gid_t *) cp;
 301
 302           for (int i = 0; i < start; ++i)
 303             *gcp++ = groups[i];
 304
 305           cp = (char *) gcp;
 306         }
 307
 308       /* Finally the user name.  */
 309       memcpy (cp, key, req->key_len);
 310
 311       assert (cp == dataset->strdata + total - offsetof (struct dataset,
 312                                                          strdata));
 313
 314       /* Now we can determine whether on refill we have to create a new
 315          record or not.  */
 316       if (he != NULL)
 317         {
 318           assert (fd == -1);
 319
 320           if (total + req->key_len == dh->allocsize
 321               && total - offsetof (struct dataset, resp) == dh->recsize
 322               && memcmp (&dataset->resp, dh->data,
 323                          dh->allocsize - offsetof (struct dataset, resp)) == 0)
 324             {
 325               /* The data has not changed.  We will just bump the
 326                  timeout value.  Note that the new record has been
 327                  allocated on the stack and need not be freed.  */
 328               dh->timeout = dataset->head.timeout;
 329               ++dh->nreloads;
 330             }
 331           else
 332             {
 333               /* We have to create a new record.  Just allocate
 334                  appropriate memory and copy it.  */
 335               struct dataset *newp
 336                 = (struct dataset *) mempool_alloc (db, total + req->key_len,
 337                                                     1);
 338               if (newp != NULL)
 339                 {
 340                   /* Adjust pointer into the memory block.  */
 341                   cp = (char *) newp + (cp - (char *) dataset);
 342
 343                   dataset = memcpy (newp, dataset, total + req->key_len);
 344                   alloca_used = false;
 345                 }
 346
 347               /* Mark the old record as obsolete.  */
 348               dh->usable = false;
 349             }
 350         }
 351       else
 352         {
 353           /* We write the dataset before inserting it to the database
 354              since while inserting this thread might block and so would
 355              unnecessarily let the receiver wait.  */
 356           assert (fd != -1);
 357
 358 #ifdef HAVE_SENDFILE
 359           if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
 360             {
 361               assert (db->wr_fd != -1);
 362               assert ((char *) &dataset->resp > (char *) db->data);
 363               assert ((char *) dataset - (char *) db->head
 364                       + total
 365                       <= (sizeof (struct database_pers_head)
 366                           + db->head->module * sizeof (ref_t)
 367                           + db->head->data_size));
 368               written = sendfileall (fd, db->wr_fd,
 369                                      (char *) &dataset->resp
 370                                      - (char *) db->head, dataset->head.recsize);
 371 # ifndef __ASSUME_SENDFILE
 372               if (written == -1 && errno == ENOSYS)
 373                 goto use_write;
 374 # endif
 375             }
 376           else
 377 # ifndef __ASSUME_SENDFILE
 378           use_write:
 379 # endif
 380 #endif
 381             written = writeall (fd, &dataset->resp, dataset->head.recsize);
 382         }
 383
 384
 385       /* Add the record to the database.  But only if it has not been
 386          stored on the stack.  */
 387       if (! alloca_used)
 388         {
 389           /* If necessary, we also propagate the data to disk.  */
 390           if (db->persistent)
 391             {
 392               // XXX async OK?
 393               uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
 394               msync ((void *) pval,
 395                      ((uintptr_t) dataset & pagesize_m1) + total +
 396                      req->key_len, MS_ASYNC);
 397             }
 398
 399           (void) cache_add (INITGROUPS, cp, req->key_len, &dataset->head, true,
 400                             db, uid, he == NULL);
 401
 402           pthread_rwlock_unlock (&db->lock);
 403         }
 404     }
 405
 406   free (groups);
 407
 408   if (__builtin_expect (written != total, 0) && debug_level > 0)
 409     {
 410       char buf[256];
 411       dbg_log (_("short write in %s: %s"), __FUNCTION__,
 412                strerror_r (errno, buf, sizeof (buf)));
 413     }
 414
 415   return timeout;
 416 }
 417
 418
 419 void
 420 addinitgroups (struct database_dyn *db, int fd, request_header *req, void *key,
 421                uid_t uid)
 422 {
 423   addinitgroupsX (db, fd, req, key, uid, NULL, NULL);
 424 }
 425
 426
 427 time_t
 428 readdinitgroups (struct database_dyn *db, struct hashentry *he,
 429                  struct datahead *dh)
 430 {
 431   request_header req =
 432     {
 433       .type = INITGROUPS,
 434       .key_len = he->len
 435     };
 436
 437   return addinitgroupsX (db, -1, &req, db->data + he->key, he->owner, he, dh);
 438 }