1 /* Cache handling for group lookup.
2 Copyright (C) 1998-2008, 2009, 2011 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
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. */
34 #include <sys/socket.h>
35 #include <stackinfo.h>
40 # include <kernel-features.h>
43 /* This is the standard reply in case the service is disabled. */
44 static const gr_response_header disabled
=
46 .version
= NSCD_VERSION
,
54 /* This is the struct describing how to write this record. */
55 const struct iovec grp_iov_disabled
=
57 .iov_base
= (void *) &disabled
,
58 .iov_len
= sizeof (disabled
)
62 /* This is the standard reply in case we haven't found the dataset. */
63 static const gr_response_header notfound
=
65 .version
= NSCD_VERSION
,
75 cache_addgr (struct database_dyn
*db
, int fd
, request_header
*req
,
76 const void *key
, struct group
*grp
, uid_t owner
,
77 struct hashentry
*const he
, struct datahead
*dh
, int errval
)
81 time_t t
= time (NULL
);
83 /* We allocate all data in one memory block: the iov vector,
84 the response header and the dataset itself. */
88 gr_response_header resp
;
92 assert (offsetof (struct dataset
, resp
) == offsetof (struct datahead
, data
));
94 time_t timeout
= MAX_TIMEOUT_VALUE
;
97 if (he
!= NULL
&& errval
== EAGAIN
)
99 /* If we have an old record available but cannot find one
100 now because the service is not available we keep the old
101 record and make sure it does not get removed. */
102 if (reload_count
!= UINT_MAX
)
103 /* Do not reset the value if we never not reload the record. */
104 dh
->nreloads
= reload_count
- 1;
106 /* Reload with the same time-to-live value. */
107 timeout
= dh
->timeout
= t
+ db
->postimeout
;
113 /* We have no data. This means we send the standard reply for this
115 total
= sizeof (notfound
);
117 written
= TEMP_FAILURE_RETRY (send (fd
, ¬found
, total
,
120 dataset
= mempool_alloc (db
, sizeof (struct dataset
) + req
->key_len
,
122 /* If we cannot permanently store the result, so be it. */
125 dataset
->head
.allocsize
= sizeof (struct dataset
) + req
->key_len
;
126 dataset
->head
.recsize
= total
;
127 dataset
->head
.notfound
= true;
128 dataset
->head
.nreloads
= 0;
129 dataset
->head
.usable
= true;
131 /* Compute the timeout time. */
132 timeout
= dataset
->head
.timeout
= t
+ db
->negtimeout
;
134 /* This is the reply. */
135 memcpy (&dataset
->resp
, ¬found
, total
);
137 /* Copy the key data. */
138 memcpy (dataset
->strdata
, key
, req
->key_len
);
140 /* If necessary, we also propagate the data to disk. */
144 uintptr_t pval
= (uintptr_t) dataset
& ~pagesize_m1
;
145 msync ((void *) pval
,
146 ((uintptr_t) dataset
& pagesize_m1
)
147 + sizeof (struct dataset
) + req
->key_len
, MS_ASYNC
);
150 (void) cache_add (req
->type
, &dataset
->strdata
, req
->key_len
,
151 &dataset
->head
, true, db
, owner
, he
== NULL
);
153 pthread_rwlock_unlock (&db
->lock
);
155 /* Mark the old entry as obsolete. */
163 /* Determine the I/O structure. */
164 size_t gr_name_len
= strlen (grp
->gr_name
) + 1;
165 size_t gr_passwd_len
= strlen (grp
->gr_passwd
) + 1;
166 size_t gr_mem_cnt
= 0;
167 uint32_t *gr_mem_len
;
168 size_t gr_mem_len_total
= 0;
171 const size_t key_len
= strlen (key
);
172 const size_t buf_len
= 3 * sizeof (grp
->gr_gid
) + key_len
+ 1;
173 char *buf
= alloca (buf_len
);
177 /* We need this to insert the `bygid' entry. */
179 n
= snprintf (buf
, buf_len
, "%d%c%n%s", grp
->gr_gid
, '\0',
180 &key_offset
, (char *) key
) + 1;
182 /* Determine the length of all members. */
183 while (grp
->gr_mem
[gr_mem_cnt
])
185 gr_mem_len
= (uint32_t *) alloca (gr_mem_cnt
* sizeof (uint32_t));
186 for (gr_mem_cnt
= 0; grp
->gr_mem
[gr_mem_cnt
]; ++gr_mem_cnt
)
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
];
192 written
= total
= (offsetof (struct dataset
, strdata
)
193 + gr_mem_cnt
* sizeof (uint32_t)
194 + gr_name_len
+ gr_passwd_len
+ gr_mem_len_total
);
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 alloca_used
= false;
204 dataset
= (struct dataset
*) mempool_alloc (db
, total
+ n
, 1);
208 /* We cannot permanently add the result in the moment. But
209 we can provide the result as is. Store the data in some
211 dataset
= (struct dataset
*) alloca (total
+ n
);
213 /* We cannot add this record to the permanent database. */
217 dataset
->head
.allocsize
= total
+ n
;
218 dataset
->head
.recsize
= total
- offsetof (struct dataset
, resp
);
219 dataset
->head
.notfound
= false;
220 dataset
->head
.nreloads
= he
== NULL
? 0 : (dh
->nreloads
+ 1);
221 dataset
->head
.usable
= true;
223 /* Compute the timeout time. */
224 timeout
= dataset
->head
.timeout
= t
+ db
->postimeout
;
226 dataset
->resp
.version
= NSCD_VERSION
;
227 dataset
->resp
.found
= 1;
228 dataset
->resp
.gr_name_len
= gr_name_len
;
229 dataset
->resp
.gr_passwd_len
= gr_passwd_len
;
230 dataset
->resp
.gr_gid
= grp
->gr_gid
;
231 dataset
->resp
.gr_mem_cnt
= gr_mem_cnt
;
233 cp
= dataset
->strdata
;
235 /* This is the member string length array. */
236 cp
= mempcpy (cp
, gr_mem_len
, gr_mem_cnt
* sizeof (uint32_t));
238 cp
= mempcpy (cp
, grp
->gr_name
, gr_name_len
);
239 cp
= mempcpy (cp
, grp
->gr_passwd
, gr_passwd_len
);
241 for (cnt
= 0; cnt
< gr_mem_cnt
; ++cnt
)
242 cp
= mempcpy (cp
, grp
->gr_mem
[cnt
], gr_mem_len
[cnt
]);
244 /* Finally the stringified GID value. */
246 char *key_copy
= cp
+ key_offset
;
247 assert (key_copy
== (char *) rawmemchr (cp
, '\0') + 1);
249 assert (cp
== dataset
->strdata
+ total
- offsetof (struct dataset
,
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
, 1);
277 /* Adjust pointers into the memory block. */
278 gr_name
= (char *) newp
+ (gr_name
- (char *) dataset
);
279 cp
= (char *) newp
+ (cp
- (char *) dataset
);
280 key_copy
= (char *) newp
+ (key_copy
- (char *) dataset
);
282 dataset
= memcpy (newp
, dataset
, total
+ n
);
286 /* Mark the old record as obsolete. */
292 /* We write the dataset before inserting it to the database
293 since while inserting this thread might block and so would
294 unnecessarily let the receiver wait. */
298 if (__builtin_expect (db
->mmap_used
, 1) && !alloca_used
)
300 assert (db
->wr_fd
!= -1);
301 assert ((char *) &dataset
->resp
> (char *) db
->data
);
302 assert ((char *) dataset
- (char *) db
->head
304 <= (sizeof (struct database_pers_head
)
305 + db
->head
->module
* sizeof (ref_t
)
306 + db
->head
->data_size
));
307 written
= sendfileall (fd
, db
->wr_fd
,
308 (char *) &dataset
->resp
309 - (char *) db
->head
, dataset
->head
.recsize
);
310 # ifndef __ASSUME_SENDFILE
311 if (written
== -1 && errno
== ENOSYS
)
316 # ifndef __ASSUME_SENDFILE
320 written
= writeall (fd
, &dataset
->resp
, dataset
->head
.recsize
);
323 /* Add the record to the database. But only if it has not been
324 stored on the stack. */
327 /* If necessary, we also propagate the data to disk. */
331 uintptr_t pval
= (uintptr_t) dataset
& ~pagesize_m1
;
332 msync ((void *) pval
,
333 ((uintptr_t) dataset
& pagesize_m1
) + total
+ n
,
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
343 /* If the request was by GID, add that entry first. */
344 if (req
->type
== GETGRBYGID
)
346 if (cache_add (GETGRBYGID
, cp
, key_offset
, &dataset
->head
, true,
347 db
, owner
, he
== NULL
) < 0)
352 /* If the key is different from the name add a separate entry. */
353 else if (strcmp (key_copy
, gr_name
) != 0)
355 if (cache_add (GETGRBYNAME
, key_copy
, key_len
+ 1,
356 &dataset
->head
, true, db
, owner
, he
== NULL
) < 0)
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
,
366 &dataset
->head
, first
, db
, owner
,
370 if (req
->type
== GETGRBYNAME
&& db
->propagate
)
371 (void) cache_add (GETGRBYGID
, cp
, key_offset
, &dataset
->head
,
372 false, db
, owner
, false);
376 pthread_rwlock_unlock (&db
->lock
);
380 if (__builtin_expect (written
!= total
, 0) && debug_level
> 0)
383 dbg_log (_("short write in %s: %s"), __FUNCTION__
,
384 strerror_r (errno
, buf
, sizeof (buf
)));
399 lookup (int type
, union keytype key
, struct group
*resultbufp
, char *buffer
,
400 size_t buflen
, struct group
**grp
)
402 if (type
== GETGRBYNAME
)
403 return __getgrnam_r (key
.v
, resultbufp
, buffer
, buflen
, grp
);
405 return __getgrgid_r (key
.g
, resultbufp
, buffer
, buflen
, grp
);
410 addgrbyX (struct database_dyn
*db
, int fd
, request_header
*req
,
411 union keytype key
, const char *keystr
, uid_t uid
,
412 struct hashentry
*he
, struct datahead
*dh
)
414 /* Search for the entry matching the key. Please note that we don't
415 look again in the table whether the dataset is now available. We
416 simply insert it. It does not matter if it is in there twice. The
417 pruning function only will look at the timestamp. */
418 size_t buflen
= 1024;
419 char *buffer
= (char *) alloca (buflen
);
420 struct group resultbuf
;
422 bool use_malloc
= false;
425 if (__builtin_expect (debug_level
> 0, 0))
428 dbg_log (_("Haven't found \"%s\" in group cache!"), keystr
);
430 dbg_log (_("Reloading \"%s\" in group cache!"), keystr
);
433 while (lookup (req
->type
, key
, &resultbuf
, buffer
, buflen
, &grp
) != 0
434 && (errval
= errno
) == ERANGE
)
438 if (__builtin_expect (buflen
> 32768, 0))
440 char *old_buffer
= buffer
;
442 buffer
= (char *) realloc (use_malloc
? buffer
: NULL
, buflen
);
445 /* We ran out of memory. We cannot do anything but
446 sending a negative response. In reality this should
451 /* We set the error to indicate this is (possibly) a
452 temporary error and that it does not mean the entry
453 is not available at all. */
460 /* Allocate a new buffer on the stack. If possible combine it
461 with the previously allocated buffer. */
462 buffer
= (char *) extend_alloca (buffer
, buflen
, 2 * buflen
);
465 time_t timeout
= cache_addgr (db
, fd
, req
, keystr
, grp
, uid
, he
, dh
, errval
);
475 addgrbyname (struct database_dyn
*db
, int fd
, request_header
*req
,
476 void *key
, uid_t uid
)
478 union keytype u
= { .v
= key
};
480 addgrbyX (db
, fd
, req
, u
, key
, uid
, NULL
, NULL
);
485 readdgrbyname (struct database_dyn
*db
, struct hashentry
*he
,
493 union keytype u
= { .v
= db
->data
+ he
->key
};
495 return addgrbyX (db
, -1, &req
, u
, db
->data
+ he
->key
, he
->owner
, he
, dh
);
500 addgrbygid (struct database_dyn
*db
, int fd
, request_header
*req
,
501 void *key
, uid_t uid
)
504 gid_t gid
= strtoul ((char *) key
, &ep
, 10);
506 if (*(char *) key
== '\0' || *ep
!= '\0') /* invalid numeric uid */
509 dbg_log (_("Invalid numeric gid \"%s\"!"), (char *) key
);
515 union keytype u
= { .g
= gid
};
517 addgrbyX (db
, fd
, req
, u
, key
, uid
, NULL
, NULL
);
522 readdgrbygid (struct database_dyn
*db
, struct hashentry
*he
,
526 gid_t gid
= strtoul (db
->data
+ he
->key
, &ep
, 10);
528 /* Since the key has been added before it must be OK. */
529 assert (*(db
->data
+ he
->key
) != '\0' && *ep
== '\0');
536 union keytype u
= { .g
= gid
};
538 return addgrbyX (db
, -1, &req
, u
, db
->data
+ he
->key
, he
->owner
, he
, dh
);