.
[glibc/history.git] / nscd / pwdcache.c
blob2338e7e1e089c1e62052a48bce0d53efd77c60c8
1 /* Cache handling for passwd lookup.
2 Copyright (C) 1998-2008, 2009 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. */
20 #include <alloca.h>
21 #include <assert.h>
22 #include <errno.h>
23 #include <error.h>
24 #include <libintl.h>
25 #include <pwd.h>
26 #include <stdbool.h>
27 #include <stddef.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <time.h>
32 #include <unistd.h>
33 #include <sys/mman.h>
34 #include <sys/socket.h>
35 #include <stackinfo.h>
37 #include "nscd.h"
38 #include "dbg_log.h"
39 #ifdef HAVE_SENDFILE
40 # include <kernel-features.h>
41 #endif
43 /* This is the standard reply in case the service is disabled. */
44 static const pw_response_header disabled =
46 .version = NSCD_VERSION,
47 .found = -1,
48 .pw_name_len = 0,
49 .pw_passwd_len = 0,
50 .pw_uid = -1,
51 .pw_gid = -1,
52 .pw_gecos_len = 0,
53 .pw_dir_len = 0,
54 .pw_shell_len = 0
57 /* This is the struct describing how to write this record. */
58 const struct iovec pwd_iov_disabled =
60 .iov_base = (void *) &disabled,
61 .iov_len = sizeof (disabled)
65 /* This is the standard reply in case we haven't found the dataset. */
66 static const pw_response_header notfound =
68 .version = NSCD_VERSION,
69 .found = 0,
70 .pw_name_len = 0,
71 .pw_passwd_len = 0,
72 .pw_uid = -1,
73 .pw_gid = -1,
74 .pw_gecos_len = 0,
75 .pw_dir_len = 0,
76 .pw_shell_len = 0
80 static void
81 cache_addpw (struct database_dyn *db, int fd, request_header *req,
82 const void *key, struct passwd *pwd, uid_t owner,
83 struct hashentry *const he, struct datahead *dh, int errval)
85 ssize_t total;
86 ssize_t written;
87 time_t t = time (NULL);
89 /* We allocate all data in one memory block: the iov vector,
90 the response header and the dataset itself. */
91 struct dataset
93 struct datahead head;
94 pw_response_header resp;
95 char strdata[0];
96 } *dataset;
98 assert (offsetof (struct dataset, resp) == offsetof (struct datahead, data));
100 if (pwd == NULL)
102 if (he != NULL && errval == EAGAIN)
104 /* If we have an old record available but cannot find one
105 now because the service is not available we keep the old
106 record and make sure it does not get removed. */
107 if (reload_count != UINT_MAX && dh->nreloads == reload_count)
108 /* Do not reset the value if we never not reload the record. */
109 dh->nreloads = reload_count - 1;
111 written = total = 0;
113 else
115 /* We have no data. This means we send the standard reply for this
116 case. */
117 written = total = sizeof (notfound);
119 if (fd != -1)
120 written = TEMP_FAILURE_RETRY (send (fd, &notfound, total,
121 MSG_NOSIGNAL));
123 dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len,
125 /* If we cannot permanently store the result, so be it. */
126 if (dataset != NULL)
128 dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
129 dataset->head.recsize = total;
130 dataset->head.notfound = true;
131 dataset->head.nreloads = 0;
132 dataset->head.usable = true;
134 /* Compute the timeout time. */
135 dataset->head.timeout = t + db->negtimeout;
137 /* This is the reply. */
138 memcpy (&dataset->resp, &notfound, total);
140 /* Copy the key data. */
141 char *key_copy = memcpy (dataset->strdata, key, req->key_len);
143 /* If necessary, we also propagate the data to disk. */
144 if (db->persistent)
146 // XXX async OK?
147 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
148 msync ((void *) pval,
149 ((uintptr_t) dataset & pagesize_m1)
150 + sizeof (struct dataset) + req->key_len, MS_ASYNC);
153 (void) cache_add (req->type, key_copy, req->key_len,
154 &dataset->head, true, db, owner, he == NULL);
156 pthread_rwlock_unlock (&db->lock);
158 /* Mark the old entry as obsolete. */
159 if (dh != NULL)
160 dh->usable = false;
164 else
166 /* Determine the I/O structure. */
167 size_t pw_name_len = strlen (pwd->pw_name) + 1;
168 size_t pw_passwd_len = strlen (pwd->pw_passwd) + 1;
169 size_t pw_gecos_len = strlen (pwd->pw_gecos) + 1;
170 size_t pw_dir_len = strlen (pwd->pw_dir) + 1;
171 size_t pw_shell_len = strlen (pwd->pw_shell) + 1;
172 char *cp;
173 const size_t key_len = strlen (key);
174 const size_t buf_len = 3 * sizeof (pwd->pw_uid) + key_len + 1;
175 char *buf = alloca (buf_len);
176 ssize_t n;
178 /* We need this to insert the `byuid' entry. */
179 int key_offset;
180 n = snprintf (buf, buf_len, "%d%c%n%s", pwd->pw_uid, '\0',
181 &key_offset, (char *) key) + 1;
183 written = total = (offsetof (struct dataset, strdata)
184 + pw_name_len + pw_passwd_len
185 + pw_gecos_len + pw_dir_len + pw_shell_len);
187 /* If we refill the cache, first assume the reconrd did not
188 change. Allocate memory on the cache since it is likely
189 discarded anyway. If it turns out to be necessary to have a
190 new record we can still allocate real memory. */
191 bool alloca_used = false;
192 dataset = NULL;
194 if (he == NULL)
195 dataset = (struct dataset *) mempool_alloc (db, total + n, 1);
197 if (dataset == NULL)
199 /* We cannot permanently add the result in the moment. But
200 we can provide the result as is. Store the data in some
201 temporary memory. */
202 dataset = (struct dataset *) alloca (total + n);
204 /* We cannot add this record to the permanent database. */
205 alloca_used = true;
208 dataset->head.allocsize = total + n;
209 dataset->head.recsize = total - offsetof (struct dataset, resp);
210 dataset->head.notfound = false;
211 dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
212 dataset->head.usable = true;
214 /* Compute the timeout time. */
215 dataset->head.timeout = t + db->postimeout;
217 dataset->resp.version = NSCD_VERSION;
218 dataset->resp.found = 1;
219 dataset->resp.pw_name_len = pw_name_len;
220 dataset->resp.pw_passwd_len = pw_passwd_len;
221 dataset->resp.pw_uid = pwd->pw_uid;
222 dataset->resp.pw_gid = pwd->pw_gid;
223 dataset->resp.pw_gecos_len = pw_gecos_len;
224 dataset->resp.pw_dir_len = pw_dir_len;
225 dataset->resp.pw_shell_len = pw_shell_len;
227 cp = dataset->strdata;
229 /* Copy the strings over into the buffer. */
230 cp = mempcpy (cp, pwd->pw_name, pw_name_len);
231 cp = mempcpy (cp, pwd->pw_passwd, pw_passwd_len);
232 cp = mempcpy (cp, pwd->pw_gecos, pw_gecos_len);
233 cp = mempcpy (cp, pwd->pw_dir, pw_dir_len);
234 cp = mempcpy (cp, pwd->pw_shell, pw_shell_len);
236 /* Finally the stringified UID value. */
237 memcpy (cp, buf, n);
238 char *key_copy = cp + key_offset;
239 assert (key_copy == (char *) rawmemchr (cp, '\0') + 1);
241 assert (cp == dataset->strdata + total - offsetof (struct dataset,
242 strdata));
244 /* Now we can determine whether on refill we have to create a new
245 record or not. */
246 if (he != NULL)
248 assert (fd == -1);
250 if (dataset->head.allocsize == dh->allocsize
251 && dataset->head.recsize == dh->recsize
252 && memcmp (&dataset->resp, dh->data,
253 dh->allocsize - offsetof (struct dataset, resp)) == 0)
255 /* The data has not changed. We will just bump the
256 timeout value. Note that the new record has been
257 allocated on the stack and need not be freed. */
258 dh->timeout = dataset->head.timeout;
259 ++dh->nreloads;
261 else
263 /* We have to create a new record. Just allocate
264 appropriate memory and copy it. */
265 struct dataset *newp
266 = (struct dataset *) mempool_alloc (db, total + n, 1);
267 if (newp != NULL)
269 /* Adjust pointer into the memory block. */
270 cp = (char *) newp + (cp - (char *) dataset);
271 key_copy = (char *) newp + (key_copy - (char *) dataset);
273 dataset = memcpy (newp, dataset, total + n);
274 alloca_used = false;
277 /* Mark the old record as obsolete. */
278 dh->usable = false;
281 else
283 /* We write the dataset before inserting it to the database
284 since while inserting this thread might block and so would
285 unnecessarily let the receiver wait. */
286 assert (fd != -1);
288 #ifdef HAVE_SENDFILE
289 if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
291 assert (db->wr_fd != -1);
292 assert ((char *) &dataset->resp > (char *) db->data);
293 assert ((char *) &dataset->resp - (char *) db->head
294 + total
295 <= (sizeof (struct database_pers_head)
296 + db->head->module * sizeof (ref_t)
297 + db->head->data_size));
298 written = sendfileall (fd, db->wr_fd,
299 (char *) &dataset->resp
300 - (char *) db->head, total);
301 # ifndef __ASSUME_SENDFILE
302 if (written == -1 && errno == ENOSYS)
303 goto use_write;
304 # endif
306 else
307 # ifndef __ASSUME_SENDFILE
308 use_write:
309 # endif
310 #endif
311 written = writeall (fd, &dataset->resp, total);
315 /* Add the record to the database. But only if it has not been
316 stored on the stack. */
317 if (! alloca_used)
319 /* If necessary, we also propagate the data to disk. */
320 if (db->persistent)
322 // XXX async OK?
323 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
324 msync ((void *) pval,
325 ((uintptr_t) dataset & pagesize_m1) + total + n,
326 MS_ASYNC);
329 /* NB: in the following code we always must add the entry
330 marked with FIRST first. Otherwise we end up with
331 dangling "pointers" in case a latter hash entry cannot be
332 added. */
333 bool first = true;
335 /* If the request was by UID, add that entry first. */
336 if (req->type == GETPWBYUID)
338 if (cache_add (GETPWBYUID, cp, key_offset, &dataset->head, true,
339 db, owner, he == NULL) < 0)
340 goto out;
342 first = false;
344 /* If the key is different from the name add a separate entry. */
345 else if (strcmp (key_copy, dataset->strdata) != 0)
347 if (cache_add (GETPWBYNAME, key_copy, key_len + 1,
348 &dataset->head, true, db, owner, he == NULL) < 0)
349 goto out;
351 first = false;
354 /* We have to add the value for both, byname and byuid. */
355 if ((req->type == GETPWBYNAME || db->propagate)
356 && __builtin_expect (cache_add (GETPWBYNAME, dataset->strdata,
357 pw_name_len, &dataset->head,
358 first, db, owner, he == NULL)
359 == 0, 1))
361 if (req->type == GETPWBYNAME && db->propagate)
362 (void) cache_add (GETPWBYUID, cp, key_offset, &dataset->head,
363 false, db, owner, false);
366 out:
367 pthread_rwlock_unlock (&db->lock);
371 if (__builtin_expect (written != total, 0) && debug_level > 0)
373 char buf[256];
374 dbg_log (_("short write in %s: %s"), __FUNCTION__,
375 strerror_r (errno, buf, sizeof (buf)));
380 union keytype
382 void *v;
383 uid_t u;
387 static int
388 lookup (int type, union keytype key, struct passwd *resultbufp, char *buffer,
389 size_t buflen, struct passwd **pwd)
391 if (type == GETPWBYNAME)
392 return __getpwnam_r (key.v, resultbufp, buffer, buflen, pwd);
393 else
394 return __getpwuid_r (key.u, resultbufp, buffer, buflen, pwd);
398 static void
399 addpwbyX (struct database_dyn *db, int fd, request_header *req,
400 union keytype key, const char *keystr, uid_t c_uid,
401 struct hashentry *he, struct datahead *dh)
403 /* Search for the entry matching the key. Please note that we don't
404 look again in the table whether the dataset is now available. We
405 simply insert it. It does not matter if it is in there twice. The
406 pruning function only will look at the timestamp. */
407 size_t buflen = 1024;
408 char *buffer = (char *) alloca (buflen);
409 struct passwd resultbuf;
410 struct passwd *pwd;
411 bool use_malloc = false;
412 int errval = 0;
414 if (__builtin_expect (debug_level > 0, 0))
416 if (he == NULL)
417 dbg_log (_("Haven't found \"%s\" in password cache!"), keystr);
418 else
419 dbg_log (_("Reloading \"%s\" in password cache!"), keystr);
422 while (lookup (req->type, key, &resultbuf, buffer, buflen, &pwd) != 0
423 && (errval = errno) == ERANGE)
425 errno = 0;
427 if (__builtin_expect (buflen > 32768, 0))
429 char *old_buffer = buffer;
430 buflen *= 2;
431 buffer = (char *) realloc (use_malloc ? buffer : NULL, buflen);
432 if (buffer == NULL)
434 /* We ran out of memory. We cannot do anything but
435 sending a negative response. In reality this should
436 never happen. */
437 pwd = NULL;
438 buffer = old_buffer;
440 /* We set the error to indicate this is (possibly) a
441 temporary error and that it does not mean the entry
442 is not available at all. */
443 errval = EAGAIN;
444 break;
446 use_malloc = true;
448 else
449 /* Allocate a new buffer on the stack. If possible combine it
450 with the previously allocated buffer. */
451 buffer = (char *) extend_alloca (buffer, buflen, 2 * buflen);
454 /* Add the entry to the cache. */
455 cache_addpw (db, fd, req, keystr, pwd, c_uid, he, dh, errval);
457 if (use_malloc)
458 free (buffer);
462 void
463 addpwbyname (struct database_dyn *db, int fd, request_header *req,
464 void *key, uid_t c_uid)
466 union keytype u = { .v = key };
468 addpwbyX (db, fd, req, u, key, c_uid, NULL, NULL);
472 void
473 readdpwbyname (struct database_dyn *db, struct hashentry *he,
474 struct datahead *dh)
476 request_header req =
478 .type = GETPWBYNAME,
479 .key_len = he->len
481 union keytype u = { .v = db->data + he->key };
483 addpwbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);
487 void
488 addpwbyuid (struct database_dyn *db, int fd, request_header *req,
489 void *key, uid_t c_uid)
491 char *ep;
492 uid_t uid = strtoul ((char *) key, &ep, 10);
494 if (*(char *) key == '\0' || *ep != '\0') /* invalid numeric uid */
496 if (debug_level > 0)
497 dbg_log (_("Invalid numeric uid \"%s\"!"), (char *) key);
499 errno = EINVAL;
500 return;
503 union keytype u = { .u = uid };
505 addpwbyX (db, fd, req, u, key, c_uid, NULL, NULL);
509 void
510 readdpwbyuid (struct database_dyn *db, struct hashentry *he,
511 struct datahead *dh)
513 char *ep;
514 uid_t uid = strtoul (db->data + he->key, &ep, 10);
516 /* Since the key has been added before it must be OK. */
517 assert (*(db->data + he->key) != '\0' && *ep == '\0');
519 request_header req =
521 .type = GETPWBYUID,
522 .key_len = he->len
524 union keytype u = { .u = uid };
526 addpwbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);