Changes needed for Tandem NSK, supplied by Scott Uroff (scott@xypro.com).

[openssl.git] / crypto / bn / bn_lib.c

diff --git a/crypto/bn/bn_lib.c b/crypto/bn/bn_lib.c
index ee194c55b27c955ce419cff81593ad2475143341..b693c7e0c07b8cd493b1b18f81c1291495ba4218 100644 (file)
--- a/crypto/bn/bn_lib.c
+++ b/crypto/bn/bn_lib.c
@@ -71,14 +71,14 @@ const char *BN_version="Big Number" OPENSSL_VERSION_PTEXT;
  * 7 - 128 == 4096
  * 8 - 256 == 8192
  */
-OPENSSL_GLOBAL int bn_limit_bits=0;
-OPENSSL_GLOBAL int bn_limit_num=8;        /* (1<<bn_limit_bits) */
-OPENSSL_GLOBAL int bn_limit_bits_low=0;
-OPENSSL_GLOBAL int bn_limit_num_low=8;    /* (1<<bn_limit_bits_low) */
-OPENSSL_GLOBAL int bn_limit_bits_high=0;
-OPENSSL_GLOBAL int bn_limit_num_high=8;   /* (1<<bn_limit_bits_high) */
-OPENSSL_GLOBAL int bn_limit_bits_mont=0;
-OPENSSL_GLOBAL int bn_limit_num_mont=8;   /* (1<<bn_limit_bits_mont) */
+static int bn_limit_bits=0;
+static int bn_limit_num=8;        /* (1<<bn_limit_bits) */
+static int bn_limit_bits_low=0;
+static int bn_limit_num_low=8;    /* (1<<bn_limit_bits_low) */
+static int bn_limit_bits_high=0;
+static int bn_limit_num_high=8;   /* (1<<bn_limit_bits_high) */
+static int bn_limit_bits_mont=0;
+static int bn_limit_num_mont=8;   /* (1<<bn_limit_bits_mont) */
 
 void BN_set_params(int mult, int high, int low, int mont)
        {
@@ -262,24 +262,24 @@ void BN_clear_free(BIGNUM *a)
        if (a == NULL) return;
        if (a->d != NULL)
                {
-               memset(a->d,0,a->max*sizeof(a->d[0]));
+               memset(a->d,0,a->dmax*sizeof(a->d[0]));
                if (!(BN_get_flags(a,BN_FLG_STATIC_DATA)))
-                       Free(a->d);
+                       OPENSSL_free(a->d);
                }
        i=BN_get_flags(a,BN_FLG_MALLOCED);
        memset(a,0,sizeof(BIGNUM));
        if (i)
-               Free(a);
+               OPENSSL_free(a);
        }
 
 void BN_free(BIGNUM *a)
        {
        if (a == NULL) return;
        if ((a->d != NULL) && !(BN_get_flags(a,BN_FLG_STATIC_DATA)))
-               Free(a->d);
+               OPENSSL_free(a->d);
        a->flags|=BN_FLG_FREE; /* REMOVE? */
        if (a->flags & BN_FLG_MALLOCED)
-               Free(a);
+               OPENSSL_free(a);
        }
 
 void BN_init(BIGNUM *a)
@@ -291,7 +291,7 @@ BIGNUM *BN_new(void)
        {
        BIGNUM *ret;
 
-       if ((ret=(BIGNUM *)Malloc(sizeof(BIGNUM))) == NULL)
+       if ((ret=(BIGNUM *)OPENSSL_malloc(sizeof(BIGNUM))) == NULL)
                {
                BNerr(BN_F_BN_NEW,ERR_R_MALLOC_FAILURE);
                return(NULL);
@@ -299,47 +299,15 @@ BIGNUM *BN_new(void)
        ret->flags=BN_FLG_MALLOCED;
        ret->top=0;
        ret->neg=0;
-       ret->max=0;
+       ret->dmax=0;
        ret->d=NULL;
        return(ret);
        }
 
-
-BN_CTX *BN_CTX_new(void)
-       {
-       BN_CTX *ret;
-
-       ret=(BN_CTX *)Malloc(sizeof(BN_CTX));
-       if (ret == NULL)
-               {
-               BNerr(BN_F_BN_CTX_NEW,ERR_R_MALLOC_FAILURE);
-               return(NULL);
-               }
-
-       BN_CTX_init(ret);
-       ret->flags=BN_FLG_MALLOCED;
-       return(ret);
-       }
-
-void BN_CTX_init(BN_CTX *ctx)
-       {
-       memset(ctx,0,sizeof(BN_CTX));
-       ctx->tos=0;
-       ctx->flags=0;
-       }
-
-void BN_CTX_free(BN_CTX *c)
-       {
-       int i;
-
-       if(c == NULL)
-           return;
-
-       for (i=0; i<BN_CTX_NUM; i++)
-               BN_clear_free(&(c->bn[i]));
-       if (c->flags & BN_FLG_MALLOCED)
-               Free(c);
-       }
+/* This is an internal function that should not be used in applications.
+ * It ensures that 'b' has enough room for a 'words' word number number.
+ * It is mostly used by the various BIGNUM routines. If there is an error,
+ * NULL is returned. If not, 'b' is returned. */
 
 BIGNUM *bn_expand2(BIGNUM *b, int words)
        {
@@ -349,7 +317,7 @@ BIGNUM *bn_expand2(BIGNUM *b, int words)
 
        bn_check_top(b);
 
-       if (words > b->max)
+       if (words > b->dmax)
                {
                bn_check_top(b);        
                if (BN_get_flags(b,BN_FLG_STATIC_DATA))
@@ -357,7 +325,7 @@ BIGNUM *bn_expand2(BIGNUM *b, int words)
                        BNerr(BN_F_BN_EXPAND2,BN_R_EXPAND_ON_STATIC_BIGNUM_DATA);
                        return(NULL);
                        }
-               a=A=(BN_ULONG *)Malloc(sizeof(BN_ULONG)*(words+1));
+               a=A=(BN_ULONG *)OPENSSL_malloc(sizeof(BN_ULONG)*(words+1));
                if (A == NULL)
                        {
                        BNerr(BN_F_BN_EXPAND2,ERR_R_MALLOC_FAILURE);
@@ -389,7 +357,7 @@ BIGNUM *bn_expand2(BIGNUM *b, int words)
  * if A and B happen to share same cache line such code is going to
  * cause severe cache trashing. Both factors have severe impact on
  * performance of modern CPUs and this is the reason why this
- * particulare piece of code is #ifdefed away and replaced by more
+ * particular piece of code is #ifdefed away and replaced by more
  * "friendly" version found in #else section below. This comment
  * also applies to BN_copy function.
  *
@@ -420,7 +388,7 @@ BIGNUM *bn_expand2(BIGNUM *b, int words)
                                A[0]=B[0];
                        case 0:
                                /* I need the 'case 0' entry for utrix cc.
-                                * If the optimiser is turned on, it does the
+                                * If the optimizer is turned on, it does the
                                 * switch table by doing
                                 * a=top&7
                                 * a--;
@@ -455,21 +423,21 @@ BIGNUM *bn_expand2(BIGNUM *b, int words)
                                case 0: ; /* ultrix cc workaround, see above */
                                }
 #endif
-                       Free(b->d);
+                       OPENSSL_free(b->d);
                        }
 
                b->d=a;
-               b->max=words;
+               b->dmax=words;
 
                /* Now need to zero any data between b->top and b->max */
 
                A= &(b->d[b->top]);
-               for (i=(b->max - b->top)>>3; i>0; i--,A+=8)
+               for (i=(b->dmax - b->top)>>3; i>0; i--,A+=8)
                        {
                        A[0]=0; A[1]=0; A[2]=0; A[3]=0;
                        A[4]=0; A[5]=0; A[6]=0; A[7]=0;
                        }
-               for (i=(b->max - b->top)&7; i>0; i--,A++)
+               for (i=(b->dmax - b->top)&7; i>0; i--,A++)
                        A[0]=0;
 #else
                        memset(A,0,sizeof(BN_ULONG)*(words+1));
@@ -489,6 +457,8 @@ BIGNUM *BN_dup(const BIGNUM *a)
        {
        BIGNUM *r;
 
+       if (a == NULL) return NULL;
+
        bn_check_top(a);
 
        r=BN_new();
@@ -538,7 +508,7 @@ BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b)
 void BN_clear(BIGNUM *a)
        {
        if (a->d != NULL)
-               memset(a->d,0,a->max*sizeof(a->d[0]));
+               memset(a->d,0,a->dmax*sizeof(a->d[0]));
        a->top=0;
        a->neg=0;
        }
@@ -629,7 +599,7 @@ BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret)
        }
 
 /* ignore negative */
-int BN_bn2bin(BIGNUM *a, unsigned char *to)
+int BN_bn2bin(const BIGNUM *a, unsigned char *to)
        {
        int n,i;
        BN_ULONG l;