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