/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
 *  SIGNTOOL
 *
 *  A command line tool to create manifest files
 *  from a directory hierarchy. It is assumed that
 *  the tree will be equivalent to what resides
 *  or will reside in an archive.
 *
 *
 */

#include "nss.h"
#include "signtool.h"
#include "prmem.h"
#include "prio.h"

/***********************************************************************
 * Global Variable Definitions
 */
char *progName; /* argv[0] */

/* password data */
secuPWData pwdata = { PW_NONE, 0 };

/* directories or files to exclude in descent */
PLHashTable *excludeDirs = NULL;
static PRBool exclusionsGiven = PR_FALSE;

/* zatharus is the man who knows no time, dies tragic death */
int no_time = 0;

/* -b basename of .rsa, .sf files */
char *base = DEFAULT_BASE_NAME;

/* Only sign files with this extension */
PLHashTable *extensions = NULL;
PRBool extensionsGiven = PR_FALSE;

char *scriptdir = NULL;

int verbosity = 0;

PRFileDesc *outputFD = NULL, *errorFD = NULL;

int errorCount = 0, warningCount = 0;

int compression_level = DEFAULT_COMPRESSION_LEVEL;
PRBool compression_level_specified = PR_FALSE;

int xpi_arc = 0;

/* Command-line arguments */
static char *genkey = NULL;
static char *verify = NULL;
static char *zipfile = NULL;
static char *cert_dir = NULL;
static int javascript = 0;
static char *jartree = NULL;
static char *keyName = NULL;
static char *metafile = NULL;
static char *install_script = NULL;
static int list_certs = 0;
static int list_modules = 0;
static int optimize = 0;
static int enableOCSP = 0;
static char *tell_who = NULL;
static char *outfile = NULL;
static char *cmdFile = NULL;
static PRBool noRecurse = PR_FALSE;
static PRBool leaveArc = PR_FALSE;
static int keySize = -1;
static char *token = NULL;

typedef enum {
    UNKNOWN_OPT,
    HELP_OPT,
    LONG_HELP_OPT,
    BASE_OPT,
    COMPRESSION_OPT,
    CERT_DIR_OPT,
    EXTENSION_OPT,
    INSTALL_SCRIPT_OPT,
    SCRIPTDIR_OPT,
    CERTNAME_OPT,
    LIST_OBJSIGN_CERTS_OPT,
    LIST_ALL_CERTS_OPT,
    METAFILE_OPT,
    OPTIMIZE_OPT,
    ENABLE_OCSP_OPT,
    PASSWORD_OPT,
    VERIFY_OPT,
    WHO_OPT,
    EXCLUDE_OPT,
    NO_TIME_OPT,
    JAVASCRIPT_OPT,
    ZIPFILE_OPT,
    GENKEY_OPT,
    MODULES_OPT,
    NORECURSE_OPT,
    SIGNDIR_OPT,
    OUTFILE_OPT,
    COMMAND_FILE_OPT,
    LEAVE_ARC_OPT,
    VERBOSITY_OPT,
    KEYSIZE_OPT,
    TOKEN_OPT,
    XPI_ARC_OPT
}

OPT_TYPE;

typedef enum {
    DUPLICATE_OPTION_ERR = 0,
    OPTION_NEEDS_ARG_ERR
}

Error;

static char *errStrings[] = {
    "warning: %s option specified more than once.\n"
    "Only last specification will be used.\n",
    "ERROR: option \"%s\" requires an argument.\n"
};

static int ProcessOneOpt(OPT_TYPE type, char *arg);

/*********************************************************************
 *
 * P r o c e s s C o m m a n d F i l e
 */
int
ProcessCommandFile()
{
    PRFileDesc *fd;
#define CMD_FILE_BUFSIZE 1024
    char buf[CMD_FILE_BUFSIZE];
    char *equals;
    int linenum = 0;
    int retval = -1;
    OPT_TYPE type;

    fd = PR_Open(cmdFile, PR_RDONLY, 0777);
    if (!fd) {
        PR_fprintf(errorFD, "ERROR: Unable to open command file %s.\n");
        errorCount++;
        return -1;
    }

    while (pr_fgets(buf, CMD_FILE_BUFSIZE, fd)) {
        char *eol;
        linenum++;

        /* Chop off final newline */
        eol = PL_strchr(buf, '\r');
        if (!eol) {
            eol = PL_strchr(buf, '\n');
        }
        if (eol)
            *eol = '\0';

        equals = PL_strchr(buf, '=');
        if (!equals) {
            continue;
        }

        *equals = '\0';
        equals++;

        /* Now buf points to the attribute, and equals points to the value. */

        /* This is pretty straightforward, just deal with whatever attribute
         * this is */
        if (!PL_strcasecmp(buf, "basename")) {
            type = BASE_OPT;
        } else if (!PL_strcasecmp(buf, "compression")) {
            type = COMPRESSION_OPT;
        } else if (!PL_strcasecmp(buf, "certdir")) {
            type = CERT_DIR_OPT;
        } else if (!PL_strcasecmp(buf, "extension")) {
            type = EXTENSION_OPT;
        } else if (!PL_strcasecmp(buf, "generate")) {
            type = GENKEY_OPT;
        } else if (!PL_strcasecmp(buf, "installScript")) {
            type = INSTALL_SCRIPT_OPT;
        } else if (!PL_strcasecmp(buf, "javascriptdir")) {
            type = SCRIPTDIR_OPT;
        } else if (!PL_strcasecmp(buf, "htmldir")) {
            type = JAVASCRIPT_OPT;
            if (jartree) {
                PR_fprintf(errorFD,
                           "warning: directory to be signed specified more than once."
                           " Only last specification will be used.\n");
                warningCount++;
                PR_Free(jartree);
                jartree = NULL;
            }
            jartree = PL_strdup(equals);
        } else if (!PL_strcasecmp(buf, "certname")) {
            type = CERTNAME_OPT;
        } else if (!PL_strcasecmp(buf, "signdir")) {
            type = SIGNDIR_OPT;
        } else if (!PL_strcasecmp(buf, "list")) {
            type = LIST_OBJSIGN_CERTS_OPT;
        } else if (!PL_strcasecmp(buf, "listall")) {
            type = LIST_ALL_CERTS_OPT;
        } else if (!PL_strcasecmp(buf, "metafile")) {
            type = METAFILE_OPT;
        } else if (!PL_strcasecmp(buf, "modules")) {
            type = MODULES_OPT;
        } else if (!PL_strcasecmp(buf, "optimize")) {
            type = OPTIMIZE_OPT;
        } else if (!PL_strcasecmp(buf, "ocsp")) {
            type = ENABLE_OCSP_OPT;
        } else if (!PL_strcasecmp(buf, "password")) {
            type = PASSWORD_OPT;
        } else if (!PL_strcasecmp(buf, "verify")) {
            type = VERIFY_OPT;
        } else if (!PL_strcasecmp(buf, "who")) {
            type = WHO_OPT;
        } else if (!PL_strcasecmp(buf, "exclude")) {
            type = EXCLUDE_OPT;
        } else if (!PL_strcasecmp(buf, "notime")) {
            type = NO_TIME_OPT;
        } else if (!PL_strcasecmp(buf, "jarfile")) {
            type = ZIPFILE_OPT;
        } else if (!PL_strcasecmp(buf, "outfile")) {
            type = OUTFILE_OPT;
        } else if (!PL_strcasecmp(buf, "leavearc")) {
            type = LEAVE_ARC_OPT;
        } else if (!PL_strcasecmp(buf, "verbosity")) {
            type = VERBOSITY_OPT;
        } else if (!PL_strcasecmp(buf, "keysize")) {
            type = KEYSIZE_OPT;
        } else if (!PL_strcasecmp(buf, "token")) {
            type = TOKEN_OPT;
        } else if (!PL_strcasecmp(buf, "xpi")) {
            type = XPI_ARC_OPT;
        } else {
            PR_fprintf(errorFD,
                       "warning: unknown attribute \"%s\" in command file, line %d.\n",
                       buf, linenum);
            warningCount++;
            type = UNKNOWN_OPT;
        }

        /* Process the option, whatever it is */
        if (type != UNKNOWN_OPT) {
            if (ProcessOneOpt(type, equals) == -1) {
                goto finish;
            }
        }
    }

    retval = 0;

finish:
    PR_Close(fd);
    return retval;
}

/*********************************************************************
 *
 * p a r s e _ a r g s
 */
static int
parse_args(int argc, char *argv[])
{
    char *opt;
    char *arg;
    int needsInc = 0;
    int i;
    OPT_TYPE type;

    /* Loop over all arguments */
    for (i = 1; i < argc; i++) {
        opt = argv[i];
        arg = NULL;

        if (opt[0] == '-') {
            if (opt[1] == '-') {
                /* word option */
                if (i < argc - 1) {
                    needsInc = 1;
                    arg = argv[i + 1];
                } else {
                    arg = NULL;
                }

                if (!PL_strcasecmp(opt + 2, "norecurse")) {
                    type = NORECURSE_OPT;
                } else if (!PL_strcasecmp(opt + 2, "leavearc")) {
                    type = LEAVE_ARC_OPT;
                } else if (!PL_strcasecmp(opt + 2, "verbosity")) {
                    type = VERBOSITY_OPT;
                } else if (!PL_strcasecmp(opt + 2, "outfile")) {
                    type = OUTFILE_OPT;
                } else if (!PL_strcasecmp(opt + 2, "keysize")) {
                    type = KEYSIZE_OPT;
                } else if (!PL_strcasecmp(opt + 2, "token")) {
                    type = TOKEN_OPT;
                } else {
                    PR_fprintf(errorFD, "warning: unknown option: %s\n",
                               opt);
                    warningCount++;
                    type = UNKNOWN_OPT;
                }
            } else {
                /* char option */
                if (opt[2] != '\0') {
                    arg = opt + 2;
                } else if (i < argc - 1) {
                    needsInc = 1;
                    arg = argv[i + 1];
                } else {
                    arg = NULL;
                }

                switch (opt[1]) {
                    case 'b':
                        type = BASE_OPT;
                        break;
                    case 'c':
                        type = COMPRESSION_OPT;
                        break;
                    case 'd':
                        type = CERT_DIR_OPT;
                        break;
                    case 'e':
                        type = EXTENSION_OPT;
                        break;
                    case 'f':
                        type = COMMAND_FILE_OPT;
                        break;
                    case 'h':
                        type = HELP_OPT;
                        break;
                    case 'H':
                        type = LONG_HELP_OPT;
                        break;
                    case 'i':
                        type = INSTALL_SCRIPT_OPT;
                        break;
                    case 'j':
                        type = SCRIPTDIR_OPT;
                        break;
                    case 'k':
                        type = CERTNAME_OPT;
                        break;
                    case 'l':
                        type = LIST_OBJSIGN_CERTS_OPT;
                        break;
                    case 'L':
                        type = LIST_ALL_CERTS_OPT;
                        break;
                    case 'm':
                        type = METAFILE_OPT;
                        break;
                    case 'o':
                        type = OPTIMIZE_OPT;
                        break;
                    case 'O':
                        type = ENABLE_OCSP_OPT;
                        break;
                    case 'p':
                        type = PASSWORD_OPT;
                        break;
                    case 'v':
                        type = VERIFY_OPT;
                        break;
                    case 'w':
                        type = WHO_OPT;
                        break;
                    case 'x':
                        type = EXCLUDE_OPT;
                        break;
                    case 'X':
                        type = XPI_ARC_OPT;
                        break;
                    case 'z':
                        type = NO_TIME_OPT;
                        break;
                    case 'J':
                        type = JAVASCRIPT_OPT;
                        break;
                    case 'Z':
                        type = ZIPFILE_OPT;
                        break;
                    case 'G':
                        type = GENKEY_OPT;
                        break;
                    case 'M':
                        type = MODULES_OPT;
                        break;
                    case 's':
                        type = KEYSIZE_OPT;
                        break;
                    case 't':
                        type = TOKEN_OPT;
                        break;
                    default:
                        type = UNKNOWN_OPT;
                        PR_fprintf(errorFD, "warning: unrecognized option: -%c.\n",
                                   opt[1]);
                        warningCount++;
                        break;
                }
            }
        } else {
            type = UNKNOWN_OPT;
            if (i == argc - 1) {
                if (jartree) {
                    PR_fprintf(errorFD,
                               "warning: directory to be signed specified more than once.\n"
                               " Only last specification will be used.\n");
                    warningCount++;
                    PR_Free(jartree);
                    jartree = NULL;
                }
                jartree = PL_strdup(opt);
            } else {
                PR_fprintf(errorFD, "warning: unrecognized option: %s\n", opt);
                warningCount++;
            }
        }

        if (type != UNKNOWN_OPT) {
            short ateArg = ProcessOneOpt(type, arg);
            if (ateArg == -1) {
                /* error */
                return -1;
            }
            if (ateArg && needsInc) {
                i++;
            }
        }
    }

    return 0;
}

/*********************************************************************
 *
 * P r o c e s s O n e O p t
 *
 * Since options can come from different places (command file, word options,
 * char options), this is a central function that is called to deal with
 * them no matter where they come from.
 *
 * type is the type of option.
 * arg is the argument to the option, possibly NULL.
 * Returns 1 if the argument was eaten, 0 if it wasn't, and -1 for error.
 */
static int
ProcessOneOpt(OPT_TYPE type, char *arg)
{
    int ate = 0;

    switch (type) {
        case HELP_OPT:
            Usage();
            break;
        case LONG_HELP_OPT:
            LongUsage();
            break;
        case BASE_OPT:
            if (base) {
                PR_fprintf(errorFD, errStrings[DUPLICATE_OPTION_ERR], "-b");
                warningCount++;
                PR_Free(base);
                base = NULL;
            }
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR], "-b");
                errorCount++;
                goto loser;
            }
            base = PL_strdup(arg);
            ate = 1;
            break;
        case COMPRESSION_OPT:
            if (compression_level_specified) {
                PR_fprintf(errorFD, errStrings[DUPLICATE_OPTION_ERR], "-c");
                warningCount++;
            }
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR], "-c");
                errorCount++;
                goto loser;
            }
            compression_level = atoi(arg);
            compression_level_specified = PR_TRUE;
            ate = 1;
            break;
        case CERT_DIR_OPT:
            if (cert_dir) {
                PR_fprintf(errorFD, errStrings[DUPLICATE_OPTION_ERR], "-d");
                warningCount++;
                PR_Free(cert_dir);
                cert_dir = NULL;
            }
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR], "-d");
                errorCount++;
                goto loser;
            }
            cert_dir = PL_strdup(arg);
            ate = 1;
            break;
        case EXTENSION_OPT:
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR],
                           "extension (-e)");
                errorCount++;
                goto loser;
            }
            PL_HashTableAdd(extensions, arg, arg);
            extensionsGiven = PR_TRUE;
            ate = 1;
            break;
        case INSTALL_SCRIPT_OPT:
            if (install_script) {
                PR_fprintf(errorFD, errStrings[DUPLICATE_OPTION_ERR],
                           "installScript (-i)");
                warningCount++;
                PR_Free(install_script);
                install_script = NULL;
            }
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR],
                           "installScript (-i)");
                errorCount++;
                goto loser;
            }
            install_script = PL_strdup(arg);
            ate = 1;
            break;
        case SCRIPTDIR_OPT:
            if (scriptdir) {
                PR_fprintf(errorFD, errStrings[DUPLICATE_OPTION_ERR],
                           "javascriptdir (-j)");
                warningCount++;
                PR_Free(scriptdir);
                scriptdir = NULL;
            }
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR],
                           "javascriptdir (-j)");
                errorCount++;
                goto loser;
            }
            scriptdir = PL_strdup(arg);
            ate = 1;
            break;
        case CERTNAME_OPT:
            if (keyName) {
                PR_fprintf(errorFD, errStrings[DUPLICATE_OPTION_ERR],
                           "keyName (-k)");
                warningCount++;
                PR_Free(keyName);
                keyName = NULL;
            }
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR],
                           "keyName (-k)");
                errorCount++;
                goto loser;
            }
            keyName = PL_strdup(arg);
            ate = 1;
            break;
        case LIST_OBJSIGN_CERTS_OPT:
        case LIST_ALL_CERTS_OPT:
            if (list_certs != 0) {
                PR_fprintf(errorFD,
                           "warning: only one of -l and -L may be specified.\n");
                warningCount++;
            }
            list_certs = (type == LIST_OBJSIGN_CERTS_OPT ? 1 : 2);
            break;
        case METAFILE_OPT:
            if (metafile) {
                PR_fprintf(errorFD, errStrings[DUPLICATE_OPTION_ERR],
                           "metafile (-m)");
                warningCount++;
                PR_Free(metafile);
                metafile = NULL;
            }
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR],
                           "metafile (-m)");
                errorCount++;
                goto loser;
            }
            metafile = PL_strdup(arg);
            ate = 1;
            break;
        case OPTIMIZE_OPT:
            optimize = 1;
            break;
        case ENABLE_OCSP_OPT:
            enableOCSP = 1;
            break;
        case PASSWORD_OPT:
            if (pwdata.data) {
                PR_fprintf(errorFD, errStrings[DUPLICATE_OPTION_ERR],
                           "password (-p)");
                warningCount++;
                PR_Free(pwdata.data);
                pwdata.data = NULL;
            }
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR],
                           "password (-p)");
                errorCount++;
                goto loser;
            }
            pwdata.source = PW_PLAINTEXT;
            pwdata.data = PL_strdup(arg);
            ate = 1;
            break;
        case VERIFY_OPT:
            if (verify) {
                PR_fprintf(errorFD, errStrings[DUPLICATE_OPTION_ERR],
                           "verify (-v)");
                warningCount++;
                PR_Free(verify);
                verify = NULL;
            }
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR],
                           "verify (-v)");
                errorCount++;
                goto loser;
            }
            verify = PL_strdup(arg);
            ate = 1;
            break;
        case WHO_OPT:
            if (tell_who) {
                PR_fprintf(errorFD, errStrings[DUPLICATE_OPTION_ERR],
                           "who (-v)");
                warningCount++;
                PR_Free(tell_who);
                tell_who = NULL;
            }
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR],
                           "who (-w)");
                errorCount++;
                goto loser;
            }
            tell_who = PL_strdup(arg);
            ate = 1;
            break;
        case EXCLUDE_OPT:
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR],
                           "exclude (-x)");
                errorCount++;
                goto loser;
            }
            PL_HashTableAdd(excludeDirs, arg, arg);
            exclusionsGiven = PR_TRUE;
            ate = 1;
            break;
        case NO_TIME_OPT:
            no_time = 1;
            break;
        case JAVASCRIPT_OPT:
            javascript++;
            break;
        case ZIPFILE_OPT:
            if (zipfile) {
                PR_fprintf(errorFD, errStrings[DUPLICATE_OPTION_ERR],
                           "jarfile (-Z)");
                warningCount++;
                PR_Free(zipfile);
                zipfile = NULL;
            }
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR],
                           "jarfile (-Z)");
                errorCount++;
                goto loser;
            }
            zipfile = PL_strdup(arg);
            ate = 1;
            break;
        case GENKEY_OPT:
            if (genkey) {
                PR_fprintf(errorFD, errStrings[DUPLICATE_OPTION_ERR],
                           "generate (-G)");
                warningCount++;
                PR_Free(genkey);
                genkey = NULL;
            }
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR],
                           "generate (-G)");
                errorCount++;
                goto loser;
            }
            genkey = PL_strdup(arg);
            ate = 1;
            break;
        case MODULES_OPT:
            list_modules++;
            break;
        case SIGNDIR_OPT:
            if (jartree) {
                PR_fprintf(errorFD, errStrings[DUPLICATE_OPTION_ERR],
                           "signdir");
                warningCount++;
                PR_Free(jartree);
                jartree = NULL;
            }
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR],
                           "signdir");
                errorCount++;
                goto loser;
            }
            jartree = PL_strdup(arg);
            ate = 1;
            break;
        case OUTFILE_OPT:
            if (outfile) {
                PR_fprintf(errorFD, errStrings[DUPLICATE_OPTION_ERR],
                           "outfile");
                warningCount++;
                PR_Free(outfile);
                outfile = NULL;
            }
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR],
                           "outfile");
                errorCount++;
                goto loser;
            }
            outfile = PL_strdup(arg);
            ate = 1;
            break;
        case COMMAND_FILE_OPT:
            if (cmdFile) {
                PR_fprintf(errorFD, errStrings[DUPLICATE_OPTION_ERR],
                           "-f");
                warningCount++;
                PR_Free(cmdFile);
                cmdFile = NULL;
            }
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR],
                           "-f");
                errorCount++;
                goto loser;
            }
            cmdFile = PL_strdup(arg);
            ate = 1;
            break;
        case NORECURSE_OPT:
            noRecurse = PR_TRUE;
            break;
        case LEAVE_ARC_OPT:
            leaveArc = PR_TRUE;
            break;
        case VERBOSITY_OPT:
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR],
                           "--verbosity");
                errorCount++;
                goto loser;
            }
            verbosity = atoi(arg);
            ate = 1;
            break;
        case KEYSIZE_OPT:
            if (keySize != -1) {
                PR_fprintf(errorFD, errStrings[DUPLICATE_OPTION_ERR], "-s");
                warningCount++;
            }
            keySize = atoi(arg);
            ate = 1;
            if (keySize < 1 || keySize > MAX_RSA_KEY_SIZE) {
                PR_fprintf(errorFD, "Invalid key size: %d.\n", keySize);
                errorCount++;
                goto loser;
            }
            break;
        case TOKEN_OPT:
            if (token) {
                PR_fprintf(errorFD, errStrings[DUPLICATE_OPTION_ERR], "-t");
                PR_Free(token);
                token = NULL;
            }
            if (!arg) {
                PR_fprintf(errorFD, errStrings[OPTION_NEEDS_ARG_ERR], "-t");
                errorCount++;
                goto loser;
            }
            token = PL_strdup(arg);
            ate = 1;
            break;
        case XPI_ARC_OPT:
            xpi_arc = 1;
            break;
        default:
            PR_fprintf(errorFD, "warning: unknown option\n");
            warningCount++;
            break;
    }

    return ate;
loser:
    return -1;
}

/*********************************************************************
 *
 * m a i n
 */
int
main(int argc, char *argv[])
{
    PRBool readOnly;
    int retval = 0;

    outputFD = PR_STDOUT;
    errorFD = PR_STDERR;

    progName = argv[0];

    if (argc < 2) {
        Usage();
    }

    excludeDirs = PL_NewHashTable(10, PL_HashString, PL_CompareStrings,
                                  PL_CompareStrings, NULL, NULL);
    extensions = PL_NewHashTable(10, PL_HashString, PL_CompareStrings,
                                 PL_CompareStrings, NULL, NULL);

    if (parse_args(argc, argv)) {
        retval = -1;
        goto cleanup;
    }

    /* Parse the command file if one was given */
    if (cmdFile) {
        if (ProcessCommandFile()) {
            retval = -1;
            goto cleanup;
        }
    }

    /* Set up output redirection */
    if (outfile) {
        if (PR_Access(outfile, PR_ACCESS_EXISTS) == PR_SUCCESS) {
            /* delete the file if it is already present */
            PR_fprintf(errorFD,
                       "warning: %s already exists and will be overwritten.\n",
                       outfile);
            warningCount++;
            if (PR_Delete(outfile) != PR_SUCCESS) {
                PR_fprintf(errorFD, "ERROR: unable to delete %s.\n", outfile);
                errorCount++;
                exit(ERRX);
            }
        }
        outputFD = PR_Open(outfile,
                           PR_WRONLY |
                               PR_CREATE_FILE | PR_TRUNCATE,
                           0777);
        if (!outputFD) {
            PR_fprintf(errorFD, "ERROR: Unable to create %s.\n",
                       outfile);
            errorCount++;
            exit(ERRX);
        }
        errorFD = outputFD;
    }

    /* This seems to be a fairly common user error */

    if (verify && list_certs > 0) {
        PR_fprintf(errorFD, "%s: Can't use -l and -v at the same time\n",
                   PROGRAM_NAME);
        errorCount++;
        retval = -1;
        goto cleanup;
    }

    /* -J assumes -Z now */

    if (javascript && zipfile) {
        PR_fprintf(errorFD, "%s: Can't use -J and -Z at the same time\n",
                   PROGRAM_NAME);
        PR_fprintf(errorFD, "%s: -J option will create the jar files for you\n",
                   PROGRAM_NAME);
        errorCount++;
        retval = -1;
        goto cleanup;
    }

    /* -X needs -Z */

    if (xpi_arc && !zipfile) {
        PR_fprintf(errorFD, "%s: option XPI (-X) requires option jarfile (-Z)\n",
                   PROGRAM_NAME);
        errorCount++;
        retval = -1;
        goto cleanup;
    }

    /* Less common mixing of -L with various options */

    if (list_certs > 0 &&
        (tell_who || zipfile || javascript ||
         scriptdir || extensionsGiven || exclusionsGiven || install_script)) {
        PR_fprintf(errorFD, "%s: Can't use -l or -L with that option\n",
                   PROGRAM_NAME);
        errorCount++;
        retval = -1;
        goto cleanup;
    }

    if (!cert_dir)
        cert_dir = get_default_cert_dir();

    VerifyCertDir(cert_dir, keyName);

    if (compression_level < MIN_COMPRESSION_LEVEL ||
        compression_level > MAX_COMPRESSION_LEVEL) {
        PR_fprintf(errorFD, "Compression level must be between %d and %d.\n",
                   MIN_COMPRESSION_LEVEL, MAX_COMPRESSION_LEVEL);
        errorCount++;
        retval = -1;
        goto cleanup;
    }

    if (jartree && !keyName) {
        PR_fprintf(errorFD, "You must specify a key with which to sign.\n");
        errorCount++;
        retval = -1;
        goto cleanup;
    }

    readOnly = (genkey == NULL); /* only key generation requires write */
    if (InitCrypto(cert_dir, readOnly)) {
        PR_fprintf(errorFD, "ERROR: Cryptographic initialization failed.\n");
        errorCount++;
        retval = -1;
        goto cleanup;
    }

    if (enableOCSP) {
        SECStatus rv = CERT_EnableOCSPChecking(CERT_GetDefaultCertDB());
        if (rv != SECSuccess) {
            PR_fprintf(errorFD, "ERROR: Attempt to enable OCSP Checking failed.\n");
            errorCount++;
            retval = -1;
        }
    }

    if (verify) {
        if (VerifyJar(verify)) {
            errorCount++;
            retval = -1;
            goto cleanup;
        }
    } else if (list_certs) {
        if (ListCerts(keyName, list_certs)) {
            errorCount++;
            retval = -1;
            goto cleanup;
        }
    } else if (list_modules) {
        JarListModules();
    } else if (genkey) {
        if (GenerateCert(genkey, keySize, token)) {
            errorCount++;
            retval = -1;
            goto cleanup;
        }
    } else if (tell_who) {
        if (JarWho(tell_who)) {
            errorCount++;
            retval = -1;
            goto cleanup;
        }
    } else if (javascript && jartree) {
        /* make sure directory exists */
        PRDir *dir;
        dir = PR_OpenDir(jartree);
        if (!dir) {
            PR_fprintf(errorFD, "ERROR: unable to open directory %s.\n",
                       jartree);
            errorCount++;
            retval = -1;
            goto cleanup;
        } else {
            PR_CloseDir(dir);
        }

        /* undo junk from prior runs of signtool*/
        if (RemoveAllArc(jartree)) {
            PR_fprintf(errorFD, "Error removing archive directories under %s\n",
                       jartree);
            errorCount++;
            retval = -1;
            goto cleanup;
        }

        /* traverse all the htm|html files in the directory */
        if (InlineJavaScript(jartree, !noRecurse)) {
            retval = -1;
            goto cleanup;
        }

        /* sign any resultant .arc directories created in above step */
        if (SignAllArc(jartree, keyName, javascript, metafile, install_script,
                       optimize, !noRecurse)) {
            retval = -1;
            goto cleanup;
        }

        if (!leaveArc) {
            RemoveAllArc(jartree);
        }

        if (errorCount > 0 || warningCount > 0) {
            PR_fprintf(outputFD, "%d error%s, %d warning%s.\n",
                       errorCount,
                       errorCount == 1 ? "" : "s", warningCount, warningCount == 1
                                                                     ? ""
                                                                     : "s");
        } else {
            PR_fprintf(outputFD, "Directory %s signed successfully.\n",
                       jartree);
        }
    } else if (jartree) {
        SignArchive(jartree, keyName, zipfile, javascript, metafile,
                    install_script, optimize, !noRecurse);
    } else
        Usage();

cleanup:
    if (extensions) {
        PL_HashTableDestroy(extensions);
        extensions = NULL;
    }
    if (excludeDirs) {
        PL_HashTableDestroy(excludeDirs);
        excludeDirs = NULL;
    }
    if (outputFD != PR_STDOUT) {
        PR_Close(outputFD);
    }
    rm_dash_r(TMP_OUTPUT);
    if (retval == 0) {
        if (NSS_Shutdown() != SECSuccess) {
            exit(1);
        }
    }
    return retval;
}
