1/*	$NetBSD: nsdispatch.c,v 1.39 2022/04/19 20:32:15 rillig Exp $	*/
2
3/*-
4 * Copyright (c) 1997, 1998, 1999, 2004 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; and by Jason R. Thorpe.
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/*-
33 * Copyright (c) 2003 Networks Associates Technology, Inc.
34 * All rights reserved.
35 *
36 * Portions of this software were developed for the FreeBSD Project by
37 * Jacques A. Vidrine, Safeport Network Services, and Network
38 * Associates Laboratories, the Security Research Division of Network
39 * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035
40 * ("CBOSS"), as part of the DARPA CHATS research program.
41 *
42 * Redistribution and use in source and binary forms, with or without
43 * modification, are permitted provided that the following conditions
44 * are met:
45 * 1. Redistributions of source code must retain the above copyright
46 *    notice, this list of conditions and the following disclaimer.
47 * 2. Redistributions in binary form must reproduce the above copyright
48 *    notice, this list of conditions and the following disclaimer in the
49 *    documentation and/or other materials provided with the distribution.
50 *
51 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
52 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
53 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
54 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
55 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
56 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
57 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
58 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
59 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
60 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
61 * SUCH DAMAGE.
62 */
63
64#include <sys/cdefs.h>
65#if defined(LIBC_SCCS) && !defined(lint)
66__RCSID("$NetBSD: nsdispatch.c,v 1.39 2022/04/19 20:32:15 rillig Exp $");
67#endif /* LIBC_SCCS and not lint */
68
69#include "namespace.h"
70
71#include <sys/types.h>
72#include <sys/param.h>
73#include <sys/stat.h>
74#include <sys/queue.h>
75
76#include <assert.h>
77#ifdef __ELF__
78#include <dlfcn.h>
79#endif /* __ELF__ */
80#include <err.h>
81#include <fcntl.h>
82#define _NS_PRIVATE
83#include <nsswitch.h>
84#include <stdarg.h>
85#include <stdio.h>
86#include <stdlib.h>
87#include <string.h>
88#include <unistd.h>
89
90#include "reentrant.h"
91
92extern	FILE 	*_nsyyin;
93extern	int	 _nsyyparse(void);
94
95
96#ifdef __weak_alias
97__weak_alias(nsdispatch,_nsdispatch)
98#endif
99
100
101/*
102 * default sourcelist: `files'
103 */
104const ns_src __nsdefaultsrc[] = {
105	{ NSSRC_FILES,	NS_SUCCESS },
106	{ 0, 0 },
107};
108
109const ns_src __nsdefaultcompat[] = {
110	{ NSSRC_COMPAT,	NS_SUCCESS },
111	{ 0, 0 }
112};
113
114const ns_src __nsdefaultcompat_forceall[] = {
115	{ NSSRC_COMPAT,	NS_SUCCESS | NS_FORCEALL },
116	{ 0, 0 }
117};
118
119const ns_src __nsdefaultfiles[] = {
120	{ NSSRC_FILES,	NS_SUCCESS },
121	{ 0, 0 },
122};
123
124const ns_src __nsdefaultfiles_forceall[] = {
125	{ NSSRC_FILES,	NS_SUCCESS | NS_FORCEALL },
126	{ 0, 0 },
127};
128
129const ns_src __nsdefaultnis[] = {
130	{ NSSRC_NIS,	NS_SUCCESS },
131	{ 0, 0 }
132};
133
134const ns_src __nsdefaultnis_forceall[] = {
135	{ NSSRC_NIS,	NS_SUCCESS | NS_FORCEALL },
136	{ 0, 0 }
137};
138
139
140/* Database, source mappings. */
141static	u_int			 _nsmapsize;
142static	ns_dbt			*_nsmap;
143
144/* Nsswitch modules. */
145static	u_int			 _nsmodsize;
146static	ns_mod			*_nsmod;
147
148/* Placeholder for built-in modules' dlopen() handles. */
149static	void			*_nsbuiltin = &_nsbuiltin;
150
151#ifdef _REENTRANT
152/*
153 * Global nsswitch data structures are mostly read-only, but we update them
154 * when we read or re-read nsswitch.conf.
155 */
156static 	rwlock_t		_nslock = RWLOCK_INITIALIZER;
157
158/*
159 * List of threads currently in nsdispatch().  We use this to detect
160 * recursive calls and avoid reloading configuration in such cases,
161 * which could cause deadlock.
162 */
163struct _ns_drec {
164	LIST_ENTRY(_ns_drec)	list;
165	thr_t			thr;
166};
167static LIST_HEAD(, _ns_drec) _ns_drec = LIST_HEAD_INITIALIZER(&_ns_drec);
168static mutex_t _ns_drec_lock = MUTEX_INITIALIZER;
169#endif /* _REENTRANT */
170
171
172/*
173 * Runtime determination of whether we are dynamically linked or not.
174 */
175#ifndef __ELF__
176#define	is_dynamic()		(0)	/* don't bother - switch to ELF! */
177#else
178__weakref_visible int rtld_DYNAMIC __weak_reference(_DYNAMIC);
179#define	is_dynamic()		(&rtld_DYNAMIC != NULL)
180#endif
181
182
183/*
184 * size of dynamic array chunk for _nsmap and _nsmap[x].srclist (and other
185 * growing arrays).
186 */
187#define NSELEMSPERCHUNK		8
188
189/*
190 * Dynamically growable arrays are used for lists of databases, sources,
191 * and modules.  The following "vector" API is used to isolate the
192 * common operations.
193 */
194typedef void	(*_nsvect_free_elem)(void *);
195
196static void *
197_nsvect_append(const void *elem, void *vec, u_int *count, size_t esize)
198{
199	void	*p;
200
201	if ((*count % NSELEMSPERCHUNK) == 0) {
202		p = realloc(vec, (*count + NSELEMSPERCHUNK) * esize);
203		if (p == NULL)
204			return (NULL);
205		vec = p;
206	}
207	memmove((void *)(((uintptr_t)vec) + (*count * esize)), elem, esize);
208	(*count)++;
209	return (vec);
210}
211
212static void *
213_nsvect_elem(u_int i, void *vec, u_int count, size_t esize)
214{
215
216	if (i < count)
217		return ((void *)((uintptr_t)vec + (i * esize)));
218	else
219		return (NULL);
220}
221
222static void
223_nsvect_free(void *vec, u_int *count, size_t esize, _nsvect_free_elem free_elem)
224{
225	void	*elem;
226	u_int	 i;
227
228	for (i = 0; i < *count; i++) {
229		elem = _nsvect_elem(i, vec, *count, esize);
230		if (elem != NULL)
231			(*free_elem)(elem);
232	}
233	if (vec != NULL)
234		free(vec);
235	*count = 0;
236}
237#define	_NSVECT_FREE(v, c, s, f)					\
238do {									\
239	_nsvect_free((v), (c), (s), (f));				\
240	(v) = NULL;							\
241} while (0)
242
243static int
244_nsdbtcmp(const void *a, const void *b)
245{
246
247	return (strcasecmp(((const ns_dbt *)a)->name,
248	    ((const ns_dbt *)b)->name));
249}
250
251static int
252_nsmodcmp(const void *a, const void *b)
253{
254
255	return (strcasecmp(((const ns_mod *)a)->name,
256	    ((const ns_mod *)b)->name));
257}
258
259static int
260_nsmtabcmp(const void *a, const void *b)
261{
262	int	cmp;
263
264	cmp = strcmp(((const ns_mtab *)a)->name,
265	    ((const ns_mtab *)b)->name);
266	if (cmp)
267		return (cmp);
268
269	return (strcasecmp(((const ns_mtab *)a)->database,
270	    ((const ns_mtab *)b)->database));
271}
272
273static void
274_nsmodfree(ns_mod *mod)
275{
276
277	free(__UNCONST(mod->name));
278	if (mod->handle == NULL)
279		return;
280	if (mod->unregister != NULL)
281		(*mod->unregister)(mod->mtab, mod->mtabsize);
282#ifdef __ELF__
283	if (mod->handle != _nsbuiltin)
284		(void) dlclose(mod->handle);
285#endif /* __ELF__ */
286}
287
288/*
289 * Load a built-in or dyanamically linked module.  If the `reg_fn'
290 * argument is non-NULL, assume a built-in module and use `reg_fn'
291 * to register it.  Otherwise, search for a dynamic nsswitch module.
292 */
293static int
294_nsloadmod(const char *source, nss_module_register_fn reg_fn)
295{
296#ifdef __ELF__
297	char	buf[PATH_MAX];
298#endif
299	ns_mod	mod, *new;
300
301	memset(&mod, 0, sizeof(mod));
302	mod.name = strdup(source);
303	if (mod.name == NULL)
304		return (-1);
305
306	if (reg_fn != NULL) {
307		/*
308		 * The placeholder is required, as a NULL handle
309		 * represents an invalid module.
310		 */
311		mod.handle = _nsbuiltin;
312	} else if (!is_dynamic()) {
313		goto out;
314	} else {
315#ifdef __ELF__
316		if (snprintf(buf, sizeof(buf), "nss_%s.so.%d", mod.name,
317		    NSS_MODULE_INTERFACE_VERSION) >= (int)sizeof(buf))
318			goto out;
319		mod.handle = dlopen(buf, RTLD_LOCAL | RTLD_LAZY);
320		if (mod.handle == NULL) {
321#ifdef _NSS_DEBUG
322			/*
323			 * This gets pretty annoying, since the built-in
324			 * sources are not yet modules.
325			 */
326			/* XXX log some error? */
327#endif
328			goto out;
329		}
330		reg_fn = (nss_module_register_fn) dlsym(mod.handle,
331		    "nss_module_register");
332		if (reg_fn == NULL) {
333			(void) dlclose(mod.handle);
334			mod.handle = NULL;
335			/* XXX log some error? */
336			goto out;
337		}
338#else /* ! __ELF__ */
339		mod.handle = NULL;
340#endif /* __ELF__ */
341	}
342	mod.mtab = (*reg_fn)(mod.name, &mod.mtabsize, &mod.unregister);
343	if (mod.mtab == NULL || mod.mtabsize == 0) {
344#ifdef __ELF__
345		if (mod.handle != _nsbuiltin)
346			(void) dlclose(mod.handle);
347#endif /* __ELF__ */
348		mod.handle = NULL;
349		/* XXX log some error? */
350		goto out;
351	}
352	if (mod.mtabsize > 1)
353		qsort(mod.mtab, mod.mtabsize, sizeof(mod.mtab[0]),
354		    _nsmtabcmp);
355 out:
356	new = _nsvect_append(&mod, _nsmod, &_nsmodsize, sizeof(*_nsmod));
357	if (new == NULL) {
358		_nsmodfree(&mod);
359		return (-1);
360	}
361	_nsmod = new;
362	/* _nsmodsize already incremented */
363
364	qsort(_nsmod, _nsmodsize, sizeof(*_nsmod), _nsmodcmp);
365	return (0);
366}
367
368static void
369_nsloadbuiltin(void)
370{
371
372	/* Do nothing, for now. */
373}
374
375int
376_nsdbtaddsrc(ns_dbt *dbt, const ns_src *src)
377{
378	void		*new;
379	const ns_mod	*mod;
380	ns_mod		 modkey;
381
382	_DIAGASSERT(dbt != NULL);
383	_DIAGASSERT(src != NULL);
384
385	new = _nsvect_append(src, dbt->srclist, &dbt->srclistsize,
386	    sizeof(*src));
387	if (new == NULL)
388		return (-1);
389	dbt->srclist = new;
390	/* dbt->srclistsize already incremented */
391
392	modkey.name = src->name;
393	mod = bsearch(&modkey, _nsmod, _nsmodsize, sizeof(*_nsmod), _nsmodcmp);
394	if (mod == NULL)
395		return (_nsloadmod(src->name, NULL));
396
397	return (0);
398}
399
400void
401_nsdbtdump(const ns_dbt *dbt)
402{
403	unsigned int	i;
404
405	_DIAGASSERT(dbt != NULL);
406
407	printf("%s (%d source%s):", dbt->name, dbt->srclistsize,
408	    dbt->srclistsize == 1 ? "" : "s");
409	for (i = 0; i < dbt->srclistsize; i++) {
410		printf(" %s", dbt->srclist[i].name);
411		if (!(dbt->srclist[i].flags &
412		    (NS_UNAVAIL|NS_NOTFOUND|NS_TRYAGAIN)) &&
413		    (dbt->srclist[i].flags & NS_SUCCESS))
414			continue;
415		printf(" [");
416		if (!(dbt->srclist[i].flags & NS_SUCCESS))
417			printf(" SUCCESS=continue");
418		if (dbt->srclist[i].flags & NS_UNAVAIL)
419			printf(" UNAVAIL=return");
420		if (dbt->srclist[i].flags & NS_NOTFOUND)
421			printf(" NOTFOUND=return");
422		if (dbt->srclist[i].flags & NS_TRYAGAIN)
423			printf(" TRYAGAIN=return");
424		printf(" ]");
425	}
426	printf("\n");
427}
428
429static void
430_nssrclist_free(ns_src **src, u_int srclistsize)
431{
432	u_int	i;
433
434	for (i = 0; i < srclistsize; i++) {
435		if ((*src)[i].name != NULL)
436			free(__UNCONST((*src)[i].name));
437	}
438	free(*src);
439	*src = NULL;
440}
441
442static void
443_nsdbtfree(ns_dbt *dbt)
444{
445
446	_nssrclist_free(&dbt->srclist, dbt->srclistsize);
447	if (dbt->name != NULL)
448		free(__UNCONST(dbt->name));
449}
450
451int
452_nsdbtput(const ns_dbt *dbt)
453{
454	ns_dbt	*p;
455	void	*new;
456	u_int	i;
457
458	_DIAGASSERT(dbt != NULL);
459
460	for (i = 0; i < _nsmapsize; i++) {
461		p = _nsvect_elem(i, _nsmap, _nsmapsize, sizeof(*_nsmap));
462		if (strcasecmp(dbt->name, p->name) == 0) {
463					/* overwrite existing entry */
464			if (p->srclist != NULL)
465				_nssrclist_free(&p->srclist, p->srclistsize);
466			memmove(p, dbt, sizeof(*dbt));
467			return (0);
468		}
469	}
470	new = _nsvect_append(dbt, _nsmap, &_nsmapsize, sizeof(*_nsmap));
471	if (new == NULL)
472		return (-1);
473	_nsmap = new;
474	/* _nsmapsize already incremented */
475
476	return (0);
477}
478
479/*
480 * This function is called each time nsdispatch() is called.  If this
481 * is the first call, or if the configuration has changed, (re-)prepare
482 * the global data used by NSS.
483 */
484static int
485_nsconfigure(void)
486{
487#ifdef _REENTRANT
488	static mutex_t	_nsconflock = MUTEX_INITIALIZER;
489#endif
490	static time_t	_nsconfmod;
491	struct stat	statbuf;
492
493	mutex_lock(&_nsconflock);
494
495	if (stat(_PATH_NS_CONF, &statbuf) == -1) {
496		/*
497		 * No nsswitch.conf; just use whatever configuration we
498		 * currently have, or fall back on the defaults specified
499		 * by the caller.
500		 */
501		mutex_unlock(&_nsconflock);
502		return (0);
503	}
504
505	if (statbuf.st_mtime <= _nsconfmod) {
506		/* Internal state is up-to-date with nsswitch.conf. */
507		mutex_unlock(&_nsconflock);
508		return (0);
509	}
510
511	/*
512	 * Ok, we've decided we need to update the nsswitch configuration
513	 * structures.  Acquire a write-lock on _nslock while continuing
514	 * to hold _nsconflock.  Acquiring a write-lock blocks while
515	 * waiting for other threads already holding a read-lock to clear.
516	 * We hold _nsconflock for the duration, and update the time stamp
517	 * at the end of the update operation, at which time we release
518	 * both locks.
519	 */
520	rwlock_wrlock(&_nslock);
521
522	_nsyyin = fopen(_PATH_NS_CONF, "re");
523	if (_nsyyin == NULL) {
524		/*
525		 * Unable to open nsswitch.conf; behave as though the
526		 * stat() above failed.  Even though we have already
527		 * updated _nsconfmod, if the file reappears, the
528		 * mtime will change.
529		 */
530		goto out;
531	}
532
533	_NSVECT_FREE(_nsmap, &_nsmapsize, sizeof(*_nsmap),
534	    (_nsvect_free_elem) _nsdbtfree);
535	_NSVECT_FREE(_nsmod, &_nsmodsize, sizeof(*_nsmod),
536	    (_nsvect_free_elem) _nsmodfree);
537
538	_nsloadbuiltin();
539
540	_nsyyparse();
541	(void) fclose(_nsyyin);
542	if (_nsmapsize != 0)
543		qsort(_nsmap, _nsmapsize, sizeof(*_nsmap), _nsdbtcmp);
544
545	_nsconfmod = statbuf.st_mtime;
546
547 out:
548	rwlock_unlock(&_nslock);
549	mutex_unlock(&_nsconflock);
550	return (0);
551}
552
553static nss_method
554_nsmethod(const char *source, const char *database, const char *method,
555    const ns_dtab disp_tab[], void **cb_data)
556{
557	int	curdisp;
558	ns_mod	*mod, modkey;
559	ns_mtab	*mtab, mtabkey;
560
561	if (disp_tab != NULL) {
562		for (curdisp = 0; disp_tab[curdisp].src != NULL; curdisp++) {
563			if (strcasecmp(source, disp_tab[curdisp].src) == 0) {
564				*cb_data = disp_tab[curdisp].cb_data;
565				return (disp_tab[curdisp].callback);
566			}
567		}
568	}
569
570	modkey.name = source;
571	mod = bsearch(&modkey, _nsmod, _nsmodsize, sizeof(*_nsmod),
572	    _nsmodcmp);
573	if (mod != NULL && mod->handle != NULL) {
574		mtabkey.database = database;
575		mtabkey.name = method;
576		mtab = bsearch(&mtabkey, mod->mtab, mod->mtabsize,
577		    sizeof(mod->mtab[0]), _nsmtabcmp);
578		if (mtab != NULL) {
579			*cb_data = mtab->mdata;
580			return (mtab->method);
581		}
582	}
583
584	*cb_data = NULL;
585	return (NULL);
586}
587
588int
589/*ARGSUSED*/
590nsdispatch(void *retval, const ns_dtab disp_tab[], const char *database,
591	    const char *method, const ns_src defaults[], ...)
592{
593	static int	 _nsdispatching;
594#ifdef _REENTRANT
595	struct _ns_drec	 drec, *ldrec;
596#endif
597	va_list		 ap;
598	int		 i, result;
599	ns_dbt		 key;
600	const ns_dbt	*dbt;
601	const ns_src	*srclist;
602	int		 srclistsize;
603	nss_method	 cb;
604	void		*cb_data;
605
606	/* retval may be NULL */
607	/* disp_tab may be NULL */
608	_DIAGASSERT(database != NULL);
609	_DIAGASSERT(method != NULL);
610	_DIAGASSERT(defaults != NULL);
611	if (database == NULL || method == NULL || defaults == NULL)
612		return (NS_UNAVAIL);
613
614	/*
615	 * In both the threaded and non-threaded cases, avoid reloading
616	 * the configuration if the current thread is already running
617	 * nsdispatch() (i.e. recursive call).
618	 *
619	 * In the non-threaded case, this avoids changing the data structures
620	 * while we're using them.
621	 *
622	 * In the threaded case, this avoids trying to take a write lock
623	 * while the current thread holds a read lock (which would result
624	 * in deadlock).
625	 */
626#ifdef _REENTRANT
627	if (__isthreaded) {
628		drec.thr = thr_self();
629		mutex_lock(&_ns_drec_lock);
630		LIST_FOREACH(ldrec, &_ns_drec, list) {
631			if (ldrec->thr == drec.thr)
632				break;
633		}
634		LIST_INSERT_HEAD(&_ns_drec, &drec, list);
635		mutex_unlock(&_ns_drec_lock);
636		if (ldrec == NULL && _nsconfigure()) {
637			mutex_lock(&_ns_drec_lock);
638			LIST_REMOVE(&drec, list);
639			mutex_unlock(&_ns_drec_lock);
640			return (NS_UNAVAIL);
641		}
642	} else
643#endif /* _REENTRANT */
644	if (_nsdispatching++ == 0 && _nsconfigure()) {
645		_nsdispatching--;
646		return (NS_UNAVAIL);
647	}
648
649	rwlock_rdlock(&_nslock);
650
651	key.name = database;
652	dbt = bsearch(&key, _nsmap, _nsmapsize, sizeof(*_nsmap), _nsdbtcmp);
653	if (dbt != NULL) {
654		srclist = dbt->srclist;
655		srclistsize = dbt->srclistsize;
656	} else {
657		srclist = defaults;
658		srclistsize = 0;
659		while (srclist[srclistsize].name != NULL)
660			srclistsize++;
661	}
662	result = 0;
663
664	for (i = 0; i < srclistsize; i++) {
665		cb = _nsmethod(srclist[i].name, database, method,
666		    disp_tab, &cb_data);
667		result = 0;
668		if (cb != NULL) {
669			va_start(ap, defaults);
670			result = (*cb)(retval, cb_data, ap);
671			va_end(ap);
672			if (defaults[0].flags & NS_FORCEALL)
673				continue;
674			if (result & srclist[i].flags)
675				break;
676		}
677	}
678	result &= NS_STATUSMASK;	/* clear private flags in result */
679
680	rwlock_unlock(&_nslock);
681
682#ifdef _REENTRANT
683	if (__isthreaded) {
684		mutex_lock(&_ns_drec_lock);
685		LIST_REMOVE(&drec, list);
686		mutex_unlock(&_ns_drec_lock);
687	} else
688#endif /* _REENTRANT */
689		_nsdispatching--;
690
691	return (result ? result : NS_NOTFOUND);
692}
693