1/*	$NetBSD: nsdispatch.c,v 1.9 1999/01/25 00:16:17 lukem Exp $	*/
2
3/*-
4 * Copyright (c) 1997, 1998, 1999 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Luke Mewburn.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 *    notice, this list of conditions and the following disclaimer in the
17 *    documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31/*-
32 * Copyright (c) 2003 Networks Associates Technology, Inc.
33 * All rights reserved.
34 *
35 * Portions of this software were developed for the FreeBSD Project by
36 * Jacques A. Vidrine, Safeport Network Services, and Network
37 * Associates Laboratories, the Security Research Division of Network
38 * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035
39 * ("CBOSS"), as part of the DARPA CHATS research program.
40 *
41 * Redistribution and use in source and binary forms, with or without
42 * modification, are permitted provided that the following conditions
43 * are met:
44 * 1. Redistributions of source code must retain the above copyright
45 *    notice, this list of conditions and the following disclaimer.
46 * 2. Redistributions in binary form must reproduce the above copyright
47 *    notice, this list of conditions and the following disclaimer in the
48 *    documentation and/or other materials provided with the distribution.
49 *
50 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
51 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
52 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
53 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
54 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
55 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
56 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
57 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
58 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
59 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
60 * SUCH DAMAGE.
61 *
62 */
63#include <sys/cdefs.h>
64__FBSDID("$FreeBSD$");
65
66#include "namespace.h"
67#include <sys/param.h>
68#include <sys/stat.h>
69
70#include <dlfcn.h>
71#include <errno.h>
72#include <fcntl.h>
73#define _NS_PRIVATE
74#include <nsswitch.h>
75#include <pthread.h>
76#include <pthread_np.h>
77#include <stdio.h>
78#include <stdlib.h>
79#include <string.h>
80#include <syslog.h>
81#include <unistd.h>
82#include "un-namespace.h"
83#include "nss_tls.h"
84#include "libc_private.h"
85#ifdef NS_CACHING
86#include "nscache.h"
87#endif
88
89enum _nss_constants {
90	/* Number of elements allocated when we grow a vector */
91	ELEMSPERCHUNK =	8
92};
93
94/*
95 * Global NSS data structures are mostly read-only, but we update
96 * them when we read or re-read the nsswitch.conf.
97 */
98static	pthread_rwlock_t	nss_lock = PTHREAD_RWLOCK_INITIALIZER;
99
100/*
101 * Runtime determination of whether we are dynamically linked or not.
102 */
103extern	int		_DYNAMIC __attribute__ ((weak));
104#define	is_dynamic()	(&_DYNAMIC != NULL)
105
106/*
107 * default sourcelist: `files'
108 */
109const ns_src __nsdefaultsrc[] = {
110	{ NSSRC_FILES, NS_SUCCESS },
111	{ 0 },
112};
113
114/* Database, source mappings. */
115static	unsigned int		 _nsmapsize;
116static	ns_dbt			*_nsmap = NULL;
117
118/* NSS modules. */
119static	unsigned int		 _nsmodsize;
120static	ns_mod			*_nsmod;
121
122/* Placeholder for builtin modules' dlopen `handle'. */
123static	int			 __nss_builtin_handle;
124static	void			*nss_builtin_handle = &__nss_builtin_handle;
125
126#ifdef NS_CACHING
127/*
128 * Cache lookup cycle prevention function - if !NULL then no cache lookups
129 * will be made
130 */
131static	void			*nss_cache_cycle_prevention_func = NULL;
132#endif
133
134/*
135 * When this is set to 1, nsdispatch won't use nsswitch.conf
136 * but will consult the 'defaults' source list only.
137 * NOTE: nested fallbacks (when nsdispatch calls fallback functions,
138 *     which in turn calls nsdispatch, which should call fallback
139 *     function) are not supported
140 */
141struct fb_state {
142	int	fb_dispatch;
143};
144static	void	fb_endstate(void *);
145NSS_TLS_HANDLING(fb);
146
147/*
148 * Attempt to spew relatively uniform messages to syslog.
149 */
150#define nss_log(level, fmt, ...) \
151	syslog((level), "NSSWITCH(%s): " fmt, __func__, __VA_ARGS__)
152#define nss_log_simple(level, s) \
153	syslog((level), "NSSWITCH(%s): " s, __func__)
154
155/*
156 * Dynamically growable arrays are used for lists of databases, sources,
157 * and modules.  The following `vector' interface is used to isolate the
158 * common operations.
159 */
160typedef	int	(*vector_comparison)(const void *, const void *);
161typedef	void	(*vector_free_elem)(void *);
162static	void	  vector_sort(void *, unsigned int, size_t,
163		    vector_comparison);
164static	void	  vector_free(void *, unsigned int *, size_t,
165		    vector_free_elem);
166static	void	 *vector_ref(unsigned int, void *, unsigned int, size_t);
167static	void	 *vector_search(const void *, void *, unsigned int, size_t,
168		    vector_comparison);
169static	void	 *vector_append(const void *, void *, unsigned int *, size_t);
170
171
172/*
173 * Internal interfaces.
174 */
175static	int	 string_compare(const void *, const void *);
176static	int	 mtab_compare(const void *, const void *);
177static	int	 nss_configure(void);
178static	void	 ns_dbt_free(ns_dbt *);
179static	void	 ns_mod_free(ns_mod *);
180static	void	 ns_src_free(ns_src **, int);
181static	void	 nss_load_builtin_modules(void);
182static	void	 nss_load_module(const char *, nss_module_register_fn);
183static	void	 nss_atexit(void);
184/* nsparser */
185extern	FILE	*_nsyyin;
186
187
188/*
189 * The vector operations
190 */
191static void
192vector_sort(void *vec, unsigned int count, size_t esize,
193    vector_comparison comparison)
194{
195	qsort(vec, count, esize, comparison);
196}
197
198
199static void *
200vector_search(const void *key, void *vec, unsigned int count, size_t esize,
201    vector_comparison comparison)
202{
203	return (bsearch(key, vec, count, esize, comparison));
204}
205
206
207static void *
208vector_append(const void *elem, void *vec, unsigned int *count, size_t esize)
209{
210	void	*p;
211
212	if ((*count % ELEMSPERCHUNK) == 0) {
213		p = realloc(vec, (*count + ELEMSPERCHUNK) * esize);
214		if (p == NULL) {
215			nss_log_simple(LOG_ERR, "memory allocation failure");
216			return (vec);
217		}
218		vec = p;
219	}
220	memmove((void *)(((uintptr_t)vec) + (*count * esize)), elem, esize);
221	(*count)++;
222	return (vec);
223}
224
225
226static void *
227vector_ref(unsigned int i, void *vec, unsigned int count, size_t esize)
228{
229	if (i < count)
230		return (void *)((uintptr_t)vec + (i * esize));
231	else
232		return (NULL);
233}
234
235
236#define VECTOR_FREE(v, c, s, f) \
237	do { vector_free(v, c, s, f); v = NULL; } while (0)
238static void
239vector_free(void *vec, unsigned int *count, size_t esize,
240    vector_free_elem free_elem)
241{
242	unsigned int	 i;
243	void		*elem;
244
245	for (i = 0; i < *count; i++) {
246		elem = vector_ref(i, vec, *count, esize);
247		if (elem != NULL)
248			free_elem(elem);
249	}
250	free(vec);
251	*count = 0;
252}
253
254/*
255 * Comparison functions for vector_search.
256 */
257static int
258string_compare(const void *a, const void *b)
259{
260      return (strcasecmp(*(const char * const *)a, *(const char * const *)b));
261}
262
263
264static int
265mtab_compare(const void *a, const void *b)
266{
267      int     cmp;
268
269      cmp = strcmp(((const ns_mtab *)a)->name, ((const ns_mtab *)b)->name);
270      if (cmp != 0)
271	      return (cmp);
272      else
273	      return (strcmp(((const ns_mtab *)a)->database,
274		  ((const ns_mtab *)b)->database));
275}
276
277/*
278 * NSS nsmap management.
279 */
280void
281_nsdbtaddsrc(ns_dbt *dbt, const ns_src *src)
282{
283	const ns_mod	*modp;
284
285	dbt->srclist = vector_append(src, dbt->srclist, &dbt->srclistsize,
286	    sizeof(*src));
287	modp = vector_search(&src->name, _nsmod, _nsmodsize, sizeof(*_nsmod),
288	    string_compare);
289	if (modp == NULL)
290		nss_load_module(src->name, NULL);
291}
292
293
294#ifdef _NSS_DEBUG
295void
296_nsdbtdump(const ns_dbt *dbt)
297{
298	int i;
299
300	printf("%s (%d source%s):", dbt->name, dbt->srclistsize,
301	    dbt->srclistsize == 1 ? "" : "s");
302	for (i = 0; i < (int)dbt->srclistsize; i++) {
303		printf(" %s", dbt->srclist[i].name);
304		if (!(dbt->srclist[i].flags &
305		    (NS_UNAVAIL|NS_NOTFOUND|NS_TRYAGAIN)) &&
306		    (dbt->srclist[i].flags & NS_SUCCESS))
307			continue;
308		printf(" [");
309		if (!(dbt->srclist[i].flags & NS_SUCCESS))
310			printf(" SUCCESS=continue");
311		if (dbt->srclist[i].flags & NS_UNAVAIL)
312			printf(" UNAVAIL=return");
313		if (dbt->srclist[i].flags & NS_NOTFOUND)
314			printf(" NOTFOUND=return");
315		if (dbt->srclist[i].flags & NS_TRYAGAIN)
316			printf(" TRYAGAIN=return");
317		printf(" ]");
318	}
319	printf("\n");
320}
321#endif
322
323
324/*
325 * The first time nsdispatch is called (during a process's lifetime,
326 * or after nsswitch.conf has been updated), nss_configure will
327 * prepare global data needed by NSS.
328 */
329static int
330nss_configure(void)
331{
332	static pthread_mutex_t conf_lock = PTHREAD_MUTEX_INITIALIZER;
333	static time_t	 confmod;
334	struct stat	 statbuf;
335	int		 result, isthreaded;
336	const char	*path;
337#ifdef NS_CACHING
338	void		*handle;
339#endif
340
341	result = 0;
342	isthreaded = __isthreaded;
343#if defined(_NSS_DEBUG) && defined(_NSS_SHOOT_FOOT)
344	/* NOTE WELL:  THIS IS A SECURITY HOLE. This must only be built
345	 * for debugging purposes and MUST NEVER be used in production.
346	 */
347	path = getenv("NSSWITCH_CONF");
348	if (path == NULL)
349#endif
350	path = _PATH_NS_CONF;
351	if (stat(path, &statbuf) != 0)
352		return (0);
353	if (statbuf.st_mtime <= confmod)
354		return (0);
355	if (isthreaded) {
356	    result = _pthread_mutex_trylock(&conf_lock);
357	    if (result != 0)
358		    return (0);
359	    (void)_pthread_rwlock_unlock(&nss_lock);
360	    result = _pthread_rwlock_wrlock(&nss_lock);
361	    if (result != 0)
362		    goto fin2;
363	}
364	_nsyyin = fopen(path, "re");
365	if (_nsyyin == NULL)
366		goto fin;
367	VECTOR_FREE(_nsmap, &_nsmapsize, sizeof(*_nsmap),
368	    (vector_free_elem)ns_dbt_free);
369	VECTOR_FREE(_nsmod, &_nsmodsize, sizeof(*_nsmod),
370	    (vector_free_elem)ns_mod_free);
371	nss_load_builtin_modules();
372	_nsyyparse();
373	(void)fclose(_nsyyin);
374	vector_sort(_nsmap, _nsmapsize, sizeof(*_nsmap), string_compare);
375	if (confmod == 0)
376		(void)atexit(nss_atexit);
377	confmod = statbuf.st_mtime;
378
379#ifdef NS_CACHING
380	handle = libc_dlopen(NULL, RTLD_LAZY | RTLD_GLOBAL);
381	if (handle != NULL) {
382		nss_cache_cycle_prevention_func = dlsym(handle,
383			"_nss_cache_cycle_prevention_function");
384		dlclose(handle);
385	}
386#endif
387fin:
388	if (isthreaded) {
389	    (void)_pthread_rwlock_unlock(&nss_lock);
390	    if (result == 0)
391		    result = _pthread_rwlock_rdlock(&nss_lock);
392	}
393fin2:
394	if (isthreaded)
395		(void)_pthread_mutex_unlock(&conf_lock);
396	return (result);
397}
398
399
400void
401_nsdbtput(const ns_dbt *dbt)
402{
403	unsigned int	 i;
404	ns_dbt		*p;
405
406	for (i = 0; i < _nsmapsize; i++) {
407		p = vector_ref(i, _nsmap, _nsmapsize, sizeof(*_nsmap));
408		if (string_compare(&dbt->name, &p->name) == 0) {
409			/* overwrite existing entry */
410			if (p->srclist != NULL)
411				ns_src_free(&p->srclist, p->srclistsize);
412			memmove(p, dbt, sizeof(*dbt));
413			return;
414		}
415	}
416	_nsmap = vector_append(dbt, _nsmap, &_nsmapsize, sizeof(*_nsmap));
417}
418
419
420static void
421ns_dbt_free(ns_dbt *dbt)
422{
423	ns_src_free(&dbt->srclist, dbt->srclistsize);
424	if (dbt->name)
425		free((void *)dbt->name);
426}
427
428
429static void
430ns_src_free(ns_src **src, int srclistsize)
431{
432	int	i;
433
434	for (i = 0; i < srclistsize; i++)
435		if ((*src)[i].name != NULL)
436			/* This one was allocated by nslexer. You'll just
437			 * have to trust me.
438			 */
439			free((void *)((*src)[i].name));
440	free(*src);
441	*src = NULL;
442}
443
444
445
446/*
447 * NSS module management.
448 */
449/* The built-in NSS modules are all loaded at once. */
450#define NSS_BACKEND(name, reg) \
451ns_mtab	*reg(unsigned int *, nss_module_unregister_fn *);
452#include "nss_backends.h"
453#undef NSS_BACKEND
454
455static void
456nss_load_builtin_modules(void)
457{
458#define NSS_BACKEND(name, reg) nss_load_module(#name, reg);
459#include "nss_backends.h"
460#undef NSS_BACKEND
461}
462
463
464/* Load a built-in or dynamically linked module.  If the `reg_fn'
465 * argument is non-NULL, assume a built-in module and use reg_fn to
466 * register it.  Otherwise, search for a dynamic NSS module.
467 */
468static void
469nss_load_module(const char *source, nss_module_register_fn reg_fn)
470{
471	char		 buf[PATH_MAX];
472	ns_mod		 mod;
473	nss_module_register_fn fn;
474
475	memset(&mod, 0, sizeof(mod));
476	mod.name = strdup(source);
477	if (mod.name == NULL) {
478		nss_log_simple(LOG_ERR, "memory allocation failure");
479		return;
480	}
481	if (reg_fn != NULL) {
482		/* The placeholder is required, as a NULL handle
483		 * represents an invalid module.
484		 */
485		mod.handle = nss_builtin_handle;
486		fn = reg_fn;
487	} else if (!is_dynamic())
488		goto fin;
489	else {
490		if (snprintf(buf, sizeof(buf), "nss_%s.so.%d", mod.name,
491		    NSS_MODULE_INTERFACE_VERSION) >= (int)sizeof(buf))
492			goto fin;
493		mod.handle = libc_dlopen(buf, RTLD_LOCAL|RTLD_LAZY);
494		if (mod.handle == NULL) {
495#ifdef _NSS_DEBUG
496			/* This gets pretty annoying since the built-in
497			 * sources aren't modules yet.
498			 */
499			nss_log(LOG_DEBUG, "%s, %s", mod.name, dlerror());
500#endif
501			goto fin;
502		}
503		fn = (nss_module_register_fn)dlfunc(mod.handle,
504		    "nss_module_register");
505		if (fn == NULL) {
506			(void)dlclose(mod.handle);
507			mod.handle = NULL;
508			nss_log(LOG_ERR, "%s, %s", mod.name, dlerror());
509			goto fin;
510		}
511	}
512	mod.mtab = fn(mod.name, &mod.mtabsize, &mod.unregister);
513	if (mod.mtab == NULL || mod.mtabsize == 0) {
514		if (mod.handle != nss_builtin_handle)
515			(void)dlclose(mod.handle);
516		mod.handle = NULL;
517		nss_log(LOG_ERR, "%s, registration failed", mod.name);
518		goto fin;
519	}
520	if (mod.mtabsize > 1)
521		qsort(mod.mtab, mod.mtabsize, sizeof(mod.mtab[0]),
522		    mtab_compare);
523fin:
524	_nsmod = vector_append(&mod, _nsmod, &_nsmodsize, sizeof(*_nsmod));
525	vector_sort(_nsmod, _nsmodsize, sizeof(*_nsmod), string_compare);
526}
527
528
529
530static void
531ns_mod_free(ns_mod *mod)
532{
533
534	free(mod->name);
535	if (mod->handle == NULL)
536		return;
537	if (mod->unregister != NULL)
538		mod->unregister(mod->mtab, mod->mtabsize);
539	if (mod->handle != nss_builtin_handle)
540		(void)dlclose(mod->handle);
541}
542
543
544
545/*
546 * Cleanup
547 */
548static void
549nss_atexit(void)
550{
551	int isthreaded;
552
553	isthreaded = __isthreaded;
554	if (isthreaded)
555		(void)_pthread_rwlock_wrlock(&nss_lock);
556	VECTOR_FREE(_nsmap, &_nsmapsize, sizeof(*_nsmap),
557	    (vector_free_elem)ns_dbt_free);
558	VECTOR_FREE(_nsmod, &_nsmodsize, sizeof(*_nsmod),
559	    (vector_free_elem)ns_mod_free);
560	if (isthreaded)
561		(void)_pthread_rwlock_unlock(&nss_lock);
562}
563
564
565
566/*
567 * Finally, the actual implementation.
568 */
569static nss_method
570nss_method_lookup(const char *source, const char *database,
571    const char *method, const ns_dtab disp_tab[], void **mdata)
572{
573	ns_mod	*mod;
574	ns_mtab	*match, key;
575	int	 i;
576
577	if (disp_tab != NULL)
578		for (i = 0; disp_tab[i].src != NULL; i++)
579			if (strcasecmp(source, disp_tab[i].src) == 0) {
580				*mdata = disp_tab[i].mdata;
581				return (disp_tab[i].method);
582			}
583	mod = vector_search(&source, _nsmod, _nsmodsize, sizeof(*_nsmod),
584	    string_compare);
585	if (mod != NULL && mod->handle != NULL) {
586		key.database = database;
587		key.name = method;
588		match = bsearch(&key, mod->mtab, mod->mtabsize,
589		    sizeof(mod->mtab[0]), mtab_compare);
590		if (match != NULL) {
591			*mdata = match->mdata;
592			return (match->method);
593		}
594	}
595
596	*mdata = NULL;
597	return (NULL);
598}
599
600static void
601fb_endstate(void *p)
602{
603	free(p);
604}
605
606__weak_reference(_nsdispatch, nsdispatch);
607
608int
609_nsdispatch(void *retval, const ns_dtab disp_tab[], const char *database,
610	    const char *method_name, const ns_src defaults[], ...)
611{
612	va_list		 ap;
613	const ns_dbt	*dbt;
614	const ns_src	*srclist;
615	nss_method	 method, fb_method;
616	void		*mdata;
617	int		 isthreaded, serrno, i, result, srclistsize;
618	struct fb_state	*st;
619
620#ifdef NS_CACHING
621	nss_cache_data	 cache_data;
622	nss_cache_data	*cache_data_p;
623	int		 cache_flag;
624#endif
625
626	dbt = NULL;
627	fb_method = NULL;
628
629	isthreaded = __isthreaded;
630	serrno = errno;
631	if (isthreaded) {
632		result = _pthread_rwlock_rdlock(&nss_lock);
633		if (result != 0) {
634			result = NS_UNAVAIL;
635			goto fin;
636		}
637	}
638
639	result = fb_getstate(&st);
640	if (result != 0) {
641		result = NS_UNAVAIL;
642		goto fin;
643	}
644
645	result = nss_configure();
646	if (result != 0) {
647		result = NS_UNAVAIL;
648		goto fin;
649	}
650	if (st->fb_dispatch == 0) {
651		dbt = vector_search(&database, _nsmap, _nsmapsize, sizeof(*_nsmap),
652		    string_compare);
653		fb_method = nss_method_lookup(NSSRC_FALLBACK, database,
654		    method_name, disp_tab, &mdata);
655	}
656
657	if (dbt != NULL) {
658		srclist = dbt->srclist;
659		srclistsize = dbt->srclistsize;
660	} else {
661		srclist = defaults;
662		srclistsize = 0;
663		while (srclist[srclistsize].name != NULL)
664			srclistsize++;
665	}
666
667#ifdef NS_CACHING
668	cache_data_p = NULL;
669	cache_flag = 0;
670#endif
671	for (i = 0; i < srclistsize; i++) {
672		result = NS_NOTFOUND;
673		method = nss_method_lookup(srclist[i].name, database,
674		    method_name, disp_tab, &mdata);
675
676		if (method != NULL) {
677#ifdef NS_CACHING
678			if (strcmp(srclist[i].name, NSSRC_CACHE) == 0 &&
679			    nss_cache_cycle_prevention_func == NULL) {
680#ifdef NS_STRICT_LIBC_EID_CHECKING
681				if (issetugid() != 0)
682					continue;
683#endif
684				cache_flag = 1;
685
686				memset(&cache_data, 0, sizeof(nss_cache_data));
687				cache_data.info = (nss_cache_info const *)mdata;
688				cache_data_p = &cache_data;
689
690				va_start(ap, defaults);
691				if (cache_data.info->id_func != NULL)
692					result = __nss_common_cache_read(retval,
693					    cache_data_p, ap);
694				else if (cache_data.info->marshal_func != NULL)
695					result = __nss_mp_cache_read(retval,
696					    cache_data_p, ap);
697				else
698					result = __nss_mp_cache_end(retval,
699					    cache_data_p, ap);
700				va_end(ap);
701			} else {
702				cache_flag = 0;
703				errno = 0;
704				va_start(ap, defaults);
705				result = method(retval, mdata, ap);
706				va_end(ap);
707			}
708#else /* NS_CACHING */
709			errno = 0;
710			va_start(ap, defaults);
711			result = method(retval, mdata, ap);
712			va_end(ap);
713#endif /* NS_CACHING */
714
715			if (result & (srclist[i].flags))
716				break;
717		} else {
718			if (fb_method != NULL) {
719				st->fb_dispatch = 1;
720				va_start(ap, defaults);
721				result = fb_method(retval,
722				    (void *)srclist[i].name, ap);
723				va_end(ap);
724				st->fb_dispatch = 0;
725			} else
726				nss_log(LOG_DEBUG, "%s, %s, %s, not found, "
727				    "and no fallback provided",
728				    srclist[i].name, database, method_name);
729		}
730	}
731
732#ifdef NS_CACHING
733	if (cache_data_p != NULL &&
734	    (result & (NS_NOTFOUND | NS_SUCCESS)) && cache_flag == 0) {
735		va_start(ap, defaults);
736		if (result == NS_SUCCESS) {
737			if (cache_data.info->id_func != NULL)
738				__nss_common_cache_write(retval, cache_data_p,
739				    ap);
740			else if (cache_data.info->marshal_func != NULL)
741				__nss_mp_cache_write(retval, cache_data_p, ap);
742		} else if (result == NS_NOTFOUND) {
743			if (cache_data.info->id_func == NULL) {
744				if (cache_data.info->marshal_func != NULL)
745					__nss_mp_cache_write_submit(retval,
746					    cache_data_p, ap);
747			} else
748				__nss_common_cache_write_negative(cache_data_p);
749		}
750		va_end(ap);
751	}
752#endif /* NS_CACHING */
753
754	if (isthreaded)
755		(void)_pthread_rwlock_unlock(&nss_lock);
756fin:
757	errno = serrno;
758	return (result);
759}
760