lib/libc/net/nsdispatch.c

   1 /*      $NetBSD: nsdispatch.c,v 1.37 2012/03/13 21:13:42 christos 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.37 2012/03/13 21:13:42 christos 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
  92 extern  FILE    *_nsyyin;
  93 extern  int      _nsyyparse(void);
  94
  95
  96 #ifdef __weak_alias
  97 __weak_alias(nsdispatch,_nsdispatch)
  98 #endif
  99
 100
 101 /*
 102  * default sourcelist: `files'
 103  */
 104 const ns_src __nsdefaultsrc[] = {
 105         { NSSRC_FILES,  NS_SUCCESS },
 106         { 0, 0 },
 107 };
 108
 109 const ns_src __nsdefaultcompat[] = {
 110         { NSSRC_COMPAT, NS_SUCCESS },
 111         { 0, 0 }
 112 };
 113
 114 const ns_src __nsdefaultcompat_forceall[] = {
 115         { NSSRC_COMPAT, NS_SUCCESS | NS_FORCEALL },
 116         { 0, 0 }
 117 };
 118
 119 const ns_src __nsdefaultfiles[] = {
 120         { NSSRC_FILES,  NS_SUCCESS },
 121         { 0, 0 },
 122 };
 123
 124 const ns_src __nsdefaultfiles_forceall[] = {
 125         { NSSRC_FILES,  NS_SUCCESS | NS_FORCEALL },
 126         { 0, 0 },
 127 };
 128
 129 const ns_src __nsdefaultnis[] = {
 130         { NSSRC_NIS,    NS_SUCCESS },
 131         { 0, 0 }
 132 };
 133
 134 const ns_src __nsdefaultnis_forceall[] = {
 135         { NSSRC_NIS,    NS_SUCCESS | NS_FORCEALL },
 136         { 0, 0 }
 137 };
 138
 139
 140 /* Database, source mappings. */
 141 static  u_int                    _nsmapsize;
 142 static  ns_dbt                  *_nsmap;
 143
 144 /* Nsswitch modules. */
 145 static  u_int                    _nsmodsize;
 146 static  ns_mod                  *_nsmod;
 147
 148 /* Placeholder for built-in modules' dlopen() handles. */
 149 static  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  */
 156 static  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  */
 163 struct _ns_drec {
 164         LIST_ENTRY(_ns_drec)    list;
 165         thr_t                   thr;
 166 };
 167 static LIST_HEAD(, _ns_drec) _ns_drec = LIST_HEAD_INITIALIZER(&_ns_drec);
 168 static 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  */
 194 typedef void    (*_nsvect_free_elem)(void *);
 195
 196 static 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
 212 static 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
 222 static 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)                                        \
 238 do {                                                                    \
 239         _nsvect_free((v), (c), (s), (f));                               \
 240         (v) = NULL;                                                     \
 241 } while (/*CONSTCOND*/0)
 242
 243 static 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
 251 static 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
 259 static 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
 273 static 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  */
 293 static 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
 368 static void
 369 _nsloadbuiltin(void)
 370 {
 371
 372         /* Do nothing, for now. */
 373 }
 374
 375 int
 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
 400 void
 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
 429 static 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
 442 static 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
 451 int
 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  */
 484 static 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, "r");
 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
 553 static 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
 588 int
 589 /*ARGSUSED*/
 590 nsdispatch(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 }