/* 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;
}
