1 /* Cache handling for group lookup.
2 Copyright (C) 1998-2005, 2006, 2007, 2008 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
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.
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.
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. */
34 #include <sys/socket.h>
35 #include <stackinfo.h>
40 # include <kernel-features.h>
43 /* This is the standard reply in case the service is disabled. */
44 static const gr_response_header disabled =
46 .version = NSCD_VERSION,
54 /* This is the struct describing how to write this record. */
55 const struct iovec grp_iov_disabled =
57 .iov_base = (void *) &disabled,
58 .iov_len = sizeof (disabled)
62 /* This is the standard reply in case we haven't found the dataset. */
63 static const gr_response_header notfound =
65 .version = NSCD_VERSION,
75 cache_addgr (struct database_dyn *db, int fd, request_header *req,
76 const void *key, struct group *grp, uid_t owner,
77 struct hashentry *he, struct datahead *dh, int errval)
81 time_t t = time (NULL);
83 /* We allocate all data in one memory block: the iov vector,
84 the response header and the dataset itself. */
88 gr_response_header resp;
92 assert (offsetof (struct dataset, resp) == offsetof (struct datahead, data));
96 if (he != NULL && errval == EAGAIN)
98 /* If we have an old record available but cannot find one
99 now because the service is not available we keep the old
100 record and make sure it does not get removed. */
101 if (reload_count != UINT_MAX)
102 /* Do not reset the value if we never not reload the record. */
103 dh->nreloads = reload_count - 1;
109 /* We have no data. This means we send the standard reply for this
111 total = sizeof (notfound);
113 written = TEMP_FAILURE_RETRY (send (fd, ¬found, total,
116 dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len,
118 /* If we cannot permanently store the result, so be it. */
121 dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
122 dataset->head.recsize = total;
123 dataset->head.notfound = true;
124 dataset->head.nreloads = 0;
125 dataset->head.usable = true;
127 /* Compute the timeout time. */
128 dataset->head.timeout = t + db->negtimeout;
130 /* This is the reply. */
131 memcpy (&dataset->resp, ¬found, total);
133 /* Copy the key data. */
134 memcpy (dataset->strdata, key, req->key_len);
136 /* If necessary, we also propagate the data to disk. */
140 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
141 msync ((void *) pval,
142 ((uintptr_t) dataset & pagesize_m1)
143 + sizeof (struct dataset) + req->key_len, MS_ASYNC);
146 /* Now get the lock to safely insert the records. */
147 pthread_rwlock_rdlock (&db->lock);
149 if (cache_add (req->type, &dataset->strdata, req->key_len,
150 &dataset->head, true, db, owner) < 0)
151 /* Ensure the data can be recovered. */
152 dataset->head.usable = false;
154 pthread_rwlock_unlock (&db->lock);
156 /* Mark the old entry as obsolete. */
161 ++db->head->addfailed;
166 /* Determine the I/O structure. */
167 size_t gr_name_len = strlen (grp->gr_name) + 1;
168 size_t gr_passwd_len = strlen (grp->gr_passwd) + 1;
169 size_t gr_mem_cnt = 0;
170 uint32_t *gr_mem_len;
171 size_t gr_mem_len_total = 0;
174 const size_t key_len = strlen (key);
175 const size_t buf_len = 3 * sizeof (grp->gr_gid) + key_len + 1;
176 char *buf = alloca (buf_len);
180 /* We need this to insert the `bygid' entry. */
182 n = snprintf (buf, buf_len, "%d%c%n%s", grp->gr_gid, '\0',
183 &key_offset, (char *) key) + 1;
185 /* Determine the length of all members. */
186 while (grp->gr_mem[gr_mem_cnt])
188 gr_mem_len = (uint32_t *) alloca (gr_mem_cnt * sizeof (uint32_t));
189 for (gr_mem_cnt = 0; grp->gr_mem[gr_mem_cnt]; ++gr_mem_cnt)
191 gr_mem_len[gr_mem_cnt] = strlen (grp->gr_mem[gr_mem_cnt]) + 1;
192 gr_mem_len_total += gr_mem_len[gr_mem_cnt];
195 written = total = (sizeof (struct dataset)
196 + gr_mem_cnt * sizeof (uint32_t)
197 + gr_name_len + gr_passwd_len + gr_mem_len_total);
199 /* If we refill the cache, first assume the reconrd did not
200 change. Allocate memory on the cache since it is likely
201 discarded anyway. If it turns out to be necessary to have a
202 new record we can still allocate real memory. */
203 bool alloca_used = false;
208 dataset = (struct dataset *) mempool_alloc (db, total + n,
211 ++db->head->addfailed;
216 /* We cannot permanently add the result in the moment. But
217 we can provide the result as is. Store the data in some
219 dataset = (struct dataset *) alloca (total + n);
221 /* We cannot add this record to the permanent database. */
225 dataset->head.allocsize = total + n;
226 dataset->head.recsize = total - offsetof (struct dataset, resp);
227 dataset->head.notfound = false;
228 dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
229 dataset->head.usable = true;
231 /* Compute the timeout time. */
232 dataset->head.timeout = t + db->postimeout;
234 dataset->resp.version = NSCD_VERSION;
235 dataset->resp.found = 1;
236 dataset->resp.gr_name_len = gr_name_len;
237 dataset->resp.gr_passwd_len = gr_passwd_len;
238 dataset->resp.gr_gid = grp->gr_gid;
239 dataset->resp.gr_mem_cnt = gr_mem_cnt;
241 cp = dataset->strdata;
243 /* This is the member string length array. */
244 cp = mempcpy (cp, gr_mem_len, gr_mem_cnt * sizeof (uint32_t));
246 cp = mempcpy (cp, grp->gr_name, gr_name_len);
247 cp = mempcpy (cp, grp->gr_passwd, gr_passwd_len);
249 for (cnt = 0; cnt < gr_mem_cnt; ++cnt)
250 cp = mempcpy (cp, grp->gr_mem[cnt], gr_mem_len[cnt]);
252 /* Finally the stringified GID value. */
254 char *key_copy = cp + key_offset;
255 assert (key_copy == (char *) rawmemchr (cp, '\0') + 1);
257 /* Now we can determine whether on refill we have to create a new
263 if (total + n == dh->allocsize
264 && total - offsetof (struct dataset, resp) == dh->recsize
265 && memcmp (&dataset->resp, dh->data,
266 dh->allocsize - offsetof (struct dataset, resp)) == 0)
268 /* The data has not changed. We will just bump the
269 timeout value. Note that the new record has been
270 allocated on the stack and need not be freed. */
271 dh->timeout = dataset->head.timeout;
276 /* We have to create a new record. Just allocate
277 appropriate memory and copy it. */
279 = (struct dataset *) mempool_alloc (db, total + n,
283 /* Adjust pointers into the memory block. */
284 gr_name = (char *) newp + (gr_name - (char *) dataset);
285 cp = (char *) newp + (cp - (char *) dataset);
286 key_copy = (char *) newp + (key_copy - (char *) dataset);
288 dataset = memcpy (newp, dataset, total + n);
292 ++db->head->addfailed;
294 /* Mark the old record as obsolete. */
300 /* We write the dataset before inserting it to the database
301 since while inserting this thread might block and so would
302 unnecessarily let the receiver wait. */
306 if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
308 assert (db->wr_fd != -1);
309 assert ((char *) &dataset->resp > (char *) db->data);
310 assert ((char *) &dataset->resp - (char *) db->head
312 <= (sizeof (struct database_pers_head)
313 + db->head->module * sizeof (ref_t)
314 + db->head->data_size));
315 written = sendfileall (fd, db->wr_fd,
316 (char *) &dataset->resp
317 - (char *) db->head, total);
318 # ifndef __ASSUME_SENDFILE
319 if (written == -1 && errno == ENOSYS)
324 # ifndef __ASSUME_SENDFILE
328 written = writeall (fd, &dataset->resp, total);
331 /* Add the record to the database. But only if it has not been
332 stored on the stack. */
335 /* If necessary, we also propagate the data to disk. */
339 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
340 msync ((void *) pval,
341 ((uintptr_t) dataset & pagesize_m1) + total + n,
345 /* Now get the lock to safely insert the records. */
346 pthread_rwlock_rdlock (&db->lock);
348 /* NB: in the following code we always must add the entry
349 marked with FIRST first. Otherwise we end up with
350 dangling "pointers" in case a latter hash entry cannot be
354 /* If the request was by GID, add that entry first. */
355 if (req->type == GETGRBYGID)
357 if (cache_add (GETGRBYGID, cp, key_offset, &dataset->head, true,
360 /* Could not allocate memory. Make sure the data gets
362 dataset->head.usable = false;
368 /* If the key is different from the name add a separate entry. */
369 else if (strcmp (key_copy, gr_name) != 0)
371 if (cache_add (GETGRBYNAME, key_copy, key_len + 1,
372 &dataset->head, true, db, owner) < 0)
374 /* Could not allocate memory. Make sure the data gets
376 dataset->head.usable = false;
383 /* We have to add the value for both, byname and byuid. */
384 if ((req->type == GETGRBYNAME || db->propagate)
385 && __builtin_expect (cache_add (GETGRBYNAME, gr_name,
387 &dataset->head, first, db, owner)
390 if (req->type == GETGRBYNAME && db->propagate)
391 (void) cache_add (GETGRBYGID, cp, key_offset, &dataset->head,
392 req->type != GETGRBYNAME, db, owner);
395 /* Could not allocate memory. Make sure the data gets
397 dataset->head.usable = false;
400 pthread_rwlock_unlock (&db->lock);
404 if (__builtin_expect (written != total, 0) && debug_level > 0)
407 dbg_log (_("short write in %s: %s"), __FUNCTION__,
408 strerror_r (errno, buf, sizeof (buf)));
421 lookup (int type, union keytype key, struct group *resultbufp, char *buffer,
422 size_t buflen, struct group **grp)
424 if (type == GETGRBYNAME)
425 return __getgrnam_r (key.v, resultbufp, buffer, buflen, grp);
427 return __getgrgid_r (key.g, resultbufp, buffer, buflen, grp);
432 addgrbyX (struct database_dyn *db, int fd, request_header *req,
433 union keytype key, const char *keystr, uid_t uid,
434 struct hashentry *he, struct datahead *dh)
436 /* Search for the entry matching the key. Please note that we don't
437 look again in the table whether the dataset is now available. We
438 simply insert it. It does not matter if it is in there twice. The
439 pruning function only will look at the timestamp. */
440 size_t buflen = 1024;
441 char *buffer = (char *) alloca (buflen);
442 struct group resultbuf;
444 bool use_malloc = false;
447 if (__builtin_expect (debug_level > 0, 0))
450 dbg_log (_("Haven't found \"%s\" in group cache!"), keystr);
452 dbg_log (_("Reloading \"%s\" in group cache!"), keystr);
455 while (lookup (req->type, key, &resultbuf, buffer, buflen, &grp) != 0
456 && (errval = errno) == ERANGE)
460 if (__builtin_expect (buflen > 32768, 0))
462 char *old_buffer = buffer;
464 buffer = (char *) realloc (use_malloc ? buffer : NULL, buflen);
467 /* We ran out of memory. We cannot do anything but
468 sending a negative response. In reality this should
473 /* We set the error to indicate this is (possibly) a
474 temporary error and that it does not mean the entry
475 is not available at all. */
482 /* Allocate a new buffer on the stack. If possible combine it
483 with the previously allocated buffer. */
484 buffer = (char *) extend_alloca (buffer, buflen, 2 * buflen);
487 cache_addgr (db, fd, req, keystr, grp, uid, he, dh, errval);
495 addgrbyname (struct database_dyn *db, int fd, request_header *req,
496 void *key, uid_t uid)
498 union keytype u = { .v = key };
500 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
505 readdgrbyname (struct database_dyn *db, struct hashentry *he,
513 union keytype u = { .v = db->data + he->key };
515 addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);
520 addgrbygid (struct database_dyn *db, int fd, request_header *req,
521 void *key, uid_t uid)
524 gid_t gid = strtoul ((char *) key, &ep, 10);
526 if (*(char *) key == '\0' || *ep != '\0') /* invalid numeric uid */
529 dbg_log (_("Invalid numeric gid \"%s\"!"), (char *) key);
535 union keytype u = { .g = gid };
537 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
542 readdgrbygid (struct database_dyn *db, struct hashentry *he,
546 gid_t gid = strtoul (db->data + he->key, &ep, 10);
548 /* Since the key has been added before it must be OK. */
549 assert (*(db->data + he->key) != '\0' && *ep == '\0');
556 union keytype u = { .g = gid };
558 addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);