1 /* Cache handling for group lookup.
2 Copyright (C) 1998-2005, 2006, 2007 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);
117 /* If we cannot permanently store the result, so be it. */
120 dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
121 dataset->head.recsize = total;
122 dataset->head.notfound = true;
123 dataset->head.nreloads = 0;
124 dataset->head.usable = true;
126 /* Compute the timeout time. */
127 dataset->head.timeout = t + db->negtimeout;
129 /* This is the reply. */
130 memcpy (&dataset->resp, ¬found, total);
132 /* Copy the key data. */
133 memcpy (dataset->strdata, key, req->key_len);
135 /* If necessary, we also propagate the data to disk. */
139 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
140 msync ((void *) pval,
141 ((uintptr_t) dataset & pagesize_m1)
142 + sizeof (struct dataset) + req->key_len, MS_ASYNC);
145 /* Now get the lock to safely insert the records. */
146 pthread_rwlock_rdlock (&db->lock);
148 if (cache_add (req->type, &dataset->strdata, req->key_len,
149 &dataset->head, true, db, owner) < 0)
150 /* Ensure the data can be recovered. */
151 dataset->head.usable = false;
153 pthread_rwlock_unlock (&db->lock);
155 /* Mark the old entry as obsolete. */
160 ++db->head->addfailed;
165 /* Determine the I/O structure. */
166 size_t gr_name_len = strlen (grp->gr_name) + 1;
167 size_t gr_passwd_len = strlen (grp->gr_passwd) + 1;
168 size_t gr_mem_cnt = 0;
169 uint32_t *gr_mem_len;
170 size_t gr_mem_len_total = 0;
173 const size_t key_len = strlen (key);
174 const size_t buf_len = 3 * sizeof (grp->gr_gid) + key_len + 1;
175 char *buf = alloca (buf_len);
179 /* We need this to insert the `bygid' entry. */
181 n = snprintf (buf, buf_len, "%d%c%n%s", grp->gr_gid, '\0',
182 &key_offset, (char *) key) + 1;
184 /* Determine the length of all members. */
185 while (grp->gr_mem[gr_mem_cnt])
187 gr_mem_len = (uint32_t *) alloca (gr_mem_cnt * sizeof (uint32_t));
188 for (gr_mem_cnt = 0; grp->gr_mem[gr_mem_cnt]; ++gr_mem_cnt)
190 gr_mem_len[gr_mem_cnt] = strlen (grp->gr_mem[gr_mem_cnt]) + 1;
191 gr_mem_len_total += gr_mem_len[gr_mem_cnt];
194 written = total = (sizeof (struct dataset)
195 + gr_mem_cnt * sizeof (uint32_t)
196 + gr_name_len + gr_passwd_len + gr_mem_len_total);
198 /* If we refill the cache, first assume the reconrd did not
199 change. Allocate memory on the cache since it is likely
200 discarded anyway. If it turns out to be necessary to have a
201 new record we can still allocate real memory. */
202 bool alloca_used = false;
207 dataset = (struct dataset *) mempool_alloc (db, total + n);
209 ++db->head->addfailed;
214 /* We cannot permanently add the result in the moment. But
215 we can provide the result as is. Store the data in some
217 dataset = (struct dataset *) alloca (total + n);
219 /* We cannot add this record to the permanent database. */
223 dataset->head.allocsize = total + n;
224 dataset->head.recsize = total - offsetof (struct dataset, resp);
225 dataset->head.notfound = false;
226 dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
227 dataset->head.usable = true;
229 /* Compute the timeout time. */
230 dataset->head.timeout = t + db->postimeout;
232 dataset->resp.version = NSCD_VERSION;
233 dataset->resp.found = 1;
234 dataset->resp.gr_name_len = gr_name_len;
235 dataset->resp.gr_passwd_len = gr_passwd_len;
236 dataset->resp.gr_gid = grp->gr_gid;
237 dataset->resp.gr_mem_cnt = gr_mem_cnt;
239 cp = dataset->strdata;
241 /* This is the member string length array. */
242 cp = mempcpy (cp, gr_mem_len, gr_mem_cnt * sizeof (uint32_t));
244 cp = mempcpy (cp, grp->gr_name, gr_name_len);
245 cp = mempcpy (cp, grp->gr_passwd, gr_passwd_len);
247 for (cnt = 0; cnt < gr_mem_cnt; ++cnt)
248 cp = mempcpy (cp, grp->gr_mem[cnt], gr_mem_len[cnt]);
250 /* Finally the stringified GID value. */
252 char *key_copy = cp + key_offset;
253 assert (key_copy == (char *) rawmemchr (cp, '\0') + 1);
255 /* Now we can determine whether on refill we have to create a new
261 if (total + n == dh->allocsize
262 && total - offsetof (struct dataset, resp) == dh->recsize
263 && memcmp (&dataset->resp, dh->data,
264 dh->allocsize - offsetof (struct dataset, resp)) == 0)
266 /* The data has not changed. We will just bump the
267 timeout value. Note that the new record has been
268 allocated on the stack and need not be freed. */
269 dh->timeout = dataset->head.timeout;
274 /* We have to create a new record. Just allocate
275 appropriate memory and copy it. */
277 = (struct dataset *) mempool_alloc (db, total + n);
280 /* Adjust pointers into the memory block. */
281 gr_name = (char *) newp + (gr_name - (char *) dataset);
282 cp = (char *) newp + (cp - (char *) dataset);
283 key_copy = (char *) newp + (key_copy - (char *) dataset);
285 dataset = memcpy (newp, dataset, total + n);
289 /* Mark the old record as obsolete. */
295 /* We write the dataset before inserting it to the database
296 since while inserting this thread might block and so would
297 unnecessarily let the receiver wait. */
301 if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
303 assert (db->wr_fd != -1);
304 assert ((char *) &dataset->resp > (char *) db->data);
305 assert ((char *) &dataset->resp - (char *) db->head
307 <= (sizeof (struct database_pers_head)
308 + db->head->module * sizeof (ref_t)
309 + db->head->data_size));
310 written = sendfileall (fd, db->wr_fd,
311 (char *) &dataset->resp
312 - (char *) db->head, total);
313 # ifndef __ASSUME_SENDFILE
314 if (written == -1 && errno == ENOSYS)
319 # ifndef __ASSUME_SENDFILE
323 written = writeall (fd, &dataset->resp, total);
326 /* Add the record to the database. But only if it has not been
327 stored on the stack. */
330 /* If necessary, we also propagate the data to disk. */
334 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
335 msync ((void *) pval,
336 ((uintptr_t) dataset & pagesize_m1) + total + n,
340 /* Now get the lock to safely insert the records. */
341 pthread_rwlock_rdlock (&db->lock);
343 /* NB: in the following code we always must add the entry
344 marked with FIRST first. Otherwise we end up with
345 dangling "pointers" in case a latter hash entry cannot be
349 /* If the request was by GID, add that entry first. */
350 if (req->type == GETGRBYGID)
352 if (cache_add (GETGRBYGID, cp, key_offset, &dataset->head, true,
355 /* Could not allocate memory. Make sure the data gets
357 dataset->head.usable = false;
363 /* If the key is different from the name add a separate entry. */
364 else if (strcmp (key_copy, gr_name) != 0)
366 if (cache_add (GETGRBYNAME, key_copy, key_len + 1,
367 &dataset->head, true, db, owner) < 0)
369 /* Could not allocate memory. Make sure the data gets
371 dataset->head.usable = false;
378 /* We have to add the value for both, byname and byuid. */
379 if ((req->type == GETGRBYNAME || db->propagate)
380 && __builtin_expect (cache_add (GETGRBYNAME, gr_name,
382 &dataset->head, first, db, owner)
385 if (req->type == GETGRBYNAME && db->propagate)
386 (void) cache_add (GETGRBYGID, cp, key_offset, &dataset->head,
387 req->type != GETGRBYNAME, db, owner);
390 /* Could not allocate memory. Make sure the data gets
392 dataset->head.usable = false;
395 pthread_rwlock_unlock (&db->lock);
399 if (__builtin_expect (written != total, 0) && debug_level > 0)
402 dbg_log (_("short write in %s: %s"), __FUNCTION__,
403 strerror_r (errno, buf, sizeof (buf)));
416 lookup (int type, union keytype key, struct group *resultbufp, char *buffer,
417 size_t buflen, struct group **grp)
419 if (type == GETGRBYNAME)
420 return __getgrnam_r (key.v, resultbufp, buffer, buflen, grp);
422 return __getgrgid_r (key.g, resultbufp, buffer, buflen, grp);
427 addgrbyX (struct database_dyn *db, int fd, request_header *req,
428 union keytype key, const char *keystr, uid_t uid,
429 struct hashentry *he, struct datahead *dh)
431 /* Search for the entry matching the key. Please note that we don't
432 look again in the table whether the dataset is now available. We
433 simply insert it. It does not matter if it is in there twice. The
434 pruning function only will look at the timestamp. */
435 size_t buflen = 1024;
436 char *buffer = (char *) alloca (buflen);
437 struct group resultbuf;
439 bool use_malloc = false;
442 if (__builtin_expect (debug_level > 0, 0))
445 dbg_log (_("Haven't found \"%s\" in group cache!"), keystr);
447 dbg_log (_("Reloading \"%s\" in group cache!"), keystr);
450 while (lookup (req->type, key, &resultbuf, buffer, buflen, &grp) != 0
451 && (errval = errno) == ERANGE)
455 if (__builtin_expect (buflen > 32768, 0))
457 char *old_buffer = buffer;
459 buffer = (char *) realloc (use_malloc ? buffer : NULL, buflen);
462 /* We ran out of memory. We cannot do anything but
463 sending a negative response. In reality this should
468 /* We set the error to indicate this is (possibly) a
469 temporary error and that it does not mean the entry
470 is not available at all. */
477 /* Allocate a new buffer on the stack. If possible combine it
478 with the previously allocated buffer. */
479 buffer = (char *) extend_alloca (buffer, buflen, 2 * buflen);
482 cache_addgr (db, fd, req, keystr, grp, uid, he, dh, errval);
490 addgrbyname (struct database_dyn *db, int fd, request_header *req,
491 void *key, uid_t uid)
493 union keytype u = { .v = key };
495 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
500 readdgrbyname (struct database_dyn *db, struct hashentry *he,
508 union keytype u = { .v = db->data + he->key };
510 addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);
515 addgrbygid (struct database_dyn *db, int fd, request_header *req,
516 void *key, uid_t uid)
519 gid_t gid = strtoul ((char *) key, &ep, 10);
521 if (*(char *) key == '\0' || *ep != '\0') /* invalid numeric uid */
524 dbg_log (_("Invalid numeric gid \"%s\"!"), (char *) key);
530 union keytype u = { .g = gid };
532 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
537 readdgrbygid (struct database_dyn *db, struct hashentry *he,
541 gid_t gid = strtoul (db->data + he->key, &ep, 10);
543 /* Since the key has been added before it must be OK. */
544 assert (*(db->data + he->key) != '\0' && *ep == '\0');
551 union keytype u = { .g = gid };
553 addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);