1/* Cache handling for group lookup.
2 Copyright (C) 1998-2017 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
5
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.
10
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.
15
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/>. */
18
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>
35
36#include "nscd.h"
37#include "dbg_log.h"
38#ifdef HAVE_SENDFILE
39# include <kernel-features.h>
40#endif
41
42/* This is the standard reply in case the service is disabled. */
43static const gr_response_header disabled =
44{
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,
51};
52
53/* This is the struct describing how to write this record. */
54const struct iovec grp_iov_disabled =
55{
56 .iov_base = (void *) &disabled,
57 .iov_len = sizeof (disabled)
58};
59
60
61/* This is the standard reply in case we haven't found the dataset. */
62static const gr_response_header notfound =
63{
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,
70};
71
72
73static time_t
74cache_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)
77{
78 bool all_written = true;
79 ssize_t total;
80 time_t t = time (NULL);
81
82 /* We allocate all data in one memory block: the iov vector,
83 the response header and the dataset itself. */
84 struct dataset
85 {
86 struct datahead head;
87 gr_response_header resp;
88 char strdata[0];
89 } *dataset;
90
91 assert (offsetof (struct dataset, resp) == offsetof (struct datahead, data));
92
93 time_t timeout = MAX_TIMEOUT_VALUE;
94 if (grp == NULL)
95 {
96 if (he != NULL && errval == EAGAIN)
97 {
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;
104
105 /* Reload with the same time-to-live value. */
106 timeout = dh->timeout = t + db->postimeout;
107
108 total = 0;
109 }
110 else
111 {
112 /* We have no data. This means we send the standard reply for this
113 case. */
114 total = sizeof (notfound);
115
116 if (fd != -1
117 && TEMP_FAILURE_RETRY (send (fd, &notfound, total,
118 MSG_NOSIGNAL)) != total)
119 all_written = false;
120
121 /* If we have a transient error or cannot permanently store
122 the result, so be it. */
123 if (errno == EAGAIN || __builtin_expect (db->negtimeout == 0, 0))
124 {
125 /* Mark the old entry as obsolete. */
126 if (dh != NULL)
127 dh->usable = false;
128 }
129 else if ((dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len, 1)) != NULL)
130 {
131 timeout = datahead_init_neg (&dataset->head,
132 (sizeof (struct dataset)
133 + req->key_len), total,
134 db->negtimeout);
135
136 /* This is the reply. */
137 memcpy (&dataset->resp, &notfound, total);
138
139 /* Copy the key data. */
140 memcpy (dataset->strdata, key, req->key_len);
141
142 /* If necessary, we also propagate the data to disk. */
143 if (db->persistent)
144 {
145 // XXX async OK?
146 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
147 msync ((void *) pval,
148 ((uintptr_t) dataset & pagesize_m1)
149 + sizeof (struct dataset) + req->key_len, MS_ASYNC);
150 }
151
152 (void) cache_add (req->type, &dataset->strdata, req->key_len,
153 &dataset->head, true, db, owner, he == NULL);
154
155 pthread_rwlock_unlock (&db->lock);
156
157 /* Mark the old entry as obsolete. */
158 if (dh != NULL)
159 dh->usable = false;
160 }
161 }
162 }
163 else
164 {
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;
171 char *gr_name;
172 char *cp;
173 const size_t key_len = strlen (key);
174 const size_t buf_len = 3 * sizeof (grp->gr_gid) + key_len + 1;
175 size_t alloca_used = 0;
176 char *buf = alloca_account (buf_len, alloca_used);
177 ssize_t n;
178 size_t cnt;
179
180 /* We need this to insert the `bygid' entry. */
181 int key_offset;
182 n = snprintf (buf, buf_len, "%d%c%n%s", grp->gr_gid, '\0',
183 &key_offset, (char *) key) + 1;
184
185 /* Determine the length of all members. */
186 while (grp->gr_mem[gr_mem_cnt])
187 ++gr_mem_cnt;
188 gr_mem_len = alloca_account (gr_mem_cnt * sizeof (uint32_t), alloca_used);
189 for (gr_mem_cnt = 0; grp->gr_mem[gr_mem_cnt]; ++gr_mem_cnt)
190 {
191 gr_mem_len[gr_mem_cnt] = strlen (grp->gr_mem[gr_mem_cnt]) + 1;
192 gr_mem_len_total += gr_mem_len[gr_mem_cnt];
193 }
194
195 total = (offsetof (struct dataset, strdata)
196 + gr_mem_cnt * sizeof (uint32_t)
197 + gr_name_len + gr_passwd_len + gr_mem_len_total);
198
199 /* If we refill the cache, first assume the reconrd did not
200 change. Allocate memory on the cache since it is likely
201 discarded anyway. If it turns out to be necessary to have a
202 new record we can still allocate real memory. */
203 bool dataset_temporary = false;
204 bool dataset_malloced = false;
205 dataset = NULL;
206
207 if (he == NULL)
208 {
209 /* Prevent an INVALIDATE request from pruning the data between
210 the two calls to cache_add. */
211 if (db->propagate)
212 pthread_mutex_lock (&db->prune_run_lock);
213 dataset = (struct dataset *) mempool_alloc (db, total + n, 1);
214 }
215
216 if (dataset == NULL)
217 {
218 if (he == NULL && db->propagate)
219 pthread_mutex_unlock (&db->prune_run_lock);
220
221 /* We cannot permanently add the result in the moment. But
222 we can provide the result as is. Store the data in some
223 temporary memory. */
224 if (! __libc_use_alloca (alloca_used + total + n))
225 {
226 dataset = malloc (total + n);
227 /* Perhaps we should log a message that we were unable
228 to allocate memory for a large request. */
229 if (dataset == NULL)
230 goto out;
231 dataset_malloced = true;
232 }
233 else
234 dataset = alloca_account (total + n, alloca_used);
235
236 /* We cannot add this record to the permanent database. */
237 dataset_temporary = true;
238 }
239
240 timeout = datahead_init_pos (&dataset->head, total + n,
241 total - offsetof (struct dataset, resp),
242 he == NULL ? 0 : dh->nreloads + 1,
243 db->postimeout);
244
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;
251
252 cp = dataset->strdata;
253
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);
259
260 for (cnt = 0; cnt < gr_mem_cnt; ++cnt)
261 cp = mempcpy (cp, grp->gr_mem[cnt], gr_mem_len[cnt]);
262
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);
267
268 assert (cp == dataset->strdata + total - offsetof (struct dataset,
269 strdata));
270
271 /* Now we can determine whether on refill we have to create a new
272 record or not. */
273 if (he != NULL)
274 {
275 assert (fd == -1);
276
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)
281 {
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;
287
288 /* If the new record was allocated via malloc, then we must free
289 it here. */
290 if (dataset_malloced)
291 free (dataset);
292 }
293 else
294 {
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)
300 {
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);
305
306 dataset = memcpy (newp, dataset, total + n);
307 dataset_temporary = false;
308 }
309
310 /* Mark the old record as obsolete. */
311 dh->usable = false;
312 }
313 }
314 else
315 {
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);
320
321#ifdef HAVE_SENDFILE
322 if (__builtin_expect (db->mmap_used, 1) && ! dataset_temporary)
323 {
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 ssize_t written = sendfileall (fd, db->wr_fd,
332 (char *) &dataset->resp
333 - (char *) db->head,
334 dataset->head.recsize);
335 if (written != dataset->head.recsize)
336 {
337# ifndef __ASSUME_SENDFILE
338 if (written == -1 && errno == ENOSYS)
339 goto use_write;
340# endif
341 all_written = false;
342 }
343 }
344 else
345# ifndef __ASSUME_SENDFILE
346 use_write:
347# endif
348#endif
349 if (writeall (fd, &dataset->resp, dataset->head.recsize)
350 != dataset->head.recsize)
351 all_written = false;
352 }
353
354 /* Add the record to the database. But only if it has not been
355 stored on the stack. */
356 if (! dataset_temporary)
357 {
358 /* If necessary, we also propagate the data to disk. */
359 if (db->persistent)
360 {
361 // XXX async OK?
362 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
363 msync ((void *) pval,
364 ((uintptr_t) dataset & pagesize_m1) + total + n,
365 MS_ASYNC);
366 }
367
368 /* NB: in the following code we always must add the entry
369 marked with FIRST first. Otherwise we end up with
370 dangling "pointers" in case a latter hash entry cannot be
371 added. */
372 bool first = true;
373
374 /* If the request was by GID, add that entry first. */
375 if (req->type == GETGRBYGID)
376 {
377 if (cache_add (GETGRBYGID, cp, key_offset, &dataset->head, true,
378 db, owner, he == NULL) < 0)
379 goto out;
380
381 first = false;
382 }
383 /* If the key is different from the name add a separate entry. */
384 else if (strcmp (key_copy, gr_name) != 0)
385 {
386 if (cache_add (GETGRBYNAME, key_copy, key_len + 1,
387 &dataset->head, true, db, owner, he == NULL) < 0)
388 goto out;
389
390 first = false;
391 }
392
393 /* We have to add the value for both, byname and byuid. */
394 if ((req->type == GETGRBYNAME || db->propagate)
395 && __builtin_expect (cache_add (GETGRBYNAME, gr_name,
396 gr_name_len,
397 &dataset->head, first, db, owner,
398 he == NULL)
399 == 0, 1))
400 {
401 if (req->type == GETGRBYNAME && db->propagate)
402 (void) cache_add (GETGRBYGID, cp, key_offset, &dataset->head,
403 false, db, owner, false);
404 }
405
406 out:
407 pthread_rwlock_unlock (&db->lock);
408 if (he == NULL && db->propagate)
409 pthread_mutex_unlock (&db->prune_run_lock);
410 }
411 }
412
413 if (__builtin_expect (!all_written, 0) && debug_level > 0)
414 {
415 char buf[256];
416 dbg_log (_("short write in %s: %s"), __FUNCTION__,
417 strerror_r (errno, buf, sizeof (buf)));
418 }
419
420 return timeout;
421}
422
423
424union keytype
425{
426 void *v;
427 gid_t g;
428};
429
430
431static int
432lookup (int type, union keytype key, struct group *resultbufp, char *buffer,
433 size_t buflen, struct group **grp)
434{
435 if (type == GETGRBYNAME)
436 return __getgrnam_r (key.v, resultbufp, buffer, buflen, grp);
437 else
438 return __getgrgid_r (key.g, resultbufp, buffer, buflen, grp);
439}
440
441
442static time_t
443addgrbyX (struct database_dyn *db, int fd, request_header *req,
444 union keytype key, const char *keystr, uid_t uid,
445 struct hashentry *he, struct datahead *dh)
446{
447 /* Search for the entry matching the key. Please note that we don't
448 look again in the table whether the dataset is now available. We
449 simply insert it. It does not matter if it is in there twice. The
450 pruning function only will look at the timestamp. */
451 size_t buflen = 1024;
452 char *buffer = (char *) alloca (buflen);
453 struct group resultbuf;
454 struct group *grp;
455 bool use_malloc = false;
456 int errval = 0;
457
458 if (__glibc_unlikely (debug_level > 0))
459 {
460 if (he == NULL)
461 dbg_log (_("Haven't found \"%s\" in group cache!"), keystr);
462 else
463 dbg_log (_("Reloading \"%s\" in group cache!"), keystr);
464 }
465
466 while (lookup (req->type, key, &resultbuf, buffer, buflen, &grp) != 0
467 && (errval = errno) == ERANGE)
468 {
469 errno = 0;
470
471 if (__glibc_unlikely (buflen > 32768))
472 {
473 char *old_buffer = buffer;
474 buflen *= 2;
475 buffer = (char *) realloc (use_malloc ? buffer : NULL, buflen);
476 if (buffer == NULL)
477 {
478 /* We ran out of memory. We cannot do anything but
479 sending a negative response. In reality this should
480 never happen. */
481 grp = NULL;
482 buffer = old_buffer;
483
484 /* We set the error to indicate this is (possibly) a
485 temporary error and that it does not mean the entry
486 is not available at all. */
487 errval = EAGAIN;
488 break;
489 }
490 use_malloc = true;
491 }
492 else
493 /* Allocate a new buffer on the stack. If possible combine it
494 with the previously allocated buffer. */
495 buffer = (char *) extend_alloca (buffer, buflen, 2 * buflen);
496 }
497
498 time_t timeout = cache_addgr (db, fd, req, keystr, grp, uid, he, dh, errval);
499
500 if (use_malloc)
501 free (buffer);
502
503 return timeout;
504}
505
506
507void
508addgrbyname (struct database_dyn *db, int fd, request_header *req,
509 void *key, uid_t uid)
510{
511 union keytype u = { .v = key };
512
513 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
514}
515
516
517time_t
518readdgrbyname (struct database_dyn *db, struct hashentry *he,
519 struct datahead *dh)
520{
521 request_header req =
522 {
523 .type = GETGRBYNAME,
524 .key_len = he->len
525 };
526 union keytype u = { .v = db->data + he->key };
527
528 return addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);
529}
530
531
532void
533addgrbygid (struct database_dyn *db, int fd, request_header *req,
534 void *key, uid_t uid)
535{
536 char *ep;
537 gid_t gid = strtoul ((char *) key, &ep, 10);
538
539 if (*(char *) key == '\0' || *ep != '\0') /* invalid numeric uid */
540 {
541 if (debug_level > 0)
542 dbg_log (_("Invalid numeric gid \"%s\"!"), (char *) key);
543
544 errno = EINVAL;
545 return;
546 }
547
548 union keytype u = { .g = gid };
549
550 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
551}
552
553
554time_t
555readdgrbygid (struct database_dyn *db, struct hashentry *he,
556 struct datahead *dh)
557{
558 char *ep;
559 gid_t gid = strtoul (db->data + he->key, &ep, 10);
560
561 /* Since the key has been added before it must be OK. */
562 assert (*(db->data + he->key) != '\0' && *ep == '\0');
563
564 request_header req =
565 {
566 .type = GETGRBYGID,
567 .key_len = he->len
568 };
569 union keytype u = { .g = gid };
570
571 return addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);
572}
573