tor-browser

multinit.c (24887B)

---

/* 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/. */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "nss.h"
#include "secutil.h"
#include "pk11pub.h"
#include "cert.h"

typedef struct commandDescriptStr {
   int required;
   char *arg;
   char *des;
} commandDescript;

enum optionNames {
   opt_liborder = 0,
   opt_mainDB,
   opt_lib1DB,
   opt_lib2DB,
   opt_mainRO,
   opt_lib1RO,
   opt_lib2RO,
   opt_mainCMD,
   opt_lib1CMD,
   opt_lib2CMD,
   opt_mainTokNam,
   opt_lib1TokNam,
   opt_lib2TokNam,
   opt_oldStyle,
   opt_verbose,
   opt_summary,
   opt_help,
   opt_last
};

static const secuCommandFlag options_init[] = {
   { /* opt_liborder */ 'o', PR_TRUE, "1M2zmi", PR_TRUE, "order" },
   { /* opt_mainDB */ 'd', PR_TRUE, 0, PR_FALSE, "main_db" },
   { /* opt_lib1DB */ '1', PR_TRUE, 0, PR_FALSE, "lib1_db" },
   { /* opt_lib2DB */ '2', PR_TRUE, 0, PR_FALSE, "lib2_db" },
   { /* opt_mainRO */ 'r', PR_FALSE, 0, PR_FALSE, "main_readonly" },
   { /* opt_lib1RO */ 0, PR_FALSE, 0, PR_FALSE, "lib1_readonly" },
   { /* opt_lib2RO */ 0, PR_FALSE, 0, PR_FALSE, "lib2_readonly" },
   { /* opt_mainCMD */ 'c', PR_TRUE, 0, PR_FALSE, "main_command" },
   { /* opt_lib1CMD */ 0, PR_TRUE, 0, PR_FALSE, "lib1_command" },
   { /* opt_lib2CMD */ 0, PR_TRUE, 0, PR_FALSE, "lib2_command" },
   { /* opt_mainTokNam */ 't', PR_TRUE, 0, PR_FALSE, "main_token_name" },
   { /* opt_lib1TokNam */ 0, PR_TRUE, 0, PR_FALSE, "lib1_token_name" },
   { /* opt_lib2TokNam */ 0, PR_TRUE, 0, PR_FALSE, "lib2_token_name" },
   { /* opt_oldStype */ 's', PR_FALSE, 0, PR_FALSE, "oldStype" },
   { /* opt_verbose */ 'v', PR_FALSE, 0, PR_FALSE, "verbose" },
   { /* opt_summary */ 'z', PR_FALSE, 0, PR_FALSE, "summary" },
   { /* opt_help */ 'h', PR_FALSE, 0, PR_FALSE, "help" }
};

static const commandDescript options_des[] = {
   { /* opt_liborder */ PR_FALSE, "initOrder",
     " Specifies the order of NSS initialization and shutdown. Order is\n"
     " given as a string where each character represents either an init or\n"
     " a shutdown of the main program or one of the 2 test libraries\n"
     " (library 1 and library 2). The valid characters are as follows:\n"
     "   M Init the main program\n   1 Init library 1\n"
     "   2 Init library 2\n"
     "   m Shutdown the main program\n   i Shutdown library 1\n"
     "   z Shutdown library 2\n" },
   { /* opt_mainDB */ PR_TRUE, "nss_db",
     " Specified the directory to open the nss database for the main\n"
     " program. Must be specified if \"M\" is given in the order string\n" },
   { /* opt_lib1DB */ PR_FALSE, "nss_db",
     " Specified the directory to open the nss database for library 1.\n"
     " Must be specified if \"1\" is given in the order string\n" },
   { /* opt_lib2DB */ PR_FALSE, "nss_db",
     " Specified the directory to open the nss database for library 2.\n"
     " Must be specified if \"2\" is given in the order string\n" },
   { /* opt_mainRO */ PR_FALSE, NULL,
     " Open the main program's database read only.\n" },
   { /* opt_lib1RO */ PR_FALSE, NULL,
     " Open library 1's database read only.\n" },
   { /* opt_lib2RO */ PR_FALSE, NULL,
     " Open library 2's database read only.\n" },
   { /* opt_mainCMD */ PR_FALSE, "nss_command",
     " Specifies the NSS command to execute in the main program.\n"
     " Valid commands are: \n"
     "   key_slot, list_slots, list_certs, add_cert, none.\n"
     " Default is \"none\".\n" },
   { /* opt_lib1CMD */ PR_FALSE, "nss_command",
     " Specifies the NSS command to execute in library 1.\n" },
   { /* opt_lib2CMD */ PR_FALSE, "nss_command",
     " Specifies the NSS command to execute in library 2.\n" },
   { /* opt_mainTokNam */ PR_FALSE, "token_name",
     " Specifies the name of PKCS11 token for the main program's "
     "database.\n" },
   { /* opt_lib1TokNam */ PR_FALSE, "token_name",
     " Specifies the name of PKCS11 token for library 1's database.\n" },
   { /* opt_lib2TokNam */ PR_FALSE, "token_name",
     " Specifies the name of PKCS11 token for library 2's database.\n" },
   { /* opt_oldStype */ PR_FALSE, NULL,
     " Use NSS_Shutdown rather than NSS_ShutdownContext in the main\n"
     " program.\n" },
   { /* opt_verbose */ PR_FALSE, NULL,
     " Noisily output status to standard error\n" },
   { /* opt_summarize */ PR_FALSE, NULL,
     "report a summary of the test results\n" },
   { /* opt_help */ PR_FALSE, NULL, " give this message\n" }
};

/*
* output our short help (table driven). (does not exit).
*/
static void
short_help(const char *prog)
{
   int count = opt_last;
   int i, words_found;

   /* make sure all the tables are up to date before we allow compiles to
    * succeed */
   PR_STATIC_ASSERT(sizeof(options_init) / sizeof(secuCommandFlag) == opt_last);
   PR_STATIC_ASSERT(sizeof(options_init) / sizeof(secuCommandFlag) ==
                    sizeof(options_des) / sizeof(commandDescript));

   /* print the base usage */
   fprintf(stderr, "usage: %s ", prog);
   for (i = 0, words_found = 0; i < count; i++) {
       if (!options_des[i].required) {
           fprintf(stderr, "[");
       }
       if (options_init[i].longform) {
           fprintf(stderr, "--%s", options_init[i].longform);
           words_found++;
       } else {
           fprintf(stderr, "-%c", options_init[i].flag);
       }
       if (options_init[i].needsArg) {
           if (options_des[i].arg) {
               fprintf(stderr, " %s", options_des[i].arg);
           } else {
               fprintf(stderr, " arg");
           }
           words_found++;
       }
       if (!options_des[i].required) {
           fprintf(stderr, "]");
       }
       if (i < count - 1) {
           if (words_found >= 5) {
               fprintf(stderr, "\n      ");
               words_found = 0;
           } else {
               fprintf(stderr, " ");
           }
       }
   }
   fprintf(stderr, "\n");
}

/*
* print out long help. like short_help, this does not exit
*/
static void
long_help(const char *prog)
{
   int i;
   int count = opt_last;

   short_help(prog);
   /* print the option descriptions */
   fprintf(stderr, "\n");
   for (i = 0; i < count; i++) {
       fprintf(stderr, "        ");
       if (options_init[i].flag) {
           fprintf(stderr, "-%c", options_init[i].flag);
           if (options_init[i].longform) {
               fprintf(stderr, ",");
           }
       }
       if (options_init[i].longform) {
           fprintf(stderr, "--%s", options_init[i].longform);
       }
       if (options_init[i].needsArg) {
           if (options_des[i].arg) {
               fprintf(stderr, " %s", options_des[i].arg);
           } else {
               fprintf(stderr, " arg");
           }
           if (options_init[i].arg) {
               fprintf(stderr, " (default = \"%s\")", options_init[i].arg);
           }
       }
       fprintf(stderr, "\n%s", options_des[i].des);
   }
}

/*
* record summary data
*/
struct bufferData {
   char *data; /* lowest address of the buffer */
   char *next; /* pointer to the next element on the buffer */
   int len;    /* length of the buffer */
};

/* our actual buffer. If data is NULL, then all append ops
* except are noops */
static struct bufferData buffer = { NULL, NULL, 0 };

#define CHUNK_SIZE 1000

/*
* get our initial data. and set the buffer variables up. on failure,
* just don't initialize the buffer.
*/
static void
initBuffer(void)
{
   buffer.data = PORT_Alloc(CHUNK_SIZE);
   if (!buffer.data) {
       return;
   }
   buffer.next = buffer.data;
   buffer.len = CHUNK_SIZE;
}

/*
* grow the buffer. If we can't get more data, record a 'D' in the second
* to last record and allow the rest of the data to overwrite the last
* element.
*/
static void
growBuffer(void)
{
   char *new = PORT_Realloc(buffer.data, buffer.len + CHUNK_SIZE);
   if (!new) {
       buffer.data[buffer.len - 2] = 'D'; /* signal malloc failure in summary */
       /* buffer must always point to good memory if it exists */
       buffer.next = buffer.data + (buffer.len - 1);
       return;
   }
   buffer.next = new + (buffer.next - buffer.data);
   buffer.data = new;
   buffer.len += CHUNK_SIZE;
}

/*
* append a label, doubles as appending a single character.
*/
static void
appendLabel(char label)
{
   if (!buffer.data) {
       return;
   }

   *buffer.next++ = label;
   if (buffer.data + buffer.len >= buffer.next) {
       growBuffer();
   }
}

/*
* append a string onto the buffer. The result will be <string>
*/
static void
appendString(char *string)
{
   if (!buffer.data) {
       return;
   }

   appendLabel('<');
   while (*string) {
       appendLabel(*string++);
   }
   appendLabel('>');
}

/*
* append a bool, T= true, F=false
*/
static void
appendBool(PRBool bool)
{
   if (!buffer.data) {
       return;
   }

   if (bool) {
       appendLabel('t');
   } else {
       appendLabel('f');
   }
}

/*
* append a single hex nibble.
*/
static void
appendHex(unsigned char nibble)
{
   if (nibble <= 9) {
       appendLabel('0' + nibble);
   } else {
       appendLabel('a' + nibble - 10);
   }
}

/*
* append a 32 bit integer (even on a 64 bit platform).
* for simplicity append it as a hex value, full extension with 0x prefix.
*/
static void
appendInt(unsigned int value)
{
   int i;

   if (!buffer.data) {
       return;
   }

   appendLabel('0');
   appendLabel('x');
   value = value & 0xffffffff; /* only look at the buttom 8 bytes */
   for (i = 0; i < 8; i++) {
       appendHex(value >> 28);
       value = value << 4;
   }
}

/* append a trust flag */
static void
appendFlags(unsigned int flag)
{
   char trust[10];
   char *cp = trust;

   trust[0] = 0;
   printflags(trust, flag);
   while (*cp) {
       appendLabel(*cp++);
   }
}

/*
* dump our buffer out with a result= flag so we can find it easily.
* free the buffer as a side effect.
*/
static void
dumpBuffer(void)
{
   if (!buffer.data) {
       return;
   }

   appendLabel(0); /* terminate */
   printf("\nresult=%s\n", buffer.data);
   PORT_Free(buffer.data);
   buffer.data = buffer.next = NULL;
   buffer.len = 0;
}

/*
* usage, like traditional usage, automatically exit
*/
static void
usage(const char *prog)
{
   short_help(prog);
   dumpBuffer();
   exit(1);
}

/*
* like usage, except prints the long version of help
*/
static void
usage_long(const char *prog)
{
   long_help(prog);
   dumpBuffer();
   exit(1);
}

static const char *
bool2String(PRBool bool)
{
   return bool ? "true" : "false";
}

/*
* print out interesting info about the given slot
*/
void
print_slot(PK11SlotInfo *slot, int log)
{
   if (log) {
       fprintf(stderr, "* Name=%s Token_Name=%s present=%s, ro=%s *\n",
               PK11_GetSlotName(slot), PK11_GetTokenName(slot),
               bool2String(PK11_IsPresent(slot)),
               bool2String(PK11_IsReadOnly(slot)));
   }
   appendLabel('S');
   appendString(PK11_GetTokenName(slot));
   appendBool(PK11_IsPresent(slot));
   appendBool(PK11_IsReadOnly(slot));
}

/*
* list all our slots
*/
void
do_list_slots(const char *progName, int log)
{
   PK11SlotList *list;
   PK11SlotListElement *le;

   list = PK11_GetAllTokens(CKM_INVALID_MECHANISM, PR_FALSE, PR_FALSE, NULL);
   if (list == NULL) {
       fprintf(stderr, "ERROR: no tokens found %s\n",
               SECU_Strerror(PORT_GetError()));
       appendLabel('S');
       appendString("none");
       return;
   }

   for (le = PK11_GetFirstSafe(list); le;
        le = PK11_GetNextSafe(list, le, PR_TRUE)) {
       print_slot(le->slot, log);
   }
   PK11_FreeSlotList(list);
}

static PRBool
sort_CN(CERTCertificate *certa, CERTCertificate *certb, void *arg)
{
   char *commonNameA, *commonNameB;
   int ret;

   commonNameA = CERT_GetCommonName(&certa->subject);
   commonNameB = CERT_GetCommonName(&certb->subject);

   if (commonNameA == NULL) {
       PORT_Free(commonNameB);
       return PR_TRUE;
   }
   if (commonNameB == NULL) {
       PORT_Free(commonNameA);
       return PR_FALSE;
   }
   ret = PORT_Strcmp(commonNameA, commonNameB);
   PORT_Free(commonNameA);
   PORT_Free(commonNameB);
   return (ret < 0) ? PR_TRUE : PR_FALSE;
}

/*
* list all the certs
*/
void
do_list_certs(const char *progName, int log)
{
   CERTCertList *list;
   CERTCertList *sorted;
   CERTCertListNode *node;
   CERTCertTrust trust;
   unsigned int i;

   list = PK11_ListCerts(PK11CertListUnique, NULL);
   if (list == NULL) {
       fprintf(stderr, "ERROR: no certs found %s\n",
               SECU_Strerror(PORT_GetError()));
       appendLabel('C');
       appendString("none");
       return;
   }

   sorted = CERT_NewCertList();
   if (sorted == NULL) {
       fprintf(stderr, "ERROR: no certs found %s\n",
               SECU_Strerror(PORT_GetError()));
       appendLabel('C');
       appendLabel('E');
       appendInt(PORT_GetError());
       return;
   }

   /* sort the list */
   for (node = CERT_LIST_HEAD(list); !CERT_LIST_END(node, list);
        node = CERT_LIST_NEXT(node)) {
       CERT_AddCertToListSorted(sorted, node->cert, sort_CN, NULL);
   }

   for (node = CERT_LIST_HEAD(sorted); !CERT_LIST_END(node, sorted);
        node = CERT_LIST_NEXT(node)) {
       CERTCertificate *cert = node->cert;
       char *commonName;

       SECU_PrintCertNickname(node, stderr);
       if (log) {
           fprintf(stderr, "*	Slot=%s*\n", cert->slot ? PK11_GetTokenName(cert->slot) : "none");
           fprintf(stderr, "*	Nickname=%s*\n", cert->nickname);
           fprintf(stderr, "*	Subject=<%s>*\n", cert->subjectName);
           fprintf(stderr, "*	Issuer=<%s>*\n", cert->issuerName);
           fprintf(stderr, "*	SN=");
           for (i = 0; i < cert->serialNumber.len; i++) {
               if (i != 0)
                   fprintf(stderr, ":");
               fprintf(stderr, "%02x", cert->serialNumber.data[0]);
           }
           fprintf(stderr, " *\n");
       }
       appendLabel('C');
       commonName = CERT_GetCommonName(&cert->subject);
       appendString(commonName ? commonName : "*NoName*");
       PORT_Free(commonName);
       if (CERT_GetCertTrust(cert, &trust) == SECSuccess) {
           appendFlags(trust.sslFlags);
           appendFlags(trust.emailFlags);
           appendFlags(trust.objectSigningFlags);
       }
   }
   CERT_DestroyCertList(list);
}

/*
* need to implement yet... try to add a new certificate
*/
void
do_add_cert(const char *progName, int log)
{
   PORT_Assert(/* do_add_cert not implemented */ 0);
}

/*
* display the current key slot
*/
void
do_key_slot(const char *progName, int log)
{
   PK11SlotInfo *slot = PK11_GetInternalKeySlot();
   if (!slot) {
       fprintf(stderr, "ERROR: no internal key slot found %s\n",
               SECU_Strerror(PORT_GetError()));
       appendLabel('K');
       appendLabel('S');
       appendString("none");
   }
   print_slot(slot, log);
   PK11_FreeSlot(slot);
}

/*
* execute some NSS command.
*/
void
do_command(const char *label, int initialized, secuCommandFlag *command,
          const char *progName, int log)
{
   char *command_string;
   if (!initialized) {
       return;
   }

   if (command->activated) {
       command_string = command->arg;
   } else {
       command_string = "none";
   }

   if (log) {
       fprintf(stderr, "*Executing nss command \"%s\" for %s*\n",
               command_string, label);
   }

   /* do something */
   if (PORT_Strcasecmp(command_string, "list_slots") == 0) {
       do_list_slots(progName, log);
   } else if (PORT_Strcasecmp(command_string, "list_certs") == 0) {
       do_list_certs(progName, log);
   } else if (PORT_Strcasecmp(command_string, "add_cert") == 0) {
       do_add_cert(progName, log);
   } else if (PORT_Strcasecmp(command_string, "key_slot") == 0) {
       do_key_slot(progName, log);
   } else if (PORT_Strcasecmp(command_string, "none") != 0) {
       fprintf(stderr, ">> Unknown command (%s)\n", command_string);
       appendLabel('E');
       appendString("bc");
       usage_long(progName);
   }
}

/*
* functions do handle
* different library initializations.
*/
static int main_initialized;
static int lib1_initialized;
static int lib2_initialized;

void
main_Init(secuCommandFlag *db, secuCommandFlag *tokNam,
         int readOnly, const char *progName, int log)
{
   SECStatus rv;
   if (log) {
       fprintf(stderr, "*NSS_Init for the main program*\n");
   }
   appendLabel('M');
   if (!db->activated) {
       fprintf(stderr, ">> No main_db has been specified\n");
       usage(progName);
   }
   if (main_initialized) {
       fprintf(stderr, "Warning: Second initialization of Main\n");
       appendLabel('E');
       appendString("2M");
   }
   if (tokNam->activated) {
       PK11_ConfigurePKCS11(NULL, NULL, NULL, tokNam->arg,
                            NULL, NULL, NULL, NULL, 0, 0);
   }
   rv = NSS_Initialize(db->arg, "", "", "",
                       NSS_INIT_NOROOTINIT |
                           (readOnly ? NSS_INIT_READONLY : 0));
   if (rv != SECSuccess) {
       appendLabel('E');
       appendInt(PORT_GetError());
       fprintf(stderr, ">> %s\n", SECU_Strerror(PORT_GetError()));
       dumpBuffer();
       exit(1);
   }
   main_initialized = 1;
}

void
main_Do(secuCommandFlag *command, const char *progName, int log)
{
   do_command("main", main_initialized, command, progName, log);
}

void
main_Shutdown(int old_style, const char *progName, int log)
{
   SECStatus rv;
   appendLabel('N');
   if (log) {
       fprintf(stderr, "*NSS_Shutdown for the main program*\n");
   }
   if (!main_initialized) {
       fprintf(stderr, "Warning: Main shutdown without corresponding init\n");
   }
   if (old_style) {
       rv = NSS_Shutdown();
   } else {
       rv = NSS_ShutdownContext(NULL);
   }
   fprintf(stderr, "Shutdown main state = %d\n", rv);
   if (rv != SECSuccess) {
       appendLabel('E');
       appendInt(PORT_GetError());
       fprintf(stderr, "ERROR: %s\n", SECU_Strerror(PORT_GetError()));
   }
   main_initialized = 0;
}

/* common library init */
NSSInitContext *
lib_Init(const char *lableString, char label, int initialized,
        secuCommandFlag *db, secuCommandFlag *tokNam, int readonly,
        const char *progName, int log)
{
   NSSInitContext *ctxt;
   NSSInitParameters initStrings;
   NSSInitParameters *initStringPtr = NULL;

   appendLabel(label);
   if (log) {
       fprintf(stderr, "*NSS_Init for %s*\n", lableString);
   }

   if (!db->activated) {
       fprintf(stderr, ">> No %s_db has been specified\n", lableString);
       usage(progName);
   }
   if (initialized) {
       fprintf(stderr, "Warning: Second initialization of %s\n", lableString);
   }
   if (tokNam->activated) {
       PORT_Memset(&initStrings, 0, sizeof(initStrings));
       initStrings.length = sizeof(initStrings);
       initStrings.dbTokenDescription = tokNam->arg;
       initStringPtr = &initStrings;
   }
   ctxt = NSS_InitContext(db->arg, "", "", "", initStringPtr,
                          NSS_INIT_NOROOTINIT |
                              (readonly ? NSS_INIT_READONLY : 0));
   if (ctxt == NULL) {
       appendLabel('E');
       appendInt(PORT_GetError());
       fprintf(stderr, ">> %s\n", SECU_Strerror(PORT_GetError()));
       dumpBuffer();
       exit(1);
   }
   return ctxt;
}

/* common library shutdown */
void
lib_Shutdown(const char *labelString, char label, NSSInitContext *ctx,
            int initialize, const char *progName, int log)
{
   SECStatus rv;
   appendLabel(label);
   if (log) {
       fprintf(stderr, "*NSS_Shutdown for %s\n*", labelString);
   }
   if (!initialize) {
       fprintf(stderr, "Warning: %s shutdown without corresponding init\n",
               labelString);
   }
   rv = NSS_ShutdownContext(ctx);
   fprintf(stderr, "Shutdown %s state = %d\n", labelString, rv);
   if (rv != SECSuccess) {
       appendLabel('E');
       appendInt(PORT_GetError());
       fprintf(stderr, "ERROR: %s\n", SECU_Strerror(PORT_GetError()));
   }
}

static NSSInitContext *lib1_context;
static NSSInitContext *lib2_context;
void
lib1_Init(secuCommandFlag *db, secuCommandFlag *tokNam,
         int readOnly, const char *progName, int log)
{
   lib1_context = lib_Init("lib1", '1', lib1_initialized, db, tokNam,
                           readOnly, progName, log);
   lib1_initialized = 1;
}

void
lib2_Init(secuCommandFlag *db, secuCommandFlag *tokNam,
         int readOnly, const char *progName, int log)
{
   lib2_context = lib_Init("lib2", '2', lib2_initialized,
                           db, tokNam, readOnly, progName, log);
   lib2_initialized = 1;
}

void
lib1_Do(secuCommandFlag *command, const char *progName, int log)
{
   do_command("lib1", lib1_initialized, command, progName, log);
}

void
lib2_Do(secuCommandFlag *command, const char *progName, int log)
{
   do_command("lib2", lib2_initialized, command, progName, log);
}

void
lib1_Shutdown(const char *progName, int log)
{
   lib_Shutdown("lib1", 'I', lib1_context, lib1_initialized, progName, log);
   lib1_initialized = 0;
   /* don't clear lib1_Context, so we can test multiple attempts to close
    * the same context produces correct errors*/
}

void
lib2_Shutdown(const char *progName, int log)
{
   lib_Shutdown("lib2", 'Z', lib2_context, lib2_initialized, progName, log);
   lib2_initialized = 0;
   /* don't clear lib2_Context, so we can test multiple attempts to close
    * the same context produces correct errors*/
}

int
main(int argc, char **argv)
{
   SECStatus rv;
   secuCommand libinit;
   char *progName;
   char *order;
   secuCommandFlag *options;
   int log = 0;

   progName = strrchr(argv[0], '/');
   progName = progName ? progName + 1 : argv[0];

   libinit.numCommands = 0;
   libinit.commands = 0;
   libinit.numOptions = opt_last;
   options = (secuCommandFlag *)PORT_Alloc(sizeof(options_init));
   if (options == NULL) {
       fprintf(stderr, ">> %s:Not enough free memory to run command\n",
               progName);
       exit(1);
   }
   PORT_Memcpy(options, options_init, sizeof(options_init));
   libinit.options = options;

   rv = SECU_ParseCommandLine(argc, argv, progName, &libinit);
   if (rv != SECSuccess) {
       usage(progName);
   }

   if (libinit.options[opt_help].activated) {
       long_help(progName);
       exit(0);
   }

   log = libinit.options[opt_verbose].activated;
   if (libinit.options[opt_summary].activated) {
       initBuffer();
   }

   order = libinit.options[opt_liborder].arg;
   if (!order) {
       usage(progName);
   }

   if (log) {
       fprintf(stderr, "* initializing with order \"%s\"*\n", order);
   }

   for (; *order; order++) {
       switch (*order) {
           case 'M':
               main_Init(&libinit.options[opt_mainDB],
                         &libinit.options[opt_mainTokNam],
                         libinit.options[opt_mainRO].activated,
                         progName, log);
               break;
           case '1':
               lib1_Init(&libinit.options[opt_lib1DB],
                         &libinit.options[opt_lib1TokNam],
                         libinit.options[opt_lib1RO].activated,
                         progName, log);
               break;
           case '2':
               lib2_Init(&libinit.options[opt_lib2DB],
                         &libinit.options[opt_lib2TokNam],
                         libinit.options[opt_lib2RO].activated,
                         progName, log);
               break;
           case 'm':
               main_Shutdown(libinit.options[opt_oldStyle].activated,
                             progName, log);
               break;
           case 'i':
               lib1_Shutdown(progName, log);
               break;
           case 'z':
               lib2_Shutdown(progName, log);
               break;
           default:
               fprintf(stderr, ">> Unknown init/shutdown command \"%c\"", *order);
               usage_long(progName);
       }
       main_Do(&libinit.options[opt_mainCMD], progName, log);
       lib1_Do(&libinit.options[opt_lib1CMD], progName, log);
       lib2_Do(&libinit.options[opt_lib2CMD], progName, log);
   }

   if (NSS_IsInitialized()) {
       appendLabel('X');
       fprintf(stderr, "Warning: NSS is initialized\n");
   }
   dumpBuffer();

   exit(0);
}