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