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

openssl/crypto/lhash/lhash.c

 /* crypto/lhash/lhash.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 89 matching lines @@
 #include <openssl/crypto.h>
 #include <openssl/lhash.h>
 
 const char lh_version[]="lhash" OPENSSL_VERSION_PTEXT;
 
 #undef MIN_NODES 
 #define MIN_NODES       16
 #define UP_LOAD         (2*LH_LOAD_MULT) /* load times 256  (default 2) */
 #define DOWN_LOAD       (LH_LOAD_MULT)   /* load times 256  (default 1) */
 
-static void expand(LHASH *lh);
-static void contract(LHASH *lh);
-static LHASH_NODE **getrn(LHASH *lh, const void *data, unsigned long *rhash);
+static void expand(_LHASH *lh);
+static void contract(_LHASH *lh);
+static LHASH_NODE **getrn(_LHASH *lh, const void *data, unsigned long *rhash);
 
-LHASH *lh_new(LHASH_HASH_FN_TYPE h, LHASH_COMP_FN_TYPE c)
+_LHASH *lh_new(LHASH_HASH_FN_TYPE h, LHASH_COMP_FN_TYPE c)
         {
-        LHASH *ret;
+        _LHASH *ret;
         int i;
 
-        if ((ret=(LHASH *)OPENSSL_malloc(sizeof(LHASH))) == NULL)
+        if ((ret=OPENSSL_malloc(sizeof(_LHASH))) == NULL)
                 goto err0;
-        if ((ret->b=(LHASH_NODE **)OPENSSL_malloc(sizeof(LHASH_NODE *)*MIN_NODES)) == NULL)
+        if ((ret->b=OPENSSL_malloc(sizeof(LHASH_NODE *)*MIN_NODES)) == NULL)
                 goto err1;
         for (i=0; i<MIN_NODES; i++)
                 ret->b[i]=NULL;
         ret->comp=((c == NULL)?(LHASH_COMP_FN_TYPE)strcmp:c);
         ret->hash=((h == NULL)?(LHASH_HASH_FN_TYPE)lh_strhash:h);
         ret->num_nodes=MIN_NODES/2;
         ret->num_alloc_nodes=MIN_NODES;
         ret->p=0;
         ret->pmax=MIN_NODES/2;
         ret->up_load=UP_LOAD;
@@ skipping 15 matching lines @@
         ret->num_hash_comps=0;
 
         ret->error=0;
         return(ret);
 err1:
         OPENSSL_free(ret);
 err0:
         return(NULL);
         }
 
-void lh_free(LHASH *lh)
+void lh_free(_LHASH *lh)
         {
         unsigned int i;
         LHASH_NODE *n,*nn;
 
         if (lh == NULL)
             return;
 
         for (i=0; i<lh->num_nodes; i++)
                 {
                 n=lh->b[i];
                 while (n != NULL)
                         {
                         nn=n->next;
                         OPENSSL_free(n);
                         n=nn;
                         }
                 }
         OPENSSL_free(lh->b);
         OPENSSL_free(lh);
         }
 
-void *lh_insert(LHASH *lh, void *data)
+void *lh_insert(_LHASH *lh, void *data)
         {
         unsigned long hash;
         LHASH_NODE *nn,**rn;
         void *ret;
 
         lh->error=0;
         if (lh->up_load <= (lh->num_items*LH_LOAD_MULT/lh->num_nodes))
                 expand(lh);
 
         rn=getrn(lh,data,&hash);
@@ skipping 17 matching lines @@
                 }
         else /* replace same key */
                 {
                 ret= (*rn)->data;
                 (*rn)->data=data;
                 lh->num_replace++;
                 }
         return(ret);
         }
 
-void *lh_delete(LHASH *lh, const void *data)
+void *lh_delete(_LHASH *lh, const void *data)
         {
         unsigned long hash;
         LHASH_NODE *nn,**rn;
         void *ret;
 
         lh->error=0;
         rn=getrn(lh,data,&hash);
 
         if (*rn == NULL)
                 {
@@ skipping 10 matching lines @@
                 }
 
         lh->num_items--;
         if ((lh->num_nodes > MIN_NODES) &&
                 (lh->down_load >= (lh->num_items*LH_LOAD_MULT/lh->num_nodes)))
                 contract(lh);
 
         return(ret);
         }
 
-void *lh_retrieve(LHASH *lh, const void *data)
+void *lh_retrieve(_LHASH *lh, const void *data)
         {
         unsigned long hash;
         LHASH_NODE **rn;
         void *ret;
 
         lh->error=0;
         rn=getrn(lh,data,&hash);
 
         if (*rn == NULL)
                 {
                 lh->num_retrieve_miss++;
                 return(NULL);
                 }
         else
                 {
                 ret= (*rn)->data;
                 lh->num_retrieve++;
                 }
         return(ret);
         }
 
-static void doall_util_fn(LHASH *lh, int use_arg, LHASH_DOALL_FN_TYPE func,
+static void doall_util_fn(_LHASH *lh, int use_arg, LHASH_DOALL_FN_TYPE func,
                           LHASH_DOALL_ARG_FN_TYPE func_arg, void *arg)
         {
         int i;
         LHASH_NODE *a,*n;
 
+        if (lh == NULL)
+                return;
+
         /* reverse the order so we search from 'top to bottom'
          * We were having memory leaks otherwise */
         for (i=lh->num_nodes-1; i>=0; i--)
                 {
                 a=lh->b[i];
                 while (a != NULL)
                         {
                         /* 28/05/91 - eay - n added so items can be deleted
                          * via lh_doall */
+                        /* 22/05/08 - ben - eh? since a is not passed,
+                         * this should not be needed */
                         n=a->next;
                         if(use_arg)
                                 func_arg(a->data,arg);
                         else
                                 func(a->data);
                         a=n;
                         }
                 }
         }
 
-void lh_doall(LHASH *lh, LHASH_DOALL_FN_TYPE func)
+void lh_doall(_LHASH *lh, LHASH_DOALL_FN_TYPE func)
         {
         doall_util_fn(lh, 0, func, (LHASH_DOALL_ARG_FN_TYPE)0, NULL);
         }
 
-void lh_doall_arg(LHASH *lh, LHASH_DOALL_ARG_FN_TYPE func, void *arg)
+void lh_doall_arg(_LHASH *lh, LHASH_DOALL_ARG_FN_TYPE func, void *arg)
         {
         doall_util_fn(lh, 1, (LHASH_DOALL_FN_TYPE)0, func, arg);
         }
 
-static void expand(LHASH *lh)
+static void expand(_LHASH *lh)
         {
         LHASH_NODE **n,**n1,**n2,*np;
-        unsigned int p,i,j,pmax;
+        unsigned int p,i,j;
         unsigned long hash,nni;
 
-        p=(int)lh->p++;
-        nni=lh->num_alloc_nodes;
-        pmax=lh->pmax;
-
-        if ((lh->p) >= lh->pmax)
-                {
-                j=(int)lh->num_alloc_nodes*2;
-                n=(LHASH_NODE **)OPENSSL_realloc(lh->b,
-                        (int)sizeof(LHASH_NODE *)*j);
-                if (n == NULL)
-                        {
-/*                      fputs("realloc error in lhash",stderr); */
-                        lh->error++;
-                        lh->p=0;
-                        return;
-                        }
-                /* else */
-                for (i=(int)lh->num_alloc_nodes; i<j; i++)/* 26/02/92 eay */
-                        n[i]=NULL;                        /* 02/03/92 eay */
-                lh->pmax=lh->num_alloc_nodes;
-                lh->num_alloc_nodes=j;
-                lh->num_expand_reallocs++;
-                lh->p=0;
-                lh->b=n;
-                }
-
         lh->num_nodes++;
         lh->num_expands++;
+        p=(int)lh->p++;
         n1= &(lh->b[p]);
-        n2= &(lh->b[p+pmax]);
+        n2= &(lh->b[p+(int)lh->pmax]);
         *n2=NULL;        /* 27/07/92 - eay - undefined pointer bug */
+        nni=lh->num_alloc_nodes;
         
         for (np= *n1; np != NULL; )
                 {
 #ifndef OPENSSL_NO_HASH_COMP
                 hash=np->hash;
 #else
                 hash=lh->hash(np->data);
                 lh->num_hash_calls++;
 #endif
                 if ((hash%nni) != p)
                         { /* move it */
                         *n1= (*n1)->next;
                         np->next= *n2;
                         *n2=np;
                         }
                 else
                         n1= &((*n1)->next);
                 np= *n1;
                 }
 
+        if ((lh->p) >= lh->pmax)
+                {
+                j=(int)lh->num_alloc_nodes*2;
+                n=(LHASH_NODE **)OPENSSL_realloc(lh->b,
+                        (int)(sizeof(LHASH_NODE *)*j));
+                if (n == NULL)
+                        {
+/*                      fputs("realloc error in lhash",stderr); */
+                        lh->error++;
+                        lh->p=0;
+                        return;
+                        }
+                /* else */
+                for (i=(int)lh->num_alloc_nodes; i<j; i++)/* 26/02/92 eay */
+                        n[i]=NULL;                        /* 02/03/92 eay */
+                lh->pmax=lh->num_alloc_nodes;
+                lh->num_alloc_nodes=j;
+                lh->num_expand_reallocs++;
+                lh->p=0;
+                lh->b=n;
+                }
         }
 
-static void contract(LHASH *lh)
+static void contract(_LHASH *lh)
         {
         LHASH_NODE **n,*n1,*np;
-        int idx = lh->p+lh->pmax-1;
 
-        np=lh->b[idx];
+        np=lh->b[lh->p+lh->pmax-1];
+        lh->b[lh->p+lh->pmax-1]=NULL; /* 24/07-92 - eay - weird but :-( */
         if (lh->p == 0)
                 {
                 n=(LHASH_NODE **)OPENSSL_realloc(lh->b,
                         (unsigned int)(sizeof(LHASH_NODE *)*lh->pmax));
                 if (n == NULL)
                         {
 /*                      fputs("realloc error in lhash",stderr); */
                         lh->error++;
                         return;
                         }
                 lh->num_contract_reallocs++;
                 lh->num_alloc_nodes/=2;
                 lh->pmax/=2;
                 lh->p=lh->pmax-1;
                 lh->b=n;
                 }
         else
                 lh->p--;
 
-        lh->b[idx] = NULL;
         lh->num_nodes--;
         lh->num_contracts++;
 
         n1=lh->b[(int)lh->p];
         if (n1 == NULL)
                 lh->b[(int)lh->p]=np;
         else
                 {
                 while (n1->next != NULL)
                         n1=n1->next;
                 n1->next=np;
                 }
         }
 
-static LHASH_NODE **getrn(LHASH *lh, const void *data, unsigned long *rhash)
+static LHASH_NODE **getrn(_LHASH *lh, const void *data, unsigned long *rhash)
         {
         LHASH_NODE **ret,*n1;
         unsigned long hash,nn;
         LHASH_COMP_FN_TYPE cf;
 
         hash=(*(lh->hash))(data);
         lh->num_hash_calls++;
         *rhash=hash;
 
         nn=hash%lh->pmax;
@@ skipping 46 matching lines @@
                 n+=0x100;
                 r= (int)((v>>2)^v)&0x0f;
                 ret=(ret<<r)|(ret>>(32-r));
                 ret&=0xFFFFFFFFL;
                 ret^=v*v;
                 c++;
                 }
         return((ret>>16)^ret);
         }
 
-unsigned long lh_num_items(const LHASH *lh)
+unsigned long lh_num_items(const _LHASH *lh)
         {
         return lh ? lh->num_items : 0;
         }