Don't install e_os.h in include/openssl, use it only as a local

[oweals/openssl.git] / crypto / bn / bn_mul.c

diff --git a/crypto/bn/bn_mul.c b/crypto/bn/bn_mul.c
index fc7bf974fd162299bce6a4f2576d93f10bc63ad7..4b19c9f043d6ed60ffb0183d6c853d339053fa35 100644 (file)
--- a/crypto/bn/bn_mul.c
+++ b/crypto/bn/bn_mul.c
@@ -71,10 +71,8 @@
  * a[0]*b[0]+a[1]*b[1]+(a[0]-a[1])*(b[1]-b[0])
  * a[1]*b[1]
  */
-void bn_mul_recursive(r,a,b,n2,t)
-BN_ULONG *r,*a,*b;
-int n2;
-BN_ULONG *t;
+void bn_mul_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n2,
+            BN_ULONG *t)
        {
        int n=n2/2,c1,c2;
        unsigned int neg,zero;
@@ -176,16 +174,16 @@ printf(" bn_mul_recursive %d * %d\n",n2,n2);
         * r[32] holds (b[1]*b[1])
         */
 
-       c1=bn_add_words(t,r,&(r[n2]),n2);
+       c1=(int)(bn_add_words(t,r,&(r[n2]),n2));
 
        if (neg) /* if t[32] is negative */
                {
-               c1-=bn_sub_words(&(t[n2]),t,&(t[n2]),n2);
+               c1-=(int)(bn_sub_words(&(t[n2]),t,&(t[n2]),n2));
                }
        else
                {
                /* Might have a carry */
-               c1+=bn_add_words(&(t[n2]),&(t[n2]),t,n2);
+               c1+=(int)(bn_add_words(&(t[n2]),&(t[n2]),t,n2));
                }
 
        /* t[32] holds (a[0]-a[1])*(b[1]-b[0])+(a[0]*b[0])+(a[1]*b[1])
@@ -193,7 +191,7 @@ printf(" bn_mul_recursive %d * %d\n",n2,n2);
         * r[32] holds (b[1]*b[1])
         * c1 holds the carry bits
         */
-       c1+=bn_add_words(&(r[n]),&(r[n]),&(t[n2]),n2);
+       c1+=(int)(bn_add_words(&(r[n]),&(r[n]),&(t[n2]),n2));
        if (c1)
                {
                p= &(r[n+n2]);
@@ -217,10 +215,8 @@ printf(" bn_mul_recursive %d * %d\n",n2,n2);
 
 /* n+tn is the word length
  * t needs to be n*4 is size, as does r */
-void bn_mul_part_recursive(r,a,b,tn,n,t)
-BN_ULONG *r,*a,*b;
-int tn,n;
-BN_ULONG *t;
+void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int tn,
+            int n, BN_ULONG *t)
        {
        int i,j,n2=n*2;
        unsigned int c1;
@@ -311,15 +307,15 @@ printf(" bn_mul_part_recursive %d * %d\n",tn+n,tn+n);
         * r[32] holds (b[1]*b[1])
         */
 
-       c1=bn_add_words(t,r,&(r[n2]),n2);
-       c1-=bn_sub_words(&(t[n2]),t,&(t[n2]),n2);
+       c1=(int)(bn_add_words(t,r,&(r[n2]),n2));
+       c1-=(int)(bn_sub_words(&(t[n2]),t,&(t[n2]),n2));
 
        /* t[32] holds (a[0]-a[1])*(b[1]-b[0])+(a[0]*b[0])+(a[1]*b[1])
         * r[10] holds (a[0]*b[0])
         * r[32] holds (b[1]*b[1])
         * c1 holds the carry bits
         */
-       c1+=bn_add_words(&(r[n]),&(r[n]),&(t[n2]),n2);
+       c1+=(int)(bn_add_words(&(r[n]),&(r[n]),&(t[n2]),n2));
        if (c1)
                {
                p= &(r[n+n2]);
@@ -344,10 +340,8 @@ printf(" bn_mul_part_recursive %d * %d\n",tn+n,tn+n);
 /* a and b must be the same size, which is n2.
  * r needs to be n2 words and t needs to be n2*2
  */
-void bn_mul_low_recursive(r,a,b,n2,t)
-BN_ULONG *r,*a,*b;
-int n2;
-BN_ULONG *t;
+void bn_mul_low_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n2,
+            BN_ULONG *t)
        {
        int n=n2/2;
 
@@ -377,10 +371,8 @@ printf(" bn_mul_low_recursive %d * %d\n",n2,n2);
  * l is the low words of the output.
  * t needs to be n2*3
  */
-void bn_mul_high(r,a,b,l,n2,t)
-BN_ULONG *r,*a,*b,*l;
-int n2;
-BN_ULONG *t;
+void bn_mul_high(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, BN_ULONG *l, int n2,
+            BN_ULONG *t)
        {
        int i,n;
        int c1,c2;
@@ -390,7 +382,7 @@ BN_ULONG *t;
 #ifdef BN_COUNT
 printf(" bn_mul_high %d * %d\n",n2,n2);
 #endif
-       n=(n2+1)/2;
+       n=n2/2;
 
        /* Calculate (al-ah)*(bh-bl) */
        neg=zero=0;
@@ -454,7 +446,7 @@ printf(" bn_mul_high %d * %d\n",n2,n2);
        if (l != NULL)
                {
                lp= &(t[n2+n]);
-               c1=bn_add_words(lp,&(r[0]),&(l[0]),n);
+               c1=(int)(bn_add_words(lp,&(r[0]),&(l[0]),n));
                }
        else
                {
@@ -463,7 +455,7 @@ printf(" bn_mul_high %d * %d\n",n2,n2);
                }
 
        if (neg)
-               neg=bn_sub_words(&(t[n2]),lp,&(t[0]),n);
+               neg=(int)(bn_sub_words(&(t[n2]),lp,&(t[0]),n));
        else
                {
                bn_add_words(&(t[n2]),lp,&(t[0]),n);
@@ -498,25 +490,25 @@ printf(" bn_mul_high %d * %d\n",n2,n2);
        if (l != NULL)
                {
                lp= &(t[n2]);
-               c1= bn_add_words(lp,&(t[n2+n]),&(l[0]),n);
+               c1= (int)(bn_add_words(lp,&(t[n2+n]),&(l[0]),n));
                }
        else
                {
                lp= &(t[n2+n]);
                c1=0;
                }
-       c1+=bn_add_words(&(t[n2]),lp,  &(r[0]),n);
+       c1+=(int)(bn_add_words(&(t[n2]),lp,  &(r[0]),n));
        if (oneg)
-               c1-=bn_sub_words(&(t[n2]),&(t[n2]),&(t[0]),n);
+               c1-=(int)(bn_sub_words(&(t[n2]),&(t[n2]),&(t[0]),n));
        else
-               c1+=bn_add_words(&(t[n2]),&(t[n2]),&(t[0]),n);
+               c1+=(int)(bn_add_words(&(t[n2]),&(t[n2]),&(t[0]),n));
 
-       c2 =bn_add_words(&(r[0]),&(r[0]),&(t[n2+n]),n);
-       c2+=bn_add_words(&(r[0]),&(r[0]),&(r[n]),n);
+       c2 =(int)(bn_add_words(&(r[0]),&(r[0]),&(t[n2+n]),n));
+       c2+=(int)(bn_add_words(&(r[0]),&(r[0]),&(r[n]),n));
        if (oneg)
-               c2-=bn_sub_words(&(r[0]),&(r[0]),&(t[n]),n);
+               c2-=(int)(bn_sub_words(&(r[0]),&(r[0]),&(t[n]),n));
        else
-               c2+=bn_add_words(&(r[0]),&(r[0]),&(t[n]),n);
+               c2+=(int)(bn_add_words(&(r[0]),&(r[0]),&(t[n]),n));
        
        if (c1 != 0) /* Add starting at r[0], could be +ve or -ve */
                {
@@ -565,15 +557,14 @@ printf(" bn_mul_high %d * %d\n",n2,n2);
        }
 #endif
 
-int BN_mul(r,a,b,ctx)
-BIGNUM *r,*a,*b;
-BN_CTX *ctx;
+int BN_mul(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
        {
-       int top,i,j,k,al,bl;
+       int top,al,bl;
+       BIGNUM *rr;
+#ifdef BN_RECURSION
        BIGNUM *t;
-
-       t=NULL;
-       i=j=k=0;
+       int i,j,k;
+#endif
 
 #ifdef BN_COUNT
 printf("BN_mul %d * %d\n",a->top,b->top);
@@ -593,22 +584,28 @@ printf("BN_mul %d * %d\n",a->top,b->top);
                return(1);
                }
        top=al+bl;
+
+       if ((r == a) || (r == b))
+               rr= &(ctx->bn[ctx->tos+1]);
+       else
+               rr=r;
+
 #if defined(BN_MUL_COMBA) || defined(BN_RECURSION)
        if (al == bl)
                {
 #  ifdef BN_MUL_COMBA
 /*             if (al == 4)
                        {
-                       if (bn_wexpand(r,8) == NULL) return(0);
+                       if (bn_wexpand(rr,8) == NULL) return(0);
                        r->top=8;
-                       bn_mul_comba4(r->d,a->d,b->d);
+                       bn_mul_comba4(rr->d,a->d,b->d);
                        goto end;
                        }
                else */ if (al == 8)
                        {
-                       if (bn_wexpand(r,16) == NULL) return(0);
+                       if (bn_wexpand(rr,16) == NULL) return(0);
                        r->top=16;
-                       bn_mul_comba8(r->d,a->d,b->d);
+                       bn_mul_comba8(rr->d,a->d,b->d);
                        goto end;
                        }
                else
@@ -617,9 +614,9 @@ printf("BN_mul %d * %d\n",a->top,b->top);
                if (al < BN_MULL_SIZE_NORMAL)
 #endif
                        {
-                       if (bn_wexpand(r,top) == NULL) return(0);
-                       r->top=top;
-                       bn_mul_normal(r->d,a->d,al,b->d,bl);
+                       if (bn_wexpand(rr,top) == NULL) return(0);
+                       rr->top=top;
+                       bn_mul_normal(rr->d,a->d,al,b->d,bl);
                        goto end;
                        }
 #  ifdef BN_RECURSION
@@ -630,9 +627,9 @@ printf("BN_mul %d * %d\n",a->top,b->top);
 #ifdef BN_RECURSION
        else if ((al < BN_MULL_SIZE_NORMAL) || (bl < BN_MULL_SIZE_NORMAL))
                {
-               if (bn_wexpand(r,top) == NULL) return(0);
-               r->top=top;
-               bn_mul_normal(r->d,a->d,al,b->d,bl);
+               if (bn_wexpand(rr,top) == NULL) return(0);
+               rr->top=top;
+               bn_mul_normal(rr->d,a->d,al,b->d,bl);
                goto end;
                }
        else
@@ -656,9 +653,9 @@ printf("BN_mul %d * %d\n",a->top,b->top);
 #endif
 
        /* asymetric and >= 4 */ 
-       if (bn_wexpand(r,top) == NULL) return(0);
-       r->top=top;
-       bn_mul_normal(r->d,a->d,al,b->d,bl);
+       if (bn_wexpand(rr,top) == NULL) return(0);
+       rr->top=top;
+       bn_mul_normal(rr->d,a->d,al,b->d,bl);
 
 #ifdef BN_RECURSION
        if (0)
@@ -673,34 +670,33 @@ symetric:
                if (al == j) /* exact multiple */
                        {
                        bn_wexpand(t,k*2);
-                       bn_wexpand(r,k*2);
-                       bn_mul_recursive(r->d,a->d,b->d,al,t->d);
+                       bn_wexpand(rr,k*2);
+                       bn_mul_recursive(rr->d,a->d,b->d,al,t->d);
                        }
                else
                        {
                        bn_wexpand(a,k);
                        bn_wexpand(b,k);
                        bn_wexpand(t,k*4);
-                       bn_wexpand(r,k*4);
+                       bn_wexpand(rr,k*4);
                        for (i=a->top; i<k; i++)
                                a->d[i]=0;
                        for (i=b->top; i<k; i++)
                                b->d[i]=0;
-                       bn_mul_part_recursive(r->d,a->d,b->d,al-j,j,t->d);
+                       bn_mul_part_recursive(rr->d,a->d,b->d,al-j,j,t->d);
                        }
-               r->top=top;
+               rr->top=top;
                }
 #endif
+#if defined(BN_MUL_COMBA) || defined(BN_RECURSION)
 end:
-       bn_fix_top(r);
+#endif
+       bn_fix_top(rr);
+       if (r != rr) BN_copy(r,rr);
        return(1);
        }
 
-void bn_mul_normal(r,a,na,b,nb)
-BN_ULONG *r,*a;
-int na;
-BN_ULONG *b;
-int nb;
+void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
        {
        BN_ULONG *rr;
 
@@ -736,9 +732,7 @@ printf(" bn_mul_normal %d * %d\n",na,nb);
                }
        }
 
-void bn_mul_low_normal(r,a,b,n)
-BN_ULONG *r,*a,*b;
-int n;
+void bn_mul_low_normal(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n)
        {
 #ifdef BN_COUNT
 printf(" bn_mul_low_normal %d * %d\n",n,n);