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 * We keep track of nsdispatch() nesting depth in dispatch_depth.  When a
136 * fallback method is invoked from nsdispatch(), we temporarily set
137 * fallback_depth to the current dispatch depth plus one.  Subsequent
138 * calls at that exact depth will run in fallback mode (restricted to the
139 * same source as the call that was handled by the fallback method), while
140 * calls below that depth will be handled normally, allowing fallback
141 * methods to perform arbitrary lookups.
142 */
143struct fb_state {
144	int	dispatch_depth;
145	int	fallback_depth;
146};
147static	void	fb_endstate(void *);
148NSS_TLS_HANDLING(fb);
149
150/*
151 * Attempt to spew relatively uniform messages to syslog.
152 */
153#define nss_log(level, fmt, ...) \
154	syslog((level), "NSSWITCH(%s): " fmt, __func__, __VA_ARGS__)
155#define nss_log_simple(level, s) \
156	syslog((level), "NSSWITCH(%s): " s, __func__)
157
158/*
159 * Dynamically growable arrays are used for lists of databases, sources,
160 * and modules.  The following `vector' interface is used to isolate the
161 * common operations.
162 */
163typedef	int	(*vector_comparison)(const void *, const void *);
164typedef	void	(*vector_free_elem)(void *);
165static	void	  vector_sort(void *, unsigned int, size_t,
166		    vector_comparison);
167static	void	  vector_free(void *, unsigned int *, size_t,
168		    vector_free_elem);
169static	void	 *vector_ref(unsigned int, void *, unsigned int, size_t);
170static	void	 *vector_search(const void *, void *, unsigned int, size_t,
171		    vector_comparison);
172static	void	 *vector_append(const void *, void *, unsigned int *, size_t);
173
174
175/*
176 * Internal interfaces.
177 */
178static	int	 string_compare(const void *, const void *);
179static	int	 mtab_compare(const void *, const void *);
180static	int	 nss_configure(void);
181static	void	 ns_dbt_free(ns_dbt *);
182static	void	 ns_mod_free(ns_mod *);
183static	void	 ns_src_free(ns_src **, int);
184static	void	 nss_load_builtin_modules(void);
185static	void	 nss_load_module(const char *, nss_module_register_fn);
186static	void	 nss_atexit(void);
187/* nsparser */
188extern	FILE	*_nsyyin;
189
190
191/*
192 * The vector operations
193 */
194static void
195vector_sort(void *vec, unsigned int count, size_t esize,
196    vector_comparison comparison)
197{
198	qsort(vec, count, esize, comparison);
199}
200
201
202static void *
203vector_search(const void *key, void *vec, unsigned int count, size_t esize,
204    vector_comparison comparison)
205{
206	return (bsearch(key, vec, count, esize, comparison));
207}
208
209
210static void *
211vector_append(const void *elem, void *vec, unsigned int *count, size_t esize)
212{
213	void	*p;
214
215	if ((*count % ELEMSPERCHUNK) == 0) {
216		p = realloc(vec, (*count + ELEMSPERCHUNK) * esize);
217		if (p == NULL) {
218			nss_log_simple(LOG_ERR, "memory allocation failure");
219			return (vec);
220		}
221		vec = p;
222	}
223	memmove((void *)(((uintptr_t)vec) + (*count * esize)), elem, esize);
224	(*count)++;
225	return (vec);
226}
227
228
229static void *
230vector_ref(unsigned int i, void *vec, unsigned int count, size_t esize)
231{
232	if (i < count)
233		return (void *)((uintptr_t)vec + (i * esize));
234	else
235		return (NULL);
236}
237
238
239#define VECTOR_FREE(v, c, s, f) \
240	do { vector_free(v, c, s, f); v = NULL; } while (0)
241static void
242vector_free(void *vec, unsigned int *count, size_t esize,
243    vector_free_elem free_elem)
244{
245	unsigned int	 i;
246	void		*elem;
247
248	for (i = 0; i < *count; i++) {
249		elem = vector_ref(i, vec, *count, esize);
250		if (elem != NULL)
251			free_elem(elem);
252	}
253	free(vec);
254	*count = 0;
255}
256
257/*
258 * Comparison functions for vector_search.
259 */
260static int
261string_compare(const void *a, const void *b)
262{
263      return (strcasecmp(*(const char * const *)a, *(const char * const *)b));
264}
265
266
267static int
268mtab_compare(const void *a, const void *b)
269{
270      int     cmp;
271
272      cmp = strcmp(((const ns_mtab *)a)->name, ((const ns_mtab *)b)->name);
273      if (cmp != 0)
274	      return (cmp);
275      else
276	      return (strcmp(((const ns_mtab *)a)->database,
277		  ((const ns_mtab *)b)->database));
278}
279
280/*
281 * NSS nsmap management.
282 */
283void
284_nsdbtaddsrc(ns_dbt *dbt, const ns_src *src)
285{
286	const ns_mod	*modp;
287
288	dbt->srclist = vector_append(src, dbt->srclist, &dbt->srclistsize,
289	    sizeof(*src));
290	modp = vector_search(&src->name, _nsmod, _nsmodsize, sizeof(*_nsmod),
291	    string_compare);
292	if (modp == NULL)
293		nss_load_module(src->name, NULL);
294}
295
296
297#ifdef _NSS_DEBUG
298void
299_nsdbtdump(const ns_dbt *dbt)
300{
301	int i;
302
303	printf("%s (%d source%s):", dbt->name, dbt->srclistsize,
304	    dbt->srclistsize == 1 ? "" : "s");
305	for (i = 0; i < (int)dbt->srclistsize; i++) {
306		printf(" %s", dbt->srclist[i].name);
307		if (!(dbt->srclist[i].flags &
308		    (NS_UNAVAIL|NS_NOTFOUND|NS_TRYAGAIN)) &&
309		    (dbt->srclist[i].flags & NS_SUCCESS))
310			continue;
311		printf(" [");
312		if (!(dbt->srclist[i].flags & NS_SUCCESS))
313			printf(" SUCCESS=continue");
314		if (dbt->srclist[i].flags & NS_UNAVAIL)
315			printf(" UNAVAIL=return");
316		if (dbt->srclist[i].flags & NS_NOTFOUND)
317			printf(" NOTFOUND=return");
318		if (dbt->srclist[i].flags & NS_TRYAGAIN)
319			printf(" TRYAGAIN=return");
320		printf(" ]");
321	}
322	printf("\n");
323}
324#endif
325
326
327/*
328 * The first time nsdispatch is called (during a process's lifetime,
329 * or after nsswitch.conf has been updated), nss_configure will
330 * prepare global data needed by NSS.
331 */
332static int
333nss_configure(void)
334{
335	static time_t	 confmod;
336	struct stat	 statbuf;
337	int		 result, isthreaded;
338	const char	*path;
339#ifdef NS_CACHING
340	void		*handle;
341#endif
342
343	result = 0;
344	isthreaded = __isthreaded;
345#if defined(_NSS_DEBUG) && defined(_NSS_SHOOT_FOOT)
346	/* NOTE WELL:  THIS IS A SECURITY HOLE. This must only be built
347	 * for debugging purposes and MUST NEVER be used in production.
348	 */
349	path = getenv("NSSWITCH_CONF");
350	if (path == NULL)
351#endif
352	path = _PATH_NS_CONF;
353	if (stat(path, &statbuf) != 0)
354		return (0);
355	if (statbuf.st_mtime <= confmod)
356		return (0);
357	if (isthreaded) {
358	    (void)_pthread_rwlock_unlock(&nss_lock);
359	    result = _pthread_rwlock_wrlock(&nss_lock);
360	    if (result != 0)
361		    return (result);
362	    if (stat(path, &statbuf) != 0)
363		    goto fin;
364	    if (statbuf.st_mtime <= confmod)
365		    goto fin;
366	}
367	_nsyyin = fopen(path, "re");
368	if (_nsyyin == NULL)
369		goto fin;
370	VECTOR_FREE(_nsmap, &_nsmapsize, sizeof(*_nsmap),
371	    (vector_free_elem)ns_dbt_free);
372	VECTOR_FREE(_nsmod, &_nsmodsize, sizeof(*_nsmod),
373	    (vector_free_elem)ns_mod_free);
374	nss_load_builtin_modules();
375	_nsyyparse();
376	(void)fclose(_nsyyin);
377	vector_sort(_nsmap, _nsmapsize, sizeof(*_nsmap), string_compare);
378	if (confmod == 0)
379		(void)atexit(nss_atexit);
380	confmod = statbuf.st_mtime;
381
382#ifdef NS_CACHING
383	handle = libc_dlopen(NULL, RTLD_LAZY | RTLD_GLOBAL);
384	if (handle != NULL) {
385		nss_cache_cycle_prevention_func = dlsym(handle,
386			"_nss_cache_cycle_prevention_function");
387		dlclose(handle);
388	}
389#endif
390fin:
391	if (isthreaded) {
392	    (void)_pthread_rwlock_unlock(&nss_lock);
393	    if (result == 0)
394		    result = _pthread_rwlock_rdlock(&nss_lock);
395	}
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	int		 saved_depth;
620
621#ifdef NS_CACHING
622	nss_cache_data	 cache_data;
623	nss_cache_data	*cache_data_p;
624	int		 cache_flag;
625#endif
626
627	dbt = NULL;
628	fb_method = NULL;
629
630	isthreaded = __isthreaded;
631	serrno = errno;
632	if (isthreaded) {
633		result = _pthread_rwlock_rdlock(&nss_lock);
634		if (result != 0) {
635			result = NS_UNAVAIL;
636			goto fin;
637		}
638	}
639
640	result = fb_getstate(&st);
641	if (result != 0) {
642		result = NS_UNAVAIL;
643		goto fin;
644	}
645
646	result = nss_configure();
647	if (result != 0) {
648		result = NS_UNAVAIL;
649		goto fin;
650	}
651	++st->dispatch_depth;
652	if (st->dispatch_depth > st->fallback_depth) {
653		dbt = vector_search(&database, _nsmap, _nsmapsize, sizeof(*_nsmap),
654		    string_compare);
655		fb_method = nss_method_lookup(NSSRC_FALLBACK, database,
656		    method_name, disp_tab, &mdata);
657	}
658
659	if (dbt != NULL) {
660		srclist = dbt->srclist;
661		srclistsize = dbt->srclistsize;
662	} else {
663		srclist = defaults;
664		srclistsize = 0;
665		while (srclist[srclistsize].name != NULL)
666			srclistsize++;
667	}
668
669#ifdef NS_CACHING
670	cache_data_p = NULL;
671	cache_flag = 0;
672#endif
673	for (i = 0; i < srclistsize; i++) {
674		result = NS_NOTFOUND;
675		method = nss_method_lookup(srclist[i].name, database,
676		    method_name, disp_tab, &mdata);
677
678		if (method != NULL) {
679#ifdef NS_CACHING
680			if (strcmp(srclist[i].name, NSSRC_CACHE) == 0 &&
681			    nss_cache_cycle_prevention_func == NULL) {
682#ifdef NS_STRICT_LIBC_EID_CHECKING
683				if (issetugid() != 0)
684					continue;
685#endif
686				cache_flag = 1;
687
688				memset(&cache_data, 0, sizeof(nss_cache_data));
689				cache_data.info = (nss_cache_info const *)mdata;
690				cache_data_p = &cache_data;
691
692				va_start(ap, defaults);
693				if (cache_data.info->id_func != NULL)
694					result = __nss_common_cache_read(retval,
695					    cache_data_p, ap);
696				else if (cache_data.info->marshal_func != NULL)
697					result = __nss_mp_cache_read(retval,
698					    cache_data_p, ap);
699				else
700					result = __nss_mp_cache_end(retval,
701					    cache_data_p, ap);
702				va_end(ap);
703			} else {
704				cache_flag = 0;
705				errno = 0;
706				va_start(ap, defaults);
707				result = method(retval, mdata, ap);
708				va_end(ap);
709			}
710#else /* NS_CACHING */
711			errno = 0;
712			va_start(ap, defaults);
713			result = method(retval, mdata, ap);
714			va_end(ap);
715#endif /* NS_CACHING */
716
717			if (result & (srclist[i].flags))
718				break;
719		} else {
720			if (fb_method != NULL) {
721				saved_depth = st->fallback_depth;
722				st->fallback_depth = st->dispatch_depth + 1;
723				va_start(ap, defaults);
724				result = fb_method(retval,
725				    (void *)srclist[i].name, ap);
726				va_end(ap);
727				st->fallback_depth = saved_depth;
728			} else
729				nss_log(LOG_DEBUG, "%s, %s, %s, not found, "
730				    "and no fallback provided",
731				    srclist[i].name, database, method_name);
732		}
733	}
734
735#ifdef NS_CACHING
736	if (cache_data_p != NULL &&
737	    (result & (NS_NOTFOUND | NS_SUCCESS)) && cache_flag == 0) {
738		va_start(ap, defaults);
739		if (result == NS_SUCCESS) {
740			if (cache_data.info->id_func != NULL)
741				__nss_common_cache_write(retval, cache_data_p,
742				    ap);
743			else if (cache_data.info->marshal_func != NULL)
744				__nss_mp_cache_write(retval, cache_data_p, ap);
745		} else if (result == NS_NOTFOUND) {
746			if (cache_data.info->id_func == NULL) {
747				if (cache_data.info->marshal_func != NULL)
748					__nss_mp_cache_write_submit(retval,
749					    cache_data_p, ap);
750			} else
751				__nss_common_cache_write_negative(cache_data_p);
752		}
753		va_end(ap);
754	}
755#endif /* NS_CACHING */
756
757	if (isthreaded)
758		(void)_pthread_rwlock_unlock(&nss_lock);
759	--st->dispatch_depth;
760fin:
761	errno = serrno;
762	return (result);
763}
764