source: EcnlProtoTool/trunk/openssl-1.1.0e/apps/opt.c@ 331

Last change on this file since 331 was 331, checked in by coas-nagasima, 6 years ago

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