xref: /freebsd/lib/libc/net/nsdispatch.c (revision 3e65b9c6e6b7b2081d54e1dc40983c3c00eaf738)
1248aee62SJacques Vidrine /*	$NetBSD: nsdispatch.c,v 1.9 1999/01/25 00:16:17 lukem Exp $	*/
2248aee62SJacques Vidrine 
3248aee62SJacques Vidrine /*-
4248aee62SJacques Vidrine  * Copyright (c) 1997, 1998, 1999 The NetBSD Foundation, Inc.
5248aee62SJacques Vidrine  * All rights reserved.
6248aee62SJacques Vidrine  *
7248aee62SJacques Vidrine  * This code is derived from software contributed to The NetBSD Foundation
8248aee62SJacques Vidrine  * by Luke Mewburn.
9248aee62SJacques Vidrine  *
10248aee62SJacques Vidrine  * Redistribution and use in source and binary forms, with or without
11248aee62SJacques Vidrine  * modification, are permitted provided that the following conditions
12248aee62SJacques Vidrine  * are met:
13248aee62SJacques Vidrine  * 1. Redistributions of source code must retain the above copyright
14248aee62SJacques Vidrine  *    notice, this list of conditions and the following disclaimer.
15248aee62SJacques Vidrine  * 2. Redistributions in binary form must reproduce the above copyright
16248aee62SJacques Vidrine  *    notice, this list of conditions and the following disclaimer in the
17248aee62SJacques Vidrine  *    documentation and/or other materials provided with the distribution.
18248aee62SJacques Vidrine  * 3. All advertising materials mentioning features or use of this software
19248aee62SJacques Vidrine  *    must display the following acknowledgement:
20248aee62SJacques Vidrine  *        This product includes software developed by the NetBSD
21248aee62SJacques Vidrine  *        Foundation, Inc. and its contributors.
22248aee62SJacques Vidrine  * 4. Neither the name of The NetBSD Foundation nor the names of its
23248aee62SJacques Vidrine  *    contributors may be used to endorse or promote products derived
24248aee62SJacques Vidrine  *    from this software without specific prior written permission.
25248aee62SJacques Vidrine  *
26248aee62SJacques Vidrine  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27248aee62SJacques Vidrine  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28248aee62SJacques Vidrine  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29248aee62SJacques Vidrine  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30248aee62SJacques Vidrine  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31248aee62SJacques Vidrine  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32248aee62SJacques Vidrine  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33248aee62SJacques Vidrine  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34248aee62SJacques Vidrine  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35248aee62SJacques Vidrine  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36248aee62SJacques Vidrine  * POSSIBILITY OF SUCH DAMAGE.
37248aee62SJacques Vidrine  */
3846d93063SJacques Vidrine /*-
3946d93063SJacques Vidrine  * Copyright (c) 2003 Networks Associates Technology, Inc.
4046d93063SJacques Vidrine  * All rights reserved.
4146d93063SJacques Vidrine  *
4246d93063SJacques Vidrine  * Portions of this software were developed for the FreeBSD Project by
4346d93063SJacques Vidrine  * Jacques A. Vidrine, Safeport Network Services, and Network
4446d93063SJacques Vidrine  * Associates Laboratories, the Security Research Division of Network
4546d93063SJacques Vidrine  * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035
4646d93063SJacques Vidrine  * ("CBOSS"), as part of the DARPA CHATS research program.
4746d93063SJacques Vidrine  *
4846d93063SJacques Vidrine  * Redistribution and use in source and binary forms, with or without
4946d93063SJacques Vidrine  * modification, are permitted provided that the following conditions
5046d93063SJacques Vidrine  * are met:
5146d93063SJacques Vidrine  * 1. Redistributions of source code must retain the above copyright
5246d93063SJacques Vidrine  *    notice, this list of conditions and the following disclaimer.
5346d93063SJacques Vidrine  * 2. Redistributions in binary form must reproduce the above copyright
5446d93063SJacques Vidrine  *    notice, this list of conditions and the following disclaimer in the
5546d93063SJacques Vidrine  *    documentation and/or other materials provided with the distribution.
5646d93063SJacques Vidrine  *
5746d93063SJacques Vidrine  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
5846d93063SJacques Vidrine  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
5946d93063SJacques Vidrine  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
6046d93063SJacques Vidrine  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
6146d93063SJacques Vidrine  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
6246d93063SJacques Vidrine  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
6346d93063SJacques Vidrine  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
6446d93063SJacques Vidrine  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
6546d93063SJacques Vidrine  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
6646d93063SJacques Vidrine  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
6746d93063SJacques Vidrine  * SUCH DAMAGE.
6846d93063SJacques Vidrine  *
6946d93063SJacques Vidrine  */
70248aee62SJacques Vidrine #include <sys/cdefs.h>
71333fc21eSDavid E. O'Brien __FBSDID("$FreeBSD$");
72248aee62SJacques Vidrine 
7346d93063SJacques Vidrine #include "namespace.h"
74248aee62SJacques Vidrine #include <sys/param.h>
75248aee62SJacques Vidrine #include <sys/stat.h>
76248aee62SJacques Vidrine 
7746d93063SJacques Vidrine #include <dlfcn.h>
7846d93063SJacques Vidrine #include <errno.h>
79248aee62SJacques Vidrine #include <fcntl.h>
80248aee62SJacques Vidrine #define _NS_PRIVATE
81248aee62SJacques Vidrine #include <nsswitch.h>
8246d93063SJacques Vidrine #include <pthread.h>
836d722173SZachary Loafman #include <pthread_np.h>
84248aee62SJacques Vidrine #include <stdio.h>
85248aee62SJacques Vidrine #include <stdlib.h>
86248aee62SJacques Vidrine #include <string.h>
8746d93063SJacques Vidrine #include <syslog.h>
88248aee62SJacques Vidrine #include <unistd.h>
892bbd7cf8SJacques Vidrine #include "un-namespace.h"
906d722173SZachary Loafman #include "nss_tls.h"
91ab930670SJohn Baldwin #include "libc_private.h"
9206a99fe3SHajimu UMEMOTO #ifdef NS_CACHING
9306a99fe3SHajimu UMEMOTO #include "nscache.h"
9406a99fe3SHajimu UMEMOTO #endif
95248aee62SJacques Vidrine 
9646d93063SJacques Vidrine enum _nss_constants {
9746d93063SJacques Vidrine 	/* Number of elements allocated when we grow a vector */
9846d93063SJacques Vidrine 	ELEMSPERCHUNK =	8
9946d93063SJacques Vidrine };
10046d93063SJacques Vidrine 
10146d93063SJacques Vidrine /*
10246d93063SJacques Vidrine  * Global NSS data structures are mostly read-only, but we update
10346d93063SJacques Vidrine  * them when we read or re-read the nsswitch.conf.
10446d93063SJacques Vidrine  */
10546d93063SJacques Vidrine static	pthread_rwlock_t	nss_lock = PTHREAD_RWLOCK_INITIALIZER;
10646d93063SJacques Vidrine 
10746d93063SJacques Vidrine /*
10846d93063SJacques Vidrine  * Runtime determination of whether we are dynamically linked or not.
10946d93063SJacques Vidrine  */
11046d93063SJacques Vidrine extern	int		_DYNAMIC __attribute__ ((weak));
11146d93063SJacques Vidrine #define	is_dynamic()	(&_DYNAMIC != NULL)
11246d93063SJacques Vidrine 
113248aee62SJacques Vidrine /*
114248aee62SJacques Vidrine  * default sourcelist: `files'
115248aee62SJacques Vidrine  */
116248aee62SJacques Vidrine const ns_src __nsdefaultsrc[] = {
117248aee62SJacques Vidrine 	{ NSSRC_FILES, NS_SUCCESS },
118248aee62SJacques Vidrine 	{ 0 },
119248aee62SJacques Vidrine };
120248aee62SJacques Vidrine 
12146d93063SJacques Vidrine /* Database, source mappings. */
12246d93063SJacques Vidrine static	unsigned int		 _nsmapsize;
123248aee62SJacques Vidrine static	ns_dbt			*_nsmap = NULL;
124248aee62SJacques Vidrine 
12546d93063SJacques Vidrine /* NSS modules. */
12646d93063SJacques Vidrine static	unsigned int		 _nsmodsize;
12746d93063SJacques Vidrine static	ns_mod			*_nsmod;
12846d93063SJacques Vidrine 
12946d93063SJacques Vidrine /* Placeholder for builtin modules' dlopen `handle'. */
13046d93063SJacques Vidrine static	int			 __nss_builtin_handle;
13146d93063SJacques Vidrine static	void			*nss_builtin_handle = &__nss_builtin_handle;
13246d93063SJacques Vidrine 
13306a99fe3SHajimu UMEMOTO #ifdef NS_CACHING
13406a99fe3SHajimu UMEMOTO /*
13506a99fe3SHajimu UMEMOTO  * Cache lookup cycle prevention function - if !NULL then no cache lookups
13606a99fe3SHajimu UMEMOTO  * will be made
13706a99fe3SHajimu UMEMOTO  */
13806a99fe3SHajimu UMEMOTO static	void			*nss_cache_cycle_prevention_func = NULL;
13906a99fe3SHajimu UMEMOTO #endif
14006a99fe3SHajimu UMEMOTO 
141248aee62SJacques Vidrine /*
142a59d6a87SMichael Bushkov  * When this is set to 1, nsdispatch won't use nsswitch.conf
143a59d6a87SMichael Bushkov  * but will consult the 'defaults' source list only.
144a59d6a87SMichael Bushkov  * NOTE: nested fallbacks (when nsdispatch calls fallback functions,
145a59d6a87SMichael Bushkov  *     which in turn calls nsdispatch, which should call fallback
146a59d6a87SMichael Bushkov  *     function) are not supported
147a59d6a87SMichael Bushkov  */
1486d722173SZachary Loafman struct fb_state {
1496d722173SZachary Loafman 	int	fb_dispatch;
1506d722173SZachary Loafman };
1516d722173SZachary Loafman static	void	fb_endstate(void *);
1526d722173SZachary Loafman NSS_TLS_HANDLING(fb);
153a59d6a87SMichael Bushkov 
154a59d6a87SMichael Bushkov /*
15546d93063SJacques Vidrine  * Attempt to spew relatively uniform messages to syslog.
156248aee62SJacques Vidrine  */
15746d93063SJacques Vidrine #define nss_log(level, fmt, ...) \
15846d93063SJacques Vidrine 	syslog((level), "NSSWITCH(%s): " fmt, __func__, __VA_ARGS__)
15946d93063SJacques Vidrine #define nss_log_simple(level, s) \
16046d93063SJacques Vidrine 	syslog((level), "NSSWITCH(%s): " s, __func__)
16146d93063SJacques Vidrine 
16246d93063SJacques Vidrine /*
16346d93063SJacques Vidrine  * Dynamically growable arrays are used for lists of databases, sources,
16446d93063SJacques Vidrine  * and modules.  The following `vector' interface is used to isolate the
16546d93063SJacques Vidrine  * common operations.
16646d93063SJacques Vidrine  */
16746d93063SJacques Vidrine typedef	int	(*vector_comparison)(const void *, const void *);
16846d93063SJacques Vidrine typedef	void	(*vector_free_elem)(void *);
16946d93063SJacques Vidrine static	void	  vector_sort(void *, unsigned int, size_t,
17046d93063SJacques Vidrine 		    vector_comparison);
1714705e3daSDag-Erling Smørgrav static	void	  vector_free(void *, unsigned int *, size_t,
17246d93063SJacques Vidrine 		    vector_free_elem);
17346d93063SJacques Vidrine static	void	 *vector_ref(unsigned int, void *, unsigned int, size_t);
17446d93063SJacques Vidrine static	void	 *vector_search(const void *, void *, unsigned int, size_t,
17546d93063SJacques Vidrine 		    vector_comparison);
1764705e3daSDag-Erling Smørgrav static	void	 *vector_append(const void *, void *, unsigned int *, size_t);
177248aee62SJacques Vidrine 
178248aee62SJacques Vidrine 
17946d93063SJacques Vidrine /*
18046d93063SJacques Vidrine  * Internal interfaces.
18146d93063SJacques Vidrine  */
18246d93063SJacques Vidrine static	int	 string_compare(const void *, const void *);
18346d93063SJacques Vidrine static	int	 mtab_compare(const void *, const void *);
18446d93063SJacques Vidrine static	int	 nss_configure(void);
18546d93063SJacques Vidrine static	void	 ns_dbt_free(ns_dbt *);
18646d93063SJacques Vidrine static	void	 ns_mod_free(ns_mod *);
18746d93063SJacques Vidrine static	void	 ns_src_free(ns_src **, int);
18846d93063SJacques Vidrine static	void	 nss_load_builtin_modules(void);
18946d93063SJacques Vidrine static	void	 nss_load_module(const char *, nss_module_register_fn);
19046d93063SJacques Vidrine static	void	 nss_atexit(void);
19146d93063SJacques Vidrine /* nsparser */
19246d93063SJacques Vidrine extern	FILE	*_nsyyin;
193248aee62SJacques Vidrine 
194248aee62SJacques Vidrine 
19546d93063SJacques Vidrine /*
19646d93063SJacques Vidrine  * The vector operations
19746d93063SJacques Vidrine  */
19846d93063SJacques Vidrine static void
19946d93063SJacques Vidrine vector_sort(void *vec, unsigned int count, size_t esize,
20046d93063SJacques Vidrine     vector_comparison comparison)
201248aee62SJacques Vidrine {
20246d93063SJacques Vidrine 	qsort(vec, count, esize, comparison);
203248aee62SJacques Vidrine }
204248aee62SJacques Vidrine 
205248aee62SJacques Vidrine 
20646d93063SJacques Vidrine static void *
20746d93063SJacques Vidrine vector_search(const void *key, void *vec, unsigned int count, size_t esize,
20846d93063SJacques Vidrine     vector_comparison comparison)
209248aee62SJacques Vidrine {
21046d93063SJacques Vidrine 	return (bsearch(key, vec, count, esize, comparison));
211248aee62SJacques Vidrine }
212248aee62SJacques Vidrine 
213248aee62SJacques Vidrine 
2144705e3daSDag-Erling Smørgrav static void *
2154705e3daSDag-Erling Smørgrav vector_append(const void *elem, void *vec, unsigned int *count, size_t esize)
21646d93063SJacques Vidrine {
21746d93063SJacques Vidrine 	void	*p;
21846d93063SJacques Vidrine 
21946d93063SJacques Vidrine 	if ((*count % ELEMSPERCHUNK) == 0) {
2204705e3daSDag-Erling Smørgrav 		p = realloc(vec, (*count + ELEMSPERCHUNK) * esize);
22146d93063SJacques Vidrine 		if (p == NULL) {
22246d93063SJacques Vidrine 			nss_log_simple(LOG_ERR, "memory allocation failure");
2234705e3daSDag-Erling Smørgrav 			return (vec);
22446d93063SJacques Vidrine 		}
2254705e3daSDag-Erling Smørgrav 		vec = p;
2264705e3daSDag-Erling Smørgrav 	}
2274705e3daSDag-Erling Smørgrav 	memmove((void *)(((uintptr_t)vec) + (*count * esize)), elem, esize);
22846d93063SJacques Vidrine 	(*count)++;
2294705e3daSDag-Erling Smørgrav 	return (vec);
23046d93063SJacques Vidrine }
23146d93063SJacques Vidrine 
23246d93063SJacques Vidrine 
23346d93063SJacques Vidrine static void *
23446d93063SJacques Vidrine vector_ref(unsigned int i, void *vec, unsigned int count, size_t esize)
23546d93063SJacques Vidrine {
23646d93063SJacques Vidrine 	if (i < count)
23746d93063SJacques Vidrine 		return (void *)((uintptr_t)vec + (i * esize));
23846d93063SJacques Vidrine 	else
23946d93063SJacques Vidrine 		return (NULL);
24046d93063SJacques Vidrine }
24146d93063SJacques Vidrine 
24246d93063SJacques Vidrine 
2434705e3daSDag-Erling Smørgrav #define VECTOR_FREE(v, c, s, f) \
2444705e3daSDag-Erling Smørgrav 	do { vector_free(v, c, s, f); v = NULL; } while (0)
24546d93063SJacques Vidrine static void
2464705e3daSDag-Erling Smørgrav vector_free(void *vec, unsigned int *count, size_t esize,
24746d93063SJacques Vidrine     vector_free_elem free_elem)
24846d93063SJacques Vidrine {
24946d93063SJacques Vidrine 	unsigned int	 i;
25046d93063SJacques Vidrine 	void		*elem;
25146d93063SJacques Vidrine 
25246d93063SJacques Vidrine 	for (i = 0; i < *count; i++) {
2534705e3daSDag-Erling Smørgrav 		elem = vector_ref(i, vec, *count, esize);
25446d93063SJacques Vidrine 		if (elem != NULL)
25546d93063SJacques Vidrine 			free_elem(elem);
25646d93063SJacques Vidrine 	}
2574705e3daSDag-Erling Smørgrav 	free(vec);
25846d93063SJacques Vidrine 	*count = 0;
25946d93063SJacques Vidrine }
26046d93063SJacques Vidrine 
26146d93063SJacques Vidrine /*
26246d93063SJacques Vidrine  * Comparison functions for vector_search.
26346d93063SJacques Vidrine  */
26446d93063SJacques Vidrine static int
26546d93063SJacques Vidrine string_compare(const void *a, const void *b)
26646d93063SJacques Vidrine {
26746d93063SJacques Vidrine       return (strcasecmp(*(const char * const *)a, *(const char * const *)b));
26846d93063SJacques Vidrine }
26946d93063SJacques Vidrine 
27046d93063SJacques Vidrine 
27146d93063SJacques Vidrine static int
27246d93063SJacques Vidrine mtab_compare(const void *a, const void *b)
27346d93063SJacques Vidrine {
27446d93063SJacques Vidrine       int     cmp;
27546d93063SJacques Vidrine 
27646d93063SJacques Vidrine       cmp = strcmp(((const ns_mtab *)a)->name, ((const ns_mtab *)b)->name);
27746d93063SJacques Vidrine       if (cmp != 0)
27846d93063SJacques Vidrine 	      return (cmp);
27946d93063SJacques Vidrine       else
28046d93063SJacques Vidrine 	      return (strcmp(((const ns_mtab *)a)->database,
28146d93063SJacques Vidrine 		  ((const ns_mtab *)b)->database));
28246d93063SJacques Vidrine }
28346d93063SJacques Vidrine 
28446d93063SJacques Vidrine /*
28546d93063SJacques Vidrine  * NSS nsmap management.
28646d93063SJacques Vidrine  */
287248aee62SJacques Vidrine void
28846d93063SJacques Vidrine _nsdbtaddsrc(ns_dbt *dbt, const ns_src *src)
28946d93063SJacques Vidrine {
29046d93063SJacques Vidrine 	const ns_mod	*modp;
29146d93063SJacques Vidrine 
2924705e3daSDag-Erling Smørgrav 	dbt->srclist = vector_append(src, dbt->srclist, &dbt->srclistsize,
29346d93063SJacques Vidrine 	    sizeof(*src));
29446d93063SJacques Vidrine 	modp = vector_search(&src->name, _nsmod, _nsmodsize, sizeof(*_nsmod),
29546d93063SJacques Vidrine 	    string_compare);
29646d93063SJacques Vidrine 	if (modp == NULL)
29746d93063SJacques Vidrine 		nss_load_module(src->name, NULL);
29846d93063SJacques Vidrine }
29946d93063SJacques Vidrine 
30046d93063SJacques Vidrine 
30146d93063SJacques Vidrine #ifdef _NSS_DEBUG
30246d93063SJacques Vidrine void
30346d93063SJacques Vidrine _nsdbtdump(const ns_dbt *dbt)
304248aee62SJacques Vidrine {
305248aee62SJacques Vidrine 	int i;
306248aee62SJacques Vidrine 
307248aee62SJacques Vidrine 	printf("%s (%d source%s):", dbt->name, dbt->srclistsize,
308248aee62SJacques Vidrine 	    dbt->srclistsize == 1 ? "" : "s");
30946d93063SJacques Vidrine 	for (i = 0; i < (int)dbt->srclistsize; i++) {
310248aee62SJacques Vidrine 		printf(" %s", dbt->srclist[i].name);
311248aee62SJacques Vidrine 		if (!(dbt->srclist[i].flags &
312248aee62SJacques Vidrine 		    (NS_UNAVAIL|NS_NOTFOUND|NS_TRYAGAIN)) &&
313248aee62SJacques Vidrine 		    (dbt->srclist[i].flags & NS_SUCCESS))
314248aee62SJacques Vidrine 			continue;
315248aee62SJacques Vidrine 		printf(" [");
316248aee62SJacques Vidrine 		if (!(dbt->srclist[i].flags & NS_SUCCESS))
317248aee62SJacques Vidrine 			printf(" SUCCESS=continue");
318248aee62SJacques Vidrine 		if (dbt->srclist[i].flags & NS_UNAVAIL)
319248aee62SJacques Vidrine 			printf(" UNAVAIL=return");
320248aee62SJacques Vidrine 		if (dbt->srclist[i].flags & NS_NOTFOUND)
321248aee62SJacques Vidrine 			printf(" NOTFOUND=return");
322248aee62SJacques Vidrine 		if (dbt->srclist[i].flags & NS_TRYAGAIN)
323248aee62SJacques Vidrine 			printf(" TRYAGAIN=return");
324248aee62SJacques Vidrine 		printf(" ]");
325248aee62SJacques Vidrine 	}
326248aee62SJacques Vidrine 	printf("\n");
327248aee62SJacques Vidrine }
32846d93063SJacques Vidrine #endif
329248aee62SJacques Vidrine 
330248aee62SJacques Vidrine 
33146d93063SJacques Vidrine /*
33246d93063SJacques Vidrine  * The first time nsdispatch is called (during a process's lifetime,
33346d93063SJacques Vidrine  * or after nsswitch.conf has been updated), nss_configure will
33446d93063SJacques Vidrine  * prepare global data needed by NSS.
33546d93063SJacques Vidrine  */
33646d93063SJacques Vidrine static int
33746d93063SJacques Vidrine nss_configure(void)
338248aee62SJacques Vidrine {
33946d93063SJacques Vidrine 	static pthread_mutex_t conf_lock = PTHREAD_MUTEX_INITIALIZER;
340248aee62SJacques Vidrine 	static time_t	 confmod;
341248aee62SJacques Vidrine 	struct stat	 statbuf;
342a03fd3b6SJacques Vidrine 	int		 result, isthreaded;
34346d93063SJacques Vidrine 	const char	*path;
34406a99fe3SHajimu UMEMOTO #ifdef NS_CACHING
34506a99fe3SHajimu UMEMOTO 	void		*handle;
34606a99fe3SHajimu UMEMOTO #endif
347248aee62SJacques Vidrine 
348a03fd3b6SJacques Vidrine 	result = 0;
349a03fd3b6SJacques Vidrine 	isthreaded = __isthreaded;
35046d93063SJacques Vidrine #if defined(_NSS_DEBUG) && defined(_NSS_SHOOT_FOOT)
35146d93063SJacques Vidrine 	/* NOTE WELL:  THIS IS A SECURITY HOLE. This must only be built
35246d93063SJacques Vidrine 	 * for debugging purposes and MUST NEVER be used in production.
35346d93063SJacques Vidrine 	 */
35446d93063SJacques Vidrine 	path = getenv("NSSWITCH_CONF");
35546d93063SJacques Vidrine 	if (path == NULL)
35646d93063SJacques Vidrine #endif
35746d93063SJacques Vidrine 	path = _PATH_NS_CONF;
35846d93063SJacques Vidrine 	if (stat(path, &statbuf) != 0)
35946d93063SJacques Vidrine 		return (0);
36046d93063SJacques Vidrine 	if (statbuf.st_mtime <= confmod)
36146d93063SJacques Vidrine 		return (0);
362a03fd3b6SJacques Vidrine 	if (isthreaded) {
36346d93063SJacques Vidrine 	    result = _pthread_mutex_trylock(&conf_lock);
36446d93063SJacques Vidrine 	    if (result != 0)
36546d93063SJacques Vidrine 		    return (0);
36646d93063SJacques Vidrine 	    (void)_pthread_rwlock_unlock(&nss_lock);
36746d93063SJacques Vidrine 	    result = _pthread_rwlock_wrlock(&nss_lock);
36846d93063SJacques Vidrine 	    if (result != 0)
36946d93063SJacques Vidrine 		    goto fin2;
370a03fd3b6SJacques Vidrine 	}
37146d93063SJacques Vidrine 	_nsyyin = fopen(path, "r");
3728074e24dSJacques Vidrine 	if (_nsyyin == NULL)
37346d93063SJacques Vidrine 		goto fin;
3744705e3daSDag-Erling Smørgrav 	VECTOR_FREE(_nsmap, &_nsmapsize, sizeof(*_nsmap),
37546d93063SJacques Vidrine 	    (vector_free_elem)ns_dbt_free);
3764705e3daSDag-Erling Smørgrav 	VECTOR_FREE(_nsmod, &_nsmodsize, sizeof(*_nsmod),
37746d93063SJacques Vidrine 	    (vector_free_elem)ns_mod_free);
37846d93063SJacques Vidrine 	nss_load_builtin_modules();
379248aee62SJacques Vidrine 	_nsyyparse();
380248aee62SJacques Vidrine 	(void)fclose(_nsyyin);
38146d93063SJacques Vidrine 	vector_sort(_nsmap, _nsmapsize, sizeof(*_nsmap), string_compare);
38246d93063SJacques Vidrine 	if (confmod == 0)
38346d93063SJacques Vidrine 		(void)atexit(nss_atexit);
384248aee62SJacques Vidrine 	confmod = statbuf.st_mtime;
38506a99fe3SHajimu UMEMOTO 
38606a99fe3SHajimu UMEMOTO #ifdef NS_CACHING
387*3e65b9c6SColin Percival 	handle = libc_dlopen(NULL, RTLD_LAZY | RTLD_GLOBAL);
38806a99fe3SHajimu UMEMOTO 	if (handle != NULL) {
38906a99fe3SHajimu UMEMOTO 		nss_cache_cycle_prevention_func = dlsym(handle,
39006a99fe3SHajimu UMEMOTO 			"_nss_cache_cycle_prevention_function");
39106a99fe3SHajimu UMEMOTO 		dlclose(handle);
39206a99fe3SHajimu UMEMOTO 	}
39306a99fe3SHajimu UMEMOTO #endif
39446d93063SJacques Vidrine fin:
395a03fd3b6SJacques Vidrine 	if (isthreaded) {
39646d93063SJacques Vidrine 	    (void)_pthread_rwlock_unlock(&nss_lock);
397a03fd3b6SJacques Vidrine 	    if (result == 0)
39846d93063SJacques Vidrine 		    result = _pthread_rwlock_rdlock(&nss_lock);
399a03fd3b6SJacques Vidrine 	}
40046d93063SJacques Vidrine fin2:
401a03fd3b6SJacques Vidrine 	if (isthreaded)
40246d93063SJacques Vidrine 		(void)_pthread_mutex_unlock(&conf_lock);
40346d93063SJacques Vidrine 	return (result);
404248aee62SJacques Vidrine }
405248aee62SJacques Vidrine 
406248aee62SJacques Vidrine 
407248aee62SJacques Vidrine void
40846d93063SJacques Vidrine _nsdbtput(const ns_dbt *dbt)
409248aee62SJacques Vidrine {
41046d93063SJacques Vidrine 	unsigned int	 i;
41146d93063SJacques Vidrine 	ns_dbt		*p;
412248aee62SJacques Vidrine 
413248aee62SJacques Vidrine 	for (i = 0; i < _nsmapsize; i++) {
41446d93063SJacques Vidrine 		p = vector_ref(i, _nsmap, _nsmapsize, sizeof(*_nsmap));
41546d93063SJacques Vidrine 		if (string_compare(&dbt->name, &p->name) == 0) {
416248aee62SJacques Vidrine 			/* overwrite existing entry */
41746d93063SJacques Vidrine 			if (p->srclist != NULL)
41846d93063SJacques Vidrine 				ns_src_free(&p->srclist, p->srclistsize);
41946d93063SJacques Vidrine 			memmove(p, dbt, sizeof(*dbt));
420248aee62SJacques Vidrine 			return;
421248aee62SJacques Vidrine 		}
422248aee62SJacques Vidrine 	}
4234705e3daSDag-Erling Smørgrav 	_nsmap = vector_append(dbt, _nsmap, &_nsmapsize, sizeof(*_nsmap));
424248aee62SJacques Vidrine }
425248aee62SJacques Vidrine 
426248aee62SJacques Vidrine 
42746d93063SJacques Vidrine static void
42846d93063SJacques Vidrine ns_dbt_free(ns_dbt *dbt)
42946d93063SJacques Vidrine {
43046d93063SJacques Vidrine 	ns_src_free(&dbt->srclist, dbt->srclistsize);
4317a800a56SJonathan Chen 	if (dbt->name)
4327a800a56SJonathan Chen 		free((void *)dbt->name);
43346d93063SJacques Vidrine }
43446d93063SJacques Vidrine 
43546d93063SJacques Vidrine 
43646d93063SJacques Vidrine static void
43746d93063SJacques Vidrine ns_src_free(ns_src **src, int srclistsize)
43846d93063SJacques Vidrine {
43946d93063SJacques Vidrine 	int	i;
44046d93063SJacques Vidrine 
44146d93063SJacques Vidrine 	for (i = 0; i < srclistsize; i++)
44246d93063SJacques Vidrine 		if ((*src)[i].name != NULL)
44346d93063SJacques Vidrine 			/* This one was allocated by nslexer. You'll just
44446d93063SJacques Vidrine 			 * have to trust me.
44546d93063SJacques Vidrine 			 */
44646d93063SJacques Vidrine 			free((void *)((*src)[i].name));
44746d93063SJacques Vidrine 	free(*src);
44846d93063SJacques Vidrine 	*src = NULL;
44946d93063SJacques Vidrine }
45046d93063SJacques Vidrine 
45146d93063SJacques Vidrine 
45246d93063SJacques Vidrine 
45346d93063SJacques Vidrine /*
45446d93063SJacques Vidrine  * NSS module management.
45546d93063SJacques Vidrine  */
45646d93063SJacques Vidrine /* The built-in NSS modules are all loaded at once. */
45746d93063SJacques Vidrine #define NSS_BACKEND(name, reg) \
45846d93063SJacques Vidrine ns_mtab	*reg(unsigned int *, nss_module_unregister_fn *);
45946d93063SJacques Vidrine #include "nss_backends.h"
46046d93063SJacques Vidrine #undef NSS_BACKEND
46146d93063SJacques Vidrine 
46246d93063SJacques Vidrine static void
46346d93063SJacques Vidrine nss_load_builtin_modules(void)
46446d93063SJacques Vidrine {
46546d93063SJacques Vidrine #define NSS_BACKEND(name, reg) nss_load_module(#name, reg);
46646d93063SJacques Vidrine #include "nss_backends.h"
46746d93063SJacques Vidrine #undef NSS_BACKEND
46846d93063SJacques Vidrine }
46946d93063SJacques Vidrine 
47046d93063SJacques Vidrine 
47146d93063SJacques Vidrine /* Load a built-in or dynamically linked module.  If the `reg_fn'
47246d93063SJacques Vidrine  * argument is non-NULL, assume a built-in module and use reg_fn to
47346d93063SJacques Vidrine  * register it.  Otherwise, search for a dynamic NSS module.
47446d93063SJacques Vidrine  */
47546d93063SJacques Vidrine static void
47646d93063SJacques Vidrine nss_load_module(const char *source, nss_module_register_fn reg_fn)
47746d93063SJacques Vidrine {
47846d93063SJacques Vidrine 	char		 buf[PATH_MAX];
47946d93063SJacques Vidrine 	ns_mod		 mod;
48046d93063SJacques Vidrine 	nss_module_register_fn fn;
48146d93063SJacques Vidrine 
48246d93063SJacques Vidrine 	memset(&mod, 0, sizeof(mod));
48346d93063SJacques Vidrine 	mod.name = strdup(source);
48446d93063SJacques Vidrine 	if (mod.name == NULL) {
48546d93063SJacques Vidrine 		nss_log_simple(LOG_ERR, "memory allocation failure");
48646d93063SJacques Vidrine 		return;
48746d93063SJacques Vidrine 	}
48846d93063SJacques Vidrine 	if (reg_fn != NULL) {
48946d93063SJacques Vidrine 		/* The placeholder is required, as a NULL handle
49046d93063SJacques Vidrine 		 * represents an invalid module.
49146d93063SJacques Vidrine 		 */
49246d93063SJacques Vidrine 		mod.handle = nss_builtin_handle;
49346d93063SJacques Vidrine 		fn = reg_fn;
49446d93063SJacques Vidrine 	} else if (!is_dynamic())
49546d93063SJacques Vidrine 		goto fin;
49646d93063SJacques Vidrine 	else {
49746d93063SJacques Vidrine 		if (snprintf(buf, sizeof(buf), "nss_%s.so.%d", mod.name,
49846d93063SJacques Vidrine 		    NSS_MODULE_INTERFACE_VERSION) >= (int)sizeof(buf))
49946d93063SJacques Vidrine 			goto fin;
500*3e65b9c6SColin Percival 		mod.handle = libc_dlopen(buf, RTLD_LOCAL|RTLD_LAZY);
50146d93063SJacques Vidrine 		if (mod.handle == NULL) {
50246d93063SJacques Vidrine #ifdef _NSS_DEBUG
50346d93063SJacques Vidrine 			/* This gets pretty annoying since the built-in
50446d93063SJacques Vidrine 			 * sources aren't modules yet.
50546d93063SJacques Vidrine 			 */
50646d93063SJacques Vidrine 			nss_log(LOG_DEBUG, "%s, %s", mod.name, dlerror());
50746d93063SJacques Vidrine #endif
50846d93063SJacques Vidrine 			goto fin;
50946d93063SJacques Vidrine 		}
51046d93063SJacques Vidrine 		fn = (nss_module_register_fn)dlfunc(mod.handle,
51146d93063SJacques Vidrine 		    "nss_module_register");
51246d93063SJacques Vidrine 		if (fn == NULL) {
51346d93063SJacques Vidrine 			(void)dlclose(mod.handle);
51446d93063SJacques Vidrine 			mod.handle = NULL;
51546d93063SJacques Vidrine 			nss_log(LOG_ERR, "%s, %s", mod.name, dlerror());
51646d93063SJacques Vidrine 			goto fin;
51746d93063SJacques Vidrine 		}
51846d93063SJacques Vidrine 	}
51946d93063SJacques Vidrine 	mod.mtab = fn(mod.name, &mod.mtabsize, &mod.unregister);
52046d93063SJacques Vidrine 	if (mod.mtab == NULL || mod.mtabsize == 0) {
52146d93063SJacques Vidrine 		if (mod.handle != nss_builtin_handle)
52246d93063SJacques Vidrine 			(void)dlclose(mod.handle);
52346d93063SJacques Vidrine 		mod.handle = NULL;
52446d93063SJacques Vidrine 		nss_log(LOG_ERR, "%s, registration failed", mod.name);
52546d93063SJacques Vidrine 		goto fin;
52646d93063SJacques Vidrine 	}
52746d93063SJacques Vidrine 	if (mod.mtabsize > 1)
52846d93063SJacques Vidrine 		qsort(mod.mtab, mod.mtabsize, sizeof(mod.mtab[0]),
52946d93063SJacques Vidrine 		    mtab_compare);
53046d93063SJacques Vidrine fin:
5314705e3daSDag-Erling Smørgrav 	_nsmod = vector_append(&mod, _nsmod, &_nsmodsize, sizeof(*_nsmod));
53246d93063SJacques Vidrine 	vector_sort(_nsmod, _nsmodsize, sizeof(*_nsmod), string_compare);
53346d93063SJacques Vidrine }
53446d93063SJacques Vidrine 
53546d93063SJacques Vidrine 
53646d93063SJacques Vidrine 
53746d93063SJacques Vidrine static void
53846d93063SJacques Vidrine ns_mod_free(ns_mod *mod)
53946d93063SJacques Vidrine {
54046d93063SJacques Vidrine 
54146d93063SJacques Vidrine 	free(mod->name);
54246d93063SJacques Vidrine 	if (mod->handle == NULL)
54346d93063SJacques Vidrine 		return;
54446d93063SJacques Vidrine 	if (mod->unregister != NULL)
54546d93063SJacques Vidrine 		mod->unregister(mod->mtab, mod->mtabsize);
54646d93063SJacques Vidrine 	if (mod->handle != nss_builtin_handle)
54746d93063SJacques Vidrine 		(void)dlclose(mod->handle);
54846d93063SJacques Vidrine }
54946d93063SJacques Vidrine 
55046d93063SJacques Vidrine 
55146d93063SJacques Vidrine 
55246d93063SJacques Vidrine /*
55346d93063SJacques Vidrine  * Cleanup
55446d93063SJacques Vidrine  */
55546d93063SJacques Vidrine static void
55646d93063SJacques Vidrine nss_atexit(void)
55746d93063SJacques Vidrine {
558a03fd3b6SJacques Vidrine 	int isthreaded;
559a03fd3b6SJacques Vidrine 
560a03fd3b6SJacques Vidrine 	isthreaded = __isthreaded;
561a03fd3b6SJacques Vidrine 	if (isthreaded)
56246d93063SJacques Vidrine 		(void)_pthread_rwlock_wrlock(&nss_lock);
5634705e3daSDag-Erling Smørgrav 	VECTOR_FREE(_nsmap, &_nsmapsize, sizeof(*_nsmap),
56446d93063SJacques Vidrine 	    (vector_free_elem)ns_dbt_free);
5654705e3daSDag-Erling Smørgrav 	VECTOR_FREE(_nsmod, &_nsmodsize, sizeof(*_nsmod),
56646d93063SJacques Vidrine 	    (vector_free_elem)ns_mod_free);
567a03fd3b6SJacques Vidrine 	if (isthreaded)
56846d93063SJacques Vidrine 		(void)_pthread_rwlock_unlock(&nss_lock);
56946d93063SJacques Vidrine }
57046d93063SJacques Vidrine 
57146d93063SJacques Vidrine 
57246d93063SJacques Vidrine 
57346d93063SJacques Vidrine /*
57446d93063SJacques Vidrine  * Finally, the actual implementation.
57546d93063SJacques Vidrine  */
57646d93063SJacques Vidrine static nss_method
57746d93063SJacques Vidrine nss_method_lookup(const char *source, const char *database,
57846d93063SJacques Vidrine     const char *method, const ns_dtab disp_tab[], void **mdata)
57946d93063SJacques Vidrine {
58046d93063SJacques Vidrine 	ns_mod	*mod;
58146d93063SJacques Vidrine 	ns_mtab	*match, key;
58246d93063SJacques Vidrine 	int	 i;
58346d93063SJacques Vidrine 
58446d93063SJacques Vidrine 	if (disp_tab != NULL)
58546d93063SJacques Vidrine 		for (i = 0; disp_tab[i].src != NULL; i++)
58646d93063SJacques Vidrine 			if (strcasecmp(source, disp_tab[i].src) == 0) {
58746d93063SJacques Vidrine 				*mdata = disp_tab[i].mdata;
58846d93063SJacques Vidrine 				return (disp_tab[i].method);
58946d93063SJacques Vidrine 			}
59046d93063SJacques Vidrine 	mod = vector_search(&source, _nsmod, _nsmodsize, sizeof(*_nsmod),
59146d93063SJacques Vidrine 	    string_compare);
59246d93063SJacques Vidrine 	if (mod != NULL && mod->handle != NULL) {
59346d93063SJacques Vidrine 		key.database = database;
59446d93063SJacques Vidrine 		key.name = method;
59546d93063SJacques Vidrine 		match = bsearch(&key, mod->mtab, mod->mtabsize,
59646d93063SJacques Vidrine 		    sizeof(mod->mtab[0]), mtab_compare);
59746d93063SJacques Vidrine 		if (match != NULL) {
59846d93063SJacques Vidrine 			*mdata = match->mdata;
59946d93063SJacques Vidrine 			return (match->method);
60046d93063SJacques Vidrine 		}
60146d93063SJacques Vidrine 	}
60236736e35SMichael Bushkov 
60346d93063SJacques Vidrine 	*mdata = NULL;
60446d93063SJacques Vidrine 	return (NULL);
60546d93063SJacques Vidrine }
60646d93063SJacques Vidrine 
6076d722173SZachary Loafman static void
6086d722173SZachary Loafman fb_endstate(void *p)
6096d722173SZachary Loafman {
6106d722173SZachary Loafman 	free(p);
6116d722173SZachary Loafman }
61246d93063SJacques Vidrine 
61346d93063SJacques Vidrine __weak_reference(_nsdispatch, nsdispatch);
61446d93063SJacques Vidrine 
615248aee62SJacques Vidrine int
61646d93063SJacques Vidrine _nsdispatch(void *retval, const ns_dtab disp_tab[], const char *database,
61746d93063SJacques Vidrine 	    const char *method_name, const ns_src defaults[], ...)
618248aee62SJacques Vidrine {
619248aee62SJacques Vidrine 	va_list		 ap;
620248aee62SJacques Vidrine 	const ns_dbt	*dbt;
621248aee62SJacques Vidrine 	const ns_src	*srclist;
622a59d6a87SMichael Bushkov 	nss_method	 method, fb_method;
62346d93063SJacques Vidrine 	void		*mdata;
624a03fd3b6SJacques Vidrine 	int		 isthreaded, serrno, i, result, srclistsize;
6256d722173SZachary Loafman 	struct fb_state	*st;
626248aee62SJacques Vidrine 
62706a99fe3SHajimu UMEMOTO #ifdef NS_CACHING
62806a99fe3SHajimu UMEMOTO 	nss_cache_data	 cache_data;
62906a99fe3SHajimu UMEMOTO 	nss_cache_data	*cache_data_p;
63006a99fe3SHajimu UMEMOTO 	int		 cache_flag;
63106a99fe3SHajimu UMEMOTO #endif
63206a99fe3SHajimu UMEMOTO 
633a59d6a87SMichael Bushkov 	dbt = NULL;
634a59d6a87SMichael Bushkov 	fb_method = NULL;
635a59d6a87SMichael Bushkov 
636a03fd3b6SJacques Vidrine 	isthreaded = __isthreaded;
63746d93063SJacques Vidrine 	serrno = errno;
638a03fd3b6SJacques Vidrine 	if (isthreaded) {
63946d93063SJacques Vidrine 		result = _pthread_rwlock_rdlock(&nss_lock);
64046d93063SJacques Vidrine 		if (result != 0) {
64146d93063SJacques Vidrine 			result = NS_UNAVAIL;
64246d93063SJacques Vidrine 			goto fin;
64346d93063SJacques Vidrine 		}
644a03fd3b6SJacques Vidrine 	}
6456d722173SZachary Loafman 
6466d722173SZachary Loafman 	result = fb_getstate(&st);
6476d722173SZachary Loafman 	if (result != 0) {
6486d722173SZachary Loafman 		result = NS_UNAVAIL;
6496d722173SZachary Loafman 		goto fin;
6506d722173SZachary Loafman 	}
6516d722173SZachary Loafman 
65246d93063SJacques Vidrine 	result = nss_configure();
65346d93063SJacques Vidrine 	if (result != 0) {
65446d93063SJacques Vidrine 		result = NS_UNAVAIL;
65546d93063SJacques Vidrine 		goto fin;
65646d93063SJacques Vidrine 	}
6576d722173SZachary Loafman 	if (st->fb_dispatch == 0) {
65846d93063SJacques Vidrine 		dbt = vector_search(&database, _nsmap, _nsmapsize, sizeof(*_nsmap),
65946d93063SJacques Vidrine 		    string_compare);
660a59d6a87SMichael Bushkov 		fb_method = nss_method_lookup(NSSRC_FALLBACK, database,
661a59d6a87SMichael Bushkov 		    method_name, disp_tab, &mdata);
662a59d6a87SMichael Bushkov 	}
663a59d6a87SMichael Bushkov 
664248aee62SJacques Vidrine 	if (dbt != NULL) {
665248aee62SJacques Vidrine 		srclist = dbt->srclist;
666248aee62SJacques Vidrine 		srclistsize = dbt->srclistsize;
667248aee62SJacques Vidrine 	} else {
668248aee62SJacques Vidrine 		srclist = defaults;
669248aee62SJacques Vidrine 		srclistsize = 0;
670248aee62SJacques Vidrine 		while (srclist[srclistsize].name != NULL)
671248aee62SJacques Vidrine 			srclistsize++;
672248aee62SJacques Vidrine 	}
67306a99fe3SHajimu UMEMOTO 
67406a99fe3SHajimu UMEMOTO #ifdef NS_CACHING
67506a99fe3SHajimu UMEMOTO 	cache_data_p = NULL;
67606a99fe3SHajimu UMEMOTO 	cache_flag = 0;
67706a99fe3SHajimu UMEMOTO #endif
678248aee62SJacques Vidrine 	for (i = 0; i < srclistsize; i++) {
67946d93063SJacques Vidrine 		result = NS_NOTFOUND;
68046d93063SJacques Vidrine 		method = nss_method_lookup(srclist[i].name, database,
68146d93063SJacques Vidrine 		    method_name, disp_tab, &mdata);
68206a99fe3SHajimu UMEMOTO 
68346d93063SJacques Vidrine 		if (method != NULL) {
68406a99fe3SHajimu UMEMOTO #ifdef NS_CACHING
68506a99fe3SHajimu UMEMOTO 			if (strcmp(srclist[i].name, NSSRC_CACHE) == 0 &&
68606a99fe3SHajimu UMEMOTO 			    nss_cache_cycle_prevention_func == NULL) {
68706a99fe3SHajimu UMEMOTO #ifdef NS_STRICT_LIBC_EID_CHECKING
68806a99fe3SHajimu UMEMOTO 				if (issetugid() != 0)
68906a99fe3SHajimu UMEMOTO 					continue;
69006a99fe3SHajimu UMEMOTO #endif
69106a99fe3SHajimu UMEMOTO 				cache_flag = 1;
69206a99fe3SHajimu UMEMOTO 
69306a99fe3SHajimu UMEMOTO 				memset(&cache_data, 0, sizeof(nss_cache_data));
69406a99fe3SHajimu UMEMOTO 				cache_data.info = (nss_cache_info const *)mdata;
69506a99fe3SHajimu UMEMOTO 				cache_data_p = &cache_data;
69606a99fe3SHajimu UMEMOTO 
69706a99fe3SHajimu UMEMOTO 				va_start(ap, defaults);
69806a99fe3SHajimu UMEMOTO 				if (cache_data.info->id_func != NULL)
69906a99fe3SHajimu UMEMOTO 					result = __nss_common_cache_read(retval,
70006a99fe3SHajimu UMEMOTO 					    cache_data_p, ap);
70106a99fe3SHajimu UMEMOTO 				else if (cache_data.info->marshal_func != NULL)
70206a99fe3SHajimu UMEMOTO 					result = __nss_mp_cache_read(retval,
70306a99fe3SHajimu UMEMOTO 					    cache_data_p, ap);
70406a99fe3SHajimu UMEMOTO 				else
70506a99fe3SHajimu UMEMOTO 					result = __nss_mp_cache_end(retval,
70606a99fe3SHajimu UMEMOTO 					    cache_data_p, ap);
70706a99fe3SHajimu UMEMOTO 				va_end(ap);
70806a99fe3SHajimu UMEMOTO 			} else {
70906a99fe3SHajimu UMEMOTO 				cache_flag = 0;
710f700faa5SHajimu UMEMOTO 				errno = 0;
711248aee62SJacques Vidrine 				va_start(ap, defaults);
71246d93063SJacques Vidrine 				result = method(retval, mdata, ap);
713248aee62SJacques Vidrine 				va_end(ap);
71406a99fe3SHajimu UMEMOTO 			}
71506a99fe3SHajimu UMEMOTO #else /* NS_CACHING */
716f700faa5SHajimu UMEMOTO 			errno = 0;
71706a99fe3SHajimu UMEMOTO 			va_start(ap, defaults);
71806a99fe3SHajimu UMEMOTO 			result = method(retval, mdata, ap);
71906a99fe3SHajimu UMEMOTO 			va_end(ap);
72006a99fe3SHajimu UMEMOTO #endif /* NS_CACHING */
72106a99fe3SHajimu UMEMOTO 
72246d93063SJacques Vidrine 			if (result & (srclist[i].flags))
723248aee62SJacques Vidrine 				break;
72436736e35SMichael Bushkov 		} else {
72536736e35SMichael Bushkov 			if (fb_method != NULL) {
7266d722173SZachary Loafman 				st->fb_dispatch = 1;
727a59d6a87SMichael Bushkov 				va_start(ap, defaults);
72836736e35SMichael Bushkov 				result = fb_method(retval,
72936736e35SMichael Bushkov 				    (void *)srclist[i].name, ap);
730a59d6a87SMichael Bushkov 				va_end(ap);
7316d722173SZachary Loafman 				st->fb_dispatch = 0;
73236736e35SMichael Bushkov 			} else
73336736e35SMichael Bushkov 				nss_log(LOG_DEBUG, "%s, %s, %s, not found, "
73436736e35SMichael Bushkov 				    "and no fallback provided",
73536736e35SMichael Bushkov 				    srclist[i].name, database, method_name);
736248aee62SJacques Vidrine 		}
737248aee62SJacques Vidrine 	}
73806a99fe3SHajimu UMEMOTO 
73906a99fe3SHajimu UMEMOTO #ifdef NS_CACHING
74006a99fe3SHajimu UMEMOTO 	if (cache_data_p != NULL &&
74106a99fe3SHajimu UMEMOTO 	    (result & (NS_NOTFOUND | NS_SUCCESS)) && cache_flag == 0) {
74206a99fe3SHajimu UMEMOTO 		va_start(ap, defaults);
74306a99fe3SHajimu UMEMOTO 		if (result == NS_SUCCESS) {
74406a99fe3SHajimu UMEMOTO 			if (cache_data.info->id_func != NULL)
74506a99fe3SHajimu UMEMOTO 				__nss_common_cache_write(retval, cache_data_p,
74606a99fe3SHajimu UMEMOTO 				    ap);
74706a99fe3SHajimu UMEMOTO 			else if (cache_data.info->marshal_func != NULL)
74806a99fe3SHajimu UMEMOTO 				__nss_mp_cache_write(retval, cache_data_p, ap);
74906a99fe3SHajimu UMEMOTO 		} else if (result == NS_NOTFOUND) {
75006a99fe3SHajimu UMEMOTO 			if (cache_data.info->id_func == NULL) {
75106a99fe3SHajimu UMEMOTO 				if (cache_data.info->marshal_func != NULL)
75206a99fe3SHajimu UMEMOTO 					__nss_mp_cache_write_submit(retval,
75306a99fe3SHajimu UMEMOTO 					    cache_data_p, ap);
75406a99fe3SHajimu UMEMOTO 			} else
75506a99fe3SHajimu UMEMOTO 				__nss_common_cache_write_negative(cache_data_p);
75606a99fe3SHajimu UMEMOTO 		}
75706a99fe3SHajimu UMEMOTO 		va_end(ap);
75806a99fe3SHajimu UMEMOTO 	}
75906a99fe3SHajimu UMEMOTO #endif /* NS_CACHING */
76006a99fe3SHajimu UMEMOTO 
761a03fd3b6SJacques Vidrine 	if (isthreaded)
76246d93063SJacques Vidrine 		(void)_pthread_rwlock_unlock(&nss_lock);
76346d93063SJacques Vidrine fin:
76446d93063SJacques Vidrine 	errno = serrno;
76546d93063SJacques Vidrine 	return (result);
766248aee62SJacques Vidrine }
767