Update openssl to 1.0.2d

Also update Cryptlib to edk2 r17731

Signed-off-by: Gary Ching-Pang Lin <glin@suse.com>

1 files changed, 65 insertions, 70 deletions

diff --git a/Cryptlib/OpenSSL/crypto/conf/conf_api.c b/Cryptlib/OpenSSL/crypto/conf/conf_api.c
index d994ef8f..4cf75533 100644
--- a/Cryptlib/OpenSSL/crypto/conf/conf_api.c
+++ b/Cryptlib/OpenSSL/crypto/conf/conf_api.c
@@ -70,18 +70,12 @@
 #include <openssl/conf_api.h>
 #include "e_os.h"
 
-static void value_free_hash(CONF_VALUE *a, LHASH *conf);
-static void value_free_stack(CONF_VALUE *a, LHASH *conf);
-static IMPLEMENT_LHASH_DOALL_ARG_FN(value_free_hash, CONF_VALUE *, LHASH *)
-static IMPLEMENT_LHASH_DOALL_ARG_FN(value_free_stack, CONF_VALUE *, LHASH *)
-/*
- * We don't use function pointer casting or wrapper functions - but cast each
- * callback parameter inside the callback functions.
- */
-/* static unsigned long hash(CONF_VALUE *v); */
-static unsigned long hash(const void *v_void);
-/* static int cmp_conf(CONF_VALUE *a,CONF_VALUE *b); */
-static int cmp_conf(const void *a_void, const void *b_void);
+static void value_free_hash_doall_arg(CONF_VALUE *a,
+                                      LHASH_OF(CONF_VALUE) *conf);
+static void value_free_stack_doall(CONF_VALUE *a);
+static IMPLEMENT_LHASH_DOALL_ARG_FN(value_free_hash, CONF_VALUE,
+                                    LHASH_OF(CONF_VALUE))
+static IMPLEMENT_LHASH_DOALL_FN(value_free_stack, CONF_VALUE)
 
 /* Up until OpenSSL 0.9.5a, this was get_section */
 CONF_VALUE *_CONF_get_section(const CONF *conf, const char *section)
@@ -92,7 +86,7 @@ CONF_VALUE *_CONF_get_section(const CONF *conf, const char *section)
         return (NULL);
     vv.name = NULL;
     vv.section = (char *)section;
-    v = (CONF_VALUE *)lh_retrieve(conf->data, &vv);
+    v = lh_CONF_VALUE_retrieve(conf->data, &vv);
     return (v);
 }
 
@@ -121,7 +115,7 @@ int _CONF_add_string(CONF *conf, CONF_VALUE *section, CONF_VALUE *value)
         return 0;
     }
 
-    v = (CONF_VALUE *)lh_insert(conf->data, value);
+    v = lh_CONF_VALUE_insert(conf->data, value);
     if (v != NULL) {
         (void)sk_CONF_VALUE_delete_ptr(ts, v);
         OPENSSL_free(v->name);
@@ -143,24 +137,24 @@ char *_CONF_get_string(const CONF *conf, const char *section,
         if (section != NULL) {
             vv.name = (char *)name;
             vv.section = (char *)section;
-            v = (CONF_VALUE *)lh_retrieve(conf->data, &vv);
+            v = lh_CONF_VALUE_retrieve(conf->data, &vv);
             if (v != NULL)
                 return (v->value);
             if (strcmp(section, "ENV") == 0) {
-                p = Getenv(name);
+                p = getenv(name);
                 if (p != NULL)
                     return (p);
             }
         }
         vv.section = "default";
         vv.name = (char *)name;
-        v = (CONF_VALUE *)lh_retrieve(conf->data, &vv);
+        v = lh_CONF_VALUE_retrieve(conf->data, &vv);
         if (v != NULL)
             return (v->value);
         else
             return (NULL);
     } else
-        return (Getenv(name));
+        return (getenv(name));
 }
 
 #if 0                           /* There's no way to provide error checking
@@ -185,13 +179,41 @@ long _CONF_get_number(CONF *conf, char *section, char *name)
 }
 #endif
 
+static unsigned long conf_value_hash(const CONF_VALUE *v)
+{
+    return (lh_strhash(v->section) << 2) ^ lh_strhash(v->name);
+}
+
+static IMPLEMENT_LHASH_HASH_FN(conf_value, CONF_VALUE)
+
+static int conf_value_cmp(const CONF_VALUE *a, const CONF_VALUE *b)
+{
+    int i;
+
+    if (a->section != b->section) {
+        i = strcmp(a->section, b->section);
+        if (i)
+            return (i);
+    }
+
+    if ((a->name != NULL) && (b->name != NULL)) {
+        i = strcmp(a->name, b->name);
+        return (i);
+    } else if (a->name == b->name)
+        return (0);
+    else
+        return ((a->name == NULL) ? -1 : 1);
+}
+
+static IMPLEMENT_LHASH_COMP_FN(conf_value, CONF_VALUE)
+
 int _CONF_new_data(CONF *conf)
 {
     if (conf == NULL) {
         return 0;
     }
     if (conf->data == NULL)
-        if ((conf->data = lh_new(hash, cmp_conf)) == NULL) {
+        if ((conf->data = lh_CONF_VALUE_new()) == NULL) {
             return 0;
         }
     return 1;
@@ -202,104 +224,77 @@ void _CONF_free_data(CONF *conf)
     if (conf == NULL || conf->data == NULL)
         return;
 
-    conf->data->down_load = 0;  /* evil thing to make sure the
-                                 * 'OPENSSL_free()' works as expected */
-    lh_doall_arg(conf->data, LHASH_DOALL_ARG_FN(value_free_hash), conf->data);
+    lh_CONF_VALUE_down_load(conf->data) = 0; /* evil thing to make * sure the
+                                              * 'OPENSSL_free()' works as *
+                                              * expected */
+    lh_CONF_VALUE_doall_arg(conf->data,
+                            LHASH_DOALL_ARG_FN(value_free_hash),
+                            LHASH_OF(CONF_VALUE), conf->data);
 
     /*
      * We now have only 'section' entries in the hash table. Due to problems
      * with
      */
 
-    lh_doall_arg(conf->data, LHASH_DOALL_ARG_FN(value_free_stack),
-                 conf->data);
-    lh_free(conf->data);
+    lh_CONF_VALUE_doall(conf->data, LHASH_DOALL_FN(value_free_stack));
+    lh_CONF_VALUE_free(conf->data);
 }
 
-static void value_free_hash(CONF_VALUE *a, LHASH *conf)
+static void value_free_hash_doall_arg(CONF_VALUE *a,
+                                      LHASH_OF(CONF_VALUE) *conf)
 {
-    if (a->name != NULL) {
-        a = (CONF_VALUE *)lh_delete(conf, a);
-    }
+    if (a->name != NULL)
+        (void)lh_CONF_VALUE_delete(conf, a);
 }
 
-static void value_free_stack(CONF_VALUE *a, LHASH *conf)
+static void value_free_stack_doall(CONF_VALUE *a)
 {
     CONF_VALUE *vv;
-    STACK *sk;
+    STACK_OF(CONF_VALUE) *sk;
     int i;
 
     if (a->name != NULL)
         return;
 
-    sk = (STACK *) a->value;
-    for (i = sk_num(sk) - 1; i >= 0; i--) {
-        vv = (CONF_VALUE *)sk_value(sk, i);
+    sk = (STACK_OF(CONF_VALUE) *)a->value;
+    for (i = sk_CONF_VALUE_num(sk) - 1; i >= 0; i--) {
+        vv = sk_CONF_VALUE_value(sk, i);
         OPENSSL_free(vv->value);
         OPENSSL_free(vv->name);
         OPENSSL_free(vv);
     }
     if (sk != NULL)
-        sk_free(sk);
+        sk_CONF_VALUE_free(sk);
     OPENSSL_free(a->section);
     OPENSSL_free(a);
 }
 
-/* static unsigned long hash(CONF_VALUE *v) */
-static unsigned long hash(const void *v_void)
-{
-    CONF_VALUE *v = (CONF_VALUE *)v_void;
-    return ((lh_strhash(v->section) << 2) ^ lh_strhash(v->name));
-}
-
-/* static int cmp_conf(CONF_VALUE *a, CONF_VALUE *b) */
-static int cmp_conf(const void *a_void, const void *b_void)
-{
-    int i;
-    CONF_VALUE *a = (CONF_VALUE *)a_void;
-    CONF_VALUE *b = (CONF_VALUE *)b_void;
-
-    if (a->section != b->section) {
-        i = strcmp(a->section, b->section);
-        if (i)
-            return (i);
-    }
-
-    if ((a->name != NULL) && (b->name != NULL)) {
-        i = strcmp(a->name, b->name);
-        return (i);
-    } else if (a->name == b->name)
-        return (0);
-    else
-        return ((a->name == NULL) ? -1 : 1);
-}
-
 /* Up until OpenSSL 0.9.5a, this was new_section */
 CONF_VALUE *_CONF_new_section(CONF *conf, const char *section)
 {
-    STACK *sk = NULL;
+    STACK_OF(CONF_VALUE) *sk = NULL;
     int ok = 0, i;
     CONF_VALUE *v = NULL, *vv;
 
-    if ((sk = sk_new_null()) == NULL)
+    if ((sk = sk_CONF_VALUE_new_null()) == NULL)
         goto err;
-    if ((v = (CONF_VALUE *)OPENSSL_malloc(sizeof(CONF_VALUE))) == NULL)
+    if ((v = OPENSSL_malloc(sizeof(CONF_VALUE))) == NULL)
         goto err;
     i = strlen(section) + 1;
-    if ((v->section = (char *)OPENSSL_malloc(i)) == NULL)
+    if ((v->section = OPENSSL_malloc(i)) == NULL)
         goto err;
 
     memcpy(v->section, section, i);
     v->name = NULL;
     v->value = (char *)sk;
 
-    vv = (CONF_VALUE *)lh_insert(conf->data, v);
+    vv = lh_CONF_VALUE_insert(conf->data, v);
     OPENSSL_assert(vv == NULL);
     ok = 1;
  err:
     if (!ok) {
         if (sk != NULL)
-            sk_free(sk);
+            sk_CONF_VALUE_free(sk);
         if (v != NULL)
             OPENSSL_free(v);
         v = NULL;