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

openssl/crypto/engine/eng_dyn.c

 /* crypto/engine/eng_dyn.c */
 /* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL
  * project 2001.
  */
 /* ====================================================================
  * Copyright (c) 1999-2001 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ skipping 128 matching lines @@
          * ENGINE list. If 2, the add must succeed or the entire load should fail. */
         int list_add_value;
         /* The symbol name for the version checking function */
         const char *DYNAMIC_F1;
         /* The symbol name for the "initialise ENGINE structure" function */
         const char *DYNAMIC_F2;
         /* Whether to never use 'dirs', use 'dirs' as a fallback, or only use
          * 'dirs' for loading. Default is to use 'dirs' as a fallback. */
         int dir_load;
         /* A stack of directories from which ENGINEs could be loaded */
-        STACK *dirs;
+        STACK_OF(OPENSSL_STRING) *dirs;
         };
 
 /* This is the "ex_data" index we obtain and reserve for use with our context
  * structure. */
 static int dynamic_ex_data_idx = -1;
 
-static void int_free_str(void *s) { OPENSSL_free(s); }
+static void int_free_str(char *s) { OPENSSL_free(s); }
 /* Because our ex_data element may or may not get allocated depending on whether
  * a "first-use" occurs before the ENGINE is freed, we have a memory leak
  * problem to solve. We can't declare a "new" handler for the ex_data as we
  * don't want a dynamic_data_ctx in *all* ENGINE structures of all types (this
  * is a bug in the design of CRYPTO_EX_DATA). As such, we just declare a "free"
  * handler and that will get called if an ENGINE is being destroyed and there
  * was an ex_data element corresponding to our context type. */
 static void dynamic_data_ctx_free_func(void *parent, void *ptr,
                         CRYPTO_EX_DATA *ad, int idx, long argl, void *argp)
         {
         if(ptr)
                 {
                 dynamic_data_ctx *ctx = (dynamic_data_ctx *)ptr;
                 if(ctx->dynamic_dso)
                         DSO_free(ctx->dynamic_dso);
                 if(ctx->DYNAMIC_LIBNAME)
                         OPENSSL_free((void*)ctx->DYNAMIC_LIBNAME);
                 if(ctx->engine_id)
                         OPENSSL_free((void*)ctx->engine_id);
                 if(ctx->dirs)
-                        sk_pop_free(ctx->dirs, int_free_str);
+                        sk_OPENSSL_STRING_pop_free(ctx->dirs, int_free_str);
                 OPENSSL_free(ctx);
                 }
         }
 
 /* Construct the per-ENGINE context. We create it blindly and then use a lock to
  * check for a race - if so, all but one of the threads "racing" will have
  * wasted their time. The alternative involves creating everything inside the
  * lock which is far worse. */
 static int dynamic_set_data_ctx(ENGINE *e, dynamic_data_ctx **ctx)
         {
         dynamic_data_ctx *c;
         c = OPENSSL_malloc(sizeof(dynamic_data_ctx));
         if(!c)
                 {
                 ENGINEerr(ENGINE_F_DYNAMIC_SET_DATA_CTX,ERR_R_MALLOC_FAILURE);
                 return 0;
                 }
         memset(c, 0, sizeof(dynamic_data_ctx));
         c->dynamic_dso = NULL;
         c->v_check = NULL;
         c->bind_engine = NULL;
         c->DYNAMIC_LIBNAME = NULL;
         c->no_vcheck = 0;
         c->engine_id = NULL;
         c->list_add_value = 0;
         c->DYNAMIC_F1 = "v_check";
         c->DYNAMIC_F2 = "bind_engine";
         c->dir_load = 1;
-        c->dirs = sk_new_null();
+        c->dirs = sk_OPENSSL_STRING_new_null();
         if(!c->dirs)
                 {
                 ENGINEerr(ENGINE_F_DYNAMIC_SET_DATA_CTX,ERR_R_MALLOC_FAILURE);
                 OPENSSL_free(c);
                 return 0;
                 }
         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
         if((*ctx = (dynamic_data_ctx *)ENGINE_get_ex_data(e,
                                 dynamic_ex_data_idx)) == NULL)
                 {
@@ skipping 169 matching lines @@
                         return 0;
                         }
                 {
                 char *tmp_str = BUF_strdup(p);
                 if(!tmp_str)
                         {
                         ENGINEerr(ENGINE_F_DYNAMIC_CTRL,
                                 ERR_R_MALLOC_FAILURE);
                         return 0;
                         }
-                sk_insert(ctx->dirs, tmp_str, -1);
+                sk_OPENSSL_STRING_insert(ctx->dirs, tmp_str, -1);
                 }
                 return 1;
         default:
                 break;
                 }
         ENGINEerr(ENGINE_F_DYNAMIC_CTRL,ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED);
         return 0;
         }
 
 static int int_load(dynamic_data_ctx *ctx)
         {
         int num, loop;
         /* Unless told not to, try a direct load */
         if((ctx->dir_load != 2) && (DSO_load(ctx->dynamic_dso,
                                 ctx->DYNAMIC_LIBNAME, NULL, 0)) != NULL)
                 return 1;
         /* If we're not allowed to use 'dirs' or we have none, fail */
-        if(!ctx->dir_load || ((num = sk_num(ctx->dirs)) < 1))
+        if(!ctx->dir_load || (num = sk_OPENSSL_STRING_num(ctx->dirs)) < 1)
                 return 0;
         for(loop = 0; loop < num; loop++)
                 {
-                const char *s = sk_value(ctx->dirs, loop);
+                const char *s = sk_OPENSSL_STRING_value(ctx->dirs, loop);
                 char *merge = DSO_merge(ctx->dynamic_dso, ctx->DYNAMIC_LIBNAME, s);
                 if(!merge)
                         return 0;
                 if(DSO_load(ctx->dynamic_dso, merge, NULL, 0))
                         {
                         /* Found what we're looking for */
                         OPENSSL_free(merge);
                         return 1;
                         }
                 OPENSSL_free(merge);
@@ skipping 110 matching lines @@
                                 ENGINEerr(ENGINE_F_DYNAMIC_LOAD,
                                         ENGINE_R_CONFLICTING_ENGINE_ID);
                                 return 0;
                                 }
                         /* Tolerate */
                         ERR_clear_error();
                         }
                 }
         return 1;
         }