nss/getent.c

   1 /* Copyright (c) 1998-2003, 2004 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Thorsten Kukuk <kukuk@suse.de>, 1998.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 /* getent: get entries from administrative database.  */
  21
  22 #include <aliases.h>
  23 #include <argp.h>
  24 #include <grp.h>
  25 #include <pwd.h>
  26 #include <shadow.h>
  27 #include <ctype.h>
  28 #include <error.h>
  29 #include <libintl.h>
  30 #include <locale.h>
  31 #include <netdb.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <sys/socket.h>
  36 #include <netinet/in.h>
  37 #include <netinet/ether.h>
  38 #include <arpa/inet.h>
  39 #include <arpa/nameser.h>
  40
  41 /* Get libc version number.  */
  42 #include <version.h>
  43
  44 #define PACKAGE _libc_intl_domainname
  45
  46 /* Name and version of program.  */
  47 static void print_version (FILE *stream, struct argp_state *state);
  48 void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version;
  49
  50 /* Short description of parameters.  */
  51 static const char args_doc[] = N_("database [key ...]");
  52
  53 /* Supported options. */
  54 static const struct argp_option args_options[] =
  55   {
  56     { "service", 's', "CONFIG", 0, N_("Service configuration to be used") },
  57     { NULL, 0, NULL, 0, NULL },
  58   };
  59
  60 /* Prototype for option handler.  */
  61 static error_t parse_option (int key, char *arg, struct argp_state *state);
  62
  63 /* Data structure to communicate with argp functions.  */
  64 static struct argp argp =
  65   {
  66     args_options, parse_option, args_doc, NULL,
  67   };
  68
  69 /* Print the version information.  */
  70 static void
  71 print_version (FILE *stream, struct argp_state *state)
  72 {
  73   fprintf (stream, "getent (GNU %s) %s\n", PACKAGE, VERSION);
  74   fprintf (stream, gettext ("\
  75 Copyright (C) %s Free Software Foundation, Inc.\n\
  76 This is free software; see the source for copying conditions.  There is NO\n\
  77 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
  78 "), "2004");
  79   fprintf (stream, gettext ("Written by %s.\n"), "Thorsten Kukuk");
  80 }
  81
  82 /* This is for aliases */
  83 static inline void
  84 print_aliases (struct aliasent *alias)
  85 {
  86   unsigned int i = 0;
  87
  88   printf ("%s: ", alias->alias_name);
  89   for  (i = strlen (alias->alias_name); i < 14; ++i)
  90     fputs_unlocked (" ", stdout);
  91
  92   for (i = 0; i < alias->alias_members_len; ++i)
  93     printf ("%s%s",
  94             alias->alias_members [i],
  95             i + 1 == alias->alias_members_len ? "\n" : ", ");
  96 }
  97
  98 static int
  99 aliases_keys (int number, char *key[])
 100 {
 101   int result = 0;
 102   int i;
 103   struct aliasent *alias;
 104
 105   if (number == 0)
 106     {
 107       setaliasent ();
 108       while ((alias = getaliasent ()) != NULL)
 109         print_aliases (alias);
 110       endaliasent ();
 111       return result;
 112     }
 113
 114   for (i = 0; i < number; ++i)
 115     {
 116       alias = getaliasbyname (key[i]);
 117
 118       if (alias == NULL)
 119         result = 2;
 120       else
 121         print_aliases (alias);
 122     }
 123
 124   return result;
 125 }
 126
 127 /* This is for ethers */
 128 static int
 129 ethers_keys (int number, char *key[])
 130 {
 131   int result = 0;
 132   int i;
 133
 134   if (number == 0)
 135     {
 136       fprintf (stderr, _("Enumeration not supported on %s\n"), "ethers");
 137       return 3;
 138     }
 139
 140   for (i = 0; i < number; ++i)
 141     {
 142       struct ether_addr *ethp, eth;
 143       char buffer [1024], *p;
 144
 145       ethp = ether_aton (key[i]);
 146       if (ethp != NULL)
 147         {
 148           if (ether_ntohost (buffer, ethp))
 149             {
 150               result = 2;
 151               continue;
 152             }
 153           p = buffer;
 154         }
 155       else
 156         {
 157           if (ether_hostton (key[i], &eth))
 158             {
 159               result = 2;
 160               continue;
 161             }
 162           p = key[i];
 163           ethp = &eth;
 164         }
 165       printf ("%s %s\n", ether_ntoa (ethp), p);
 166     }
 167
 168   return result;
 169 }
 170
 171 /* This is for group */
 172 static inline void
 173 print_group (struct group *grp)
 174 {
 175   unsigned int i = 0;
 176
 177   printf ("%s:%s:%lu:", grp->gr_name ? grp->gr_name : "",
 178           grp->gr_passwd ? grp->gr_passwd : "",
 179           (unsigned long int) grp->gr_gid);
 180
 181   while (grp->gr_mem[i] != NULL)
 182     {
 183       fputs_unlocked (grp->gr_mem[i], stdout);
 184       ++i;
 185       if (grp->gr_mem[i] != NULL)
 186         putchar_unlocked (',');
 187     }
 188   putchar_unlocked ('\n');
 189 }
 190
 191 static int
 192 group_keys (int number, char *key[])
 193 {
 194   int result = 0;
 195   int i;
 196   struct group *grp;
 197
 198   if (number == 0)
 199     {
 200       setgrent ();
 201       while ((grp = getgrent ()) != NULL)
 202         print_group (grp);
 203       endgrent ();
 204       return result;
 205     }
 206
 207   for (i = 0; i < number; ++i)
 208     {
 209       errno = 0;
 210       char *ep;
 211       gid_t arg_gid = strtoul(key[i], &ep, 10);
 212
 213       if (errno != EINVAL && *key[i] != '\0' && *ep == '\0')
 214         /* Valid numeric gid.  */
 215         grp = getgrgid (arg_gid);
 216       else
 217         grp = getgrnam (key[i]);
 218
 219       if (grp == NULL)
 220         result = 2;
 221       else
 222         print_group (grp);
 223     }
 224
 225   return result;
 226 }
 227
 228 /* This is for hosts */
 229 static void
 230 print_hosts (struct hostent *host)
 231 {
 232   unsigned int cnt;
 233
 234   for (cnt = 0; host->h_addr_list[cnt] != NULL; ++cnt)
 235     {
 236       char buf[INET6_ADDRSTRLEN];
 237       const char *ip = inet_ntop (host->h_addrtype, host->h_addr_list[cnt],
 238                                   buf, sizeof (buf));
 239
 240       printf ("%-15s %s", ip, host->h_name);
 241
 242       unsigned int i;
 243       for (i = 0; host->h_aliases[i] != NULL; ++i)
 244         {
 245           putchar_unlocked (' ');
 246           fputs_unlocked (host->h_aliases[i], stdout);
 247         }
 248       putchar_unlocked ('\n');
 249     }
 250 }
 251
 252 static int
 253 hosts_keys (int number, char *key[])
 254 {
 255   int result = 0;
 256   int i;
 257   struct hostent *host;
 258
 259   if (number == 0)
 260     {
 261       sethostent (0);
 262       while ((host = gethostent ()) != NULL)
 263         print_hosts (host);
 264       endhostent ();
 265       return result;
 266     }
 267
 268   for (i = 0; i < number; ++i)
 269     {
 270       struct hostent *host = NULL;
 271
 272       if (strchr (key[i], ':') != NULL)
 273         {
 274           char addr[IN6ADDRSZ];
 275           if (inet_pton (AF_INET6, key[i], &addr))
 276             host = gethostbyaddr (addr, sizeof (addr), AF_INET6);
 277         }
 278       else if (isdigit (key[i][0]))
 279         {
 280           char addr[INADDRSZ];
 281           if (inet_pton (AF_INET, key[i], &addr))
 282             host = gethostbyaddr (addr, sizeof (addr), AF_INET);
 283         }
 284       else if ((host = gethostbyname2 (key[i], AF_INET6)) == NULL)
 285         host = gethostbyname2 (key[i], AF_INET);
 286
 287       if (host == NULL)
 288         result = 2;
 289       else
 290         print_hosts (host);
 291     }
 292
 293   return result;
 294 }
 295
 296 /* This is for hosts, but using getaddrinfo */
 297 static int
 298 ahosts_keys_int (int af, int xflags, int number, char *key[])
 299 {
 300   int result = 0;
 301   int i;
 302   struct hostent *host;
 303
 304   if (number == 0)
 305     {
 306       sethostent (0);
 307       while ((host = gethostent ()) != NULL)
 308         print_hosts (host);
 309       endhostent ();
 310       return result;
 311     }
 312
 313   struct addrinfo hint;
 314   memset (&hint, '\0', sizeof (hint));
 315   hint.ai_flags = AI_V4MAPPED | AI_ADDRCONFIG | AI_CANONNAME | xflags;
 316   hint.ai_family = af;
 317
 318   for (i = 0; i < number; ++i)
 319     {
 320       struct addrinfo *res;
 321
 322       if (getaddrinfo (key[i], NULL, &hint, &res) != 0)
 323         result = 2;
 324       else
 325         {
 326           struct addrinfo *runp = res;
 327
 328           while (runp != NULL)
 329             {
 330               char sockbuf[20];
 331               const char *sockstr;
 332               if (runp->ai_socktype == SOCK_STREAM)
 333                 sockstr = "STREAM";
 334               else if (runp->ai_socktype == SOCK_DGRAM)
 335                 sockstr = "DGRAM";
 336               else if (runp->ai_socktype == SOCK_RAW)
 337                 sockstr = "RAW";
 338               else
 339                 {
 340                   snprintf (sockbuf, sizeof (sockbuf), "%d",
 341                             runp->ai_socktype);
 342                   sockstr = sockbuf;
 343                 }
 344
 345               char buf[INET6_ADDRSTRLEN];
 346               printf ("%-15s %-6s %s\n",
 347                       inet_ntop (runp->ai_family,
 348                                  &((struct sockaddr_in *) runp->ai_addr)->sin_addr,
 349                                  buf, sizeof (buf)),
 350                       sockstr,
 351                       runp->ai_canonname ?: "");
 352
 353               runp = runp->ai_next;
 354             }
 355
 356           freeaddrinfo (res);
 357         }
 358     }
 359
 360   return result;
 361 }
 362
 363 static int
 364 ahosts_keys (int number, char *key[])
 365 {
 366   return ahosts_keys_int (AF_UNSPEC, 0, number, key);
 367 }
 368
 369 static int
 370 ahostsv4_keys (int number, char *key[])
 371 {
 372   return ahosts_keys_int (AF_INET, 0, number, key);
 373 }
 374
 375 static int
 376 ahostsv6_keys (int number, char *key[])
 377 {
 378   return ahosts_keys_int (AF_INET6, AI_V4MAPPED, number, key);
 379 }
 380
 381 /* This is for netgroup */
 382 static int
 383 netgroup_keys (int number, char *key[])
 384 {
 385   int result = 0;
 386   int i;
 387
 388   if (number == 0)
 389     {
 390       fprintf (stderr, _("Enumeration not supported on %s\n"), "netgroup");
 391       return 3;
 392     }
 393
 394   for (i = 0; i < number; ++i)
 395     {
 396       if (!setnetgrent (key[i]))
 397         result = 2;
 398       else
 399         {
 400           char *p[3];
 401
 402           printf ("%-21s", key[i]);
 403
 404           while (getnetgrent (p, p + 1, p + 2))
 405             printf (" (%s, %s, %s)", p[0] ?: " ", p[1] ?: "", p[2] ?: "");
 406           putchar_unlocked ('\n');
 407         }
 408     }
 409
 410   return result;
 411 }
 412
 413 /* This is for networks */
 414 static void
 415 print_networks (struct netent *net)
 416 {
 417   unsigned int i;
 418   struct in_addr ip;
 419   ip.s_addr = htonl (net->n_net);
 420
 421   printf ("%-21s %s", net->n_name, inet_ntoa (ip));
 422
 423   i = 0;
 424   while (net->n_aliases[i] != NULL)
 425     {
 426       putchar_unlocked (' ');
 427       fputs_unlocked (net->n_aliases[i], stdout);
 428       ++i;
 429       if (net->n_aliases[i] != NULL)
 430         putchar_unlocked (',');
 431     }
 432   putchar_unlocked ('\n');
 433 }
 434
 435 static int
 436 networks_keys (int number, char *key[])
 437 {
 438   int result = 0;
 439   int i;
 440   struct netent *net;
 441
 442   if (number == 0)
 443     {
 444       setnetent (0);
 445       while ((net = getnetent ()) != NULL)
 446         print_networks (net);
 447       endnetent ();
 448       return result;
 449     }
 450
 451   for (i = 0; i < number; ++i)
 452     {
 453       if (isdigit (key[i][0]))
 454         net = getnetbyaddr (inet_addr (key[i]), AF_UNIX);
 455       else
 456         net = getnetbyname (key[i]);
 457
 458       if (net == NULL)
 459         result = 2;
 460       else
 461         print_networks (net);
 462     }
 463
 464   return result;
 465 }
 466
 467 /* Now is all for passwd */
 468 static inline void
 469 print_passwd (struct passwd *pwd)
 470 {
 471   printf ("%s:%s:%lu:%lu:%s:%s:%s\n",
 472           pwd->pw_name ? pwd->pw_name : "",
 473           pwd->pw_passwd ? pwd->pw_passwd : "",
 474           (unsigned long int) pwd->pw_uid,
 475           (unsigned long int) pwd->pw_gid,
 476           pwd->pw_gecos ? pwd->pw_gecos : "",
 477           pwd->pw_dir ? pwd->pw_dir : "",
 478           pwd->pw_shell ? pwd->pw_shell : "");
 479 }
 480
 481 static int
 482 passwd_keys (int number, char *key[])
 483 {
 484   int result = 0;
 485   int i;
 486   struct passwd *pwd;
 487
 488   if (number == 0)
 489     {
 490       setpwent ();
 491       while ((pwd = getpwent ()) != NULL)
 492         print_passwd (pwd);
 493       endpwent ();
 494       return result;
 495     }
 496
 497   for (i = 0; i < number; ++i)
 498     {
 499       errno = 0;
 500       char *ep;
 501       uid_t arg_uid = strtoul(key[i], &ep, 10);
 502
 503       if (errno != EINVAL && *key[i] != '\0' && *ep == '\0')
 504         /* Valid numeric uid.  */
 505         pwd = getpwuid (arg_uid);
 506       else
 507         pwd = getpwnam (key[i]);
 508
 509       if (pwd == NULL)
 510         result = 2;
 511       else
 512         print_passwd (pwd);
 513     }
 514
 515   return result;
 516 }
 517
 518 /* This is for protocols */
 519 static inline void
 520 print_protocols (struct protoent *proto)
 521 {
 522   unsigned int i;
 523
 524   printf ("%-21s %d", proto->p_name, proto->p_proto);
 525
 526   i = 0;
 527   while (proto->p_aliases[i] != NULL)
 528     {
 529       putchar_unlocked (' ');
 530       fputs_unlocked (proto->p_aliases[i], stdout);
 531       ++i;
 532     }
 533   putchar_unlocked ('\n');
 534 }
 535
 536 static int
 537 protocols_keys (int number, char *key[])
 538 {
 539   int result = 0;
 540   int i;
 541   struct protoent *proto;
 542
 543   if (number == 0)
 544     {
 545       setprotoent (0);
 546       while ((proto = getprotoent ()) != NULL)
 547         print_protocols (proto);
 548       endprotoent ();
 549       return result;
 550     }
 551
 552   for (i = 0; i < number; ++i)
 553     {
 554       if (isdigit (key[i][0]))
 555         proto = getprotobynumber (atol (key[i]));
 556       else
 557         proto = getprotobyname (key[i]);
 558
 559       if (proto == NULL)
 560         result = 2;
 561       else
 562         print_protocols (proto);
 563     }
 564
 565   return result;
 566 }
 567
 568 /* Now is all for rpc */
 569 static inline void
 570 print_rpc (struct rpcent *rpc)
 571 {
 572   int i;
 573
 574   printf ("%-15s %d%s",
 575           rpc->r_name, rpc->r_number, rpc->r_aliases[0] ? " " : "");
 576
 577   for (i = 0; rpc->r_aliases[i]; ++i)
 578     printf (" %s", rpc->r_aliases[i]);
 579   putchar_unlocked ('\n');
 580 }
 581
 582 static int
 583 rpc_keys (int number, char *key[])
 584 {
 585   int result = 0;
 586   int i;
 587   struct rpcent *rpc;
 588
 589   if (number == 0)
 590     {
 591       setrpcent (0);
 592       while ((rpc = getrpcent ()) != NULL)
 593         print_rpc (rpc);
 594       endrpcent ();
 595       return result;
 596     }
 597
 598   for (i = 0; i < number; ++i)
 599     {
 600       if (isdigit (key[i][0]))
 601         rpc = getrpcbynumber (atol (key[i]));
 602       else
 603         rpc = getrpcbyname (key[i]);
 604
 605       if (rpc == NULL)
 606         result = 2;
 607       else
 608         print_rpc (rpc);
 609     }
 610
 611   return result;
 612 }
 613
 614 /* for services */
 615 static void
 616 print_services (struct servent *serv)
 617 {
 618   unsigned int i;
 619
 620   printf ("%-21s %d/%s", serv->s_name, ntohs (serv->s_port), serv->s_proto);
 621
 622   i = 0;
 623   while (serv->s_aliases[i] != NULL)
 624     {
 625       putchar_unlocked (' ');
 626       fputs_unlocked (serv->s_aliases[i], stdout);
 627       ++i;
 628     }
 629   putchar_unlocked ('\n');
 630 }
 631
 632 static int
 633 services_keys (int number, char *key[])
 634 {
 635   int result = 0;
 636   int i;
 637   struct servent *serv;
 638
 639   if (!number)
 640     {
 641       setservent (0);
 642       while ((serv = getservent ()) != NULL)
 643         print_services (serv);
 644       endservent ();
 645       return result;
 646     }
 647
 648   for (i = 0; i < number; ++i)
 649     {
 650       struct servent *serv;
 651       char *proto = strchr (key[i], '/');
 652
 653       if (proto != NULL)
 654         *proto++ = '\0';
 655
 656       if (isdigit (key[i][0]))
 657         serv = getservbyport (htons (atol (key[i])), proto);
 658       else
 659         serv = getservbyname (key[i], proto);
 660
 661       if (serv == NULL)
 662         result = 2;
 663       else
 664         print_services (serv);
 665     }
 666
 667   return result;
 668 }
 669
 670 /* This is for shadow */
 671 static void
 672 print_shadow (struct spwd *sp)
 673 {
 674   printf ("%s:%s:",
 675           sp->sp_namp ? sp->sp_namp : "",
 676           sp->sp_pwdp ? sp->sp_pwdp : "");
 677
 678 #define SHADOW_FIELD(n) \
 679   if (sp->n == -1)                                                            \
 680     putchar_unlocked (':');                                                   \
 681   else                                                                        \
 682     printf ("%ld:", sp->n)
 683
 684   SHADOW_FIELD (sp_lstchg);
 685   SHADOW_FIELD (sp_min);
 686   SHADOW_FIELD (sp_max);
 687   SHADOW_FIELD (sp_warn);
 688   SHADOW_FIELD (sp_inact);
 689   SHADOW_FIELD (sp_expire);
 690   if (sp->sp_flag == ~0ul)
 691     putchar_unlocked ('\n');
 692   else
 693     printf ("%lu\n", sp->sp_flag);
 694 }
 695
 696 static int
 697 shadow_keys (int number, char *key[])
 698 {
 699   int result = 0;
 700   int i;
 701
 702   if (number == 0)
 703     {
 704       struct spwd *sp;
 705
 706       setspent ();
 707       while ((sp = getspent ()) != NULL)
 708         print_shadow (sp);
 709       endpwent ();
 710       return result;
 711     }
 712
 713   for (i = 0; i < number; ++i)
 714     {
 715       struct spwd *sp;
 716
 717       sp = getspnam (key[i]);
 718
 719       if (sp == NULL)
 720         result = 2;
 721       else
 722         print_shadow (sp);
 723     }
 724
 725   return result;
 726 }
 727
 728 struct
 729   {
 730     const char *name;
 731     int (*func) (int number, char *key[]);
 732   } databases[] =
 733   {
 734 #define D(name) { #name, name ## _keys },
 735 D(ahosts)
 736 D(ahostsv4)
 737 D(ahostsv6)
 738 D(aliases)
 739 D(ethers)
 740 D(group)
 741 D(hosts)
 742 D(netgroup)
 743 D(networks)
 744 D(passwd)
 745 D(protocols)
 746 D(rpc)
 747 D(services)
 748 D(shadow)
 749 #undef D
 750     { NULL, NULL }
 751   };
 752
 753 /* Handle arguments found by argp. */
 754 static error_t
 755 parse_option (int key, char *arg, struct argp_state *state)
 756 {
 757   int i;
 758   switch (key)
 759     {
 760     case 's':
 761       for (i = 0; databases[i].name; ++i)
 762         __nss_configure_lookup (databases[i].name, arg);
 763       break;
 764
 765     default:
 766       return ARGP_ERR_UNKNOWN;
 767     }
 768
 769   return 0;
 770 }
 771
 772 /* build doc */
 773 static void
 774 build_doc (void)
 775 {
 776   int i, j, len;
 777   char *short_doc, *long_doc, *doc, *p;
 778
 779   short_doc = _("getent - get entries from administrative database.");
 780   long_doc = _("Supported databases:");
 781   len = strlen (short_doc) + strlen (long_doc) + 3;
 782
 783   for (i = 0; databases[i].name; ++i)
 784     len += strlen (databases[i].name) + 1;
 785
 786   doc = (char *) malloc (len);
 787   if (doc == NULL)
 788     doc = short_doc;
 789   else
 790     {
 791       p = stpcpy (doc, short_doc);
 792       *p++ = '\v';
 793       p = stpcpy (p, long_doc);
 794       *p++ = '\n';
 795
 796       for (i = 0, j = 0; databases[i].name; ++i)
 797         {
 798           len = strlen (databases[i].name);
 799           if (i != 0)
 800             {
 801               if (j + len > 72)
 802                 {
 803                   j = 0;
 804                   *p++ = '\n';
 805                 }
 806               else
 807                 *p++ = ' ';
 808             }
 809
 810           p = mempcpy (p, databases[i].name, len);
 811           j += len + 1;
 812         }
 813     }
 814
 815   argp.doc = doc;
 816 }
 817
 818 /* the main function */
 819 int
 820 main (int argc, char *argv[])
 821 {
 822   int remaining, i;
 823
 824   /* Set locale via LC_ALL.  */
 825   setlocale (LC_ALL, "");
 826   /* Set the text message domain.  */
 827   textdomain (PACKAGE);
 828
 829   /* Build argp.doc.  */
 830   build_doc ();
 831
 832   /* Parse and process arguments.  */
 833   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
 834
 835   if ((argc - remaining) < 1)
 836     {
 837       error (0, 0, gettext ("wrong number of arguments"));
 838       argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
 839       return 1;
 840     }
 841
 842   for (i = 0; databases[i].name; ++i)
 843     if (argv[remaining][0] == databases[i].name[0]
 844         && !strcmp (argv[remaining], databases[i].name))
 845       return databases[i].func (argc - remaining - 1, &argv[remaining + 1]);
 846
 847   fprintf (stderr, _("Unknown database: %s\n"), argv[remaining]);
 848   argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
 849   return 1;
 850 }