Upgrade chrome's OpenSSL to same version Android ships with.

openssl/crypto/asn1/a_int.c

 /* crypto/asn1/a_int.c */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
  * This package is an SSL implementation written
  * by Eric Young (eay@cryptsoft.com).
  * The implementation was written so as to conform with Netscapes SSL.
  * 
  * This library is free for commercial and non-commercial use as long as
  * the following conditions are aheared to.  The following conditions
@@ skipping 43 matching lines @@
  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
 
 #include <stdio.h>
 #include "cryptlib.h"
 #include <openssl/asn1.h>
 #include <openssl/bn.h>
 
-ASN1_INTEGER *ASN1_INTEGER_dup(ASN1_INTEGER *x)
+ASN1_INTEGER *ASN1_INTEGER_dup(const ASN1_INTEGER *x)
 { return M_ASN1_INTEGER_dup(x);}
 
-int ASN1_INTEGER_cmp(ASN1_INTEGER *x, ASN1_INTEGER *y)
+int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y)
         { 
         int neg, ret;
         /* Compare signs */
         neg = x->type & V_ASN1_NEG;
         if (neg != (y->type & V_ASN1_NEG))
                 {
                 if (neg)
                         return -1;
                 else
                         return 1;
@@ skipping 188 matching lines @@
 /* This is a version of d2i_ASN1_INTEGER that ignores the sign bit of
  * ASN1 integers: some broken software can encode a positive INTEGER
  * with its MSB set as negative (it doesn't add a padding zero).
  */
 
 ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp,
              long length)
         {
         ASN1_INTEGER *ret=NULL;
         const unsigned char *p;
-        unsigned char *to,*s;
+        unsigned char *s;
         long len;
         int inf,tag,xclass;
         int i;
 
         if ((a == NULL) || ((*a) == NULL))
                 {
                 if ((ret=M_ASN1_INTEGER_new()) == NULL) return(NULL);
                 ret->type=V_ASN1_INTEGER;
                 }
         else
@@ skipping 14 matching lines @@
                 }
 
         /* We must OPENSSL_malloc stuff, even for 0 bytes otherwise it
          * signifies a missing NULL parameter. */
         s=(unsigned char *)OPENSSL_malloc((int)len+1);
         if (s == NULL)
                 {
                 i=ERR_R_MALLOC_FAILURE;
                 goto err;
                 }
-        to=s;
         ret->type=V_ASN1_INTEGER;
         if(len) {
                 if ((*p == 0) && (len != 1))
                         {
                         p++;
                         len--;
                         }
                 memcpy(s,p,(int)len);
                 p+=len;
         }
@@ skipping 44 matching lines @@
                 buf[i]=(int)d&0xff;
                 d>>=8;
                 }
         j=0;
         for (k=i-1; k >=0; k--)
                 a->data[j++]=buf[k];
         a->length=j;
         return(1);
         }
 
-long ASN1_INTEGER_get(ASN1_INTEGER *a)
+long ASN1_INTEGER_get(const ASN1_INTEGER *a)
         {
         int neg=0,i;
         long r=0;
 
         if (a == NULL) return(0L);
         i=a->type;
         if (i == V_ASN1_NEG_INTEGER)
                 neg=1;
         else if (i != V_ASN1_INTEGER)
                 return -1;
         
         if (a->length > (int)sizeof(long))
                 {
                 /* hmm... a bit ugly */
                 return(0xffffffffL);
                 }
         if (a->data == NULL)
                 return 0;
 
         for (i=0; i<a->length; i++)
                 {
                 r<<=8;
                 r|=(unsigned char)a->data[i];
                 }
         if (neg) r= -r;
         return(r);
         }
 
-ASN1_INTEGER *BN_to_ASN1_INTEGER(BIGNUM *bn, ASN1_INTEGER *ai)
+ASN1_INTEGER *BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai)
         {
         ASN1_INTEGER *ret;
         int len,j;
 
         if (ai == NULL)
                 ret=M_ASN1_INTEGER_new();
         else
                 ret=ai;
         if (ret == NULL)
                 {
@@ skipping 21 matching lines @@
                 {
                 ret->data[0] = 0;
                 ret->length = 1;
                 }
         return(ret);
 err:
         if (ret != ai) M_ASN1_INTEGER_free(ret);
         return(NULL);
         }
 
-BIGNUM *ASN1_INTEGER_to_BN(ASN1_INTEGER *ai, BIGNUM *bn)
+BIGNUM *ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn)
         {
         BIGNUM *ret;
 
         if ((ret=BN_bin2bn(ai->data,ai->length,bn)) == NULL)
                 ASN1err(ASN1_F_ASN1_INTEGER_TO_BN,ASN1_R_BN_LIB);
         else if(ai->type == V_ASN1_NEG_INTEGER)
                 BN_set_negative(ret, 1);
         return(ret);
         }
 
 IMPLEMENT_STACK_OF(ASN1_INTEGER)
 IMPLEMENT_ASN1_SET_OF(ASN1_INTEGER)