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)
  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
 101     /* Copy over the name, in lowercase. */
 102     if (n > sizeof prog - 1)
 103         n = sizeof prog - 1;
 104     for (q = prog, i = 0; i < n; i++, p++)
 105         *q++ = isupper(*p) ? tolower(*p) : *p;
 106     *q = '\0';
 107     return prog;
 108 }
 109
 110 #elif defined(OPENSSL_SYS_VMS)
 111
 112 char *opt_progname(const char *argv0)
 113 {
 114     const char *p, *q;
 115
 116     /* Find last special charcter sys:[foo.bar]openssl */
 117     for (p = argv0 + strlen(argv0); --p > argv0;)
 118         if (*p == ':' || *p == ']' || *p == '>') {
 119             p++;
 120             break;
 121         }
 122
 123     q = strrchr(p, '.');
 124     strncpy(prog, p, sizeof prog - 1);
 125     prog[sizeof prog - 1] = '\0';
 126     if (q != NULL && q - p < sizeof prog)
 127         prog[q - p] = '\0';
 128     return prog;
 129 }
 130
 131 #else
 132
 133 char *opt_progname(const char *argv0)
 134 {
 135     const char *p;
 136
 137     /* Could use strchr, but this is like the ones above. */
 138     for (p = argv0 + strlen(argv0); --p > argv0;)
 139         if (*p == '/') {
 140             p++;
 141             break;
 142         }
 143     strncpy(prog, p, sizeof prog - 1);
 144     prog[sizeof prog - 1] = '\0';
 145     return prog;
 146 }
 147 #endif
 148
 149 char *opt_getprog(void)
 150 {
 151     return prog;
 152 }
 153
 154 /* Set up the arg parsing. */
 155 char *opt_init(int ac, char **av, const OPTIONS *o)
 156 {
 157     /* Store state. */
 158     argc = ac;
 159     argv = av;
 160     opt_index = 1;
 161     opts = o;
 162     opt_progname(av[0]);
 163     unknown = NULL;
 164
 165     for (; o->name; ++o) {
 166 #ifndef NDEBUG
 167         const OPTIONS *next;
 168         int duplicated, i;
 169 #endif
 170
 171         if (o->name == OPT_HELP_STR || o->name == OPT_MORE_STR)
 172             continue;
 173 #ifndef NDEBUG
 174         i = o->valtype;
 175
 176         /* Make sure options are legit. */
 177         assert(o->name[0] != '-');
 178         assert(o->retval > 0);
 179         switch (i) {
 180         case   0: case '-': case '/': case '<': case '>': case 'E': case 'F':
 181         case 'M': case 'U': case 'f': case 'l': case 'n': case 'p': case 's':
 182         case 'u':
 183             break;
 184         default:
 185             assert(0);
 186         }
 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 /* Parse an int, put it into *result; return 0 on failure, else 1. */
 354 int opt_int(const char *value, int *result)
 355 {
 356     long l;
 357
 358     if (!opt_long(value, &l))
 359         return 0;
 360     *result = (int)l;
 361     if (*result != l) {
 362         BIO_printf(bio_err, "%s: Value \"%s\" outside integer range\n",
 363                    prog, value);
 364         return 0;
 365     }
 366     return 1;
 367 }
 368
 369 /* Parse a long, put it into *result; return 0 on failure, else 1. */
 370 int opt_long(const char *value, long *result)
 371 {
 372     int oerrno = errno;
 373     long l;
 374     char *endp;
 375
 376     errno = 0;
 377     l = strtol(value, &endp, 0);
 378     if (*endp
 379             || endp == value
 380             || ((l == LONG_MAX || l == LONG_MIN) && errno == ERANGE)
 381             || (l == 0 && errno != 0)) {
 382         BIO_printf(bio_err, "%s: Can't parse \"%s\" as a number\n",
 383                    prog, value);
 384         errno = oerrno;
 385         return 0;
 386     }
 387     *result = l;
 388     errno = oerrno;
 389     return 1;
 390 }
 391
 392 #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L && \
 393     defined(INTMAX_MAX) && defined(UINTMAX_MAX)
 394
 395 /* Parse an intmax_t, put it into *result; return 0 on failure, else 1. */
 396 int opt_imax(const char *value, intmax_t *result)
 397 {
 398     int oerrno = errno;
 399     intmax_t m;
 400     char *endp;
 401
 402     errno = 0;
 403     m = strtoimax(value, &endp, 0);
 404     if (*endp
 405             || endp == value
 406             || ((m == INTMAX_MAX || m == INTMAX_MIN) && errno == ERANGE)
 407             || (m == 0 && errno != 0)) {
 408         BIO_printf(bio_err, "%s: Can't parse \"%s\" as a number\n",
 409                    prog, value);
 410         errno = oerrno;
 411         return 0;
 412     }
 413     *result = m;
 414     errno = oerrno;
 415     return 1;
 416 }
 417
 418 /* Parse a uintmax_t, put it into *result; return 0 on failure, else 1. */
 419 int opt_umax(const char *value, uintmax_t *result)
 420 {
 421     int oerrno = errno;
 422     uintmax_t m;
 423     char *endp;
 424
 425     errno = 0;
 426     m = strtoumax(value, &endp, 0);
 427     if (*endp
 428             || endp == value
 429             || (m == UINTMAX_MAX && errno == ERANGE)
 430             || (m == 0 && errno != 0)) {
 431         BIO_printf(bio_err, "%s: Can't parse \"%s\" as a number\n",
 432                    prog, value);
 433         errno = oerrno;
 434         return 0;
 435     }
 436     *result = m;
 437     errno = oerrno;
 438     return 1;
 439 }
 440 #endif
 441
 442 /*
 443  * Parse an unsigned long, put it into *result; return 0 on failure, else 1.
 444  */
 445 int opt_ulong(const char *value, unsigned long *result)
 446 {
 447     int oerrno = errno;
 448     char *endptr;
 449     unsigned long l;
 450
 451     errno = 0;
 452     l = strtoul(value, &endptr, 0);
 453     if (*endptr
 454             || endptr == value
 455             || ((l == ULONG_MAX) && errno == ERANGE)
 456             || (l == 0 && errno != 0)) {
 457         BIO_printf(bio_err, "%s: Can't parse \"%s\" as an unsigned number\n",
 458                    prog, value);
 459         errno = oerrno;
 460         return 0;
 461     }
 462     *result = l;
 463     errno = oerrno;
 464     return 1;
 465 }
 466
 467 /*
 468  * We pass opt as an int but cast it to "enum range" so that all the
 469  * items in the OPT_V_ENUM enumeration are caught; this makes -Wswitch
 470  * in gcc do the right thing.
 471  */
 472 enum range { OPT_V_ENUM };
 473
 474 int opt_verify(int opt, X509_VERIFY_PARAM *vpm)
 475 {
 476     int i;
 477     ossl_intmax_t t = 0;
 478     ASN1_OBJECT *otmp;
 479     X509_PURPOSE *xptmp;
 480     const X509_VERIFY_PARAM *vtmp;
 481
 482     assert(vpm != NULL);
 483     assert(opt > OPT_V__FIRST);
 484     assert(opt < OPT_V__LAST);
 485
 486     switch ((enum range)opt) {
 487     case OPT_V__FIRST:
 488     case OPT_V__LAST:
 489         return 0;
 490     case OPT_V_POLICY:
 491         otmp = OBJ_txt2obj(opt_arg(), 0);
 492         if (otmp == NULL) {
 493             BIO_printf(bio_err, "%s: Invalid Policy %s\n", prog, opt_arg());
 494             return 0;
 495         }
 496         X509_VERIFY_PARAM_add0_policy(vpm, otmp);
 497         break;
 498     case OPT_V_PURPOSE:
 499         /* purpose name -> purpose index */
 500         i = X509_PURPOSE_get_by_sname(opt_arg());
 501         if (i < 0) {
 502             BIO_printf(bio_err, "%s: Invalid purpose %s\n", prog, opt_arg());
 503             return 0;
 504         }
 505
 506         /* purpose index -> purpose object */
 507         xptmp = X509_PURPOSE_get0(i);
 508
 509         /* purpose object -> purpose value */
 510         i = X509_PURPOSE_get_id(xptmp);
 511
 512         if (!X509_VERIFY_PARAM_set_purpose(vpm, i)) {
 513             BIO_printf(bio_err,
 514                        "%s: Internal error setting purpose %s\n",
 515                        prog, opt_arg());
 516             return 0;
 517         }
 518         break;
 519     case OPT_V_VERIFY_NAME:
 520         vtmp = X509_VERIFY_PARAM_lookup(opt_arg());
 521         if (vtmp == NULL) {
 522             BIO_printf(bio_err, "%s: Invalid verify name %s\n",
 523                        prog, opt_arg());
 524             return 0;
 525         }
 526         X509_VERIFY_PARAM_set1(vpm, vtmp);
 527         break;
 528     case OPT_V_VERIFY_DEPTH:
 529         i = atoi(opt_arg());
 530         if (i >= 0)
 531             X509_VERIFY_PARAM_set_depth(vpm, i);
 532         break;
 533     case OPT_V_VERIFY_AUTH_LEVEL:
 534         i = atoi(opt_arg());
 535         if (i >= 0)
 536             X509_VERIFY_PARAM_set_auth_level(vpm, i);
 537         break;
 538     case OPT_V_ATTIME:
 539         if (!opt_imax(opt_arg(), &t))
 540             return 0;
 541         if (t != (time_t)t) {
 542             BIO_printf(bio_err, "%s: epoch time out of range %s\n",
 543                        prog, opt_arg());
 544             return 0;
 545         }
 546         X509_VERIFY_PARAM_set_time(vpm, (time_t)t);
 547         break;
 548     case OPT_V_VERIFY_HOSTNAME:
 549         if (!X509_VERIFY_PARAM_set1_host(vpm, opt_arg(), 0))
 550             return 0;
 551         break;
 552     case OPT_V_VERIFY_EMAIL:
 553         if (!X509_VERIFY_PARAM_set1_email(vpm, opt_arg(), 0))
 554             return 0;
 555         break;
 556     case OPT_V_VERIFY_IP:
 557         if (!X509_VERIFY_PARAM_set1_ip_asc(vpm, opt_arg()))
 558             return 0;
 559         break;
 560     case OPT_V_IGNORE_CRITICAL:
 561         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_IGNORE_CRITICAL);
 562         break;
 563     case OPT_V_ISSUER_CHECKS:
 564         /* NOP, deprecated */
 565         break;
 566     case OPT_V_CRL_CHECK:
 567         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_CRL_CHECK);
 568         break;
 569     case OPT_V_CRL_CHECK_ALL:
 570         X509_VERIFY_PARAM_set_flags(vpm,
 571                                     X509_V_FLAG_CRL_CHECK |
 572                                     X509_V_FLAG_CRL_CHECK_ALL);
 573         break;
 574     case OPT_V_POLICY_CHECK:
 575         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_POLICY_CHECK);
 576         break;
 577     case OPT_V_EXPLICIT_POLICY:
 578         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_EXPLICIT_POLICY);
 579         break;
 580     case OPT_V_INHIBIT_ANY:
 581         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_INHIBIT_ANY);
 582         break;
 583     case OPT_V_INHIBIT_MAP:
 584         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_INHIBIT_MAP);
 585         break;
 586     case OPT_V_X509_STRICT:
 587         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_X509_STRICT);
 588         break;
 589     case OPT_V_EXTENDED_CRL:
 590         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_EXTENDED_CRL_SUPPORT);
 591         break;
 592     case OPT_V_USE_DELTAS:
 593         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_USE_DELTAS);
 594         break;
 595     case OPT_V_POLICY_PRINT:
 596         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_NOTIFY_POLICY);
 597         break;
 598     case OPT_V_CHECK_SS_SIG:
 599         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_CHECK_SS_SIGNATURE);
 600         break;
 601     case OPT_V_TRUSTED_FIRST:
 602         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_TRUSTED_FIRST);
 603         break;
 604     case OPT_V_SUITEB_128_ONLY:
 605         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_SUITEB_128_LOS_ONLY);
 606         break;
 607     case OPT_V_SUITEB_128:
 608         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_SUITEB_128_LOS);
 609         break;
 610     case OPT_V_SUITEB_192:
 611         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_SUITEB_192_LOS);
 612         break;
 613     case OPT_V_PARTIAL_CHAIN:
 614         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_PARTIAL_CHAIN);
 615         break;
 616     case OPT_V_NO_ALT_CHAINS:
 617         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_NO_ALT_CHAINS);
 618         break;
 619     case OPT_V_NO_CHECK_TIME:
 620         X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_NO_CHECK_TIME);
 621         break;
 622     }
 623     return 1;
 624
 625 }
 626
 627 /*
 628  * Parse the next flag (and value if specified), return 0 if done, -1 on
 629  * error, otherwise the flag's retval.
 630  */
 631 int opt_next(void)
 632 {
 633     char *p;
 634     const OPTIONS *o;
 635     int ival;
 636     long lval;
 637     unsigned long ulval;
 638     ossl_intmax_t imval;
 639     ossl_uintmax_t umval;
 640
 641     /* Look at current arg; at end of the list? */
 642     arg = NULL;
 643     p = argv[opt_index];
 644     if (p == NULL)
 645         return 0;
 646
 647     /* If word doesn't start with a -, we're done. */
 648     if (*p != '-')
 649         return 0;
 650
 651     /* Hit "--" ? We're done. */
 652     opt_index++;
 653     if (strcmp(p, "--") == 0)
 654         return 0;
 655
 656     /* Allow -nnn and --nnn */
 657     if (*++p == '-')
 658         p++;
 659     flag = p - 1;
 660
 661     /* If we have --flag=foo, snip it off */
 662     if ((arg = strchr(p, '=')) != NULL)
 663         *arg++ = '\0';
 664     for (o = opts; o->name; ++o) {
 665         /* If not this option, move on to the next one. */
 666         if (strcmp(p, o->name) != 0)
 667             continue;
 668
 669         /* If it doesn't take a value, make sure none was given. */
 670         if (o->valtype == 0 || o->valtype == '-') {
 671             if (arg) {
 672                 BIO_printf(bio_err,
 673                            "%s: Option -%s does not take a value\n", prog, p);
 674                 return -1;
 675             }
 676             return o->retval;
 677         }
 678
 679         /* Want a value; get the next param if =foo not used. */
 680         if (arg == NULL) {
 681             if (argv[opt_index] == NULL) {
 682                 BIO_printf(bio_err,
 683                            "%s: Option -%s needs a value\n", prog, o->name);
 684                 return -1;
 685             }
 686             arg = argv[opt_index++];
 687         }
 688
 689         /* Syntax-check value. */
 690         switch (o->valtype) {
 691         default:
 692         case 's':
 693             /* Just a string. */
 694             break;
 695         case '/':
 696             if (app_isdir(arg) >= 0)
 697                 break;
 698             BIO_printf(bio_err, "%s: Not a directory: %s\n", prog, arg);
 699             return -1;
 700         case '<':
 701             /* Input file. */
 702             if (strcmp(arg, "-") == 0 || app_access(arg, R_OK) >= 0)
 703                 break;
 704             BIO_printf(bio_err,
 705                        "%s: Cannot open input file %s, %s\n",
 706                        prog, arg, strerror(errno));
 707             return -1;
 708         case '>':
 709             /* Output file. */
 710             if (strcmp(arg, "-") == 0 || app_access(arg, W_OK) >= 0 || errno == ENOENT)
 711                 break;
 712             BIO_printf(bio_err,
 713                        "%s: Cannot open output file %s, %s\n",
 714                        prog, arg, strerror(errno));
 715             return -1;
 716         case 'p':
 717         case 'n':
 718             if (!opt_int(arg, &ival)
 719                     || (o->valtype == 'p' && ival <= 0)) {
 720                 BIO_printf(bio_err,
 721                            "%s: Non-positive number \"%s\" for -%s\n",
 722                            prog, arg, o->name);
 723                 return -1;
 724             }
 725             break;
 726         case 'M':
 727             if (!opt_imax(arg, &imval)) {
 728                 BIO_printf(bio_err,
 729                            "%s: Invalid number \"%s\" for -%s\n",
 730                            prog, arg, o->name);
 731                 return -1;
 732             }
 733             break;
 734         case 'U':
 735             if (!opt_umax(arg, &umval)) {
 736                 BIO_printf(bio_err,
 737                            "%s: Invalid number \"%s\" for -%s\n",
 738                            prog, arg, o->name);
 739                 return -1;
 740             }
 741             break;
 742         case 'l':
 743             if (!opt_long(arg, &lval)) {
 744                 BIO_printf(bio_err,
 745                            "%s: Invalid number \"%s\" for -%s\n",
 746                            prog, arg, o->name);
 747                 return -1;
 748             }
 749             break;
 750         case 'u':
 751             if (!opt_ulong(arg, &ulval)) {
 752                 BIO_printf(bio_err,
 753                            "%s: Invalid number \"%s\" for -%s\n",
 754                            prog, arg, o->name);
 755                 return -1;
 756             }
 757             break;
 758         case 'E':
 759         case 'F':
 760         case 'f':
 761             if (opt_format(arg,
 762                            o->valtype == 'E' ? OPT_FMT_PDE :
 763                            o->valtype == 'F' ? OPT_FMT_PEMDER
 764                            : OPT_FMT_ANY, &ival))
 765                 break;
 766             BIO_printf(bio_err,
 767                        "%s: Invalid format \"%s\" for -%s\n",
 768                        prog, arg, o->name);
 769             return -1;
 770         }
 771
 772         /* Return the flag value. */
 773         return o->retval;
 774     }
 775     if (unknown != NULL) {
 776         dunno = p;
 777         return unknown->retval;
 778     }
 779     BIO_printf(bio_err, "%s: Option unknown option -%s\n", prog, p);
 780     return -1;
 781 }
 782
 783 /* Return the most recent flag parameter. */
 784 char *opt_arg(void)
 785 {
 786     return arg;
 787 }
 788
 789 /* Return the most recent flag. */
 790 char *opt_flag(void)
 791 {
 792     return flag;
 793 }
 794
 795 /* Return the unknown option. */
 796 char *opt_unknown(void)
 797 {
 798     return dunno;
 799 }
 800
 801 /* Return the rest of the arguments after parsing flags. */
 802 char **opt_rest(void)
 803 {
 804     return &argv[opt_index];
 805 }
 806
 807 /* How many items in remaining args? */
 808 int opt_num_rest(void)
 809 {
 810     int i = 0;
 811     char **pp;
 812
 813     for (pp = opt_rest(); *pp; pp++, i++)
 814         continue;
 815     return i;
 816 }
 817
 818 /* Return a string describing the parameter type. */
 819 static const char *valtype2param(const OPTIONS *o)
 820 {
 821     switch (o->valtype) {
 822     case 0:
 823     case '-':
 824         return "";
 825     case 's':
 826         return "val";
 827     case '/':
 828         return "dir";
 829     case '<':
 830         return "infile";
 831     case '>':
 832         return "outfile";
 833     case 'p':
 834         return "+int";
 835     case 'n':
 836         return "int";
 837     case 'l':
 838         return "long";
 839     case 'u':
 840         return "ulong";
 841     case 'E':
 842         return "PEM|DER|ENGINE";
 843     case 'F':
 844         return "PEM|DER";
 845     case 'f':
 846         return "format";
 847     case 'M':
 848         return "intmax";
 849     case 'U':
 850         return "uintmax";
 851     }
 852     return "parm";
 853 }
 854
 855 void opt_help(const OPTIONS *list)
 856 {
 857     const OPTIONS *o;
 858     int i;
 859     int standard_prolog;
 860     int width = 5;
 861     char start[80 + 1];
 862     char *p;
 863     const char *help;
 864
 865     /* Starts with its own help message? */
 866     standard_prolog = list[0].name != OPT_HELP_STR;
 867
 868     /* Find the widest help. */
 869     for (o = list; o->name; o++) {
 870         if (o->name == OPT_MORE_STR)
 871             continue;
 872         i = 2 + (int)strlen(o->name);
 873         if (o->valtype != '-')
 874             i += 1 + strlen(valtype2param(o));
 875         if (i < MAX_OPT_HELP_WIDTH && i > width)
 876             width = i;
 877         assert(i < (int)sizeof start);
 878     }
 879
 880     if (standard_prolog)
 881         BIO_printf(bio_err, "Usage: %s [options]\nValid options are:\n",
 882                    prog);
 883
 884     /* Now let's print. */
 885     for (o = list; o->name; o++) {
 886         help = o->helpstr ? o->helpstr : "(No additional info)";
 887         if (o->name == OPT_HELP_STR) {
 888             BIO_printf(bio_err, help, prog);
 889             continue;
 890         }
 891
 892         /* Pad out prefix */
 893         memset(start, ' ', sizeof(start) - 1);
 894         start[sizeof start - 1] = '\0';
 895
 896         if (o->name == OPT_MORE_STR) {
 897             /* Continuation of previous line; padd and print. */
 898             start[width] = '\0';
 899             BIO_printf(bio_err, "%s  %s\n", start, help);
 900             continue;
 901         }
 902
 903         /* Build up the "-flag [param]" part. */
 904         p = start;
 905         *p++ = ' ';
 906         *p++ = '-';
 907         if (o->name[0])
 908             p += strlen(strcpy(p, o->name));
 909         else
 910             *p++ = '*';
 911         if (o->valtype != '-') {
 912             *p++ = ' ';
 913             p += strlen(strcpy(p, valtype2param(o)));
 914         }
 915         *p = ' ';
 916         if ((int)(p - start) >= MAX_OPT_HELP_WIDTH) {
 917             *p = '\0';
 918             BIO_printf(bio_err, "%s\n", start);
 919             memset(start, ' ', sizeof(start));
 920         }
 921         start[width] = '\0';
 922         BIO_printf(bio_err, "%s  %s\n", start, help);
 923     }
 924 }
 925
 926 #ifdef COMPILE_STANDALONE_TEST_DRIVER
 927 # include <sys/stat.h>
 928
 929 typedef enum OPTION_choice {
 930     OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
 931     OPT_IN, OPT_INFORM, OPT_OUT, OPT_COUNT, OPT_U, OPT_FLAG,
 932     OPT_STR, OPT_NOTUSED
 933 } OPTION_CHOICE;
 934
 935 static OPTIONS options[] = {
 936     {OPT_HELP_STR, 1, '-', "Usage: %s flags\n"},
 937     {OPT_HELP_STR, 1, '-', "Valid options are:\n"},
 938     {"help", OPT_HELP, '-', "Display this summary"},
 939     {"in", OPT_IN, '<', "input file"},
 940     {OPT_MORE_STR, 1, '-', "more detail about input"},
 941     {"inform", OPT_INFORM, 'f', "input file format; defaults to pem"},
 942     {"out", OPT_OUT, '>', "output file"},
 943     {"count", OPT_COUNT, 'p', "a counter greater than zero"},
 944     {"u", OPT_U, 'u', "an unsigned number"},
 945     {"flag", OPT_FLAG, 0, "just some flag"},
 946     {"str", OPT_STR, 's', "the magic word"},
 947     {"areallyverylongoption", OPT_HELP, '-', "long way for help"},
 948     {NULL}
 949 };
 950
 951 BIO *bio_err;
 952
 953 int app_isdir(const char *name)
 954 {
 955     struct stat sb;
 956
 957     return name != NULL && stat(name, &sb) >= 0 && S_ISDIR(sb.st_mode);
 958 }
 959
 960 int main(int ac, char **av)
 961 {
 962     OPTION_CHOICE o;
 963     char **rest;
 964     char *prog;
 965
 966     bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);
 967
 968     prog = opt_init(ac, av, options);
 969     while ((o = opt_next()) != OPT_EOF) {
 970         switch (c) {
 971         case OPT_NOTUSED:
 972         case OPT_EOF:
 973         case OPT_ERR:
 974             printf("%s: Usage error; try -help.\n", prog);
 975             return 1;
 976         case OPT_HELP:
 977             opt_help(options);
 978             return 0;
 979         case OPT_IN:
 980             printf("in %s\n", opt_arg());
 981             break;
 982         case OPT_INFORM:
 983             printf("inform %s\n", opt_arg());
 984             break;
 985         case OPT_OUT:
 986             printf("out %s\n", opt_arg());
 987             break;
 988         case OPT_COUNT:
 989             printf("count %s\n", opt_arg());
 990             break;
 991         case OPT_U:
 992             printf("u %s\n", opt_arg());
 993             break;
 994         case OPT_FLAG:
 995             printf("flag\n");
 996             break;
 997         case OPT_STR:
 998             printf("str %s\n", opt_arg());
 999             break;
1000         }
1001     }
1002     argc = opt_num_rest();
1003     argv = opt_rest();
1004
1005     printf("args = %d\n", argc);
1006     if (argc)
1007         while (*argv)
1008             printf("  %s\n", *argv++);
1009     return 0;
1010 }
1011 #endif