Update NSS to NSS 3.14 pre-release snapshot 2012-06-28 01:00:00 PDT.

mozilla/security/nss/lib/pk11wrap/pk11pars.c

 /* 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/. */
 /*
  * The following handles the loading, unloading and management of
  * various PCKS #11 modules
  */
 
 #include <ctype.h>
 #include "pkcs11.h"
 #include "seccomon.h"
 #include "secmod.h"
 #include "secmodi.h"
 #include "secmodti.h"
 #include "pki3hack.h"
 #include "secerr.h"
    
-#include "pk11pars.h" 
+#include "utilpars.h" 
 
 /* create a new module */
 static  SECMODModule *
 secmod_NewModule(void)
 {
     SECMODModule *newMod;
     PRArenaPool *arena;
 
 
     /* create an arena in which dllName and commonName can be
@@ skipping 112 matching lines @@
     if (mod == NULL) return NULL;
 
     mod->commonName = PORT_ArenaStrdup(mod->arena,moduleName ? moduleName : "");
     if (library) {
         mod->dllName = PORT_ArenaStrdup(mod->arena,library);
     }
     /* new field */
     if (parameters) {
         mod->libraryParams = PORT_ArenaStrdup(mod->arena,parameters);
     }
-    mod->internal   = secmod_argHasFlag("flags","internal",nssc);
-    mod->isFIPS     = secmod_argHasFlag("flags","FIPS",nssc);
-    mod->isCritical = secmod_argHasFlag("flags","critical",nssc);
-    slotParams      = secmod_argGetParamValue("slotParams",nssc);
-    mod->slotInfo   = secmod_argParseSlotInfo(mod->arena,slotParams,
+    mod->internal   = NSSUTIL_ArgHasFlag("flags","internal",nssc);
+    mod->isFIPS     = NSSUTIL_ArgHasFlag("flags","FIPS",nssc);
+    mod->isCritical = NSSUTIL_ArgHasFlag("flags","critical",nssc);
+    slotParams      = NSSUTIL_ArgGetParamValue("slotParams",nssc);
+    mod->slotInfo   = NSSUTIL_ArgParseSlotInfo(mod->arena,slotParams,
                                                         &mod->slotInfoCount);
     if (slotParams) PORT_Free(slotParams);
     /* new field */
-    mod->trustOrder  = secmod_argReadLong("trustOrder",nssc,
-                                        SECMOD_DEFAULT_TRUST_ORDER,NULL);
+    mod->trustOrder  = NSSUTIL_ArgReadLong("trustOrder",nssc,
+                                        NSSUTIL_DEFAULT_TRUST_ORDER,NULL);
     /* new field */
-    mod->cipherOrder = secmod_argReadLong("cipherOrder",nssc,
-                                        SECMOD_DEFAULT_CIPHER_ORDER,NULL);
+    mod->cipherOrder = NSSUTIL_ArgReadLong("cipherOrder",nssc,
+                                        NSSUTIL_DEFAULT_CIPHER_ORDER,NULL);
     /* new field */
-    mod->isModuleDB   = secmod_argHasFlag("flags","moduleDB",nssc);
-    mod->moduleDBOnly = secmod_argHasFlag("flags","moduleDBOnly",nssc);
+    mod->isModuleDB   = NSSUTIL_ArgHasFlag("flags","moduleDB",nssc);
+    mod->moduleDBOnly = NSSUTIL_ArgHasFlag("flags","moduleDBOnly",nssc);
     if (mod->moduleDBOnly) mod->isModuleDB = PR_TRUE;
 
     /* we need more bits, but we also want to preserve binary compatibility 
      * so we overload the isModuleDB PRBool with additional flags. 
      * These flags are only valid if mod->isModuleDB is already set.
      * NOTE: this depends on the fact that PRBool is at least a char on 
      * all platforms. These flags are only valid if moduleDB is set, so 
      * code checking if (mod->isModuleDB) will continue to work correctly. */
     if (mod->isModuleDB) {
         char flags = SECMOD_FLAG_MODULE_DB_IS_MODULE_DB;
-        if (secmod_argHasFlag("flags","skipFirst",nssc)) {
+        if (NSSUTIL_ArgHasFlag("flags","skipFirst",nssc)) {
             flags |= SECMOD_FLAG_MODULE_DB_SKIP_FIRST;
         }
-        if (secmod_argHasFlag("flags","defaultModDB",nssc)) {
+        if (NSSUTIL_ArgHasFlag("flags","defaultModDB",nssc)) {
             flags |= SECMOD_FLAG_MODULE_DB_DEFAULT_MODDB;
         }
         /* additional moduleDB flags could be added here in the future */
         mod->isModuleDB = (PRBool) flags;
     }
 
     if (mod->internal) {
         char flags = SECMOD_FLAG_INTERNAL_IS_INTERNAL;
 
-        if (secmod_argHasFlag("flags", "internalKeySlot", nssc)) {
+        if (NSSUTIL_ArgHasFlag("flags", "internalKeySlot", nssc)) {
             flags |= SECMOD_FLAG_INTERNAL_KEY_SLOT;
         }
         mod->internal = (PRBool) flags;
     }
 
-    ciphers = secmod_argGetParamValue("ciphers",nssc);
-    secmod_argSetNewCipherFlags(&mod->ssl[0],ciphers);
+    ciphers = NSSUTIL_ArgGetParamValue("ciphers",nssc);
+    NSSUTIL_ArgParseCipherFlags(&mod->ssl[0],ciphers);
     if (ciphers) PORT_Free(ciphers);
 
     secmod_PrivateModuleCount++;
 
     return mod;
 }
 
 PRBool
 SECMOD_GetSkipFirstFlag(SECMODModule *mod)
 {
@@ skipping 24 matching lines @@
    char flags = (char) mod->internal;
 
    if (val)  {
         flags |= SECMOD_FLAG_INTERNAL_KEY_SLOT;
    } else {
         flags &= ~SECMOD_FLAG_INTERNAL_KEY_SLOT;
    }
    mod->internal = flags;
 }
 
-/* forward declarations */
-static int secmod_escapeSize(const char *string, char quote);
-static char *secmod_addEscape(const char *string, char quote);
-
 /*
  * copy desc and value into target. Target is known to be big enough to
  * hold desc +2 +value, which is good because the result of this will be
  * *desc"*value". We may, however, have to add some escapes for special
  * characters imbedded into value (rare). This string potentially comes from
  * a user, so we don't want the user overflowing the target buffer by using
  * excessive escapes. To prevent this we count the escapes we need to add and
  * try to expand the buffer with Realloc.
  */
 static char *
 secmod_doDescCopy(char *target, int *targetLen, const char *desc,
                         int descLen, char *value)
 {
     int diff, esc_len;
 
-    esc_len = secmod_escapeSize(value, '\"') - 1;
+    esc_len = NSSUTIL_EscapeSize(value, '\"') - 1;
     diff = esc_len - strlen(value);
     if (diff > 0) {
         /* we need to escape... expand newSpecPtr as well to make sure
          * we don't overflow it */
         char *newPtr = PORT_Realloc(target, *targetLen * diff);
         if (!newPtr) {
             return target; /* not enough space, just drop the whole copy */
         }
         *targetLen += diff;
         target = newPtr;
-        value = secmod_addEscape(value, '\"');
+        value = NSSUTIL_Escape(value, '\"');
         if (value == NULL) {
             return target; /* couldn't escape value, just drop the copy */
         }
     }
     PORT_Memcpy(target, desc, descLen);
     target += descLen;
     *target++='\"';
     PORT_Memcpy(target, value, esc_len);
     target += esc_len;
     *target++='\"';
+    if (diff > 0) {
+        PORT_Free(value);
+    }
     return target;
 }
 
 #define SECMOD_SPEC_COPY(new, start, end)    \
   if (end > start) {                         \
         int _cnt = end - start;              \
         PORT_Memcpy(new, start, _cnt);       \
         new += _cnt;                         \
   }
 #define SECMOD_TOKEN_DESCRIPTION "tokenDescription="
@@ skipping 27 matching lines @@
     int        i;
 
     if (newSpec == NULL) {
         return NULL;
     }
 
     *children = NULL;
     if (ids) {
         *ids = NULL;
     }
-    moduleSpec = secmod_argStrip(moduleSpec);
+    moduleSpec = NSSUTIL_ArgStrip(moduleSpec);
     SECMOD_SPEC_COPY(newSpecPtr, modulePrev, moduleSpec);
 
     /* Notes on 'convert' and 'isFIPS' flags: The base parameters for opening 
      * a new softoken module takes the following parameters to name the 
      * various tokens:
      *  
      *  cryptoTokenDescription: name of the non-fips crypto token.
      *  cryptoSlotDescription: name of the non-fips crypto slot.
      *  dbTokenDescription: name of the non-fips db token.
      *  dbSlotDescription: name of the non-fips db slot.
@@ skipping 11 matching lines @@
      * (either db or FIPS based on the isFIPS flag) to tokenDescription and 
      * slotDescription).
      */
     /*
      * walk down the list. if we find a tokens= argument, save it,
      * otherise copy the argument.
      */
     while (*moduleSpec) {
         int next;
         modulePrev = moduleSpec;
-        SECMOD_HANDLE_STRING_ARG(moduleSpec, target, "tokens=",
+        NSSUTIL_HANDLE_STRING_ARG(moduleSpec, target, "tokens=",
                         modulePrev = moduleSpec; /* skip copying */ )
-        SECMOD_HANDLE_STRING_ARG(moduleSpec, tmp, "cryptoTokenDescription=",
+        NSSUTIL_HANDLE_STRING_ARG(moduleSpec, tmp, "cryptoTokenDescription=",
                         if (convert) { modulePrev = moduleSpec; } );
-        SECMOD_HANDLE_STRING_ARG(moduleSpec, tmp, "cryptoSlotDescription=",
+        NSSUTIL_HANDLE_STRING_ARG(moduleSpec, tmp, "cryptoSlotDescription=",
                         if (convert) { modulePrev = moduleSpec; } );
-        SECMOD_HANDLE_STRING_ARG(moduleSpec, tmp, "dbTokenDescription=",
+        NSSUTIL_HANDLE_STRING_ARG(moduleSpec, tmp, "dbTokenDescription=",
                         if (convert) {
                             modulePrev = moduleSpec; 
                             if (!isFIPS) {
                                 newSpecPtr = secmod_doDescCopy(newSpecPtr, 
                                     &newSpecLen, SECMOD_TOKEN_DESCRIPTION, 
                                     sizeof(SECMOD_TOKEN_DESCRIPTION)-1, tmp);
                             }
                         });
-        SECMOD_HANDLE_STRING_ARG(moduleSpec, tmp, "dbSlotDescription=",
+        NSSUTIL_HANDLE_STRING_ARG(moduleSpec, tmp, "dbSlotDescription=",
                         if (convert) {
                             modulePrev = moduleSpec; /* skip copying */ 
                             if (!isFIPS) {
                                 newSpecPtr = secmod_doDescCopy(newSpecPtr, 
                                     &newSpecLen, SECMOD_SLOT_DESCRIPTION, 
                                     sizeof(SECMOD_SLOT_DESCRIPTION)-1, tmp);
                             }
                         } );
-        SECMOD_HANDLE_STRING_ARG(moduleSpec, tmp, "FIPSTokenDescription=",
+        NSSUTIL_HANDLE_STRING_ARG(moduleSpec, tmp, "FIPSTokenDescription=",
                         if (convert) {
                             modulePrev = moduleSpec; /* skip copying */ 
                             if (isFIPS) {
                                 newSpecPtr = secmod_doDescCopy(newSpecPtr, 
                                     &newSpecLen, SECMOD_TOKEN_DESCRIPTION, 
                                     sizeof(SECMOD_TOKEN_DESCRIPTION)-1, tmp);
                             }
                         } );
-        SECMOD_HANDLE_STRING_ARG(moduleSpec, tmp, "FIPSSlotDescription=",
+        NSSUTIL_HANDLE_STRING_ARG(moduleSpec, tmp, "FIPSSlotDescription=",
                         if (convert) {
                             modulePrev = moduleSpec; /* skip copying */ 
                             if (isFIPS) {
                                 newSpecPtr = secmod_doDescCopy(newSpecPtr, 
                                     &newSpecLen, SECMOD_SLOT_DESCRIPTION, 
                                     sizeof(SECMOD_SLOT_DESCRIPTION)-1, tmp);
                             }
                         } );
-        SECMOD_HANDLE_FINAL_ARG(moduleSpec)
+        NSSUTIL_HANDLE_FINAL_ARG(moduleSpec)
         SECMOD_SPEC_COPY(newSpecPtr, modulePrev, moduleSpec);
     }
     if (tmp) {
         PORT_Free(tmp);
         tmp = NULL;
     }
     *newSpecPtr = 0;
 
     /* no target found, return the newSpec */
     if (target == NULL) {
         return newSpec;
     }
 
     /* now build the child array from target */
     /*first count them */
-    for (tokenIndex = secmod_argStrip(target); *tokenIndex;
-        tokenIndex = secmod_argStrip(secmod_argSkipParameter(tokenIndex))) {
+    for (tokenIndex = NSSUTIL_ArgStrip(target); *tokenIndex;
+        tokenIndex = NSSUTIL_ArgStrip(NSSUTIL_ArgSkipParameter(tokenIndex))) {
         tokenCount++;
     }
 
     childArray = PORT_NewArray(char *, tokenCount+1);
     if (childArray == NULL) {
         /* just return the spec as is then */
         PORT_Free(target);
         return newSpec;
     }
     if (ids) {
         idArray = PORT_NewArray(CK_SLOT_ID, tokenCount+1);
         if (idArray == NULL) {
             PORT_Free(childArray);
             PORT_Free(target);
             return newSpec;
         }
     }
 
     /* now fill them in */
-    for (tokenIndex = secmod_argStrip(target), i=0 ; 
+    for (tokenIndex = NSSUTIL_ArgStrip(target), i=0 ; 
                         *tokenIndex && (i < tokenCount); 
-                        tokenIndex=secmod_argStrip(tokenIndex)) {
+                        tokenIndex=NSSUTIL_ArgStrip(tokenIndex)) {
         int next;
-        char *name = secmod_argGetName(tokenIndex, &next);
+        char *name = NSSUTIL_ArgGetLabel(tokenIndex, &next);
         tokenIndex += next;
 
         if (idArray) {
-           idArray[i] = secmod_argDecodeNumber(name);
+           idArray[i] = NSSUTIL_ArgDecodeNumber(name);
         }
 
         PORT_Free(name); /* drop the explicit number */
 
         /* if anything is left, copy the args to the child array */
-        if (!secmod_argIsBlank(*tokenIndex)) {
-            childArray[i++] = secmod_argFetchValue(tokenIndex, &next);
+        if (!NSSUTIL_ArgIsBlank(*tokenIndex)) {
+            childArray[i++] = NSSUTIL_ArgFetchValue(tokenIndex, &next);
             tokenIndex += next;
         }
     }
 
     PORT_Free(target);
     childArray[i] = 0;
     if (idArray) {
         idArray[i] = 0;
     }
 
     /* return it */
     *children = childArray;
     if (ids) {
         *ids = idArray;
     }
     return newSpec;
 }
 
 /* get the database and flags from the spec */
 static char *
 secmod_getConfigDir(char *spec, char **certPrefix, char **keyPrefix,
                           PRBool *readOnly)
 {
     char * config = NULL;
 
     *certPrefix = NULL;
     *keyPrefix = NULL;
-    *readOnly = secmod_argHasFlag("flags","readOnly",spec);
+    *readOnly = NSSUTIL_ArgHasFlag("flags","readOnly",spec);
 
-    spec = secmod_argStrip(spec);
+    spec = NSSUTIL_ArgStrip(spec);
     while (*spec) {
         int next;
-        SECMOD_HANDLE_STRING_ARG(spec, config, "configdir=", ;)
-        SECMOD_HANDLE_STRING_ARG(spec, *certPrefix, "certPrefix=", ;)
-        SECMOD_HANDLE_STRING_ARG(spec, *keyPrefix, "keyPrefix=", ;)
-        SECMOD_HANDLE_FINAL_ARG(spec)
+        NSSUTIL_HANDLE_STRING_ARG(spec, config, "configdir=", ;)
+        NSSUTIL_HANDLE_STRING_ARG(spec, *certPrefix, "certPrefix=", ;)
+        NSSUTIL_HANDLE_STRING_ARG(spec, *keyPrefix, "keyPrefix=", ;)
+        NSSUTIL_HANDLE_FINAL_ARG(spec)
     }
     return config;
 }
 
 struct SECMODConfigListStr {
     char *config;
     char *certPrefix;
     char *keyPrefix;
     PRBool isReadOnly;
 };
@@ skipping 160 matching lines @@
     for (thisChild = children; thisChild && *thisChild; thisChild++ ) {
         PORT_Free(*thisChild);
     }
     PORT_Free(children);
     if (ids) {
         PORT_Free(ids);
     }
     return;
 }
 
-
-static int
-secmod_escapeSize(const char *string, char quote)
-{
-    int escapes = 0, size = 0;
-    const char *src;
-    for (src=string; *src ; src++) {
-        if ((*src == quote) || (*src == '\\')) escapes++;
-        size++;
-    }
-
-    return escapes+size+1;
-}
-
-
-/*
- * add escapes to protect quote characters...
- */
-static char *
-secmod_addEscape(const char *string, char quote)
-{
-    char *newString = 0;
-    int size = 0;
-    const char *src;
-    char *dest;
-
-
-    size = secmod_escapeSize(string,quote);
-    newString = PORT_ZAlloc(size);
-    if (newString == NULL) {
-        return NULL;
-    }
-
-    for (src=string, dest=newString; *src; src++,dest++) {
-        if ((*src == '\\') || (*src == quote)) {
-            *dest++ = '\\';
-        }
-        *dest = *src;
-    }
-
-    return newString;
-}
-
-static int
-secmod_doubleEscapeSize(const char *string, char quote1, char quote2)
-{
-    int escapes = 0, size = 0;
-    const char *src;
-    for (src=string; *src ; src++) {
-        if (*src == '\\')   escapes+=3; /* \\\\ */
-        if (*src == quote1) escapes+=2; /* \\quote1 */
-        if (*src == quote2) escapes++;   /* \quote2 */
-        size++;
-    }
-
-    return escapes+size+1;
-}
-
-char *
-secmod_DoubleEscape(const char *string, char quote1, char quote2)
-{
-    char *round1 = NULL;
-    char *retValue = NULL;
-    if (string == NULL) {
-        goto done;
-    }
-    round1 = secmod_addEscape(string,quote1);
-    if (round1) {
-        retValue = secmod_addEscape(round1,quote2);
-        PORT_Free(round1);
-    }
-
-done:
-    if (retValue == NULL) {
-        retValue = PORT_Strdup("");
-    }
-    return retValue;
-}
-
-
 /*
  * caclulate the length of each child record:
  * " 0x{id}=<{escaped_child}>"
  */
 static int
 secmod_getChildLength(char *child, CK_SLOT_ID id)
 {
-    int length = secmod_doubleEscapeSize(child, '>', ']');
+    int length = NSSUTIL_DoubleEscapeSize(child, '>', ']');
     if (id == 0) {
         length++;
     }
     while (id) {
         length++;
         id = id >> 4;
     }
     length += 6; /* {sp}0x[id]=<{child}> */
     return length;
 }
 
 /*
  * Build a child record:
  * " 0x{id}=<{escaped_child}>"
  */
 static SECStatus
 secmod_mkTokenChild(char **next, int *length, char *child, CK_SLOT_ID id)
 {
     int len;
     char *escSpec;
 
     len = PR_snprintf(*next, *length, " 0x%x=<",id);
     if (len < 0) {
         return SECFailure;
     }
     *next += len;
     *length -= len;
-    escSpec = secmod_DoubleEscape(child, '>', ']');
+    escSpec = NSSUTIL_DoubleEscape(child, '>', ']');
     if (escSpec == NULL) {
         return SECFailure;
     }
     if (*child && (*escSpec == 0)) {
         PORT_Free(escSpec);
         return SECFailure;
     }
     len = strlen(escSpec);
     if (len+1 > *length) {
         PORT_Free(escSpec);
@@ skipping 145 matching lines @@
         goto loser;
     }
 
 
     /* build the slot info strings */
     if (module->slotCount) {
         for (i=0, si= 0; i < module->slotCount; i++) {
             if (module->slots[i]->defaultFlags) {
                 PORT_Assert(si < slotCount);
                 if (si >= slotCount) break;
-                slotStrings[si] = secmod_mkSlotString(module->slots[i]->slotID,
+                slotStrings[si] = NSSUTIL_MkSlotString(module->slots[i]->slotID,
                         module->slots[i]->defaultFlags,
                         module->slots[i]->timeout,
                         module->slots[i]->askpw,
                         module->slots[i]->hasRootCerts,
                         module->slots[i]->hasRootTrust);
                 si++;
             }
         }
      } else {
         for (i=0; i < slotCount; i++) {
-                slotStrings[i] = secmod_mkSlotString(module->slotInfo[i].slotID,
+                slotStrings[i] = NSSUTIL_MkSlotString(
+                        module->slotInfo[i].slotID,
                         module->slotInfo[i].defaultFlags,
                         module->slotInfo[i].timeout,
                         module->slotInfo[i].askpw,
                         module->slotInfo[i].hasRootCerts,
                         module->slotInfo[i].hasRootTrust);
         }
     }
 
     SECMOD_ReleaseReadLock(moduleLock);
-    nss = secmod_mkNSS(slotStrings,slotCount,module->internal, module->isFIPS,
-                       module->isModuleDB, module->moduleDBOnly, 
-                       module->isCritical, module->trustOrder,
-                       module->cipherOrder,module->ssl[0],module->ssl[1]);
-    modSpec= secmod_mkNewModuleSpec(module->dllName,module->commonName,
+    nss = NSSUTIL_MkNSSString(slotStrings,slotCount,module->internal, 
+                       module->isFIPS, module->isModuleDB,
+                       module->moduleDBOnly, module->isCritical,
+                       module->trustOrder, module->cipherOrder,
+                       module->ssl[0],module->ssl[1]);
+    modSpec= NSSUTIL_MkModuleSpec(module->dllName,module->commonName,
                                                 module->libraryParams,nss);
     PORT_Free(slotStrings);
     PR_smprintf_free(nss);
 loser:
     return (modSpec);
 }
     
 
 char **
 SECMOD_GetModuleSpecList(SECMODModule *module)
@@ skipping 67 matching lines @@
 {
     char *library = NULL, *moduleName = NULL, *parameters = NULL, *nss= NULL;
     SECStatus status;
     SECMODModule *module = NULL;
     SECMODModule *oldModule = NULL;
     SECStatus rv;
 
     /* initialize the underlying module structures */
     SECMOD_Init();
 
-    status = secmod_argParseModuleSpec(modulespec, &library, &moduleName, 
+    status = NSSUTIL_ArgParseModuleSpec(modulespec, &library, &moduleName, 
                                                         &parameters, &nss);
     if (status != SECSuccess) {
         goto loser;
     }
 
     module = SECMOD_CreateModule(library, moduleName, parameters, nss);
     if (library) PORT_Free(library);
     if (moduleName) PORT_Free(moduleName);
     if (parameters) PORT_Free(parameters);
     if (nss) PORT_Free(nss);
@@ skipping 126 matching lines @@
 
     SECMOD_GetReadLock(moduleLock);
     rv = STAN_RemoveModuleFromDefaultTrustDomain(mod);
     SECMOD_ReleaseReadLock(moduleLock);
     if (SECSuccess != rv) {
         return SECFailure;
     }
     return SECMOD_DeleteModuleEx(NULL, mod, &atype, PR_FALSE);
 }