getusershell.c revision 1.27
1 /* $NetBSD: getusershell.c,v 1.27 2008/04/28 20:22:59 martin Exp $ */ 2 3 /*- 4 * Copyright (c) 1999, 2005 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 /* 33 * Copyright (c) 1985, 1993 34 * The Regents of the University of California. All rights reserved. 35 * 36 * Redistribution and use in source and binary forms, with or without 37 * modification, are permitted provided that the following conditions 38 * are met: 39 * 1. Redistributions of source code must retain the above copyright 40 * notice, this list of conditions and the following disclaimer. 41 * 2. Redistributions in binary form must reproduce the above copyright 42 * notice, this list of conditions and the following disclaimer in the 43 * documentation and/or other materials provided with the distribution. 44 * 3. Neither the name of the University nor the names of its contributors 45 * may be used to endorse or promote products derived from this software 46 * without specific prior written permission. 47 * 48 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 49 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 51 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 54 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 55 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 58 * SUCH DAMAGE. 59 */ 60 61 #include <sys/cdefs.h> 62 #if defined(LIBC_SCCS) && !defined(lint) 63 #if 0 64 static char sccsid[] = "@(#)getusershell.c 8.1 (Berkeley) 6/4/93"; 65 #else 66 __RCSID("$NetBSD: getusershell.c,v 1.27 2008/04/28 20:22:59 martin Exp $"); 67 #endif 68 #endif /* LIBC_SCCS and not lint */ 69 70 #include "namespace.h" 71 #include "reentrant.h" 72 73 #include <sys/param.h> 74 #include <sys/file.h> 75 76 #include <assert.h> 77 #include <ctype.h> 78 #include <errno.h> 79 #include <nsswitch.h> 80 #include <paths.h> 81 #include <stdarg.h> 82 #include <stdio.h> 83 #include <stdlib.h> 84 #include <string.h> 85 #include <unistd.h> 86 87 #ifdef HESIOD 88 #include <hesiod.h> 89 #endif 90 #ifdef YP 91 #include <rpc/rpc.h> 92 #include <rpcsvc/ypclnt.h> 93 #include <rpcsvc/yp_prot.h> 94 #endif 95 96 #ifdef __weak_alias 97 __weak_alias(endusershell,_endusershell) 98 __weak_alias(getusershell,_getusershell) 99 __weak_alias(setusershell,_setusershell) 100 #endif 101 102 /* 103 * Local shells should NOT be added here. 104 * They should be added in /etc/shells. 105 */ 106 static const char *const okshells[] = { _PATH_BSHELL, _PATH_CSHELL, NULL }; 107 108 #ifdef _REENTRANT 109 static mutex_t __shellmutex = MUTEX_INITIALIZER; 110 #endif 111 112 static char curshell[MAXPATHLEN + 2]; 113 114 static const char *const *curokshell = okshells; 115 static int shellsfound = 0; 116 117 /* 118 * files methods 119 */ 120 121 /* state shared between files methods */ 122 struct files_state { 123 FILE *fp; 124 }; 125 126 static struct files_state _files_state; 127 128 129 static int 130 _files_start(struct files_state *state) 131 { 132 133 _DIAGASSERT(state != NULL); 134 135 if (state->fp == NULL) { 136 state->fp = fopen(_PATH_SHELLS, "r"); 137 if (state->fp == NULL) 138 return NS_UNAVAIL; 139 } else { 140 rewind(state->fp); 141 } 142 return NS_SUCCESS; 143 } 144 145 static int 146 _files_end(struct files_state *state) 147 { 148 149 _DIAGASSERT(state != NULL); 150 151 if (state->fp) { 152 (void) fclose(state->fp); 153 state->fp = NULL; 154 } 155 return NS_SUCCESS; 156 } 157 158 /*ARGSUSED*/ 159 static int 160 _files_setusershell(void *nsrv, void *nscb, va_list ap) 161 { 162 163 return _files_start(&_files_state); 164 } 165 166 /*ARGSUSED*/ 167 static int 168 _files_endusershell(void *nsrv, void *nscb, va_list ap) 169 { 170 171 return _files_end(&_files_state); 172 } 173 174 /*ARGSUSED*/ 175 static int 176 _files_getusershell(void *nsrv, void *nscb, va_list ap) 177 { 178 char **retval = va_arg(ap, char **); 179 180 char *sp, *cp; 181 int rv; 182 183 _DIAGASSERT(retval != NULL); 184 185 *retval = NULL; 186 if (_files_state.fp == NULL) { /* only start if file not open yet */ 187 rv = _files_start(&_files_state); 188 if (rv != NS_SUCCESS) 189 return rv; 190 } 191 192 while (fgets(curshell, sizeof(curshell) - 1, _files_state.fp) != NULL) { 193 sp = cp = curshell; 194 while (*cp != '#' && *cp != '/' && *cp != '\0') 195 cp++; 196 if (*cp == '#' || *cp == '\0') 197 continue; 198 sp = cp; 199 while (!isspace((unsigned char) *cp) && *cp != '#' 200 && *cp != '\0') 201 cp++; 202 *cp++ = '\0'; 203 *retval = sp; 204 return NS_SUCCESS; 205 } 206 207 return NS_NOTFOUND; 208 } 209 210 211 #ifdef HESIOD 212 /* 213 * dns methods 214 */ 215 216 /* state shared between dns methods */ 217 struct dns_state { 218 void *context; /* Hesiod context */ 219 int num; /* shell index, -1 if no more */ 220 }; 221 222 static struct dns_state _dns_state; 223 224 static int 225 _dns_start(struct dns_state *state) 226 { 227 228 _DIAGASSERT(state != NULL); 229 230 state->num = 0; 231 if (state->context == NULL) { /* setup Hesiod */ 232 if (hesiod_init(&state->context) == -1) 233 return NS_UNAVAIL; 234 } 235 236 return NS_SUCCESS; 237 } 238 239 static int 240 _dns_end(struct dns_state *state) 241 { 242 243 _DIAGASSERT(state != NULL); 244 245 state->num = 0; 246 if (state->context) { 247 hesiod_end(state->context); 248 state->context = NULL; 249 } 250 return NS_SUCCESS; 251 } 252 253 /*ARGSUSED*/ 254 static int 255 _dns_setusershell(void *nsrv, void *nscb, va_list ap) 256 { 257 258 return _dns_start(&_dns_state); 259 } 260 261 /*ARGSUSED*/ 262 static int 263 _dns_endusershell(void *nsrv, void *nscb, va_list ap) 264 { 265 266 return _dns_end(&_dns_state); 267 } 268 269 /*ARGSUSED*/ 270 static int 271 _dns_getusershell(void *nsrv, void *nscb, va_list ap) 272 { 273 char **retval = va_arg(ap, char **); 274 275 char shellname[] = "shells-NNNNNNNNNN"; 276 char **hp, *ep; 277 int rv; 278 279 _DIAGASSERT(retval != NULL); 280 281 *retval = NULL; 282 283 if (_dns_state.num == -1) /* exhausted search */ 284 return NS_NOTFOUND; 285 286 if (_dns_state.context == NULL) { 287 /* only start if Hesiod not setup */ 288 rv = _dns_start(&_dns_state); 289 if (rv != NS_SUCCESS) 290 return rv; 291 } 292 293 hp = NULL; 294 rv = NS_NOTFOUND; 295 296 /* find shells-NNN */ 297 snprintf(shellname, sizeof(shellname), "shells-%d", _dns_state.num); 298 _dns_state.num++; 299 300 hp = hesiod_resolve(_dns_state.context, shellname, "shells"); 301 if (hp == NULL) { 302 if (errno == ENOENT) 303 rv = NS_NOTFOUND; 304 else 305 rv = NS_UNAVAIL; 306 } else { 307 if ((ep = strchr(hp[0], '\n')) != NULL) 308 *ep = '\0'; /* clear trailing \n */ 309 /* only use first result */ 310 strlcpy(curshell, hp[0], sizeof(curshell)); 311 *retval = curshell; 312 rv = NS_SUCCESS; 313 } 314 315 if (hp) 316 hesiod_free_list(_dns_state.context, hp); 317 if (rv != NS_SUCCESS) 318 _dns_state.num = -1; /* any failure halts search */ 319 return rv; 320 } 321 322 #endif /* HESIOD */ 323 324 325 #ifdef YP 326 /* 327 * nis methods 328 */ 329 /* state shared between nis methods */ 330 struct nis_state { 331 char *domain; /* NIS domain */ 332 int done; /* non-zero if search exhausted */ 333 char *current; /* current first/next match */ 334 int currentlen; /* length of _nis_current */ 335 }; 336 337 static struct nis_state _nis_state; 338 339 static int 340 _nis_start(struct nis_state *state) 341 { 342 343 _DIAGASSERT(state != NULL); 344 345 state->done = 0; 346 if (state->current) { 347 free(state->current); 348 state->current = NULL; 349 } 350 if (state->domain == NULL) { /* setup NIS */ 351 switch (yp_get_default_domain(&state->domain)) { 352 case 0: 353 break; 354 case YPERR_RESRC: 355 return NS_TRYAGAIN; 356 default: 357 return NS_UNAVAIL; 358 } 359 } 360 return NS_SUCCESS; 361 } 362 363 static int 364 _nis_end(struct nis_state *state) 365 { 366 367 _DIAGASSERT(state != NULL); 368 369 if (state->domain) 370 state->domain = NULL; 371 state->done = 0; 372 if (state->current) 373 free(state->current); 374 state->current = NULL; 375 return NS_SUCCESS; 376 } 377 378 /*ARGSUSED*/ 379 static int 380 _nis_setusershell(void *nsrv, void *nscb, va_list ap) 381 { 382 383 return _nis_start(&_nis_state); 384 } 385 386 /*ARGSUSED*/ 387 static int 388 _nis_endusershell(void *nsrv, void *nscb, va_list ap) 389 { 390 391 return _nis_end(&_nis_state); 392 } 393 394 /*ARGSUSED*/ 395 static int 396 _nis_getusershell(void *nsrv, void *nscb, va_list ap) 397 { 398 char **retval = va_arg(ap, char **); 399 400 char *key, *data; 401 int keylen, datalen, rv, nisr; 402 403 _DIAGASSERT(retval != NULL); 404 405 *retval = NULL; 406 407 if (_nis_state.done) /* exhausted search */ 408 return NS_NOTFOUND; 409 if (_nis_state.domain == NULL) { 410 /* only start if NIS not setup */ 411 rv = _nis_start(&_nis_state); 412 if (rv != NS_SUCCESS) 413 return rv; 414 } 415 416 key = NULL; 417 data = NULL; 418 rv = NS_NOTFOUND; 419 420 if (_nis_state.current) { /* already searching */ 421 nisr = yp_next(_nis_state.domain, "shells", 422 _nis_state.current, _nis_state.currentlen, 423 &key, &keylen, &data, &datalen); 424 free(_nis_state.current); 425 _nis_state.current = NULL; 426 switch (nisr) { 427 case 0: 428 _nis_state.current = key; 429 _nis_state.currentlen = keylen; 430 key = NULL; 431 break; 432 case YPERR_NOMORE: 433 rv = NS_NOTFOUND; 434 goto nisent_out; 435 default: 436 rv = NS_UNAVAIL; 437 goto nisent_out; 438 } 439 } else { /* new search */ 440 if (yp_first(_nis_state.domain, "shells", 441 &_nis_state.current, &_nis_state.currentlen, 442 &data, &datalen)) { 443 rv = NS_UNAVAIL; 444 goto nisent_out; 445 } 446 } 447 448 data[datalen] = '\0'; /* clear trailing \n */ 449 strlcpy(curshell, data, sizeof(curshell)); 450 *retval = curshell; 451 rv = NS_SUCCESS; 452 453 nisent_out: 454 if (key) 455 free(key); 456 if (data) 457 free(data); 458 if (rv != NS_SUCCESS) /* any failure halts search */ 459 _nis_state.done = 1; 460 return rv; 461 } 462 463 #endif /* YP */ 464 465 466 /* 467 * public functions 468 */ 469 470 void 471 endusershell(void) 472 { 473 static const ns_dtab dtab[] = { 474 NS_FILES_CB(_files_endusershell, NULL) 475 NS_DNS_CB(_dns_endusershell, NULL) 476 NS_NIS_CB(_nis_endusershell, NULL) 477 NS_NULL_CB 478 }; 479 480 mutex_lock(&__shellmutex); 481 482 curokshell = okshells; /* reset okshells fallback state */ 483 shellsfound = 0; 484 485 /* force all endusershell() methods */ 486 (void) nsdispatch(NULL, dtab, NSDB_SHELLS, "endusershell", 487 __nsdefaultfiles_forceall); 488 mutex_unlock(&__shellmutex); 489 } 490 491 __aconst char * 492 getusershell(void) 493 { 494 int rv; 495 __aconst char *retval; 496 497 static const ns_dtab dtab[] = { 498 NS_FILES_CB(_files_getusershell, NULL) 499 NS_DNS_CB(_dns_getusershell, NULL) 500 NS_NIS_CB(_nis_getusershell, NULL) 501 NS_NULL_CB 502 }; 503 504 mutex_lock(&__shellmutex); 505 506 retval = NULL; 507 do { 508 rv = nsdispatch(NULL, dtab, NSDB_SHELLS, "getusershell", 509 __nsdefaultsrc, &retval); 510 /* loop until failure or non-blank result */ 511 } while (rv == NS_SUCCESS && retval[0] == '\0'); 512 513 if (rv == NS_SUCCESS) { 514 shellsfound++; 515 } else if (shellsfound == 0) { /* no shells; fall back to okshells */ 516 if (curokshell != NULL) { 517 retval = __UNCONST(*curokshell); 518 curokshell++; 519 rv = NS_SUCCESS; 520 } 521 } 522 523 mutex_unlock(&__shellmutex); 524 return (rv == NS_SUCCESS) ? retval : NULL; 525 } 526 527 void 528 setusershell(void) 529 { 530 static const ns_dtab dtab[] = { 531 NS_FILES_CB(_files_setusershell, NULL) 532 NS_DNS_CB(_dns_setusershell, NULL) 533 NS_NIS_CB(_nis_setusershell, NULL) 534 NS_NULL_CB 535 }; 536 537 mutex_lock(&__shellmutex); 538 539 curokshell = okshells; /* reset okshells fallback state */ 540 shellsfound = 0; 541 542 /* force all setusershell() methods */ 543 (void) nsdispatch(NULL, dtab, NSDB_SHELLS, "setusershell", 544 __nsdefaultfiles_forceall); 545 mutex_unlock(&__shellmutex); 546 } 547
Indexes created Sun Sep 21 20:09:37 GMT 2025