getent.c

   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
  61 static int      usage(void);
  62 static int      parsenum(const char *, unsigned long *);
  63 static int      ethers(int, char *[]);
  64 static int      group(int, char *[]);
  65 static int      hosts(int, char *[]);
  66 static int      netgroup(int, char *[]);
  67 static int      networks(int, char *[]);
  68 static int      passwd(int, char *[]);
  69 static int      protocols(int, char *[]);
  70 static int      rpc(int, char *[]);
  71 static int      services(int, char *[]);
  72 static int      shells(int, char *[]);
  73 static int      utmpx(int, char *[]);
  74
  75 enum {
  76         RV_OK           = 0,
  77         RV_USAGE        = 1,
  78         RV_NOTFOUND     = 2,
  79         RV_NOENUM       = 3
  80 };
  81
  82 static 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
 101 int
 102 main(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
 121 static int
 122 usage(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
 137 static int
 138 parsenum(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  */
 164 static void
 165 printfmtstrings(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  */
 187 static int
 188 ethers(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
 229 static int
 230 group(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
 270 static void
 271 hostsprint(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
 281 static int
 282 hosts(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  */
 329 static void
 330 networksprint(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
 342 static int
 343 networks(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  */
 379 static int
 380 passwd(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  */
 419 static int
 420 protocols(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  */
 458 static int
 459 rpc(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  */
 498 static int
 499 services(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  */
 542 static int
 543 shells(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  */
 580 static int
 581 netgroup(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
 628 static void
 629 utmpxprint(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
 680 static int
 681 utmpx(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 }