1 /* Cache handling for host lookup.
2 Copyright (C) 2004-2020 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@redhat.com>, 2004.
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, see <https://www.gnu.org/licenses/>. */
27 #include <scratch_buffer.h>
33 #include "../nss/nsswitch.h"
35 /* Type of the lookup function. */
36 typedef enum nss_status (*initgroups_dyn_function) (const char *, gid_t,
37 long int *, long int *,
38 gid_t **, long int, int *);
41 static const initgr_response_header notfound =
43 .version = NSCD_VERSION,
49 #include "../grp/compat-initgroups.c"
53 addinitgroupsX (struct database_dyn *db, int fd, request_header *req,
54 void *key, uid_t uid, struct hashentry *const he,
57 /* Search for the entry matching the key. Please note that we don't
58 look again in the table whether the dataset is now available. We
59 simply insert it. It does not matter if it is in there twice. The
60 pruning function only will look at the timestamp. */
63 /* We allocate all data in one memory block: the iov vector,
64 the response header and the dataset itself. */
68 initgr_response_header resp;
72 if (__glibc_unlikely (debug_level > 0))
75 dbg_log (_("Haven't found \"%s\" in group cache!"), (char *) key);
77 dbg_log (_("Reloading \"%s\" in group cache!"), (char *) key);
80 static service_user *group_database;
84 if (group_database == NULL)
85 no_more = __nss_database_lookup2 ("group", NULL, "files",
91 /* We always use sysconf even if NGROUPS_MAX is defined. That way, the
92 limit can be raised in the kernel configuration without having to
94 long int limit = __sysconf (_SC_NGROUPS_MAX);
98 /* We limit the size of the intially allocated array. */
99 size = MIN (limit, 64);
101 /* No fixed limit on groups. Pick a starting buffer size. */
105 bool all_tryagain = true;
106 bool any_success = false;
108 /* This is temporary memory, we need not (and must not) call
110 // XXX This really should use alloca. need to change the backends.
111 gid_t *groups = (gid_t *) malloc (size * sizeof (gid_t));
112 if (__glibc_unlikely (groups == NULL))
113 /* No more memory. */
116 /* Nothing added yet. */
119 long int prev_start = start;
120 enum nss_status status;
121 initgroups_dyn_function fct;
122 fct = __nss_lookup_function (nip, "initgroups_dyn");
126 status = compat_call (nip, key, -1, &start, &size, &groups,
129 if (nss_next_action (nip, NSS_STATUS_UNAVAIL) != NSS_ACTION_CONTINUE)
133 status = DL_CALL_FCT (fct, (key, -1, &start, &size, &groups,
136 /* Remove duplicates. */
137 long int cnt = prev_start;
141 for (inner = 0; inner < prev_start; ++inner)
142 if (groups[inner] == groups[cnt])
145 if (inner < prev_start)
146 groups[cnt] = groups[--start];
151 if (status != NSS_STATUS_TRYAGAIN)
152 all_tryagain = false;
154 /* This is really only for debugging. */
155 if (NSS_STATUS_TRYAGAIN > status || status > NSS_STATUS_RETURN)
156 __libc_fatal ("Illegal status in internal_getgrouplist.\n");
158 any_success |= status == NSS_STATUS_SUCCESS;
160 if (status != NSS_STATUS_SUCCESS
161 && nss_next_action (nip, status) == NSS_ACTION_RETURN)
164 if (nip->next == NULL)
175 timeout = MAX_TIMEOUT_VALUE;
178 /* Nothing found. Create a negative result record. */
179 total = sizeof (notfound);
181 if (he != NULL && all_tryagain)
183 /* If we have an old record available but cannot find one now
184 because the service is not available we keep the old record
185 and make sure it does not get removed. */
186 if (reload_count != UINT_MAX && dh->nreloads == reload_count)
187 /* Do not reset the value if we never not reload the record. */
188 dh->nreloads = reload_count - 1;
190 /* Reload with the same time-to-live value. */
191 timeout = dh->timeout = time (NULL) + db->postimeout;
195 /* We have no data. This means we send the standard reply for this
198 && TEMP_FAILURE_RETRY (send (fd, ¬found, total,
199 MSG_NOSIGNAL)) != total)
202 /* If we have a transient error or cannot permanently store
203 the result, so be it. */
204 if (all_tryagain || __builtin_expect (db->negtimeout == 0, 0))
206 /* Mark the old entry as obsolete. */
210 else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
211 + req->key_len), 1)) != NULL)
213 timeout = datahead_init_neg (&dataset->head,
214 (sizeof (struct dataset)
215 + req->key_len), total,
218 /* This is the reply. */
219 memcpy (&dataset->resp, ¬found, total);
221 /* Copy the key data. */
222 char *key_copy = memcpy (dataset->strdata, key, req->key_len);
224 /* If necessary, we also propagate the data to disk. */
228 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
229 msync ((void *) pval,
230 ((uintptr_t) dataset & pagesize_m1)
231 + sizeof (struct dataset) + req->key_len, MS_ASYNC);
234 (void) cache_add (req->type, key_copy, req->key_len,
235 &dataset->head, true, db, uid, he == NULL);
237 pthread_rwlock_unlock (&db->lock);
239 /* Mark the old entry as obsolete. */
248 total = offsetof (struct dataset, strdata) + start * sizeof (int32_t);
250 /* If we refill the cache, first assume the reconrd did not
251 change. Allocate memory on the cache since it is likely
252 discarded anyway. If it turns out to be necessary to have a
253 new record we can still allocate real memory. */
254 bool alloca_used = false;
258 dataset = (struct dataset *) mempool_alloc (db, total + req->key_len,
263 /* We cannot permanently add the result in the moment. But
264 we can provide the result as is. Store the data in some
266 dataset = (struct dataset *) alloca (total + req->key_len);
268 /* We cannot add this record to the permanent database. */
272 timeout = datahead_init_pos (&dataset->head, total + req->key_len,
273 total - offsetof (struct dataset, resp),
274 he == NULL ? 0 : dh->nreloads + 1,
277 dataset->resp.version = NSCD_VERSION;
278 dataset->resp.found = 1;
279 dataset->resp.ngrps = start;
281 char *cp = dataset->strdata;
283 /* Copy the GID values. If the size of the types match this is
285 if (sizeof (gid_t) == sizeof (int32_t))
286 cp = mempcpy (cp, groups, start * sizeof (gid_t));
289 gid_t *gcp = (gid_t *) cp;
291 for (int i = 0; i < start; ++i)
297 /* Finally the user name. */
298 memcpy (cp, key, req->key_len);
300 assert (cp == dataset->strdata + total - offsetof (struct dataset,
303 /* Now we can determine whether on refill we have to create a new
309 if (total + req->key_len == dh->allocsize
310 && total - offsetof (struct dataset, resp) == dh->recsize
311 && memcmp (&dataset->resp, dh->data,
312 dh->allocsize - offsetof (struct dataset, resp)) == 0)
314 /* The data has not changed. We will just bump the
315 timeout value. Note that the new record has been
316 allocated on the stack and need not be freed. */
317 dh->timeout = dataset->head.timeout;
322 /* We have to create a new record. Just allocate
323 appropriate memory and copy it. */
325 = (struct dataset *) mempool_alloc (db, total + req->key_len,
329 /* Adjust pointer into the memory block. */
330 cp = (char *) newp + (cp - (char *) dataset);
332 dataset = memcpy (newp, dataset, total + req->key_len);
336 /* Mark the old record as obsolete. */
342 /* We write the dataset before inserting it to the database
343 since while inserting this thread might block and so would
344 unnecessarily let the receiver wait. */
347 if (writeall (fd, &dataset->resp, dataset->head.recsize)
348 != dataset->head.recsize)
353 /* Add the record to the database. But only if it has not been
354 stored on the stack. */
357 /* If necessary, we also propagate the data to disk. */
361 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
362 msync ((void *) pval,
363 ((uintptr_t) dataset & pagesize_m1) + total
364 + req->key_len, MS_ASYNC);
367 (void) cache_add (INITGROUPS, cp, req->key_len, &dataset->head, true,
368 db, uid, he == NULL);
370 pthread_rwlock_unlock (&db->lock);
376 if (__builtin_expect (!all_written, 0) && debug_level > 0)
379 dbg_log (_("short write in %s: %s"), __FUNCTION__,
380 strerror_r (errno, buf, sizeof (buf)));
388 addinitgroups (struct database_dyn *db, int fd, request_header *req, void *key,
391 addinitgroupsX (db, fd, req, key, uid, NULL, NULL);
396 readdinitgroups (struct database_dyn *db, struct hashentry *he,
405 return addinitgroupsX (db, -1, &req, db->data + he->key, he->owner, he, dh);