xref: /freebsd/usr.bin/getent/getent.c (revision efe3b0de1438e7a8473d92f2be57072394559e3c) 
1 /*	$NetBSD: getent.c,v 1.7 2005/08/24 14:31:02 ginsbach Exp $	*/
2 
3 /*-
4  * Copyright (c) 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.
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 __FBSDID("$FreeBSD$");
34 
35 #include <sys/socket.h>
36 #include <sys/param.h>
37 #include <arpa/inet.h>
38 #include <arpa/nameser.h>
39 #include <net/if.h>
40 #include <netinet/if_ether.h>
41 #include <netinet/in.h>		/* for INET6_ADDRSTRLEN */
42 #include <rpc/rpcent.h>
43 
44 #include <assert.h>
45 #include <ctype.h>
46 #include <errno.h>
47 #include <grp.h>
48 #include <limits.h>
49 #include <netdb.h>
50 #include <pwd.h>
51 #include <stdarg.h>
52 #include <stdint.h>
53 #include <stdio.h>
54 #include <stdlib.h>
55 #include <string.h>
56 #include <unistd.h>
57 #include <utmpx.h>
58 
59 static int	usage(void);
60 static int	parsenum(const char *, unsigned long *);
61 static int	ethers(int, char *[]);
62 static int	group(int, char *[]);
63 static int	hosts(int, char *[]);
64 static int	netgroup(int, char *[]);
65 static int	networks(int, char *[]);
66 static int	passwd(int, char *[]);
67 static int	protocols(int, char *[]);
68 static int	rpc(int, char *[]);
69 static int	services(int, char *[]);
70 static int	shells(int, char *[]);
71 static int	utmpx(int, char *[]);
72 
73 enum {
74 	RV_OK		= 0,
75 	RV_USAGE	= 1,
76 	RV_NOTFOUND	= 2,
77 	RV_NOENUM	= 3
78 };
79 
80 static struct getentdb {
81 	const char	*name;
82 	int		(*callback)(int, char *[]);
83 } databases[] = {
84 	{	"ethers",	ethers,		},
85 	{	"group",	group,		},
86 	{	"hosts",	hosts,		},
87 	{	"netgroup",	netgroup,	},
88 	{	"networks",	networks,	},
89 	{	"passwd",	passwd,		},
90 	{	"protocols",	protocols,	},
91 	{	"rpc",		rpc,		},
92 	{	"services",	services,	},
93 	{	"shells",	shells,		},
94 	{	"utmpx",	utmpx,		},
95 
96 	{	NULL,		NULL,		},
97 };
98 
99 int
100 main(int argc, char *argv[])
101 {
102 	struct getentdb	*curdb;
103 
104 	setprogname(argv[0]);
105 
106 	if (argc < 2)
107 		usage();
108 	for (curdb = databases; curdb->name != NULL; curdb++) {
109 		if (strcmp(curdb->name, argv[1]) == 0) {
110 			exit(curdb->callback(argc, argv));
111 		}
112 	}
113 	fprintf(stderr, "Unknown database: %s\n", argv[1]);
114 	usage();
115 	/* NOTREACHED */
116 	return RV_USAGE;
117 }
118 
119 static int
120 usage(void)
121 {
122 	struct getentdb	*curdb;
123 
124 	fprintf(stderr, "Usage: %s database [key ...]\n",
125 	    getprogname());
126 	fprintf(stderr, "       database may be one of:\n\t");
127 	for (curdb = databases; curdb->name != NULL; curdb++) {
128 		fprintf(stderr, " %s", curdb->name);
129 	}
130 	fprintf(stderr, "\n");
131 	exit(RV_USAGE);
132 	/* NOTREACHED */
133 }
134 
135 static int
136 parsenum(const char *word, unsigned long *result)
137 {
138 	unsigned long	num;
139 	char		*ep;
140 
141 	assert(word != NULL);
142 	assert(result != NULL);
143 
144 	if (!isdigit((unsigned char)word[0]))
145 		return 0;
146 	errno = 0;
147 	num = strtoul(word, &ep, 10);
148 	if (num == ULONG_MAX && errno == ERANGE)
149 		return 0;
150 	if (*ep != '\0')
151 		return 0;
152 	*result = num;
153 	return 1;
154 }
155 
156 /*
157  * printfmtstrings --
158  *	vprintf(format, ...),
159  *	then the aliases (beginning with prefix, separated by sep),
160  *	then a newline
161  */
162 static void
163 printfmtstrings(char *strings[], const char *prefix, const char *sep,
164 	const char *fmt, ...)
165 {
166 	va_list		ap;
167 	const char	*curpref;
168 	int		i;
169 
170 	va_start(ap, fmt);
171 	vprintf(fmt, ap);
172 
173 	curpref = prefix;
174 	for (i = 0; strings[i] != NULL; i++) {
175 		printf("%s%s", curpref, strings[i]);
176 		curpref = sep;
177 	}
178 	printf("\n");
179 	va_end(ap);
180 }
181 
182 /*
183  * ethers
184  */
185 static int
186 ethers(int argc, char *argv[])
187 {
188 	char		hostname[MAXHOSTNAMELEN + 1], *hp;
189 	struct ether_addr ea, *eap;
190 	int		i, rv;
191 
192 	assert(argc > 1);
193 	assert(argv != NULL);
194 
195 #define ETHERSPRINT	printf("%-17s  %s\n", ether_ntoa(eap), hp)
196 
197 	rv = RV_OK;
198 	if (argc == 2) {
199 		fprintf(stderr, "Enumeration not supported on ethers\n");
200 		rv = RV_NOENUM;
201 	} else {
202 		for (i = 2; i < argc; i++) {
203 			if ((eap = ether_aton(argv[i])) == NULL) {
204 				eap = &ea;
205 				hp = argv[i];
206 				if (ether_hostton(hp, eap) != 0) {
207 					rv = RV_NOTFOUND;
208 					break;
209 				}
210 			} else {
211 				hp = hostname;
212 				if (ether_ntohost(hp, eap) != 0) {
213 					rv = RV_NOTFOUND;
214 					break;
215 				}
216 			}
217 			ETHERSPRINT;
218 		}
219 	}
220 	return rv;
221 }
222 
223 /*
224  * group
225  */
226 
227 static int
228 group(int argc, char *argv[])
229 {
230 	struct group	*gr;
231 	unsigned long	id;
232 	int		i, rv;
233 
234 	assert(argc > 1);
235 	assert(argv != NULL);
236 
237 #define GROUPPRINT	printfmtstrings(gr->gr_mem, ":", ",", "%s:%s:%u", \
238 			    gr->gr_name, gr->gr_passwd, gr->gr_gid)
239 
240 	setgroupent(1);
241 	rv = RV_OK;
242 	if (argc == 2) {
243 		while ((gr = getgrent()) != NULL)
244 			GROUPPRINT;
245 	} else {
246 		for (i = 2; i < argc; i++) {
247 			if (parsenum(argv[i], &id))
248 				gr = getgrgid((gid_t)id);
249 			else
250 				gr = getgrnam(argv[i]);
251 			if (gr != NULL)
252 				GROUPPRINT;
253 			else {
254 				rv = RV_NOTFOUND;
255 				break;
256 			}
257 		}
258 	}
259 	endgrent();
260 	return rv;
261 }
262 
263 
264 /*
265  * hosts
266  */
267 
268 static void
269 hostsprint(const struct hostent *he)
270 {
271 	char	buf[INET6_ADDRSTRLEN];
272 
273 	assert(he != NULL);
274 	if (inet_ntop(he->h_addrtype, he->h_addr, buf, sizeof(buf)) == NULL)
275 		strlcpy(buf, "# unknown", sizeof(buf));
276 	printfmtstrings(he->h_aliases, "  ", " ", "%-16s  %s", buf, he->h_name);
277 }
278 
279 static int
280 hosts(int argc, char *argv[])
281 {
282 	struct hostent	*he4, *he6;
283 	char		addr[IN6ADDRSZ];
284 	int		i, rv;
285 
286 	assert(argc > 1);
287 	assert(argv != NULL);
288 
289 	sethostent(1);
290 	he4 = he6 = NULL;
291 	rv = RV_OK;
292 	if (argc == 2) {
293 		while ((he4 = gethostent()) != NULL)
294 			hostsprint(he4);
295 	} else {
296 		for (i = 2; i < argc; i++) {
297 			if (inet_pton(AF_INET6, argv[i], (void *)addr) > 0) {
298 				he6 = gethostbyaddr(addr, IN6ADDRSZ, AF_INET6);
299 				if (he6 != NULL)
300 					hostsprint(he6);
301 			} else if (inet_pton(AF_INET, argv[i],
302 			    (void *)addr) > 0) {
303 				he4 = gethostbyaddr(addr, INADDRSZ, AF_INET);
304 				if (he4 != NULL)
305 					hostsprint(he4);
306 	       		} else {
307 				he6 = gethostbyname2(argv[i], AF_INET6);
308 				if (he6 != NULL)
309 					hostsprint(he6);
310 				he4 = gethostbyname(argv[i]);
311 				if (he4 != NULL)
312 					hostsprint(he4);
313 			}
314 			if ( he4 == NULL && he6 == NULL ) {
315 				rv = RV_NOTFOUND;
316 				break;
317 			}
318 		}
319 	}
320 	endhostent();
321 	return rv;
322 }
323 
324 /*
325  * networks
326  */
327 static void
328 networksprint(const struct netent *ne)
329 {
330 	char		buf[INET6_ADDRSTRLEN];
331 	struct	in_addr	ianet;
332 
333 	assert(ne != NULL);
334 	ianet = inet_makeaddr(ne->n_net, 0);
335 	if (inet_ntop(ne->n_addrtype, &ianet, buf, sizeof(buf)) == NULL)
336 		strlcpy(buf, "# unknown", sizeof(buf));
337 	printfmtstrings(ne->n_aliases, "  ", " ", "%-16s  %s", ne->n_name, buf);
338 }
339 
340 static int
341 networks(int argc, char *argv[])
342 {
343 	struct netent	*ne;
344 	in_addr_t	net;
345 	int		i, rv;
346 
347 	assert(argc > 1);
348 	assert(argv != NULL);
349 
350 	setnetent(1);
351 	rv = RV_OK;
352 	if (argc == 2) {
353 		while ((ne = getnetent()) != NULL)
354 			networksprint(ne);
355 	} else {
356 		for (i = 2; i < argc; i++) {
357 			net = inet_network(argv[i]);
358 			if (net != INADDR_NONE)
359 				ne = getnetbyaddr(net, AF_INET);
360 			else
361 				ne = getnetbyname(argv[i]);
362 			if (ne != NULL)
363 				networksprint(ne);
364 			else {
365 				rv = RV_NOTFOUND;
366 				break;
367 			}
368 		}
369 	}
370 	endnetent();
371 	return rv;
372 }
373 
374 /*
375  * passwd
376  */
377 static int
378 passwd(int argc, char *argv[])
379 {
380 	struct passwd	*pw;
381 	unsigned long	id;
382 	int		i, rv;
383 
384 	assert(argc > 1);
385 	assert(argv != NULL);
386 
387 #define PASSWDPRINT	printf("%s:%s:%u:%u:%s:%s:%s\n", \
388 			    pw->pw_name, pw->pw_passwd, pw->pw_uid, \
389 			    pw->pw_gid, pw->pw_gecos, pw->pw_dir, pw->pw_shell)
390 
391 	setpassent(1);
392 	rv = RV_OK;
393 	if (argc == 2) {
394 		while ((pw = getpwent()) != NULL)
395 			PASSWDPRINT;
396 	} else {
397 		for (i = 2; i < argc; i++) {
398 			if (parsenum(argv[i], &id))
399 				pw = getpwuid((uid_t)id);
400 			else
401 				pw = getpwnam(argv[i]);
402 			if (pw != NULL)
403 				PASSWDPRINT;
404 			else {
405 				rv = RV_NOTFOUND;
406 				break;
407 			}
408 		}
409 	}
410 	endpwent();
411 	return rv;
412 }
413 
414 /*
415  * protocols
416  */
417 static int
418 protocols(int argc, char *argv[])
419 {
420 	struct protoent	*pe;
421 	unsigned long	id;
422 	int		i, rv;
423 
424 	assert(argc > 1);
425 	assert(argv != NULL);
426 
427 #define PROTOCOLSPRINT	printfmtstrings(pe->p_aliases, "  ", " ", \
428 			    "%-16s  %5d", pe->p_name, pe->p_proto)
429 
430 	setprotoent(1);
431 	rv = RV_OK;
432 	if (argc == 2) {
433 		while ((pe = getprotoent()) != NULL)
434 			PROTOCOLSPRINT;
435 	} else {
436 		for (i = 2; i < argc; i++) {
437 			if (parsenum(argv[i], &id))
438 				pe = getprotobynumber((int)id);
439 			else
440 				pe = getprotobyname(argv[i]);
441 			if (pe != NULL)
442 				PROTOCOLSPRINT;
443 			else {
444 				rv = RV_NOTFOUND;
445 				break;
446 			}
447 		}
448 	}
449 	endprotoent();
450 	return rv;
451 }
452 
453 /*
454  * rpc
455  */
456 static int
457 rpc(int argc, char *argv[])
458 {
459 	struct rpcent	*re;
460 	unsigned long	id;
461 	int		i, rv;
462 
463 	assert(argc > 1);
464 	assert(argv != NULL);
465 
466 #define RPCPRINT	printfmtstrings(re->r_aliases, "  ", " ", \
467 				"%-16s  %6d", \
468 				re->r_name, re->r_number)
469 
470 	setrpcent(1);
471 	rv = RV_OK;
472 	if (argc == 2) {
473 		while ((re = getrpcent()) != NULL)
474 			RPCPRINT;
475 	} else {
476 		for (i = 2; i < argc; i++) {
477 			if (parsenum(argv[i], &id))
478 				re = getrpcbynumber((int)id);
479 			else
480 				re = getrpcbyname(argv[i]);
481 			if (re != NULL)
482 				RPCPRINT;
483 			else {
484 				rv = RV_NOTFOUND;
485 				break;
486 			}
487 		}
488 	}
489 	endrpcent();
490 	return rv;
491 }
492 
493 /*
494  * services
495  */
496 static int
497 services(int argc, char *argv[])
498 {
499 	struct servent	*se;
500 	unsigned long	id;
501 	char		*proto;
502 	int		i, rv;
503 
504 	assert(argc > 1);
505 	assert(argv != NULL);
506 
507 #define SERVICESPRINT	printfmtstrings(se->s_aliases, "  ", " ", \
508 			    "%-16s  %5d/%s", \
509 			    se->s_name, ntohs(se->s_port), se->s_proto)
510 
511 	setservent(1);
512 	rv = RV_OK;
513 	if (argc == 2) {
514 		while ((se = getservent()) != NULL)
515 			SERVICESPRINT;
516 	} else {
517 		for (i = 2; i < argc; i++) {
518 			proto = strchr(argv[i], '/');
519 			if (proto != NULL)
520 				*proto++ = '\0';
521 			if (parsenum(argv[i], &id))
522 				se = getservbyport(htons((u_short)id), proto);
523 			else
524 				se = getservbyname(argv[i], proto);
525 			if (se != NULL)
526 				SERVICESPRINT;
527 			else {
528 				rv = RV_NOTFOUND;
529 				break;
530 			}
531 		}
532 	}
533 	endservent();
534 	return rv;
535 }
536 
537 /*
538  * shells
539  */
540 static int
541 shells(int argc, char *argv[])
542 {
543 	const char	*sh;
544 	int		i, rv;
545 
546 	assert(argc > 1);
547 	assert(argv != NULL);
548 
549 #define SHELLSPRINT	printf("%s\n", sh)
550 
551 	setusershell();
552 	rv = RV_OK;
553 	if (argc == 2) {
554 		while ((sh = getusershell()) != NULL)
555 			SHELLSPRINT;
556 	} else {
557 		for (i = 2; i < argc; i++) {
558 			setusershell();
559 			while ((sh = getusershell()) != NULL) {
560 				if (strcmp(sh, argv[i]) == 0) {
561 					SHELLSPRINT;
562 					break;
563 				}
564 			}
565 			if (sh == NULL) {
566 				rv = RV_NOTFOUND;
567 				break;
568 			}
569 		}
570 	}
571 	endusershell();
572 	return rv;
573 }
574 
575 /*
576  * netgroup
577  */
578 static int
579 netgroup(int argc, char *argv[])
580 {
581 	char		*host, *user, *domain;
582 	int		first;
583 	int		rv, i;
584 
585 	assert(argc > 1);
586 	assert(argv != NULL);
587 
588 #define NETGROUPPRINT(s)	(((s) != NULL) ? (s) : "")
589 
590 	rv = RV_OK;
591 	if (argc == 2) {
592 		fprintf(stderr, "Enumeration not supported on netgroup\n");
593 		rv = RV_NOENUM;
594 	} else {
595 		for (i = 2; i < argc; i++) {
596 			setnetgrent(argv[i]);
597 			first = 1;
598 			while (getnetgrent(&host, &user, &domain) != 0) {
599 				if (first) {
600 					first = 0;
601 					(void)fputs(argv[i], stdout);
602 				}
603 				(void)printf(" (%s,%s,%s)",
604 				    NETGROUPPRINT(host),
605 				    NETGROUPPRINT(user),
606 				    NETGROUPPRINT(domain));
607 			}
608 			if (!first)
609 				(void)putchar('\n');
610 			endnetgrent();
611 		}
612 	}
613 	return rv;
614 }
615 
616 /*
617  * utmpx
618  */
619 
620 #define	UTMPXPRINTID do {			\
621 	size_t i;				\
622 	for (i = 0; i < sizeof ut->ut_id; i++)	\
623 		printf("%02hhx", ut->ut_id[i]);	\
624 } while (0)
625 
626 static void
627 utmpxprint(const struct utmpx *ut)
628 {
629 
630 	if (ut->ut_type == EMPTY)
631 		return;
632 
633 	printf("[%jd.%06u -- %.24s] ",
634 	    (intmax_t)ut->ut_tv.tv_sec, (unsigned int)ut->ut_tv.tv_usec,
635 	    ctime(&ut->ut_tv.tv_sec));
636 
637 	switch (ut->ut_type) {
638 	case BOOT_TIME:
639 		printf("system boot\n");
640 		return;
641 	case SHUTDOWN_TIME:
642 		printf("system shutdown\n");
643 		return;
644 	case OLD_TIME:
645 		printf("old system time\n");
646 		return;
647 	case NEW_TIME:
648 		printf("new system time\n");
649 		return;
650 	case USER_PROCESS:
651 		printf("user process: id=\"");
652 		UTMPXPRINTID;
653 		printf("\" pid=\"%d\" user=\"%s\" line=\"%s\" host=\"%s\"\n",
654 		    ut->ut_pid, ut->ut_user, ut->ut_line, ut->ut_host);
655 		break;
656 	case INIT_PROCESS:
657 		printf("init process: id=\"");
658 		UTMPXPRINTID;
659 		printf("\" pid=\"%d\"\n", ut->ut_pid);
660 		break;
661 	case LOGIN_PROCESS:
662 		printf("login process: id=\"");
663 		UTMPXPRINTID;
664 		printf("\" pid=\"%d\" user=\"%s\" line=\"%s\" host=\"%s\"\n",
665 		    ut->ut_pid, ut->ut_user, ut->ut_line, ut->ut_host);
666 		break;
667 	case DEAD_PROCESS:
668 		printf("dead process: id=\"");
669 		UTMPXPRINTID;
670 		printf("\" pid=\"%d\"\n", ut->ut_pid);
671 		break;
672 	default:
673 		printf("unknown record type %hu\n", ut->ut_type);
674 		break;
675 	}
676 }
677 
678 static int
679 utmpx(int argc, char *argv[])
680 {
681 	const struct utmpx *ut;
682 	const char *file = NULL;
683 	int rv = RV_OK, db = 0;
684 
685 	assert(argc > 1);
686 	assert(argv != NULL);
687 
688 	if (argc == 3 || argc == 4) {
689 		if (strcmp(argv[2], "active") == 0)
690 			db = UTXDB_ACTIVE;
691 		else if (strcmp(argv[2], "lastlogin") == 0)
692 			db = UTXDB_LASTLOGIN;
693 		else if (strcmp(argv[2], "log") == 0)
694 			db = UTXDB_LOG;
695 		else
696 			rv = RV_USAGE;
697 		if (argc == 4)
698 			file = argv[3];
699 	} else {
700 		rv = RV_USAGE;
701 	}
702 
703 	if (rv == RV_USAGE) {
704 		fprintf(stderr,
705 		    "Usage: %s utmpx active | lastlogin | log [filename]\n",
706 		    getprogname());
707 	} else if (rv == RV_OK) {
708 		if (setutxdb(db, file) != 0)
709 			return (RV_NOTFOUND);
710 		while ((ut = getutxent()) != NULL)
711 			utmpxprint(ut);
712 		endutxent();
713 	}
714 	return (rv);
715 }
716