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