Rename lh_xxx,sk_xxx tp OPENSSL_{LH,SK}_xxx
authorRich Salz <rsalz@openssl.org>
Fri, 20 May 2016 14:46:29 +0000 (10:46 -0400)
committerRich Salz <rsalz@openssl.org>
Fri, 20 May 2016 14:48:29 +0000 (10:48 -0400)
Rename sk_xxx to OPENSSL_sk_xxx and _STACK to OPENSSL_STACK
Rename lh_xxx API to OPENSSL_LH_xxx and LHASH_NODE to OPENSSL_LH_NODE
Make lhash stuff opaque.
Use typedefs for function pointers; makes the code simpler.
Remove CHECKED_xxx macros.
Add documentation; remove old X509-oriented doc.
Add API-compat names for entire old API

Reviewed-by: Dr. Stephen Henson <steve@openssl.org>
22 files changed:
CHANGES
apps/apps.c
apps/openssl.c
crypto/asn1/tasn_dec.c
crypto/conf/conf_api.c
crypto/lhash/lh_stats.c
crypto/lhash/lhash.c
crypto/lhash/lhash_lcl.h [new file with mode: 0644]
crypto/objects/o_names.c
crypto/objects/obj_dat.c
crypto/stack/stack.c
crypto/txt_db/txt_db.c
doc/crypto/lh_stats.pod
doc/crypto/lhash.pod
doc/crypto/sk_X509_num.pod [deleted file]
doc/crypto/stack.pod [new file with mode: 0644]
include/openssl/lhash.h
include/openssl/safestack.h
include/openssl/stack.h
include/openssl/txt_db.h
ssl/ssl_sess.c
util/libcrypto.num

diff --git a/CHANGES b/CHANGES
index 10ec93f..541efc3 100644 (file)
--- a/CHANGES
+++ b/CHANGES
@@ -4,6 +4,11 @@
 
  Changes between 1.0.2h and 1.1.0  [xx XXX 2016]
 
+  *) The stack and lhash API's were renamed to start with OPENSSL_SK_
+     and OPENSSL_LH_, respectively.  The old names are available
+     with API compatibility.  They new names are now completely documented.
+     [Rich Salz]
+
   *) Unify TYPE_up_ref(obj) methods signature.
      SSL_CTX_up_ref(), SSL_up_ref(), X509_up_ref(), EVP_PKEY_up_ref(),
      X509_CRL_up_ref(), X509_OBJECT_up_ref_count() methods are now returning an
index 37f423b..5db4b22 100644 (file)
@@ -1283,7 +1283,7 @@ static unsigned long index_serial_hash(const OPENSSL_CSTRING *a)
     n = a[DB_serial];
     while (*n == '0')
         n++;
-    return (lh_strhash(n));
+    return OPENSSL_LH_strhash(n);
 }
 
 static int index_serial_cmp(const OPENSSL_CSTRING *a,
@@ -1303,7 +1303,7 @@ static int index_name_qual(char **a)
 
 static unsigned long index_name_hash(const OPENSSL_CSTRING *a)
 {
-    return (lh_strhash(a[DB_name]));
+    return OPENSSL_LH_strhash(a[DB_name]);
 }
 
 int index_name_cmp(const OPENSSL_CSTRING *a, const OPENSSL_CSTRING *b)
index e554010..f069277 100644 (file)
@@ -525,7 +525,7 @@ static int function_cmp(const FUNCTION * a, const FUNCTION * b)
 
 static unsigned long function_hash(const FUNCTION * a)
 {
-    return lh_strhash(a->name);
+    return OPENSSL_LH_strhash(a->name);
 }
 
 static int SortFnByName(const void *_f1, const void *_f2)
index cc49197..64bbe40 100644 (file)
@@ -535,7 +535,7 @@ static int asn1_template_noexp_d2i(ASN1_VALUE **val,
         } else if (ret == -1)
             return -1;
         if (!*val)
-            *val = (ASN1_VALUE *)sk_new_null();
+            *val = (ASN1_VALUE *)OPENSSL_sk_new_null();
         else {
             /*
              * We've got a valid STACK: free up any items present
index 0d4b23f..5535416 100644 (file)
@@ -100,7 +100,7 @@ char *_CONF_get_string(const CONF *conf, const char *section,
 
 static unsigned long conf_value_hash(const CONF_VALUE *v)
 {
-    return (lh_strhash(v->section) << 2) ^ lh_strhash(v->name);
+    return (OPENSSL_LH_strhash(v->section) << 2) ^ OPENSSL_LH_strhash(v->name);
 }
 
 static int conf_value_cmp(const CONF_VALUE *a, const CONF_VALUE *b)
index 0644c75..7337832 100644 (file)
 
 #include <openssl/bio.h>
 #include <openssl/lhash.h>
+#include "lhash_lcl.h"
 
 # ifndef OPENSSL_NO_STDIO
-void lh_stats(const _LHASH *lh, FILE *fp)
+void OPENSSL_LH_stats(const OPENSSL_LHASH *lh, FILE *fp)
 {
     BIO *bp;
 
     bp = BIO_new(BIO_s_file());
     if (bp == NULL)
-        goto end;
+        return;
     BIO_set_fp(bp, fp, BIO_NOCLOSE);
-    lh_stats_bio(lh, bp);
+    OPENSSL_LH_stats_bio(lh, bp);
     BIO_free(bp);
- end:;
 }
 
-void lh_node_stats(const _LHASH *lh, FILE *fp)
+void OPENSSL_LH_node_stats(const OPENSSL_LHASH *lh, FILE *fp)
 {
     BIO *bp;
 
     bp = BIO_new(BIO_s_file());
     if (bp == NULL)
-        goto end;
+        return;
     BIO_set_fp(bp, fp, BIO_NOCLOSE);
-    lh_node_stats_bio(lh, bp);
+    OPENSSL_LH_node_stats_bio(lh, bp);
     BIO_free(bp);
- end:;
 }
 
-void lh_node_usage_stats(const _LHASH *lh, FILE *fp)
+void OPENSSL_LH_node_usage_stats(const OPENSSL_LHASH *lh, FILE *fp)
 {
     BIO *bp;
 
     bp = BIO_new(BIO_s_file());
     if (bp == NULL)
-        goto end;
+        return;
     BIO_set_fp(bp, fp, BIO_NOCLOSE);
-    lh_node_usage_stats_bio(lh, bp);
+    OPENSSL_LH_node_usage_stats_bio(lh, bp);
     BIO_free(bp);
- end:;
 }
 
 # endif
 
-void lh_stats_bio(const _LHASH *lh, BIO *out)
+void OPENSSL_LH_stats_bio(const OPENSSL_LHASH *lh, BIO *out)
 {
     BIO_printf(out, "num_items             = %lu\n", lh->num_items);
     BIO_printf(out, "num_nodes             = %u\n", lh->num_nodes);
@@ -82,9 +80,9 @@ void lh_stats_bio(const _LHASH *lh, BIO *out)
     BIO_printf(out, "num_hash_comps        = %lu\n", lh->num_hash_comps);
 }
 
-void lh_node_stats_bio(const _LHASH *lh, BIO *out)
+void OPENSSL_LH_node_stats_bio(const OPENSSL_LHASH *lh, BIO *out)
 {
-    LHASH_NODE *n;
+    OPENSSL_LH_NODE *n;
     unsigned int i, num;
 
     for (i = 0; i < lh->num_nodes; i++) {
@@ -94,9 +92,9 @@ void lh_node_stats_bio(const _LHASH *lh, BIO *out)
     }
 }
 
-void lh_node_usage_stats_bio(const _LHASH *lh, BIO *out)
+void OPENSSL_LH_node_usage_stats_bio(const OPENSSL_LHASH *lh, BIO *out)
 {
-    LHASH_NODE *n;
+    OPENSSL_LH_NODE *n;
     unsigned long num;
     unsigned int i;
     unsigned long total = 0, n_used = 0;
index 9fa46b0..3e58eea 100644 (file)
@@ -7,70 +7,33 @@
  * https://www.openssl.org/source/license.html
  */
 
-/*-
- * Code for dynamic hash table routines
- * Author - Eric Young v 2.0
- *
- * 2.2 eay - added #include "crypto.h" so the memory leak checking code is
- *           present. eay 18-Jun-98
- *
- * 2.1 eay - Added an 'error in last operation' flag. eay 6-May-98
- *
- * 2.0 eay - Fixed a bug that occurred when using lh_delete
- *           from inside lh_doall().  As entries were deleted,
- *           the 'table' was 'contract()ed', making some entries
- *           jump from the end of the table to the start, there by
- *           skipping the lh_doall() processing. eay - 4/12/95
- *
- * 1.9 eay - Fixed a memory leak in lh_free, the LHASH_NODEs
- *           were not being free()ed. 21/11/95
- *
- * 1.8 eay - Put the stats routines into a separate file, lh_stats.c
- *           19/09/95
- *
- * 1.7 eay - Removed the fputs() for realloc failures - the code
- *           should silently tolerate them.  I have also fixed things
- *           lint complained about 04/05/95
- *
- * 1.6 eay - Fixed an invalid pointers in contract/expand 27/07/92
- *
- * 1.5 eay - Fixed a misuse of realloc in expand 02/03/1992
- *
- * 1.4 eay - Fixed lh_doall so the function can call lh_delete 28/05/91
- *
- * 1.3 eay - Fixed a few lint problems 19/3/1991
- *
- * 1.2 eay - Fixed lh_doall problem 13/3/1991
- *
- * 1.1 eay - Added lh_doall
- *
- * 1.0 eay - First version
- */
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <openssl/crypto.h>
 #include <openssl/lhash.h>
+#include "lhash_lcl.h"
+
 
 #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(OPENSSL_LHASH *lh);
+static void contract(OPENSSL_LHASH *lh);
+static OPENSSL_LH_NODE **getrn(OPENSSL_LHASH *lh, const void *data, unsigned long *rhash);
 
-_LHASH *lh_new(LHASH_HASH_FN_TYPE h, LHASH_COMP_FN_TYPE c)
+OPENSSL_LHASH *OPENSSL_LH_new(OPENSSL_LH_HASHFUNC h, OPENSSL_LH_COMPFUNC c)
 {
-    _LHASH *ret;
+    OPENSSL_LHASH *ret;
 
     if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
         goto err0;
     if ((ret->b = OPENSSL_zalloc(sizeof(*ret->b) * MIN_NODES)) == NULL)
         goto err1;
-    ret->comp = ((c == NULL) ? (LHASH_COMP_FN_TYPE)strcmp : c);
-    ret->hash = ((h == NULL) ? (LHASH_HASH_FN_TYPE)lh_strhash : h);
+    ret->comp = ((c == NULL) ? (OPENSSL_LH_COMPFUNC)strcmp : c);
+    ret->hash = ((h == NULL) ? (OPENSSL_LH_HASHFUNC)OPENSSL_LH_strhash : h);
     ret->num_nodes = MIN_NODES / 2;
     ret->num_alloc_nodes = MIN_NODES;
     ret->pmax = MIN_NODES / 2;
@@ -84,10 +47,10 @@ _LHASH *lh_new(LHASH_HASH_FN_TYPE h, LHASH_COMP_FN_TYPE c)
     return (NULL);
 }
 
-void lh_free(_LHASH *lh)
+void OPENSSL_LH_free(OPENSSL_LHASH *lh)
 {
     unsigned int i;
-    LHASH_NODE *n, *nn;
+    OPENSSL_LH_NODE *n, *nn;
 
     if (lh == NULL)
         return;
@@ -104,10 +67,10 @@ void lh_free(_LHASH *lh)
     OPENSSL_free(lh);
 }
 
-void *lh_insert(_LHASH *lh, void *data)
+void *OPENSSL_LH_insert(OPENSSL_LHASH *lh, void *data)
 {
     unsigned long hash;
-    LHASH_NODE *nn, **rn;
+    OPENSSL_LH_NODE *nn, **rn;
     void *ret;
 
     lh->error = 0;
@@ -137,10 +100,10 @@ void *lh_insert(_LHASH *lh, void *data)
     return (ret);
 }
 
-void *lh_delete(_LHASH *lh, const void *data)
+void *OPENSSL_LH_delete(OPENSSL_LHASH *lh, const void *data)
 {
     unsigned long hash;
-    LHASH_NODE *nn, **rn;
+    OPENSSL_LH_NODE *nn, **rn;
     void *ret;
 
     lh->error = 0;
@@ -165,10 +128,10 @@ void *lh_delete(_LHASH *lh, const void *data)
     return (ret);
 }
 
-void *lh_retrieve(_LHASH *lh, const void *data)
+void *OPENSSL_LH_retrieve(OPENSSL_LHASH *lh, const void *data)
 {
     unsigned long hash;
-    LHASH_NODE **rn;
+    OPENSSL_LH_NODE **rn;
     void *ret;
 
     lh->error = 0;
@@ -184,11 +147,12 @@ void *lh_retrieve(_LHASH *lh, const void *data)
     return (ret);
 }
 
-static void doall_util_fn(_LHASH *lh, int use_arg, LHASH_DOALL_FN_TYPE func,
-                          LHASH_DOALL_ARG_FN_TYPE func_arg, void *arg)
+static void doall_util_fn(OPENSSL_LHASH *lh, int use_arg,
+                          OPENSSL_LH_DOALL_FUNC func,
+                          OPENSSL_LH_DOALL_FUNCARG func_arg, void *arg)
 {
     int i;
-    LHASH_NODE *a, *n;
+    OPENSSL_LH_NODE *a, *n;
 
     if (lh == NULL)
         return;
@@ -200,13 +164,6 @@ static void doall_util_fn(_LHASH *lh, int use_arg, LHASH_DOALL_FN_TYPE func,
     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);
@@ -217,19 +174,19 @@ static void doall_util_fn(_LHASH *lh, int use_arg, LHASH_DOALL_FN_TYPE func,
     }
 }
 
-void lh_doall(_LHASH *lh, LHASH_DOALL_FN_TYPE func)
+void OPENSSL_LH_doall(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNC func)
 {
-    doall_util_fn(lh, 0, func, (LHASH_DOALL_ARG_FN_TYPE)0, NULL);
+    doall_util_fn(lh, 0, func, (OPENSSL_LH_DOALL_FUNCARG)0, NULL);
 }
 
-void lh_doall_arg(_LHASH *lh, LHASH_DOALL_ARG_FN_TYPE func, void *arg)
+void OPENSSL_LH_doall_arg(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNCARG func, void *arg)
 {
-    doall_util_fn(lh, 1, (LHASH_DOALL_FN_TYPE)0, func, arg);
+    doall_util_fn(lh, 1, (OPENSSL_LH_DOALL_FUNC)0, func, arg);
 }
 
-static void expand(_LHASH *lh)
+static void expand(OPENSSL_LHASH *lh)
 {
-    LHASH_NODE **n, **n1, **n2, *np;
+    OPENSSL_LH_NODE **n, **n1, **n2, *np;
     unsigned int p, i, j;
     unsigned long hash, nni;
 
@@ -238,7 +195,7 @@ static void expand(_LHASH *lh)
     p = (int)lh->p++;
     n1 = &(lh->b[p]);
     n2 = &(lh->b[p + (int)lh->pmax]);
-    *n2 = NULL;                 /* 27/07/92 - eay - undefined pointer bug */
+    *n2 = NULL;
     nni = lh->num_alloc_nodes;
 
     for (np = *n1; np != NULL;) {
@@ -254,7 +211,7 @@ static void expand(_LHASH *lh)
 
     if ((lh->p) >= lh->pmax) {
         j = (int)lh->num_alloc_nodes * 2;
-        n = OPENSSL_realloc(lh->b, (int)(sizeof(LHASH_NODE *) * j));
+        n = OPENSSL_realloc(lh->b, (int)(sizeof(OPENSSL_LH_NODE *) * j));
         if (n == NULL) {
             /* fputs("realloc error in lhash",stderr); */
             lh->error++;
@@ -271,15 +228,15 @@ static void expand(_LHASH *lh)
     }
 }
 
-static void contract(_LHASH *lh)
+static void contract(OPENSSL_LHASH *lh)
 {
-    LHASH_NODE **n, *n1, *np;
+    OPENSSL_LH_NODE **n, *n1, *np;
 
     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 = OPENSSL_realloc(lh->b,
-                            (unsigned int)(sizeof(LHASH_NODE *) * lh->pmax));
+                            (unsigned int)(sizeof(OPENSSL_LH_NODE *) * lh->pmax));
         if (n == NULL) {
             /* fputs("realloc error in lhash",stderr); */
             lh->error++;
@@ -306,11 +263,12 @@ static void contract(_LHASH *lh)
     }
 }
 
-static LHASH_NODE **getrn(_LHASH *lh, const void *data, unsigned long *rhash)
+static OPENSSL_LH_NODE **getrn(OPENSSL_LHASH *lh,
+                               const void *data, unsigned long *rhash)
 {
-    LHASH_NODE **ret, *n1;
+    OPENSSL_LH_NODE **ret, *n1;
     unsigned long hash, nn;
-    LHASH_COMP_FN_TYPE cf;
+    OPENSSL_LH_COMPFUNC cf;
 
     hash = (*(lh->hash)) (data);
     lh->num_hash_calls++;
@@ -341,7 +299,7 @@ static LHASH_NODE **getrn(_LHASH *lh, const void *data, unsigned long *rhash)
  * collisions on /usr/dict/words and it distributes on %2^n quite well, not
  * as good as MD5, but still good.
  */
-unsigned long lh_strhash(const char *c)
+unsigned long OPENSSL_LH_strhash(const char *c)
 {
     unsigned long ret = 0;
     long n;
@@ -369,22 +327,22 @@ unsigned long lh_strhash(const char *c)
     return ((ret >> 16) ^ ret);
 }
 
-unsigned long lh_num_items(const _LHASH *lh)
+unsigned long OPENSSL_LH_num_items(const OPENSSL_LHASH *lh)
 {
     return lh ? lh->num_items : 0;
 }
 
-unsigned long lh_get_down_load(const _LHASH *lh)
+unsigned long OPENSSL_LH_get_down_load(const OPENSSL_LHASH *lh)
 {
     return lh->down_load;
 }
 
-void lh_set_down_load(_LHASH *lh, unsigned long down_load)
+void OPENSSL_LH_set_down_load(OPENSSL_LHASH *lh, unsigned long down_load)
 {
     lh->down_load = down_load;
 }
 
-int lh_error(_LHASH *lh)
+int OPENSSL_LH_error(OPENSSL_LHASH *lh)
 {
     return lh->error;
 }
diff --git a/crypto/lhash/lhash_lcl.h b/crypto/lhash/lhash_lcl.h
new file mode 100644 (file)
index 0000000..cfb0e1a
--- /dev/null
@@ -0,0 +1,42 @@
+/*
+ * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the OpenSSL license (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+struct lhash_node_st {
+    void *data;
+    struct lhash_node_st *next;
+    unsigned long hash;
+};
+
+struct lhash_st {
+    LHASH_NODE **b;
+    OPENSSL_LH_COMPFUNC comp;
+    OPENSSL_LH_HASHFUNC hash;
+    unsigned int num_nodes;
+    unsigned int num_alloc_nodes;
+    unsigned int p;
+    unsigned int pmax;
+    unsigned long up_load;      /* load times 256 */
+    unsigned long down_load;    /* load times 256 */
+    unsigned long num_items;
+    unsigned long num_expands;
+    unsigned long num_expand_reallocs;
+    unsigned long num_contracts;
+    unsigned long num_contract_reallocs;
+    unsigned long num_hash_calls;
+    unsigned long num_comp_calls;
+    unsigned long num_insert;
+    unsigned long num_replace;
+    unsigned long num_delete;
+    unsigned long num_no_delete;
+    unsigned long num_retrieve;
+    unsigned long num_retrieve_miss;
+    unsigned long num_hash_comps;
+    int error;
+};
index 321a342..e43fb30 100644 (file)
@@ -99,7 +99,7 @@ int OBJ_NAME_new_index(unsigned long (*hash_func) (const char *),
             OBJerr(OBJ_F_OBJ_NAME_NEW_INDEX, ERR_R_MALLOC_FAILURE);
             return (0);
         }
-        name_funcs->hash_func = lh_strhash;
+        name_funcs->hash_func = OPENSSL_LH_strhash;
         name_funcs->cmp_func = obj_strcmp;
         CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE);
         sk_NAME_FUNCS_push(name_funcs_stack, name_funcs);
@@ -141,7 +141,7 @@ static unsigned long obj_name_hash(const OBJ_NAME *a)
             sk_NAME_FUNCS_value(name_funcs_stack,
                                 a->type)->hash_func(a->name);
     } else {
-        ret = lh_strhash(a->name);
+        ret = OPENSSL_LH_strhash(a->name);
     }
     ret ^= a->type;
     return (ret);
index 3b836fe..46f98cb 100644 (file)
@@ -68,10 +68,10 @@ static unsigned long added_obj_hash(const ADDED_OBJ *ca)
             ret ^= p[i] << ((i * 3) % 24);
         break;
     case ADDED_SNAME:
-        ret = lh_strhash(a->sn);
+        ret = OPENSSL_LH_strhash(a->sn);
         break;
     case ADDED_LNAME:
-        ret = lh_strhash(a->ln);
+        ret = OPENSSL_LH_strhash(a->ln);
         break;
     case ADDED_NID:
         ret = a->nid;
index c23f305..36fc921 100644 (file)
@@ -17,7 +17,7 @@ struct stack_st {
     char **data;
     int sorted;
     int num_alloc;
-    int (*comp) (const void *, const void *);
+    OPENSSL_sk_compfunc comp;
 };
 
 #undef MIN_NODES
@@ -25,9 +25,9 @@ struct stack_st {
 
 #include <errno.h>
 
-int (*sk_set_cmp_func(_STACK *sk, int (*c) (const void *, const void *)))
- (const void *, const void *) {
-    int (*old) (const void *, const void *) = sk->comp;
+OPENSSL_sk_compfunc OPENSSL_sk_set_cmp_func(OPENSSL_STACK *sk, OPENSSL_sk_compfunc c)
+{
+    OPENSSL_sk_compfunc old = sk->comp;
 
     if (sk->comp != c)
         sk->sorted = 0;
@@ -36,12 +36,12 @@ int (*sk_set_cmp_func(_STACK *sk, int (*c) (const void *, const void *)))
     return old;
 }
 
-_STACK *sk_dup(_STACK *sk)
+OPENSSL_STACK *OPENSSL_sk_dup(OPENSSL_STACK *sk)
 {
-    _STACK *ret;
+    OPENSSL_STACK *ret;
     char **s;
 
-    if ((ret = sk_new(sk->comp)) == NULL)
+    if ((ret = OPENSSL_sk_new(sk->comp)) == NULL)
         goto err;
     s = OPENSSL_realloc((char *)ret->data,
                         (unsigned int)sizeof(char *) * sk->num_alloc);
@@ -56,17 +56,17 @@ _STACK *sk_dup(_STACK *sk)
     ret->comp = sk->comp;
     return (ret);
  err:
-    sk_free(ret);
+    OPENSSL_sk_free(ret);
     return (NULL);
 }
 
-_STACK *sk_deep_copy(_STACK *sk, void *(*copy_func) (void *),
-                     void (*free_func) (void *))
+OPENSSL_STACK *OPENSSL_sk_deep_copy(OPENSSL_STACK *sk, OPENSSL_sk_copyfunc copy_func,
+                             OPENSSL_sk_freefunc free_func)
 {
-    _STACK *ret;
+    OPENSSL_STACK *ret;
     int i;
 
-    if ((ret = OPENSSL_malloc(sizeof(_STACK))) == NULL)
+    if ((ret = OPENSSL_malloc(sizeof(*ret))) == NULL)
         return ret;
     ret->comp = sk->comp;
     ret->sorted = sk->sorted;
@@ -87,23 +87,23 @@ _STACK *sk_deep_copy(_STACK *sk, void *(*copy_func) (void *),
             while (--i >= 0)
                 if (ret->data[i] != NULL)
                     free_func(ret->data[i]);
-            sk_free(ret);
+            OPENSSL_sk_free(ret);
             return NULL;
         }
     }
     return ret;
 }
 
-_STACK *sk_new_null(void)
+OPENSSL_STACK *OPENSSL_sk_new_null(void)
 {
-    return sk_new((int (*)(const void *, const void *))0);
+    return OPENSSL_sk_new((OPENSSL_sk_compfunc)NULL);
 }
 
-_STACK *sk_new(int (*c) (const void *, const void *))
+OPENSSL_STACK *OPENSSL_sk_new(OPENSSL_sk_compfunc c)
 {
-    _STACK *ret;
+    OPENSSL_STACK *ret;
 
-    if ((ret = OPENSSL_zalloc(sizeof(_STACK))) == NULL)
+    if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
         goto err;
     if ((ret->data = OPENSSL_zalloc(sizeof(*ret->data) * MIN_NODES)) == NULL)
         goto err;
@@ -116,7 +116,7 @@ _STACK *sk_new(int (*c) (const void *, const void *))
     return (NULL);
 }
 
-int sk_insert(_STACK *st, void *data, int loc)
+int OPENSSL_sk_insert(OPENSSL_STACK *st, void *data, int loc)
 {
     char **s;
 
@@ -142,22 +142,22 @@ int sk_insert(_STACK *st, void *data, int loc)
     return (st->num);
 }
 
-void *sk_delete_ptr(_STACK *st, void *p)
+void *OPENSSL_sk_delete_ptr(OPENSSL_STACK *st, void *p)
 {
     int i;
 
     for (i = 0; i < st->num; i++)
         if (st->data[i] == p)
-            return (sk_delete(st, i));
+            return (OPENSSL_sk_delete(st, i));
     return (NULL);
 }
 
-void *sk_delete(_STACK *st, int loc)
+void *OPENSSL_sk_delete(OPENSSL_STACK *st, int loc)
 {
     char *ret;
     int i, j;
 
-    if (!st || (loc < 0) || (loc >= st->num))
+    if (st == NULL || loc < 0 || loc >= st->num)
         return NULL;
 
     ret = st->data[loc];
@@ -174,7 +174,7 @@ void *sk_delete(_STACK *st, int loc)
     return (ret);
 }
 
-static int internal_find(_STACK *st, void *data, int ret_val_options)
+static int internal_find(OPENSSL_STACK *st, void *data, int ret_val_options)
 {
     const void *const *r;
     int i;
@@ -188,7 +188,7 @@ static int internal_find(_STACK *st, void *data, int ret_val_options)
                 return (i);
         return (-1);
     }
-    sk_sort(st);
+    OPENSSL_sk_sort(st);
     if (data == NULL)
         return (-1);
     r = OBJ_bsearch_ex_(&data, st->data, st->num, sizeof(void *), st->comp,
@@ -198,45 +198,45 @@ static int internal_find(_STACK *st, void *data, int ret_val_options)
     return (int)((char **)r - st->data);
 }
 
-int sk_find(_STACK *st, void *data)
+int OPENSSL_sk_find(OPENSSL_STACK *st, void *data)
 {
     return internal_find(st, data, OBJ_BSEARCH_FIRST_VALUE_ON_MATCH);
 }
 
-int sk_find_ex(_STACK *st, void *data)
+int OPENSSL_sk_find_ex(OPENSSL_STACK *st, void *data)
 {
     return internal_find(st, data, OBJ_BSEARCH_VALUE_ON_NOMATCH);
 }
 
-int sk_push(_STACK *st, void *data)
+int OPENSSL_sk_push(OPENSSL_STACK *st, void *data)
 {
-    return (sk_insert(st, data, st->num));
+    return (OPENSSL_sk_insert(st, data, st->num));
 }
 
-int sk_unshift(_STACK *st, void *data)
+int OPENSSL_sk_unshift(OPENSSL_STACK *st, void *data)
 {
-    return (sk_insert(st, data, 0));
+    return (OPENSSL_sk_insert(st, data, 0));
 }
 
-void *sk_shift(_STACK *st)
+void *OPENSSL_sk_shift(OPENSSL_STACK *st)
 {
     if (st == NULL)
         return (NULL);
     if (st->num <= 0)
         return (NULL);
-    return (sk_delete(st, 0));
+    return (OPENSSL_sk_delete(st, 0));
 }
 
-void *sk_pop(_STACK *st)
+void *OPENSSL_sk_pop(OPENSSL_STACK *st)
 {
     if (st == NULL)
         return (NULL);
     if (st->num <= 0)
         return (NULL);
-    return (sk_delete(st, st->num - 1));
+    return (OPENSSL_sk_delete(st, st->num - 1));
 }
 
-void sk_zero(_STACK *st)
+void OPENSSL_sk_zero(OPENSSL_STACK *st)
 {
     if (st == NULL)
         return;
@@ -246,7 +246,7 @@ void sk_zero(_STACK *st)
     st->num = 0;
 }
 
-void sk_pop_free(_STACK *st, void (*func) (void *))
+void OPENSSL_sk_pop_free(OPENSSL_STACK *st, OPENSSL_sk_freefunc func)
 {
     int i;
 
@@ -255,10 +255,10 @@ void sk_pop_free(_STACK *st, void (*func) (void *))
     for (i = 0; i < st->num; i++)
         if (st->data[i] != NULL)
             func(st->data[i]);
-    sk_free(st);
+    OPENSSL_sk_free(st);
 }
 
-void sk_free(_STACK *st)
+void OPENSSL_sk_free(OPENSSL_STACK *st)
 {
     if (st == NULL)
         return;
@@ -266,48 +266,38 @@ void sk_free(_STACK *st)
     OPENSSL_free(st);
 }
 
-int sk_num(const _STACK *st)
+int OPENSSL_sk_num(const OPENSSL_STACK *st)
 {
     if (st == NULL)
         return -1;
     return st->num;
 }
 
-void *sk_value(const _STACK *st, int i)
+void *OPENSSL_sk_value(const OPENSSL_STACK *st, int i)
 {
-    if (!st || (i < 0) || (i >= st->num))
+    if (st == NULL || i < 0 || i >= st->num)
         return NULL;
     return st->data[i];
 }
 
-void *sk_set(_STACK *st, int i, void *value)
+void *OPENSSL_sk_set(OPENSSL_STACK *st, int i, void *value)
 {
-    if (!st || (i < 0) || (i >= st->num))
+    if (st == NULL || i < 0 || i >= st->num)
         return NULL;
     return (st->data[i] = value);
 }
 
-void sk_sort(_STACK *st)
+void OPENSSL_sk_sort(OPENSSL_STACK *st)
 {
     if (st && !st->sorted && st->comp != NULL) {
-        int (*comp_func) (const void *, const void *);
-
-        /*
-         * same comment as in sk_find ... previously st->comp was declared as
-         * a (void*,void*) callback type, but this made the population of the
-         * callback pointer illogical - our callbacks compare type** with
-         * type**, so we leave the casting until absolutely necessary (ie.
-         * "now").
-         */
-        comp_func = (int (*)(const void *, const void *))(st->comp);
-        qsort(st->data, st->num, sizeof(char *), comp_func);
+        qsort(st->data, st->num, sizeof(char *), st->comp);
         st->sorted = 1;
     }
 }
 
-int sk_is_sorted(const _STACK *st)
+int OPENSSL_sk_is_sorted(const OPENSSL_STACK *st)
 {
-    if (!st)
+    if (st == NULL)
         return 1;
     return st->sorted;
 }
index 6bc0262..1432230 100644 (file)
@@ -145,7 +145,7 @@ OPENSSL_STRING *TXT_DB_get_by_index(TXT_DB *db, int idx,
 }
 
 int TXT_DB_create_index(TXT_DB *db, int field, int (*qual) (OPENSSL_STRING *),
-                        LHASH_HASH_FN_TYPE hash, LHASH_COMP_FN_TYPE cmp)
+                        OPENSSL_LH_HASHFUNC hash, OPENSSL_LH_COMPFUNC cmp)
 {
     LHASH_OF(OPENSSL_STRING) *idx;
     OPENSSL_STRING *r;
@@ -156,7 +156,7 @@ int TXT_DB_create_index(TXT_DB *db, int field, int (*qual) (OPENSSL_STRING *),
         return (0);
     }
     /* FIXME: we lose type checking at this point */
-    if ((idx = (LHASH_OF(OPENSSL_STRING) *)lh_new(hash, cmp)) == NULL) {
+    if ((idx = (LHASH_OF(OPENSSL_STRING) *)OPENSSL_LH_new(hash, cmp)) == NULL) {
         db->error = DB_ERROR_MALLOC;
         return (0);
     }
index 12b4a16..bdc19b4 100644 (file)
@@ -2,20 +2,21 @@
 
 =head1 NAME
 
-lh_stats, lh_node_stats, lh_node_usage_stats, lh_stats_bio,
-lh_node_stats_bio, lh_node_usage_stats_bio - LHASH statistics
+OPENSSL_LH_stats, OPENSSL_LH_node_stats, OPENSSL_LH_node_usage_stats,
+OPENSSL_LH_stats_bio,
+OPENSSL_LH_node_stats_bio, OPENSSL_LH_node_usage_stats_bio - LHASH statistics
 
 =head1 SYNOPSIS
 
  #include <openssl/lhash.h>
 
- void lh_stats(LHASH *table, FILE *out);
- void lh_node_stats(LHASH *table, FILE *out);
- void lh_node_usage_stats(LHASH *table, FILE *out);
+ void OPENSSL_LH_stats(LHASH *table, FILE *out);
+ void OPENSSL_LH_node_stats(LHASH *table, FILE *out);
+ void OPENSSL_LH_node_usage_stats(LHASH *table, FILE *out);
 
- void lh_stats_bio(LHASH *table, BIO *out);
- void lh_node_stats_bio(LHASH *table, BIO *out);
- void lh_node_usage_stats_bio(LHASH *table, BIO *out);
+ void OPENSSL_LH_stats_bio(LHASH *table, BIO *out);
+ void OPENSSL_LH_node_stats_bio(LHASH *table, BIO *out);
+ void OPENSSL_LH_node_usage_stats_bio(LHASH *table, BIO *out);
 
 =head1 DESCRIPTION
 
@@ -24,14 +25,14 @@ accessing the hash table.  This is mostly a legacy of Eric Young
 writing this library for the reasons of implementing what looked like
 a nice algorithm rather than for a particular software product.
 
-lh_stats() prints out statistics on the size of the hash table, how
+OPENSSL_LH_stats() prints out statistics on the size of the hash table, how
 many entries are in it, and the number and result of calls to the
 routines in this library.
 
-lh_node_stats() prints the number of entries for each 'bucket' in the
+OPENSSL_LH_node_stats() prints the number of entries for each 'bucket' in the
 hash table.
 
-lh_node_usage_stats() prints out a short summary of the state of the
+OPENSSL_LH_node_usage_stats() prints out a short summary of the state of the
 hash table.  It prints the 'load' and the 'actual load'.  The load is
 the average number of data items per 'bucket' in the hash table.  The
 'actual load' is the average number of items per 'bucket', but only
@@ -40,7 +41,7 @@ average number of searches that will need to find an item in the hash
 table, while the 'load' is the average number that will be done to
 record a miss.
 
-lh_stats_bio(), lh_node_stats_bio() and lh_node_usage_stats_bio()
+OPENSSL_LH_stats_bio(), OPENSSL_LH_node_stats_bio() and OPENSSL_LH_node_usage_stats_bio()
 are the same as the above, except that the output goes to a B<BIO>.
 
 =head1 RETURN VALUES
index acc0821..9e29617 100644 (file)
@@ -2,39 +2,45 @@
 
 =head1 NAME
 
-lh_new, lh_free, lh_insert, lh_delete, lh_retrieve, lh_doall, lh_doall_arg, lh_error - dynamic hash table
+DECLARE_LHASH_OF,
+OPENSSL_LH_COMPFUNC, OPENSSL_LH_HASHFUNC, OPENSSL_LH_DOALL_FUNC,
+LHASH_DOALL_ARG_FN_TYPE,
+lh_TYPE_new, lh_TYPE_free,
+lh_TYPE_insert, lh_TYPE_delete, lh_TYPE_retrieve,
+lh_TYPE_doall, lh_TYPE_doall_arg, lh_TYPE_error - dynamic hash table
 
 =head1 SYNOPSIS
 
  #include <openssl/lhash.h>
 
- DECLARE_LHASH_OF(<type>);
+ DECLARE_LHASH_OF(TYPE);
 
- LHASH *lh_<type>_new();
- void lh_<type>_free(LHASH_OF(<type> *table);
+ LHASH *lh_TYPE_new();
+ void lh_TYPE_free(LHASH_OF(TYPE *table);
 
<type> *lh_<type>_insert(LHASH_OF(<type> *table, <type> *data);
<type> *lh_<type>_delete(LHASH_OF(<type> *table, <type> *data);
<type> *lh_retrieve(LHASH_OF<type> *table, <type> *data);
TYPE *lh_TYPE_insert(LHASH_OF(TYPE *table, TYPE *data);
TYPE *lh_TYPE_delete(LHASH_OF(TYPE *table, TYPE *data);
TYPE *lh_retrieve(LHASH_OFTYPE *table, TYPE *data);
 
- void lh_<type>_doall(LHASH_OF(<type> *table, LHASH_DOALL_FN_TYPE func);
- void lh_<type>_doall_arg(LHASH_OF(<type> *table, LHASH_DOALL_ARG_FN_TYPE func,
-          <type2>, <type2> *arg);
+ void lh_TYPE_doall(LHASH_OF(TYPE *table, OPENSSL_LH_DOALL_FUNC func);
+ void lh_TYPE_doall_arg(LHASH_OF(TYPE) *table, OPENSSL_LH_DOALL_FUNCARG func,
+          TYPE, TYPE *arg);
 
- int lh_<type>_error(LHASH_OF(<type> *table);
+ int lh_TYPE_error(LHASH_OF(TYPE) *table);
 
- typedef int (*LHASH_COMP_FN_TYPE)(const void *, const void *);
- typedef unsigned long (*LHASH_HASH_FN_TYPE)(const void *);
- typedef void (*LHASH_DOALL_FN_TYPE)(const void *);
+ typedef int (*OPENSSL_LH_COMPFUNC)(const void *, const void *);
+ typedef unsigned long (*OPENSSL_LH_HASHFUNC)(const void *);
+ typedef void (*OPENSSL_LH_DOALL_FUNC)(const void *);
  typedef void (*LHASH_DOALL_ARG_FN_TYPE)(const void *, const void *);
 
 =head1 DESCRIPTION
 
 This library implements type-checked dynamic hash tables. The hash
 table entries can be arbitrary structures. Usually they consist of key
-and value fields.
+and value fields.  In the description here, I<TYPE> is used a placeholder
+for any of the OpenSSL datatypes, such as I<SSL_SESSION>.
 
-lh_<type>_new() creates a new B<LHASH_OF(<type>> structure to store
+lh_TYPE_new() creates a new B<LHASH_OF(TYPE)> structure to store
 arbitrary data entries, and provides the 'hash' and 'compare'
 callbacks to be used in organising the table's entries.  The B<hash>
 callback takes a pointer to a table entry as its argument and returns
@@ -47,7 +53,7 @@ will contain items of some particular type and the B<hash> and
 B<compare> callbacks hash/compare these types, then the
 B<DECLARE_LHASH_HASH_FN> and B<IMPLEMENT_LHASH_COMP_FN> macros can be
 used to create callback wrappers of the prototypes required by
-lh_<type>_new().  These provide per-variable casts before calling the
+lh_TYPE_new().  These provide per-variable casts before calling the
 type-specific callbacks written by the application author.  These
 macros, as well as those used for the "doall" callbacks, are defined
 as;
@@ -104,25 +110,25 @@ as;
          /* ... */
  }
 
-lh_<type>_free() frees the B<LHASH_OF(<type>> structure
+lh_TYPE_free() frees the B<LHASH_OF(TYPE)> structure
 B<table>. Allocated hash table entries will not be freed; consider
-using lh_<type>_doall() to deallocate any remaining entries in the
+using lh_TYPE_doall() to deallocate any remaining entries in the
 hash table (see below).
 
-lh_<type>_insert() inserts the structure pointed to by B<data> into
+lh_TYPE_insert() inserts the structure pointed to by B<data> into
 B<table>.  If there already is an entry with the same key, the old
-value is replaced. Note that lh_<type>_insert() stores pointers, the
+value is replaced. Note that lh_TYPE_insert() stores pointers, the
 data are not copied.
 
-lh_<type>_delete() deletes an entry from B<table>.
+lh_TYPE_delete() deletes an entry from B<table>.
 
-lh_<type>_retrieve() looks up an entry in B<table>. Normally, B<data>
+lh_TYPE_retrieve() looks up an entry in B<table>. Normally, B<data>
 is a structure with the key field(s) set; the function will return a
 pointer to a fully populated structure.
 
-lh_<type>_doall() will, for every entry in the hash table, call
-B<func> with the data item as its parameter.  For lh_<type>_doall()
-and lh_<type>_doall_arg(), function pointer casting should be avoided
+lh_TYPE_doall() will, for every entry in the hash table, call
+B<func> with the data item as its parameter.  For lh_TYPE_doall()
+and lh_TYPE_doall_arg(), function pointer casting should be avoided
 in the callbacks (see B<NOTE>) - instead use the declare/implement
 macros to create type-checked wrappers that cast variables prior to
 calling your type-specific callbacks.  An example of this is
@@ -149,7 +155,7 @@ you start (which will stop the hash table ever decreasing in size).
 The best solution is probably to avoid deleting items from the hash
 table inside a "doall" callback!
 
-lh_<type>_doall_arg() is the same as lh_<type>_doall() except that
+lh_TYPE_doall_arg() is the same as lh_TYPE_doall() except that
 B<func> will be called with B<arg> as the second argument and B<func>
 should be of type B<LHASH_DOALL_ARG_FN_TYPE> (a callback prototype
 that is passed both the table entry and an extra argument).  As with
@@ -169,27 +175,28 @@ that is provided by the caller):
  lh_STUFF_doall_arg(hashtable, LHASH_DOALL_ARG_FN(STUFF_print), BIO,
                     logging_bio);
 
-lh_<type>_error() can be used to determine if an error occurred in the last
-operation. lh_<type>_error() is a macro.
+
+lh_TYPE_error() can be used to determine if an error occurred in the last
+operation.
 
 =head1 RETURN VALUES
 
-lh_<type>_new() returns B<NULL> on error, otherwise a pointer to the new
+lh_TYPE_new() returns B<NULL> on error, otherwise a pointer to the new
 B<LHASH> structure.
 
-When a hash table entry is replaced, lh_<type>_insert() returns the value
+When a hash table entry is replaced, lh_TYPE_insert() returns the value
 being replaced. B<NULL> is returned on normal operation and on error.
 
-lh_<type>_delete() returns the entry being deleted.  B<NULL> is returned if
+lh_TYPE_delete() returns the entry being deleted.  B<NULL> is returned if
 there is no such value in the hash table.
 
-lh_<type>_retrieve() returns the hash table entry if it has been found,
+lh_TYPE_retrieve() returns the hash table entry if it has been found,
 B<NULL> otherwise.
 
-lh_<type>_error() returns 1 if an error occurred in the last operation, 0
+lh_TYPE_error() returns 1 if an error occurred in the last operation, 0
 otherwise.
 
-lh_<type>_free(), lh_<type>_doall() and lh_<type>_doall_arg() return no values.
+lh_TYPE_free(), lh_TYPE_doall() and lh_TYPE_doall_arg() return no values.
 
 =head1 NOTE
 
@@ -232,17 +239,12 @@ without any "const" qualifiers.
 
 =head1 BUGS
 
-lh_<type>_insert() returns B<NULL> both for success and error.
+lh_TYPE_insert() returns B<NULL> both for success and error.
 
 =head1 SEE ALSO
 
 L<lh_stats(3)>
 
-=head1 HISTORY
-
-In OpenSSL 1.0.0, the lhash interface was revamped for better
-type checking.
-
 =cut
 
 =head1 COPYRIGHT
diff --git a/doc/crypto/sk_X509_num.pod b/doc/crypto/sk_X509_num.pod
deleted file mode 100644 (file)
index 1f16e81..0000000
+++ /dev/null
@@ -1,213 +0,0 @@
-=pod
-
-=head1 NAME
-
-sk_X509_num, sk_X509_value, sk_X509_new, sk_X509_new_null, sk_X509_free,
-sk_X509_zero, sk_X509_delete, sk_X509_delete_ptr, sk_X509_push,
-sk_X509_unshift, sk_X509_pop, sk_X509_shift, sk_X509_pop_free, sk_X509_insert,
-sk_X509_set, sk_X509_find, sk_X509_find_ex, sk_X509_sort, sk_X509_is_sorted,
-sk_X509_dup, sk_X509_deep_copy, sk_X509_set_cmp_func - X509 stack
-
-=head1 SYNOPSIS
-
- #include <openssl/x509.h>
-
- int sk_X509_num(const STACK_OF(X509) *sk);
- X509 *sk_X509_value(const STACK_OF(X509) *sk, int idx);
- STACK_OF(X509) *sk_X509_new(int (*cmpf)(const X509 * const *a,
-                                         const X509 * const *b));
- STACK_OF(X509) *sk_X509_new_null(void);
- int (*sk_X509_set_cmp_func (STACK_OF(X509) *sk,
-                             int (*cmpf) (const X509 * const *a,
-                                          const X509 * const *b)))
-                             (const X509 * const *, const X509 * const *);
- void sk_X509_free(const STACK_OF(X509) *sk);
- void sk_X509_zero(const STACK_OF(X509) *sk);
- void sk_X509_pop_free(STACK_OF(X509) *sk, void (*func) (X509 *a));
- X509 *sk_X509_delete(STACK_OF(X509) *sk, int i);
- X509 *sk_X509_delete_ptr(STACK_OF(X509) *sk, X509 *ptr);
- int sk_X509_insert(STACK_OF(X509) *sk, X509 *ptr, int idx);
- int sk_X509_push(STACK_OF(X509) *sk, X509 *ptr);
- int sk_X509_unshift(STACK_OF(X509) *sk, X509 *ptr);
- X509 *sk_X509_pop(STACK_OF(X509) *sk);
- X509 *sk_X509_shift(STACK_OF(X509) *sk);
- X509 *sk_X509_set(STACK_OF(X509) *sk, int idx, X509 *ptr);
- int sk_X509_find(STACK_OF(X509) *sk, X509 *ptr);
- int sk_X509_find_ex(STACK_OF(X509) *sk, X509 *ptr);
- void sk_X509_sort(const STACK_OF(X509) *sk);
- int sk_X509_is_sorted(const STACK_OF(X509) *sk);
- STACK_OF(X509) *sk_X509_dup(STACK_OF(X509) *sk);
- STACK_OF(X509) *sk_X509_deep_copy(STACK_OF(X509) *sk,
-                                   X509 * (*copyfn) (const X509 *),
-                                   void (*freefn) (X509 *));
-
-=head1 DESCRIPTION
-
-sk_X509_num() returns the number of elements in B<sk> or -1 if B<sk> is
-B<NULL>.
-
-sk_X509_value() returns element B<idx> in B<sk>. Where B<idx> runs from 0
-to sk_X509_num(sk) - 1 inclusive. If B<idx> is out of range then B<NULL>
-is returned.
-
-sk_X509_new() allocates a new empty stack using comparison function B<cmpf>.
-If B<cmpf> is B<0> then no comparison function is used.
-
-sk_X509_new_null() allocates a new empty stack with no comparison function.
-
-sk_X509_set_cmp_func() sets the comparison function of B<sk> to B<cmpf>.
-The previous comparison function is returned or B<0> if there was
-no previous comparison function.
-
-sk_X509_free() frees up the B<sk> structure. It does B<not> free up any
-elements of B<sk>. After this call B<sk> is no longer valid.
-
-sk_X509_zero() sets the number of elements in B<sk> to zero. It does not free
-B<sk> so after this call B<sk> is still valid.
-
-sk_X509_pop_free() frees up all elements of B<sk> and B<sk> itself. The
-free function func() is called on each element to free it.
-
-sk_X509_delete() deletes element B<i> from B<sk>. It returns the deleted
-element or B<NULL> if B<i> is out of range.
-
-sk_X509_delete_ptr() deletes element matching B<ptr> from B<sk>. It returns
-the deleted element or B<NULL> if no element matching B<ptr> was found.
-
-sk_X509_insert() inserts B<ptr> into B<sk> at position B<idx>. Any existing
-elements at or after B<idx> are moved downwards. If B<idx> is out of range
-the new element is appended to B<sk>. sk_X509_insert() either returns the
-number of elements in B<sk> after the new element is inserted or zero if
-an error occurred: which will happen if there is a memory allocation failure.
-
-sk_X509_push() appends B<ptr> to B<sk> it is equivalent to:
-
- sk_X509_insert(sk, ptr, -1);
-
-sk_X509_unshift() inserts B<ptr> at the start of B<sk> it is equivalent to:
-
- sk_X509_insert(sk, ptr, 0);
-
-sk_X509_pop() returns and removes the last element from B<sk>.
-
-sk_X509_shift() returns and removes the first element from B<sk>.
-
-sk_X509_set() sets element B<idx> of B<sk> to B<ptr> replacing the current
-element. The new element value is returned or B<NULL> if an error occurred:
-this will only happen if B<sk> is B<NULL> or B<idx> is out of range.
-
-sk_X509_find() and int sk_X509_find_ex() search B<sk> using the supplied
-comparison function for an element matching B<ptr>. sk_X509_find() returns
-the index of the first matching element or B<-1> if there is no match.
-sk_X509_find_ex() returns a matching element or the nearest element that
-does not match B<ptr>. Note: if a comparison function is set then  B<sk> is
-sorted before the search which may change its order. If no comparison
-function is set then a linear search is made for a pointer matching B<ptr>
-and the stack is not reordered.
-
-sk_X509_sort() sorts B<sk> using the supplied comparison function.
-
-sk_X509_is_sorted() returns B<1> if B<sk> is sorted and B<0> otherwise.
-
-sk_X509_dup() returns a copy of B<sk>. Note the pointers in the copy
-are identical to the original.
-
-sk_X509_deep_copy() returns a new stack where each element has been copied.
-Copying is performed by the supplied copyfn() and freeing by freefn(). The
-function freefn() is only called if an error occurs.
-
-=head1 NOTES
-
-This manual page documents the functions which operate on a stack of
-B<X509> pointers. A stack can contain pointers to any structure with B<X509>
-replaced by the appropriate structure name.
-
-Care should be taken when accessing stacks in multi-threaded environments.
-Any operation which increases the size of a stack such as sk_X509_insert() or
-sk_push() can "grow" the size of an internal array and cause race conditions
-if the same stack is accessed in a different thread. Operations such as
-sk_find() and sk_sort() can also reorder the stack.
-
-Any comparison function supplied should use a metric suitable
-for use in a binary search operation. That is it should return zero, a
-positive or negative value if B<a> is equal to, greater than
-or less than B<b> respectively.
-
-Care should be taken when checking the return values of the functions
-sk_X509_find() and sk_X509_find_ex(). They return an index to the
-matching element. In particular B<0> indicates a matching first element.
-A failed search is indicated by a B<-1> return value.
-
-=head1 APPLICATION DEFINED STACKS
-
-Applications can create and use their own stacks by placing any of the macros
-described below in a header file.
-
-DEFINE_STACK_OF(NAME) creates set of functions for a stack of B<NAME>. This
-will mean that type B<NAME> is stored in each stack, the type is referenced by
-STACK_OF(NAME) and each function name begins with sk_NAME_. For example:
-
- NAME *sk_NAME_value(STACK_OF(NAME) *sk, int idx);
-
-DEFINE_STACK_OF_CONST(NAME) is identical to DEFINE_STACK_OF(NAME) except
-each element is constant for example:
-
- const NAME *sk_name_value(STACK_OF(NAME) *sk, int idx);
-
-DEFINE_SPECIAL_STACK_OF(FNAME, STNAME) defines a stack of B<STNAME> but
-each function uses B<FNAME>. For example:
-
- STNAME *sk_FNAME_value(STACK_OF(STNAME) *sk, int idx);
-
-=head1 RETURN VALUES
-
-sk_X509_num() returns the number of elements in the stack or B<-1> if the
-passed stack is B<NULL>.
-
-sk_X509_value() returns a pointer to a stack element or B<NULL> if the
-index is out of range.
-
-sk_X509_new() and sk_X509_new_null() return an empty stack or B<NULL> if
-an error occurs.
-
-sk_X509_set_cmp_func() returns the old comparison function or B<NULL> if
-there was no old comparison function.
-
-sk_X509_free(), sk_X509_zero(), sk_X509_pop_free() and sk_X509_sort() do
-not return values.
-
-sk_X509_pop(), sk_X509_shift(), sk_X509_delete() and sk_X509_delete_ptr()
-return a pointer to the deleted element or B<NULL> on error.
-
-sk_X509_insert(), sk_X509_push() and sk_X509_unshift() return the total
-number of elements in the stack and 0 if an error occurred.
-
-sk_X509_set() returns a pointer to the replacement element or B<NULL> on
-error.
-
-sk_X509_find() and sk_X509_find_ex() return an index to the found element
-or B<-1> on error.
-
-sk_X509_is_sorted() returns B<1> if the stack is sorted and B<0> if it is
-not.
-
-sk_X509_dup() and sk_X509_deep_copy() return a pointer to the copy of the
-stack.
-
-=head1 HISTORY
-
-Use of inline functions and application defined stacks first appeared in
-OpenSSL 1.1.0. Previous versions of OpenSSL implemented stacks as macros.
-
-=cut
-
-=head1 COPYRIGHT
-
-Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
-
-Licensed under the OpenSSL license (the "License").  You may not use
-this file except in compliance with the License.  You can obtain a copy
-in the file LICENSE in the source distribution or at
-L<https://www.openssl.org/source/license.html>.
-
-=cut
diff --git a/doc/crypto/stack.pod b/doc/crypto/stack.pod
new file mode 100644 (file)
index 0000000..1defff0
--- /dev/null
@@ -0,0 +1,212 @@
+=pod
+
+=head1 NAME
+
+DEFINE_STACK_OF, DEFINE_STACK_OF_CONST, DEFINE_SPECIAL_STACK_OF,
+sk_TYPE_num, sk_TYPE_value, sk_TYPE_new, sk_TYPE_new_null, sk_TYPE_free,
+sk_TYPE_zero, sk_TYPE_delete, sk_TYPE_delete_ptr, sk_TYPE_push,
+sk_TYPE_unshift, sk_TYPE_pop, sk_TYPE_shift, sk_TYPE_pop_free,
+sk_TYPE_insert, sk_TYPE_set, sk_TYPE_find, sk_TYPE_find_ex, sk_TYPE_sort,
+sk_TYPE_is_sorted, sk_TYPE_dup, sk_TYPE_deep_copy, sk_TYPE_set_cmp_func -
+stack container
+
+=head1 SYNOPSIS
+
+ #include <openssl/safestack.h>
+
+ #define STACK_OF(TYPE)
+ #define DEFINE_STACK_OF
+ #define DEFINE_STACK_OF_CONST
+ #define DEFINE_SPECIAL_STACK_OF
+
+ typedef int (*sk_TYPE_compfunc)(const TYPE *const *a, const TYPE *const *b);
+ typedef TYPE * (*sk_TYPE_copyfunc)(const TYPE *a);
+ typedef void (*sk_TYPE_freefunc)(TYPE *a);
+
+ int sk_TYPE_num(const STACK_OF(TYPE) *sk);
+ TYPE *sk_TYPE_value(const STACK_OF(TYPE) *sk, int idx);
+ STACK_OF(TYPE) *sk_TYPE_new(sk_TYPE_compfunc compare);
+ STACK_OF(TYPE) *sk_TYPE_new_null(void);
+ void sk_TYPE_free(const STACK_OF(TYPE) *sk);
+ void sk_TYPE_zero(const STACK_OF(TYPE) *sk);
+ TYPE *sk_TYPE_delete(STACK_OF(TYPE) *sk, int i);
+ TYPE *sk_TYPE_delete_ptr(STACK_OF(TYPE) *sk, TYPE *ptr);
+ int sk_TYPE_push(STACK_OF(TYPE) *sk, TYPE *ptr);
+ int sk_TYPE_unshift(STACK_OF(TYPE) *sk, TYPE *ptr);
+ TYPE *sk_TYPE_pop(STACK_OF(TYPE) *sk);
+ TYPE *sk_TYPE_shift(STACK_OF(TYPE) *sk);
+ void sk_TYPE_pop_free(STACK_OF(TYPE) *sk, sk_TYPE_freefunc freefunc);
+ int sk_TYPE_insert(STACK_OF(TYPE) *sk, TYPE *ptr, int idx);
+ TYPE *sk_TYPE_set(STACK_OF(TYPE) *sk, int idx, TYPE *ptr);
+ int sk_TYPE_find(STACK_OF(TYPE) *sk, TYPE *ptr);
+ int sk_TYPE_find_ex(STACK_OF(TYPE) *sk, TYPE *ptr);
+ void sk_TYPE_sort(const STACK_OF(TYPE) *sk);
+ int sk_TYPE_is_sorted(const STACK_OF(TYPE) *sk);
+ STACK_OF(TYPE) *sk_TYPE_dup(STACK_OF(TYPE) *sk);
+ STACK_OF(TYPE) *sk_TYPE_deep_copy(STACK_OF(TYPE) *sk,
+                                   sk_TYPE_copyfunc copyfunc,
+                                   sk_TYPE_freefunc freefunc);
+ sk_TYPE_compfunc (*sk_TYPE_set_cmp_func(STACK_OF(TYPE) *sk, sk_TYPE_compfunc compare);
+
+=head1 DESCRIPTION
+
+Applications can create and use their own stacks by placing any of the macros
+described below in a header file.  In the description below, I<TYPE> is used
+as a placeholder for any of the OpenSSL datatypes, such as I<X509>.
+
+DEFINE_STACK_OF(TYPE) creates set of functions for a stack of B<TYPE>. This
+will mean that type B<TYPE> is stored in each stack, the type is referenced by
+STACK_OF(TYPE) and each function name begins with I<sk_TYPE_>. For example:
+
+ TYPE *sk_TYPE_value(STACK_OF(TYPE) *sk, int idx);
+
+DEFINE_STACK_OF_CONST(TYPE) is identical to DEFINE_STACK_OF(TYPE) except
+each element is constant. For example:
+
+ const TYPE *sk_TYPE_value(STACK_OF(TYPE) *sk, int idx);
+
+DEFINE_SPECIAL_STACK_OF(FUNCNAME, TYPE) defines a stack of B<TYPE> but
+each function uses B<FUNCNAME> in the function name. For example:
+
+ TYPE *sk_FUNCNAME_value(STACK_OF(TYPE) *sk, int idx);
+
+sk_TYPE_num() returns the number of elements in B<sk> or -1 if B<sk> is
+B<NULL>.
+
+sk_TYPE_value() returns element B<idx> in B<sk>, where B<idx> starts at
+zero. If B<idx> is out of range then B<NULL> is returned.
+
+sk_TYPE_new() allocates a new empty stack using comparison function B<compar>.
+If B<compar> is B<NULL> then no comparison function is used.
+
+sk_TYPE_new_null() allocates a new empty stack with no comparison function.
+
+sk_TYPE_set_cmp_func() sets the comparison function of B<sk> to B<compar>.
+The previous comparison function is returned or B<NULL> if there was
+no previous comparison function.
+
+sk_TYPE_free() frees up the B<sk> structure. It does B<not> free up any
+elements of B<sk>. After this call B<sk> is no longer valid.
+
+sk_TYPE_zero() sets the number of elements in B<sk> to zero. It does not free
+B<sk> so after this call B<sk> is still valid.
+
+sk_TYPE_pop_free() frees up all elements of B<sk> and B<sk> itself. The
+free function freefunc() is called on each element to free it.
+
+sk_TYPE_delete() deletes element B<i> from B<sk>. It returns the deleted
+element or B<NULL> if B<i> is out of range.
+
+sk_TYPE_delete_ptr() deletes element matching B<ptr> from B<sk>. It returns
+the deleted element or B<NULL> if no element matching B<ptr> was found.
+
+sk_TYPE_insert() inserts B<ptr> into B<sk> at position B<idx>. Any existing
+elements at or after B<idx> are moved downwards. If B<idx> is out of range
+the new element is appended to B<sk>. sk_TYPE_insert() either returns the
+number of elements in B<sk> after the new element is inserted or zero if
+an error (such as memory allocation failure) occurred.
+
+sk_TYPE_push() appends B<ptr> to B<sk> it is equivalent to:
+
+ sk_TYPE_insert(sk, ptr, -1);
+
+sk_TYPE_unshift() inserts B<ptr> at the start of B<sk> it is equivalent to:
+
+ sk_TYPE_insert(sk, ptr, 0);
+
+sk_TYPE_pop() returns and removes the last element from B<sk>.
+
+sk_TYPE_shift() returns and removes the first element from B<sk>.
+
+sk_TYPE_set() sets element B<idx> of B<sk> to B<ptr> replacing the current
+element. The new element value is returned or B<NULL> if an error occurred:
+this will only happen if B<sk> is B<NULL> or B<idx> is out of range.
+
+sk_TYPE_find() and sk_TYPE_find_ex() search B<sk> using the supplied
+comparison function for an element matching B<ptr>. sk_TYPE_find() returns
+the index of the first matching element or B<-1> if there is no match.
+sk_TYPE_find_ex() returns a matching element or the nearest element that
+does not match B<ptr>. Note: if a comparison function is set then  B<sk> is
+sorted before the search which may change its order. If no comparison
+function is set then a linear search is made for a pointer matching B<ptr>
+and the stack is not reordered.
+
+sk_TYPE_sort() sorts B<sk> using the supplied comparison function.
+
+sk_TYPE_is_sorted() returns B<1> if B<sk> is sorted and B<0> otherwise.
+
+sk_TYPE_dup() returns a copy of B<sk>. Note the pointers in the copy
+are identical to the original.
+
+sk_TYPE_deep_copy() returns a new stack where each element has been copied.
+Copying is performed by the supplied copyfunc() and freeing by freefunc(). The
+function freefunc() is only called if an error occurs.
+
+=head1 NOTES
+
+Care should be taken when accessing stacks in multi-threaded environments.
+Any operation which increases the size of a stack such as sk_TYPE_insert() or
+sk_push() can "grow" the size of an internal array and cause race conditions
+if the same stack is accessed in a different thread. Operations such as
+sk_find() and sk_sort() can also reorder the stack.
+
+Any comparison function supplied should use a metric suitable
+for use in a binary search operation. That is it should return zero, a
+positive or negative value if B<a> is equal to, greater than
+or less than B<b> respectively.
+
+Care should be taken when checking the return values of the functions
+sk_TYPE_find() and sk_TYPE_find_ex(). They return an index to the
+matching element. In particular B<0> indicates a matching first element.
+A failed search is indicated by a B<-1> return value.
+
+=head1 RETURN VALUES
+
+sk_TYPE_num() returns the number of elements in the stack or B<-1> if the
+passed stack is B<NULL>.
+
+sk_TYPE_value() returns a pointer to a stack element or B<NULL> if the
+index is out of range.
+
+sk_TYPE_new() and sk_TYPE_new_null() return an empty stack or B<NULL> if
+an error occurs.
+
+sk_TYPE_set_cmp_func() returns the old comparison function or B<NULL> if
+there was no old comparison function.
+
+sk_TYPE_free(), sk_TYPE_zero(), sk_TYPE_pop_free() and sk_TYPE_sort() do
+not return values.
+
+sk_TYPE_pop(), sk_TYPE_shift(), sk_TYPE_delete() and sk_TYPE_delete_ptr()
+return a pointer to the deleted element or B<NULL> on error.
+
+sk_TYPE_insert(), sk_TYPE_push() and sk_TYPE_unshift() return the total
+number of elements in the stack and 0 if an error occurred.
+
+sk_TYPE_set() returns a pointer to the replacement element or B<NULL> on
+error.
+
+sk_TYPE_find() and sk_TYPE_find_ex() return an index to the found element
+or B<-1> on error.
+
+sk_TYPE_is_sorted() returns B<1> if the stack is sorted and B<0> if it is
+not.
+
+sk_TYPE_dup() and sk_TYPE_deep_copy() return a pointer to the copy of the
+stack.
+
+=head1 HISTORY
+
+Before OpenSSL 1.1.0, this was implemented via macros and not inline functions
+and was not a public API.
+
+=head1 COPYRIGHT
+
+Copyright 2000-2016 The OpenSSL Project Authors. All Rights Reserved.
+
+Licensed under the OpenSSL license (the "License").  You may not use
+this file except in compliance with the License.  You can obtain a copy
+in the file LICENSE in the source distribution or at
+L<https://www.openssl.org/source/license.html>.
+
+=cut
index 158300f..7c568ac 100644 (file)
 extern "C" {
 #endif
 
-typedef struct lhash_node_st {
-    void *data;
-    struct lhash_node_st *next;
-    unsigned long hash;
-} LHASH_NODE;
-
-typedef int (*LHASH_COMP_FN_TYPE) (const void *, const void *);
-typedef unsigned long (*LHASH_HASH_FN_TYPE) (const void *);
-typedef void (*LHASH_DOALL_FN_TYPE) (void *);
-typedef void (*LHASH_DOALL_ARG_FN_TYPE) (void *, void *);
+typedef struct lhash_node_st OPENSSL_LH_NODE;
+typedef int (*OPENSSL_LH_COMPFUNC) (const void *, const void *);
+typedef unsigned long (*OPENSSL_LH_HASHFUNC) (const void *);
+typedef void (*OPENSSL_LH_DOALL_FUNC) (void *);
+typedef void (*OPENSSL_LH_DOALL_FUNCARG) (void *, void *);
+typedef struct lhash_st OPENSSL_LHASH;
 
 /*
  * Macros for declaring and implementing type-safe wrappers for LHASH
@@ -70,62 +66,53 @@ typedef void (*LHASH_DOALL_ARG_FN_TYPE) (void *, void *);
                 name##_doall_arg(a, b); }
 # define LHASH_DOALL_ARG_FN(name) name##_LHASH_DOALL_ARG
 
-typedef struct lhash_st {
-    LHASH_NODE **b;
-    LHASH_COMP_FN_TYPE comp;
-    LHASH_HASH_FN_TYPE hash;
-    unsigned int num_nodes;
-    unsigned int num_alloc_nodes;
-    unsigned int p;
-    unsigned int pmax;
-    unsigned long up_load;      /* load times 256 */
-    unsigned long down_load;    /* load times 256 */
-    unsigned long num_items;
-    unsigned long num_expands;
-    unsigned long num_expand_reallocs;
-    unsigned long num_contracts;
-    unsigned long num_contract_reallocs;
-    unsigned long num_hash_calls;
-    unsigned long num_comp_calls;
-    unsigned long num_insert;
-    unsigned long num_replace;
-    unsigned long num_delete;
-    unsigned long num_no_delete;
-    unsigned long num_retrieve;
-    unsigned long num_retrieve_miss;
-    unsigned long num_hash_comps;
-    int error;
-} _LHASH;                       /* Do not use _LHASH directly, use LHASH_OF
-                                 * and friends */
 
 # define LH_LOAD_MULT    256
 
-/*
- * Indicates a malloc() error in the last call, this is only bad in
- * lh_insert().
- */
-int lh_error(_LHASH *lh);
-
-_LHASH *lh_new(LHASH_HASH_FN_TYPE h, LHASH_COMP_FN_TYPE c);
-void lh_free(_LHASH *lh);
-void *lh_insert(_LHASH *lh, void *data);
-void *lh_delete(_LHASH *lh, const void *data);
-void *lh_retrieve(_LHASH *lh, const void *data);
-void lh_doall(_LHASH *lh, LHASH_DOALL_FN_TYPE func);
-void lh_doall_arg(_LHASH *lh, LHASH_DOALL_ARG_FN_TYPE func, void *arg);
-unsigned long lh_strhash(const char *c);
-unsigned long lh_num_items(const _LHASH *lh);
-unsigned long lh_get_down_load(const _LHASH *lh);
-void lh_set_down_load(_LHASH *lh, unsigned long down_load);
+int OPENSSL_LH_error(OPENSSL_LHASH *lh);
+OPENSSL_LHASH *OPENSSL_LH_new(OPENSSL_LH_HASHFUNC h, OPENSSL_LH_COMPFUNC c);
+void OPENSSL_LH_free(OPENSSL_LHASH *lh);
+void *OPENSSL_LH_insert(OPENSSL_LHASH *lh, void *data);
+void *OPENSSL_LH_delete(OPENSSL_LHASH *lh, const void *data);
+void *OPENSSL_LH_retrieve(OPENSSL_LHASH *lh, const void *data);
+void OPENSSL_LH_doall(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNC func);
+void OPENSSL_LH_doall_arg(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNCARG func, void *arg);
+unsigned long OPENSSL_LH_strhash(const char *c);
+unsigned long OPENSSL_LH_num_items(const OPENSSL_LHASH *lh);
+unsigned long OPENSSL_LH_get_down_load(const OPENSSL_LHASH *lh);
+void OPENSSL_LH_set_down_load(OPENSSL_LHASH *lh, unsigned long down_load);
 
 # ifndef OPENSSL_NO_STDIO
-void lh_stats(const _LHASH *lh, FILE *fp);
-void lh_node_stats(const _LHASH *lh, FILE *fp);
-void lh_node_usage_stats(const _LHASH *lh, FILE *fp);
+void OPENSSL_LH_stats(const OPENSSL_LHASH *lh, FILE *fp);
+void OPENSSL_LH_node_stats(const OPENSSL_LHASH *lh, FILE *fp);
+void OPENSSL_LH_node_usage_stats(const OPENSSL_LHASH *lh, FILE *fp);
+# endif
+void OPENSSL_LH_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
+void OPENSSL_LH_node_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
+void OPENSSL_LH_node_usage_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
+
+# if OPENSSL_API_COMPAT < 0x10100000L
+#  define _LHASH OPENSSL_LHASH
+#  define LHASH_NODE OPENSSL_LH_NODE
+#  define lh_error OPENSSL_LH_error
+#  define lh_new OPENSSL_lh_new
+#  define lh_free OPENSSL_LH_free
+#  define lh_insert OPENSSL_LH_insert
+#  define lh_delete OPENSSL_LH_delete
+#  define lh_retrieve OPENSSL_LH_retrieve
+#  define lh_doall OPENSSL_LH_doall
+#  define lh_doall_arg OPENSSL_LH_doall_arg
+#  define lh_strhash OPENSSL_LH_strhash
+#  define lh_num_items OPENSSL_LH_num_items
+#  ifndef OPENSSL_NO_STDIO
+#   define lh_stats OPENSSL_LH_stats
+#   define lh_node_stats OPENSSL_LH_node_stats
+#   define lh_node_usage_stats OPENSSL_LH_node_usage_stats
+#  endif
+#  define lh_stats_bio OPENSSL_LH_stats_bio
+#  define lh_node_stats_bio OPENSSL_LH_node_stats_bio
+#  define lh_node_usage_stats_bio OPENSSL_LH_node_usage_stats_bio
 # endif
-void lh_stats_bio(const _LHASH *lh, BIO *out);
-void lh_node_stats_bio(const _LHASH *lh, BIO *out);
-void lh_node_usage_stats_bio(const _LHASH *lh, BIO *out);
 
 /* Type checking... */
 
@@ -138,56 +125,56 @@ void lh_node_usage_stats_bio(const _LHASH *lh, BIO *out);
                         int (*cfn)(const type *, const type *)) \
     { \
         return (LHASH_OF(type) *) \
-            lh_new((LHASH_HASH_FN_TYPE) hfn, (LHASH_COMP_FN_TYPE)cfn); \
+            OPENSSL_LH_new((OPENSSL_LH_HASHFUNC)hfn, (OPENSSL_LH_COMPFUNC)cfn); \
     } \
     static ossl_inline void lh_##type##_free(LHASH_OF(type) *lh) \
     { \
-        lh_free((_LHASH *)lh); \
+        OPENSSL_LH_free((OPENSSL_LHASH *)lh); \
     } \
     static ossl_inline type *lh_##type##_insert(LHASH_OF(type) *lh, type *d) \
     { \
-        return (type *)lh_insert((_LHASH *)lh, d); \
+        return (type *)OPENSSL_LH_insert((OPENSSL_LHASH *)lh, d); \
     } \
     static ossl_inline type *lh_##type##_delete(LHASH_OF(type) *lh, const type *d) \
     { \
-        return (type *)lh_delete((_LHASH *)lh, d); \
+        return (type *)OPENSSL_LH_delete((OPENSSL_LHASH *)lh, d); \
     } \
     static ossl_inline type *lh_##type##_retrieve(LHASH_OF(type) *lh, const type *d) \
     { \
-        return (type *)lh_retrieve((_LHASH *)lh, d); \
+        return (type *)OPENSSL_LH_retrieve((OPENSSL_LHASH *)lh, d); \
     } \
     static ossl_inline int lh_##type##_error(LHASH_OF(type) *lh) \
     { \
-        return lh_error((_LHASH *)lh); \
+        return OPENSSL_LH_error((OPENSSL_LHASH *)lh); \
     } \
     static ossl_inline unsigned long lh_##type##_num_items(LHASH_OF(type) *lh) \
     { \
-        return lh_num_items((_LHASH *)lh); \
+        return OPENSSL_LH_num_items((OPENSSL_LHASH *)lh); \
     } \
     static ossl_inline void lh_##type##_node_stats_bio(const LHASH_OF(type) *lh, BIO *out) \
     { \
-        lh_node_stats_bio((_LHASH *)lh, out); \
+        OPENSSL_LH_node_stats_bio((OPENSSL_LHASH *)lh, out); \
     } \
     static ossl_inline void lh_##type##_node_usage_stats_bio(const LHASH_OF(type) *lh, BIO *out) \
     { \
-        lh_node_usage_stats_bio((_LHASH *)lh, out); \
+        OPENSSL_LH_node_usage_stats_bio((OPENSSL_LHASH *)lh, out); \
     } \
     static ossl_inline void lh_##type##_stats_bio(const LHASH_OF(type) *lh, BIO *out) \
     { \
-        lh_stats_bio((_LHASH *)lh, out); \
+        OPENSSL_LH_stats_bio((OPENSSL_LHASH *)lh, out); \
     } \
     static ossl_inline unsigned long lh_##type##_get_down_load(LHASH_OF(type) *lh) \
     { \
-        return lh_get_down_load((_LHASH *)lh); \
+        return OPENSSL_LH_get_down_load((OPENSSL_LHASH *)lh); \
     } \
     static ossl_inline void lh_##type##_set_down_load(LHASH_OF(type) *lh, unsigned long dl) \
     { \
-        lh_set_down_load((_LHASH *)lh, dl); \
+        OPENSSL_LH_set_down_load((OPENSSL_LHASH *)lh, dl); \
     } \
     static ossl_inline void lh_##type##_doall(LHASH_OF(type) *lh, \
                                          void (*doall)(type *)) \
     { \
-        lh_doall((_LHASH *)lh, (LHASH_DOALL_FN_TYPE)doall); \
+        OPENSSL_LH_doall((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNC)doall); \
     } \
     LHASH_OF(type)
 
@@ -203,17 +190,10 @@ void lh_node_usage_stats_bio(const _LHASH *lh, BIO *out);
                                    void (*fn)(cbargtype *, argtype *), \
                                    argtype *arg) \
     { \
-        lh_doall_arg((_LHASH *)lh, (LHASH_DOALL_ARG_FN_TYPE)fn, (void *)arg); \
+        OPENSSL_LH_doall_arg((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNCARG)fn, (void *)arg); \
     } \
     LHASH_OF(type)
 
-# define CHECKED_LHASH_OF(type,lh) \
-  ((_LHASH *)CHECKED_PTR_OF(LHASH_OF(type),lh))
-
-/* Define wrapper functions. */
-# define LHM_lh_doall_arg(type, lh, fn, arg_type, arg) \
-  lh_doall_arg(CHECKED_LHASH_OF(type, lh), fn, CHECKED_PTR_OF(arg_type, arg))
-
 DEFINE_LHASH_OF(OPENSSL_STRING);
 DEFINE_LHASH_OF(OPENSSL_CSTRING);
 
index e12f60d..d0af0eb 100644 (file)
 extern "C" {
 #endif
 
-# ifndef CHECKED_PTR_OF
-#  define CHECKED_PTR_OF(type, p) ((void*) (1 ? p : (type*)0))
-# endif
-
-/*
- * In C++ we get problems because an explicit cast is needed from (void *) we
- * use CHECKED_STACK_OF to ensure the correct type is passed in the macros
- * below.
- */
-
-# define CHECKED_STACK_OF(type, p) \
-    ((_STACK*) (1 ? p : (STACK_OF(type)*)0))
-
-# define CHECKED_SK_COPY_FUNC(type, p) \
-    ((void *(*)(void *)) ((1 ? p : (type *(*)(const type *))0)))
-
-# define CHECKED_SK_FREE_FUNC(type, p) \
-    ((void (*)(void *)) ((1 ? p : (void (*)(type *))0)))
-
-# define CHECKED_SK_CMP_FUNC(type, p) \
-    ((int (*)(const void *, const void *)) \
-        ((1 ? p : (int (*)(const type * const *, const type * const *))0)))
-
 # define STACK_OF(type) struct stack_st_##type
 
 # define SKM_DEFINE_STACK_OF(t1, t2, t3) \
     STACK_OF(t1); \
+    typedef int (*sk_##t1##_compfunc)(const t3 * const *a, const t3 *const *b); \
+    typedef void (*sk_##t1##_freefunc)(t3 *a); \
+    typedef t3 * (*sk_##t1##_copyfunc)(const t3 *a); \
     static ossl_inline int sk_##t1##_num(const STACK_OF(t1) *sk) \
     { \
-        return sk_num((const _STACK *)sk); \
+        return OPENSSL_sk_num((const OPENSSL_STACK *)sk); \
     } \
     static ossl_inline t2 *sk_##t1##_value(const STACK_OF(t1) *sk, int idx) \
     { \
-        return (t2 *)sk_value((const _STACK *)sk, idx); \
+        return (t2 *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); \
     } \
-    static ossl_inline STACK_OF(t1) *sk_##t1##_new(int (*cmpf)(const t3 * const *a, const t3 * const *b)) \
+    static ossl_inline STACK_OF(t1) *sk_##t1##_new(sk_##t1##_compfunc compare) \
     { \
-        return (STACK_OF(t1) *)sk_new((int (*)(const void *a, const void *b))cmpf); \
+        return (STACK_OF(t1) *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); \
     } \
     static ossl_inline STACK_OF(t1) *sk_##t1##_new_null(void) \
     { \
-        return (STACK_OF(t1) *)sk_new_null(); \
+        return (STACK_OF(t1) *)OPENSSL_sk_new_null(); \
     } \
     static ossl_inline void sk_##t1##_free(STACK_OF(t1) *sk) \
     { \
-        sk_free((_STACK *)sk); \
+        OPENSSL_sk_free((OPENSSL_STACK *)sk); \
     } \
     static ossl_inline void sk_##t1##_zero(STACK_OF(t1) *sk) \
     { \
-        sk_zero((_STACK *)sk); \
+        OPENSSL_sk_zero((OPENSSL_STACK *)sk); \
     } \
     static ossl_inline t2 *sk_##t1##_delete(STACK_OF(t1) *sk, int i) \
     { \
-        return (t2 *)sk_delete((_STACK *)sk, i); \
+        return (t2 *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); \
     } \
     static ossl_inline t2 *sk_##t1##_delete_ptr(STACK_OF(t1) *sk, t2 *ptr) \
     { \
-        return (t2 *)sk_delete_ptr((_STACK *)sk, (void *)ptr); \
+        return (t2 *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (void *)ptr); \
     } \
     static ossl_inline int sk_##t1##_push(STACK_OF(t1) *sk, t2 *ptr) \
     { \
-        return sk_push((_STACK *)sk, (void *)ptr); \
+        return OPENSSL_sk_push((OPENSSL_STACK *)sk, (void *)ptr); \
     } \
     static ossl_inline int sk_##t1##_unshift(STACK_OF(t1) *sk, t2 *ptr) \
     { \
-        return sk_unshift((_STACK *)sk, (void *)ptr); \
+        return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (void *)ptr); \
     } \
     static ossl_inline t2 *sk_##t1##_pop(STACK_OF(t1) *sk) \
     { \
-        return (t2 *)sk_pop((_STACK *)sk); \
+        return (t2 *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); \
     } \
     static ossl_inline t2 *sk_##t1##_shift(STACK_OF(t1) *sk) \
     { \
-        return (t2 *)sk_shift((_STACK *)sk); \
+        return (t2 *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); \
     } \
-    static ossl_inline void sk_##t1##_pop_free(STACK_OF(t1) *sk, void (*func)(t3 *a)) \
+    static ossl_inline void sk_##t1##_pop_free(STACK_OF(t1) *sk, sk_##t1##_freefunc freefunc) \
     { \
-        sk_pop_free((_STACK *)sk, (void (*)(void *))func); \
+        OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); \
     } \
     static ossl_inline int sk_##t1##_insert(STACK_OF(t1) *sk, t2 *ptr, int idx) \
     { \
-        return sk_insert((_STACK *)sk, (void *)ptr, idx); \
+        return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (void *)ptr, idx); \
     } \
     static ossl_inline t2 *sk_##t1##_set(STACK_OF(t1) *sk, int idx, t2 *ptr) \
     { \
-        return (t2 *)sk_set((_STACK *)sk, idx, (void *)ptr); \
+        return (t2 *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (void *)ptr); \
     } \
     static ossl_inline int sk_##t1##_find(STACK_OF(t1) *sk, t2 *ptr) \
     { \
-        return sk_find((_STACK *)sk, (void *)ptr); \
+        return OPENSSL_sk_find((OPENSSL_STACK *)sk, (void *)ptr); \
     } \
     static ossl_inline int sk_##t1##_find_ex(STACK_OF(t1) *sk, t2 *ptr) \
     { \
-        return sk_find_ex((_STACK *)sk, (void *)ptr); \
+        return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (void *)ptr); \
     } \
     static ossl_inline void sk_##t1##_sort(STACK_OF(t1) *sk) \
     { \
-        sk_sort((_STACK *)sk); \
+        OPENSSL_sk_sort((OPENSSL_STACK *)sk); \
     } \
     static ossl_inline int sk_##t1##_is_sorted(const STACK_OF(t1) *sk) \
     { \
-        return sk_is_sorted((const _STACK *)sk); \
+        return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); \
     } \
     static ossl_inline STACK_OF(t1) * sk_##t1##_dup(STACK_OF(t1) *sk) \
     { \
-        return (STACK_OF(t1) *)sk_dup((_STACK *)sk); \
+        return (STACK_OF(t1) *)OPENSSL_sk_dup((OPENSSL_STACK *)sk); \
     } \
     static ossl_inline STACK_OF(t1) *sk_##t1##_deep_copy(STACK_OF(t1) *sk, \
-                                                    t3 *(*copyfn)(const t3 *), \
-                                                    void (*freefn)(t3 *)) \
+                                                    sk_##t1##_copyfunc copyfunc, \
+                                                    sk_##t1##_freefunc freefunc) \
     { \
-        return (STACK_OF(t1) *)sk_deep_copy((_STACK *)sk, \
-                                            (void * (*)(void *a))copyfn, \
-                                            (void (*)(void *a))freefn); \
+        return (STACK_OF(t1) *)OPENSSL_sk_deep_copy((OPENSSL_STACK *)sk, \
+                                            (OPENSSL_sk_copyfunc)copyfunc, \
+                                            (OPENSSL_sk_freefunc)freefunc); \
     } \
-    static ossl_inline int (*sk_##t1##_set_cmp_func(STACK_OF(t1) *sk, int (*cmpf)(const t3 * const *a, const t3 * const *b)))(const t3 * const *, const t3 * const *) \
+    static ossl_inline sk_##t1##_compfunc sk_##t1##_set_cmp_func(STACK_OF(t1) *sk, sk_##t1##_compfunc compare) \
     { \
-        return (int (*)(const t3 * const *,const t3 * const *))sk_set_cmp_func((_STACK *)sk, (int (*)(const void *a, const void *b))cmpf); \
+        return (sk_##t1##_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); \
     }
 
 # define DEFINE_SPECIAL_STACK_OF(t1, t2) SKM_DEFINE_STACK_OF(t1, t2, t2)
index 5a90de6..6fab33b 100644 (file)
 extern "C" {
 #endif
 
-typedef struct stack_st _STACK; /* Use STACK_OF(...) instead */
-
-int sk_num(const _STACK *);
-void *sk_value(const _STACK *, int);
-
-void *sk_set(_STACK *, int, void *);
-
-_STACK *sk_new(int (*cmp) (const void *, const void *));
-_STACK *sk_new_null(void);
-void sk_free(_STACK *);
-void sk_pop_free(_STACK *st, void (*func) (void *));
-_STACK *sk_deep_copy(_STACK *, void *(*)(void *), void (*)(void *));
-int sk_insert(_STACK *sk, void *data, int where);
-void *sk_delete(_STACK *st, int loc);
-void *sk_delete_ptr(_STACK *st, void *p);
-int sk_find(_STACK *st, void *data);
-int sk_find_ex(_STACK *st, void *data);
-int sk_push(_STACK *st, void *data);
-int sk_unshift(_STACK *st, void *data);
-void *sk_shift(_STACK *st);
-void *sk_pop(_STACK *st);
-void sk_zero(_STACK *st);
-int (*sk_set_cmp_func(_STACK *sk, int (*c) (const void *, const void *)))
- (const void *, const void *);
-_STACK *sk_dup(_STACK *st);
-void sk_sort(_STACK *st);
-int sk_is_sorted(const _STACK *st);
+typedef struct stack_st OPENSSL_STACK; /* Use STACK_OF(...) instead */
+
+typedef int (*OPENSSL_sk_compfunc)(const void *, const void *);
+typedef void (*OPENSSL_sk_freefunc)(void *);
+typedef void *(*OPENSSL_sk_copyfunc)(const void *);
+
+int OPENSSL_sk_num(const OPENSSL_STACK *);
+void *OPENSSL_sk_value(const OPENSSL_STACK *, int);
+
+void *OPENSSL_sk_set(OPENSSL_STACK *, int, void *);
+
+OPENSSL_STACK *OPENSSL_sk_new(OPENSSL_sk_compfunc cmp);
+OPENSSL_STACK *OPENSSL_sk_new_null(void);
+void OPENSSL_sk_free(OPENSSL_STACK *);
+void OPENSSL_sk_pop_free(OPENSSL_STACK *st, void (*func) (void *));
+OPENSSL_STACK *OPENSSL_sk_deep_copy(OPENSSL_STACK *, OPENSSL_sk_copyfunc c, OPENSSL_sk_freefunc f);
+int OPENSSL_sk_insert(OPENSSL_STACK *sk, void *data, int where);
+void *OPENSSL_sk_delete(OPENSSL_STACK *st, int loc);
+void *OPENSSL_sk_delete_ptr(OPENSSL_STACK *st, void *p);
+int OPENSSL_sk_find(OPENSSL_STACK *st, void *data);
+int OPENSSL_sk_find_ex(OPENSSL_STACK *st, void *data);
+int OPENSSL_sk_push(OPENSSL_STACK *st, void *data);
+int OPENSSL_sk_unshift(OPENSSL_STACK *st, void *data);
+void *OPENSSL_sk_shift(OPENSSL_STACK *st);
+void *OPENSSL_sk_pop(OPENSSL_STACK *st);
+void OPENSSL_sk_zero(OPENSSL_STACK *st);
+OPENSSL_sk_compfunc OPENSSL_sk_set_cmp_func(OPENSSL_STACK *sk, OPENSSL_sk_compfunc cmp);
+OPENSSL_STACK *OPENSSL_sk_dup(OPENSSL_STACK *st);
+void OPENSSL_sk_sort(OPENSSL_STACK *st);
+int OPENSSL_sk_is_sorted(const OPENSSL_STACK *st);
+
+# if OPENSSL_API_COMPAT < 0x10100000L
+#  define _STACK OPENSSL_STACK
+#  define sk_num OPENSSL_sk_num
+#  define sk_value OPENSSL_sk_value
+#  define sk_set OPENSSL_sk_set
+#  define sk_new OPENSSL_sk_new
+#  define sk_new_null OPENSSL_sk_new_null
+#  define sk_free OPENSSL_sk_free
+#  define sk_pop_free OPENSSL_sk_pop_free
+#  define sk_deep_copy OPENSSL_sk_deep_copy
+#  define sk_insert OPENSSL_sk_insert
+#  define sk_delete OPENSSL_sk_delete
+#  define sk_delete_ptr OPENSSL_sk_delete_ptr
+#  define sk_find OPENSSL_sk_find
+#  define sk_find_ex OPENSSL_sk_find_ex
+#  define sk_push OPENSSL_sk_push
+#  define sk_unshift OPENSSL_sk_unshift
+#  define sk_shift OPENSSL_sk_shift
+#  define sk_pop OPENSSL_sk_pop
+#  define sk_zero OPENSSL_sk_zero
+#  define sk_set_cmp_func OPENSSL_sk_set_cmp_func
+#  define sk_dup OPENSSL_sk_dup
+#  define sk_sort OPENSSL_sk_sort
+#  define sk_is_sorted OPENSSL_sk_is_sorted
+# endif
 
 #ifdef  __cplusplus
 }
index a12d62f..0e6c943 100644 (file)
@@ -44,7 +44,7 @@ typedef struct txt_db_st {
 TXT_DB *TXT_DB_read(BIO *in, int num);
 long TXT_DB_write(BIO *out, TXT_DB *db);
 int TXT_DB_create_index(TXT_DB *db, int field, int (*qual) (OPENSSL_STRING *),
-                        LHASH_HASH_FN_TYPE hash, LHASH_COMP_FN_TYPE cmp);
+                        OPENSSL_LH_HASHFUNC hash, OPENSSL_LH_COMPFUNC cmp);
 void TXT_DB_free(TXT_DB *db);
 OPENSSL_STRING *TXT_DB_get_by_index(TXT_DB *db, int idx,
                                     OPENSSL_STRING *value);
index f602134..f168900 100644 (file)
@@ -977,10 +977,10 @@ void SSL_CTX_flush_sessions(SSL_CTX *s, long t)
         return;
     tp.time = t;
     CRYPTO_THREAD_write_lock(s->lock);
-    i = CHECKED_LHASH_OF(SSL_SESSION, tp.cache)->down_load;
-    CHECKED_LHASH_OF(SSL_SESSION, tp.cache)->down_load = 0;
+    i = lh_SSL_SESSION_get_down_load(s->sessions);
+    lh_SSL_SESSION_set_down_load(s->sessions, 0);
     lh_SSL_SESSION_doall_TIMEOUT_PARAM(tp.cache, timeout_cb, &tp);
-    CHECKED_LHASH_OF(SSL_SESSION, tp.cache)->down_load = i;
+    lh_SSL_SESSION_set_down_load(s->sessions, i);
     CRYPTO_THREAD_unlock(s->lock);
 }
 
index 9511d90..ccd37f8 100644 (file)
@@ -348,7 +348,7 @@ X509_NAME_cmp                           343 1_1_0   EXIST::FUNCTION:
 DIST_POINT_it                           344    1_1_0   EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:
 DIST_POINT_it                           344    1_1_0   EXIST:EXPORT_VAR_AS_FUNCTION:FUNCTION:
 PEM_read_X509_CRL                       345    1_1_0   EXIST::FUNCTION:
-sk_sort                                 346    1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_sort                         346    1_1_0   EXIST::FUNCTION:
 CTLOG_STORE_load_file                   347    1_1_0   EXIST::FUNCTION:CT
 ASN1_SEQUENCE_it                        348    1_1_0   EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:
 ASN1_SEQUENCE_it                        348    1_1_0   EXIST:EXPORT_VAR_AS_FUNCTION:FUNCTION:
@@ -489,7 +489,7 @@ X509_CRL_sort                           480 1_1_0   EXIST::FUNCTION:
 i2d_RSA_PUBKEY_bio                      481    1_1_0   EXIST::FUNCTION:RSA
 ASN1_T61STRING_free                     482    1_1_0   EXIST::FUNCTION:
 PEM_write_CMS                           483    1_1_0   EXIST::FUNCTION:CMS
-sk_find                                 484    1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_find                         484    1_1_0   EXIST::FUNCTION:
 ENGINE_get_ciphers                      485    1_1_0   EXIST::FUNCTION:ENGINE
 EVP_rc2_ofb                             486    1_1_0   EXIST::FUNCTION:RC2
 EVP_PKEY_set1_RSA                       487    1_1_0   EXIST::FUNCTION:RSA
@@ -746,7 +746,7 @@ EC_POINT_hex2point                      727 1_1_0   EXIST::FUNCTION:EC
 X509v3_get_ext_by_critical              728    1_1_0   EXIST::FUNCTION:
 ENGINE_get_default_RSA                  729    1_1_0   EXIST::FUNCTION:ENGINE
 DSA_sign_setup                          730    1_1_0   EXIST::FUNCTION:DSA
-sk_new_null                             731    1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_new_null                     731    1_1_0   EXIST::FUNCTION:
 PEM_read_PKCS8                          732    1_1_0   EXIST::FUNCTION:
 BN_mod_sqr                              733    1_1_0   EXIST::FUNCTION:
 CAST_ofb64_encrypt                      734    1_1_0   EXIST::FUNCTION:CAST
@@ -761,7 +761,7 @@ ENGINE_get_pkey_meth_engine             742 1_1_0   EXIST::FUNCTION:ENGINE
 OCSP_BASICRESP_free                     743    1_1_0   EXIST::FUNCTION:OCSP
 BN_set_params                           744    1_1_0   EXIST::FUNCTION:DEPRECATEDIN_0_9_8
 BN_add                                  745    1_1_0   EXIST::FUNCTION:
-sk_free                                 746    1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_free                         746    1_1_0   EXIST::FUNCTION:
 TS_TST_INFO_get_ext_d2i                 747    1_1_0   EXIST::FUNCTION:TS
 RSA_check_key                           748    1_1_0   EXIST::FUNCTION:RSA
 TS_MSG_IMPRINT_set_algo                 749    1_1_0   EXIST::FUNCTION:TS
@@ -859,7 +859,7 @@ CRYPTO_gcm128_new                       838 1_1_0   EXIST::FUNCTION:
 SMIME_read_PKCS7                        839    1_1_0   EXIST::FUNCTION:
 EC_GROUP_copy                           840    1_1_0   EXIST::FUNCTION:EC
 ENGINE_set_ciphers                      841    1_1_0   EXIST::FUNCTION:ENGINE
-lh_doall_arg                            842    1_1_0   EXIST::FUNCTION:
+OPENSSL_LH_doall_arg                    842    1_1_0   EXIST::FUNCTION:
 OCSP_REQUEST_get_ext_by_NID             843    1_1_0   EXIST::FUNCTION:OCSP
 X509_REQ_get_attr_by_NID                844    1_1_0   EXIST::FUNCTION:
 PBE2PARAM_new                           845    1_1_0   EXIST::FUNCTION:
@@ -923,7 +923,7 @@ PKCS7_add_recipient                     899 1_1_0   EXIST::FUNCTION:
 OCSP_SINGLERESP_add_ext                 900    1_1_0   EXIST::FUNCTION:OCSP
 d2i_X509_SIG                            901    1_1_0   EXIST::FUNCTION:
 X509_NAME_set                           902    1_1_0   EXIST::FUNCTION:
-sk_pop                                  903    1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_pop                          903    1_1_0   EXIST::FUNCTION:
 ENGINE_register_ciphers                 904    1_1_0   EXIST::FUNCTION:ENGINE
 PKCS5_pbe2_set_iv                       905    1_1_0   EXIST::FUNCTION:
 ASN1_add_stable_module                  906    1_1_0   EXIST::FUNCTION:
@@ -1044,12 +1044,12 @@ i2d_DSA_PUBKEY_fp                       1014    1_1_0   EXIST::FUNCTION:DSA,STDIO
 X509at_get_attr_by_OBJ                  1015   1_1_0   EXIST::FUNCTION:
 EVP_MD_CTX_copy_ex                      1016   1_1_0   EXIST::FUNCTION:
 UI_dup_error_string                     1017   1_1_0   EXIST::FUNCTION:UI
-lh_num_items                            1018   1_1_0   EXIST::FUNCTION:
+OPENSSL_LH_num_items                    1018   1_1_0   EXIST::FUNCTION:
 ERR_get_err_state_table                 1019   1_1_0   NOEXIST::FUNCTION:
 ASN1_INTEGER_cmp                        1020   1_1_0   EXIST::FUNCTION:
 X509_NAME_entry_count                   1021   1_1_0   EXIST::FUNCTION:
 UI_method_set_closer                    1022   1_1_0   EXIST::FUNCTION:UI
-lh_get_down_load                        1023   1_1_0   EXIST::FUNCTION:
+OPENSSL_LH_get_down_load                1023   1_1_0   EXIST::FUNCTION:
 EVP_md4                                 1024   1_1_0   EXIST::FUNCTION:MD4
 X509_set_subject_name                   1025   1_1_0   EXIST::FUNCTION:
 i2d_PKCS8PrivateKey_nid_bio             1026   1_1_0   EXIST::FUNCTION:
@@ -1103,7 +1103,7 @@ X509_EXTENSION_set_data                 1071      1_1_0   EXIST::FUNCTION:
 ENGINE_get_EC                           1072   1_1_0   EXIST::FUNCTION:ENGINE
 ASN1_STRING_copy                        1073   1_1_0   EXIST::FUNCTION:
 EVP_PKEY_encrypt_old                    1074   1_1_0   EXIST::FUNCTION:
-lh_free                                 1075   1_1_0   EXIST::FUNCTION:
+OPENSSL_LH_free                         1075   1_1_0   EXIST::FUNCTION:
 DES_is_weak_key                         1076   1_1_0   EXIST::FUNCTION:DES
 EVP_PKEY_verify                         1077   1_1_0   EXIST::FUNCTION:
 ERR_load_BIO_strings                    1078   1_1_0   EXIST::FUNCTION:
@@ -1241,7 +1241,7 @@ OPENSSL_uni2asc                         1205      1_1_0   EXIST::FUNCTION:
 SCT_validation_status_string            1206   1_1_0   EXIST::FUNCTION:CT
 PKCS7_add_attribute                     1207   1_1_0   EXIST::FUNCTION:
 ENGINE_register_DSA                     1208   1_1_0   EXIST::FUNCTION:ENGINE
-lh_node_stats                           1209   1_1_0   EXIST::FUNCTION:STDIO
+OPENSSL_LH_node_stats                   1209   1_1_0   EXIST::FUNCTION:STDIO
 X509_policy_tree_free                   1210   1_1_0   EXIST::FUNCTION:
 EC_GFp_simple_method                    1211   1_1_0   EXIST::FUNCTION:EC
 X509_it                                 1212   1_1_0   EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:
@@ -1293,7 +1293,7 @@ EVP_aes_192_gcm                         1255      1_1_0   EXIST::FUNCTION:
 TS_CONF_set_tsa_name                    1256   1_1_0   EXIST::FUNCTION:TS
 X509_email_free                         1257   1_1_0   EXIST::FUNCTION:
 BIO_get_callback                        1258   1_1_0   EXIST::FUNCTION:
-sk_shift                                1259   1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_shift                        1259   1_1_0   EXIST::FUNCTION:
 i2d_X509_REVOKED                        1260   1_1_0   EXIST::FUNCTION:
 CMS_sign                                1261   1_1_0   EXIST::FUNCTION:CMS
 X509_STORE_add_cert                     1262   1_1_0   EXIST::FUNCTION:
@@ -1388,7 +1388,7 @@ BIO_f_linebuffer                        1346      1_1_0   EXIST::FUNCTION:
 ASN1_item_d2i_bio                       1347   1_1_0   EXIST::FUNCTION:
 ENGINE_get_flags                        1348   1_1_0   EXIST::FUNCTION:ENGINE
 OCSP_resp_find                          1349   1_1_0   EXIST::FUNCTION:OCSP
-lh_node_usage_stats_bio                 1350   1_1_0   EXIST::FUNCTION:
+OPENSSL_LH_node_usage_stats_bio         1350   1_1_0   EXIST::FUNCTION:
 EVP_PKEY_encrypt                        1351   1_1_0   EXIST::FUNCTION:
 CRYPTO_cfb128_8_encrypt                 1352   1_1_0   EXIST::FUNCTION:
 SXNET_get_id_INTEGER                    1353   1_1_0   EXIST::FUNCTION:
@@ -1410,7 +1410,7 @@ d2i_X509_VAL                            1368      1_1_0   EXIST::FUNCTION:
 _shadow_DES_rw_mode                     1369   1_1_0   NOEXIST::FUNCTION:
 CRYPTO_gcm128_decrypt_ctr32             1370   1_1_0   EXIST::FUNCTION:
 DHparams_print                          1371   1_1_0   EXIST::FUNCTION:DH
-sk_unshift                              1372   1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_unshift                      1372   1_1_0   EXIST::FUNCTION:
 BN_GENCB_set_old                        1373   1_1_0   EXIST::FUNCTION:
 PEM_write_bio_X509                      1374   1_1_0   EXIST::FUNCTION:
 EVP_PKEY_asn1_free                      1375   1_1_0   EXIST::FUNCTION:
@@ -1606,7 +1606,7 @@ EVP_MD_meth_set_app_datasize            1560      1_1_0   EXIST::FUNCTION:
 DSO_free                                1561   1_1_0   EXIST::FUNCTION:
 TS_TST_INFO_get_tsa                     1562   1_1_0   EXIST::FUNCTION:TS
 EC_GROUP_check                          1563   1_1_0   EXIST::FUNCTION:EC
-sk_delete                               1564   1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_delete                       1564   1_1_0   EXIST::FUNCTION:
 TS_RESP_CTX_set_extension_cb            1565   1_1_0   EXIST::FUNCTION:TS
 EVP_CIPHER_CTX_nid                      1566   1_1_0   EXIST::FUNCTION:
 TS_RESP_CTX_add_md                      1567   1_1_0   EXIST::FUNCTION:TS
@@ -1797,7 +1797,7 @@ EVP_PKEY_CTX_hex2ctrl                   1747      1_1_0   EXIST::FUNCTION:
 PEM_write_bio_PKCS8PrivateKey           1748   1_1_0   EXIST::FUNCTION:
 CMAC_Update                             1749   1_1_0   EXIST::FUNCTION:CMAC
 d2i_ASN1_UTCTIME                        1750   1_1_0   EXIST::FUNCTION:
-sk_insert                               1751   1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_insert                       1751   1_1_0   EXIST::FUNCTION:
 DSO_up_ref                              1752   1_1_0   EXIST::FUNCTION:
 EVP_rc2_cbc                             1753   1_1_0   EXIST::FUNCTION:RC2
 i2d_NETSCAPE_SPKI                       1754   1_1_0   EXIST::FUNCTION:
@@ -1861,7 +1861,7 @@ ASN1_BIT_STRING_new                     1808      1_1_0   EXIST::FUNCTION:
 BIO_new_file                            1809   1_1_0   EXIST::FUNCTION:
 PKCS7_SIGNER_INFO_get0_algs             1810   1_1_0   EXIST::FUNCTION:
 TS_RESP_set_status_info                 1811   1_1_0   EXIST::FUNCTION:TS
-lh_delete                               1812   1_1_0   EXIST::FUNCTION:
+OPENSSL_LH_delete                       1812   1_1_0   EXIST::FUNCTION:
 TS_STATUS_INFO_dup                      1813   1_1_0   EXIST::FUNCTION:TS
 X509v3_addr_get_range                   1814   1_1_0   EXIST::FUNCTION:RFC3779
 X509_EXTENSION_get_data                 1815   1_1_0   EXIST::FUNCTION:
@@ -1876,7 +1876,7 @@ X509_get_ext_by_critical                1823      1_1_0   EXIST::FUNCTION:
 ASYNC_WAIT_CTX_clear_fd                 1824   1_1_0   EXIST::FUNCTION:
 ZLONG_it                                1825   1_1_0   EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:
 ZLONG_it                                1825   1_1_0   EXIST:EXPORT_VAR_AS_FUNCTION:FUNCTION:
-sk_find_ex                              1826   1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_find_ex                      1826   1_1_0   EXIST::FUNCTION:
 ASN1_ENUMERATED_to_BN                   1827   1_1_0   EXIST::FUNCTION:
 X509_CRL_get_ext_d2i                    1828   1_1_0   EXIST::FUNCTION:
 i2d_AUTHORITY_KEYID                     1829   1_1_0   EXIST::FUNCTION:
@@ -1888,7 +1888,7 @@ ASN1_STRING_to_UTF8                     1833      1_1_0   EXIST::FUNCTION:
 DSO_METHOD_null                         1834   1_1_0   NOEXIST::FUNCTION:
 EVP_MD_meth_set_update                  1835   1_1_0   EXIST::FUNCTION:
 EVP_camellia_192_cbc                    1836   1_1_0   EXIST::FUNCTION:CAMELLIA
-lh_stats_bio                            1837   1_1_0   EXIST::FUNCTION:
+OPENSSL_LH_stats_bio                    1837   1_1_0   EXIST::FUNCTION:
 PKCS7_set_signed_attributes             1838   1_1_0   EXIST::FUNCTION:
 EC_KEY_priv2buf                         1839   1_1_0   EXIST::FUNCTION:EC
 BN_BLINDING_free                        1840   1_1_0   EXIST::FUNCTION:
@@ -1968,7 +1968,7 @@ SRP_Calc_B                              1910      1_1_0   EXIST::FUNCTION:SRP
 CMS_decrypt_set1_key                    1911   1_1_0   EXIST::FUNCTION:CMS
 EC_GROUP_get_degree                     1912   1_1_0   EXIST::FUNCTION:EC
 X509_ALGOR_set0                         1913   1_1_0   EXIST::FUNCTION:
-lh_set_down_load                        1914   1_1_0   EXIST::FUNCTION:
+OPENSSL_LH_set_down_load                1914   1_1_0   EXIST::FUNCTION:
 X509v3_asid_inherits                    1915   1_1_0   EXIST::FUNCTION:RFC3779
 EVP_MD_meth_get_app_datasize            1916   1_1_0   EXIST::FUNCTION:
 X509_STORE_CTX_get_num_untrusted        1917   1_1_0   EXIST::FUNCTION:
@@ -2067,7 +2067,7 @@ TS_REQ_get_version                      2006      1_1_0   EXIST::FUNCTION:TS
 BN_exp                                  2007   1_1_0   EXIST::FUNCTION:
 i2d_SXNET                               2008   1_1_0   EXIST::FUNCTION:
 OBJ_bsearch_                            2009   1_1_0   EXIST::FUNCTION:
-lh_new                                  2010   1_1_0   EXIST::FUNCTION:
+OPENSSL_LH_new                          2010   1_1_0   EXIST::FUNCTION:
 ENGINE_register_all_pkey_meths          2011   1_1_0   EXIST::FUNCTION:ENGINE
 ENGINE_get_init_function                2012   1_1_0   EXIST::FUNCTION:ENGINE
 EC_POINT_point2hex                      2013   1_1_0   EXIST::FUNCTION:EC
@@ -2080,7 +2080,7 @@ i2d_TS_REQ_fp                           2019      1_1_0   EXIST::FUNCTION:STDIO,TS
 i2d_OTHERNAME                           2020   1_1_0   EXIST::FUNCTION:
 EC_KEY_get0_private_key                 2021   1_1_0   EXIST::FUNCTION:EC
 SCT_get0_extensions                     2022   1_1_0   EXIST::FUNCTION:CT
-lh_node_stats_bio                       2023   1_1_0   EXIST::FUNCTION:
+OPENSSL_LH_node_stats_bio               2023   1_1_0   EXIST::FUNCTION:
 i2d_DIRECTORYSTRING                     2024   1_1_0   EXIST::FUNCTION:
 BN_X931_derive_prime_ex                 2025   1_1_0   EXIST::FUNCTION:
 ENGINE_get_pkey_asn1_meth_str           2026   1_1_0   EXIST::FUNCTION:ENGINE
@@ -2093,7 +2093,7 @@ UI_construct_prompt                     2032      1_1_0   EXIST::FUNCTION:UI
 ENGINE_unregister_RSA                   2033   1_1_0   EXIST::FUNCTION:ENGINE
 EC_GROUP_order_bits                     2034   1_1_0   EXIST::FUNCTION:EC
 d2i_CMS_bio                             2035   1_1_0   EXIST::FUNCTION:CMS
-sk_num                                  2036   1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_num                          2036   1_1_0   EXIST::FUNCTION:
 _shadow_DES_check_key                   2037   1_1_0   EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:DES
 _shadow_DES_check_key                   2037   1_1_0   EXIST:EXPORT_VAR_AS_FUNCTION:FUNCTION:DES
 CMS_RecipientInfo_set0_pkey             2038   1_1_0   EXIST::FUNCTION:CMS
@@ -2227,7 +2227,7 @@ PEM_write_X509                          2158      1_1_0   EXIST::FUNCTION:
 BN_CTX_free                             2159   1_1_0   EXIST::FUNCTION:
 EC_GROUP_get_curve_GF2m                 2160   1_1_0   EXIST::FUNCTION:EC,EC2M
 EVP_MD_flags                            2161   1_1_0   EXIST::FUNCTION:
-sk_set                                  2162   1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_set                          2162   1_1_0   EXIST::FUNCTION:
 OCSP_request_sign                       2163   1_1_0   EXIST::FUNCTION:OCSP
 BN_GF2m_mod_solve_quad                  2164   1_1_0   EXIST::FUNCTION:EC2M
 EC_POINT_method_of                      2165   1_1_0   EXIST::FUNCTION:EC
@@ -2282,7 +2282,7 @@ i2d_TS_ACCURACY                         2210      1_1_0   EXIST::FUNCTION:TS
 ASN1_VISIBLESTRING_free                 2211   1_1_0   EXIST::FUNCTION:
 NCONF_load_bio                          2212   1_1_0   EXIST::FUNCTION:
 DSA_get_default_method                  2213   1_1_0   EXIST::FUNCTION:DSA
-lh_retrieve                             2214   1_1_0   EXIST::FUNCTION:
+OPENSSL_LH_retrieve                     2214   1_1_0   EXIST::FUNCTION:
 CRYPTO_ccm128_decrypt_ccm64             2215   1_1_0   EXIST::FUNCTION:
 TS_RESP_CTX_set_clock_precision_digits  2216   1_1_0   EXIST::FUNCTION:TS
 SCT_LIST_validate                       2217   1_1_0   EXIST::FUNCTION:CT
@@ -2326,7 +2326,7 @@ CMS_signed_get_attr_by_NID              2253      1_1_0   EXIST::FUNCTION:CMS
 X509_STORE_CTX_get_by_subject           2254   1_1_0   EXIST::FUNCTION:
 ASN1_OCTET_STRING_it                    2255   1_1_0   EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:
 ASN1_OCTET_STRING_it                    2255   1_1_0   EXIST:EXPORT_VAR_AS_FUNCTION:FUNCTION:
-sk_set_cmp_func                         2256   1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_set_cmp_func                 2256   1_1_0   EXIST::FUNCTION:
 X509_VERIFY_PARAM_table_cleanup         2257   1_1_0   EXIST::FUNCTION:
 i2d_re_X509_REQ_tbs                     2258   1_1_0   EXIST::FUNCTION:
 CONF_load_bio                           2259   1_1_0   EXIST::FUNCTION:
@@ -2408,7 +2408,7 @@ EVP_aes_256_xts                         2333      1_1_0   EXIST::FUNCTION:
 EVP_DigestSignFinal                     2334   1_1_0   EXIST::FUNCTION:
 ASN1_STRING_cmp                         2335   1_1_0   EXIST::FUNCTION:
 EVP_chacha20_poly1305                   2336   1_1_0   EXIST::FUNCTION:CHACHA,POLY1305
-sk_zero                                 2337   1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_zero                         2337   1_1_0   EXIST::FUNCTION:
 ASN1_PRINTABLE_type                     2338   1_1_0   EXIST::FUNCTION:
 TS_CONF_set_ess_cert_id_chain           2339   1_1_0   EXIST::FUNCTION:TS
 PEM_read_DSAPrivateKey                  2340   1_1_0   EXIST::FUNCTION:DSA
@@ -2651,7 +2651,7 @@ EVP_sha256                              2569      1_1_0   EXIST::FUNCTION:
 CMS_unsigned_delete_attr                2570   1_1_0   EXIST::FUNCTION:CMS
 EVP_md5_sha1                            2571   1_1_0   EXIST::FUNCTION:MD5
 EVP_PKEY_sign_init                      2572   1_1_0   EXIST::FUNCTION:
-lh_insert                               2573   1_1_0   EXIST::FUNCTION:
+OPENSSL_LH_insert                       2573   1_1_0   EXIST::FUNCTION:
 EVP_CIPHER_meth_get_cleanup             2574   1_1_0   EXIST::FUNCTION:
 ASN1_item_ex_d2i                        2575   1_1_0   EXIST::FUNCTION:
 EVP_MD_meth_free                        2576   1_1_0   EXIST::FUNCTION:
@@ -2692,7 +2692,7 @@ EVP_DecodeUpdate                        2609      1_1_0   EXIST::FUNCTION:
 ENGINE_get_default_RAND                 2610   1_1_0   EXIST::FUNCTION:ENGINE
 ERR_peek_last_error_line                2611   1_1_0   EXIST::FUNCTION:
 ENGINE_get_ssl_client_cert_function     2612   1_1_0   EXIST::FUNCTION:ENGINE
-lh_node_usage_stats                     2613   1_1_0   EXIST::FUNCTION:STDIO
+OPENSSL_LH_node_usage_stats             2613   1_1_0   EXIST::FUNCTION:STDIO
 DIRECTORYSTRING_it                      2614   1_1_0   EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:
 DIRECTORYSTRING_it                      2614   1_1_0   EXIST:EXPORT_VAR_AS_FUNCTION:FUNCTION:
 BIO_write                               2615   1_1_0   EXIST::FUNCTION:
@@ -2740,7 +2740,7 @@ EVP_aes_256_cbc_hmac_sha1               2652      1_1_0   EXIST::FUNCTION:
 SCT_validate                            2653   1_1_0   EXIST::FUNCTION:CT
 EC_GROUP_dup                            2654   1_1_0   EXIST::FUNCTION:EC
 EVP_sha1                                2655   1_1_0   EXIST::FUNCTION:
-sk_new                                  2656   1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_new                          2656   1_1_0   EXIST::FUNCTION:
 BN_dup                                  2657   1_1_0   EXIST::FUNCTION:
 TS_MSG_IMPRINT_print_bio                2658   1_1_0   EXIST::FUNCTION:TS
 CONF_module_set_usr_data                2659   1_1_0   EXIST::FUNCTION:
@@ -2872,7 +2872,7 @@ RSAPrivateKey_it                        2777      1_1_0   EXIST:EXPORT_VAR_AS_FUNCTION:
 X509_NAME_ENTRY_free                    2778   1_1_0   EXIST::FUNCTION:
 BIO_new_fd                              2779   1_1_0   EXIST::FUNCTION:
 ENGINE_cleanup                          2780   1_1_0   NOEXIST::FUNCTION:
-sk_value                                2781   1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_value                        2781   1_1_0   EXIST::FUNCTION:
 NCONF_get_section                       2782   1_1_0   EXIST::FUNCTION:
 PKCS12_MAC_DATA_it                      2783   1_1_0   EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:
 PKCS12_MAC_DATA_it                      2783   1_1_0   EXIST:EXPORT_VAR_AS_FUNCTION:FUNCTION:
@@ -3219,7 +3219,7 @@ i2s_ASN1_ENUMERATED                     3112      1_1_0   EXIST::FUNCTION:
 X509v3_get_ext_by_OBJ                   3113   1_1_0   EXIST::FUNCTION:
 OCSP_REQUEST_free                       3114   1_1_0   EXIST::FUNCTION:OCSP
 CRYPTO_ocb128_aad                       3115   1_1_0   EXIST::FUNCTION:OCB
-sk_deep_copy                            3116   1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_deep_copy                    3116   1_1_0   EXIST::FUNCTION:
 i2d_RSA_PSS_PARAMS                      3117   1_1_0   EXIST::FUNCTION:RSA
 EVP_aes_128_wrap_pad                    3118   1_1_0   EXIST::FUNCTION:
 ASN1_BIT_STRING_set                     3119   1_1_0   EXIST::FUNCTION:
@@ -3247,10 +3247,10 @@ TXT_DB_free                             3139    1_1_0   EXIST::FUNCTION:
 ASN1_STRING_set                         3140   1_1_0   EXIST::FUNCTION:
 d2i_ESS_CERT_ID                         3141   1_1_0   EXIST::FUNCTION:TS
 EVP_PKEY_meth_set_derive                3142   1_1_0   EXIST::FUNCTION:
-lh_stats                                3143   1_1_0   EXIST::FUNCTION:STDIO
+OPENSSL_LH_stats                        3143   1_1_0   EXIST::FUNCTION:STDIO
 NCONF_dump_fp                           3144   1_1_0   EXIST::FUNCTION:STDIO
 TS_STATUS_INFO_print_bio                3145   1_1_0   EXIST::FUNCTION:TS
-sk_dup                                  3146   1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_dup                          3146   1_1_0   EXIST::FUNCTION:
 BF_cfb64_encrypt                        3147   1_1_0   EXIST::FUNCTION:BF
 ASN1_GENERALIZEDTIME_adj                3148   1_1_0   EXIST::FUNCTION:
 ECDSA_verify                            3149   1_1_0   EXIST::FUNCTION:EC
@@ -3391,7 +3391,7 @@ CRYPTO_set_mem_debug                    3282      1_1_0   EXIST::FUNCTION:
 TS_VERIFY_CTX_init                      3283   1_1_0   EXIST::FUNCTION:TS
 OCSP_cert_id_new                        3284   1_1_0   EXIST::FUNCTION:OCSP
 GENERAL_SUBTREE_new                     3285   1_1_0   EXIST::FUNCTION:
-sk_push                                 3286   1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_push                         3286   1_1_0   EXIST::FUNCTION:
 X509_LOOKUP_ctrl                        3287   1_1_0   EXIST::FUNCTION:
 SRP_check_known_gN_param                3288   1_1_0   EXIST::FUNCTION:SRP
 d2i_DIST_POINT                          3289   1_1_0   EXIST::FUNCTION:
@@ -3411,7 +3411,7 @@ DSA_SIG_free                            3301      1_1_0   EXIST::FUNCTION:DSA
 BIO_asn1_set_suffix                     3302   1_1_0   EXIST::FUNCTION:
 EVP_PKEY_set_type_str                   3303   1_1_0   EXIST::FUNCTION:
 i2d_X509_SIG                            3304   1_1_0   EXIST::FUNCTION:
-lh_strhash                              3305   1_1_0   EXIST::FUNCTION:
+OPENSSL_LH_strhash                      3305   1_1_0   EXIST::FUNCTION:
 X509_STORE_CTX_set_trust                3306   1_1_0   EXIST::FUNCTION:
 TS_ACCURACY_set_micros                  3307   1_1_0   EXIST::FUNCTION:TS
 EVP_DigestFinal_ex                      3308   1_1_0   EXIST::FUNCTION:
@@ -3460,7 +3460,7 @@ ASN1_SEQUENCE_ANY_it                    3350      1_1_0   EXIST:!EXPORT_VAR_AS_FUNCTION
 ASN1_SEQUENCE_ANY_it                    3350   1_1_0   EXIST:EXPORT_VAR_AS_FUNCTION:FUNCTION:
 ASN1_UTCTIME_adj                        3351   1_1_0   EXIST::FUNCTION:
 BN_mod_sqrt                             3352   1_1_0   EXIST::FUNCTION:
-sk_is_sorted                            3353   1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_is_sorted                    3353   1_1_0   EXIST::FUNCTION:
 OCSP_SIGNATURE_new                      3354   1_1_0   EXIST::FUNCTION:OCSP
 EVP_PKEY_meth_get_paramgen              3355   1_1_0   EXIST::FUNCTION:
 X509_ATTRIBUTE_create_by_OBJ            3356   1_1_0   EXIST::FUNCTION:
@@ -3488,7 +3488,7 @@ PKCS12_PBE_add                          3376      1_1_0   EXIST::FUNCTION:
 EC_KEY_set_public_key_affine_coordinates 3377  1_1_0   EXIST::FUNCTION:EC
 EVP_EncryptInit_ex                      3378   1_1_0   EXIST::FUNCTION:
 ENGINE_add                              3379   1_1_0   EXIST::FUNCTION:ENGINE
-lh_error                                3380   1_1_0   EXIST::FUNCTION:
+OPENSSL_LH_error                        3380   1_1_0   EXIST::FUNCTION:
 PKCS7_DIGEST_it                         3381   1_1_0   EXIST:!EXPORT_VAR_AS_FUNCTION:VARIABLE:
 PKCS7_DIGEST_it                         3381   1_1_0   EXIST:EXPORT_VAR_AS_FUNCTION:FUNCTION:
 X509_CINF_new                           3382   1_1_0   EXIST::FUNCTION:
@@ -3839,7 +3839,7 @@ X509_VERIFY_PARAM_free                  3721      1_1_0   EXIST::FUNCTION:
 ASN1_TYPE_new                           3722   1_1_0   EXIST::FUNCTION:
 CMAC_CTX_cleanup                        3723   1_1_0   EXIST::FUNCTION:CMAC
 i2d_PKCS7_NDEF                          3724   1_1_0   EXIST::FUNCTION:
-sk_pop_free                             3725   1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_pop_free                     3725   1_1_0   EXIST::FUNCTION:
 X509_STORE_CTX_get0_policy_tree         3726   1_1_0   EXIST::FUNCTION:
 DES_set_key_checked                     3727   1_1_0   EXIST::FUNCTION:DES
 EVP_PKEY_meth_free                      3728   1_1_0   EXIST::FUNCTION:
@@ -4001,7 +4001,7 @@ X509_get_default_cert_dir               3875      1_1_0   EXIST::FUNCTION:
 DSO_get_method                          3876   1_1_0   NOEXIST::FUNCTION:
 PROXY_POLICY_free                       3877   1_1_0   EXIST::FUNCTION:
 PEM_write_DSAPrivateKey                 3878   1_1_0   EXIST::FUNCTION:DSA
-sk_delete_ptr                           3879   1_1_0   EXIST::FUNCTION:
+OPENSSL_sk_delete_ptr                   3879   1_1_0   EXIST::FUNCTION:
 CMS_add0_RevocationInfoChoice           3880   1_1_0   EXIST::FUNCTION:CMS
 ASN1_PCTX_get_flags                     3881   1_1_0   EXIST::FUNCTION:
 EVP_MD_meth_set_result_size             3882   1_1_0   EXIST::FUNCTION:
@@ -4030,7 +4030,7 @@ EVP_PKEY_verify_recover_init            3902      1_1_0   EXIST::FUNCTION:
 SHA512_Init                             3903   1_1_0   EXIST:!VMSVAX:FUNCTION:
 TS_MSG_IMPRINT_set_msg                  3904   1_1_0   EXIST::FUNCTION:TS
 CMS_unsigned_add1_attr                  3905   1_1_0   EXIST::FUNCTION:CMS
-lh_doall                                3906   1_1_0   EXIST::FUNCTION:
+OPENSSL_LH_doall                        3906   1_1_0   EXIST::FUNCTION:
 PKCS8_pkey_get0_attrs                   3907   1_1_0   EXIST::FUNCTION:
 PKCS8_pkey_add1_attr_by_NID             3908   1_1_0   EXIST::FUNCTION:
 ASYNC_is_capable                        3909   1_1_0   EXIST::FUNCTION: