Allow NSS to be built with NO_NSPR_10_SUPPORT.

nss/lib/freebl/rsa.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/. */
 
 /*
  * RSA key generation, public key op, private key op.
  */
 #ifdef FREEBL_NO_DEPEND
 #include "stubs.h"
 #endif
@@ skipping 221 matching lines @@
 RSAPrivateKey *
 RSA_NewKey(int keySizeInBits, SECItem *publicExponent)
 {
     unsigned int primeLen;
     mp_int p, q, e, d;
     int kiter;
     mp_err   err = MP_OKAY;
     SECStatus rv = SECSuccess;
     int prerr = 0;
     RSAPrivateKey *key = NULL;
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     /* Require key size to be a multiple of 16 bits. */
     if (!publicExponent || keySizeInBits % 16 != 0 ||
             BAD_RSA_KEY_SIZE(keySizeInBits/8, publicExponent->len)) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return NULL;
     }
     /* 1. Allocate arena & key */
     arena = PORT_NewArena(NSS_FREEBL_DEFAULT_CHUNKSIZE);
     if (!arena) {
         PORT_SetError(SEC_ERROR_NO_MEMORY);
         return NULL;
     }
     key = PORT_ArenaZNew(arena, RSAPrivateKey);
     if (!key) {
         PORT_SetError(SEC_ERROR_NO_MEMORY);
         PORT_FreeArena(arena, PR_TRUE);
         return NULL;
     }
     key->arena = arena;
     /* length of primes p and q (in bytes) */
-    primeLen = keySizeInBits / (2 * BITS_PER_BYTE);
+    primeLen = keySizeInBits / (2 * PR_BITS_PER_BYTE);
     MP_DIGITS(&p) = 0;
     MP_DIGITS(&q) = 0;
     MP_DIGITS(&e) = 0;
     MP_DIGITS(&d) = 0;
     CHECK_MPI_OK( mp_init(&p) );
     CHECK_MPI_OK( mp_init(&q) );
     CHECK_MPI_OK( mp_init(&e) );
     CHECK_MPI_OK( mp_init(&d) );
     /* 2.  Set the version number (PKCS1 v1.5 says it should be zero) */
     SECITEM_AllocItem(arena, &key->version, 1);
@@ skipping 372 matching lines @@
  *        phi = n - s + 1, s = n - phi +1.  Now that we have s = p+q and n=pq,
  *        we can solve our 2 equations and 2 unknowns as follows: q=s-p ->
  *        n=p*(s-p)= sp -p^2 -> p^2-sp+n = 0. Using the quadratic to solve for
  *        p, p=1/2*(s+ sqrt(s*s-4*n)) [q=1/2*(s-sqrt(s*s-4*n)]. We again have
  *        2 primes and an exponent.
  *
  */
 SECStatus
 RSA_PopulatePrivateKey(RSAPrivateKey *key)
 {
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     PRBool needPublicExponent = PR_TRUE;
     PRBool needPrivateExponent = PR_TRUE;
     PRBool hasModulus = PR_FALSE;
     unsigned int keySizeInBits = 0;
     int prime_count = 0;
     /* standard RSA nominclature */
     mp_int p, q, e, d, n;
     /* remainder */
     mp_int r;
     mp_err err = 0;
@@ skipping 38 matching lines @@
 
     /* load up the known primes. If only one prime is given, it will be
      * assigned 'p'. Once we have both primes, well make sure p is the larger.
      * The value prime_count tells us howe many we have acquired.
      */
     if (key->prime1.data) {
         int primeLen = key->prime1.len;
         if (key->prime1.data[0] == 0) {
            primeLen--;
         }
-        keySizeInBits = primeLen * 2 * BITS_PER_BYTE;
+        keySizeInBits = primeLen * 2 * PR_BITS_PER_BYTE;
         SECITEM_TO_MPINT(key->prime1, &p);
         prime_count++;
     }
     if (key->prime2.data) {
         int primeLen = key->prime2.len;
         if (key->prime2.data[0] == 0) {
            primeLen--;
         }
-        keySizeInBits = primeLen * 2 * BITS_PER_BYTE;
+        keySizeInBits = primeLen * 2 * PR_BITS_PER_BYTE;
         SECITEM_TO_MPINT(key->prime2, prime_count ? &q : &p);
         prime_count++;
     }
     /* load up the modulus */
     if (key->modulus.data) {
         int modLen = key->modulus.len;
         if (key->modulus.data[0] == 0) {
            modLen--;
         }
-        keySizeInBits = modLen * BITS_PER_BYTE;
+        keySizeInBits = modLen * PR_BITS_PER_BYTE;
         SECITEM_TO_MPINT(key->modulus, &n);
         hasModulus = PR_TRUE;
     }
     /* if we have the modulus and one prime, calculate the second. */
     if ((prime_count == 1) && (hasModulus)) {
         mp_div(&n,&p,&q,&r);
         if (mp_cmp_z(&r) != 0) {
            /* p is not a factor or n, fail */
            err = MP_BADARG;
            goto cleanup;
@@ skipping 602 matching lines @@
 
 SECStatus 
 RSA_PrivateKeyOpDoubleChecked(RSAPrivateKey *key, 
                               unsigned char *output, 
                               const unsigned char *input)
 {
     return rsa_PrivateKeyOp(key, output, input, PR_TRUE);
 }
 
 static SECStatus
-swap_in_key_value(PRArenaPool *arena, mp_int *mpval, SECItem *buffer)
+swap_in_key_value(PLArenaPool *arena, mp_int *mpval, SECItem *buffer)
 {
     int len;
     mp_err err = MP_OKAY;
     memset(buffer->data, 0, buffer->len);
     len = mp_unsigned_octet_size(mpval);
     if (len <= 0) return SECFailure;
     if ((unsigned int)len <= buffer->len) {
         /* The new value is no longer than the old buffer, so use it */
         err = mp_to_unsigned_octets(mpval, buffer->data, len);
         if (err >= 0) err = MP_OKAY;
@@ skipping 201 matching lines @@
 PRBool bl_parentForkedAfterC_Initialize;
 
 /*
  * Set fork flag so it can be tested in SKIP_AFTER_FORK on relevant platforms.
  */
 void BL_SetForkState(PRBool forked)
 {
     bl_parentForkedAfterC_Initialize = forked;
 }