xref: /minix/usr.bin/getent/getent.c (revision 90b80121) 
1 /*	$NetBSD: getent.c,v 1.19 2012/03/15 02:02:23 joerg Exp $	*/
2 
3 /*-
4  * Copyright (c) 2004-2006 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 #include <sys/cdefs.h>
33 #ifndef lint
34 __RCSID("$NetBSD: getent.c,v 1.19 2012/03/15 02:02:23 joerg Exp $");
35 #endif /* not lint */
36 
37 #include <sys/socket.h>
38 
39 #include <assert.h>
40 #include <ctype.h>
41 #include <errno.h>
42 #include <grp.h>
43 #include <limits.h>
44 #include <netdb.h>
45 #include <netgroup.h>
46 #include <pwd.h>
47 #include <stdio.h>
48 #include <stdarg.h>
49 #include <stdbool.h>
50 #include <stdlib.h>
51 #include <string.h>
52 #include <unistd.h>
53 #include <paths.h>
54 #include <err.h>
55 
56 #include <arpa/inet.h>
57 #include <arpa/nameser.h>
58 
59 #include <net/if.h>
60 #include <net/if_ether.h>
61 
62 #include <netinet/in.h>		/* for INET6_ADDRSTRLEN */
63 
64 #if !defined(__minix)
65 #include <rpc/rpcent.h>
66 #endif /* !defined(__minix) */
67 
68 #include <disktab.h>
69 
70 static int	usage(void) __attribute__((__noreturn__));
71 static int	parsenum(const char *, unsigned long *);
72 static int	disktab(int, char *[]);
73 static int	gettytab(int, char *[]);
74 static int	ethers(int, char *[]);
75 static int	group(int, char *[]);
76 static int	hosts(int, char *[]);
77 static int	netgroup(int, char *[]);
78 static int	networks(int, char *[]);
79 static int	passwd(int, char *[]);
80 static int	printcap(int, char *[]);
81 static int	protocols(int, char *[]);
82 #if !defined(__minix)
83 static int	rpc(int, char *[]);
84 #endif /* !defined(__minix) */
85 static int	services(int, char *[]);
86 static int	shells(int, char *[]);
87 
88 enum {
89 	RV_OK		= 0,
90 	RV_USAGE	= 1,
91 	RV_NOTFOUND	= 2,
92 	RV_NOENUM	= 3
93 };
94 
95 static struct getentdb {
96 	const char	*name;
97 	int		(*callback)(int, char *[]);
98 } databases[] = {
99 	{	"disktab",	disktab,	},
100 	{	"ethers",	ethers,		},
101 	{	"gettytab",	gettytab,	},
102 	{	"group",	group,		},
103 	{	"hosts",	hosts,		},
104 	{	"netgroup",	netgroup,	},
105 	{	"networks",	networks,	},
106 	{	"passwd",	passwd,		},
107 	{	"printcap",	printcap,	},
108 	{	"protocols",	protocols,	},
109 #if !defined(__minix)
110 	{	"rpc",		rpc,		},
111 #endif /* !defined(__minix) */
112 	{	"services",	services,	},
113 	{	"shells",	shells,		},
114 
115 	{	NULL,		NULL,		},
116 };
117 
118 
119 int
120 main(int argc, char *argv[])
121 {
122 	struct getentdb	*curdb;
123 
124 	setprogname(argv[0]);
125 
126 	if (argc < 2)
127 		usage();
128 	for (curdb = databases; curdb->name != NULL; curdb++)
129 		if (strcmp(curdb->name, argv[1]) == 0)
130 			return (*curdb->callback)(argc, argv);
131 
132 	warn("Unknown database `%s'", argv[1]);
133 	usage();
134 	/* NOTREACHED */
135 }
136 
137 static int
138 usage(void)
139 {
140 	struct getentdb	*curdb;
141 	size_t i;
142 
143 	(void)fprintf(stderr, "Usage: %s database [key ...]\n",
144 	    getprogname());
145 	(void)fprintf(stderr, "\tdatabase may be one of:");
146 	for (i = 0, curdb = databases; curdb->name != NULL; curdb++, i++) {
147 		if (i % 7 == 0)
148 			(void)fputs("\n\t\t", stderr);
149 		(void)fprintf(stderr, "%s%s", i % 7 == 0 ? "" : " ",
150 		    curdb->name);
151 	}
152 	(void)fprintf(stderr, "\n");
153 	exit(RV_USAGE);
154 	/* NOTREACHED */
155 }
156 
157 static int
158 parsenum(const char *word, unsigned long *result)
159 {
160 	unsigned long	num;
161 	char		*ep;
162 
163 	assert(word != NULL);
164 	assert(result != NULL);
165 
166 	if (!isdigit((unsigned char)word[0]))
167 		return 0;
168 	errno = 0;
169 	num = strtoul(word, &ep, 10);
170 	if (num == ULONG_MAX && errno == ERANGE)
171 		return 0;
172 	if (*ep != '\0')
173 		return 0;
174 	*result = num;
175 	return 1;
176 }
177 
178 /*
179  * printfmtstrings --
180  *	vprintf(format, ...),
181  *	then the aliases (beginning with prefix, separated by sep),
182  *	then a newline
183  */
184 static __printflike(4, 5) void
185 printfmtstrings(char *strings[], const char *prefix, const char *sep,
186     const char *fmt, ...)
187 {
188 	va_list		ap;
189 	const char	*curpref;
190 	size_t		i;
191 
192 	va_start(ap, fmt);
193 	(void)vprintf(fmt, ap);
194 	va_end(ap);
195 
196 	curpref = prefix;
197 	for (i = 0; strings[i] != NULL; i++) {
198 		(void)printf("%s%s", curpref, strings[i]);
199 		curpref = sep;
200 	}
201 	(void)printf("\n");
202 }
203 
204 
205 		/*
206 		 * ethers
207 		 */
208 
209 static int
210 ethers(int argc, char *argv[])
211 {
212 	char		hostname[MAXHOSTNAMELEN + 1], *hp;
213 	struct ether_addr ea, *eap;
214 	int		i, rv;
215 
216 	assert(argc > 1);
217 	assert(argv != NULL);
218 
219 #define ETHERSPRINT	(void)printf("%-17s  %s\n", ether_ntoa(eap), hp)
220 
221 	rv = RV_OK;
222 	if (argc == 2) {
223 		warnx("Enumeration not supported on ethers");
224 		rv = RV_NOENUM;
225 	} else {
226 		for (i = 2; i < argc; i++) {
227 			if ((eap = ether_aton(argv[i])) == NULL) {
228 				eap = &ea;
229 				hp = argv[i];
230 				if (ether_hostton(hp, eap) != 0) {
231 					rv = RV_NOTFOUND;
232 					break;
233 				}
234 			} else {
235 				hp = hostname;
236 				if (ether_ntohost(hp, eap) != 0) {
237 					rv = RV_NOTFOUND;
238 					break;
239 				}
240 			}
241 			ETHERSPRINT;
242 		}
243 	}
244 	return rv;
245 }
246 
247 		/*
248 		 * group
249 		 */
250 
251 static int
252 group(int argc, char *argv[])
253 {
254 	struct group	*gr;
255 	unsigned long	id;
256 	int		i, rv;
257 
258 	assert(argc > 1);
259 	assert(argv != NULL);
260 
261 #define GROUPPRINT	printfmtstrings(gr->gr_mem, ":", ",", "%s:%s:%u", \
262 			    gr->gr_name, gr->gr_passwd, gr->gr_gid)
263 
264 	(void)setgroupent(1);
265 	rv = RV_OK;
266 	if (argc == 2) {
267 		while ((gr = getgrent()) != NULL)
268 			GROUPPRINT;
269 	} else {
270 		for (i = 2; i < argc; i++) {
271 			if (parsenum(argv[i], &id))
272 				gr = getgrgid((gid_t)id);
273 			else
274 				gr = getgrnam(argv[i]);
275 			if (gr != NULL)
276 				GROUPPRINT;
277 			else {
278 				rv = RV_NOTFOUND;
279 				break;
280 			}
281 		}
282 	}
283 	endgrent();
284 	return rv;
285 }
286 
287 
288 		/*
289 		 * hosts
290 		 */
291 
292 static void
293 hostsprint(const struct hostent *he)
294 {
295 	char	buf[INET6_ADDRSTRLEN];
296 
297 	assert(he != NULL);
298 	if (inet_ntop(he->h_addrtype, he->h_addr, buf, sizeof(buf)) == NULL)
299 		(void)strlcpy(buf, "# unknown", sizeof(buf));
300 	printfmtstrings(he->h_aliases, "  ", " ", "%-16s  %s", buf, he->h_name);
301 }
302 
303 static int
304 hosts(int argc, char *argv[])
305 {
306 	struct hostent	*he;
307 	char		addr[IN6ADDRSZ];
308 	int		i, rv;
309 
310 	assert(argc > 1);
311 	assert(argv != NULL);
312 
313 	sethostent(1);
314 	rv = RV_OK;
315 	if (argc == 2) {
316 		while ((he = gethostent()) != NULL)
317 			hostsprint(he);
318 	} else {
319 		for (i = 2; i < argc; i++) {
320 			if (inet_pton(AF_INET6, argv[i], (void *)addr) > 0)
321 				he = gethostbyaddr(addr, IN6ADDRSZ, AF_INET6);
322 			else if (inet_pton(AF_INET, argv[i], (void *)addr) > 0)
323 				he = gethostbyaddr(addr, INADDRSZ, AF_INET);
324 			else
325 				he = gethostbyname(argv[i]);
326 			if (he != NULL)
327 				hostsprint(he);
328 			else {
329 				rv = RV_NOTFOUND;
330 				break;
331 			}
332 		}
333 	}
334 	endhostent();
335 	return rv;
336 }
337 
338 		/*
339 		 * netgroup
340 		 */
341 static int
342 netgroup(int argc, char *argv[])
343 {
344 	int		rv, i;
345 	bool		first;
346 	const char	*host, *user, *domain;
347 
348 	assert(argc > 1);
349 	assert(argv != NULL);
350 
351 #define NETGROUPPRINT(s)	(((s) != NULL) ? (s) : "")
352 
353 	rv = RV_OK;
354 	if (argc == 2) {
355 		warnx("Enumeration not supported on netgroup");
356 		rv = RV_NOENUM;
357 	} else {
358 		for (i = 2; i < argc; i++) {
359 			setnetgrent(argv[i]);
360 			first = true;
361 			while (getnetgrent(&host, &user, &domain) != 0) {
362 				if (first) {
363 					first = false;
364 					(void)fputs(argv[i], stdout);
365 				}
366 				(void)printf(" (%s,%s,%s)",
367 				    NETGROUPPRINT(host),
368 				    NETGROUPPRINT(user),
369 				    NETGROUPPRINT(domain));
370 			}
371 			if (!first)
372 				(void)putchar('\n');
373 			endnetgrent();
374 		}
375 	}
376 
377 	return rv;
378 }
379 
380 		/*
381 		 * networks
382 		 */
383 
384 static void
385 networksprint(const struct netent *ne)
386 {
387 	char		buf[INET6_ADDRSTRLEN];
388 	struct	in_addr	ianet;
389 
390 	assert(ne != NULL);
391 	ianet = inet_makeaddr(ne->n_net, 0);
392 	if (inet_ntop(ne->n_addrtype, &ianet, buf, sizeof(buf)) == NULL)
393 		(void)strlcpy(buf, "# unknown", sizeof(buf));
394 	printfmtstrings(ne->n_aliases, "  ", " ", "%-16s  %s", ne->n_name, buf);
395 }
396 
397 static int
398 networks(int argc, char *argv[])
399 {
400 	struct netent	*ne;
401 	in_addr_t	net;
402 	int		i, rv;
403 
404 	assert(argc > 1);
405 	assert(argv != NULL);
406 
407 	setnetent(1);
408 	rv = RV_OK;
409 	if (argc == 2) {
410 		while ((ne = getnetent()) != NULL)
411 			networksprint(ne);
412 	} else {
413 		for (i = 2; i < argc; i++) {
414 			net = inet_network(argv[i]);
415 			if (net != INADDR_NONE)
416 				ne = getnetbyaddr(net, AF_INET);
417 			else
418 				ne = getnetbyname(argv[i]);
419 			if (ne != NULL)
420 				networksprint(ne);
421 			else {
422 				rv = RV_NOTFOUND;
423 				break;
424 			}
425 		}
426 	}
427 	endnetent();
428 	return rv;
429 }
430 
431 
432 		/*
433 		 * passwd
434 		 */
435 
436 static int
437 passwd(int argc, char *argv[])
438 {
439 	struct passwd	*pw;
440 	unsigned long	id;
441 	int		i, rv;
442 
443 	assert(argc > 1);
444 	assert(argv != NULL);
445 
446 #define PASSWDPRINT	(void)printf("%s:%s:%u:%u:%s:%s:%s\n", \
447 			    pw->pw_name, pw->pw_passwd, pw->pw_uid, \
448 			    pw->pw_gid, pw->pw_gecos, pw->pw_dir, pw->pw_shell)
449 
450 	(void)setpassent(1);
451 	rv = RV_OK;
452 	if (argc == 2) {
453 		while ((pw = getpwent()) != NULL)
454 			PASSWDPRINT;
455 	} else {
456 		for (i = 2; i < argc; i++) {
457 			if (parsenum(argv[i], &id))
458 				pw = getpwuid((uid_t)id);
459 			else
460 				pw = getpwnam(argv[i]);
461 			if (pw != NULL)
462 				PASSWDPRINT;
463 			else {
464 				rv = RV_NOTFOUND;
465 				break;
466 			}
467 		}
468 	}
469 	endpwent();
470 	return rv;
471 }
472 
473 static char *
474 mygetent(const char * const * db_array, const char *name)
475 {
476 	char *buf = NULL;
477 	int error;
478 
479 	switch (error = cgetent(&buf, db_array, name)) {
480 	case -3:
481 		warnx("tc= loop in record `%s' in `%s'", name, db_array[0]);
482 		break;
483 	case -2:
484 		warn("system error fetching record `%s' in `%s'", name,
485 		    db_array[0]);
486 		break;
487 	case -1:
488 	case 0:
489 		break;
490 	case 1:
491 		warnx("tc= reference not found in record for `%s' in `%s'",
492 		    name, db_array[0]);
493 		break;
494 	default:
495 		warnx("unknown error %d in record `%s' in `%s'", error, name,
496 		    db_array[0]);
497 		break;
498 	}
499 	return buf;
500 }
501 
502 static char *
503 mygetone(const char * const * db_array, int first)
504 {
505 	char *buf = NULL;
506 	int error;
507 
508 	switch (error = (first ? cgetfirst : cgetnext)(&buf, db_array)) {
509 	case -2:
510 		warnx("tc= loop in `%s'", db_array[0]);
511 		break;
512 	case -1:
513 		warn("system error fetching record in `%s'", db_array[0]);
514 		break;
515 	case 0:
516 	case 1:
517 		break;
518 	case 2:
519 		warnx("tc= reference not found in `%s'", db_array[0]);
520 		break;
521 	default:
522 		warnx("unknown error %d in `%s'", error, db_array[0]);
523 		break;
524 	}
525 	return buf;
526 }
527 
528 static void
529 capprint(const char *cap)
530 {
531 	char *c = strchr(cap, ':');
532 	if (c)
533 		if (c == cap)
534 			(void)printf("true\n");
535 		else {
536 			int l = (int)(c - cap);
537 			(void)printf("%*.*s\n", l, l, cap);
538 		}
539 	else
540 		(void)printf("%s\n", cap);
541 }
542 
543 static void
544 prettyprint(char *b)
545 {
546 #define TERMWIDTH 65
547 	int did = 0;
548 	size_t len;
549 	char *s, c;
550 
551 	for (;;) {
552 		len = strlen(b);
553 		if (len <= TERMWIDTH) {
554 done:
555 			if (did)
556 				printf("\t:");
557 			printf("%s\n", b);
558 			return;
559 		}
560 		for (s = b + TERMWIDTH; s > b && *s != ':'; s--)
561 			continue;
562 		if (*s++ != ':')
563 			goto done;
564 		c = *s;
565 		*s = '\0';
566 		if (did)
567 			printf("\t:");
568 		did++;
569 		printf("%s\\\n", b);
570 		*s = c;
571 		b = s;
572 	}
573 }
574 
575 static void
576 handleone(const char * const *db_array, char *b, int recurse, int pretty,
577     int level)
578 {
579 	char *tc;
580 
581 	if (level && pretty)
582 		printf("\n");
583 	if (pretty)
584 		prettyprint(b);
585 	else
586 		printf("%s\n", b);
587 	if (!recurse || cgetstr(b, "tc", &tc) <= 0)
588 		return;
589 
590 	b = mygetent(db_array, tc);
591 	free(tc);
592 
593 	if (b == NULL)
594 		return;
595 
596 	handleone(db_array, b, recurse, pretty, ++level);
597 	free(b);
598 }
599 
600 static int
601 handlecap(const char *db, int argc, char *argv[])
602 {
603 	static const char sfx[] = "=#:";
604 	const char *db_array[] = { db, NULL };
605 	char	*b, *cap;
606 	int	i, rv, c;
607 	size_t	j;
608 	int	expand = 1, recurse = 0, pretty = 0;
609 
610 	assert(argc > 1);
611 	assert(argv != NULL);
612 
613 	argc--;
614 	argv++;
615 	while ((c = getopt(argc, argv, "pnr")) != -1)
616 		switch (c) {
617 		case 'n':
618 			expand = 0;
619 			break;
620 		case 'r':
621 			expand = 0;
622 			recurse = 1;
623 			break;
624 		case 'p':
625 			pretty = 1;
626 			break;
627 		default:
628 			usage();
629 			break;
630 		}
631 
632 	argc -= optind;
633 	argv += optind;
634 	csetexpandtc(expand);
635 	rv = RV_OK;
636 	if (argc == 0) {
637 		for (b = mygetone(db_array, 1); b; b = mygetone(db_array, 0)) {
638 			handleone(db_array, b, recurse, pretty, 0);
639 			free(b);
640 		}
641 	} else {
642 		if ((b = mygetent(db_array, argv[0])) == NULL)
643 			return RV_NOTFOUND;
644 		if (argc == 1)
645 			handleone(db_array, b, recurse, pretty, 0);
646 		else {
647 			for (i = 2; i < argc; i++) {
648 				for (j = 0; j < sizeof(sfx) - 1; j++) {
649 					cap = cgetcap(b, argv[i], sfx[j]);
650 					if (cap) {
651 						capprint(cap);
652 						break;
653 					}
654 				}
655 				if (j == sizeof(sfx) - 1)
656 					printf("false\n");
657 			}
658 		}
659 		free(b);
660 	}
661 	return rv;
662 }
663 
664 		/*
665 		 * gettytab
666 		 */
667 
668 static int
669 gettytab(int argc, char *argv[])
670 {
671 	return handlecap(_PATH_GETTYTAB, argc, argv);
672 }
673 
674 		/*
675 		 * printcap
676 		 */
677 
678 static int
679 printcap(int argc, char *argv[])
680 {
681 	return handlecap(_PATH_PRINTCAP, argc, argv);
682 }
683 
684 		/*
685 		 * disktab
686 		 */
687 
688 static int
689 disktab(int argc, char *argv[])
690 {
691 	return handlecap(_PATH_DISKTAB, argc, argv);
692 }
693 
694 		/*
695 		 * protocols
696 		 */
697 
698 static int
699 protocols(int argc, char *argv[])
700 {
701 	struct protoent	*pe;
702 	unsigned long	id;
703 	int		i, rv;
704 
705 	assert(argc > 1);
706 	assert(argv != NULL);
707 
708 #define PROTOCOLSPRINT	printfmtstrings(pe->p_aliases, "  ", " ", \
709 			    "%-16s  %5d", pe->p_name, pe->p_proto)
710 
711 	setprotoent(1);
712 	rv = RV_OK;
713 	if (argc == 2) {
714 		while ((pe = getprotoent()) != NULL)
715 			PROTOCOLSPRINT;
716 	} else {
717 		for (i = 2; i < argc; i++) {
718 			if (parsenum(argv[i], &id))
719 				pe = getprotobynumber((int)id);
720 			else
721 				pe = getprotobyname(argv[i]);
722 			if (pe != NULL)
723 				PROTOCOLSPRINT;
724 			else {
725 				rv = RV_NOTFOUND;
726 				break;
727 			}
728 		}
729 	}
730 	endprotoent();
731 	return rv;
732 }
733 
734 #if !defined(__minix)
735 		/*
736 		 * rpc
737 		 */
738 
739 static int
740 rpc(int argc, char *argv[])
741 {
742 	struct rpcent	*re;
743 	unsigned long	id;
744 	int		i, rv;
745 
746 	assert(argc > 1);
747 	assert(argv != NULL);
748 
749 #define RPCPRINT	printfmtstrings(re->r_aliases, "  ", " ", \
750 				"%-16s  %6d", \
751 				re->r_name, re->r_number)
752 
753 	setrpcent(1);
754 	rv = RV_OK;
755 	if (argc == 2) {
756 		while ((re = getrpcent()) != NULL)
757 			RPCPRINT;
758 	} else {
759 		for (i = 2; i < argc; i++) {
760 			if (parsenum(argv[i], &id))
761 				re = getrpcbynumber((int)id);
762 			else
763 				re = getrpcbyname(argv[i]);
764 			if (re != NULL)
765 				RPCPRINT;
766 			else {
767 				rv = RV_NOTFOUND;
768 				break;
769 			}
770 		}
771 	}
772 	endrpcent();
773 	return rv;
774 }
775 #endif /* !defined(__minix) */
776 
777 		/*
778 		 * services
779 		 */
780 
781 static int
782 services(int argc, char *argv[])
783 {
784 	struct servent	*se;
785 	unsigned long	id;
786 	char		*proto;
787 	int		i, rv;
788 
789 	assert(argc > 1);
790 	assert(argv != NULL);
791 
792 #define SERVICESPRINT	printfmtstrings(se->s_aliases, "  ", " ", \
793 			    "%-16s  %5d/%s", \
794 			    se->s_name, ntohs(se->s_port), se->s_proto)
795 
796 	setservent(1);
797 	rv = RV_OK;
798 	if (argc == 2) {
799 		while ((se = getservent()) != NULL)
800 			SERVICESPRINT;
801 	} else {
802 		for (i = 2; i < argc; i++) {
803 			proto = strchr(argv[i], '/');
804 			if (proto != NULL)
805 				*proto++ = '\0';
806 			if (parsenum(argv[i], &id))
807 				se = getservbyport(htons(id), proto);
808 			else
809 				se = getservbyname(argv[i], proto);
810 			if (se != NULL)
811 				SERVICESPRINT;
812 			else {
813 				rv = RV_NOTFOUND;
814 				break;
815 			}
816 		}
817 	}
818 	endservent();
819 	return rv;
820 }
821 
822 
823 		/*
824 		 * shells
825 		 */
826 
827 static int
828 shells(int argc, char *argv[])
829 {
830 	const char	*sh;
831 	int		i, rv;
832 
833 	assert(argc > 1);
834 	assert(argv != NULL);
835 
836 #define SHELLSPRINT	(void)printf("%s\n", sh)
837 
838 	setusershell();
839 	rv = RV_OK;
840 	if (argc == 2) {
841 		while ((sh = getusershell()) != NULL)
842 			SHELLSPRINT;
843 	} else {
844 		for (i = 2; i < argc; i++) {
845 			setusershell();
846 			while ((sh = getusershell()) != NULL) {
847 				if (strcmp(sh, argv[i]) == 0) {
848 					SHELLSPRINT;
849 					break;
850 				}
851 			}
852 			if (sh == NULL) {
853 				rv = RV_NOTFOUND;
854 				break;
855 			}
856 		}
857 	}
858 	endusershell();
859 	return rv;
860 }
861