Put the first stage of my bignum debugging adventures into CVS. This code

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

diff --git a/crypto/bn/bn_print.c b/crypto/bn/bn_print.c
index 91418a23512c90a7d5275a8fb807721a093aacfd..5b5eb8fc9cb075824d9bb4fcf49ed7c7dcfc4335 100644 (file)
--- a/crypto/bn/bn_print.c
+++ b/crypto/bn/bn_print.c
@@ -64,14 +64,14 @@
 
 static const char *Hex="0123456789ABCDEF";
 
-/* Must 'Free' the returned data */
-char *BN_bn2hex(BIGNUM *a)
+/* Must 'OPENSSL_free' the returned data */
+char *BN_bn2hex(const BIGNUM *a)
        {
        int i,j,v,z=0;
        char *buf;
        char *p;
 
-       buf=(char *)Malloc(a->top*BN_BYTES*2+2);
+       buf=(char *)OPENSSL_malloc(a->top*BN_BYTES*2+2);
        if (buf == NULL)
                {
                BNerr(BN_F_BN_BN2HEX,ERR_R_MALLOC_FAILURE);
@@ -99,8 +99,8 @@ err:
        return(buf);
        }
 
-/* Must 'Free' the returned data */
-char *BN_bn2dec(BIGNUM *a)
+/* Must 'OPENSSL_free' the returned data */
+char *BN_bn2dec(const BIGNUM *a)
        {
        int i=0,num;
        char *buf=NULL;
@@ -110,8 +110,8 @@ char *BN_bn2dec(BIGNUM *a)
 
        i=BN_num_bits(a)*3;
        num=(i/10+i/1000+3)+1;
-       bn_data=(BN_ULONG *)Malloc((num/BN_DEC_NUM+1)*sizeof(BN_ULONG));
-       buf=(char *)Malloc(num+3);
+       bn_data=(BN_ULONG *)OPENSSL_malloc((num/BN_DEC_NUM+1)*sizeof(BN_ULONG));
+       buf=(char *)OPENSSL_malloc(num+3);
        if ((buf == NULL) || (bn_data == NULL))
                {
                BNerr(BN_F_BN_BN2DEC,ERR_R_MALLOC_FAILURE);
@@ -137,7 +137,7 @@ char *BN_bn2dec(BIGNUM *a)
                        }
                lp--;
                /* We now have a series of blocks, BN_DEC_NUM chars
-                * in length, where the last one needs trucation.
+                * in length, where the last one needs truncation.
                 * The blocks need to be reversed in order. */
                sprintf(p,BN_DEC_FMT1,*lp);
                while (*p) p++;
@@ -149,12 +149,12 @@ char *BN_bn2dec(BIGNUM *a)
                        }
                }
 err:
-       if (bn_data != NULL) Free(bn_data);
+       if (bn_data != NULL) OPENSSL_free(bn_data);
        if (t != NULL) BN_free(t);
        return(buf);
        }
 
-int BN_hex2bn(BIGNUM **bn, char *a)
+int BN_hex2bn(BIGNUM **bn, const char *a)
        {
        BIGNUM *ret=NULL;
        BN_ULONG l=0;
@@ -171,7 +171,7 @@ int BN_hex2bn(BIGNUM **bn, char *a)
        num=i+neg;
        if (bn == NULL) return(num);
 
-       /* a is the start of the hex digets, and it is 'i' long */
+       /* a is the start of the hex digits, and it is 'i' long */
        if (*bn == NULL)
                {
                if ((ret=BN_new()) == NULL) return(0);
@@ -185,7 +185,7 @@ int BN_hex2bn(BIGNUM **bn, char *a)
        /* i is the number of hex digests; */
        if (bn_expand(ret,i*4) == NULL) goto err;
 
-       j=i; /* least significate 'hex' */
+       j=i; /* least significant 'hex' */
        m=0;
        h=0;
        while (j > 0)
@@ -210,17 +210,18 @@ int BN_hex2bn(BIGNUM **bn, char *a)
                j-=(BN_BYTES*2);
                }
        ret->top=h;
-       bn_fix_top(ret);
+       bn_correct_top(ret);
        ret->neg=neg;
 
        *bn=ret;
+       bn_check_top(ret);
        return(num);
 err:
        if (*bn == NULL) BN_free(ret);
        return(0);
        }
 
-int BN_dec2bn(BIGNUM **bn, char *a)
+int BN_dec2bn(BIGNUM **bn, const char *a)
        {
        BIGNUM *ret=NULL;
        BN_ULONG l=0;
@@ -236,8 +237,8 @@ int BN_dec2bn(BIGNUM **bn, char *a)
        num=i+neg;
        if (bn == NULL) return(num);
 
-       /* a is the start of the digets, and it is 'i' long.
-        * We chop it into BN_DEC_NUM digets at a time */
+       /* a is the start of the digits, and it is 'i' long.
+        * We chop it into BN_DEC_NUM digits at a time */
        if (*bn == NULL)
                {
                if ((ret=BN_new()) == NULL) return(0);
@@ -269,18 +270,18 @@ int BN_dec2bn(BIGNUM **bn, char *a)
                }
        ret->neg=neg;
 
-       bn_fix_top(ret);
+       bn_correct_top(ret);
        *bn=ret;
+       bn_check_top(ret);
        return(num);
 err:
        if (*bn == NULL) BN_free(ret);
        return(0);
        }
 
-#ifndef NO_BIO
-
-#ifndef NO_FP_API
-int BN_print_fp(FILE *fp, BIGNUM *a)
+#ifndef OPENSSL_NO_BIO
+#ifndef OPENSSL_NO_FP_API
+int BN_print_fp(FILE *fp, const BIGNUM *a)
        {
        BIO *b;
        int ret;
@@ -319,5 +320,15 @@ int BN_print(BIO *bp, const BIGNUM *a)
 end:
        return(ret);
        }
+#endif
 
+#ifdef BN_DEBUG
+void bn_dump1(FILE *o, const char *a, const BN_ULONG *b,int n)
+       {
+       int i;
+       fprintf(o, "%s=", a);
+       for (i=n-1;i>=0;i--)
+               fprintf(o, "%08lX", b[i]); /* assumes 32-bit BN_ULONG */
+       fprintf(o, "\n");
+       }
 #endif