1 /*        $NetBSD: getarg.c,v 1.6 2023/06/19 21:41:45 christos Exp $  */
2 
3 /*
4  * Copyright (c) 1997 - 2002 Kungliga Tekniska Högskolan
5  * (Royal Institute of Technology, Stockholm, Sweden).
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  *
19  * 3. Neither the name of the Institute nor the names of its contributors
20  *    may be used to endorse or promote products derived from this software
21  *    without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  */
35 
36 #include <config.h>
37 
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #include <krb5/roken.h>
42 #include <getarg.h>
43 
44 #define ISFLAG(X) ((X).type == arg_flag || (X).type == arg_negative_flag)
45 
46 static size_t
print_arg(char * string,size_t len,int mdoc,int longp,struct getargs * arg,char * (i18n)(const char *))47 print_arg (char *string,
48              size_t len,
49              int mdoc,
50              int longp,
51              struct getargs *arg,
52              char *(i18n)(const char *))
53 {
54     const char *s;
55 
56     *string = '\0';
57 
58     if (ISFLAG(*arg) || (!longp && arg->type == arg_counter))
59           return 0;
60 
61     if(mdoc){
62           if(longp)
63               strlcat(string, "= Ns", len);
64           strlcat(string, " Ar ", len);
65     } else {
66           if (longp)
67               strlcat (string, "=", len);
68           else
69               strlcat (string, " ", len);
70     }
71 
72     if (arg->arg_help)
73           s = (*i18n)(arg->arg_help);
74     else if (arg->type == arg_integer || arg->type == arg_counter)
75           s = "integer";
76     else if (arg->type == arg_string)
77           s = "string";
78     else if (arg->type == arg_strings)
79           s = "strings";
80     else if (arg->type == arg_double)
81           s = "float";
82     else
83           s = "<undefined>";
84 
85     strlcat(string, s, len);
86     return 1 + strlen(s);
87 }
88 
89 static void
mandoc_template(struct getargs * args,size_t num_args,const char * progname,const char * extra_string,char * (i18n)(const char *))90 mandoc_template(struct getargs *args,
91                     size_t num_args,
92                     const char *progname,
93                     const char *extra_string,
94                     char *(i18n)(const char *))
95 {
96     size_t i;
97     char timestr[64], cmd[64];
98     char buf[128];
99     const char *p;
100     time_t t;
101 
102     printf(".\\\" Things to fix:\n");
103     printf(".\\\"   * correct section, and operating system\n");
104     printf(".\\\"   * remove Op from mandatory flags\n");
105     printf(".\\\"   * use better macros for arguments (like .Pa for files)\n");
106     printf(".\\\"\n");
107     t = time(NULL);
108     strftime(timestr, sizeof(timestr), "%B %e, %Y", localtime(&t));
109     printf(".Dd %s\n", timestr);
110     p = strrchr(progname, '/');
111     if(p) p++; else p = progname;
112     strlcpy(cmd, p, sizeof(cmd));
113     strupr(cmd);
114 
115     printf(".Dt %s SECTION\n", cmd);
116     printf(".Os OPERATING_SYSTEM\n");
117     printf(".Sh NAME\n");
118     printf(".Nm %s\n", p);
119     printf(".Nd in search of a description\n");
120     printf(".Sh SYNOPSIS\n");
121     printf(".Nm\n");
122     for(i = 0; i < num_args; i++){
123           /* we seem to hit a limit on number of arguments if doing
124            short and long flags with arguments -- split on two lines */
125           if(ISFLAG(args[i]) ||
126              args[i].short_name == 0 || args[i].long_name == NULL) {
127               printf(".Op ");
128 
129               if(args[i].short_name) {
130                     print_arg(buf, sizeof(buf), 1, 0, args + i, i18n);
131                     printf("Fl %c%s", args[i].short_name, buf);
132                     if(args[i].long_name)
133                         printf(" | ");
134               }
135               if(args[i].long_name) {
136                     print_arg(buf, sizeof(buf), 1, 1, args + i, i18n);
137                     printf("Fl Fl %s%s%s",
138                            args[i].type == arg_negative_flag ? "no-" : "",
139                            args[i].long_name, buf);
140               }
141               printf("\n");
142           } else {
143               print_arg(buf, sizeof(buf), 1, 0, args + i, i18n);
144               printf(".Oo Fl %c%s \\*(Ba Xo\n", args[i].short_name, buf);
145               print_arg(buf, sizeof(buf), 1, 1, args + i, i18n);
146               printf(".Fl Fl %s%s\n.Xc\n.Oc\n", args[i].long_name, buf);
147           }
148     /*
149               if(args[i].type == arg_strings)
150                     fprintf (stderr, "...");
151                     */
152     }
153     if (extra_string && *extra_string)
154           printf (".Ar %s\n", extra_string);
155     printf(".Sh DESCRIPTION\n");
156     printf("Supported options:\n");
157     printf(".Bl -tag -width Ds\n");
158     for(i = 0; i < num_args; i++){
159           printf(".It Xo\n");
160           if(args[i].short_name){
161               printf(".Fl %c", args[i].short_name);
162               print_arg(buf, sizeof(buf), 1, 0, args + i, i18n);
163               printf("%s", buf);
164               if(args[i].long_name)
165                     printf(" ,");
166               printf("\n");
167           }
168           if(args[i].long_name){
169               printf(".Fl Fl %s%s",
170                        args[i].type == arg_negative_flag ? "no-" : "",
171                        args[i].long_name);
172               print_arg(buf, sizeof(buf), 1, 1, args + i, i18n);
173               printf("%s\n", buf);
174           }
175           printf(".Xc\n");
176           if(args[i].help)
177               printf("%s\n", args[i].help);
178     /*
179               if(args[i].type == arg_strings)
180                     fprintf (stderr, "...");
181                     */
182     }
183     printf(".El\n");
184     printf(".\\\".Sh ENVIRONMENT\n");
185     printf(".\\\".Sh FILES\n");
186     printf(".\\\".Sh EXAMPLES\n");
187     printf(".\\\".Sh DIAGNOSTICS\n");
188     printf(".\\\".Sh SEE ALSO\n");
189     printf(".\\\".Sh STANDARDS\n");
190     printf(".\\\".Sh HISTORY\n");
191     printf(".\\\".Sh AUTHORS\n");
192     printf(".\\\".Sh BUGS\n");
193 }
194 
195 static int
check_column(FILE * f,int col,int len,int columns)196 check_column(FILE *f, int col, int len, int columns)
197 {
198     if(col + len > columns) {
199           fprintf(f, "\n");
200           col = fprintf(f, "  ");
201     }
202     return col;
203 }
204 
205 static char *
builtin_i18n(const char * str)206 builtin_i18n(const char *str)
207 {
208     return rk_UNCONST(str);
209 }
210 
211 ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
arg_printusage(struct getargs * args,size_t num_args,const char * progname,const char * extra_string)212 arg_printusage (struct getargs *args,
213                     size_t num_args,
214                     const char *progname,
215                     const char *extra_string)
216 {
217     arg_printusage_i18n(args, num_args, "Usage",
218                               progname, extra_string, builtin_i18n);
219 }
220 
221 ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
arg_printusage_i18n(struct getargs * args,size_t num_args,const char * usage,const char * progname,const char * extra_string,char * (* i18n)(const char *))222 arg_printusage_i18n (struct getargs *args,
223                          size_t num_args,
224                          const char *usage,
225                          const char *progname,
226                          const char *extra_string,
227                          char *(*i18n)(const char *))
228 {
229     size_t i, max_len = 0;
230     char buf[128];
231     int col = 0, columns;
232 
233     if (progname == NULL)
234           progname = getprogname();
235 
236     if (i18n == NULL)
237           i18n = builtin_i18n;
238 
239     if(getenv("GETARGMANDOC")){
240           mandoc_template(args, num_args, progname, extra_string, i18n);
241           return;
242     }
243     if(get_window_size(2, NULL, &columns) == -1)
244           columns = 80;
245     col = 0;
246     col += fprintf (stderr, "%s: %s", usage, progname);
247     buf[0] = '\0';
248     for (i = 0; i < num_args; ++i) {
249           if(args[i].short_name && ISFLAG(args[i])) {
250               char s[2];
251               if(buf[0] == '\0')
252                     strlcpy(buf, "[-", sizeof(buf));
253               s[0] = args[i].short_name;
254               s[1] = '\0';
255               strlcat(buf, s, sizeof(buf));
256           }
257     }
258     if(buf[0] != '\0') {
259           strlcat(buf, "]", sizeof(buf));
260           col = check_column(stderr, col, strlen(buf) + 1, columns);
261           col += fprintf(stderr, " %s", buf);
262     }
263 
264     for (i = 0; i < num_args; ++i) {
265           size_t len = 0;
266 
267           if (args[i].long_name) {
268               buf[0] = '\0';
269               strlcat(buf, "[--", sizeof(buf));
270               len += 2;
271               if(args[i].type == arg_negative_flag) {
272                     strlcat(buf, "no-", sizeof(buf));
273                     len += 3;
274               }
275               strlcat(buf, args[i].long_name, sizeof(buf));
276               len += strlen(args[i].long_name);
277               len += print_arg(buf + strlen(buf), sizeof(buf) - strlen(buf),
278                                    0, 1, &args[i], i18n);
279               strlcat(buf, "]", sizeof(buf));
280               if(args[i].type == arg_strings)
281                     strlcat(buf, "...", sizeof(buf));
282               col = check_column(stderr, col, strlen(buf) + 1, columns);
283               col += fprintf(stderr, " %s", buf);
284           }
285           if (args[i].short_name && !ISFLAG(args[i])) {
286               snprintf(buf, sizeof(buf), "[-%c", args[i].short_name);
287               len += 2;
288               len += print_arg(buf + strlen(buf), sizeof(buf) - strlen(buf),
289                                    0, 0, &args[i], i18n);
290               strlcat(buf, "]", sizeof(buf));
291               if(args[i].type == arg_strings)
292                     strlcat(buf, "...", sizeof(buf));
293               col = check_column(stderr, col, strlen(buf) + 1, columns);
294               col += fprintf(stderr, " %s", buf);
295           }
296           if (args[i].long_name && args[i].short_name)
297               len += 2; /* ", " */
298           max_len = max(max_len, len);
299     }
300     if (extra_string) {
301           check_column(stderr, col, strlen(extra_string) + 1, columns);
302           fprintf (stderr, " %s\n", extra_string);
303     } else
304           fprintf (stderr, "\n");
305     for (i = 0; i < num_args; ++i) {
306           if (args[i].help) {
307               size_t count = 0;
308 
309               if (args[i].short_name) {
310                     count += fprintf (stderr, "-%c", args[i].short_name);
311                     print_arg (buf, sizeof(buf), 0, 0, &args[i], i18n);
312                     count += fprintf(stderr, "%s", buf);
313               }
314               if (args[i].short_name && args[i].long_name)
315                     count += fprintf (stderr, ", ");
316               if (args[i].long_name) {
317                     count += fprintf (stderr, "--");
318                     if (args[i].type == arg_negative_flag)
319                         count += fprintf (stderr, "no-");
320                     count += fprintf (stderr, "%s", args[i].long_name);
321                     print_arg (buf, sizeof(buf), 0, 1, &args[i], i18n);
322                     count += fprintf(stderr, "%s", buf);
323               }
324               while(count++ <= max_len)
325                     putc (' ', stderr);
326               fprintf (stderr, "%s\n", (*i18n)(args[i].help));
327           }
328     }
329 }
330 
331 static int
add_string(getarg_strings * s,char * value)332 add_string(getarg_strings *s, char *value)
333 {
334     char **strings;
335 
336     strings = realloc(s->strings, (s->num_strings + 1) * sizeof(*s->strings));
337     if (strings == NULL) {
338           free(s->strings);
339           s->strings = NULL;
340           s->num_strings = 0;
341           return ENOMEM;
342     }
343     s->strings = strings;
344     s->strings[s->num_strings] = value;
345     s->num_strings++;
346     return 0;
347 }
348 
349 static int
arg_match_long(struct getargs * args,size_t num_args,char * argv,int argc,char ** rargv,int * goptind)350 arg_match_long(struct getargs *args, size_t num_args,
351                  char *argv, int argc, char **rargv, int *goptind)
352 {
353     size_t i;
354     char *goptarg = NULL;
355     int negate = 0;
356     int partial_match = 0;
357     struct getargs *partial = NULL;
358     struct getargs *current = NULL;
359     int argv_len;
360     char *p;
361     int p_len;
362 
363     argv_len = strlen(argv);
364     p = strchr (argv, '=');
365     if (p != NULL)
366           argv_len = p - argv;
367 
368     for (i = 0; i < num_args; ++i) {
369           if(args[i].long_name) {
370               int len = strlen(args[i].long_name);
371               p = argv;
372               p_len = argv_len;
373               negate = 0;
374 
375               for (;;) {
376                     if (strncmp (args[i].long_name, p, p_len) == 0) {
377                         if(p_len == len)
378                               current = &args[i];
379                         else {
380                               ++partial_match;
381                               partial = &args[i];
382                         }
383                         goptarg  = p + p_len;
384                     } else if (ISFLAG(args[i]) && strncmp (p, "no-", 3) == 0) {
385                         negate = !negate;
386                         p += 3;
387                         p_len -= 3;
388                         continue;
389                     }
390                     break;
391               }
392               if (current)
393                     break;
394           }
395     }
396     if (current == NULL) {
397           if (partial_match == 1)
398               current = partial;
399           else
400               return ARG_ERR_NO_MATCH;
401     }
402 
403     if(*goptarg == '\0'
404        && !ISFLAG(*current)
405        && current->type != arg_collect
406        && current->type != arg_counter)
407           return ARG_ERR_NO_MATCH;
408     switch(current->type){
409     case arg_integer:
410     {
411           int tmp;
412           if(sscanf(goptarg + 1, "%d", &tmp) != 1)
413               return ARG_ERR_BAD_ARG;
414           *(int*)current->value = tmp;
415           return 0;
416     }
417     case arg_string:
418     {
419           *(char**)current->value = goptarg + 1;
420           return 0;
421     }
422     case arg_strings:
423     {
424           return add_string((getarg_strings*)current->value, goptarg + 1);
425     }
426     case arg_flag:
427     case arg_negative_flag:
428     {
429           int *flag = current->value;
430           if(*goptarg == '\0' ||
431              strcmp(goptarg + 1, "yes") == 0 ||
432              strcmp(goptarg + 1, "true") == 0){
433               *flag = !negate;
434               return 0;
435           } else if (*goptarg && strcmp(goptarg + 1, "maybe") == 0) {
436               *flag = rk_random() & 1;
437           } else {
438               *flag = negate;
439               return 0;
440           }
441           return ARG_ERR_BAD_ARG;
442     }
443     case arg_counter :
444     {
445           int val;
446 
447           if (*goptarg == '\0')
448               val = 1;
449           else if(sscanf(goptarg + 1, "%d", &val) != 1)
450               return ARG_ERR_BAD_ARG;
451           *(int *)current->value += val;
452           return 0;
453     }
454     case arg_double:
455     {
456           double tmp;
457           if(sscanf(goptarg + 1, "%lf", &tmp) != 1)
458               return ARG_ERR_BAD_ARG;
459           *(double*)current->value = tmp;
460           return 0;
461     }
462     case arg_collect:{
463           struct getarg_collect_info *c = current->value;
464           int o = argv - rargv[*goptind];
465           return (*c->func)(FALSE, argc, rargv, goptind, &o, c->data);
466     }
467 
468     default:
469           abort ();
470           UNREACHABLE(return 0);
471     }
472 }
473 
474 static int
arg_match_short(struct getargs * args,size_t num_args,char * argv,int argc,char ** rargv,int * goptind)475 arg_match_short (struct getargs *args, size_t num_args,
476                      char *argv, int argc, char **rargv, int *goptind)
477 {
478     size_t j, k;
479 
480     for(j = 1; j > 0 && j < strlen(rargv[*goptind]); j++) {
481           for(k = 0; k < num_args; k++) {
482               char *goptarg;
483 
484               if(args[k].short_name == 0)
485                     continue;
486               if(argv[j] == args[k].short_name) {
487                     if(args[k].type == arg_flag) {
488                         *(int*)args[k].value = 1;
489                         break;
490                     }
491                     if(args[k].type == arg_negative_flag) {
492                         *(int*)args[k].value = 0;
493                         break;
494                     }
495                     if(args[k].type == arg_counter) {
496                         ++*(int *)args[k].value;
497                         break;
498                     }
499                     if(args[k].type == arg_collect) {
500                         struct getarg_collect_info *c = args[k].value;
501                         int a = (int)j;
502 
503                         if((*c->func)(TRUE, argc, rargv, goptind, &a, c->data))
504                               return ARG_ERR_BAD_ARG;
505                         j = a;
506                         break;
507                     }
508 
509                     if(argv[j + 1])
510                         goptarg = &argv[j + 1];
511                     else {
512                         ++*goptind;
513                         goptarg = rargv[*goptind];
514                     }
515                     if(goptarg == NULL) {
516                         --*goptind;
517                         return ARG_ERR_NO_ARG;
518                     }
519                     if(args[k].type == arg_integer) {
520                         int tmp;
521                         if(sscanf(goptarg, "%d", &tmp) != 1)
522                               return ARG_ERR_BAD_ARG;
523                         *(int*)args[k].value = tmp;
524                         return 0;
525                     } else if(args[k].type == arg_string) {
526                         *(char**)args[k].value = goptarg;
527                         return 0;
528                     } else if(args[k].type == arg_strings) {
529                         return add_string((getarg_strings*)args[k].value, goptarg);
530                     } else if(args[k].type == arg_double) {
531                         double tmp;
532                         if(sscanf(goptarg, "%lf", &tmp) != 1)
533                               return ARG_ERR_BAD_ARG;
534                         *(double*)args[k].value = tmp;
535                         return 0;
536                     }
537                     return ARG_ERR_BAD_ARG;
538               }
539           }
540           if (k == num_args)
541               return ARG_ERR_NO_MATCH;
542     }
543     return 0;
544 }
545 
546 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
getarg(struct getargs * args,size_t num_args,int argc,char ** argv,int * goptind)547 getarg(struct getargs *args, size_t num_args,
548        int argc, char **argv, int *goptind)
549 {
550     int i;
551     int ret = 0;
552 
553     rk_random_init();
554     (*goptind)++;
555     for(i = *goptind; i < argc; i++) {
556           if(argv[i][0] != '-')
557               break;
558           if(argv[i][1] == '-'){
559               if(argv[i][2] == 0){
560                     i++;
561                     break;
562               }
563               ret = arg_match_long (args, num_args, argv[i] + 2,
564                                           argc, argv, &i);
565           } else {
566               ret = arg_match_short (args, num_args, argv[i],
567                                            argc, argv, &i);
568           }
569           if(ret)
570               break;
571     }
572     *goptind = i;
573     return ret;
574 }
575 
576 ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
free_getarg_strings(getarg_strings * s)577 free_getarg_strings (getarg_strings *s)
578 {
579     free (s->strings);
580 }
581 
582 #if TEST
583 int foo_flag = 2;
584 int flag1 = 0;
585 int flag2 = 0;
586 int bar_int;
587 char *baz_string;
588 
589 struct getargs args[] = {
590     { NULL, '1', arg_flag, &flag1, "one", NULL },
591     { NULL, '2', arg_flag, &flag2, "two", NULL },
592     { "foo", 'f', arg_negative_flag, &foo_flag, "foo", NULL },
593     { "bar", 'b', arg_integer, &bar_int, "bar", "seconds"},
594     { "baz", 'x', arg_string, &baz_string, "baz", "name" },
595 };
596 
main(int argc,char ** argv)597 int main(int argc, char **argv)
598 {
599     int goptind = 0;
600     while (getarg(args, 5, argc, argv, &goptind))
601           printf("Bad arg: %s\n", argv[goptind]);
602     printf("flag1 = %d\n", flag1);
603     printf("flag2 = %d\n", flag2);
604     printf("foo_flag = %d\n", foo_flag);
605     printf("bar_int = %d\n", bar_int);
606     printf("baz_flag = %s\n", baz_string);
607     arg_printusage (args, 5, argv[0], "nothing here");
608 }
609 #endif
610