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