Fix error handling in RAND_DRBG_set
[openssl.git] / apps / opt.c
1 /*
2  * Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9 #include "apps.h"
10 #include <string.h>
11 #if !defined(OPENSSL_SYS_MSDOS)
12 # include OPENSSL_UNISTD
13 #endif
14
15 #include <stdlib.h>
16 #include <errno.h>
17 #include <ctype.h>
18 #include <limits.h>
19 #include <openssl/bio.h>
20 #include <openssl/x509v3.h>
21
22 #define MAX_OPT_HELP_WIDTH 30
23 const char OPT_HELP_STR[] = "--";
24 const char OPT_MORE_STR[] = "---";
25
26 /* Our state */
27 static char **argv;
28 static int argc;
29 static int opt_index;
30 static char *arg;
31 static char *flag;
32 static char *dunno;
33 static const OPTIONS *unknown;
34 static const OPTIONS *opts;
35 static char prog[40];
36
37 /*
38  * Return the simple name of the program; removing various platform gunk.
39  */
40 #if defined(OPENSSL_SYS_WIN32)
41 char *opt_progname(const char *argv0)
42 {
43     size_t i, n;
44     const char *p;
45     char *q;
46
47     /* find the last '/', '\' or ':' */
48     for (p = argv0 + strlen(argv0); --p > argv0;)
49         if (*p == '/' || *p == '\\' || *p == ':') {
50             p++;
51             break;
52         }
53
54     /* Strip off trailing nonsense. */
55     n = strlen(p);
56     if (n > 4 &&
57         (strcmp(&p[n - 4], ".exe") == 0 || strcmp(&p[n - 4], ".EXE") == 0))
58         n -= 4;
59
60     /* Copy over the name, in lowercase. */
61     if (n > sizeof(prog) - 1)
62         n = sizeof(prog) - 1;
63     for (q = prog, i = 0; i < n; i++, p++)
64         *q++ = tolower((unsigned char)*p);
65     *q = '\0';
66     return prog;
67 }
68
69 #elif defined(OPENSSL_SYS_VMS)
70
71 char *opt_progname(const char *argv0)
72 {
73     const char *p, *q;
74
75     /* Find last special character sys:[foo.bar]openssl */
76     for (p = argv0 + strlen(argv0); --p > argv0;)
77         if (*p == ':' || *p == ']' || *p == '>') {
78             p++;
79             break;
80         }
81
82     q = strrchr(p, '.');
83     strncpy(prog, p, sizeof(prog) - 1);
84     prog[sizeof(prog) - 1] = '\0';
85     if (q != NULL && q - p < sizeof(prog))
86         prog[q - p] = '\0';
87     return prog;
88 }
89
90 #else
91
92 char *opt_progname(const char *argv0)
93 {
94     const char *p;
95
96     /* Could use strchr, but this is like the ones above. */
97     for (p = argv0 + strlen(argv0); --p > argv0;)
98         if (*p == '/') {
99             p++;
100             break;
101         }
102     strncpy(prog, p, sizeof(prog) - 1);
103     prog[sizeof(prog) - 1] = '\0';
104     return prog;
105 }
106 #endif
107
108 char *opt_getprog(void)
109 {
110     return prog;
111 }
112
113 /* Set up the arg parsing. */
114 char *opt_init(int ac, char **av, const OPTIONS *o)
115 {
116     /* Store state. */
117     argc = ac;
118     argv = av;
119     opt_index = 1;
120     opts = o;
121     opt_progname(av[0]);
122     unknown = NULL;
123
124     for (; o->name; ++o) {
125 #ifndef NDEBUG
126         const OPTIONS *next;
127         int duplicated, i;
128 #endif
129
130         if (o->name == OPT_HELP_STR || o->name == OPT_MORE_STR)
131             continue;
132 #ifndef NDEBUG
133         i = o->valtype;
134
135         /* Make sure options are legit. */
136         assert(o->name[0] != '-');
137         assert(o->retval > 0);
138         switch (i) {
139         case   0: case '-': case '/': case '<': case '>': case 'E': case 'F':
140         case 'M': case 'U': case 'f': case 'l': case 'n': case 'p': case 's':
141         case 'u': case 'c':
142             break;
143         default:
144             assert(0);
145         }
146
147         /* Make sure there are no duplicates. */
148         for (next = o + 1; next->name; ++next) {
149             /*
150              * Some compilers inline strcmp and the assert string is too long.
151              */
152             duplicated = strcmp(o->name, next->name) == 0;
153             assert(!duplicated);
154         }
155 #endif
156         if (o->name[0] == '\0') {
157             assert(unknown == NULL);
158             unknown = o;
159             assert(unknown->valtype == 0 || unknown->valtype == '-');
160         }
161     }
162     return prog;
163 }
164
165 static OPT_PAIR formats[] = {
166     {"PEM/DER", OPT_FMT_PEMDER},
167     {"pkcs12", OPT_FMT_PKCS12},
168     {"smime", OPT_FMT_SMIME},
169     {"engine", OPT_FMT_ENGINE},
170     {"msblob", OPT_FMT_MSBLOB},
171     {"nss", OPT_FMT_NSS},
172     {"text", OPT_FMT_TEXT},
173     {"http", OPT_FMT_HTTP},
174     {"pvk", OPT_FMT_PVK},
175     {NULL}
176 };
177
178 /* Print an error message about a failed format parse. */
179 int opt_format_error(const char *s, unsigned long flags)
180 {
181     OPT_PAIR *ap;
182
183     if (flags == OPT_FMT_PEMDER) {
184         BIO_printf(bio_err, "%s: Bad format \"%s\"; must be pem or der\n",
185                    prog, s);
186     } else {
187         BIO_printf(bio_err, "%s: Bad format \"%s\"; must be one of:\n",
188                    prog, s);
189         for (ap = formats; ap->name; ap++)
190             if (flags & ap->retval)
191                 BIO_printf(bio_err, "   %s\n", ap->name);
192     }
193     return 0;
194 }
195
196 /* Parse a format string, put it into *result; return 0 on failure, else 1. */
197 int opt_format(const char *s, unsigned long flags, int *result)
198 {
199     switch (*s) {
200     default:
201         return 0;
202     case 'D':
203     case 'd':
204         if ((flags & OPT_FMT_PEMDER) == 0)
205             return opt_format_error(s, flags);
206         *result = FORMAT_ASN1;
207         break;
208     case 'T':
209     case 't':
210         if ((flags & OPT_FMT_TEXT) == 0)
211             return opt_format_error(s, flags);
212         *result = FORMAT_TEXT;
213         break;
214     case 'N':
215     case 'n':
216         if ((flags & OPT_FMT_NSS) == 0)
217             return opt_format_error(s, flags);
218         if (strcmp(s, "NSS") != 0 && strcmp(s, "nss") != 0)
219             return opt_format_error(s, flags);
220         *result = FORMAT_NSS;
221         break;
222     case 'S':
223     case 's':
224         if ((flags & OPT_FMT_SMIME) == 0)
225             return opt_format_error(s, flags);
226         *result = FORMAT_SMIME;
227         break;
228     case 'M':
229     case 'm':
230         if ((flags & OPT_FMT_MSBLOB) == 0)
231             return opt_format_error(s, flags);
232         *result = FORMAT_MSBLOB;
233         break;
234     case 'E':
235     case 'e':
236         if ((flags & OPT_FMT_ENGINE) == 0)
237             return opt_format_error(s, flags);
238         *result = FORMAT_ENGINE;
239         break;
240     case 'H':
241     case 'h':
242         if ((flags & OPT_FMT_HTTP) == 0)
243             return opt_format_error(s, flags);
244         *result = FORMAT_HTTP;
245         break;
246     case '1':
247         if ((flags & OPT_FMT_PKCS12) == 0)
248             return opt_format_error(s, flags);
249         *result = FORMAT_PKCS12;
250         break;
251     case 'P':
252     case 'p':
253         if (s[1] == '\0' || strcmp(s, "PEM") == 0 || strcmp(s, "pem") == 0) {
254             if ((flags & OPT_FMT_PEMDER) == 0)
255                 return opt_format_error(s, flags);
256             *result = FORMAT_PEM;
257         } else if (strcmp(s, "PVK") == 0 || strcmp(s, "pvk") == 0) {
258             if ((flags & OPT_FMT_PVK) == 0)
259                 return opt_format_error(s, flags);
260             *result = FORMAT_PVK;
261         } else if (strcmp(s, "P12") == 0 || strcmp(s, "p12") == 0
262                    || strcmp(s, "PKCS12") == 0 || strcmp(s, "pkcs12") == 0) {
263             if ((flags & OPT_FMT_PKCS12) == 0)
264                 return opt_format_error(s, flags);
265             *result = FORMAT_PKCS12;
266         } else {
267             return 0;
268         }
269         break;
270     }
271     return 1;
272 }
273
274 /* Parse a cipher name, put it in *EVP_CIPHER; return 0 on failure, else 1. */
275 int opt_cipher(const char *name, const EVP_CIPHER **cipherp)
276 {
277     *cipherp = EVP_get_cipherbyname(name);
278     if (*cipherp != NULL)
279         return 1;
280     BIO_printf(bio_err, "%s: Unrecognized flag %s\n", prog, name);
281     return 0;
282 }
283
284 /*
285  * Parse message digest name, put it in *EVP_MD; return 0 on failure, else 1.
286  */
287 int opt_md(const char *name, const EVP_MD **mdp)
288 {
289     *mdp = EVP_get_digestbyname(name);
290     if (*mdp != NULL)
291         return 1;
292     BIO_printf(bio_err, "%s: Unrecognized flag %s\n", prog, name);
293     return 0;
294 }
295
296 /* Look through a list of name/value pairs. */
297 int opt_pair(const char *name, const OPT_PAIR* pairs, int *result)
298 {
299     const OPT_PAIR *pp;
300
301     for (pp = pairs; pp->name; pp++)
302         if (strcmp(pp->name, name) == 0) {
303             *result = pp->retval;
304             return 1;
305         }
306     BIO_printf(bio_err, "%s: Value must be one of:\n", prog);
307     for (pp = pairs; pp->name; pp++)
308         BIO_printf(bio_err, "\t%s\n", pp->name);
309     return 0;
310 }
311
312 /* Parse an int, put it into *result; return 0 on failure, else 1. */
313 int opt_int(const char *value, int *result)
314 {
315     long l;
316
317     if (!opt_long(value, &l))
318         return 0;
319     *result = (int)l;
320     if (*result != l) {
321         BIO_printf(bio_err, "%s: Value \"%s\" outside integer range\n",
322                    prog, value);
323         return 0;
324     }
325     return 1;
326 }
327
328 static void opt_number_error(const char *v)
329 {
330     size_t i = 0;
331     struct strstr_pair_st {
332         char *prefix;
333         char *name;
334     } b[] = {
335         {"0x", "a hexadecimal"},
336         {"0X", "a hexadecimal"},
337         {"0", "an octal"}
338     };
339
340     for (i = 0; i < OSSL_NELEM(b); i++) {
341         if (strncmp(v, b[i].prefix, strlen(b[i].prefix)) == 0) {
342             BIO_printf(bio_err,
343                        "%s: Can't parse \"%s\" as %s number\n",
344                        prog, v, b[i].name);
345             return;
346         }
347     }
348     BIO_printf(bio_err, "%s: Can't parse \"%s\" as a number\n", prog, v);
349     return;
350 }
351
352 /* Parse a long, put it into *result; return 0 on failure, else 1. */
353 int opt_long(const char *value, long *result)
354 {
355     int oerrno = errno;
356     long l;
357     char *endp;
358
359     errno = 0;
360     l = strtol(value, &endp, 0);
361     if (*endp
362             || endp == value
363             || ((l == LONG_MAX || l == LONG_MIN) && errno == ERANGE)
364             || (l == 0 && errno != 0)) {
365         opt_number_error(value);
366         errno = oerrno;
367         return 0;
368     }
369     *result = l;
370     errno = oerrno;
371     return 1;
372 }
373
374 #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L && \
375     defined(INTMAX_MAX) && defined(UINTMAX_MAX)
376
377 /* Parse an intmax_t, put it into *result; return 0 on failure, else 1. */
378 int opt_imax(const char *value, intmax_t *result)
379 {
380     int oerrno = errno;
381     intmax_t m;
382     char *endp;
383
384     errno = 0;
385     m = strtoimax(value, &endp, 0);
386     if (*endp
387             || endp == value
388             || ((m == INTMAX_MAX || m == INTMAX_MIN) && errno == ERANGE)
389             || (m == 0 && errno != 0)) {
390         opt_number_error(value);
391         errno = oerrno;
392         return 0;
393     }
394     *result = m;
395     errno = oerrno;
396     return 1;
397 }
398
399 /* Parse a uintmax_t, put it into *result; return 0 on failure, else 1. */
400 int opt_umax(const char *value, uintmax_t *result)
401 {
402     int oerrno = errno;
403     uintmax_t m;
404     char *endp;
405
406     errno = 0;
407     m = strtoumax(value, &endp, 0);
408     if (*endp
409             || endp == value
410             || (m == UINTMAX_MAX && errno == ERANGE)
411             || (m == 0 && errno != 0)) {
412         opt_number_error(value);
413         errno = oerrno;
414         return 0;
415     }
416     *result = m;
417     errno = oerrno;
418     return 1;
419 }
420 #endif
421
422 /*
423  * Parse an unsigned long, put it into *result; return 0 on failure, else 1.
424  */
425 int opt_ulong(const char *value, unsigned long *result)
426 {
427     int oerrno = errno;
428     char *endptr;
429     unsigned long l;
430
431     errno = 0;
432     l = strtoul(value, &endptr, 0);
433     if (*endptr
434             || endptr == value
435             || ((l == ULONG_MAX) && errno == ERANGE)
436             || (l == 0 && errno != 0)) {
437         opt_number_error(value);
438         errno = oerrno;
439         return 0;
440     }
441     *result = l;
442     errno = oerrno;
443     return 1;
444 }
445
446 /*
447  * We pass opt as an int but cast it to "enum range" so that all the
448  * items in the OPT_V_ENUM enumeration are caught; this makes -Wswitch
449  * in gcc do the right thing.
450  */
451 enum range { OPT_V_ENUM };
452
453 int opt_verify(int opt, X509_VERIFY_PARAM *vpm)
454 {
455     int i;
456     ossl_intmax_t t = 0;
457     ASN1_OBJECT *otmp;
458     X509_PURPOSE *xptmp;
459     const X509_VERIFY_PARAM *vtmp;
460
461     assert(vpm != NULL);
462     assert(opt > OPT_V__FIRST);
463     assert(opt < OPT_V__LAST);
464
465     switch ((enum range)opt) {
466     case OPT_V__FIRST:
467     case OPT_V__LAST:
468         return 0;
469     case OPT_V_POLICY:
470         otmp = OBJ_txt2obj(opt_arg(), 0);
471         if (otmp == NULL) {
472             BIO_printf(bio_err, "%s: Invalid Policy %s\n", prog, opt_arg());
473             return 0;
474         }
475         X509_VERIFY_PARAM_add0_policy(vpm, otmp);
476         break;
477     case OPT_V_PURPOSE:
478         /* purpose name -> purpose index */
479         i = X509_PURPOSE_get_by_sname(opt_arg());
480         if (i < 0) {
481             BIO_printf(bio_err, "%s: Invalid purpose %s\n", prog, opt_arg());
482             return 0;
483         }
484
485         /* purpose index -> purpose object */
486         xptmp = X509_PURPOSE_get0(i);
487
488         /* purpose object -> purpose value */
489         i = X509_PURPOSE_get_id(xptmp);
490
491         if (!X509_VERIFY_PARAM_set_purpose(vpm, i)) {
492             BIO_printf(bio_err,
493                        "%s: Internal error setting purpose %s\n",
494                        prog, opt_arg());
495             return 0;
496         }
497         break;
498     case OPT_V_VERIFY_NAME:
499         vtmp = X509_VERIFY_PARAM_lookup(opt_arg());
500         if (vtmp == NULL) {
501             BIO_printf(bio_err, "%s: Invalid verify name %s\n",
502                        prog, opt_arg());
503             return 0;
504         }
505         X509_VERIFY_PARAM_set1(vpm, vtmp);
506         break;
507     case OPT_V_VERIFY_DEPTH:
508         i = atoi(opt_arg());
509         if (i >= 0)
510             X509_VERIFY_PARAM_set_depth(vpm, i);
511         break;
512     case OPT_V_VERIFY_AUTH_LEVEL:
513         i = atoi(opt_arg());
514         if (i >= 0)
515             X509_VERIFY_PARAM_set_auth_level(vpm, i);
516         break;
517     case OPT_V_ATTIME:
518         if (!opt_imax(opt_arg(), &t))
519             return 0;
520         if (t != (time_t)t) {
521             BIO_printf(bio_err, "%s: epoch time out of range %s\n",
522                        prog, opt_arg());
523             return 0;
524         }
525         X509_VERIFY_PARAM_set_time(vpm, (time_t)t);
526         break;
527     case OPT_V_VERIFY_HOSTNAME:
528         if (!X509_VERIFY_PARAM_set1_host(vpm, opt_arg(), 0))
529             return 0;
530         break;
531     case OPT_V_VERIFY_EMAIL:
532         if (!X509_VERIFY_PARAM_set1_email(vpm, opt_arg(), 0))
533             return 0;
534         break;
535     case OPT_V_VERIFY_IP:
536         if (!X509_VERIFY_PARAM_set1_ip_asc(vpm, opt_arg()))
537             return 0;
538         break;
539     case OPT_V_IGNORE_CRITICAL:
540         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_IGNORE_CRITICAL);
541         break;
542     case OPT_V_ISSUER_CHECKS:
543         /* NOP, deprecated */
544         break;
545     case OPT_V_CRL_CHECK:
546         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_CRL_CHECK);
547         break;
548     case OPT_V_CRL_CHECK_ALL:
549         X509_VERIFY_PARAM_set_flags(vpm,
550                                     X509_V_FLAG_CRL_CHECK |
551                                     X509_V_FLAG_CRL_CHECK_ALL);
552         break;
553     case OPT_V_POLICY_CHECK:
554         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_POLICY_CHECK);
555         break;
556     case OPT_V_EXPLICIT_POLICY:
557         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_EXPLICIT_POLICY);
558         break;
559     case OPT_V_INHIBIT_ANY:
560         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_INHIBIT_ANY);
561         break;
562     case OPT_V_INHIBIT_MAP:
563         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_INHIBIT_MAP);
564         break;
565     case OPT_V_X509_STRICT:
566         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_X509_STRICT);
567         break;
568     case OPT_V_EXTENDED_CRL:
569         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_EXTENDED_CRL_SUPPORT);
570         break;
571     case OPT_V_USE_DELTAS:
572         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_USE_DELTAS);
573         break;
574     case OPT_V_POLICY_PRINT:
575         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_NOTIFY_POLICY);
576         break;
577     case OPT_V_CHECK_SS_SIG:
578         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_CHECK_SS_SIGNATURE);
579         break;
580     case OPT_V_TRUSTED_FIRST:
581         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_TRUSTED_FIRST);
582         break;
583     case OPT_V_SUITEB_128_ONLY:
584         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_SUITEB_128_LOS_ONLY);
585         break;
586     case OPT_V_SUITEB_128:
587         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_SUITEB_128_LOS);
588         break;
589     case OPT_V_SUITEB_192:
590         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_SUITEB_192_LOS);
591         break;
592     case OPT_V_PARTIAL_CHAIN:
593         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_PARTIAL_CHAIN);
594         break;
595     case OPT_V_NO_ALT_CHAINS:
596         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_NO_ALT_CHAINS);
597         break;
598     case OPT_V_NO_CHECK_TIME:
599         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_NO_CHECK_TIME);
600         break;
601     case OPT_V_ALLOW_PROXY_CERTS:
602         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_ALLOW_PROXY_CERTS);
603         break;
604     }
605     return 1;
606
607 }
608
609 /*
610  * Parse the next flag (and value if specified), return 0 if done, -1 on
611  * error, otherwise the flag's retval.
612  */
613 int opt_next(void)
614 {
615     char *p;
616     const OPTIONS *o;
617     int ival;
618     long lval;
619     unsigned long ulval;
620     ossl_intmax_t imval;
621     ossl_uintmax_t umval;
622
623     /* Look at current arg; at end of the list? */
624     arg = NULL;
625     p = argv[opt_index];
626     if (p == NULL)
627         return 0;
628
629     /* If word doesn't start with a -, we're done. */
630     if (*p != '-')
631         return 0;
632
633     /* Hit "--" ? We're done. */
634     opt_index++;
635     if (strcmp(p, "--") == 0)
636         return 0;
637
638     /* Allow -nnn and --nnn */
639     if (*++p == '-')
640         p++;
641     flag = p - 1;
642
643     /* If we have --flag=foo, snip it off */
644     if ((arg = strchr(p, '=')) != NULL)
645         *arg++ = '\0';
646     for (o = opts; o->name; ++o) {
647         /* If not this option, move on to the next one. */
648         if (strcmp(p, o->name) != 0)
649             continue;
650
651         /* If it doesn't take a value, make sure none was given. */
652         if (o->valtype == 0 || o->valtype == '-') {
653             if (arg) {
654                 BIO_printf(bio_err,
655                            "%s: Option -%s does not take a value\n", prog, p);
656                 return -1;
657             }
658             return o->retval;
659         }
660
661         /* Want a value; get the next param if =foo not used. */
662         if (arg == NULL) {
663             if (argv[opt_index] == NULL) {
664                 BIO_printf(bio_err,
665                            "%s: Option -%s needs a value\n", prog, o->name);
666                 return -1;
667             }
668             arg = argv[opt_index++];
669         }
670
671         /* Syntax-check value. */
672         switch (o->valtype) {
673         default:
674         case 's':
675             /* Just a string. */
676             break;
677         case '/':
678             if (app_isdir(arg) > 0)
679                 break;
680             BIO_printf(bio_err, "%s: Not a directory: %s\n", prog, arg);
681             return -1;
682         case '<':
683             /* Input file. */
684             break;
685         case '>':
686             /* Output file. */
687             break;
688         case 'p':
689         case 'n':
690             if (!opt_int(arg, &ival)
691                     || (o->valtype == 'p' && ival <= 0)) {
692                 BIO_printf(bio_err,
693                            "%s: Non-positive number \"%s\" for -%s\n",
694                            prog, arg, o->name);
695                 return -1;
696             }
697             break;
698         case 'M':
699             if (!opt_imax(arg, &imval)) {
700                 BIO_printf(bio_err,
701                            "%s: Invalid number \"%s\" for -%s\n",
702                            prog, arg, o->name);
703                 return -1;
704             }
705             break;
706         case 'U':
707             if (!opt_umax(arg, &umval)) {
708                 BIO_printf(bio_err,
709                            "%s: Invalid number \"%s\" for -%s\n",
710                            prog, arg, o->name);
711                 return -1;
712             }
713             break;
714         case 'l':
715             if (!opt_long(arg, &lval)) {
716                 BIO_printf(bio_err,
717                            "%s: Invalid number \"%s\" for -%s\n",
718                            prog, arg, o->name);
719                 return -1;
720             }
721             break;
722         case 'u':
723             if (!opt_ulong(arg, &ulval)) {
724                 BIO_printf(bio_err,
725                            "%s: Invalid number \"%s\" for -%s\n",
726                            prog, arg, o->name);
727                 return -1;
728             }
729             break;
730         case 'c':
731         case 'E':
732         case 'F':
733         case 'f':
734             if (opt_format(arg,
735                            o->valtype == 'c' ? OPT_FMT_PDS :
736                            o->valtype == 'E' ? OPT_FMT_PDE :
737                            o->valtype == 'F' ? OPT_FMT_PEMDER
738                            : OPT_FMT_ANY, &ival))
739                 break;
740             BIO_printf(bio_err,
741                        "%s: Invalid format \"%s\" for -%s\n",
742                        prog, arg, o->name);
743             return -1;
744         }
745
746         /* Return the flag value. */
747         return o->retval;
748     }
749     if (unknown != NULL) {
750         dunno = p;
751         return unknown->retval;
752     }
753     BIO_printf(bio_err, "%s: Option unknown option -%s\n", prog, p);
754     return -1;
755 }
756
757 /* Return the most recent flag parameter. */
758 char *opt_arg(void)
759 {
760     return arg;
761 }
762
763 /* Return the most recent flag. */
764 char *opt_flag(void)
765 {
766     return flag;
767 }
768
769 /* Return the unknown option. */
770 char *opt_unknown(void)
771 {
772     return dunno;
773 }
774
775 /* Return the rest of the arguments after parsing flags. */
776 char **opt_rest(void)
777 {
778     return &argv[opt_index];
779 }
780
781 /* How many items in remaining args? */
782 int opt_num_rest(void)
783 {
784     int i = 0;
785     char **pp;
786
787     for (pp = opt_rest(); *pp; pp++, i++)
788         continue;
789     return i;
790 }
791
792 /* Return a string describing the parameter type. */
793 static const char *valtype2param(const OPTIONS *o)
794 {
795     switch (o->valtype) {
796     case 0:
797     case '-':
798         return "";
799     case 's':
800         return "val";
801     case '/':
802         return "dir";
803     case '<':
804         return "infile";
805     case '>':
806         return "outfile";
807     case 'p':
808         return "+int";
809     case 'n':
810         return "int";
811     case 'l':
812         return "long";
813     case 'u':
814         return "ulong";
815     case 'E':
816         return "PEM|DER|ENGINE";
817     case 'F':
818         return "PEM|DER";
819     case 'f':
820         return "format";
821     case 'M':
822         return "intmax";
823     case 'U':
824         return "uintmax";
825     }
826     return "parm";
827 }
828
829 void opt_help(const OPTIONS *list)
830 {
831     const OPTIONS *o;
832     int i;
833     int standard_prolog;
834     int width = 5;
835     char start[80 + 1];
836     char *p;
837     const char *help;
838
839     /* Starts with its own help message? */
840     standard_prolog = list[0].name != OPT_HELP_STR;
841
842     /* Find the widest help. */
843     for (o = list; o->name; o++) {
844         if (o->name == OPT_MORE_STR)
845             continue;
846         i = 2 + (int)strlen(o->name);
847         if (o->valtype != '-')
848             i += 1 + strlen(valtype2param(o));
849         if (i < MAX_OPT_HELP_WIDTH && i > width)
850             width = i;
851         assert(i < (int)sizeof(start));
852     }
853
854     if (standard_prolog)
855         BIO_printf(bio_err, "Usage: %s [options]\nValid options are:\n",
856                    prog);
857
858     /* Now let's print. */
859     for (o = list; o->name; o++) {
860         help = o->helpstr ? o->helpstr : "(No additional info)";
861         if (o->name == OPT_HELP_STR) {
862             BIO_printf(bio_err, help, prog);
863             continue;
864         }
865
866         /* Pad out prefix */
867         memset(start, ' ', sizeof(start) - 1);
868         start[sizeof(start) - 1] = '\0';
869
870         if (o->name == OPT_MORE_STR) {
871             /* Continuation of previous line; pad and print. */
872             start[width] = '\0';
873             BIO_printf(bio_err, "%s  %s\n", start, help);
874             continue;
875         }
876
877         /* Build up the "-flag [param]" part. */
878         p = start;
879         *p++ = ' ';
880         *p++ = '-';
881         if (o->name[0])
882             p += strlen(strcpy(p, o->name));
883         else
884             *p++ = '*';
885         if (o->valtype != '-') {
886             *p++ = ' ';
887             p += strlen(strcpy(p, valtype2param(o)));
888         }
889         *p = ' ';
890         if ((int)(p - start) >= MAX_OPT_HELP_WIDTH) {
891             *p = '\0';
892             BIO_printf(bio_err, "%s\n", start);
893             memset(start, ' ', sizeof(start));
894         }
895         start[width] = '\0';
896         BIO_printf(bio_err, "%s  %s\n", start, help);
897     }
898 }