1 /* Cache handling for group lookup.
2 Copyright (C) 1998-2002, 2003, 2004, 2005 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
11 The GNU C Library 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 GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, write to the Free
18 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
35 #include <stackinfo.h>
40 /* This is the standard reply in case the service is disabled. */
41 static const gr_response_header disabled
=
43 .version
= NSCD_VERSION
,
51 /* This is the struct describing how to write this record. */
52 const struct iovec grp_iov_disabled
=
54 .iov_base
= (void *) &disabled
,
55 .iov_len
= sizeof (disabled
)
59 /* This is the standard reply in case we haven't found the dataset. */
60 static const gr_response_header notfound
=
62 .version
= NSCD_VERSION
,
72 cache_addgr (struct database_dyn
*db
, int fd
, request_header
*req
,
73 const void *key
, struct group
*grp
, uid_t owner
,
74 struct hashentry
*he
, struct datahead
*dh
, int errval
)
78 time_t t
= time (NULL
);
80 /* We allocate all data in one memory block: the iov vector,
81 the response header and the dataset itself. */
85 gr_response_header resp
;
89 assert (offsetof (struct dataset
, resp
) == offsetof (struct datahead
, data
));
93 if (he
!= NULL
&& errval
== EAGAIN
)
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;
106 /* We have no data. This means we send the standard reply for this
108 total
= sizeof (notfound
);
110 written
= TEMP_FAILURE_RETRY (send (fd
, ¬found
, total
,
113 dataset
= mempool_alloc (db
, sizeof (struct dataset
) + req
->key_len
);
114 /* If we cannot permanently store the result, so be it. */
117 dataset
->head
.allocsize
= sizeof (struct dataset
) + req
->key_len
;
118 dataset
->head
.recsize
= total
;
119 dataset
->head
.notfound
= true;
120 dataset
->head
.nreloads
= 0;
121 dataset
->head
.usable
= true;
123 /* Compute the timeout time. */
124 dataset
->head
.timeout
= t
+ db
->negtimeout
;
126 /* This is the reply. */
127 memcpy (&dataset
->resp
, ¬found
, total
);
129 /* Copy the key data. */
130 memcpy (dataset
->strdata
, key
, req
->key_len
);
132 /* If necessary, we also propagate the data to disk. */
136 uintptr_t pval
= (uintptr_t) dataset
& ~pagesize_m1
;
137 msync ((void *) pval
,
138 ((uintptr_t) dataset
& pagesize_m1
)
139 + sizeof (struct dataset
) + req
->key_len
, MS_ASYNC
);
142 /* Now get the lock to safely insert the records. */
143 pthread_rwlock_rdlock (&db
->lock
);
145 if (cache_add (req
->type
, &dataset
->strdata
, req
->key_len
,
146 &dataset
->head
, true, db
, owner
) < 0)
147 /* Ensure the data can be recovered. */
148 dataset
->head
.usable
= false;
150 pthread_rwlock_unlock (&db
->lock
);
152 /* Mark the old entry as obsolete. */
157 ++db
->head
->addfailed
;
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;
170 const size_t key_len
= strlen (key
);
171 const size_t buf_len
= 3 * sizeof (grp
->gr_gid
) + key_len
+ 1;
172 char *buf
= alloca (buf_len
);
176 /* We need this to insert the `bygid' entry. */
178 n
= snprintf (buf
, buf_len
, "%d%c%n%s", grp
->gr_gid
, '\0',
179 &key_offset
, (char *) key
) + 1;
181 /* Determine the length of all members. */
182 while (grp
->gr_mem
[gr_mem_cnt
])
184 gr_mem_len
= (uint32_t *) alloca (gr_mem_cnt
* sizeof (uint32_t));
185 for (gr_mem_cnt
= 0; grp
->gr_mem
[gr_mem_cnt
]; ++gr_mem_cnt
)
187 gr_mem_len
[gr_mem_cnt
] = strlen (grp
->gr_mem
[gr_mem_cnt
]) + 1;
188 gr_mem_len_total
+= gr_mem_len
[gr_mem_cnt
];
191 written
= total
= (sizeof (struct dataset
)
192 + gr_mem_cnt
* sizeof (uint32_t)
193 + gr_name_len
+ gr_passwd_len
+ gr_mem_len_total
);
195 /* If we refill the cache, first assume the reconrd did not
196 change. Allocate memory on the cache since it is likely
197 discarded anyway. If it turns out to be necessary to have a
198 new record we can still allocate real memory. */
199 bool alloca_used
= false;
204 dataset
= (struct dataset
*) mempool_alloc (db
, total
+ n
);
206 ++db
->head
->addfailed
;
211 /* We cannot permanently add the result in the moment. But
212 we can provide the result as is. Store the data in some
214 dataset
= (struct dataset
*) alloca (total
+ n
);
216 /* We cannot add this record to the permanent database. */
220 dataset
->head
.allocsize
= total
+ n
;
221 dataset
->head
.recsize
= total
- offsetof (struct dataset
, resp
);
222 dataset
->head
.notfound
= false;
223 dataset
->head
.nreloads
= he
== NULL
? 0 : (dh
->nreloads
+ 1);
224 dataset
->head
.usable
= true;
226 /* Compute the timeout time. */
227 dataset
->head
.timeout
= t
+ db
->postimeout
;
229 dataset
->resp
.version
= NSCD_VERSION
;
230 dataset
->resp
.found
= 1;
231 dataset
->resp
.gr_name_len
= gr_name_len
;
232 dataset
->resp
.gr_passwd_len
= gr_passwd_len
;
233 dataset
->resp
.gr_gid
= grp
->gr_gid
;
234 dataset
->resp
.gr_mem_cnt
= gr_mem_cnt
;
236 cp
= dataset
->strdata
;
238 /* This is the member string length array. */
239 cp
= mempcpy (cp
, gr_mem_len
, gr_mem_cnt
* sizeof (uint32_t));
241 cp
= mempcpy (cp
, grp
->gr_name
, gr_name_len
);
242 cp
= mempcpy (cp
, grp
->gr_passwd
, gr_passwd_len
);
244 for (cnt
= 0; cnt
< gr_mem_cnt
; ++cnt
)
245 cp
= mempcpy (cp
, grp
->gr_mem
[cnt
], gr_mem_len
[cnt
]);
247 /* Finally the stringified GID value. */
249 char *key_copy
= cp
+ key_offset
;
250 assert (key_copy
== (char *) rawmemchr (cp
, '\0') + 1);
252 /* Now we can determine whether on refill we have to create a new
258 if (total
+ n
== dh
->allocsize
259 && total
- offsetof (struct dataset
, resp
) == dh
->recsize
260 && memcmp (&dataset
->resp
, dh
->data
,
261 dh
->allocsize
- offsetof (struct dataset
, resp
)) == 0)
263 /* The data has not changed. We will just bump the
264 timeout value. Note that the new record has been
265 allocated on the stack and need not be freed. */
266 dh
->timeout
= dataset
->head
.timeout
;
271 /* We have to create a new record. Just allocate
272 appropriate memory and copy it. */
274 = (struct dataset
*) mempool_alloc (db
, total
+ n
);
277 /* Adjust pointers into the memory block. */
278 gr_name
= (char *) newp
+ (gr_name
- (char *) dataset
);
279 cp
= (char *) newp
+ (cp
- (char *) dataset
);
281 dataset
= memcpy (newp
, dataset
, total
+ n
);
285 /* Mark the old record as obsolete. */
291 /* We write the dataset before inserting it to the database
292 since while inserting this thread might block and so would
293 unnecessarily let the receiver wait. */
296 written
= writeall (fd
, &dataset
->resp
, total
);
299 /* Add the record to the database. But only if it has not been
300 stored on the stack. */
303 /* If necessary, we also propagate the data to disk. */
307 uintptr_t pval
= (uintptr_t) dataset
& ~pagesize_m1
;
308 msync ((void *) pval
,
309 ((uintptr_t) dataset
& pagesize_m1
) + total
+ n
,
313 /* Now get the lock to safely insert the records. */
314 pthread_rwlock_rdlock (&db
->lock
);
316 /* NB: in the following code we always must add the entry
317 marked with FIRST first. Otherwise we end up with
318 dangling "pointers" in case a latter hash entry cannot be
320 bool first
= req
->type
== GETGRBYNAME
;
322 /* If the request was by GID, add that entry first. */
323 if (req
->type
!= GETGRBYNAME
)
325 if (cache_add (GETGRBYGID
, cp
, key_offset
, &dataset
->head
, true,
328 /* Could not allocate memory. Make sure the data gets
330 dataset
->head
.usable
= false;
334 /* If the key is different from the name add a separate entry. */
335 else if (strcmp (key_copy
, gr_name
) != 0)
337 if (cache_add (GETGRBYNAME
, key_copy
, key_len
+ 1,
338 &dataset
->head
, first
, db
, owner
) < 0)
340 /* Could not allocate memory. Make sure the data gets
342 dataset
->head
.usable
= false;
349 /* We have to add the value for both, byname and byuid. */
350 if (__builtin_expect (cache_add (GETGRBYNAME
, gr_name
, gr_name_len
,
351 &dataset
->head
, first
, db
, owner
)
354 if (req
->type
== GETGRBYNAME
)
355 (void) cache_add (GETGRBYGID
, cp
, key_offset
, &dataset
->head
,
356 req
->type
!= GETGRBYNAME
, db
, owner
);
359 /* Could not allocate memory. Make sure the data gets
361 dataset
->head
.usable
= false;
364 pthread_rwlock_unlock (&db
->lock
);
368 if (__builtin_expect (written
!= total
, 0) && debug_level
> 0)
371 dbg_log (_("short write in %s: %s"), __FUNCTION__
,
372 strerror_r (errno
, buf
, sizeof (buf
)));
385 lookup (int type
, union keytype key
, struct group
*resultbufp
, char *buffer
,
386 size_t buflen
, struct group
**grp
)
388 if (type
== GETGRBYNAME
)
389 return __getgrnam_r (key
.v
, resultbufp
, buffer
, buflen
, grp
);
391 return __getgrgid_r (key
.g
, resultbufp
, buffer
, buflen
, grp
);
396 addgrbyX (struct database_dyn
*db
, int fd
, request_header
*req
,
397 union keytype key
, const char *keystr
, uid_t uid
,
398 struct hashentry
*he
, struct datahead
*dh
)
400 /* Search for the entry matching the key. Please note that we don't
401 look again in the table whether the dataset is now available. We
402 simply insert it. It does not matter if it is in there twice. The
403 pruning function only will look at the timestamp. */
404 size_t buflen
= 1024;
405 char *buffer
= (char *) alloca (buflen
);
406 struct group resultbuf
;
408 bool use_malloc
= false;
411 if (__builtin_expect (debug_level
> 0, 0))
414 dbg_log (_("Haven't found \"%s\" in group cache!"), keystr
);
416 dbg_log (_("Reloading \"%s\" in group cache!"), keystr
);
423 oldeuid
= geteuid ();
424 pthread_seteuid_np (uid
);
428 while (lookup (req
->type
, key
, &resultbuf
, buffer
, buflen
, &grp
) != 0
429 && (errval
= errno
) == ERANGE
)
431 char *old_buffer
= buffer
;
434 if (__builtin_expect (buflen
> 32768, 0))
437 buffer
= (char *) realloc (use_malloc
? buffer
: NULL
, buflen
);
440 /* We ran out of memory. We cannot do anything but
441 sending a negative response. In reality this should
446 /* We set the error to indicate this is (possibly) a
447 temporary error and that it does not mean the entry
448 is not available at all. */
455 /* Allocate a new buffer on the stack. If possible combine it
456 with the previously allocated buffer. */
457 buffer
= (char *) extend_alloca (buffer
, buflen
, 2 * buflen
);
462 pthread_seteuid_np (oldeuid
);
465 cache_addgr (db
, fd
, req
, keystr
, grp
, uid
, he
, dh
, errval
);
473 addgrbyname (struct database_dyn
*db
, int fd
, request_header
*req
,
474 void *key
, uid_t uid
)
476 union keytype u
= { .v
= key
};
478 addgrbyX (db
, fd
, req
, u
, key
, uid
, NULL
, NULL
);
483 readdgrbyname (struct database_dyn
*db
, struct hashentry
*he
,
491 union keytype u
= { .v
= db
->data
+ he
->key
};
493 addgrbyX (db
, -1, &req
, u
, db
->data
+ he
->key
, he
->owner
, he
, dh
);
498 addgrbygid (struct database_dyn
*db
, int fd
, request_header
*req
,
499 void *key
, uid_t uid
)
502 gid_t gid
= strtoul ((char *) key
, &ep
, 10);
504 if (*(char *) key
== '\0' || *ep
!= '\0') /* invalid numeric uid */
507 dbg_log (_("Invalid numeric gid \"%s\"!"), (char *) key
);
513 union keytype u
= { .g
= gid
};
515 addgrbyX (db
, fd
, req
, u
, key
, uid
, NULL
, NULL
);
520 readdgrbygid (struct database_dyn
*db
, struct hashentry
*he
,
524 gid_t gid
= strtoul (db
->data
+ he
->key
, &ep
, 10);
526 /* Since the key has been added before it must be OK. */
527 assert (*(db
->data
+ he
->key
) != '\0' && *ep
== '\0');
534 union keytype u
= { .g
= gid
};
536 addgrbyX (db
, -1, &req
, u
, db
->data
+ he
->key
, he
->owner
, he
, dh
);