* posix/globtest.sh: Use mktemp to create temporary file and
[glibc.git] / nscd / initgrcache.c
blobc5693c6be534e70930418a3bac95b29918810f72
1 /* Cache handling for host lookup.
2 Copyright (C) 2004, 2005, 2006, 2008 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, write to the Free Software Foundation,
18 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20 #include <assert.h>
21 #include <errno.h>
22 #include <grp.h>
23 #include <libintl.h>
24 #include <string.h>
25 #include <time.h>
26 #include <unistd.h>
27 #include <sys/mman.h>
29 #include "dbg_log.h"
30 #include "nscd.h"
31 #ifdef HAVE_SENDFILE
32 # include <kernel-features.h>
33 #endif
35 #include "../nss/nsswitch.h"
38 /* Type of the lookup function. */
39 typedef enum nss_status (*initgroups_dyn_function) (const char *, gid_t,
40 long int *, long int *,
41 gid_t **, long int, int *);
44 static const initgr_response_header notfound =
46 .version = NSCD_VERSION,
47 .found = 0,
48 .ngrps = 0
52 #include "../grp/compat-initgroups.c"
55 static void
56 addinitgroupsX (struct database_dyn *db, int fd, request_header *req,
57 void *key, uid_t uid, struct hashentry *he,
58 struct datahead *dh)
60 /* Search for the entry matching the key. Please note that we don't
61 look again in the table whether the dataset is now available. We
62 simply insert it. It does not matter if it is in there twice. The
63 pruning function only will look at the timestamp. */
66 /* We allocate all data in one memory block: the iov vector,
67 the response header and the dataset itself. */
68 struct dataset
70 struct datahead head;
71 initgr_response_header resp;
72 char strdata[0];
73 } *dataset = NULL;
75 if (__builtin_expect (debug_level > 0, 0))
77 if (he == NULL)
78 dbg_log (_("Haven't found \"%s\" in group cache!"), (char *) key);
79 else
80 dbg_log (_("Reloading \"%s\" in group cache!"), (char *) key);
83 static service_user *group_database;
84 service_user *nip = NULL;
85 int no_more;
87 if (group_database != NULL)
89 nip = group_database;
90 no_more = 0;
92 else
93 no_more = __nss_database_lookup ("group", NULL,
94 "compat [NOTFOUND=return] files", &nip);
96 /* We always use sysconf even if NGROUPS_MAX is defined. That way, the
97 limit can be raised in the kernel configuration without having to
98 recompile libc. */
99 long int limit = __sysconf (_SC_NGROUPS_MAX);
101 long int size;
102 if (limit > 0)
103 /* We limit the size of the intially allocated array. */
104 size = MIN (limit, 64);
105 else
106 /* No fixed limit on groups. Pick a starting buffer size. */
107 size = 16;
109 long int start = 0;
110 bool all_tryagain = true;
111 bool any_success = false;
113 /* This is temporary memory, we need not (and must not) call
114 mempool_alloc. */
115 // XXX This really should use alloca. need to change the backends.
116 gid_t *groups = (gid_t *) malloc (size * sizeof (gid_t));
117 if (__builtin_expect (groups == NULL, 0))
118 /* No more memory. */
119 goto out;
121 /* Nothing added yet. */
122 while (! no_more)
124 long int prev_start = start;
125 enum nss_status status;
126 initgroups_dyn_function fct;
127 fct = __nss_lookup_function (nip, "initgroups_dyn");
129 if (fct == NULL)
131 status = compat_call (nip, key, -1, &start, &size, &groups,
132 limit, &errno);
134 if (nss_next_action (nip, NSS_STATUS_UNAVAIL) != NSS_ACTION_CONTINUE)
135 break;
137 else
138 status = DL_CALL_FCT (fct, (key, -1, &start, &size, &groups,
139 limit, &errno));
141 /* Remove duplicates. */
142 long int cnt = prev_start;
143 while (cnt < start)
145 long int inner;
146 for (inner = 0; inner < prev_start; ++inner)
147 if (groups[inner] == groups[cnt])
148 break;
150 if (inner < prev_start)
151 groups[cnt] = groups[--start];
152 else
153 ++cnt;
156 if (status != NSS_STATUS_TRYAGAIN)
157 all_tryagain = false;
159 /* This is really only for debugging. */
160 if (NSS_STATUS_TRYAGAIN > status || status > NSS_STATUS_RETURN)
161 __libc_fatal ("illegal status in internal_getgrouplist");
163 any_success |= status == NSS_STATUS_SUCCESS;
165 if (status != NSS_STATUS_SUCCESS
166 && nss_next_action (nip, status) == NSS_ACTION_RETURN)
167 break;
169 if (nip->next == NULL)
170 no_more = -1;
171 else
172 nip = nip->next;
175 ssize_t total;
176 ssize_t written;
177 out:
178 if (!any_success)
180 /* Nothing found. Create a negative result record. */
181 written = total = sizeof (notfound);
183 if (he != NULL && all_tryagain)
185 /* If we have an old record available but cannot find one now
186 because the service is not available we keep the old record
187 and make sure it does not get removed. */
188 if (reload_count != UINT_MAX && dh->nreloads == reload_count)
189 /* Do not reset the value if we never not reload the record. */
190 dh->nreloads = reload_count - 1;
192 else
194 /* We have no data. This means we send the standard reply for this
195 case. */
196 if (fd != -1)
197 written = TEMP_FAILURE_RETRY (send (fd, &notfound, total,
198 MSG_NOSIGNAL));
200 dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len,
201 IDX_result_data);
202 /* If we cannot permanently store the result, so be it. */
203 if (dataset != NULL)
205 dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
206 dataset->head.recsize = total;
207 dataset->head.notfound = true;
208 dataset->head.nreloads = 0;
209 dataset->head.usable = true;
211 /* Compute the timeout time. */
212 dataset->head.timeout = time (NULL) + db->negtimeout;
214 /* This is the reply. */
215 memcpy (&dataset->resp, &notfound, total);
217 /* Copy the key data. */
218 char *key_copy = memcpy (dataset->strdata, key, req->key_len);
220 /* If necessary, we also propagate the data to disk. */
221 if (db->persistent)
223 // XXX async OK?
224 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
225 msync ((void *) pval,
226 ((uintptr_t) dataset & pagesize_m1)
227 + sizeof (struct dataset) + req->key_len, MS_ASYNC);
230 /* Now get the lock to safely insert the records. */
231 pthread_rwlock_rdlock (&db->lock);
233 (void) cache_add (req->type, key_copy, req->key_len,
234 &dataset->head, true, db, uid, he == NULL);
236 pthread_rwlock_unlock (&db->lock);
238 /* Mark the old entry as obsolete. */
239 if (dh != NULL)
240 dh->usable = false;
242 else
243 ++db->head->addfailed;
246 else
249 written = total = (offsetof (struct dataset, strdata)
250 + start * sizeof (int32_t));
252 /* If we refill the cache, first assume the reconrd did not
253 change. Allocate memory on the cache since it is likely
254 discarded anyway. If it turns out to be necessary to have a
255 new record we can still allocate real memory. */
256 bool alloca_used = false;
257 dataset = NULL;
259 if (he == NULL)
261 dataset = (struct dataset *) mempool_alloc (db,
262 total + req->key_len,
263 IDX_result_data);
264 if (dataset == NULL)
265 ++db->head->addfailed;
268 if (dataset == NULL)
270 /* We cannot permanently add the result in the moment. But
271 we can provide the result as is. Store the data in some
272 temporary memory. */
273 dataset = (struct dataset *) alloca (total + req->key_len);
275 /* We cannot add this record to the permanent database. */
276 alloca_used = true;
279 dataset->head.allocsize = total + req->key_len;
280 dataset->head.recsize = total - offsetof (struct dataset, resp);
281 dataset->head.notfound = false;
282 dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
283 dataset->head.usable = true;
285 /* Compute the timeout time. */
286 dataset->head.timeout = time (NULL) + db->postimeout;
288 dataset->resp.version = NSCD_VERSION;
289 dataset->resp.found = 1;
290 dataset->resp.ngrps = start;
292 char *cp = dataset->strdata;
294 /* Copy the GID values. If the size of the types match this is
295 very simple. */
296 if (sizeof (gid_t) == sizeof (int32_t))
297 cp = mempcpy (cp, groups, start * sizeof (gid_t));
298 else
300 gid_t *gcp = (gid_t *) cp;
302 for (int i = 0; i < start; ++i)
303 *gcp++ = groups[i];
305 cp = (char *) gcp;
308 /* Finally the user name. */
309 memcpy (cp, key, req->key_len);
311 assert (cp == dataset->strdata + total - offsetof (struct dataset,
312 strdata));
314 /* Now we can determine whether on refill we have to create a new
315 record or not. */
316 if (he != NULL)
318 assert (fd == -1);
320 if (total + req->key_len == dh->allocsize
321 && total - offsetof (struct dataset, resp) == dh->recsize
322 && memcmp (&dataset->resp, dh->data,
323 dh->allocsize - offsetof (struct dataset, resp)) == 0)
325 /* The data has not changed. We will just bump the
326 timeout value. Note that the new record has been
327 allocated on the stack and need not be freed. */
328 dh->timeout = dataset->head.timeout;
329 ++dh->nreloads;
331 else
333 /* We have to create a new record. Just allocate
334 appropriate memory and copy it. */
335 struct dataset *newp
336 = (struct dataset *) mempool_alloc (db, total + req->key_len,
337 IDX_result_data);
338 if (newp != NULL)
340 /* Adjust pointer into the memory block. */
341 cp = (char *) newp + (cp - (char *) dataset);
343 dataset = memcpy (newp, dataset, total + req->key_len);
344 alloca_used = false;
346 else
347 ++db->head->addfailed;
349 /* Mark the old record as obsolete. */
350 dh->usable = false;
353 else
355 /* We write the dataset before inserting it to the database
356 since while inserting this thread might block and so would
357 unnecessarily let the receiver wait. */
358 assert (fd != -1);
360 #ifdef HAVE_SENDFILE
361 if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
363 assert (db->wr_fd != -1);
364 assert ((char *) &dataset->resp > (char *) db->data);
365 assert ((char *) &dataset->resp - (char *) db->head
366 + total
367 <= (sizeof (struct database_pers_head)
368 + db->head->module * sizeof (ref_t)
369 + db->head->data_size));
370 written = sendfileall (fd, db->wr_fd,
371 (char *) &dataset->resp
372 - (char *) db->head, total);
373 # ifndef __ASSUME_SENDFILE
374 if (written == -1 && errno == ENOSYS)
375 goto use_write;
376 # endif
378 else
379 # ifndef __ASSUME_SENDFILE
380 use_write:
381 # endif
382 #endif
383 written = writeall (fd, &dataset->resp, total);
387 /* Add the record to the database. But only if it has not been
388 stored on the stack. */
389 if (! alloca_used)
391 /* If necessary, we also propagate the data to disk. */
392 if (db->persistent)
394 // XXX async OK?
395 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
396 msync ((void *) pval,
397 ((uintptr_t) dataset & pagesize_m1) + total +
398 req->key_len, MS_ASYNC);
401 /* Now get the lock to safely insert the records. */
402 pthread_rwlock_rdlock (&db->lock);
404 (void) cache_add (INITGROUPS, cp, req->key_len, &dataset->head, true,
405 db, uid, he == NULL);
407 pthread_rwlock_unlock (&db->lock);
411 free (groups);
413 if (__builtin_expect (written != total, 0) && debug_level > 0)
415 char buf[256];
416 dbg_log (_("short write in %s: %s"), __FUNCTION__,
417 strerror_r (errno, buf, sizeof (buf)));
422 void
423 addinitgroups (struct database_dyn *db, int fd, request_header *req, void *key,
424 uid_t uid)
426 addinitgroupsX (db, fd, req, key, uid, NULL, NULL);
430 void
431 readdinitgroups (struct database_dyn *db, struct hashentry *he,
432 struct datahead *dh)
434 request_header req =
436 .type = INITGROUPS,
437 .key_len = he->len
440 addinitgroupsX (db, -1, &req, db->data + he->key, he->owner, he, dh);