1/* Copyright (c) 1998-2022 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <https://www.gnu.org/licenses/>. */
17
18/* getent: get entries from administrative database. */
19
20#include <aliases.h>
21#include <argp.h>
22#include <ctype.h>
23#include <error.h>
24#include <grp.h>
25#include <gshadow.h>
26#include <libintl.h>
27#include <locale.h>
28#include <mcheck.h>
29#include <netdb.h>
30#include <pwd.h>
31#include <shadow.h>
32#include <stdbool.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#include <scratch_buffer.h>
42#include <inttypes.h>
43
44/* Get libc version number. */
45#include <version.h>
46
47#define PACKAGE _libc_intl_domainname
48
49/* Name and version of program. */
50static void print_version (FILE *stream, struct argp_state *state);
51void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version;
52
53/* Short description of parameters. */
54static const char args_doc[] = N_("database [key ...]");
55
56/* Supported options. */
57static const struct argp_option args_options[] =
58 {
59 { "service", 's', N_("CONFIG"), 0, N_("Service configuration to be used") },
60 { "no-idn", 'i', NULL, 0, N_("disable IDN encoding") },
61 { NULL, 0, NULL, 0, NULL },
62 };
63
64/* Short description of program. */
65static const char doc[] = N_("Get entries from administrative database.");
66
67/* Prototype for option handler. */
68static error_t parse_option (int key, char *arg, struct argp_state *state);
69
70/* Function to print some extra text in the help message. */
71static char *more_help (int key, const char *text, void *input);
72
73/* Data structure to communicate with argp functions. */
74static struct argp argp =
75 {
76 args_options, parse_option, args_doc, doc, NULL, more_help
77 };
78
79/* Additional getaddrinfo flags for IDN encoding. */
80static int idn_flags = AI_IDN | AI_CANONIDN;
81
82/* Print the version information. */
83static void
84print_version (FILE *stream, struct argp_state *state)
85{
86 fprintf (stream, "getent %s%s\n", PKGVERSION, VERSION);
87 fprintf (stream, gettext ("\
88Copyright (C) %s Free Software Foundation, Inc.\n\
89This is free software; see the source for copying conditions. There is NO\n\
90warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
91"), "2022");
92 fprintf (stream, gettext ("Written by %s.\n"), "Thorsten Kukuk");
93}
94
95/* This is for aliases */
96static void
97print_aliases (struct aliasent *alias)
98{
99 unsigned int i = 0;
100
101 printf ("%s: ", alias->alias_name);
102 for (i = strlen (alias->alias_name); i < 14; ++i)
103 fputs_unlocked (" ", stdout);
104
105 for (i = 0; i < alias->alias_members_len; ++i)
106 printf ("%s%s",
107 alias->alias_members [i],
108 i + 1 == alias->alias_members_len ? "\n" : ", ");
109}
110
111static int
112aliases_keys (int number, char *key[])
113{
114 int result = 0;
115 int i;
116 struct aliasent *alias;
117
118 if (number == 0)
119 {
120 setaliasent ();
121 while ((alias = getaliasent ()) != NULL)
122 print_aliases (alias);
123 endaliasent ();
124 return result;
125 }
126
127 for (i = 0; i < number; ++i)
128 {
129 alias = getaliasbyname (key[i]);
130
131 if (alias == NULL)
132 result = 2;
133 else
134 print_aliases (alias);
135 }
136
137 return result;
138}
139
140/* This is for ethers */
141static int
142ethers_keys (int number, char *key[])
143{
144 int result = 0;
145 int i;
146
147 if (number == 0)
148 {
149 fprintf (stderr, _("Enumeration not supported on %s\n"), "ethers");
150 return 3;
151 }
152
153 for (i = 0; i < number; ++i)
154 {
155 struct ether_addr *ethp, eth;
156 char buffer [1024], *p;
157
158 ethp = ether_aton (key[i]);
159 if (ethp != NULL)
160 {
161 if (ether_ntohost (buffer, ethp))
162 {
163 result = 2;
164 continue;
165 }
166 p = buffer;
167 }
168 else
169 {
170 if (ether_hostton (key[i], &eth))
171 {
172 result = 2;
173 continue;
174 }
175 p = key[i];
176 ethp = &eth;
177 }
178 printf ("%s %s\n", ether_ntoa (ethp), p);
179 }
180
181 return result;
182}
183
184/* This is for group */
185static void
186print_group (struct group *grp)
187{
188 if (putgrent (grp, stdout) != 0)
189 fprintf (stderr, "error writing group entry: %m\n");
190}
191
192static int
193group_keys (int number, char *key[])
194{
195 int result = 0;
196 int i;
197 struct group *grp;
198
199 if (number == 0)
200 {
201 setgrent ();
202 while ((grp = getgrent ()) != NULL)
203 print_group (grp);
204 endgrent ();
205 return result;
206 }
207
208 for (i = 0; i < number; ++i)
209 {
210 errno = 0;
211 char *ep;
212 gid_t arg_gid = strtoul(key[i], &ep, 10);
213
214 if (errno != EINVAL && *key[i] != '\0' && *ep == '\0')
215 /* Valid numeric gid. */
216 grp = getgrgid (arg_gid);
217 else
218 grp = getgrnam (key[i]);
219
220 if (grp == NULL)
221 result = 2;
222 else
223 print_group (grp);
224 }
225
226 return result;
227}
228
229/* This is for gshadow */
230static void
231print_gshadow (struct sgrp *sg)
232{
233 if (putsgent (sg, stdout) != 0)
234 fprintf (stderr, "error writing gshadow entry: %m\n");
235}
236
237static int
238gshadow_keys (int number, char *key[])
239{
240 int result = 0;
241 int i;
242
243 if (number == 0)
244 {
245 struct sgrp *sg;
246
247 setsgent ();
248 while ((sg = getsgent ()) != NULL)
249 print_gshadow (sg);
250 endsgent ();
251 return result;
252 }
253
254 for (i = 0; i < number; ++i)
255 {
256 struct sgrp *sg;
257
258 sg = getsgnam (key[i]);
259
260 if (sg == NULL)
261 result = 2;
262 else
263 print_gshadow (sg);
264 }
265
266 return result;
267}
268
269/* This is for hosts */
270static void
271print_hosts (struct hostent *host)
272{
273 unsigned int cnt;
274
275 for (cnt = 0; host->h_addr_list[cnt] != NULL; ++cnt)
276 {
277 char buf[INET6_ADDRSTRLEN];
278 const char *ip = inet_ntop (host->h_addrtype, host->h_addr_list[cnt],
279 buf, sizeof (buf));
280
281 printf ("%-15s %s", ip, host->h_name);
282
283 unsigned int i;
284 for (i = 0; host->h_aliases[i] != NULL; ++i)
285 {
286 putchar_unlocked (' ');
287 fputs_unlocked (host->h_aliases[i], stdout);
288 }
289 putchar_unlocked ('\n');
290 }
291}
292
293static int
294hosts_keys (int number, char *key[])
295{
296 int result = 0;
297 int i;
298 struct hostent *host;
299
300 if (number == 0)
301 {
302 sethostent (0);
303 while ((host = gethostent ()) != NULL)
304 print_hosts (host);
305 endhostent ();
306 return result;
307 }
308
309 for (i = 0; i < number; ++i)
310 {
311 struct hostent *host = NULL;
312 char addr[IN6ADDRSZ];
313
314 if (inet_pton (AF_INET6, key[i], &addr) > 0)
315 host = gethostbyaddr (addr, IN6ADDRSZ, AF_INET6);
316 else if (inet_pton (AF_INET, key[i], &addr) > 0)
317 host = gethostbyaddr (addr, INADDRSZ, AF_INET);
318 else if ((host = gethostbyname2 (key[i], AF_INET6)) == NULL)
319 host = gethostbyname2 (key[i], AF_INET);
320
321 if (host == NULL)
322 result = 2;
323 else
324 print_hosts (host);
325 }
326
327 return result;
328}
329
330/* This is for hosts, but using getaddrinfo */
331static int
332ahosts_keys_int (int af, int xflags, int number, char *key[])
333{
334 int result = 0;
335 int i;
336 struct hostent *host;
337
338 if (number == 0)
339 {
340 sethostent (0);
341 while ((host = gethostent ()) != NULL)
342 print_hosts (host);
343 endhostent ();
344 return result;
345 }
346
347 struct addrinfo hint;
348 memset (&hint, '\0', sizeof (hint));
349 hint.ai_flags = (AI_V4MAPPED | AI_ADDRCONFIG | AI_CANONNAME
350 | idn_flags | xflags);
351 hint.ai_family = af;
352
353 for (i = 0; i < number; ++i)
354 {
355 struct addrinfo *res;
356
357 if (getaddrinfo (key[i], NULL, &hint, &res) != 0)
358 result = 2;
359 else
360 {
361 struct addrinfo *runp = res;
362
363 while (runp != NULL)
364 {
365 char sockbuf[20];
366 const char *sockstr;
367 if (runp->ai_socktype == SOCK_STREAM)
368 sockstr = "STREAM";
369 else if (runp->ai_socktype == SOCK_DGRAM)
370 sockstr = "DGRAM";
371 else if (runp->ai_socktype == SOCK_RAW)
372 sockstr = "RAW";
373#ifdef SOCK_SEQPACKET
374 else if (runp->ai_socktype == SOCK_SEQPACKET)
375 sockstr = "SEQPACKET";
376#endif
377#ifdef SOCK_RDM
378 else if (runp->ai_socktype == SOCK_RDM)
379 sockstr = "RDM";
380#endif
381#ifdef SOCK_DCCP
382 else if (runp->ai_socktype == SOCK_DCCP)
383 sockstr = "DCCP";
384#endif
385#ifdef SOCK_PACKET
386 else if (runp->ai_socktype == SOCK_PACKET)
387 sockstr = "PACKET";
388#endif
389 else
390 {
391 snprintf (sockbuf, sizeof (sockbuf), "%d",
392 runp->ai_socktype);
393 sockstr = sockbuf;
394 }
395
396 /* Three digits per byte, plus '%' and null terminator. */
397 char scope[3 * sizeof (uint32_t) + 2];
398 struct sockaddr_in6 *addr6
399 = (struct sockaddr_in6 *) runp->ai_addr;
400 if (runp->ai_family != AF_INET6 || addr6->sin6_scope_id == 0)
401 /* No scope ID present. */
402 scope[0] = '\0';
403 else
404 snprintf (scope, sizeof (scope), "%%%" PRIu32,
405 addr6->sin6_scope_id);
406
407 char buf[INET6_ADDRSTRLEN];
408 if (inet_ntop (runp->ai_family,
409 runp->ai_family == AF_INET
410 ? (void *) &((struct sockaddr_in *) runp->ai_addr)->sin_addr
411 : &addr6->sin6_addr,
412 buf, sizeof (buf)) == NULL)
413 {
414 strcpy (buf, "<invalid>");
415 scope[0] = '\0';
416 }
417
418 int pad = 15 - strlen (buf) - strlen (scope);
419 if (pad < 0)
420 pad = 0;
421
422 printf ("%s%-*s %-6s %s\n",
423 buf, pad, scope, sockstr, runp->ai_canonname ?: "");
424
425 runp = runp->ai_next;
426 }
427
428 freeaddrinfo (res);
429 }
430 }
431
432 return result;
433}
434
435static int
436ahosts_keys (int number, char *key[])
437{
438 return ahosts_keys_int (AF_UNSPEC, 0, number, key);
439}
440
441static int
442ahostsv4_keys (int number, char *key[])
443{
444 return ahosts_keys_int (AF_INET, 0, number, key);
445}
446
447static int
448ahostsv6_keys (int number, char *key[])
449{
450 return ahosts_keys_int (AF_INET6, AI_V4MAPPED, number, key);
451}
452
453/* This is for netgroup */
454static int
455netgroup_keys (int number, char *key[])
456{
457 int result = 0;
458
459 if (number == 0)
460 {
461 fprintf (stderr, _("Enumeration not supported on %s\n"), "netgroup");
462 return 3;
463 }
464
465 if (number == 4)
466 {
467 char *host = strcmp (key[1], "*") == 0 ? NULL : key[1];
468 char *user = strcmp (key[2], "*") == 0 ? NULL : key[2];
469 char *domain = strcmp (key[3], "*") == 0 ? NULL : key[3];
470
471 printf ("%-21s (%s,%s,%s) = %d\n",
472 key[0], host ?: "", user ?: "", domain ?: "",
473 innetgr (key[0], host, user, domain));
474 }
475 else if (number == 1)
476 {
477 if (!setnetgrent (key[0]))
478 result = 2;
479 else
480 {
481 char *p[3];
482
483 printf ("%-21s", key[0]);
484
485 while (getnetgrent (p, p + 1, p + 2))
486 printf (" (%s,%s,%s)", p[0] ?: " ", p[1] ?: "", p[2] ?: "");
487 putchar_unlocked ('\n');
488 }
489 }
490
491 endnetgrent ();
492
493 return result;
494}
495
496#define DYNARRAY_STRUCT gid_list
497#define DYNARRAY_ELEMENT gid_t
498#define DYNARRAY_PREFIX gid_list_
499#define DYNARRAY_INITIAL_SIZE 10
500#include <malloc/dynarray-skeleton.c>
501
502/* This is for initgroups */
503static int
504initgroups_keys (int number, char *key[])
505{
506 if (number == 0)
507 {
508 fprintf (stderr, _("Enumeration not supported on %s\n"), "initgroups");
509 return 3;
510 }
511
512 struct gid_list list;
513 gid_list_init (&list);
514 if (!gid_list_resize (&list, 10))
515 {
516 fprintf (stderr, _("Could not allocate group list: %m\n"));
517 return 3;
518 }
519
520 for (int i = 0; i < number; ++i)
521 {
522 int no = gid_list_size (&list);
523 int n;
524 while ((n = getgrouplist (key[i], -1, gid_list_begin (&list), &no)) == -1
525 && no > gid_list_size (&list))
526 {
527 if (!gid_list_resize (&list, no))
528 {
529 fprintf (stderr, _("Could not allocate group list: %m\n"));
530 return 3;
531 }
532 }
533
534 if (n == -1)
535 {
536 gid_list_free (&list);
537 return 1;
538 }
539
540 const gid_t *grps = gid_list_begin (&list);
541 printf ("%-21s", key[i]);
542 for (int j = 0; j < n; ++j)
543 if (grps[j] != -1)
544 printf (" %ld", (long int) grps[j]);
545 putchar_unlocked ('\n');
546 }
547
548 gid_list_free (&list);
549
550 return 0;
551}
552
553/* This is for networks */
554static void
555print_networks (struct netent *net)
556{
557 unsigned int i;
558 struct in_addr ip;
559 ip.s_addr = htonl (net->n_net);
560
561 printf ("%-21s %s", net->n_name, inet_ntoa (ip));
562
563 i = 0;
564 while (net->n_aliases[i] != NULL)
565 {
566 putchar_unlocked (' ');
567 fputs_unlocked (net->n_aliases[i], stdout);
568 ++i;
569 }
570 putchar_unlocked ('\n');
571}
572
573static int
574networks_keys (int number, char *key[])
575{
576 int result = 0;
577 int i;
578 struct netent *net;
579
580 if (number == 0)
581 {
582 setnetent (0);
583 while ((net = getnetent ()) != NULL)
584 print_networks (net);
585 endnetent ();
586 return result;
587 }
588
589 for (i = 0; i < number; ++i)
590 {
591 if (isdigit (key[i][0]))
592 net = getnetbyaddr (ntohl (inet_addr (key[i])), AF_UNSPEC);
593 else
594 net = getnetbyname (key[i]);
595
596 if (net == NULL)
597 result = 2;
598 else
599 print_networks (net);
600 }
601
602 return result;
603}
604
605/* Now is all for passwd */
606static void
607print_passwd (struct passwd *pwd)
608{
609 if (putpwent (pwd, stdout) != 0)
610 fprintf (stderr, "error writing passwd entry: %m\n");
611}
612
613static int
614passwd_keys (int number, char *key[])
615{
616 int result = 0;
617 int i;
618 struct passwd *pwd;
619
620 if (number == 0)
621 {
622 setpwent ();
623 while ((pwd = getpwent ()) != NULL)
624 print_passwd (pwd);
625 endpwent ();
626 return result;
627 }
628
629 for (i = 0; i < number; ++i)
630 {
631 errno = 0;
632 char *ep;
633 uid_t arg_uid = strtoul(key[i], &ep, 10);
634
635 if (errno != EINVAL && *key[i] != '\0' && *ep == '\0')
636 /* Valid numeric uid. */
637 pwd = getpwuid (arg_uid);
638 else
639 pwd = getpwnam (key[i]);
640
641 if (pwd == NULL)
642 result = 2;
643 else
644 print_passwd (pwd);
645 }
646
647 return result;
648}
649
650/* This is for protocols */
651static void
652print_protocols (struct protoent *proto)
653{
654 unsigned int i;
655
656 printf ("%-21s %d", proto->p_name, proto->p_proto);
657
658 i = 0;
659 while (proto->p_aliases[i] != NULL)
660 {
661 putchar_unlocked (' ');
662 fputs_unlocked (proto->p_aliases[i], stdout);
663 ++i;
664 }
665 putchar_unlocked ('\n');
666}
667
668static int
669protocols_keys (int number, char *key[])
670{
671 int result = 0;
672 int i;
673 struct protoent *proto;
674
675 if (number == 0)
676 {
677 setprotoent (0);
678 while ((proto = getprotoent ()) != NULL)
679 print_protocols (proto);
680 endprotoent ();
681 return result;
682 }
683
684 for (i = 0; i < number; ++i)
685 {
686 if (isdigit (key[i][0]))
687 proto = getprotobynumber (atol (key[i]));
688 else
689 proto = getprotobyname (key[i]);
690
691 if (proto == NULL)
692 result = 2;
693 else
694 print_protocols (proto);
695 }
696
697 return result;
698}
699
700#if HAVE_SUNRPC
701/* Now is all for rpc */
702static void
703print_rpc (struct rpcent *rpc)
704{
705 int i;
706
707 printf ("%-15s %d%s",
708 rpc->r_name, rpc->r_number, rpc->r_aliases[0] ? " " : "");
709
710 for (i = 0; rpc->r_aliases[i]; ++i)
711 printf (" %s", rpc->r_aliases[i]);
712 putchar_unlocked ('\n');
713}
714
715static int
716rpc_keys (int number, char *key[])
717{
718 int result = 0;
719 int i;
720 struct rpcent *rpc;
721
722 if (number == 0)
723 {
724 setrpcent (0);
725 while ((rpc = getrpcent ()) != NULL)
726 print_rpc (rpc);
727 endrpcent ();
728 return result;
729 }
730
731 for (i = 0; i < number; ++i)
732 {
733 if (isdigit (key[i][0]))
734 rpc = getrpcbynumber (atol (key[i]));
735 else
736 rpc = getrpcbyname (key[i]);
737
738 if (rpc == NULL)
739 result = 2;
740 else
741 print_rpc (rpc);
742 }
743
744 return result;
745}
746#endif
747
748/* for services */
749static void
750print_services (struct servent *serv)
751{
752 unsigned int i;
753
754 printf ("%-21s %d/%s", serv->s_name, ntohs (serv->s_port), serv->s_proto);
755
756 i = 0;
757 while (serv->s_aliases[i] != NULL)
758 {
759 putchar_unlocked (' ');
760 fputs_unlocked (serv->s_aliases[i], stdout);
761 ++i;
762 }
763 putchar_unlocked ('\n');
764}
765
766static int
767services_keys (int number, char *key[])
768{
769 int result = 0;
770 int i;
771 struct servent *serv;
772
773 if (!number)
774 {
775 setservent (0);
776 while ((serv = getservent ()) != NULL)
777 print_services (serv);
778 endservent ();
779 return result;
780 }
781
782 for (i = 0; i < number; ++i)
783 {
784 struct servent *serv;
785 char *proto = strchr (key[i], '/');
786
787 if (proto != NULL)
788 *proto++ = '\0';
789
790 char *endptr;
791 long port = strtol (key[i], &endptr, 10);
792
793 if (isdigit (key[i][0]) && *endptr == '\0'
794 && 0 <= port && port <= 65535)
795 serv = getservbyport (htons (port), proto);
796 else
797 serv = getservbyname (key[i], proto);
798
799 if (serv == NULL)
800 result = 2;
801 else
802 print_services (serv);
803 }
804
805 return result;
806}
807
808/* This is for shadow */
809static void
810print_shadow (struct spwd *sp)
811{
812 if (putspent (sp, stdout) != 0)
813 fprintf (stderr, "error writing shadow entry: %m\n");
814}
815
816static int
817shadow_keys (int number, char *key[])
818{
819 int result = 0;
820 int i;
821
822 if (number == 0)
823 {
824 struct spwd *sp;
825
826 setspent ();
827 while ((sp = getspent ()) != NULL)
828 print_shadow (sp);
829 endspent ();
830 return result;
831 }
832
833 for (i = 0; i < number; ++i)
834 {
835 struct spwd *sp;
836
837 sp = getspnam (key[i]);
838
839 if (sp == NULL)
840 result = 2;
841 else
842 print_shadow (sp);
843 }
844
845 return result;
846}
847
848struct
849 {
850 const char *name;
851 int (*func) (int number, char *key[]);
852 } databases[] =
853 {
854#define D(name) { #name, name ## _keys },
855D(ahosts)
856D(ahostsv4)
857D(ahostsv6)
858D(aliases)
859D(ethers)
860D(group)
861D(gshadow)
862D(hosts)
863D(initgroups)
864D(netgroup)
865D(networks)
866D(passwd)
867D(protocols)
868#if HAVE_SUNRPC
869D(rpc)
870#endif
871D(services)
872D(shadow)
873#undef D
874 { NULL, NULL }
875 };
876
877/* Handle arguments found by argp. */
878static error_t
879parse_option (int key, char *arg, struct argp_state *state)
880{
881 char *endp;
882 switch (key)
883 {
884 case 's':
885 endp = strchr (arg, ':');
886 if (endp == NULL)
887 /* No specific database, change them all. */
888 for (int i = 0; databases[i].name != NULL; ++i)
889 __nss_configure_lookup (databases[i].name, arg);
890 else
891 {
892 int i;
893 for (i = 0; databases[i].name != NULL; ++i)
894 if (strncmp (databases[i].name, arg, endp - arg) == 0)
895 {
896 __nss_configure_lookup (databases[i].name, endp + 1);
897 break;
898 }
899 if (databases[i].name == NULL)
900 error (EXIT_FAILURE, 0, gettext ("Unknown database name"));
901 }
902 break;
903
904 case 'i':
905 idn_flags = 0;
906 break;
907
908 default:
909 return ARGP_ERR_UNKNOWN;
910 }
911
912 return 0;
913}
914
915
916static char *
917more_help (int key, const char *text, void *input)
918{
919 switch (key)
920 {
921 size_t len;
922 char *doc;
923 FILE *fp;
924
925 case ARGP_KEY_HELP_EXTRA:
926 /* We print some extra information. */
927 fp = open_memstream (&doc, &len);
928 if (fp != NULL)
929 {
930 fputs_unlocked (_("Supported databases:\n"), fp);
931
932 for (int i = 0, col = 0; databases[i].name != NULL; ++i)
933 {
934 len = strlen (databases[i].name);
935 if (i != 0)
936 {
937 if (col + len > 72)
938 {
939 col = 0;
940 fputc_unlocked ('\n', fp);
941 }
942 else
943 fputc_unlocked (' ', fp);
944 }
945
946 fputs_unlocked (databases[i].name, fp);
947 col += len + 1;
948 }
949
950 fputs ("\n\n", fp);
951
952 fprintf (fp, gettext ("\
953For bug reporting instructions, please see:\n\
954%s.\n"), REPORT_BUGS_TO);
955
956 if (fclose (fp) == 0)
957 return doc;
958 }
959 break;
960
961 default:
962 break;
963 }
964 return (char *) text;
965}
966
967
968/* the main function */
969int
970main (int argc, char *argv[])
971{
972 /* Debugging support. */
973 mtrace ();
974
975 /* Set locale via LC_ALL. */
976 setlocale (LC_ALL, "");
977 /* Set the text message domain. */
978 textdomain (PACKAGE);
979
980 /* Parse and process arguments. */
981 int remaining;
982 argp_parse (&argp, argc, argv, 0, &remaining, NULL);
983
984 if ((argc - remaining) < 1)
985 {
986 error (0, 0, gettext ("wrong number of arguments"));
987 argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
988 return 1;
989 }
990
991 for (int i = 0; databases[i].name; ++i)
992 if (argv[remaining][0] == databases[i].name[0]
993 && !strcmp (argv[remaining], databases[i].name))
994 return databases[i].func (argc - remaining - 1, &argv[remaining + 1]);
995
996 fprintf (stderr, _("Unknown database: %s\n"), argv[remaining]);
997 argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
998 return 1;
999}
1000