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