Update NSPR to 4.12 and NSS to 3.23 on iOS

nss/lib/cryptohi/dsautil.c

Index: nss/lib/cryptohi/dsautil.c
diff --git a/nss/lib/cryptohi/dsautil.c b/nss/lib/cryptohi/dsautil.c
index 5606379df4e4fe2a2e76b9435e8bc5e9e8a837e4..db397dfd5f38a2752886c58b06c326faef14da9b 100644
--- a/nss/lib/cryptohi/dsautil.c
+++ b/nss/lib/cryptohi/dsautil.c
@@ -7,7 +7,7 @@
 #include "prerr.h"
 
 #ifndef DSA1_SUBPRIME_LEN
-#define DSA1_SUBPRIME_LEN 20	/* bytes */
+#define DSA1_SUBPRIME_LEN 20 /* bytes */
 #endif
 
 typedef struct {
@@ -16,16 +16,16 @@ typedef struct {
 } DSA_ASN1Signature;
 
 const SEC_ASN1Template DSA_SignatureTemplate[] =
-{
-    { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(DSA_ASN1Signature) },
-    { SEC_ASN1_INTEGER, offsetof(DSA_ASN1Signature,r) },
-    { SEC_ASN1_INTEGER, offsetof(DSA_ASN1Signature,s) },
-    { 0, }
-};
+    {
+      { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(DSA_ASN1Signature) },
+      { SEC_ASN1_INTEGER, offsetof(DSA_ASN1Signature, r) },
+      { SEC_ASN1_INTEGER, offsetof(DSA_ASN1Signature, s) },
+      { 0 }
+    };
 
 /* Input is variable length multi-byte integer, MSB first (big endian).
-** Most signficant bit of first byte is NOT treated as a sign bit. 
-** May be one or more leading bytes of zeros. 
+** Most signficant bit of first byte is NOT treated as a sign bit.
+** May be one or more leading bytes of zeros.
 ** Output is variable length multi-byte integer, MSB first (big endian).
 ** Most significant bit of first byte will be zero (positive sign bit)
 ** No more than one leading zero byte.
@@ -37,21 +37,21 @@ DSAU_ConvertUnsignedToSigned(SECItem *dest, SECItem *src)
 {
     unsigned char *pSrc = src->data;
     unsigned char *pDst = dest->data;
-    unsigned int   cntSrc = src->len;
+    unsigned int cntSrc = src->len;
 
     /* skip any leading zeros. */
-    while (cntSrc && !(*pSrc)) { 
-    	pSrc++; 
-	cntSrc--;
+    while (cntSrc && !(*pSrc)) {
+        pSrc++;
+        cntSrc--;
     }
     if (!cntSrc) {
-    	*pDst = 0; 
-	dest->len = 1; 
-	return; 
+        *pDst = 0;
+        dest->len = 1;
+        return;
     }
 
     if (*pSrc & 0x80)
-    	*pDst++ = 0;
+        *pDst++ = 0;
 
     PORT_Memcpy(pDst, pSrc, cntSrc);
     dest->len = (pDst - dest->data) + cntSrc;
@@ -71,27 +71,27 @@ DSAU_ConvertSignedToFixedUnsigned(SECItem *dest, SECItem *src)
 {
     unsigned char *pSrc = src->data;
     unsigned char *pDst = dest->data;
-    unsigned int   cntSrc = src->len;
-    unsigned int   cntDst = dest->len;
-    int            zCount = cntDst - cntSrc;
+    unsigned int cntSrc = src->len;
+    unsigned int cntDst = dest->len;
+    int zCount = cntDst - cntSrc;
 
     if (zCount > 0) {
-    	PORT_Memset(pDst, 0, zCount);
-	PORT_Memcpy(pDst + zCount, pSrc, cntSrc);
-	return SECSuccess;
+        PORT_Memset(pDst, 0, zCount);
+        PORT_Memcpy(pDst + zCount, pSrc, cntSrc);
+        return SECSuccess;
     }
     if (zCount <= 0) {
-	/* Source is longer than destination.  Check for leading zeros. */
-	while (zCount++ < 0) {
-	    if (*pSrc++ != 0)
-		goto loser;
-	}
+        /* Source is longer than destination.  Check for leading zeros. */
+        while (zCount++ < 0) {
+            if (*pSrc++ != 0)
+                goto loser;
+        }
     }
     PORT_Memcpy(pDst, pSrc, cntDst);
     return SECSuccess;
 
 loser:
-    PORT_SetError( PR_INVALID_ARGUMENT_ERROR );
+    PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
     return SECFailure;
 }
 
@@ -101,52 +101,56 @@ loser:
 static SECStatus
 common_EncodeDerSig(SECItem *dest, SECItem *src)
 {
-    SECItem *         item;
-    SECItem           srcItem;
+    SECItem *item;
+    SECItem srcItem;
     DSA_ASN1Signature sig;
-    unsigned char     *signedR;
-    unsigned char     *signedS;
+    unsigned char *signedR;
+    unsigned char *signedS;
     unsigned int len;
 
     /* Allocate memory with room for an extra byte that
      * may be required if the top bit in the first byte
      * is already set.
      */
-    len = src->len/2;
-    signedR = (unsigned char *) PORT_Alloc(len + 1);
-    if (!signedR) return SECFailure;
-    signedS = (unsigned char *) PORT_ZAlloc(len + 1);
+    len = src->len / 2;
+    signedR = (unsigned char *)PORT_Alloc(len + 1);
+    if (!signedR)
+        return SECFailure;
+    signedS = (unsigned char *)PORT_ZAlloc(len + 1);
     if (!signedS) {
-        if (signedR) PORT_Free(signedR);
-	return SECFailure;
+        if (signedR)
+            PORT_Free(signedR);
+        return SECFailure;
     }
 
     PORT_Memset(&sig, 0, sizeof(sig));
 
     /* Must convert r and s from "unsigned" integers to "signed" integers.
     ** If the high order bit of the first byte (MSB) is 1, then must
-    ** prepend with leading zero.  
+    ** prepend with leading zero.
     ** Must remove all but one leading zero byte from numbers.
     */
     sig.r.type = siUnsignedInteger;
     sig.r.data = signedR;
-    sig.r.len  = sizeof signedR;
+    sig.r.len = sizeof signedR;
     sig.s.type = siUnsignedInteger;
     sig.s.data = signedS;
-    sig.s.len  = sizeof signedR;
+    sig.s.len = sizeof signedR;
 
     srcItem.data = src->data;
-    srcItem.len  = len;
+    srcItem.len = len;
 
     DSAU_ConvertUnsignedToSigned(&sig.r, &srcItem);
     srcItem.data += len;
     DSAU_ConvertUnsignedToSigned(&sig.s, &srcItem);
 
     item = SEC_ASN1EncodeItem(NULL, dest, &sig, DSA_SignatureTemplate);
-    if (signedR) PORT_Free(signedR);
-    if (signedS) PORT_Free(signedS);
+    if (signedR)
+        PORT_Free(signedR);
+    if (signedS)
+        PORT_Free(signedS);
     if (item == NULL)
-	return SECFailure;
+        return SECFailure;
 
     /* XXX leak item? */
     return SECSuccess;
@@ -161,54 +165,54 @@ common_EncodeDerSig(SECItem *dest, SECItem *src)
 static SECItem *
 common_DecodeDerSig(const SECItem *item, unsigned int len)
 {
-    SECItem *         result = NULL;
-    SECStatus         status;
+    SECItem *result = NULL;
+    SECStatus status;
     DSA_ASN1Signature sig;
-    SECItem           dst;
+    SECItem dst;
 
     PORT_Memset(&sig, 0, sizeof(sig));
 
     result = PORT_ZNew(SECItem);
     if (result == NULL)
-	goto loser;
+        goto loser;
 
-    result->len  = 2 * len;
-    result->data = (unsigned char*)PORT_Alloc(2 * len);
+    result->len = 2 * len;
+    result->data = (unsigned char *)PORT_Alloc(2 * len);
     if (result->data == NULL)
-	goto loser;
+        goto loser;
 
     sig.r.type = siUnsignedInteger;
     sig.s.type = siUnsignedInteger;
     status = SEC_ASN1DecodeItem(NULL, &sig, DSA_SignatureTemplate, item);
     if (status != SECSuccess)
-	goto loser;
+        goto loser;
 
-    /* Convert sig.r and sig.s from variable  length signed integers to 
+    /* Convert sig.r and sig.s from variable  length signed integers to
     ** fixed length unsigned integers.
     */
     dst.data = result->data;
-    dst.len  = len;
+    dst.len = len;
     status = DSAU_ConvertSignedToFixedUnsigned(&dst, &sig.r);
     if (status != SECSuccess)
-    	goto loser;
+        goto loser;
 
     dst.data += len;
     status = DSAU_ConvertSignedToFixedUnsigned(&dst, &sig.s);
     if (status != SECSuccess)
-    	goto loser;
+        goto loser;
 
 done:
     if (sig.r.data != NULL)
-	PORT_Free(sig.r.data);
+        PORT_Free(sig.r.data);
     if (sig.s.data != NULL)
-	PORT_Free(sig.s.data);
+        PORT_Free(sig.s.data);
 
     return result;
 
 loser:
     if (result != NULL) {
-	SECITEM_FreeItem(result, PR_TRUE);
-	result = NULL;
+        SECITEM_FreeItem(result, PR_TRUE);
+        result = NULL;
     }
     goto done;
 }
@@ -221,8 +225,8 @@ DSAU_EncodeDerSig(SECItem *dest, SECItem *src)
 {
     PORT_Assert(src->len == 2 * DSA1_SUBPRIME_LEN);
     if (src->len != 2 * DSA1_SUBPRIME_LEN) {
-    	PORT_SetError( PR_INVALID_ARGUMENT_ERROR );
-	return SECFailure;
+        PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
+        return SECFailure;
     }
 
     return common_EncodeDerSig(dest, src);
@@ -237,8 +241,8 @@ DSAU_EncodeDerSigWithLen(SECItem *dest, SECItem *src, unsigned int len)
 
     PORT_Assert((src->len == len) && (len % 2 == 0));
     if ((src->len != len) || (src->len % 2 != 0)) {
-    	PORT_SetError( PR_INVALID_ARGUMENT_ERROR );
-	return SECFailure;
+        PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
+        return SECFailure;
     }
 
     return common_EncodeDerSig(dest, src);
@@ -263,5 +267,5 @@ DSAU_DecodeDerSig(const SECItem *item)
 SECItem *
 DSAU_DecodeDerSigToLen(const SECItem *item, unsigned int len)
 {
-    return common_DecodeDerSig(item, len/2);
+    return common_DecodeDerSig(item, len / 2);
 }