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 (void) cache_add (req->type, &dataset->strdata, req->key_len,
150 &dataset->head, true, db, owner, he == NULL);
152 pthread_rwlock_unlock (&db->lock);
154 /* Mark the old entry as obsolete. */
159 ++db->head->addfailed;
164 /* Determine the I/O structure. */
165 size_t gr_name_len = strlen (grp->gr_name) + 1;
166 size_t gr_passwd_len = strlen (grp->gr_passwd) + 1;
167 size_t gr_mem_cnt = 0;
168 uint32_t *gr_mem_len;
169 size_t gr_mem_len_total = 0;
172 const size_t key_len = strlen (key);
173 const size_t buf_len = 3 * sizeof (grp->gr_gid) + key_len + 1;
174 char *buf = alloca (buf_len);
178 /* We need this to insert the `bygid' entry. */
180 n = snprintf (buf, buf_len, "%d%c%n%s", grp->gr_gid, '\0',
181 &key_offset, (char *) key) + 1;
183 /* Determine the length of all members. */
184 while (grp->gr_mem[gr_mem_cnt])
186 gr_mem_len = (uint32_t *) alloca (gr_mem_cnt * sizeof (uint32_t));
187 for (gr_mem_cnt = 0; grp->gr_mem[gr_mem_cnt]; ++gr_mem_cnt)
189 gr_mem_len[gr_mem_cnt] = strlen (grp->gr_mem[gr_mem_cnt]) + 1;
190 gr_mem_len_total += gr_mem_len[gr_mem_cnt];
193 written = total = (offsetof (struct dataset, strdata)
194 + gr_mem_cnt * sizeof (uint32_t)
195 + gr_name_len + gr_passwd_len + gr_mem_len_total);
197 /* If we refill the cache, first assume the reconrd did not
198 change. Allocate memory on the cache since it is likely
199 discarded anyway. If it turns out to be necessary to have a
200 new record we can still allocate real memory. */
201 bool alloca_used = false;
206 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 assert (cp == dataset->strdata + total - offsetof (struct dataset,
258 /* Now we can determine whether on refill we have to create a new
264 if (total + n == dh->allocsize
265 && total - offsetof (struct dataset, resp) == dh->recsize
266 && memcmp (&dataset->resp, dh->data,
267 dh->allocsize - offsetof (struct dataset, resp)) == 0)
269 /* The data has not changed. We will just bump the
270 timeout value. Note that the new record has been
271 allocated on the stack and need not be freed. */
272 dh->timeout = dataset->head.timeout;
277 /* We have to create a new record. Just allocate
278 appropriate memory and copy it. */
280 = (struct dataset *) mempool_alloc (db, total + n,
284 /* Adjust pointers into the memory block. */
285 gr_name = (char *) newp + (gr_name - (char *) dataset);
286 cp = (char *) newp + (cp - (char *) dataset);
287 key_copy = (char *) newp + (key_copy - (char *) dataset);
289 dataset = memcpy (newp, dataset, total + n);
293 ++db->head->addfailed;
295 /* Mark the old record as obsolete. */
301 /* We write the dataset before inserting it to the database
302 since while inserting this thread might block and so would
303 unnecessarily let the receiver wait. */
307 if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
309 assert (db->wr_fd != -1);
310 assert ((char *) &dataset->resp > (char *) db->data);
311 assert ((char *) &dataset->resp - (char *) db->head
313 <= (sizeof (struct database_pers_head)
314 + db->head->module * sizeof (ref_t)
315 + db->head->data_size));
316 written = sendfileall (fd, db->wr_fd,
317 (char *) &dataset->resp
318 - (char *) db->head, total);
319 # ifndef __ASSUME_SENDFILE
320 if (written == -1 && errno == ENOSYS)
325 # ifndef __ASSUME_SENDFILE
329 written = writeall (fd, &dataset->resp, total);
332 /* Add the record to the database. But only if it has not been
333 stored on the stack. */
336 /* If necessary, we also propagate the data to disk. */
340 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
341 msync ((void *) pval,
342 ((uintptr_t) dataset & pagesize_m1) + total + n,
346 /* Now get the lock to safely insert the records. */
347 pthread_rwlock_rdlock (&db->lock);
349 /* NB: in the following code we always must add the entry
350 marked with FIRST first. Otherwise we end up with
351 dangling "pointers" in case a latter hash entry cannot be
355 /* If the request was by GID, add that entry first. */
356 if (req->type == GETGRBYGID)
358 if (cache_add (GETGRBYGID, cp, key_offset, &dataset->head, true,
359 db, owner, he == NULL) < 0)
364 /* If the key is different from the name add a separate entry. */
365 else if (strcmp (key_copy, gr_name) != 0)
367 if (cache_add (GETGRBYNAME, key_copy, key_len + 1,
368 &dataset->head, true, db, owner, he == NULL) < 0)
374 /* We have to add the value for both, byname and byuid. */
375 if ((req->type == GETGRBYNAME || db->propagate)
376 && __builtin_expect (cache_add (GETGRBYNAME, gr_name,
378 &dataset->head, first, db, owner,
382 if (req->type == GETGRBYNAME && db->propagate)
383 (void) cache_add (GETGRBYGID, cp, key_offset, &dataset->head,
384 false, db, owner, false);
388 pthread_rwlock_unlock (&db->lock);
392 if (__builtin_expect (written != total, 0) && debug_level > 0)
395 dbg_log (_("short write in %s: %s"), __FUNCTION__,
396 strerror_r (errno, buf, sizeof (buf)));
409 lookup (int type, union keytype key, struct group *resultbufp, char *buffer,
410 size_t buflen, struct group **grp)
412 if (type == GETGRBYNAME)
413 return __getgrnam_r (key.v, resultbufp, buffer, buflen, grp);
415 return __getgrgid_r (key.g, resultbufp, buffer, buflen, grp);
420 addgrbyX (struct database_dyn *db, int fd, request_header *req,
421 union keytype key, const char *keystr, uid_t uid,
422 struct hashentry *he, struct datahead *dh)
424 /* Search for the entry matching the key. Please note that we don't
425 look again in the table whether the dataset is now available. We
426 simply insert it. It does not matter if it is in there twice. The
427 pruning function only will look at the timestamp. */
428 size_t buflen = 1024;
429 char *buffer = (char *) alloca (buflen);
430 struct group resultbuf;
432 bool use_malloc = false;
435 if (__builtin_expect (debug_level > 0, 0))
438 dbg_log (_("Haven't found \"%s\" in group cache!"), keystr);
440 dbg_log (_("Reloading \"%s\" in group cache!"), keystr);
443 while (lookup (req->type, key, &resultbuf, buffer, buflen, &grp) != 0
444 && (errval = errno) == ERANGE)
448 if (__builtin_expect (buflen > 32768, 0))
450 char *old_buffer = buffer;
452 buffer = (char *) realloc (use_malloc ? buffer : NULL, buflen);
455 /* We ran out of memory. We cannot do anything but
456 sending a negative response. In reality this should
461 /* We set the error to indicate this is (possibly) a
462 temporary error and that it does not mean the entry
463 is not available at all. */
470 /* Allocate a new buffer on the stack. If possible combine it
471 with the previously allocated buffer. */
472 buffer = (char *) extend_alloca (buffer, buflen, 2 * buflen);
475 cache_addgr (db, fd, req, keystr, grp, uid, he, dh, errval);
483 addgrbyname (struct database_dyn *db, int fd, request_header *req,
484 void *key, uid_t uid)
486 union keytype u = { .v = key };
488 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
493 readdgrbyname (struct database_dyn *db, struct hashentry *he,
501 union keytype u = { .v = db->data + he->key };
503 addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);
508 addgrbygid (struct database_dyn *db, int fd, request_header *req,
509 void *key, uid_t uid)
512 gid_t gid = strtoul ((char *) key, &ep, 10);
514 if (*(char *) key == '\0' || *ep != '\0') /* invalid numeric uid */
517 dbg_log (_("Invalid numeric gid \"%s\"!"), (char *) key);
523 union keytype u = { .g = gid };
525 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
530 readdgrbygid (struct database_dyn *db, struct hashentry *he,
534 gid_t gid = strtoul (db->data + he->key, &ep, 10);
536 /* Since the key has been added before it must be OK. */
537 assert (*(db->data + he->key) != '\0' && *ep == '\0');
544 union keytype u = { .g = gid };
546 addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);