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