Update NSS to NSS_3_16_RC0.

nss/lib/softoken/lowkey.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/. */
 #include "lowkeyi.h"
 #include "secoid.h"
 #include "secitem.h"
 #include "secder.h"
 #include "base64.h"
 #include "secasn1.h"
 #include "secerr.h"
 
-#ifdef NSS_ENABLE_ECC
+#ifndef NSS_DISABLE_ECC
 #include "softoken.h"
 #endif
 
 SEC_ASN1_MKSUB(SEC_AnyTemplate)
 SEC_ASN1_MKSUB(SEC_BitStringTemplate)
 SEC_ASN1_MKSUB(SEC_ObjectIDTemplate)
 SEC_ASN1_MKSUB(SECOID_AlgorithmIDTemplate)
 
 const SEC_ASN1Template nsslowkey_AttributeTemplate[] = {
     { SEC_ASN1_SEQUENCE, 
@@ skipping 61 matching lines @@
 
 const SEC_ASN1Template nsslowkey_DHPrivateKeyTemplate[] = {
     { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(NSSLOWKEYPrivateKey) },
     { SEC_ASN1_INTEGER, offsetof(NSSLOWKEYPrivateKey,u.dh.publicValue) },
     { SEC_ASN1_INTEGER, offsetof(NSSLOWKEYPrivateKey,u.dh.privateValue) },
     { SEC_ASN1_INTEGER, offsetof(NSSLOWKEYPrivateKey,u.dh.base) },
     { SEC_ASN1_INTEGER, offsetof(NSSLOWKEYPrivateKey,u.dh.prime) },
     { 0, }
 };
 
-#ifdef NSS_ENABLE_ECC
+#ifndef NSS_DISABLE_ECC
 
 /* XXX This is just a placeholder for later when we support
  * generic curves and need full-blown support for parsing EC
  * parameters. For now, we only support named curves in which
  * EC params are simply encoded as an object ID and we don't
  * use nsslowkey_ECParamsTemplate.
  */
 const SEC_ASN1Template nsslowkey_ECParamsTemplate[] = {
     { SEC_ASN1_CHOICE, offsetof(ECParams,type), NULL, sizeof(ECParams) },
     { SEC_ASN1_OBJECT_ID, offsetof(ECParams,curveOID), NULL, ec_params_named },
@@ skipping 28 matching lines @@
       offsetof(NSSLOWKEYPrivateKey,u.ec.ecParams), 
       nsslowkey_ECParamsTemplate }, 
 #endif
     { SEC_ASN1_OPTIONAL | SEC_ASN1_CONSTRUCTED |
       SEC_ASN1_EXPLICIT | SEC_ASN1_CONTEXT_SPECIFIC |
       SEC_ASN1_XTRN | 1, 
       offsetof(NSSLOWKEYPrivateKey,u.ec.publicValue),
       SEC_ASN1_SUB(SEC_BitStringTemplate) }, 
     { 0, }
 };
-#endif /* NSS_ENABLE_ECC */
+#endif /* NSS_DISABLE_ECC */
 /*
  * See bugzilla bug 125359
  * Since NSS (via PKCS#11) wants to handle big integers as unsigned ints,
  * all of the templates above that en/decode into integers must be converted
  * from ASN.1's signed integer type.  This is done by marking either the
  * source or destination (encoding or decoding, respectively) type as
  * siUnsignedInteger.
  */
 
 void
@@ skipping 35 matching lines @@
 
 void
 prepare_low_dh_priv_key_for_asn1(NSSLOWKEYPrivateKey *key)
 {
     key->u.dh.prime.type = siUnsignedInteger;
     key->u.dh.base.type = siUnsignedInteger;
     key->u.dh.publicValue.type = siUnsignedInteger;
     key->u.dh.privateValue.type = siUnsignedInteger;
 }
 
-#ifdef NSS_ENABLE_ECC
+#ifndef NSS_DISABLE_ECC
 void
 prepare_low_ecparams_for_asn1(ECParams *params)
 {
     params->DEREncoding.type = siUnsignedInteger;
     params->curveOID.type = siUnsignedInteger;
 }
 
 void
 prepare_low_ec_priv_key_for_asn1(NSSLOWKEYPrivateKey *key)
 {
     key->u.ec.version.type = siUnsignedInteger;
     key->u.ec.ecParams.DEREncoding.type = siUnsignedInteger;
     key->u.ec.ecParams.curveOID.type = siUnsignedInteger;
     key->u.ec.privateValue.type = siUnsignedInteger;
     key->u.ec.publicValue.type = siUnsignedInteger;
 }
-#endif /* NSS_ENABLE_ECC */
+#endif /* NSS_DISABLE_ECC */
 
 void
 nsslowkey_DestroyPrivateKey(NSSLOWKEYPrivateKey *privk)
 {
     if (privk && privk->arena) {
         PORT_FreeArena(privk->arena, PR_TRUE);
     }
 }
 
 void
@@ skipping 107 matching lines @@
                                   &privk->u.dh.publicValue);
             if (rv != SECSuccess) break;
             rv = SECITEM_CopyItem(arena, &pubk->u.dh.prime,
                                   &privk->u.dh.prime);
             if (rv != SECSuccess) break;
             rv = SECITEM_CopyItem(arena, &pubk->u.dh.base,
                                   &privk->u.dh.base);
             if (rv == SECSuccess) return pubk;
         }
         break;
-#ifdef NSS_ENABLE_ECC
+#ifndef NSS_DISABLE_ECC
       case NSSLOWKEYECKey:
         pubk = (NSSLOWKEYPublicKey *)PORT_ArenaZAlloc(arena,
                                                     sizeof(NSSLOWKEYPublicKey));
         if (pubk != NULL) {
             SECStatus rv;
 
             pubk->arena = arena;
             pubk->keyType = privk->keyType;
             rv = SECITEM_CopyItem(arena, &pubk->u.ec.publicValue,
                                   &privk->u.ec.publicValue);
             if (rv != SECSuccess) break;
             pubk->u.ec.ecParams.arena = arena;
             /* Copy the rest of the params */
             rv = EC_CopyParams(arena, &(pubk->u.ec.ecParams),
                                &(privk->u.ec.ecParams));
             if (rv == SECSuccess) return pubk;
         }
         break;
-#endif /* NSS_ENABLE_ECC */
+#endif /* NSS_DISABLE_ECC */
         /* No Fortezza in Low Key implementations (Fortezza keys aren't
          * stored in our data base */
     default:
         break;
     }
 
     PORT_FreeArena (arena, PR_FALSE);
     return NULL;
 }
 
@@ skipping 78 matching lines @@
                                         &(privKey->u.dh.privateValue));
             if(rv != SECSuccess) break;
             returnKey->u.dsa.params.arena = poolp;
             rv = SECITEM_CopyItem(poolp, &(returnKey->u.dh.prime),
                                         &(privKey->u.dh.prime));
             if(rv != SECSuccess) break;
             rv = SECITEM_CopyItem(poolp, &(returnKey->u.dh.base),
                                         &(privKey->u.dh.base));
             if(rv != SECSuccess) break;
             break;
-#ifdef NSS_ENABLE_ECC
+#ifndef NSS_DISABLE_ECC
         case NSSLOWKEYECKey:
             rv = SECITEM_CopyItem(poolp, &(returnKey->u.ec.version),
                                         &(privKey->u.ec.version));
             if(rv != SECSuccess) break;
             rv = SECITEM_CopyItem(poolp, &(returnKey->u.ec.publicValue),
                                         &(privKey->u.ec.publicValue));
             if(rv != SECSuccess) break;
             rv = SECITEM_CopyItem(poolp, &(returnKey->u.ec.privateValue),
                                         &(privKey->u.ec.privateValue));
             if(rv != SECSuccess) break;
             returnKey->u.ec.ecParams.arena = poolp;
             /* Copy the rest of the params */
             rv = EC_CopyParams(poolp, &(returnKey->u.ec.ecParams),
                                &(privKey->u.ec.ecParams));
             if (rv != SECSuccess) break;
             break;
-#endif /* NSS_ENABLE_ECC */
+#endif /* NSS_DISABLE_ECC */
         default:
             rv = SECFailure;
     }
 
 loser:
 
     if(rv != SECSuccess) {
         PORT_FreeArena(poolp, PR_TRUE);
         returnKey = NULL;
     }
 
     return returnKey;
 }