1 /* Cache handling for group lookup.
2 Copyright (C) 1998-2002, 2003, 2004, 2005 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
11 The GNU C Library 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 GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, write to the Free
18 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
35 #include <stackinfo.h>
40 /* This is the standard reply in case the service is disabled. */
41 static const gr_response_header disabled =
43 .version = NSCD_VERSION,
51 /* This is the struct describing how to write this record. */
52 const struct iovec grp_iov_disabled =
54 .iov_base = (void *) &disabled,
55 .iov_len = sizeof (disabled)
59 /* This is the standard reply in case we haven't found the dataset. */
60 static const gr_response_header notfound =
62 .version = NSCD_VERSION,
72 cache_addgr (struct database_dyn *db, int fd, request_header *req,
73 const void *key, struct group *grp, uid_t owner,
74 struct hashentry *he, struct datahead *dh, int errval)
78 time_t t = time (NULL);
80 /* We allocate all data in one memory block: the iov vector,
81 the response header and the dataset itself. */
85 gr_response_header resp;
89 assert (offsetof (struct dataset, resp) == offsetof (struct datahead, data));
93 if (he != NULL && errval == EAGAIN)
95 /* If we have an old record available but cannot find one
96 now because the service is not available we keep the old
97 record and make sure it does not get removed. */
98 if (reload_count != UINT_MAX)
99 /* Do not reset the value if we never not reload the record. */
100 dh->nreloads = reload_count - 1;
106 /* We have no data. This means we send the standard reply for this
108 total = sizeof (notfound);
110 written = TEMP_FAILURE_RETRY (write (fd, ¬found, total));
112 dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len);
113 /* If we cannot permanently store the result, so be it. */
116 dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
117 dataset->head.recsize = total;
118 dataset->head.notfound = true;
119 dataset->head.nreloads = 0;
120 dataset->head.usable = true;
122 /* Compute the timeout time. */
123 dataset->head.timeout = t + db->negtimeout;
125 /* This is the reply. */
126 memcpy (&dataset->resp, ¬found, total);
128 /* Copy the key data. */
129 memcpy (dataset->strdata, key, req->key_len);
131 /* If necessary, we also propagate the data to disk. */
135 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
136 msync ((void *) pval,
137 ((uintptr_t) dataset & pagesize_m1)
138 + sizeof (struct dataset) + req->key_len, MS_ASYNC);
141 /* Now get the lock to safely insert the records. */
142 pthread_rwlock_rdlock (&db->lock);
144 if (cache_add (req->type, &dataset->strdata, req->key_len,
145 &dataset->head, true, db, owner) < 0)
146 /* Ensure the data can be recovered. */
147 dataset->head.usable = false;
149 pthread_rwlock_unlock (&db->lock);
151 /* Mark the old entry as obsolete. */
156 ++db->head->addfailed;
161 /* Determine the I/O structure. */
162 size_t gr_name_len = strlen (grp->gr_name) + 1;
163 size_t gr_passwd_len = strlen (grp->gr_passwd) + 1;
164 size_t gr_mem_cnt = 0;
165 uint32_t *gr_mem_len;
166 size_t gr_mem_len_total = 0;
169 const size_t key_len = strlen (key);
170 const size_t buf_len = 3 + sizeof (grp->gr_gid) + key_len + 1;
171 char *buf = alloca (buf_len);
175 /* We need this to insert the `bygid' entry. */
177 n = snprintf (buf, buf_len, "%d%c%n%s", grp->gr_gid, '\0',
178 &key_offset, (char *) key) + 1;
180 /* Determine the length of all members. */
181 while (grp->gr_mem[gr_mem_cnt])
183 gr_mem_len = (uint32_t *) alloca (gr_mem_cnt * sizeof (uint32_t));
184 for (gr_mem_cnt = 0; grp->gr_mem[gr_mem_cnt]; ++gr_mem_cnt)
186 gr_mem_len[gr_mem_cnt] = strlen (grp->gr_mem[gr_mem_cnt]) + 1;
187 gr_mem_len_total += gr_mem_len[gr_mem_cnt];
190 written = total = (sizeof (struct dataset)
191 + gr_mem_cnt * sizeof (uint32_t)
192 + gr_name_len + gr_passwd_len + gr_mem_len_total);
194 /* If we refill the cache, first assume the reconrd did not
195 change. Allocate memory on the cache since it is likely
196 discarded anyway. If it turns out to be necessary to have a
197 new record we can still allocate real memory. */
198 bool alloca_used = false;
203 dataset = (struct dataset *) mempool_alloc (db, total + n);
205 ++db->head->addfailed;
210 /* We cannot permanently add the result in the moment. But
211 we can provide the result as is. Store the data in some
213 dataset = (struct dataset *) alloca (total + n);
215 /* We cannot add this record to the permanent database. */
219 dataset->head.allocsize = total + n;
220 dataset->head.recsize = total - offsetof (struct dataset, resp);
221 dataset->head.notfound = false;
222 dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
223 dataset->head.usable = true;
225 /* Compute the timeout time. */
226 dataset->head.timeout = t + db->postimeout;
228 dataset->resp.version = NSCD_VERSION;
229 dataset->resp.found = 1;
230 dataset->resp.gr_name_len = gr_name_len;
231 dataset->resp.gr_passwd_len = gr_passwd_len;
232 dataset->resp.gr_gid = grp->gr_gid;
233 dataset->resp.gr_mem_cnt = gr_mem_cnt;
235 cp = dataset->strdata;
237 /* This is the member string length array. */
238 cp = mempcpy (cp, gr_mem_len, gr_mem_cnt * sizeof (uint32_t));
240 cp = mempcpy (cp, grp->gr_name, gr_name_len);
241 cp = mempcpy (cp, grp->gr_passwd, gr_passwd_len);
243 for (cnt = 0; cnt < gr_mem_cnt; ++cnt)
244 cp = mempcpy (cp, grp->gr_mem[cnt], gr_mem_len[cnt]);
246 /* Finally the stringified GID value. */
248 char *key_copy = cp + key_offset;
249 assert (key_copy == (char *) rawmemchr (cp, '\0') + 1);
251 /* Now we can determine whether on refill we have to create a new
257 if (total + n == dh->allocsize
258 && total - offsetof (struct dataset, resp) == dh->recsize
259 && memcmp (&dataset->resp, dh->data,
260 dh->allocsize - offsetof (struct dataset, resp)) == 0)
262 /* The data has not changed. We will just bump the
263 timeout value. Note that the new record has been
264 allocated on the stack and need not be freed. */
265 dh->timeout = dataset->head.timeout;
270 /* We have to create a new record. Just allocate
271 appropriate memory and copy it. */
273 = (struct dataset *) mempool_alloc (db, total + n);
276 /* Adjust pointers into the memory block. */
277 gr_name = (char *) newp + (gr_name - (char *) dataset);
278 cp = (char *) newp + (cp - (char *) dataset);
280 dataset = memcpy (newp, dataset, total + n);
284 /* Mark the old record as obsolete. */
290 /* We write the dataset before inserting it to the database
291 since while inserting this thread might block and so would
292 unnecessarily let the receiver wait. */
295 written = writeall (fd, &dataset->resp, total);
298 /* Add the record to the database. But only if it has not been
299 stored on the stack. */
302 /* If necessary, we also propagate the data to disk. */
306 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
307 msync ((void *) pval,
308 ((uintptr_t) dataset & pagesize_m1) + total + n,
312 /* Now get the lock to safely insert the records. */
313 pthread_rwlock_rdlock (&db->lock);
315 /* NB: in the following code we always must add the entry
316 marked with FIRST first. Otherwise we end up with
317 dangling "pointers" in case a latter hash entry cannot be
319 bool first = req->type == GETGRBYNAME;
321 /* If the request was by GID, add that entry first. */
322 if (req->type != GETGRBYNAME)
324 if (cache_add (GETGRBYGID, cp, key_offset, &dataset->head, true,
327 /* Could not allocate memory. Make sure the data gets
329 dataset->head.usable = false;
333 /* If the key is different from the name add a separate entry. */
334 else if (strcmp (key_copy, gr_name) != 0)
336 if (cache_add (GETGRBYNAME, key_copy, key_len + 1,
337 &dataset->head, first, db, owner) < 0)
339 /* Could not allocate memory. Make sure the data gets
341 dataset->head.usable = false;
348 /* We have to add the value for both, byname and byuid. */
349 if (__builtin_expect (cache_add (GETGRBYNAME, gr_name, gr_name_len,
350 &dataset->head, first, db, owner)
353 if (req->type == GETGRBYNAME)
354 (void) cache_add (GETGRBYGID, cp, key_offset, &dataset->head,
355 req->type != GETGRBYNAME, db, owner);
358 /* Could not allocate memory. Make sure the data gets
360 dataset->head.usable = false;
363 pthread_rwlock_unlock (&db->lock);
367 if (__builtin_expect (written != total, 0) && debug_level > 0)
370 dbg_log (_("short write in %s: %s"), __FUNCTION__,
371 strerror_r (errno, buf, sizeof (buf)));
384 lookup (int type, union keytype key, struct group *resultbufp, char *buffer,
385 size_t buflen, struct group **grp)
387 if (type == GETGRBYNAME)
388 return __getgrnam_r (key.v, resultbufp, buffer, buflen, grp);
390 return __getgrgid_r (key.g, resultbufp, buffer, buflen, grp);
395 addgrbyX (struct database_dyn *db, int fd, request_header *req,
396 union keytype key, const char *keystr, uid_t uid,
397 struct hashentry *he, struct datahead *dh)
399 /* Search for the entry matching the key. Please note that we don't
400 look again in the table whether the dataset is now available. We
401 simply insert it. It does not matter if it is in there twice. The
402 pruning function only will look at the timestamp. */
403 size_t buflen = 1024;
404 char *buffer = (char *) alloca (buflen);
405 struct group resultbuf;
407 bool use_malloc = false;
410 if (__builtin_expect (debug_level > 0, 0))
413 dbg_log (_("Haven't found \"%s\" in group cache!"), keystr);
415 dbg_log (_("Reloading \"%s\" in group cache!"), keystr);
422 oldeuid = geteuid ();
423 pthread_seteuid_np (uid);
427 while (lookup (req->type, key, &resultbuf, buffer, buflen, &grp) != 0
428 && (errval = errno) == ERANGE)
430 char *old_buffer = buffer;
433 if (__builtin_expect (buflen > 32768, 0))
436 buffer = (char *) realloc (use_malloc ? buffer : NULL, buflen);
439 /* We ran out of memory. We cannot do anything but
440 sending a negative response. In reality this should
445 /* We set the error to indicate this is (possibly) a
446 temporary error and that it does not mean the entry
447 is not available at all. */
454 /* Allocate a new buffer on the stack. If possible combine it
455 with the previously allocated buffer. */
456 buffer = (char *) extend_alloca (buffer, buflen, 2 * buflen);
461 pthread_seteuid_np (oldeuid);
464 cache_addgr (db, fd, req, keystr, grp, uid, he, dh, errval);
472 addgrbyname (struct database_dyn *db, int fd, request_header *req,
473 void *key, uid_t uid)
475 union keytype u = { .v = key };
477 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
482 readdgrbyname (struct database_dyn *db, struct hashentry *he,
490 union keytype u = { .v = db->data + he->key };
492 addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);
497 addgrbygid (struct database_dyn *db, int fd, request_header *req,
498 void *key, uid_t uid)
501 gid_t gid = strtoul ((char *) key, &ep, 10);
503 if (*(char *) key == '\0' || *ep != '\0') /* invalid numeric uid */
506 dbg_log (_("Invalid numeric gid \"%s\"!"), (char *) key);
512 union keytype u = { .g = gid };
514 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
519 readdgrbygid (struct database_dyn *db, struct hashentry *he,
523 gid_t gid = strtoul (db->data + he->key, &ep, 10);
525 /* Since the key has been added before it must be OK. */
526 assert (*(db->data + he->key) != '\0' && *ep == '\0');
533 union keytype u = { .g = gid };
535 addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);