Warn about unsupported DT_FLAGS_1 flags.
[glibc.git] / nscd / grpcache.c
blobf0dad4d54c1d377aa34aa69d6d9961a323901be8
1 /* Cache handling for group lookup.
2 Copyright (C) 1998-2008, 2009, 2011, 2012 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, see <http://www.gnu.org/licenses/>. */
19 #include <alloca.h>
20 #include <assert.h>
21 #include <errno.h>
22 #include <error.h>
23 #include <grp.h>
24 #include <libintl.h>
25 #include <stdbool.h>
26 #include <stddef.h>
27 #include <stdio.h>
28 #include <stdint.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <unistd.h>
32 #include <sys/mman.h>
33 #include <sys/socket.h>
34 #include <stackinfo.h>
36 #include "nscd.h"
37 #include "dbg_log.h"
38 #ifdef HAVE_SENDFILE
39 # include <kernel-features.h>
40 #endif
42 /* This is the standard reply in case the service is disabled. */
43 static const gr_response_header disabled =
45 .version = NSCD_VERSION,
46 .found = -1,
47 .gr_name_len = 0,
48 .gr_passwd_len = 0,
49 .gr_gid = -1,
50 .gr_mem_cnt = 0,
53 /* This is the struct describing how to write this record. */
54 const struct iovec grp_iov_disabled =
56 .iov_base = (void *) &disabled,
57 .iov_len = sizeof (disabled)
61 /* This is the standard reply in case we haven't found the dataset. */
62 static const gr_response_header notfound =
64 .version = NSCD_VERSION,
65 .found = 0,
66 .gr_name_len = 0,
67 .gr_passwd_len = 0,
68 .gr_gid = -1,
69 .gr_mem_cnt = 0,
73 static time_t
74 cache_addgr (struct database_dyn *db, int fd, request_header *req,
75 const void *key, struct group *grp, uid_t owner,
76 struct hashentry *const he, struct datahead *dh, int errval)
78 ssize_t total;
79 ssize_t written;
80 time_t t = time (NULL);
82 /* We allocate all data in one memory block: the iov vector,
83 the response header and the dataset itself. */
84 struct dataset
86 struct datahead head;
87 gr_response_header resp;
88 char strdata[0];
89 } *dataset;
91 assert (offsetof (struct dataset, resp) == offsetof (struct datahead, data));
93 time_t timeout = MAX_TIMEOUT_VALUE;
94 if (grp == NULL)
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;
105 /* Reload with the same time-to-live value. */
106 timeout = dh->timeout = t + db->postimeout;
108 written = total = 0;
110 else
112 /* We have no data. This means we send the standard reply for this
113 case. */
114 total = sizeof (notfound);
116 if (fd != -1)
117 written = TEMP_FAILURE_RETRY (send (fd, &notfound, total,
118 MSG_NOSIGNAL));
119 else
120 written = total;
122 /* If we have a transient error or cannot permanently store
123 the result, so be it. */
124 if (errno == EAGAIN || __builtin_expect (db->negtimeout == 0, 0))
126 /* Mark the old entry as obsolete. */
127 if (dh != NULL)
128 dh->usable = false;
130 else if ((dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len, 1)) != NULL)
132 dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
133 dataset->head.recsize = total;
134 dataset->head.notfound = true;
135 dataset->head.nreloads = 0;
136 dataset->head.usable = true;
138 /* Compute the timeout time. */
139 timeout = dataset->head.timeout = t + db->negtimeout;
141 /* This is the reply. */
142 memcpy (&dataset->resp, &notfound, total);
144 /* Copy the key data. */
145 memcpy (dataset->strdata, key, req->key_len);
147 /* If necessary, we also propagate the data to disk. */
148 if (db->persistent)
150 // XXX async OK?
151 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
152 msync ((void *) pval,
153 ((uintptr_t) dataset & pagesize_m1)
154 + sizeof (struct dataset) + req->key_len, MS_ASYNC);
157 (void) cache_add (req->type, &dataset->strdata, req->key_len,
158 &dataset->head, true, db, owner, he == NULL);
160 pthread_rwlock_unlock (&db->lock);
162 /* Mark the old entry as obsolete. */
163 if (dh != NULL)
164 dh->usable = false;
168 else
170 /* Determine the I/O structure. */
171 size_t gr_name_len = strlen (grp->gr_name) + 1;
172 size_t gr_passwd_len = strlen (grp->gr_passwd) + 1;
173 size_t gr_mem_cnt = 0;
174 uint32_t *gr_mem_len;
175 size_t gr_mem_len_total = 0;
176 char *gr_name;
177 char *cp;
178 const size_t key_len = strlen (key);
179 const size_t buf_len = 3 * sizeof (grp->gr_gid) + key_len + 1;
180 size_t alloca_used = 0;
181 char *buf = alloca_account (buf_len, alloca_used);
182 ssize_t n;
183 size_t cnt;
185 /* We need this to insert the `bygid' entry. */
186 int key_offset;
187 n = snprintf (buf, buf_len, "%d%c%n%s", grp->gr_gid, '\0',
188 &key_offset, (char *) key) + 1;
190 /* Determine the length of all members. */
191 while (grp->gr_mem[gr_mem_cnt])
192 ++gr_mem_cnt;
193 gr_mem_len = alloca_account (gr_mem_cnt * sizeof (uint32_t), alloca_used);
194 for (gr_mem_cnt = 0; grp->gr_mem[gr_mem_cnt]; ++gr_mem_cnt)
196 gr_mem_len[gr_mem_cnt] = strlen (grp->gr_mem[gr_mem_cnt]) + 1;
197 gr_mem_len_total += gr_mem_len[gr_mem_cnt];
200 written = total = (offsetof (struct dataset, strdata)
201 + gr_mem_cnt * sizeof (uint32_t)
202 + gr_name_len + gr_passwd_len + gr_mem_len_total);
204 /* If we refill the cache, first assume the reconrd did not
205 change. Allocate memory on the cache since it is likely
206 discarded anyway. If it turns out to be necessary to have a
207 new record we can still allocate real memory. */
208 bool dataset_temporary = false;
209 bool dataset_malloced = false;
210 dataset = NULL;
212 if (he == NULL)
213 dataset = (struct dataset *) mempool_alloc (db, total + n, 1);
215 if (dataset == NULL)
217 /* We cannot permanently add the result in the moment. But
218 we can provide the result as is. Store the data in some
219 temporary memory. */
220 if (! __libc_use_alloca (alloca_used + total + n))
222 dataset = malloc (total + n);
223 /* Perhaps we should log a message that we were unable
224 to allocate memory for a large request. */
225 if (dataset == NULL)
226 goto out;
227 dataset_malloced = true;
229 else
230 dataset = alloca_account (total + n, alloca_used);
232 /* We cannot add this record to the permanent database. */
233 dataset_temporary = true;
236 dataset->head.allocsize = total + n;
237 dataset->head.recsize = total - offsetof (struct dataset, resp);
238 dataset->head.notfound = false;
239 dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
240 dataset->head.usable = true;
242 /* Compute the timeout time. */
243 timeout = dataset->head.timeout = t + db->postimeout;
245 dataset->resp.version = NSCD_VERSION;
246 dataset->resp.found = 1;
247 dataset->resp.gr_name_len = gr_name_len;
248 dataset->resp.gr_passwd_len = gr_passwd_len;
249 dataset->resp.gr_gid = grp->gr_gid;
250 dataset->resp.gr_mem_cnt = gr_mem_cnt;
252 cp = dataset->strdata;
254 /* This is the member string length array. */
255 cp = mempcpy (cp, gr_mem_len, gr_mem_cnt * sizeof (uint32_t));
256 gr_name = cp;
257 cp = mempcpy (cp, grp->gr_name, gr_name_len);
258 cp = mempcpy (cp, grp->gr_passwd, gr_passwd_len);
260 for (cnt = 0; cnt < gr_mem_cnt; ++cnt)
261 cp = mempcpy (cp, grp->gr_mem[cnt], gr_mem_len[cnt]);
263 /* Finally the stringified GID value. */
264 memcpy (cp, buf, n);
265 char *key_copy = cp + key_offset;
266 assert (key_copy == (char *) rawmemchr (cp, '\0') + 1);
268 assert (cp == dataset->strdata + total - offsetof (struct dataset,
269 strdata));
271 /* Now we can determine whether on refill we have to create a new
272 record or not. */
273 if (he != NULL)
275 assert (fd == -1);
277 if (total + n == dh->allocsize
278 && total - offsetof (struct dataset, resp) == dh->recsize
279 && memcmp (&dataset->resp, dh->data,
280 dh->allocsize - offsetof (struct dataset, resp)) == 0)
282 /* The data has not changed. We will just bump the
283 timeout value. Note that the new record has been
284 allocated on the stack and need not be freed. */
285 dh->timeout = dataset->head.timeout;
286 ++dh->nreloads;
288 /* If the new record was allocated via malloc, then we must free
289 it here. */
290 if (dataset_malloced)
291 free (dataset);
293 else
295 /* We have to create a new record. Just allocate
296 appropriate memory and copy it. */
297 struct dataset *newp
298 = (struct dataset *) mempool_alloc (db, total + n, 1);
299 if (newp != NULL)
301 /* Adjust pointers into the memory block. */
302 gr_name = (char *) newp + (gr_name - (char *) dataset);
303 cp = (char *) newp + (cp - (char *) dataset);
304 key_copy = (char *) newp + (key_copy - (char *) dataset);
306 dataset = memcpy (newp, dataset, total + n);
307 dataset_temporary = false;
310 /* Mark the old record as obsolete. */
311 dh->usable = false;
314 else
316 /* We write the dataset before inserting it to the database
317 since while inserting this thread might block and so would
318 unnecessarily let the receiver wait. */
319 assert (fd != -1);
321 #ifdef HAVE_SENDFILE
322 if (__builtin_expect (db->mmap_used, 1) && ! dataset_temporary)
324 assert (db->wr_fd != -1);
325 assert ((char *) &dataset->resp > (char *) db->data);
326 assert ((char *) dataset - (char *) db->head
327 + total
328 <= (sizeof (struct database_pers_head)
329 + db->head->module * sizeof (ref_t)
330 + db->head->data_size));
331 written = sendfileall (fd, db->wr_fd,
332 (char *) &dataset->resp
333 - (char *) db->head, dataset->head.recsize);
334 # ifndef __ASSUME_SENDFILE
335 if (written == -1 && errno == ENOSYS)
336 goto use_write;
337 # endif
339 else
340 # ifndef __ASSUME_SENDFILE
341 use_write:
342 # endif
343 #endif
344 written = writeall (fd, &dataset->resp, dataset->head.recsize);
347 /* Add the record to the database. But only if it has not been
348 stored on the stack. */
349 if (! dataset_temporary)
351 /* If necessary, we also propagate the data to disk. */
352 if (db->persistent)
354 // XXX async OK?
355 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
356 msync ((void *) pval,
357 ((uintptr_t) dataset & pagesize_m1) + total + n,
358 MS_ASYNC);
361 /* NB: in the following code we always must add the entry
362 marked with FIRST first. Otherwise we end up with
363 dangling "pointers" in case a latter hash entry cannot be
364 added. */
365 bool first = true;
367 /* If the request was by GID, add that entry first. */
368 if (req->type == GETGRBYGID)
370 if (cache_add (GETGRBYGID, cp, key_offset, &dataset->head, true,
371 db, owner, he == NULL) < 0)
372 goto out;
374 first = false;
376 /* If the key is different from the name add a separate entry. */
377 else if (strcmp (key_copy, gr_name) != 0)
379 if (cache_add (GETGRBYNAME, key_copy, key_len + 1,
380 &dataset->head, true, db, owner, he == NULL) < 0)
381 goto out;
383 first = false;
386 /* We have to add the value for both, byname and byuid. */
387 if ((req->type == GETGRBYNAME || db->propagate)
388 && __builtin_expect (cache_add (GETGRBYNAME, gr_name,
389 gr_name_len,
390 &dataset->head, first, db, owner,
391 he == NULL)
392 == 0, 1))
394 if (req->type == GETGRBYNAME && db->propagate)
395 (void) cache_add (GETGRBYGID, cp, key_offset, &dataset->head,
396 false, db, owner, false);
399 out:
400 pthread_rwlock_unlock (&db->lock);
404 if (__builtin_expect (written != total, 0) && debug_level > 0)
406 char buf[256];
407 dbg_log (_("short write in %s: %s"), __FUNCTION__,
408 strerror_r (errno, buf, sizeof (buf)));
411 return timeout;
415 union keytype
417 void *v;
418 gid_t g;
422 static int
423 lookup (int type, union keytype key, struct group *resultbufp, char *buffer,
424 size_t buflen, struct group **grp)
426 if (type == GETGRBYNAME)
427 return __getgrnam_r (key.v, resultbufp, buffer, buflen, grp);
428 else
429 return __getgrgid_r (key.g, resultbufp, buffer, buflen, grp);
433 static time_t
434 addgrbyX (struct database_dyn *db, int fd, request_header *req,
435 union keytype key, const char *keystr, uid_t uid,
436 struct hashentry *he, struct datahead *dh)
438 /* Search for the entry matching the key. Please note that we don't
439 look again in the table whether the dataset is now available. We
440 simply insert it. It does not matter if it is in there twice. The
441 pruning function only will look at the timestamp. */
442 size_t buflen = 1024;
443 char *buffer = (char *) alloca (buflen);
444 struct group resultbuf;
445 struct group *grp;
446 bool use_malloc = false;
447 int errval = 0;
449 if (__builtin_expect (debug_level > 0, 0))
451 if (he == NULL)
452 dbg_log (_("Haven't found \"%s\" in group cache!"), keystr);
453 else
454 dbg_log (_("Reloading \"%s\" in group cache!"), keystr);
457 while (lookup (req->type, key, &resultbuf, buffer, buflen, &grp) != 0
458 && (errval = errno) == ERANGE)
460 errno = 0;
462 if (__builtin_expect (buflen > 32768, 0))
464 char *old_buffer = buffer;
465 buflen *= 2;
466 buffer = (char *) realloc (use_malloc ? buffer : NULL, buflen);
467 if (buffer == NULL)
469 /* We ran out of memory. We cannot do anything but
470 sending a negative response. In reality this should
471 never happen. */
472 grp = NULL;
473 buffer = old_buffer;
475 /* We set the error to indicate this is (possibly) a
476 temporary error and that it does not mean the entry
477 is not available at all. */
478 errval = EAGAIN;
479 break;
481 use_malloc = true;
483 else
484 /* Allocate a new buffer on the stack. If possible combine it
485 with the previously allocated buffer. */
486 buffer = (char *) extend_alloca (buffer, buflen, 2 * buflen);
489 time_t timeout = cache_addgr (db, fd, req, keystr, grp, uid, he, dh, errval);
491 if (use_malloc)
492 free (buffer);
494 return timeout;
498 void
499 addgrbyname (struct database_dyn *db, int fd, request_header *req,
500 void *key, uid_t uid)
502 union keytype u = { .v = key };
504 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
508 time_t
509 readdgrbyname (struct database_dyn *db, struct hashentry *he,
510 struct datahead *dh)
512 request_header req =
514 .type = GETGRBYNAME,
515 .key_len = he->len
517 union keytype u = { .v = db->data + he->key };
519 return addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);
523 void
524 addgrbygid (struct database_dyn *db, int fd, request_header *req,
525 void *key, uid_t uid)
527 char *ep;
528 gid_t gid = strtoul ((char *) key, &ep, 10);
530 if (*(char *) key == '\0' || *ep != '\0') /* invalid numeric uid */
532 if (debug_level > 0)
533 dbg_log (_("Invalid numeric gid \"%s\"!"), (char *) key);
535 errno = EINVAL;
536 return;
539 union keytype u = { .g = gid };
541 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
545 time_t
546 readdgrbygid (struct database_dyn *db, struct hashentry *he,
547 struct datahead *dh)
549 char *ep;
550 gid_t gid = strtoul (db->data + he->key, &ep, 10);
552 /* Since the key has been added before it must be OK. */
553 assert (*(db->data + he->key) != '\0' && *ep == '\0');
555 request_header req =
557 .type = GETGRBYGID,
558 .key_len = he->len
560 union keytype u = { .g = gid };
562 return addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);