1 /* Cache handling for netgroup lookup.
2 Copyright (C) 2011-2014 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@gmail.com>, 2011.
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 <http://www.gnu.org/licenses/>. */
27 #include "../inet/netgroup.h"
31 #include <kernel-features.h>
34 /* This is the standard reply in case the service is disabled. */
35 static const netgroup_response_header disabled
=
37 .version
= NSCD_VERSION
,
43 /* This is the struct describing how to write this record. */
44 const struct iovec netgroup_iov_disabled
=
46 .iov_base
= (void *) &disabled
,
47 .iov_len
= sizeof (disabled
)
51 /* This is the standard reply in case we haven't found the dataset. */
52 static const netgroup_response_header notfound
=
54 .version
= NSCD_VERSION
,
64 netgroup_response_header resp
;
68 /* Sends a notfound message and prepares a notfound dataset to write to the
69 cache. Returns true if there was enough memory to allocate the dataset and
70 returns the dataset in DATASETP, total bytes to write in TOTALP and the
71 timeout in TIMEOUTP. KEY_COPY is set to point to the copy of the key in the
74 do_notfound (struct database_dyn
*db
, int fd
, request_header
*req
,
75 const char *key
, struct dataset
**datasetp
, ssize_t
*totalp
,
76 time_t *timeoutp
, char **key_copy
)
78 struct dataset
*dataset
;
81 bool cacheable
= false;
83 total
= sizeof (notfound
);
84 timeout
= time (NULL
) + db
->negtimeout
;
87 TEMP_FAILURE_RETRY (send (fd
, ¬found
, total
, MSG_NOSIGNAL
));
89 dataset
= mempool_alloc (db
, sizeof (struct dataset
) + req
->key_len
, 1);
90 /* If we cannot permanently store the result, so be it. */
93 timeout
= datahead_init_neg (&dataset
->head
,
94 sizeof (struct dataset
) + req
->key_len
,
95 total
, db
->negtimeout
);
97 /* This is the reply. */
98 memcpy (&dataset
->resp
, ¬found
, total
);
100 /* Copy the key data. */
101 memcpy (dataset
->strdata
, key
, req
->key_len
);
102 *key_copy
= dataset
->strdata
;
113 addgetnetgrentX (struct database_dyn
*db
, int fd
, request_header
*req
,
114 const char *key
, uid_t uid
, struct hashentry
*he
,
115 struct datahead
*dh
, struct dataset
**resultp
)
117 if (__glibc_unlikely (debug_level
> 0))
120 dbg_log (_("Haven't found \"%s\" in netgroup cache!"), key
);
122 dbg_log (_("Reloading \"%s\" in netgroup cache!"), key
);
125 static service_user
*netgroup_database
;
127 struct dataset
*dataset
;
128 bool cacheable
= false;
132 char *key_copy
= NULL
;
133 struct __netgrent data
;
134 size_t buflen
= MAX (1024, sizeof (*dataset
) + req
->key_len
);
135 size_t buffilled
= sizeof (*dataset
);
138 size_t group_len
= strlen (key
) + 1;
141 struct name_list elem
;
142 char mem
[sizeof (struct name_list
) + group_len
];
145 if (netgroup_database
== NULL
146 && __nss_database_lookup ("netgroup", NULL
, NULL
, &netgroup_database
))
148 /* No such service. */
149 cacheable
= do_notfound (db
, fd
, req
, key
, &dataset
, &total
, &timeout
,
154 memset (&data
, '\0', sizeof (data
));
155 buffer
= xmalloc (buflen
);
156 first_needed
.elem
.next
= &first_needed
.elem
;
157 memcpy (first_needed
.elem
.name
, key
, group_len
);
158 data
.needed_groups
= &first_needed
.elem
;
160 while (data
.needed_groups
!= NULL
)
162 /* Add the next group to the list of those which are known. */
163 struct name_list
*this_group
= data
.needed_groups
->next
;
164 if (this_group
== data
.needed_groups
)
165 data
.needed_groups
= NULL
;
167 data
.needed_groups
->next
= this_group
->next
;
168 this_group
->next
= data
.known_groups
;
169 data
.known_groups
= this_group
;
173 enum nss_status (*f
) (const char *, struct __netgrent
*);
177 service_user
*nip
= netgroup_database
;
178 int no_more
= __nss_lookup (&nip
, "setnetgrent", NULL
, &setfct
.ptr
);
181 enum nss_status status
182 = DL_CALL_FCT (*setfct
.f
, (data
.known_groups
->name
, &data
));
184 if (status
== NSS_STATUS_SUCCESS
)
189 enum nss_status (*f
) (struct __netgrent
*, char *, size_t,
193 getfct
.ptr
= __nss_lookup_function (nip
, "getnetgrent_r");
194 if (getfct
.f
!= NULL
)
198 status
= getfct
.f (&data
, buffer
+ buffilled
,
199 buflen
- buffilled
- req
->key_len
, &e
);
200 if (status
== NSS_STATUS_SUCCESS
)
202 if (data
.type
== triple_val
)
204 const char *nhost
= data
.val
.triple
.host
;
205 const char *nuser
= data
.val
.triple
.user
;
206 const char *ndomain
= data
.val
.triple
.domain
;
208 size_t hostlen
= strlen (nhost
?: "") + 1;
209 size_t userlen
= strlen (nuser
?: "") + 1;
210 size_t domainlen
= strlen (ndomain
?: "") + 1;
212 if (nhost
== NULL
|| nuser
== NULL
|| ndomain
== NULL
213 || nhost
> nuser
|| nuser
> ndomain
)
215 const char *last
= nhost
;
217 || (nuser
!= NULL
&& nuser
> last
))
220 || (ndomain
!= NULL
&& ndomain
> last
))
226 : last
+ strlen (last
) + 1 - buffer
);
228 /* We have to make temporary copies. */
229 size_t needed
= hostlen
+ userlen
+ domainlen
;
231 if (buflen
- req
->key_len
- bufused
< needed
)
233 buflen
+= MAX (buflen
, 2 * needed
);
234 /* Save offset in the old buffer. We don't
235 bother with the NULL check here since
236 we'll do that later anyway. */
237 size_t nhostdiff
= nhost
- buffer
;
238 size_t nuserdiff
= nuser
- buffer
;
239 size_t ndomaindiff
= ndomain
- buffer
;
241 char *newbuf
= xrealloc (buffer
, buflen
);
242 /* Fix up the triplet pointers into the new
244 nhost
= (nhost
? newbuf
+ nhostdiff
246 nuser
= (nuser
? newbuf
+ nuserdiff
248 ndomain
= (ndomain
? newbuf
+ ndomaindiff
253 nhost
= memcpy (buffer
+ bufused
,
254 nhost
?: "", hostlen
);
255 nuser
= memcpy ((char *) nhost
+ hostlen
,
256 nuser
?: "", userlen
);
257 ndomain
= memcpy ((char *) nuser
+ userlen
,
258 ndomain
?: "", domainlen
);
261 char *wp
= buffer
+ buffilled
;
262 wp
= memmove (wp
, nhost
?: "", hostlen
);
264 wp
= memmove (wp
, nuser
?: "", userlen
);
266 wp
= memmove (wp
, ndomain
?: "", domainlen
);
268 buffilled
= wp
- buffer
;
273 /* Check that the group has not been
275 struct name_list
*runp
= data
.needed_groups
;
279 if (strcmp (runp
->name
, data
.val
.group
) == 0)
283 if (runp
== data
.needed_groups
)
292 runp
= data
.known_groups
;
294 if (strcmp (runp
->name
, data
.val
.group
) == 0)
302 /* A new group is requested. */
303 size_t namelen
= strlen (data
.val
.group
) + 1;
304 struct name_list
*newg
= alloca (sizeof (*newg
)
306 memcpy (newg
->name
, data
.val
.group
, namelen
);
307 if (data
.needed_groups
== NULL
)
308 data
.needed_groups
= newg
->next
= newg
;
311 newg
->next
= data
.needed_groups
->next
;
312 data
.needed_groups
->next
= newg
;
313 data
.needed_groups
= newg
;
318 else if (status
== NSS_STATUS_TRYAGAIN
&& e
== ERANGE
)
321 buffer
= xrealloc (buffer
, buflen
);
323 else if (status
== NSS_STATUS_RETURN
324 || status
== NSS_STATUS_NOTFOUND
325 || status
== NSS_STATUS_UNAVAIL
)
326 /* This was either the last one for this group or the
327 group was empty or the NSS module had an internal
328 failure. Look at next group if available. */
332 enum nss_status (*endfct
) (struct __netgrent
*);
333 endfct
= __nss_lookup_function (nip
, "endnetgrent");
335 (void) DL_CALL_FCT (*endfct
, (&data
));
340 no_more
= __nss_next2 (&nip
, "setnetgrent", NULL
, &setfct
.ptr
,
345 /* No results. Return a failure and write out a notfound record in the
349 cacheable
= do_notfound (db
, fd
, req
, key
, &dataset
, &total
, &timeout
,
356 /* Fill in the dataset. */
357 dataset
= (struct dataset
*) buffer
;
358 timeout
= datahead_init_pos (&dataset
->head
, total
+ req
->key_len
,
359 total
- offsetof (struct dataset
, resp
),
360 he
== NULL
? 0 : dh
->nreloads
+ 1,
363 dataset
->resp
.version
= NSCD_VERSION
;
364 dataset
->resp
.found
= 1;
365 dataset
->resp
.nresults
= nentries
;
366 dataset
->resp
.result_len
= buffilled
- sizeof (*dataset
);
368 assert (buflen
- buffilled
>= req
->key_len
);
369 key_copy
= memcpy (buffer
+ buffilled
, key
, req
->key_len
);
370 buffilled
+= req
->key_len
;
372 /* Now we can determine whether on refill we have to create a new
378 if (dataset
->head
.allocsize
== dh
->allocsize
379 && dataset
->head
.recsize
== dh
->recsize
380 && memcmp (&dataset
->resp
, dh
->data
,
381 dh
->allocsize
- offsetof (struct dataset
, resp
)) == 0)
383 /* The data has not changed. We will just bump the timeout
384 value. Note that the new record has been allocated on
385 the stack and need not be freed. */
386 dh
->timeout
= dataset
->head
.timeout
;
387 dh
->ttl
= dataset
->head
.ttl
;
389 dataset
= (struct dataset
*) dh
;
397 = (struct dataset
*) mempool_alloc (db
, total
+ req
->key_len
, 1);
398 if (__glibc_likely (newp
!= NULL
))
400 /* Adjust pointer into the memory block. */
401 key_copy
= (char *) newp
+ (key_copy
- buffer
);
403 dataset
= memcpy (newp
, dataset
, total
+ req
->key_len
);
407 /* Mark the old record as obsolete. */
412 if (he
== NULL
&& fd
!= -1)
414 /* We write the dataset before inserting it to the database
415 since while inserting this thread might block and so would
416 unnecessarily let the receiver wait. */
419 if (__builtin_expect (db
->mmap_used
, 1) && cacheable
)
421 assert (db
->wr_fd
!= -1);
422 assert ((char *) &dataset
->resp
> (char *) db
->data
);
423 assert ((char *) dataset
- (char *) db
->head
+ total
424 <= (sizeof (struct database_pers_head
)
425 + db
->head
->module
* sizeof (ref_t
)
426 + db
->head
->data_size
));
427 # ifndef __ASSUME_SENDFILE
430 sendfileall (fd
, db
->wr_fd
, (char *) &dataset
->resp
431 - (char *) db
->head
, dataset
->head
.recsize
);
432 # ifndef __ASSUME_SENDFILE
433 if (written
== -1 && errno
== ENOSYS
)
440 #if defined HAVE_SENDFILE && !defined __ASSUME_SENDFILE
443 writeall (fd
, &dataset
->resp
, dataset
->head
.recsize
);
449 /* If necessary, we also propagate the data to disk. */
453 uintptr_t pval
= (uintptr_t) dataset
& ~pagesize_m1
;
454 msync ((void *) pval
,
455 ((uintptr_t) dataset
& pagesize_m1
) + total
+ req
->key_len
,
459 (void) cache_add (req
->type
, key_copy
, req
->key_len
, &dataset
->head
,
460 true, db
, uid
, he
== NULL
);
462 pthread_rwlock_unlock (&db
->lock
);
464 /* Mark the old entry as obsolete. */
479 addinnetgrX (struct database_dyn
*db
, int fd
, request_header
*req
,
480 char *key
, uid_t uid
, struct hashentry
*he
,
483 const char *group
= key
;
484 key
= (char *) rawmemchr (key
, '\0') + 1;
485 size_t group_len
= key
- group
- 1;
486 const char *host
= *key
++ ? key
: NULL
;
488 key
= (char *) rawmemchr (key
, '\0') + 1;
489 const char *user
= *key
++ ? key
: NULL
;
491 key
= (char *) rawmemchr (key
, '\0') + 1;
492 const char *domain
= *key
++ ? key
: NULL
;
494 if (__glibc_unlikely (debug_level
> 0))
497 dbg_log (_("Haven't found \"%s (%s,%s,%s)\" in netgroup cache!"),
498 group
, host
?: "", user
?: "", domain
?: "");
500 dbg_log (_("Reloading \"%s (%s,%s,%s)\" in netgroup cache!"),
501 group
, host
?: "", user
?: "", domain
?: "");
504 struct dataset
*result
= (struct dataset
*) cache_search (GETNETGRENT
,
509 timeout
= result
->head
.timeout
;
512 request_header req_get
=
517 timeout
= addgetnetgrentX (db
, -1, &req_get
, group
, uid
, NULL
, NULL
,
523 struct datahead head
;
524 innetgroup_response_header resp
;
526 = (struct indataset
*) mempool_alloc (db
,
527 sizeof (*dataset
) + req
->key_len
,
529 struct indataset dataset_mem
;
530 bool cacheable
= true;
531 if (__glibc_unlikely (dataset
== NULL
))
534 dataset
= &dataset_mem
;
537 datahead_init_pos (&dataset
->head
, sizeof (*dataset
) + req
->key_len
,
538 sizeof (innetgroup_response_header
),
539 he
== NULL
? 0 : dh
->nreloads
+ 1, result
->head
.ttl
);
540 /* Set the notfound status and timeout based on the result from
542 dataset
->head
.notfound
= result
->head
.notfound
;
543 dataset
->head
.timeout
= timeout
;
545 dataset
->resp
.version
= NSCD_VERSION
;
546 dataset
->resp
.found
= result
->resp
.found
;
547 /* Until we find a matching entry the result is 0. */
548 dataset
->resp
.result
= 0;
550 char *key_copy
= memcpy ((char *) (dataset
+ 1), group
, req
->key_len
);
552 if (dataset
->resp
.found
)
554 const char *triplets
= (const char *) (&result
->resp
+ 1);
556 for (nscd_ssize_t i
= result
->resp
.nresults
; i
> 0; --i
)
560 /* For the host, user and domain in each triplet, we assume success
561 if the value is blank because that is how the wildcard entry to
562 match anything is stored in the netgroup cache. */
563 if (host
!= NULL
&& *triplets
!= '\0')
564 success
= strcmp (host
, triplets
) == 0;
565 triplets
= (const char *) rawmemchr (triplets
, '\0') + 1;
567 if (success
&& user
!= NULL
&& *triplets
!= '\0')
568 success
= strcmp (user
, triplets
) == 0;
569 triplets
= (const char *) rawmemchr (triplets
, '\0') + 1;
571 if (success
&& (domain
== NULL
|| *triplets
== '\0'
572 || strcmp (domain
, triplets
) == 0))
574 dataset
->resp
.result
= 1;
577 triplets
= (const char *) rawmemchr (triplets
, '\0') + 1;
581 if (he
!= NULL
&& dh
->data
[0].innetgroupdata
.result
== dataset
->resp
.result
)
583 /* The data has not changed. We will just bump the timeout
584 value. Note that the new record has been allocated on
585 the stack and need not be freed. */
586 dh
->timeout
= timeout
;
587 dh
->ttl
= dataset
->head
.ttl
;
594 /* We write the dataset before inserting it to the database
595 since while inserting this thread might block and so would
596 unnecessarily let the receiver wait. */
600 if (__builtin_expect (db
->mmap_used
, 1) && cacheable
)
602 assert (db
->wr_fd
!= -1);
603 assert ((char *) &dataset
->resp
> (char *) db
->data
);
604 assert ((char *) dataset
- (char *) db
->head
+ sizeof (*dataset
)
605 <= (sizeof (struct database_pers_head
)
606 + db
->head
->module
* sizeof (ref_t
)
607 + db
->head
->data_size
));
608 # ifndef __ASSUME_SENDFILE
611 sendfileall (fd
, db
->wr_fd
,
612 (char *) &dataset
->resp
- (char *) db
->head
,
613 sizeof (innetgroup_response_header
));
614 # ifndef __ASSUME_SENDFILE
615 if (written
== -1 && errno
== ENOSYS
)
622 #if defined HAVE_SENDFILE && !defined __ASSUME_SENDFILE
625 writeall (fd
, &dataset
->resp
, sizeof (innetgroup_response_header
));
631 /* If necessary, we also propagate the data to disk. */
635 uintptr_t pval
= (uintptr_t) dataset
& ~pagesize_m1
;
636 msync ((void *) pval
,
637 ((uintptr_t) dataset
& pagesize_m1
) + sizeof (*dataset
)
642 (void) cache_add (req
->type
, key_copy
, req
->key_len
, &dataset
->head
,
643 true, db
, uid
, he
== NULL
);
645 pthread_rwlock_unlock (&db
->lock
);
647 /* Mark the old entry as obsolete. */
657 addgetnetgrent (struct database_dyn
*db
, int fd
, request_header
*req
,
658 void *key
, uid_t uid
)
660 struct dataset
*ignore
;
662 addgetnetgrentX (db
, fd
, req
, key
, uid
, NULL
, NULL
, &ignore
);
667 readdgetnetgrent (struct database_dyn
*db
, struct hashentry
*he
,
675 struct dataset
*ignore
;
677 return addgetnetgrentX (db
, -1, &req
, db
->data
+ he
->key
, he
->owner
, he
, dh
,
683 addinnetgr (struct database_dyn
*db
, int fd
, request_header
*req
,
684 void *key
, uid_t uid
)
686 addinnetgrX (db
, fd
, req
, key
, uid
, NULL
, NULL
);
691 readdinnetgr (struct database_dyn
*db
, struct hashentry
*he
,
700 return addinnetgrX (db
, -1, &req
, db
->data
+ he
->key
, he
->owner
, he
, dh
);