1/* Cache handling for group lookup.
2 Copyright (C) 1998-2021 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 <https://www.gnu.org/licenses/>. */
18
19#include <assert.h>
20#include <errno.h>
21#include <error.h>
22#include <grp.h>
23#include <libintl.h>
24#include <stdbool.h>
25#include <stddef.h>
26#include <stdio.h>
27#include <stdint.h>
28#include <stdlib.h>
29#include <string.h>
30#include <unistd.h>
31#include <sys/mman.h>
32#include <sys/socket.h>
33#include <stackinfo.h>
34#include <scratch_buffer.h>
35
36#include "nscd.h"
37#include "dbg_log.h"
38
39/* This is the standard reply in case the service is disabled. */
40static const gr_response_header disabled =
41{
42 .version = NSCD_VERSION,
43 .found = -1,
44 .gr_name_len = 0,
45 .gr_passwd_len = 0,
46 .gr_gid = -1,
47 .gr_mem_cnt = 0,
48};
49
50/* This is the struct describing how to write this record. */
51const struct iovec grp_iov_disabled =
52{
53 .iov_base = (void *) &disabled,
54 .iov_len = sizeof (disabled)
55};
56
57
58/* This is the standard reply in case we haven't found the dataset. */
59static const gr_response_header notfound =
60{
61 .version = NSCD_VERSION,
62 .found = 0,
63 .gr_name_len = 0,
64 .gr_passwd_len = 0,
65 .gr_gid = -1,
66 .gr_mem_cnt = 0,
67};
68
69
70static time_t
71cache_addgr (struct database_dyn *db, int fd, request_header *req,
72 const void *key, struct group *grp, uid_t owner,
73 struct hashentry *const he, struct datahead *dh, int errval)
74{
75 bool all_written = true;
76 ssize_t total;
77 time_t t = time (NULL);
78
79 /* We allocate all data in one memory block: the iov vector,
80 the response header and the dataset itself. */
81 struct dataset
82 {
83 struct datahead head;
84 gr_response_header resp;
85 char strdata[0];
86 } *dataset;
87
88 assert (offsetof (struct dataset, resp) == offsetof (struct datahead, data));
89
90 time_t timeout = MAX_TIMEOUT_VALUE;
91 if (grp == NULL)
92 {
93 if (he != NULL && errval == EAGAIN)
94 {
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;
101
102 /* Reload with the same time-to-live value. */
103 timeout = dh->timeout = t + db->postimeout;
104
105 total = 0;
106 }
107 else
108 {
109 /* We have no data. This means we send the standard reply for this
110 case. */
111 total = sizeof (notfound);
112
113 if (fd != -1
114 && TEMP_FAILURE_RETRY (send (fd, &notfound, total,
115 MSG_NOSIGNAL)) != total)
116 all_written = false;
117
118 /* If we have a transient error or cannot permanently store
119 the result, so be it. */
120 if (errno == EAGAIN || __builtin_expect (db->negtimeout == 0, 0))
121 {
122 /* Mark the old entry as obsolete. */
123 if (dh != NULL)
124 dh->usable = false;
125 }
126 else if ((dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len, 1)) != NULL)
127 {
128 timeout = datahead_init_neg (&dataset->head,
129 (sizeof (struct dataset)
130 + req->key_len), total,
131 db->negtimeout);
132
133 /* This is the reply. */
134 memcpy (&dataset->resp, &notfound, total);
135
136 /* Copy the key data. */
137 memcpy (dataset->strdata, key, req->key_len);
138
139 /* If necessary, we also propagate the data to disk. */
140 if (db->persistent)
141 {
142 // XXX async OK?
143 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
144 msync ((void *) pval,
145 ((uintptr_t) dataset & pagesize_m1)
146 + sizeof (struct dataset) + req->key_len, MS_ASYNC);
147 }
148
149 (void) cache_add (req->type, &dataset->strdata, req->key_len,
150 &dataset->head, true, db, owner, he == NULL);
151
152 pthread_rwlock_unlock (&db->lock);
153
154 /* Mark the old entry as obsolete. */
155 if (dh != NULL)
156 dh->usable = false;
157 }
158 }
159 }
160 else
161 {
162 /* Determine the I/O structure. */
163 size_t gr_name_len = strlen (grp->gr_name) + 1;
164 size_t gr_passwd_len = strlen (grp->gr_passwd) + 1;
165 size_t gr_mem_cnt = 0;
166 uint32_t *gr_mem_len;
167 size_t gr_mem_len_total = 0;
168 char *gr_name;
169 char *cp;
170 const size_t key_len = strlen (key);
171 const size_t buf_len = 3 * sizeof (grp->gr_gid) + key_len + 1;
172 size_t alloca_used = 0;
173 char *buf = alloca_account (buf_len, alloca_used);
174 ssize_t n;
175 size_t cnt;
176
177 /* We need this to insert the `bygid' entry. */
178 int key_offset;
179 n = snprintf (buf, buf_len, "%d%c%n%s", grp->gr_gid, '\0',
180 &key_offset, (char *) key) + 1;
181
182 /* Determine the length of all members. */
183 while (grp->gr_mem[gr_mem_cnt])
184 ++gr_mem_cnt;
185 gr_mem_len = alloca_account (gr_mem_cnt * sizeof (uint32_t), alloca_used);
186 for (gr_mem_cnt = 0; grp->gr_mem[gr_mem_cnt]; ++gr_mem_cnt)
187 {
188 gr_mem_len[gr_mem_cnt] = strlen (grp->gr_mem[gr_mem_cnt]) + 1;
189 gr_mem_len_total += gr_mem_len[gr_mem_cnt];
190 }
191
192 total = (offsetof (struct dataset, strdata)
193 + gr_mem_cnt * sizeof (uint32_t)
194 + gr_name_len + gr_passwd_len + gr_mem_len_total);
195
196 /* If we refill the cache, first assume the reconrd did not
197 change. Allocate memory on the cache since it is likely
198 discarded anyway. If it turns out to be necessary to have a
199 new record we can still allocate real memory. */
200 bool dataset_temporary = false;
201 bool dataset_malloced = false;
202 dataset = NULL;
203
204 if (he == NULL)
205 {
206 /* Prevent an INVALIDATE request from pruning the data between
207 the two calls to cache_add. */
208 if (db->propagate)
209 pthread_mutex_lock (&db->prune_run_lock);
210 dataset = (struct dataset *) mempool_alloc (db, total + n, 1);
211 }
212
213 if (dataset == NULL)
214 {
215 if (he == NULL && db->propagate)
216 pthread_mutex_unlock (&db->prune_run_lock);
217
218 /* We cannot permanently add the result in the moment. But
219 we can provide the result as is. Store the data in some
220 temporary memory. */
221 if (! __libc_use_alloca (alloca_used + total + n))
222 {
223 dataset = malloc (total + n);
224 /* Perhaps we should log a message that we were unable
225 to allocate memory for a large request. */
226 if (dataset == NULL)
227 goto out;
228 dataset_malloced = true;
229 }
230 else
231 dataset = alloca_account (total + n, alloca_used);
232
233 /* We cannot add this record to the permanent database. */
234 dataset_temporary = true;
235 }
236
237 timeout = datahead_init_pos (&dataset->head, total + n,
238 total - offsetof (struct dataset, resp),
239 he == NULL ? 0 : dh->nreloads + 1,
240 db->postimeout);
241
242 dataset->resp.version = NSCD_VERSION;
243 dataset->resp.found = 1;
244 dataset->resp.gr_name_len = gr_name_len;
245 dataset->resp.gr_passwd_len = gr_passwd_len;
246 dataset->resp.gr_gid = grp->gr_gid;
247 dataset->resp.gr_mem_cnt = gr_mem_cnt;
248
249 cp = dataset->strdata;
250
251 /* This is the member string length array. */
252 cp = mempcpy (cp, gr_mem_len, gr_mem_cnt * sizeof (uint32_t));
253 gr_name = cp;
254 cp = mempcpy (cp, grp->gr_name, gr_name_len);
255 cp = mempcpy (cp, grp->gr_passwd, gr_passwd_len);
256
257 for (cnt = 0; cnt < gr_mem_cnt; ++cnt)
258 cp = mempcpy (cp, grp->gr_mem[cnt], gr_mem_len[cnt]);
259
260 /* Finally the stringified GID value. */
261 memcpy (cp, buf, n);
262 char *key_copy = cp + key_offset;
263 assert (key_copy == (char *) rawmemchr (cp, '\0') + 1);
264
265 assert (cp == dataset->strdata + total - offsetof (struct dataset,
266 strdata));
267
268 /* Now we can determine whether on refill we have to create a new
269 record or not. */
270 if (he != NULL)
271 {
272 assert (fd == -1);
273
274 if (total + n == dh->allocsize
275 && total - offsetof (struct dataset, resp) == dh->recsize
276 && memcmp (&dataset->resp, dh->data,
277 dh->allocsize - offsetof (struct dataset, resp)) == 0)
278 {
279 /* The data has not changed. We will just bump the
280 timeout value. Note that the new record has been
281 allocated on the stack and need not be freed. */
282 dh->timeout = dataset->head.timeout;
283 ++dh->nreloads;
284
285 /* If the new record was allocated via malloc, then we must free
286 it here. */
287 if (dataset_malloced)
288 free (dataset);
289 }
290 else
291 {
292 /* We have to create a new record. Just allocate
293 appropriate memory and copy it. */
294 struct dataset *newp
295 = (struct dataset *) mempool_alloc (db, total + n, 1);
296 if (newp != NULL)
297 {
298 /* Adjust pointers into the memory block. */
299 gr_name = (char *) newp + (gr_name - (char *) dataset);
300 cp = (char *) newp + (cp - (char *) dataset);
301 key_copy = (char *) newp + (key_copy - (char *) dataset);
302
303 dataset = memcpy (newp, dataset, total + n);
304 dataset_temporary = false;
305 }
306
307 /* Mark the old record as obsolete. */
308 dh->usable = false;
309 }
310 }
311 else
312 {
313 /* We write the dataset before inserting it to the database
314 since while inserting this thread might block and so would
315 unnecessarily let the receiver wait. */
316 assert (fd != -1);
317
318 if (writeall (fd, &dataset->resp, dataset->head.recsize)
319 != dataset->head.recsize)
320 all_written = false;
321 }
322
323 /* Add the record to the database. But only if it has not been
324 stored on the stack. */
325 if (! dataset_temporary)
326 {
327 /* If necessary, we also propagate the data to disk. */
328 if (db->persistent)
329 {
330 // XXX async OK?
331 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
332 msync ((void *) pval,
333 ((uintptr_t) dataset & pagesize_m1) + total + n,
334 MS_ASYNC);
335 }
336
337 /* NB: in the following code we always must add the entry
338 marked with FIRST first. Otherwise we end up with
339 dangling "pointers" in case a latter hash entry cannot be
340 added. */
341 bool first = true;
342
343 /* If the request was by GID, add that entry first. */
344 if (req->type == GETGRBYGID)
345 {
346 if (cache_add (GETGRBYGID, cp, key_offset, &dataset->head, true,
347 db, owner, he == NULL) < 0)
348 goto out;
349
350 first = false;
351 }
352 /* If the key is different from the name add a separate entry. */
353 else if (strcmp (key_copy, gr_name) != 0)
354 {
355 if (cache_add (GETGRBYNAME, key_copy, key_len + 1,
356 &dataset->head, true, db, owner, he == NULL) < 0)
357 goto out;
358
359 first = false;
360 }
361
362 /* We have to add the value for both, byname and byuid. */
363 if ((req->type == GETGRBYNAME || db->propagate)
364 && __builtin_expect (cache_add (GETGRBYNAME, gr_name,
365 gr_name_len,
366 &dataset->head, first, db, owner,
367 he == NULL)
368 == 0, 1))
369 {
370 if (req->type == GETGRBYNAME && db->propagate)
371 (void) cache_add (GETGRBYGID, cp, key_offset, &dataset->head,
372 false, db, owner, false);
373 }
374
375 out:
376 pthread_rwlock_unlock (&db->lock);
377 if (he == NULL && db->propagate)
378 pthread_mutex_unlock (&db->prune_run_lock);
379 }
380 }
381
382 if (__builtin_expect (!all_written, 0) && debug_level > 0)
383 {
384 char buf[256];
385 dbg_log (_("short write in %s: %s"), __FUNCTION__,
386 strerror_r (errno, buf, sizeof (buf)));
387 }
388
389 return timeout;
390}
391
392
393union keytype
394{
395 void *v;
396 gid_t g;
397};
398
399
400static int
401lookup (int type, union keytype key, struct group *resultbufp, char *buffer,
402 size_t buflen, struct group **grp)
403{
404 if (type == GETGRBYNAME)
405 return __getgrnam_r (key.v, resultbufp, buffer, buflen, grp);
406 else
407 return __getgrgid_r (key.g, resultbufp, buffer, buflen, grp);
408}
409
410
411static time_t
412addgrbyX (struct database_dyn *db, int fd, request_header *req,
413 union keytype key, const char *keystr, uid_t uid,
414 struct hashentry *he, struct datahead *dh)
415{
416 /* Search for the entry matching the key. Please note that we don't
417 look again in the table whether the dataset is now available. We
418 simply insert it. It does not matter if it is in there twice. The
419 pruning function only will look at the timestamp. */
420
421 struct group resultbuf;
422 struct group *grp;
423 int errval = 0;
424 struct scratch_buffer tmpbuf;
425 scratch_buffer_init (&tmpbuf);
426
427 if (__glibc_unlikely (debug_level > 0))
428 {
429 if (he == NULL)
430 dbg_log (_("Haven't found \"%s\" in group cache!"), keystr);
431 else
432 dbg_log (_("Reloading \"%s\" in group cache!"), keystr);
433 }
434
435 while (lookup (req->type, key, &resultbuf,
436 tmpbuf.data, tmpbuf.length, &grp) != 0
437 && (errval = errno) == ERANGE)
438 if (!scratch_buffer_grow (&tmpbuf))
439 {
440 /* We ran out of memory. We cannot do anything but sending a
441 negative response. In reality this should never
442 happen. */
443 grp = NULL;
444 /* We set the error to indicate this is (possibly) a temporary
445 error and that it does not mean the entry is not available
446 at all. */
447 errval = EAGAIN;
448 break;
449 }
450
451 time_t timeout = cache_addgr (db, fd, req, keystr, grp, uid, he, dh, errval);
452 scratch_buffer_free (&tmpbuf);
453 return timeout;
454}
455
456
457void
458addgrbyname (struct database_dyn *db, int fd, request_header *req,
459 void *key, uid_t uid)
460{
461 union keytype u = { .v = key };
462
463 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
464}
465
466
467time_t
468readdgrbyname (struct database_dyn *db, struct hashentry *he,
469 struct datahead *dh)
470{
471 request_header req =
472 {
473 .type = GETGRBYNAME,
474 .key_len = he->len
475 };
476 union keytype u = { .v = db->data + he->key };
477
478 return addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);
479}
480
481
482void
483addgrbygid (struct database_dyn *db, int fd, request_header *req,
484 void *key, uid_t uid)
485{
486 char *ep;
487 gid_t gid = strtoul ((char *) key, &ep, 10);
488
489 if (*(char *) key == '\0' || *ep != '\0') /* invalid numeric uid */
490 {
491 if (debug_level > 0)
492 dbg_log (_("Invalid numeric gid \"%s\"!"), (char *) key);
493
494 errno = EINVAL;
495 return;
496 }
497
498 union keytype u = { .g = gid };
499
500 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
501}
502
503
504time_t
505readdgrbygid (struct database_dyn *db, struct hashentry *he,
506 struct datahead *dh)
507{
508 char *ep;
509 gid_t gid = strtoul (db->data + he->key, &ep, 10);
510
511 /* Since the key has been added before it must be OK. */
512 assert (*(db->data + he->key) != '\0' && *ep == '\0');
513
514 request_header req =
515 {
516 .type = GETGRBYGID,
517 .key_len = he->len
518 };
519 union keytype u = { .g = gid };
520
521 return addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);
522}
523