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

openssl/crypto/conf/conf_def.c

 /* crypto/conf/conf.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 111 matching lines @@
         }
 CONF_METHOD *NCONF_WIN32()
         {
         return &WIN32_method;
         }
 
 static CONF *def_create(CONF_METHOD *meth)
         {
         CONF *ret;
 
-        ret = (CONF *)OPENSSL_malloc(sizeof(CONF) + sizeof(unsigned short *));
+        ret = OPENSSL_malloc(sizeof(CONF) + sizeof(unsigned short *));
         if (ret)
                 if (meth->init(ret) == 0)
                         {
                         OPENSSL_free(ret);
                         ret = NULL;
                         }
         return ret;
         }
         
 static int def_init_default(CONF *conf)
         {
         if (conf == NULL)
                 return 0;
 
         conf->meth = &default_method;
-        conf->meth_data = (void *)CONF_type_default;
+        conf->meth_data = CONF_type_default;
         conf->data = NULL;
 
         return 1;
         }
 
 static int def_init_WIN32(CONF *conf)
         {
         if (conf == NULL)
                 return 0;
 
@@ skipping 47 matching lines @@
         return ret;
         }
 
 static int def_load_bio(CONF *conf, BIO *in, long *line)
         {
 /* The macro BUFSIZE conflicts with a system macro in VxWorks */
 #define CONFBUFSIZE     512
         int bufnum=0,i,ii;
         BUF_MEM *buff=NULL;
         char *s,*p,*end;
-        int again,n;
+        int again;
         long eline=0;
         char btmp[DECIMAL_SIZE(eline)+1];
         CONF_VALUE *v=NULL,*tv;
         CONF_VALUE *sv=NULL;
         char *section=NULL,*buf;
-        STACK_OF(CONF_VALUE) *section_sk=NULL,*ts;
         char *start,*psection,*pname;
         void *h = (void *)(conf->data);
 
         if ((buff=BUF_MEM_new()) == NULL)
                 {
                 CONFerr(CONF_F_DEF_LOAD_BIO,ERR_R_BUF_LIB);
                 goto err;
                 }
 
         section=(char *)OPENSSL_malloc(10);
@@ skipping 10 matching lines @@
                 goto err;
                 }
 
         sv=_CONF_new_section(conf,section);
         if (sv == NULL)
                 {
                 CONFerr(CONF_F_DEF_LOAD_BIO,
                                         CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
                 goto err;
                 }
-        section_sk=(STACK_OF(CONF_VALUE) *)sv->value;
 
         bufnum=0;
         again=0;
         for (;;)
                 {
                 if (!BUF_MEM_grow(buff,bufnum+CONFBUFSIZE))
                         {
                         CONFerr(CONF_F_DEF_LOAD_BIO,ERR_R_BUF_LIB);
                         goto err;
                         }
@@ skipping 38 matching lines @@
                                 {
                                 bufnum--;
                                 again=1;
                                 }
                         }
                 if (again) continue;
                 bufnum=0;
                 buf=buff->data;
 
                 clear_comments(conf, buf);
-                n=strlen(buf);
                 s=eat_ws(conf, buf);
                 if (IS_EOF(conf,*s)) continue; /* blank line */
                 if (*s == '[')
                         {
                         char *ss;
 
                         s++;
                         start=eat_ws(conf, s);
                         ss=start;
 again:
@@ skipping 13 matching lines @@
                         *end='\0';
                         if (!str_copy(conf,NULL,&section,start)) goto err;
                         if ((sv=_CONF_get_section(conf,section)) == NULL)
                                 sv=_CONF_new_section(conf,section);
                         if (sv == NULL)
                                 {
                                 CONFerr(CONF_F_DEF_LOAD_BIO,
                                         CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
                                 goto err;
                                 }
-                        section_sk=(STACK_OF(CONF_VALUE) *)sv->value;
                         continue;
                         }
                 else
                         {
                         pname=s;
                         psection=NULL;
                         end=eat_alpha_numeric(conf, s);
                         if ((end[0] == ':') && (end[1] == ':'))
                                 {
                                 *end='\0';
@@ skipping 42 matching lines @@
                                 {
                                 if ((tv=_CONF_get_section(conf,psection))
                                         == NULL)
                                         tv=_CONF_new_section(conf,psection);
                                 if (tv == NULL)
                                         {
                                         CONFerr(CONF_F_DEF_LOAD_BIO,
                                            CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
                                         goto err;
                                         }
-                                ts=(STACK_OF(CONF_VALUE) *)tv->value;
                                 }
                         else
-                                {
                                 tv=sv;
-                                ts=section_sk;
-                                }
 #if 1
                         if (_CONF_add_string(conf, tv, v) == 0)
                                 {
                                 CONFerr(CONF_F_DEF_LOAD_BIO,
                                                         ERR_R_MALLOC_FAILURE);
                                 goto err;
                                 }
 #else
                         v->section=tv->section; 
                         if (!sk_CONF_VALUE_push(ts,v))
@@ skipping 32 matching lines @@
                 {
                 if (v->name != NULL) OPENSSL_free(v->name);
                 if (v->value != NULL) OPENSSL_free(v->value);
                 if (v != NULL) OPENSSL_free(v);
                 }
         return(0);
         }
 
 static void clear_comments(CONF *conf, char *p)
         {
-        char *to;
-
-        to=p;
         for (;;)
                 {
                 if (IS_FCOMMENT(conf,*p))
                         {
                         *p='\0';
                         return;
                         }
                 if (!IS_WS(conf,*p))
                         {
                         break;
@@ skipping 234 matching lines @@
                                 {
                                 break;
                                 }
                         }
                 p++;
                 }
         if (*p == q) p++;
         return(p);
         }
 
-static void dump_value(CONF_VALUE *a, BIO *out)
+static void dump_value_doall_arg(CONF_VALUE *a, BIO *out)
         {
         if (a->name)
                 BIO_printf(out, "[%s] %s=%s\n", a->section, a->name, a->value);
         else
                 BIO_printf(out, "[[%s]]\n", a->section);
         }
 
-static IMPLEMENT_LHASH_DOALL_ARG_FN(dump_value, CONF_VALUE *, BIO *)
+static IMPLEMENT_LHASH_DOALL_ARG_FN(dump_value, CONF_VALUE, BIO)
 
 static int def_dump(const CONF *conf, BIO *out)
         {
-        lh_doall_arg(conf->data, LHASH_DOALL_ARG_FN(dump_value), out);
+        lh_CONF_VALUE_doall_arg(conf->data, LHASH_DOALL_ARG_FN(dump_value),
+                                BIO, out);
         return 1;
         }
 
 static int def_is_number(const CONF *conf, char c)
         {
         return IS_NUMBER(conf,c);
         }
 
 static int def_to_int(const CONF *conf, char c)
         {
         return c - '0';
         }