1/* Cache handling for group lookup.
2 Copyright (C) 1998-2016 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 dataset = (struct dataset *) mempool_alloc (db, total + n, 1);
209
210 if (dataset == NULL)
211 {
212 /* We cannot permanently add the result in the moment. But
213 we can provide the result as is. Store the data in some
214 temporary memory. */
215 if (! __libc_use_alloca (alloca_used + total + n))
216 {
217 dataset = malloc (total + n);
218 /* Perhaps we should log a message that we were unable
219 to allocate memory for a large request. */
220 if (dataset == NULL)
221 goto out;
222 dataset_malloced = true;
223 }
224 else
225 dataset = alloca_account (total + n, alloca_used);
226
227 /* We cannot add this record to the permanent database. */
228 dataset_temporary = true;
229 }
230
231 timeout = datahead_init_pos (&dataset->head, total + n,
232 total - offsetof (struct dataset, resp),
233 he == NULL ? 0 : dh->nreloads + 1,
234 db->postimeout);
235
236 dataset->resp.version = NSCD_VERSION;
237 dataset->resp.found = 1;
238 dataset->resp.gr_name_len = gr_name_len;
239 dataset->resp.gr_passwd_len = gr_passwd_len;
240 dataset->resp.gr_gid = grp->gr_gid;
241 dataset->resp.gr_mem_cnt = gr_mem_cnt;
242
243 cp = dataset->strdata;
244
245 /* This is the member string length array. */
246 cp = mempcpy (cp, gr_mem_len, gr_mem_cnt * sizeof (uint32_t));
247 gr_name = cp;
248 cp = mempcpy (cp, grp->gr_name, gr_name_len);
249 cp = mempcpy (cp, grp->gr_passwd, gr_passwd_len);
250
251 for (cnt = 0; cnt < gr_mem_cnt; ++cnt)
252 cp = mempcpy (cp, grp->gr_mem[cnt], gr_mem_len[cnt]);
253
254 /* Finally the stringified GID value. */
255 memcpy (cp, buf, n);
256 char *key_copy = cp + key_offset;
257 assert (key_copy == (char *) rawmemchr (cp, '\0') + 1);
258
259 assert (cp == dataset->strdata + total - offsetof (struct dataset,
260 strdata));
261
262 /* Now we can determine whether on refill we have to create a new
263 record or not. */
264 if (he != NULL)
265 {
266 assert (fd == -1);
267
268 if (total + n == dh->allocsize
269 && total - offsetof (struct dataset, resp) == dh->recsize
270 && memcmp (&dataset->resp, dh->data,
271 dh->allocsize - offsetof (struct dataset, resp)) == 0)
272 {
273 /* The data has not changed. We will just bump the
274 timeout value. Note that the new record has been
275 allocated on the stack and need not be freed. */
276 dh->timeout = dataset->head.timeout;
277 ++dh->nreloads;
278
279 /* If the new record was allocated via malloc, then we must free
280 it here. */
281 if (dataset_malloced)
282 free (dataset);
283 }
284 else
285 {
286 /* We have to create a new record. Just allocate
287 appropriate memory and copy it. */
288 struct dataset *newp
289 = (struct dataset *) mempool_alloc (db, total + n, 1);
290 if (newp != NULL)
291 {
292 /* Adjust pointers into the memory block. */
293 gr_name = (char *) newp + (gr_name - (char *) dataset);
294 cp = (char *) newp + (cp - (char *) dataset);
295 key_copy = (char *) newp + (key_copy - (char *) dataset);
296
297 dataset = memcpy (newp, dataset, total + n);
298 dataset_temporary = false;
299 }
300
301 /* Mark the old record as obsolete. */
302 dh->usable = false;
303 }
304 }
305 else
306 {
307 /* We write the dataset before inserting it to the database
308 since while inserting this thread might block and so would
309 unnecessarily let the receiver wait. */
310 assert (fd != -1);
311
312#ifdef HAVE_SENDFILE
313 if (__builtin_expect (db->mmap_used, 1) && ! dataset_temporary)
314 {
315 assert (db->wr_fd != -1);
316 assert ((char *) &dataset->resp > (char *) db->data);
317 assert ((char *) dataset - (char *) db->head
318 + total
319 <= (sizeof (struct database_pers_head)
320 + db->head->module * sizeof (ref_t)
321 + db->head->data_size));
322 ssize_t written = sendfileall (fd, db->wr_fd,
323 (char *) &dataset->resp
324 - (char *) db->head,
325 dataset->head.recsize);
326 if (written != dataset->head.recsize)
327 {
328# ifndef __ASSUME_SENDFILE
329 if (written == -1 && errno == ENOSYS)
330 goto use_write;
331# endif
332 all_written = false;
333 }
334 }
335 else
336# ifndef __ASSUME_SENDFILE
337 use_write:
338# endif
339#endif
340 if (writeall (fd, &dataset->resp, dataset->head.recsize)
341 != dataset->head.recsize)
342 all_written = false;
343 }
344
345 /* Add the record to the database. But only if it has not been
346 stored on the stack. */
347 if (! dataset_temporary)
348 {
349 /* If necessary, we also propagate the data to disk. */
350 if (db->persistent)
351 {
352 // XXX async OK?
353 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
354 msync ((void *) pval,
355 ((uintptr_t) dataset & pagesize_m1) + total + n,
356 MS_ASYNC);
357 }
358
359 /* NB: in the following code we always must add the entry
360 marked with FIRST first. Otherwise we end up with
361 dangling "pointers" in case a latter hash entry cannot be
362 added. */
363 bool first = true;
364
365 /* If the request was by GID, add that entry first. */
366 if (req->type == GETGRBYGID)
367 {
368 if (cache_add (GETGRBYGID, cp, key_offset, &dataset->head, true,
369 db, owner, he == NULL) < 0)
370 goto out;
371
372 first = false;
373 }
374 /* If the key is different from the name add a separate entry. */
375 else if (strcmp (key_copy, gr_name) != 0)
376 {
377 if (cache_add (GETGRBYNAME, key_copy, key_len + 1,
378 &dataset->head, true, db, owner, he == NULL) < 0)
379 goto out;
380
381 first = false;
382 }
383
384 /* We have to add the value for both, byname and byuid. */
385 if ((req->type == GETGRBYNAME || db->propagate)
386 && __builtin_expect (cache_add (GETGRBYNAME, gr_name,
387 gr_name_len,
388 &dataset->head, first, db, owner,
389 he == NULL)
390 == 0, 1))
391 {
392 if (req->type == GETGRBYNAME && db->propagate)
393 (void) cache_add (GETGRBYGID, cp, key_offset, &dataset->head,
394 false, db, owner, false);
395 }
396
397 out:
398 pthread_rwlock_unlock (&db->lock);
399 }
400 }
401
402 if (__builtin_expect (!all_written, 0) && debug_level > 0)
403 {
404 char buf[256];
405 dbg_log (_("short write in %s: %s"), __FUNCTION__,
406 strerror_r (errno, buf, sizeof (buf)));
407 }
408
409 return timeout;
410}
411
412
413union keytype
414{
415 void *v;
416 gid_t g;
417};
418
419
420static int
421lookup (int type, union keytype key, struct group *resultbufp, char *buffer,
422 size_t buflen, struct group **grp)
423{
424 if (type == GETGRBYNAME)
425 return __getgrnam_r (key.v, resultbufp, buffer, buflen, grp);
426 else
427 return __getgrgid_r (key.g, resultbufp, buffer, buflen, grp);
428}
429
430
431static time_t
432addgrbyX (struct database_dyn *db, int fd, request_header *req,
433 union keytype key, const char *keystr, uid_t uid,
434 struct hashentry *he, struct datahead *dh)
435{
436 /* Search for the entry matching the key. Please note that we don't
437 look again in the table whether the dataset is now available. We
438 simply insert it. It does not matter if it is in there twice. The
439 pruning function only will look at the timestamp. */
440 size_t buflen = 1024;
441 char *buffer = (char *) alloca (buflen);
442 struct group resultbuf;
443 struct group *grp;
444 bool use_malloc = false;
445 int errval = 0;
446
447 if (__glibc_unlikely (debug_level > 0))
448 {
449 if (he == NULL)
450 dbg_log (_("Haven't found \"%s\" in group cache!"), keystr);
451 else
452 dbg_log (_("Reloading \"%s\" in group cache!"), keystr);
453 }
454
455 while (lookup (req->type, key, &resultbuf, buffer, buflen, &grp) != 0
456 && (errval = errno) == ERANGE)
457 {
458 errno = 0;
459
460 if (__glibc_unlikely (buflen > 32768))
461 {
462 char *old_buffer = buffer;
463 buflen *= 2;
464 buffer = (char *) realloc (use_malloc ? buffer : NULL, buflen);
465 if (buffer == NULL)
466 {
467 /* We ran out of memory. We cannot do anything but
468 sending a negative response. In reality this should
469 never happen. */
470 grp = NULL;
471 buffer = old_buffer;
472
473 /* We set the error to indicate this is (possibly) a
474 temporary error and that it does not mean the entry
475 is not available at all. */
476 errval = EAGAIN;
477 break;
478 }
479 use_malloc = true;
480 }
481 else
482 /* Allocate a new buffer on the stack. If possible combine it
483 with the previously allocated buffer. */
484 buffer = (char *) extend_alloca (buffer, buflen, 2 * buflen);
485 }
486
487 time_t timeout = cache_addgr (db, fd, req, keystr, grp, uid, he, dh, errval);
488
489 if (use_malloc)
490 free (buffer);
491
492 return timeout;
493}
494
495
496void
497addgrbyname (struct database_dyn *db, int fd, request_header *req,
498 void *key, uid_t uid)
499{
500 union keytype u = { .v = key };
501
502 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
503}
504
505
506time_t
507readdgrbyname (struct database_dyn *db, struct hashentry *he,
508 struct datahead *dh)
509{
510 request_header req =
511 {
512 .type = GETGRBYNAME,
513 .key_len = he->len
514 };
515 union keytype u = { .v = db->data + he->key };
516
517 return addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);
518}
519
520
521void
522addgrbygid (struct database_dyn *db, int fd, request_header *req,
523 void *key, uid_t uid)
524{
525 char *ep;
526 gid_t gid = strtoul ((char *) key, &ep, 10);
527
528 if (*(char *) key == '\0' || *ep != '\0') /* invalid numeric uid */
529 {
530 if (debug_level > 0)
531 dbg_log (_("Invalid numeric gid \"%s\"!"), (char *) key);
532
533 errno = EINVAL;
534 return;
535 }
536
537 union keytype u = { .g = gid };
538
539 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
540}
541
542
543time_t
544readdgrbygid (struct database_dyn *db, struct hashentry *he,
545 struct datahead *dh)
546{
547 char *ep;
548 gid_t gid = strtoul (db->data + he->key, &ep, 10);
549
550 /* Since the key has been added before it must be OK. */
551 assert (*(db->data + he->key) != '\0' && *ep == '\0');
552
553 request_header req =
554 {
555 .type = GETGRBYGID,
556 .key_len = he->len
557 };
558 union keytype u = { .g = gid };
559
560 return addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);
561}
562