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

openssl/crypto/rc4/rc4_enc.c

 /* crypto/rc4/rc4_enc.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 49 matching lines @@
 #include "rc4_locl.h"
 
 /* RC4 as implemented from a posting from
  * Newsgroups: sci.crypt
  * From: sterndark@netcom.com (David Sterndark)
  * Subject: RC4 Algorithm revealed.
  * Message-ID: <sternCvKL4B.Hyy@netcom.com>
  * Date: Wed, 14 Sep 1994 06:35:31 GMT
  */
 
-void RC4(RC4_KEY *key, unsigned long len, const unsigned char *indata,
+void RC4(RC4_KEY *key, size_t len, const unsigned char *indata,
              unsigned char *outdata)
         {
         register RC4_INT *d;
         register RC4_INT x,y,tx,ty;
-        int i;
+        size_t i;
         
         x=key->x;     
         y=key->y;     
         d=key->data; 
 
 #if defined(RC4_CHUNK)
         /*
          * The original reason for implementing this(*) was the fact that
          * pre-21164a Alpha CPUs don't have byte load/store instructions
          * and e.g. a byte store has to be done with 64-bit load, shift,
@@ skipping 27 matching lines @@
 # define RC4_STEP       ( \
                         x=(x+1) &0xff,  \
                         tx=d[x],        \
                         y=(tx+y)&0xff,  \
                         ty=d[y],        \
                         d[y]=tx,        \
                         d[x]=ty,        \
                         (RC4_CHUNK)d[(tx+ty)&0xff]\
                         )
 
-        if ( ( ((unsigned long)indata  & (sizeof(RC4_CHUNK)-1)) | 
-               ((unsigned long)outdata & (sizeof(RC4_CHUNK)-1)) ) == 0 )
+        if ( ( ((size_t)indata  & (sizeof(RC4_CHUNK)-1)) | 
+               ((size_t)outdata & (sizeof(RC4_CHUNK)-1)) ) == 0 )
                 {
                 RC4_CHUNK ichunk,otp;
                 const union { long one; char little; } is_endian = {1};
 
                 /*
                  * I reckon we can afford to implement both endian
                  * cases and to decide which way to take at run-time
                  * because the machine code appears to be very compact
                  * and redundant 1-2KB is perfectly tolerable (i.e.
                  * in case the compiler fails to eliminate it:-). By
@@ skipping 15 matching lines @@
                  *   before);
                  * - in case you wonder "&(sizeof(RC4_CHUNK)*8-1)" in
                  *   [LB]ESHFT guards against "shift is out of range"
                  *   warnings when sizeof(RC4_CHUNK)!=8 
                  *
                  *                      <appro@fy.chalmers.se>
                  */
                 if (!is_endian.little)
                         {       /* BIG-ENDIAN CASE */
 # define BESHFT(c)      (((sizeof(RC4_CHUNK)-(c)-1)*8)&(sizeof(RC4_CHUNK)*8-1))
-                        for (;len&~(sizeof(RC4_CHUNK)-1);len-=sizeof(RC4_CHUNK))
+                        for (;len&(0-sizeof(RC4_CHUNK));len-=sizeof(RC4_CHUNK))
                                 {
                                 ichunk  = *(RC4_CHUNK *)indata;
                                 otp  = RC4_STEP<<BESHFT(0);
                                 otp |= RC4_STEP<<BESHFT(1);
                                 otp |= RC4_STEP<<BESHFT(2);
                                 otp |= RC4_STEP<<BESHFT(3);
                                 if (sizeof(RC4_CHUNK)==8)
                                         {
                                         otp |= RC4_STEP<<BESHFT(4);
                                         otp |= RC4_STEP<<BESHFT(5);
@@ skipping 32 matching lines @@
                                 ochunk |= (otp^ichunk) & mask;
                                 *(RC4_CHUNK *)outdata = ochunk;
                                 }
                         key->x=x;     
                         key->y=y;
                         return;
                         }
                 else
                         {       /* LITTLE-ENDIAN CASE */
 # define LESHFT(c)      (((c)*8)&(sizeof(RC4_CHUNK)*8-1))
-                        for (;len&~(sizeof(RC4_CHUNK)-1);len-=sizeof(RC4_CHUNK))
+                        for (;len&(0-sizeof(RC4_CHUNK));len-=sizeof(RC4_CHUNK))
                                 {
                                 ichunk  = *(RC4_CHUNK *)indata;
                                 otp  = RC4_STEP;
                                 otp |= RC4_STEP<<8;
                                 otp |= RC4_STEP<<16;
                                 otp |= RC4_STEP<<24;
                                 if (sizeof(RC4_CHUNK)==8)
                                         {
                                         otp |= RC4_STEP<<LESHFT(4);
                                         otp |= RC4_STEP<<LESHFT(5);
@@ skipping 45 matching lines @@
                 d[x]=ty=d[y]; \
                 d[y]=tx; \
                 (out) = d[(tx+ty)&0xff]^ (in);
 
 #ifndef RC4_INDEX
 #define RC4_LOOP(a,b,i) LOOP(*((a)++),*((b)++))
 #else
 #define RC4_LOOP(a,b,i) LOOP(a[i],b[i])
 #endif
 
-        i=(int)(len>>3L);
+        i=len>>3;
         if (i)
                 {
                 for (;;)
                         {
                         RC4_LOOP(indata,outdata,0);
                         RC4_LOOP(indata,outdata,1);
                         RC4_LOOP(indata,outdata,2);
                         RC4_LOOP(indata,outdata,3);
                         RC4_LOOP(indata,outdata,4);
                         RC4_LOOP(indata,outdata,5);
                         RC4_LOOP(indata,outdata,6);
                         RC4_LOOP(indata,outdata,7);
 #ifdef RC4_INDEX
                         indata+=8;
                         outdata+=8;
 #endif
                         if (--i == 0) break;
                         }
                 }
-        i=(int)len&0x07;
+        i=len&0x07;
         if (i)
                 {
                 for (;;)
                         {
                         RC4_LOOP(indata,outdata,0); if (--i == 0) break;
                         RC4_LOOP(indata,outdata,1); if (--i == 0) break;
                         RC4_LOOP(indata,outdata,2); if (--i == 0) break;
                         RC4_LOOP(indata,outdata,3); if (--i == 0) break;
                         RC4_LOOP(indata,outdata,4); if (--i == 0) break;
                         RC4_LOOP(indata,outdata,5); if (--i == 0) break;
                         RC4_LOOP(indata,outdata,6); if (--i == 0) break;
                         }
                 }               
         key->x=x;     
         key->y=y;
         }