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 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 (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, "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 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 } 693
Indexes created Sat Sep 20 22:09:52 GMT 2025