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