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

openssl/crypto/store/str_mem.c

 /* crypto/store/str_mem.c -*- mode:C; c-file-style: "eay" -*- */
 /* Written by Richard Levitte (richard@levitte.org) for the OpenSSL
  * project 2003.
  */
 /* ====================================================================
  * Copyright (c) 2003 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 58 matching lines @@
    This is currently provided for by sorting the entries by numbers that
    are composed of bits set at the positions indicated by attribute type
    codes.  This provides for ranges determined by the highest attribute
    type code value.  A better idea might be to sort by values computed
    from the range of attributes associated with the object (basically,
    the difference between the highest and lowest attribute type code)
    and it's distance from a base (basically, the lowest associated
    attribute type code).
 */
 
-struct mem_object_data_st
+typedef struct mem_object_data_st
         {
         STORE_OBJECT *object;
         STORE_ATTR_INFO *attr_info;
         int references;
-        };
+        } MEM_OBJECT_DATA;
 
+DECLARE_STACK_OF(MEM_OBJECT_DATA)
 struct mem_data_st
         {
-        STACK *data;            /* A stack of mem_object_data_st,
-                                   sorted with STORE_ATTR_INFO_compare(). */
+        STACK_OF(MEM_OBJECT_DATA) *data; /* sorted with
+                                          * STORE_ATTR_INFO_compare(). */
         unsigned int compute_components : 1; /* Currently unused, but can
                                                 be used to add attributes
                                                 from parts of the data. */
         };
 
+DECLARE_STACK_OF(STORE_ATTR_INFO)
 struct mem_ctx_st
         {
         int type;               /* The type we're searching for */
-        STACK *search_attributes; /* Sets of attributes to search for.
-                                     Each element is a STORE_ATTR_INFO. */
-        int search_index;       /* which of the search attributes we found a match
-                                   for, -1 when we still haven't found any */
-        int index;              /* -1 as long as we're searching for the first */
+        STACK_OF(STORE_ATTR_INFO) *search_attributes; /* Sets of
+                                     attributes to search for.  Each
+                                     element is a STORE_ATTR_INFO. */
+        int search_index;       /* which of the search attributes we
+                                   found a match for, -1 when we still
+                                   haven't found any */
+        int index;              /* -1 as long as we're searching for
+                                    the first */
         };
 
 static int mem_init(STORE *s);
 static void mem_clean(STORE *s);
 static STORE_OBJECT *mem_generate(STORE *s, STORE_OBJECT_TYPES type,
         OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]);
 static STORE_OBJECT *mem_get(STORE *s, STORE_OBJECT_TYPES type,
         OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]);
 static int mem_store(STORE *s, STORE_OBJECT_TYPES type,
         STORE_OBJECT *data, OPENSSL_ITEM attributes[],
@@ skipping 120 matching lines @@
                 {
                 STOREerr(STORE_F_MEM_LIST_START, ERR_R_STORE_LIB);
                 goto err;
                 }
 
         while((attrs = STORE_parse_attrs_next(attribute_context)))
                 {
                 if (context->search_attributes == NULL)
                         {
                         context->search_attributes =
-                                sk_new((int (*)(const char * const *, const char * const *))STORE_ATTR_INFO_compare);
+                                sk_STORE_ATTR_INFO_new(STORE_ATTR_INFO_compare);
                         if (!context->search_attributes)
                                 {
                                 STOREerr(STORE_F_MEM_LIST_START,
                                         ERR_R_MALLOC_FAILURE);
                                 goto err;
                                 }
                         }
-                sk_push(context->search_attributes,(char *)attrs);
+                sk_STORE_ATTR_INFO_push(context->search_attributes,attrs);
                 }
         if (!STORE_parse_attrs_endp(attribute_context))
                 goto err;
         STORE_parse_attrs_end(attribute_context);
         context->search_index = -1;
         context->index = -1;
         return context;
  err:
         if (attribute_context) STORE_parse_attrs_end(attribute_context);
         mem_list_end(s, context);
@@ skipping 15 matching lines @@
                 return NULL;
                 }
         if (!store)
                 {
                 STOREerr(STORE_F_MEM_LIST_NEXT, STORE_R_NO_STORE);
                 return NULL;
                 }
 
         if (context->search_index == -1)
                 {
-                for (i = 0; i < sk_num(context->search_attributes); i++)
+                for (i = 0;
+                     i < sk_STORE_ATTR_INFO_num(context->search_attributes);
+                     i++)
                         {
-                        key.attr_info =
-                                (STORE_ATTR_INFO *)sk_value(context->search_attributes, i);
-                        srch = sk_find_ex(store->data, (char *)&key);
+                        key.attr_info
+                          = sk_STORE_ATTR_INFO_value(context->search_attributes,
+                                                     i);
+                        srch = sk_MEM_OBJECT_DATA_find_ex(store->data, &key);
 
                         if (srch >= 0)
                                 {
                                 context->search_index = srch;
                                 break;
                                 }
                         }
                 }
         if (context->search_index < 0)
                 return NULL;
         
         key.attr_info =
-                (STORE_ATTR_INFO *)sk_value(context->search_attributes,
-                        context->search_index);
+                sk_STORE_ATTR_INFO_value(context->search_attributes,
+                                         context->search_index);
         for(srch = context->search_index;
-            srch < sk_num(store->data)
+            srch < sk_MEM_OBJECT_DATA_num(store->data)
                     && STORE_ATTR_INFO_in_range(key.attr_info,
-                            (STORE_ATTR_INFO *)sk_value(store->data, srch))
+                            sk_MEM_OBJECT_DATA_value(store->data, srch)->attr_info)
                     && !(cres = STORE_ATTR_INFO_in_ex(key.attr_info,
-                                 (STORE_ATTR_INFO *)sk_value(store->data, srch)));
+                                 sk_MEM_OBJECT_DATA_value(store->data, srch)->attr_info));
             srch++)
                 ;
 
         context->search_index = srch;
         if (cres)
-                return ((struct mem_object_data_st *)sk_value(store->data,
-                                srch))->object;
+                return (sk_MEM_OBJECT_DATA_value(store->data, srch))->object;
         return NULL;
         }
 static int mem_list_end(STORE *s, void *handle)
         {
         struct mem_ctx_st *context = (struct mem_ctx_st *)handle;
 
         if (!context)
                 {
                 STOREerr(STORE_F_MEM_LIST_END, ERR_R_PASSED_NULL_PARAMETER);
                 return 0;
                 }
         if (context && context->search_attributes)
-                sk_free(context->search_attributes);
+                sk_STORE_ATTR_INFO_free(context->search_attributes);
         if (context) OPENSSL_free(context);
         return 1;
         }
 static int mem_list_endp(STORE *s, void *handle)
         {
         struct mem_ctx_st *context = (struct mem_ctx_st *)handle;
 
         if (!context
-                || context->search_index == sk_num(context->search_attributes))
+            || context->search_index
+               == sk_STORE_ATTR_INFO_num(context->search_attributes))
                 return 1;
         return 0;
         }
 static int mem_lock(STORE *s, OPENSSL_ITEM attributes[],
         OPENSSL_ITEM parameters[])
         {
         return 1;
         }
 static int mem_unlock(STORE *s, OPENSSL_ITEM attributes[],
         OPENSSL_ITEM parameters[])
         {
         return 1;
         }
 static int mem_ctrl(STORE *s, int cmd, long l, void *p, void (*f)(void))
         {
         return 1;
         }