1 /* Cache handling for group lookup.
2 Copyright (C) 1998-2002, 2003, 2004 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 (write (fd
, ¬found
, total
));
112 dataset
= mempool_alloc (db
, sizeof (struct dataset
) + req
->key_len
);
113 /* If we cannot permanently store the result, so be it. */
116 dataset
->head
.allocsize
= sizeof (struct dataset
) + req
->key_len
;
117 dataset
->head
.recsize
= total
;
118 dataset
->head
.notfound
= true;
119 dataset
->head
.nreloads
= 0;
120 dataset
->head
.usable
= true;
122 /* Compute the timeout time. */
123 dataset
->head
.timeout
= t
+ db
->negtimeout
;
125 /* This is the reply. */
126 memcpy (&dataset
->resp
, ¬found
, total
);
128 /* Copy the key data. */
129 memcpy (dataset
->strdata
, key
, req
->key_len
);
131 /* Now get the lock to safely insert the records. */
132 pthread_rwlock_rdlock (&db
->lock
);
134 if (cache_add (req
->type
, &dataset
->strdata
, req
->key_len
,
135 &dataset
->head
, true, db
, owner
) < 0)
136 /* Ensure the data can be recovered. */
137 dataset
->head
.usable
= false;
139 pthread_rwlock_unlock (&db
->lock
);
141 /* Mark the old entry as obsolete. */
146 ++db
->head
->addfailed
;
151 /* Determine the I/O structure. */
152 size_t gr_name_len
= strlen (grp
->gr_name
) + 1;
153 size_t gr_passwd_len
= strlen (grp
->gr_passwd
) + 1;
154 size_t gr_mem_cnt
= 0;
155 uint32_t *gr_mem_len
;
156 size_t gr_mem_len_total
= 0;
159 const size_t key_len
= strlen (key
);
160 const size_t buf_len
= 3 + sizeof (grp
->gr_gid
) + key_len
+ 1;
161 char *buf
= alloca (buf_len
);
165 /* We need this to insert the `bygid' entry. */
167 n
= snprintf (buf
, buf_len
, "%d%c%n%s", grp
->gr_gid
, '\0',
168 &key_offset
, (char *) key
) + 1;
170 /* Determine the length of all members. */
171 while (grp
->gr_mem
[gr_mem_cnt
])
173 gr_mem_len
= (uint32_t *) alloca (gr_mem_cnt
* sizeof (uint32_t));
174 for (gr_mem_cnt
= 0; grp
->gr_mem
[gr_mem_cnt
]; ++gr_mem_cnt
)
176 gr_mem_len
[gr_mem_cnt
] = strlen (grp
->gr_mem
[gr_mem_cnt
]) + 1;
177 gr_mem_len_total
+= gr_mem_len
[gr_mem_cnt
];
180 written
= total
= (sizeof (struct dataset
)
181 + gr_mem_cnt
* sizeof (uint32_t)
182 + gr_name_len
+ gr_passwd_len
+ gr_mem_len_total
);
184 /* If we refill the cache, first assume the reconrd did not
185 change. Allocate memory on the cache since it is likely
186 discarded anyway. If it turns out to be necessary to have a
187 new record we can still allocate real memory. */
188 bool alloca_used
= false;
193 dataset
= (struct dataset
*) mempool_alloc (db
, total
+ n
);
195 ++db
->head
->addfailed
;
200 /* We cannot permanently add the result in the moment. But
201 we can provide the result as is. Store the data in some
203 dataset
= (struct dataset
*) alloca (total
+ n
);
205 /* We cannot add this record to the permanent database. */
209 dataset
->head
.allocsize
= total
+ n
;
210 dataset
->head
.recsize
= total
- offsetof (struct dataset
, resp
);
211 dataset
->head
.notfound
= false;
212 dataset
->head
.nreloads
= he
== NULL
? 0 : (dh
->nreloads
+ 1);
213 dataset
->head
.usable
= true;
215 /* Compute the timeout time. */
216 dataset
->head
.timeout
= t
+ db
->postimeout
;
218 dataset
->resp
.version
= NSCD_VERSION
;
219 dataset
->resp
.found
= 1;
220 dataset
->resp
.gr_name_len
= gr_name_len
;
221 dataset
->resp
.gr_passwd_len
= gr_passwd_len
;
222 dataset
->resp
.gr_gid
= grp
->gr_gid
;
223 dataset
->resp
.gr_mem_cnt
= gr_mem_cnt
;
225 cp
= dataset
->strdata
;
227 /* This is the member string length array. */
228 cp
= mempcpy (cp
, gr_mem_len
, gr_mem_cnt
* sizeof (uint32_t));
230 cp
= mempcpy (cp
, grp
->gr_name
, gr_name_len
);
231 cp
= mempcpy (cp
, grp
->gr_passwd
, gr_passwd_len
);
233 for (cnt
= 0; cnt
< gr_mem_cnt
; ++cnt
)
234 cp
= mempcpy (cp
, grp
->gr_mem
[cnt
], gr_mem_len
[cnt
]);
236 /* Finally the stringified GID value. */
238 char *key_copy
= cp
+ key_offset
;
239 assert (key_copy
== (char *) rawmemchr (cp
, '\0') + 1);
241 /* Now we can determine whether on refill we have to create a new
247 if (total
+ n
== dh
->allocsize
248 && total
- offsetof (struct dataset
, resp
) == dh
->recsize
249 && memcmp (&dataset
->resp
, dh
->data
,
250 dh
->allocsize
- offsetof (struct dataset
, resp
)) == 0)
252 /* The data has not changed. We will just bump the
253 timeout value. Note that the new record has been
254 allocated on the stack and need not be freed. */
255 dh
->timeout
= dataset
->head
.timeout
;
260 /* We have to create a new record. Just allocate
261 appropriate memory and copy it. */
263 = (struct dataset
*) mempool_alloc (db
, total
+ n
);
266 /* Adjust pointers into the memory block. */
267 gr_name
= (char *) newp
+ (gr_name
- (char *) dataset
);
268 cp
= (char *) newp
+ (cp
- (char *) dataset
);
270 dataset
= memcpy (newp
, dataset
, total
+ n
);
274 /* Mark the old record as obsolete. */
280 /* We write the dataset before inserting it to the database
281 since while inserting this thread might block and so would
282 unnecessarily let the receiver wait. */
285 written
= TEMP_FAILURE_RETRY (write (fd
, &dataset
->resp
, total
));
288 /* Add the record to the database. But only if it has not been
289 stored on the stack. */
292 /* If necessary, we also propagate the data to disk. */
295 msync (dataset
, total
+ n
, MS_ASYNC
);
297 /* Now get the lock to safely insert the records. */
298 pthread_rwlock_rdlock (&db
->lock
);
300 /* NB: in the following code we always must add the entry
301 marked with FIRST first. Otherwise we end up with
302 dangling "pointers" in case a latter hash entry cannot be
304 bool first
= req
->type
== GETGRBYNAME
;
306 /* If the request was by GID, add that entry first. */
307 if (req
->type
!= GETGRBYNAME
)
309 if (cache_add (GETGRBYGID
, cp
, key_offset
, &dataset
->head
, true,
312 /* Could not allocate memory. Make sure the data gets
314 dataset
->head
.usable
= false;
318 /* If the key is different from the name add a separate entry. */
319 else if (strcmp (key_copy
, gr_name
) != 0)
321 if (cache_add (GETGRBYNAME
, key_copy
, key_len
+ 1,
322 &dataset
->head
, first
, db
, owner
) < 0)
324 /* Could not allocate memory. Make sure the data gets
326 dataset
->head
.usable
= false;
333 /* We have to add the value for both, byname and byuid. */
334 if (__builtin_expect (cache_add (GETGRBYNAME
, gr_name
, gr_name_len
,
335 &dataset
->head
, first
, db
, owner
)
338 if (req
->type
== GETGRBYNAME
)
339 (void) cache_add (GETGRBYGID
, cp
, key_offset
, &dataset
->head
,
340 req
->type
!= GETGRBYNAME
, db
, owner
);
343 /* Could not allocate memory. Make sure the data gets
345 dataset
->head
.usable
= false;
348 pthread_rwlock_unlock (&db
->lock
);
352 if (__builtin_expect (written
!= total
, 0) && debug_level
> 0)
355 dbg_log (_("short write in %s: %s"), __FUNCTION__
,
356 strerror_r (errno
, buf
, sizeof (buf
)));
369 lookup (int type
, union keytype key
, struct group
*resultbufp
, char *buffer
,
370 size_t buflen
, struct group
**grp
)
372 if (type
== GETGRBYNAME
)
373 return __getgrnam_r (key
.v
, resultbufp
, buffer
, buflen
, grp
);
375 return __getgrgid_r (key
.g
, resultbufp
, buffer
, buflen
, grp
);
380 addgrbyX (struct database_dyn
*db
, int fd
, request_header
*req
,
381 union keytype key
, const char *keystr
, uid_t uid
,
382 struct hashentry
*he
, struct datahead
*dh
)
384 /* Search for the entry matching the key. Please note that we don't
385 look again in the table whether the dataset is now available. We
386 simply insert it. It does not matter if it is in there twice. The
387 pruning function only will look at the timestamp. */
388 size_t buflen
= 1024;
389 char *buffer
= (char *) alloca (buflen
);
390 struct group resultbuf
;
393 bool use_malloc
= false;
396 if (__builtin_expect (debug_level
> 0, 0))
399 dbg_log (_("Haven't found \"%s\" in group cache!"), keystr
);
401 dbg_log (_("Reloading \"%s\" in group cache!"), keystr
);
406 oldeuid
= geteuid ();
410 while (lookup (req
->type
, key
, &resultbuf
, buffer
, buflen
, &grp
) != 0
411 && (errval
= errno
) == ERANGE
)
413 char *old_buffer
= buffer
;
417 if (__builtin_expect (buflen
> 32768, 0))
420 buffer
= (char *) realloc (use_malloc
? buffer
: NULL
, buflen
);
423 /* We ran out of memory. We cannot do anything but
424 sending a negative response. In reality this should
429 /* We set the error to indicate this is (possibly) a
430 temporary error and that it does not mean the entry
431 is not available at all. */
438 /* Allocate a new buffer on the stack. If possible combine it
439 with the previously allocated buffer. */
440 buffer
= (char *) extend_alloca (buffer
, buflen
, buflen
+ INCR
);
446 cache_addgr (db
, fd
, req
, keystr
, grp
, uid
, he
, dh
, errval
);
454 addgrbyname (struct database_dyn
*db
, int fd
, request_header
*req
,
455 void *key
, uid_t uid
)
457 union keytype u
= { .v
= key
};
459 addgrbyX (db
, fd
, req
, u
, key
, uid
, NULL
, NULL
);
464 readdgrbyname (struct database_dyn
*db
, struct hashentry
*he
,
472 union keytype u
= { .v
= db
->data
+ he
->key
};
474 addgrbyX (db
, -1, &req
, u
, db
->data
+ he
->key
, he
->owner
, he
, dh
);
479 addgrbygid (struct database_dyn
*db
, int fd
, request_header
*req
,
480 void *key
, uid_t uid
)
483 gid_t gid
= strtoul ((char *) key
, &ep
, 10);
485 if (*(char *) key
== '\0' || *ep
!= '\0') /* invalid numeric uid */
488 dbg_log (_("Invalid numeric gid \"%s\"!"), (char *) key
);
494 union keytype u
= { .g
= gid
};
496 addgrbyX (db
, fd
, req
, u
, key
, uid
, NULL
, NULL
);
501 readdgrbygid (struct database_dyn
*db
, struct hashentry
*he
,
505 gid_t gid
= strtoul (db
->data
+ he
->key
, &ep
, 10);
507 /* Since the key has been added before it must be OK. */
508 assert (*(db
->data
+ he
->key
) != '\0' && *ep
== '\0');
515 union keytype u
= { .g
= gid
};
517 addgrbyX (db
, -1, &req
, u
, db
->data
+ he
->key
, he
->owner
, he
, dh
);