nss/getent.c

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