1 files changed, 256 insertions, 263 deletions

diff --git a/nss/lib/crmf/crmfreq.c b/nss/lib/crmf/crmfreq.c
index 7da81cd..e89f182 100644
--- a/nss/lib/crmf/crmfreq.c
+++ b/nss/lib/crmf/crmfreq.c
@@ -14,17 +14,16 @@
  */
 #define IS_NOT_NULL(ptr) ((ptr) == NULL) ? PR_FALSE : PR_TRUE
 
-const unsigned char hexTrue  = 0xff;
+const unsigned char hexTrue = 0xff;
 const unsigned char hexFalse = 0x00;
 
-
 SECStatus
 crmf_encode_integer(PLArenaPool *poolp, SECItem *dest, long value)
 {
     SECItem *dummy;
 
     dummy = SEC_ASN1EncodeInteger(poolp, dest, value);
-    PORT_Assert (dummy == dest);
+    PORT_Assert(dummy == dest);
     if (dummy == NULL) {
         return SECFailure;
     }
@@ -33,12 +32,12 @@ crmf_encode_integer(PLArenaPool *poolp, SECItem *dest, long value)
 
 SECStatus
 crmf_encode_unsigned_integer(PLArenaPool *poolp, SECItem *dest,
-                             unsigned long value) 
+                             unsigned long value)
 {
     SECItem *dummy;
 
     dummy = SEC_ASN1EncodeUnsignedInteger(poolp, dest, value);
-    PORT_Assert (dummy == dest);
+    PORT_Assert(dummy == dest);
     if (dummy != dest) {
         return SECFailure;
     }
@@ -46,73 +45,73 @@ crmf_encode_unsigned_integer(PLArenaPool *poolp, SECItem *dest,
 }
 
 static SECStatus
-crmf_copy_secitem (PLArenaPool *poolp, SECItem *dest, SECItem *src)
+crmf_copy_secitem(PLArenaPool *poolp, SECItem *dest, SECItem *src)
 {
-    return  SECITEM_CopyItem (poolp, dest, src); 
+    return SECITEM_CopyItem(poolp, dest, src);
 }
 
 PRBool
-CRMF_DoesRequestHaveField (CRMFCertRequest       *inCertReq, 
-			   CRMFCertTemplateField  inField)
+CRMF_DoesRequestHaveField(CRMFCertRequest *inCertReq,
+                          CRMFCertTemplateField inField)
 {
-  
+
     PORT_Assert(inCertReq != NULL);
     if (inCertReq == NULL) {
         return PR_FALSE;
     }
     switch (inField) {
-    case crmfVersion:
-        return inCertReq->certTemplate.version.data != NULL;
-    case crmfSerialNumber:
-        return inCertReq->certTemplate.serialNumber.data != NULL;
-    case crmfSigningAlg:
-        return inCertReq->certTemplate.signingAlg != NULL;
-    case crmfIssuer:
-        return inCertReq->certTemplate.issuer != NULL;
-    case crmfValidity:
-        return inCertReq->certTemplate.validity != NULL;
-    case crmfSubject:
-        return inCertReq->certTemplate.subject != NULL;
-    case crmfPublicKey:
-        return inCertReq->certTemplate.publicKey != NULL;
-    case crmfIssuerUID:
-        return inCertReq->certTemplate.issuerUID.data != NULL;
-    case crmfSubjectUID:
-        return inCertReq->certTemplate.subjectUID.data != NULL;
-    case crmfExtension:
-        return CRMF_CertRequestGetNumberOfExtensions(inCertReq) != 0;
+        case crmfVersion:
+            return inCertReq->certTemplate.version.data != NULL;
+        case crmfSerialNumber:
+            return inCertReq->certTemplate.serialNumber.data != NULL;
+        case crmfSigningAlg:
+            return inCertReq->certTemplate.signingAlg != NULL;
+        case crmfIssuer:
+            return inCertReq->certTemplate.issuer != NULL;
+        case crmfValidity:
+            return inCertReq->certTemplate.validity != NULL;
+        case crmfSubject:
+            return inCertReq->certTemplate.subject != NULL;
+        case crmfPublicKey:
+            return inCertReq->certTemplate.publicKey != NULL;
+        case crmfIssuerUID:
+            return inCertReq->certTemplate.issuerUID.data != NULL;
+        case crmfSubjectUID:
+            return inCertReq->certTemplate.subjectUID.data != NULL;
+        case crmfExtension:
+            return CRMF_CertRequestGetNumberOfExtensions(inCertReq) != 0;
     }
     return PR_FALSE;
 }
 
 CRMFCertRequest *
-CRMF_CreateCertRequest (PRUint32 inRequestID)
+CRMF_CreateCertRequest(PRUint32 inRequestID)
 {
-    PLArenaPool     *poolp;
+    PLArenaPool *poolp;
     CRMFCertRequest *certReq;
-    SECStatus        rv;
-    
+    SECStatus rv;
+
     poolp = PORT_NewArena(CRMF_DEFAULT_ARENA_SIZE);
     if (poolp == NULL) {
         goto loser;
     }
-    
-    certReq=PORT_ArenaZNew(poolp,CRMFCertRequest);
+
+    certReq = PORT_ArenaZNew(poolp, CRMFCertRequest);
     if (certReq == NULL) {
         goto loser;
     }
 
     certReq->poolp = poolp;
     certReq->requestID = inRequestID;
-    
-    rv = crmf_encode_unsigned_integer(poolp, &(certReq->certReqId), 
+
+    rv = crmf_encode_unsigned_integer(poolp, &(certReq->certReqId),
                                       inRequestID);
     if (rv != SECSuccess) {
         goto loser;
     }
 
     return certReq;
- loser:
+loser:
     if (poolp) {
         PORT_FreeArena(poolp, PR_FALSE);
     }
@@ -125,18 +124,18 @@ CRMF_DestroyCertRequest(CRMFCertRequest *inCertReq)
     PORT_Assert(inCertReq != NULL);
     if (inCertReq != NULL) {
         if (inCertReq->certTemplate.extensions) {
-	    PORT_Free(inCertReq->certTemplate.extensions);
-	}
-	if (inCertReq->controls) {
-	    /* Right now we don't support EnveloppedData option,
-	     * so we won't go through and delete each occurrence of 
-	     * an EnveloppedData in the control.
-	     */
-	    PORT_Free(inCertReq->controls);
-	}
-	if (inCertReq->poolp) {
-	    PORT_FreeArena(inCertReq->poolp, PR_TRUE);
-	}
+            PORT_Free(inCertReq->certTemplate.extensions);
+        }
+        if (inCertReq->controls) {
+            /* Right now we don't support EnveloppedData option,
+             * so we won't go through and delete each occurrence of
+             * an EnveloppedData in the control.
+             */
+            PORT_Free(inCertReq->controls);
+        }
+        if (inCertReq->poolp) {
+            PORT_FreeArena(inCertReq->poolp, PR_TRUE);
+        }
     }
     return SECSuccess;
 }
@@ -154,12 +153,12 @@ crmf_template_add_serialnumber(PLArenaPool *poolp, SECItem *dest, long serial)
 }
 
 SECStatus
-crmf_template_copy_secalg (PLArenaPool *poolp, SECAlgorithmID **dest,
-			   SECAlgorithmID* src)
+crmf_template_copy_secalg(PLArenaPool *poolp, SECAlgorithmID **dest,
+                          SECAlgorithmID *src)
 {
-    SECStatus         rv;
-    void             *mark = NULL;
-    SECAlgorithmID   *mySecAlg;
+    SECStatus rv;
+    void *mark = NULL;
+    SECAlgorithmID *mySecAlg;
 
     if (!poolp) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
@@ -180,7 +179,7 @@ crmf_template_copy_secalg (PLArenaPool *poolp, SECAlgorithmID **dest,
     }
     return SECSuccess;
 
- loser:
+loser:
     *dest = NULL;
     if (mark) {
         PORT_ArenaRelease(poolp, mark);
@@ -190,11 +189,11 @@ crmf_template_copy_secalg (PLArenaPool *poolp, SECAlgorithmID **dest,
 
 SECStatus
 crmf_copy_cert_name(PLArenaPool *poolp, CERTName **dest,
-		    CERTName *src)
+                    CERTName *src)
 {
     CERTName *newName;
     SECStatus rv;
-    void     *mark;
+    void *mark;
 
     mark = PORT_ArenaMark(poolp);
     *dest = newName = PORT_ArenaZNew(poolp, CERTName);
@@ -204,91 +203,88 @@ crmf_copy_cert_name(PLArenaPool *poolp, CERTName **dest,
 
     rv = CERT_CopyName(poolp, newName, src);
     if (rv != SECSuccess) {
-      goto loser;
+        goto loser;
     }
     PORT_ArenaUnmark(poolp, mark);
     return SECSuccess;
- loser:
+loser:
     PORT_ArenaRelease(poolp, mark);
     *dest = NULL;
     return SECFailure;
 }
 
 static SECStatus
-crmf_template_add_issuer (PLArenaPool *poolp, CERTName **dest,
-			  CERTName* issuerName)
+crmf_template_add_issuer(PLArenaPool *poolp, CERTName **dest,
+                         CERTName *issuerName)
 {
     return crmf_copy_cert_name(poolp, dest, issuerName);
 }
 
-
 static SECStatus
-crmf_template_add_validity (PLArenaPool *poolp, CRMFOptionalValidity **dest,
-			    CRMFValidityCreationInfo *info)
+crmf_template_add_validity(PLArenaPool *poolp, CRMFOptionalValidity **dest,
+                           CRMFValidityCreationInfo *info)
 {
-    SECStatus             rv;
-    void                 *mark; 
+    SECStatus rv;
+    void *mark;
     CRMFOptionalValidity *myValidity;
 
     /*First off, let's make sure at least one of the two fields is present*/
-    if (!info  || (!info->notBefore && !info->notAfter)) {
+    if (!info || (!info->notBefore && !info->notAfter)) {
         return SECFailure;
     }
-    mark = PORT_ArenaMark (poolp);
+    mark = PORT_ArenaMark(poolp);
     *dest = myValidity = PORT_ArenaZNew(poolp, CRMFOptionalValidity);
     if (myValidity == NULL) {
         goto loser;
     }
 
     if (info->notBefore) {
-        rv = DER_EncodeTimeChoice (poolp, &myValidity->notBefore, 
-				  *info->notBefore);
-	if (rv != SECSuccess) {
-	    goto loser;
-	}
+        rv = DER_EncodeTimeChoice(poolp, &myValidity->notBefore,
+                                  *info->notBefore);
+        if (rv != SECSuccess) {
+            goto loser;
+        }
     }
     if (info->notAfter) {
-        rv = DER_EncodeTimeChoice (poolp, &myValidity->notAfter,
-				  *info->notAfter);
-	if (rv != SECSuccess) {
-	    goto loser;
-	}
+        rv = DER_EncodeTimeChoice(poolp, &myValidity->notAfter,
+                                  *info->notAfter);
+        if (rv != SECSuccess) {
+            goto loser;
+        }
     }
     PORT_ArenaUnmark(poolp, mark);
     return SECSuccess;
- loser:
+loser:
     PORT_ArenaRelease(poolp, mark);
     *dest = NULL;
     return SECFailure;
 }
 
 static SECStatus
-crmf_template_add_subject (PLArenaPool *poolp, CERTName **dest,
-			   CERTName *subject)
+crmf_template_add_subject(PLArenaPool *poolp, CERTName **dest,
+                          CERTName *subject)
 {
     return crmf_copy_cert_name(poolp, dest, subject);
 }
 
 SECStatus
 crmf_template_add_public_key(PLArenaPool *poolp,
-			     CERTSubjectPublicKeyInfo **dest,
-			     CERTSubjectPublicKeyInfo  *pubKey)
+                             CERTSubjectPublicKeyInfo **dest,
+                             CERTSubjectPublicKeyInfo *pubKey)
 {
     CERTSubjectPublicKeyInfo *spki;
     SECStatus rv;
 
-    *dest = spki = (poolp == NULL) ?
-                              PORT_ZNew(CERTSubjectPublicKeyInfo) :
-                              PORT_ArenaZNew (poolp, CERTSubjectPublicKeyInfo);
+    *dest = spki = (poolp == NULL) ? PORT_ZNew(CERTSubjectPublicKeyInfo) : PORT_ArenaZNew(poolp, CERTSubjectPublicKeyInfo);
     if (spki == NULL) {
         goto loser;
     }
-    rv = SECKEY_CopySubjectPublicKeyInfo (poolp, spki, pubKey);
+    rv = SECKEY_CopySubjectPublicKeyInfo(poolp, spki, pubKey);
     if (rv != SECSuccess) {
         goto loser;
     }
     return SECSuccess;
- loser:
+loser:
     if (poolp == NULL && spki != NULL) {
         SECKEY_DestroySubjectPublicKeyInfo(spki);
     }
@@ -297,11 +293,11 @@ crmf_template_add_public_key(PLArenaPool *poolp,
 }
 
 static SECStatus
-crmf_copy_bitstring (PLArenaPool *poolp, SECItem *dest, const SECItem *src)
+crmf_copy_bitstring(PLArenaPool *poolp, SECItem *dest, const SECItem *src)
 {
     SECStatus rv;
-    SECItem  byteSrc;
-    
+    SECItem byteSrc;
+
     byteSrc = *src;
     byteSrc.len = CRMF_BITS_TO_BYTES(byteSrc.len);
     rv = crmf_copy_secitem(poolp, dest, &byteSrc);
@@ -311,23 +307,23 @@ crmf_copy_bitstring (PLArenaPool *poolp, SECItem *dest, const SECItem *src)
 
 static SECStatus
 crmf_template_add_issuer_uid(PLArenaPool *poolp, SECItem *dest,
-			     const SECItem *issuerUID)
+                             const SECItem *issuerUID)
 {
-    return crmf_copy_bitstring (poolp, dest, issuerUID);
+    return crmf_copy_bitstring(poolp, dest, issuerUID);
 }
 
 static SECStatus
 crmf_template_add_subject_uid(PLArenaPool *poolp, SECItem *dest,
-			      const SECItem *subjectUID)
+                              const SECItem *subjectUID)
 {
-    return crmf_copy_bitstring (poolp, dest, subjectUID);
+    return crmf_copy_bitstring(poolp, dest, subjectUID);
 }
 
 static void
-crmf_zeroize_new_extensions (CRMFCertExtension **extensions,
-			     int numToZeroize) 
+crmf_zeroize_new_extensions(CRMFCertExtension **extensions,
+                            int numToZeroize)
 {
-    PORT_Memset((void*)extensions, 0, sizeof(CERTCertExtension*)*numToZeroize);
+    PORT_Memset((void *)extensions, 0, sizeof(CERTCertExtension *) * numToZeroize);
 }
 
 /*
@@ -342,72 +338,71 @@ crmf_zeroize_new_extensions (CRMFCertExtension **extensions,
  */
 static SECStatus
 crmf_template_add_extensions(PLArenaPool *poolp, CRMFCertTemplate *inTemplate,
-			     CRMFCertExtCreationInfo *extensions)
+                             CRMFCertExtCreationInfo *extensions)
 {
-    void               *mark;
-    int                 newSize, oldSize, i;
-    SECStatus           rv;
+    void *mark;
+    int newSize, oldSize, i;
+    SECStatus rv;
     CRMFCertExtension **extArray;
-    CRMFCertExtension  *newExt, *currExt;
+    CRMFCertExtension *newExt, *currExt;
 
     mark = PORT_ArenaMark(poolp);
     if (inTemplate->extensions == NULL) {
         newSize = extensions->numExtensions;
-        extArray = PORT_ZNewArray(CRMFCertExtension*,newSize+1);
+        extArray = PORT_ZNewArray(CRMFCertExtension *, newSize + 1);
     } else {
         newSize = inTemplate->numExtensions + extensions->numExtensions;
-        extArray = PORT_Realloc(inTemplate->extensions, 
-				sizeof(CRMFCertExtension*)*(newSize+1));
+        extArray = PORT_Realloc(inTemplate->extensions,
+                                sizeof(CRMFCertExtension *) * (newSize + 1));
     }
     if (extArray == NULL) {
         goto loser;
     }
-    oldSize                   = inTemplate->numExtensions;
-    inTemplate->extensions    = extArray;
+    oldSize = inTemplate->numExtensions;
+    inTemplate->extensions = extArray;
     inTemplate->numExtensions = newSize;
-    for (i=oldSize; i < newSize; i++) {
+    for (i = oldSize; i < newSize; i++) {
         newExt = PORT_ArenaZNew(poolp, CRMFCertExtension);
-	if (newExt == NULL) {
-	    goto loser2;
-	}
-	currExt = extensions->extensions[i-oldSize];
-	rv = crmf_copy_secitem(poolp, &(newExt->id), &(currExt->id));
-	if (rv != SECSuccess) {
-	    goto loser2;
-	}
-	rv = crmf_copy_secitem(poolp, &(newExt->critical),
-			       &(currExt->critical));
-	if (rv != SECSuccess) {
-	    goto loser2;
-	}
-	rv = crmf_copy_secitem(poolp, &(newExt->value), &(currExt->value));
-	if (rv != SECSuccess) {
-	    goto loser2;
-	}
-	extArray[i] = newExt;
+        if (newExt == NULL) {
+            goto loser2;
+        }
+        currExt = extensions->extensions[i - oldSize];
+        rv = crmf_copy_secitem(poolp, &(newExt->id), &(currExt->id));
+        if (rv != SECSuccess) {
+            goto loser2;
+        }
+        rv = crmf_copy_secitem(poolp, &(newExt->critical),
+                               &(currExt->critical));
+        if (rv != SECSuccess) {
+            goto loser2;
+        }
+        rv = crmf_copy_secitem(poolp, &(newExt->value), &(currExt->value));
+        if (rv != SECSuccess) {
+            goto loser2;
+        }
+        extArray[i] = newExt;
     }
     extArray[newSize] = NULL;
     PORT_ArenaUnmark(poolp, mark);
     return SECSuccess;
- loser2:
-    crmf_zeroize_new_extensions (&(inTemplate->extensions[oldSize]),
-				 extensions->numExtensions);
+loser2:
+    crmf_zeroize_new_extensions(&(inTemplate->extensions[oldSize]),
+                                extensions->numExtensions);
     inTemplate->numExtensions = oldSize;
- loser:
+loser:
     PORT_ArenaRelease(poolp, mark);
     return SECFailure;
 }
 
 SECStatus
-CRMF_CertRequestSetTemplateField(CRMFCertRequest       *inCertReq, 
-				 CRMFCertTemplateField  inTemplateField,
-				 void                  *data)
+CRMF_CertRequestSetTemplateField(CRMFCertRequest *inCertReq,
+                                 CRMFCertTemplateField inTemplateField,
+                                 void *data)
 {
     CRMFCertTemplate *certTemplate;
-    PLArenaPool      *poolp;
-    SECStatus         rv = SECFailure;
-    void             *mark;
-    
+    PLArenaPool *poolp;
+    SECStatus rv = SECFailure;
+    void *mark;
 
     if (inCertReq == NULL) {
         return SECFailure;
@@ -418,47 +413,47 @@ CRMF_CertRequestSetTemplateField(CRMFCertRequest       *inCertReq,
     poolp = inCertReq->poolp;
     mark = PORT_ArenaMark(poolp);
     switch (inTemplateField) {
-    case crmfVersion:
-      rv = crmf_template_add_version(poolp,&(certTemplate->version), 
-				     *(long*)data);
-      break;
-    case crmfSerialNumber:
-      rv = crmf_template_add_serialnumber(poolp, 
-					  &(certTemplate->serialNumber),
-					  *(long*)data);
-      break;
-    case crmfSigningAlg:
-      rv = crmf_template_copy_secalg (poolp, &(certTemplate->signingAlg),
-				      (SECAlgorithmID*)data);
-      break;
-    case crmfIssuer:
-      rv = crmf_template_add_issuer (poolp, &(certTemplate->issuer), 
-				     (CERTName*)data);
-      break;
-    case crmfValidity:
-      rv = crmf_template_add_validity (poolp, &(certTemplate->validity),
-				       (CRMFValidityCreationInfo*)data);
-      break;
-    case crmfSubject:
-      rv = crmf_template_add_subject (poolp, &(certTemplate->subject),
-				      (CERTName*)data);
-      break;
-    case crmfPublicKey:
-      rv = crmf_template_add_public_key(poolp, &(certTemplate->publicKey),
-					(CERTSubjectPublicKeyInfo*)data);
-      break;
-    case crmfIssuerUID:
-      rv = crmf_template_add_issuer_uid(poolp, &(certTemplate->issuerUID),
-					(SECItem*)data);
-      break;
-    case crmfSubjectUID:
-      rv = crmf_template_add_subject_uid(poolp, &(certTemplate->subjectUID),
-					 (SECItem*)data);
-      break;
-    case crmfExtension:
-      rv = crmf_template_add_extensions(poolp, certTemplate, 
-					(CRMFCertExtCreationInfo*)data);
-      break;
+        case crmfVersion:
+            rv = crmf_template_add_version(poolp, &(certTemplate->version),
+                                           *(long *)data);
+            break;
+        case crmfSerialNumber:
+            rv = crmf_template_add_serialnumber(poolp,
+                                                &(certTemplate->serialNumber),
+                                                *(long *)data);
+            break;
+        case crmfSigningAlg:
+            rv = crmf_template_copy_secalg(poolp, &(certTemplate->signingAlg),
+                                           (SECAlgorithmID *)data);
+            break;
+        case crmfIssuer:
+            rv = crmf_template_add_issuer(poolp, &(certTemplate->issuer),
+                                          (CERTName *)data);
+            break;
+        case crmfValidity:
+            rv = crmf_template_add_validity(poolp, &(certTemplate->validity),
+                                            (CRMFValidityCreationInfo *)data);
+            break;
+        case crmfSubject:
+            rv = crmf_template_add_subject(poolp, &(certTemplate->subject),
+                                           (CERTName *)data);
+            break;
+        case crmfPublicKey:
+            rv = crmf_template_add_public_key(poolp, &(certTemplate->publicKey),
+                                              (CERTSubjectPublicKeyInfo *)data);
+            break;
+        case crmfIssuerUID:
+            rv = crmf_template_add_issuer_uid(poolp, &(certTemplate->issuerUID),
+                                              (SECItem *)data);
+            break;
+        case crmfSubjectUID:
+            rv = crmf_template_add_subject_uid(poolp, &(certTemplate->subjectUID),
+                                               (SECItem *)data);
+            break;
+        case crmfExtension:
+            rv = crmf_template_add_extensions(poolp, certTemplate,
+                                              (CRMFCertExtCreationInfo *)data);
+            break;
     }
     if (rv != SECSuccess) {
         PORT_ArenaRelease(poolp, mark);
@@ -469,22 +464,22 @@ CRMF_CertRequestSetTemplateField(CRMFCertRequest       *inCertReq,
 }
 
 SECStatus
-CRMF_CertReqMsgSetCertRequest (CRMFCertReqMsg  *inCertReqMsg, 
-			       CRMFCertRequest *inCertReq)
+CRMF_CertReqMsgSetCertRequest(CRMFCertReqMsg *inCertReqMsg,
+                              CRMFCertRequest *inCertReq)
 {
-    PORT_Assert (inCertReqMsg != NULL && inCertReq != NULL);
+    PORT_Assert(inCertReqMsg != NULL && inCertReq != NULL);
     if (inCertReqMsg == NULL || inCertReq == NULL) {
         return SECFailure;
     }
     inCertReqMsg->certReq = crmf_copy_cert_request(inCertReqMsg->poolp,
-						   inCertReq);
+                                                   inCertReq);
     return (inCertReqMsg->certReq == NULL) ? SECFailure : SECSuccess;
 }
 
-CRMFCertReqMsg*
+CRMFCertReqMsg *
 CRMF_CreateCertReqMsg(void)
 {
-    PLArenaPool    *poolp;
+    PLArenaPool *poolp;
     CRMFCertReqMsg *reqMsg;
 
     poolp = PORT_NewArena(CRMF_DEFAULT_ARENA_SIZE);
@@ -497,49 +492,48 @@ CRMF_CreateCertReqMsg(void)
     }
     reqMsg->poolp = poolp;
     return reqMsg;
-    
- loser:
+
+loser:
     if (poolp) {
         PORT_FreeArena(poolp, PR_FALSE);
     }
     return NULL;
 }
 
-SECStatus 
+SECStatus
 CRMF_DestroyCertReqMsg(CRMFCertReqMsg *inCertReqMsg)
 {
     PORT_Assert(inCertReqMsg != NULL && inCertReqMsg->poolp != NULL);
     if (!inCertReqMsg->isDecoded) {
         if (inCertReqMsg->certReq->certTemplate.extensions != NULL) {
-	    PORT_Free(inCertReqMsg->certReq->certTemplate.extensions);
-	}
-	if (inCertReqMsg->certReq->controls != NULL) {
-	    PORT_Free(inCertReqMsg->certReq->controls);
-	}
+            PORT_Free(inCertReqMsg->certReq->certTemplate.extensions);
+        }
+        if (inCertReqMsg->certReq->controls != NULL) {
+            PORT_Free(inCertReqMsg->certReq->controls);
+        }
     }
     PORT_FreeArena(inCertReqMsg->poolp, PR_TRUE);
     return SECSuccess;
 }
 
-CRMFCertExtension*
+CRMFCertExtension *
 crmf_create_cert_extension(PLArenaPool *poolp,
-			   SECOidTag    id,
-			   PRBool       isCritical,
-			   SECItem     *data)
+                           SECOidTag id,
+                           PRBool isCritical,
+                           SECItem *data)
 {
     CRMFCertExtension *newExt;
-    SECOidData        *oidData;
-    SECStatus          rv;
+    SECOidData *oidData;
+    SECStatus rv;
 
-    newExt = (poolp == NULL) ? PORT_ZNew(CRMFCertExtension) :
-                               PORT_ArenaZNew(poolp, CRMFCertExtension);
+    newExt = (poolp == NULL) ? PORT_ZNew(CRMFCertExtension) : PORT_ArenaZNew(poolp, CRMFCertExtension);
     if (newExt == NULL) {
         goto loser;
     }
     oidData = SECOID_FindOIDByTag(id);
-    if (oidData == NULL || 
-	oidData->supportedExtension != SUPPORTED_CERT_EXTENSION) {
-       goto loser;
+    if (oidData == NULL ||
+        oidData->supportedExtension != SUPPORTED_CERT_EXTENSION) {
+        goto loser;
     }
 
     rv = SECITEM_CopyItem(poolp, &(newExt->id), &(oidData->oid));
@@ -553,17 +547,16 @@ crmf_create_cert_extension(PLArenaPool *poolp,
     }
 
     if (isCritical) {
-        newExt->critical.data = (poolp == NULL) ? 
-	                                PORT_New(unsigned char) :
-	                                PORT_ArenaNew(poolp, unsigned char);
-	if (newExt->critical.data == NULL) {
-	    goto loser;
-	}
-	newExt->critical.data[0] = hexTrue;
-	newExt->critical.len = 1;
+        newExt->critical.data = (poolp == NULL) ? PORT_New(unsigned char)
+                                                : PORT_ArenaNew(poolp, unsigned char);
+        if (newExt->critical.data == NULL) {
+            goto loser;
+        }
+        newExt->critical.data[0] = hexTrue;
+        newExt->critical.len = 1;
     }
     return newExt;
- loser:
+loser:
     if (newExt != NULL && poolp == NULL) {
         CRMF_DestroyCertExtension(newExt);
     }
@@ -572,8 +565,8 @@ crmf_create_cert_extension(PLArenaPool *poolp,
 
 CRMFCertExtension *
 CRMF_CreateCertExtension(SECOidTag id,
-			 PRBool    isCritical,
-			 SECItem  *data) 
+                         PRBool isCritical,
+                         SECItem *data)
 {
     return crmf_create_cert_extension(NULL, id, isCritical, data);
 }
@@ -582,12 +575,12 @@ static SECStatus
 crmf_destroy_cert_extension(CRMFCertExtension *inExtension, PRBool freeit)
 {
     if (inExtension != NULL) {
-        SECITEM_FreeItem (&(inExtension->id), PR_FALSE);
-	SECITEM_FreeItem (&(inExtension->value), PR_FALSE);
-	SECITEM_FreeItem (&(inExtension->critical), PR_FALSE);
-	if (freeit) {
-	    PORT_Free(inExtension);
-	}
+        SECITEM_FreeItem(&(inExtension->id), PR_FALSE);
+        SECITEM_FreeItem(&(inExtension->value), PR_FALSE);
+        SECITEM_FreeItem(&(inExtension->critical), PR_FALSE);
+        if (freeit) {
+            PORT_Free(inExtension);
+        }
     }
     return SECSuccess;
 }
@@ -599,9 +592,9 @@ CRMF_DestroyCertExtension(CRMFCertExtension *inExtension)
 }
 
 SECStatus
-CRMF_DestroyCertReqMessages(CRMFCertReqMessages *inCertReqMsgs) 
+CRMF_DestroyCertReqMessages(CRMFCertReqMessages *inCertReqMsgs)
 {
-    PORT_Assert (inCertReqMsgs != NULL);
+    PORT_Assert(inCertReqMsgs != NULL);
     if (inCertReqMsgs != NULL) {
         PORT_FreeArena(inCertReqMsgs->poolp, PR_TRUE);
     }
@@ -618,53 +611,53 @@ crmf_item_has_data(SECItem *item)
 }
 
 PRBool
-CRMF_CertRequestIsFieldPresent(CRMFCertRequest       *inCertReq,
-			       CRMFCertTemplateField  inTemplateField)
+CRMF_CertRequestIsFieldPresent(CRMFCertRequest *inCertReq,
+                               CRMFCertTemplateField inTemplateField)
 {
-    PRBool             retVal;
+    PRBool retVal;
     CRMFCertTemplate *certTemplate;
 
     PORT_Assert(inCertReq != NULL);
     if (inCertReq == NULL) {
-        /* This is probably some kind of error, but this is 
-	 * the safest return value for this function.
-	 */
+        /* This is probably some kind of error, but this is
+         * the safest return value for this function.
+         */
         return PR_FALSE;
     }
     certTemplate = &inCertReq->certTemplate;
     switch (inTemplateField) {
-    case crmfVersion:
-      retVal = crmf_item_has_data(&certTemplate->version);
-      break;
-    case crmfSerialNumber:
-      retVal = crmf_item_has_data(&certTemplate->serialNumber);
-      break;
-    case crmfSigningAlg:
-      retVal = IS_NOT_NULL(certTemplate->signingAlg);
-      break;
-    case crmfIssuer:
-      retVal = IS_NOT_NULL(certTemplate->issuer);
-      break;
-    case crmfValidity:
-      retVal = IS_NOT_NULL(certTemplate->validity);
-      break;
-    case crmfSubject:
-      retVal = IS_NOT_NULL(certTemplate->subject);
-      break;
-    case crmfPublicKey:
-      retVal = IS_NOT_NULL(certTemplate->publicKey);
-      break;
-    case crmfIssuerUID:
-      retVal = crmf_item_has_data(&certTemplate->issuerUID);
-      break;
-    case crmfSubjectUID:
-      retVal = crmf_item_has_data(&certTemplate->subjectUID);
-      break;
-    case crmfExtension:
-      retVal = IS_NOT_NULL(certTemplate->extensions);
-      break;
-    default:
-      retVal = PR_FALSE;
+        case crmfVersion:
+            retVal = crmf_item_has_data(&certTemplate->version);
+            break;
+        case crmfSerialNumber:
+            retVal = crmf_item_has_data(&certTemplate->serialNumber);
+            break;
+        case crmfSigningAlg:
+            retVal = IS_NOT_NULL(certTemplate->signingAlg);
+            break;
+        case crmfIssuer:
+            retVal = IS_NOT_NULL(certTemplate->issuer);
+            break;
+        case crmfValidity:
+            retVal = IS_NOT_NULL(certTemplate->validity);
+            break;
+        case crmfSubject:
+            retVal = IS_NOT_NULL(certTemplate->subject);
+            break;
+        case crmfPublicKey:
+            retVal = IS_NOT_NULL(certTemplate->publicKey);
+            break;
+        case crmfIssuerUID:
+            retVal = crmf_item_has_data(&certTemplate->issuerUID);
+            break;
+        case crmfSubjectUID:
+            retVal = crmf_item_has_data(&certTemplate->subjectUID);
+            break;
+        case crmfExtension:
+            retVal = IS_NOT_NULL(certTemplate->extensions);
+            break;
+        default:
+            retVal = PR_FALSE;
     }
     return retVal;
 }