/work/include/openssl/lhash.h

Source (jump to first uncovered line)
/*
 * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (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
 */



/*
 * Header for dynamic hash table routines Author - Eric Young
 */

#ifndef OPENSSL_LHASH_H
# define OPENSSL_LHASH_H
# pragma once

# include <openssl/macros.h>
# ifndef OPENSSL_NO_DEPRECATED_3_0
#  define HEADER_LHASH_H
# endif

# include <openssl/e_os2.h>
# include <openssl/bio.h>

#ifdef  __cplusplus
extern "C" {
#endif

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
 * callbacks. This way, callbacks can be provided to LHASH structures without
 * function pointer casting and the macro-defined callbacks provide
 * per-variable casting before deferring to the underlying type-specific
 * callbacks. NB: It is possible to place a "static" in front of both the
 * DECLARE and IMPLEMENT macros if the functions are strictly internal.
 */

/* First: "hash" functions */
# define DECLARE_LHASH_HASH_FN(name, o_type) \
        unsigned long name##_LHASH_HASH(const void *);
# define IMPLEMENT_LHASH_HASH_FN(name, o_type) \
        unsigned long name##_LHASH_HASH(const void *arg) { \
                const o_type *a = arg; \
                return name##_hash(a); }
# define LHASH_HASH_FN(name) name##_LHASH_HASH

/* Second: "compare" functions */
# define DECLARE_LHASH_COMP_FN(name, o_type) \
        int name##_LHASH_COMP(const void *, const void *);
# define IMPLEMENT_LHASH_COMP_FN(name, o_type) \
        int name##_LHASH_COMP(const void *arg1, const void *arg2) { \
                const o_type *a = arg1;             \
                const o_type *b = arg2; \
                return name##_cmp(a,b); }
# define LHASH_COMP_FN(name) name##_LHASH_COMP

/* Fourth: "doall_arg" functions */
# define DECLARE_LHASH_DOALL_ARG_FN(name, o_type, a_type) \
        void name##_LHASH_DOALL_ARG(void *, void *);
# define IMPLEMENT_LHASH_DOALL_ARG_FN(name, o_type, a_type) \
        void name##_LHASH_DOALL_ARG(void *arg1, void *arg2) { \
                o_type *a = arg1; \
                a_type *b = arg2; \
                name##_doall_arg(a, b); }
# define LHASH_DOALL_ARG_FN(name) name##_LHASH_DOALL_ARG


# define LH_LOAD_MULT    256

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_flush(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 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);

# ifndef OPENSSL_NO_DEPRECATED_1_1_0
#  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

/* Type checking... */

# define LHASH_OF(type) struct lhash_st_##type

/* Helper macro for internal use */
# define DEFINE_LHASH_OF_INTERNAL(type) \
    LHASH_OF(type) { union lh_##type##_dummy { void* d1; unsigned long d2; int d3; } dummy; }; \
    typedef int (*lh_##type##_compfunc)(const type *a, const type *b); \
    typedef unsigned long (*lh_##type##_hashfunc)(const type *a); \
    typedef void (*lh_##type##_doallfunc)(type *a); \
    static ossl_unused ossl_inline type *ossl_check_##type##_lh_plain_type(type *ptr) \
    { \
        return ptr; \
    } \
    static ossl_unused ossl_inline const type *ossl_check_const_##type##_lh_plain_type(const type *ptr) \
    { \
        return ptr; \
    } \
    static ossl_unused ossl_inline const OPENSSL_LHASH *ossl_check_const_##type##_lh_type(const LHASH_OF(type) *lh) \
    { \
        return (const OPENSSL_LHASH *)lh; \
    } \
    static ossl_unused ossl_inline OPENSSL_LHASH *ossl_check_##type##_lh_type(LHASH_OF(type) *lh) \
    { \
        return (OPENSSL_LHASH *)lh; \
    } \
    static ossl_unused ossl_inline OPENSSL_LH_COMPFUNC ossl_check_##type##_lh_compfunc_type(lh_##type##_compfunc cmp) \
    { \
        return (OPENSSL_LH_COMPFUNC)cmp; \
    } \
    static ossl_unused ossl_inline OPENSSL_LH_HASHFUNC ossl_check_##type##_lh_hashfunc_type(lh_##type##_hashfunc hfn) \
    { \
        return (OPENSSL_LH_HASHFUNC)hfn; \
    } \
    static ossl_unused ossl_inline OPENSSL_LH_DOALL_FUNC ossl_check_##type##_lh_doallfunc_type(lh_##type##_doallfunc dfn) \
    { \
        return (OPENSSL_LH_DOALL_FUNC)dfn; \
    } \
    LHASH_OF(type)

# define DEFINE_LHASH_OF(type) \
    LHASH_OF(type) { union lh_##type##_dummy { void* d1; unsigned long d2; int d3; } dummy; }; \
    static ossl_unused ossl_inline LHASH_OF(type) *lh_##type##_new(unsigned long (*hfn)(const type *), \
                                                                   int (*cfn)(const type *, const type *)) \
    { \
        return (LHASH_OF(type) *) \
            OPENSSL_LH_new((OPENSSL_LH_HASHFUNC)hfn, (OPENSSL_LH_COMPFUNC)cfn); \
    } \
    static ossl_unused ossl_inline void lh_##type##_free(LHASH_OF(type) *lh) \
    { \
        OPENSSL_LH_free((OPENSSL_LHASH *)lh); \
    } \
    static ossl_unused ossl_inline void lh_##type##_flush(LHASH_OF(type) *lh) \
    { \
        OPENSSL_LH_flush((OPENSSL_LHASH *)lh); \
    } \
    static ossl_unused ossl_inline type *lh_##type##_insert(LHASH_OF(type) *lh, type *d) \
    { \
        return (type *)OPENSSL_LH_insert((OPENSSL_LHASH *)lh, d); \
    } \
    static ossl_unused ossl_inline type *lh_##type##_delete(LHASH_OF(type) *lh, const type *d) \
    { \
        return (type *)OPENSSL_LH_delete((OPENSSL_LHASH *)lh, d); \
    } \
    static ossl_unused ossl_inline type *lh_##type##_retrieve(LHASH_OF(type) *lh, const type *d) \
    { \
        return (type *)OPENSSL_LH_retrieve((OPENSSL_LHASH *)lh, d); \
    } \
    static ossl_unused ossl_inline int lh_##type##_error(LHASH_OF(type) *lh) \
    { \
        return OPENSSL_LH_error((OPENSSL_LHASH *)lh); \
    } \
    static ossl_unused ossl_inline unsigned long lh_##type##_num_items(LHASH_OF(type) *lh) \
    { \
        return OPENSSL_LH_num_items((OPENSSL_LHASH *)lh); \
    } \
    static ossl_unused ossl_inline void lh_##type##_node_stats_bio(const LHASH_OF(type) *lh, BIO *out) \
    { \
        OPENSSL_LH_node_stats_bio((const OPENSSL_LHASH *)lh, out); \
    } \
    static ossl_unused ossl_inline void lh_##type##_node_usage_stats_bio(const LHASH_OF(type) *lh, BIO *out) \
    { \
        OPENSSL_LH_node_usage_stats_bio((const OPENSSL_LHASH *)lh, out); \
    } \
    static ossl_unused ossl_inline void lh_##type##_stats_bio(const LHASH_OF(type) *lh, BIO *out) \
    { \
        OPENSSL_LH_stats_bio((const OPENSSL_LHASH *)lh, out); \
    } \
    static ossl_unused ossl_inline unsigned long lh_##type##_get_down_load(LHASH_OF(type) *lh) \
    { \
        return OPENSSL_LH_get_down_load((OPENSSL_LHASH *)lh); \
    } \
    static ossl_unused ossl_inline void lh_##type##_set_down_load(LHASH_OF(type) *lh, unsigned long dl) \
    { \
        OPENSSL_LH_set_down_load((OPENSSL_LHASH *)lh, dl); \
    } \
    static ossl_unused ossl_inline void lh_##type##_doall(LHASH_OF(type) *lh, \
                                                          void (*doall)(type *)) \
    { \
        OPENSSL_LH_doall((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNC)doall); \
    } \
    static ossl_unused ossl_inline void lh_##type##_doall_arg(LHASH_OF(type) *lh, \
                                                              void (*doallarg)(type *, void *), \
                                                              void *arg) \
    { \
        OPENSSL_LH_doall_arg((OPENSSL_LHASH *)lh, \
                             (OPENSSL_LH_DOALL_FUNCARG)doallarg, arg); \
    } \
    LHASH_OF(type)

#define IMPLEMENT_LHASH_DOALL_ARG_CONST(type, argtype) \
    int_implement_lhash_doall(type, argtype, const type)

#define IMPLEMENT_LHASH_DOALL_ARG(type, argtype) \
    int_implement_lhash_doall(type, argtype, type)

#define int_implement_lhash_doall(type, argtype, cbargtype) \
    static ossl_unused ossl_inline void \
        lh_##type##_doall_##argtype(LHASH_OF(type) *lh, \
                                   void (*fn)(cbargtype *, argtype *), \
                                   argtype *arg) \
    { \
        OPENSSL_LH_doall_arg((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNCARG)fn, (void *)arg); \
    } \
    LHASH_OF(type)

DEFINE_LHASH_OF_INTERNAL(OPENSSL_STRING);
#define lh_OPENSSL_STRING_new(hfn, cmp) ((LHASH_OF(OPENSSL_STRING) *)OPENSSL_LH_new(ossl_check_OPENSSL_STRING_lh_hashfunc_type(hfn), ossl_check_OPENSSL_STRING_lh_compfunc_type(cmp)))
#define lh_OPENSSL_STRING_free(lh) OPENSSL_LH_free(ossl_check_OPENSSL_STRING_lh_type(lh))
#define lh_OPENSSL_STRING_flush(lh) OPENSSL_LH_flush(ossl_check_OPENSSL_STRING_lh_type(lh))
#define lh_OPENSSL_STRING_insert(lh, ptr) ((OPENSSL_STRING *)OPENSSL_LH_insert(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_OPENSSL_STRING_lh_plain_type(ptr)))
#define lh_OPENSSL_STRING_delete(lh, ptr) ((OPENSSL_STRING *)OPENSSL_LH_delete(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_const_OPENSSL_STRING_lh_plain_type(ptr)))
#define lh_OPENSSL_STRING_retrieve(lh, ptr) ((OPENSSL_STRING *)OPENSSL_LH_retrieve(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_const_OPENSSL_STRING_lh_plain_type(ptr)))
#define lh_OPENSSL_STRING_error(lh) OPENSSL_LH_error(ossl_check_OPENSSL_STRING_lh_type(lh))
#define lh_OPENSSL_STRING_num_items(lh) OPENSSL_LH_num_items(ossl_check_OPENSSL_STRING_lh_type(lh))
#define lh_OPENSSL_STRING_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_OPENSSL_STRING_lh_type(lh), out)
#define lh_OPENSSL_STRING_node_usage_stats_bio(lh, out) OPENSSL_LH_node_usage_stats_bio(ossl_check_const_OPENSSL_STRING_lh_type(lh), out)
#define lh_OPENSSL_STRING_stats_bio(lh, out) OPENSSL_LH_stats_bio(ossl_check_const_OPENSSL_STRING_lh_type(lh), out)
#define lh_OPENSSL_STRING_get_down_load(lh) OPENSSL_LH_get_down_load(ossl_check_OPENSSL_STRING_lh_type(lh))
#define lh_OPENSSL_STRING_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_OPENSSL_STRING_lh_type(lh), dl)
#define lh_OPENSSL_STRING_doall(lh, dfn) OPENSSL_LH_doall(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_OPENSSL_STRING_lh_doallfunc_type(dfn))
DEFINE_LHASH_OF_INTERNAL(OPENSSL_CSTRING);
#define lh_OPENSSL_CSTRING_new(hfn, cmp) ((LHASH_OF(OPENSSL_CSTRING) *)OPENSSL_LH_new(ossl_check_OPENSSL_CSTRING_lh_hashfunc_type(hfn), ossl_check_OPENSSL_CSTRING_lh_compfunc_type(cmp)))
#define lh_OPENSSL_CSTRING_free(lh) OPENSSL_LH_free(ossl_check_OPENSSL_CSTRING_lh_type(lh))
#define lh_OPENSSL_CSTRING_flush(lh) OPENSSL_LH_flush(ossl_check_OPENSSL_CSTRING_lh_type(lh))
#define lh_OPENSSL_CSTRING_insert(lh, ptr) ((OPENSSL_CSTRING *)OPENSSL_LH_insert(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_OPENSSL_CSTRING_lh_plain_type(ptr)))
#define lh_OPENSSL_CSTRING_delete(lh, ptr) ((OPENSSL_CSTRING *)OPENSSL_LH_delete(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_const_OPENSSL_CSTRING_lh_plain_type(ptr)))
#define lh_OPENSSL_CSTRING_retrieve(lh, ptr) ((OPENSSL_CSTRING *)OPENSSL_LH_retrieve(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_const_OPENSSL_CSTRING_lh_plain_type(ptr)))
#define lh_OPENSSL_CSTRING_error(lh) OPENSSL_LH_error(ossl_check_OPENSSL_CSTRING_lh_type(lh))
#define lh_OPENSSL_CSTRING_num_items(lh) OPENSSL_LH_num_items(ossl_check_OPENSSL_CSTRING_lh_type(lh))
#define lh_OPENSSL_CSTRING_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_OPENSSL_CSTRING_lh_type(lh), out)
#define lh_OPENSSL_CSTRING_node_usage_stats_bio(lh, out) OPENSSL_LH_node_usage_stats_bio(ossl_check_const_OPENSSL_CSTRING_lh_type(lh), out)
#define lh_OPENSSL_CSTRING_stats_bio(lh, out) OPENSSL_LH_stats_bio(ossl_check_const_OPENSSL_CSTRING_lh_type(lh), out)
#define lh_OPENSSL_CSTRING_get_down_load(lh) OPENSSL_LH_get_down_load(ossl_check_OPENSSL_CSTRING_lh_type(lh))
#define lh_OPENSSL_CSTRING_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_OPENSSL_CSTRING_lh_type(lh), dl)
#define lh_OPENSSL_CSTRING_doall(lh, dfn) OPENSSL_LH_doall(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_OPENSSL_CSTRING_lh_doallfunc_type(dfn))


#ifdef  __cplusplus
}
#endif

#endif

Coverage Report

Created: 2025-04-22 06:18

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
3		*
4		* Licensed under the Apache License 2.0 (the "License"). You may not use
5		* this file except in compliance with the License. You can obtain a copy
6		* in the file LICENSE in the source distribution or at
7		* https://www.openssl.org/source/license.html
8		*/
9
10
11
12		/*
13		* Header for dynamic hash table routines Author - Eric Young
14		*/
15
16		#ifndef OPENSSL_LHASH_H
17		# define OPENSSL_LHASH_H
18		# pragma once
19
20		# include <openssl/macros.h>
21		# ifndef OPENSSL_NO_DEPRECATED_3_0
22		# define HEADER_LHASH_H
23		# endif
24
25		# include <openssl/e_os2.h>
26		# include <openssl/bio.h>
27
28		#ifdef __cplusplus
29		extern "C" {
30		#endif
31
32		typedef struct lhash_node_st OPENSSL_LH_NODE;
33		typedef int (OPENSSL_LH_COMPFUNC) (const void , const void *);
34		typedef unsigned long (OPENSSL_LH_HASHFUNC) (const void );
35		typedef void (OPENSSL_LH_DOALL_FUNC) (void );
36		typedef void (OPENSSL_LH_DOALL_FUNCARG) (void , void *);
37		typedef struct lhash_st OPENSSL_LHASH;
38
39		/*
40		* Macros for declaring and implementing type-safe wrappers for LHASH
41		* callbacks. This way, callbacks can be provided to LHASH structures without
42		* function pointer casting and the macro-defined callbacks provide
43		* per-variable casting before deferring to the underlying type-specific
44		* callbacks. NB: It is possible to place a "static" in front of both the
45		* DECLARE and IMPLEMENT macros if the functions are strictly internal.
46		*/
47
48		/* First: "hash" functions */
49		# define DECLARE_LHASH_HASH_FN(name, o_type) \
50		unsigned long name##_LHASH_HASH(const void *);
51		# define IMPLEMENT_LHASH_HASH_FN(name, o_type) \
52		unsigned long name##_LHASH_HASH(const void *arg) { \
53		const o_type *a = arg; \
54		return name##_hash(a); }
55		# define LHASH_HASH_FN(name) name##_LHASH_HASH
56
57		/* Second: "compare" functions */
58		# define DECLARE_LHASH_COMP_FN(name, o_type) \
59		int name##_LHASH_COMP(const void , const void );
60		# define IMPLEMENT_LHASH_COMP_FN(name, o_type) \
61		int name##_LHASH_COMP(const void arg1, const void arg2) { \
62		const o_type *a = arg1; \
63		const o_type *b = arg2; \
64		return name##_cmp(a,b); }
65		# define LHASH_COMP_FN(name) name##_LHASH_COMP
66
67		/* Fourth: "doall_arg" functions */
68		# define DECLARE_LHASH_DOALL_ARG_FN(name, o_type, a_type) \
69		void name##_LHASH_DOALL_ARG(void , void );
70		# define IMPLEMENT_LHASH_DOALL_ARG_FN(name, o_type, a_type) \
71		void name##_LHASH_DOALL_ARG(void arg1, void arg2) { \
72		o_type *a = arg1; \
73		a_type *b = arg2; \
74		name##_doall_arg(a, b); }
75		# define LHASH_DOALL_ARG_FN(name) name##_LHASH_DOALL_ARG
76
77
78		# define LH_LOAD_MULT 256
79
80		int OPENSSL_LH_error(OPENSSL_LHASH *lh);
81		OPENSSL_LHASH *OPENSSL_LH_new(OPENSSL_LH_HASHFUNC h, OPENSSL_LH_COMPFUNC c);
82		void OPENSSL_LH_free(OPENSSL_LHASH *lh);
83		void OPENSSL_LH_flush(OPENSSL_LHASH *lh);
84		void OPENSSL_LH_insert(OPENSSL_LHASH lh, void *data);
85		void OPENSSL_LH_delete(OPENSSL_LHASH lh, const void *data);
86		void OPENSSL_LH_retrieve(OPENSSL_LHASH lh, const void *data);
87		void OPENSSL_LH_doall(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNC func);
88		void OPENSSL_LH_doall_arg(OPENSSL_LHASH lh, OPENSSL_LH_DOALL_FUNCARG func, void arg);
89		unsigned long OPENSSL_LH_strhash(const char *c);
90		unsigned long OPENSSL_LH_num_items(const OPENSSL_LHASH *lh);
91		unsigned long OPENSSL_LH_get_down_load(const OPENSSL_LHASH *lh);
92		void OPENSSL_LH_set_down_load(OPENSSL_LHASH *lh, unsigned long down_load);
93
94		# ifndef OPENSSL_NO_STDIO
95		void OPENSSL_LH_stats(const OPENSSL_LHASH lh, FILE fp);
96		void OPENSSL_LH_node_stats(const OPENSSL_LHASH lh, FILE fp);
97		void OPENSSL_LH_node_usage_stats(const OPENSSL_LHASH lh, FILE fp);
98		# endif
99		void OPENSSL_LH_stats_bio(const OPENSSL_LHASH lh, BIO out);
100		void OPENSSL_LH_node_stats_bio(const OPENSSL_LHASH lh, BIO out);
101		void OPENSSL_LH_node_usage_stats_bio(const OPENSSL_LHASH lh, BIO out);
102
103		# ifndef OPENSSL_NO_DEPRECATED_1_1_0
104		# define _LHASH OPENSSL_LHASH
105		# define LHASH_NODE OPENSSL_LH_NODE
106		# define lh_error OPENSSL_LH_error
107		# define lh_new OPENSSL_LH_new
108		# define lh_free OPENSSL_LH_free
109		# define lh_insert OPENSSL_LH_insert
110		# define lh_delete OPENSSL_LH_delete
111		# define lh_retrieve OPENSSL_LH_retrieve
112		# define lh_doall OPENSSL_LH_doall
113		# define lh_doall_arg OPENSSL_LH_doall_arg
114		# define lh_strhash OPENSSL_LH_strhash
115		# define lh_num_items OPENSSL_LH_num_items
116		# ifndef OPENSSL_NO_STDIO
117		# define lh_stats OPENSSL_LH_stats
118		# define lh_node_stats OPENSSL_LH_node_stats
119		# define lh_node_usage_stats OPENSSL_LH_node_usage_stats
120		# endif
121		# define lh_stats_bio OPENSSL_LH_stats_bio
122		# define lh_node_stats_bio OPENSSL_LH_node_stats_bio
123		# define lh_node_usage_stats_bio OPENSSL_LH_node_usage_stats_bio
124		# endif
125
126		/* Type checking... */
127
128		# define LHASH_OF(type) struct lhash_st_##type
129
130		/* Helper macro for internal use */
131		# define DEFINE_LHASH_OF_INTERNAL(type) \
132		LHASH_OF(type) { union lh_##type##_dummy { void* d1; unsigned long d2; int d3; } dummy; }; \
133		typedef int (lh_##type##_compfunc)(const type a, const type *b); \
134		typedef unsigned long (lh_##type##_hashfunc)(const type a); \
135		typedef void (lh_##type##_doallfunc)(type a); \
136		static ossl_unused ossl_inline type ossl_check_##type##_lh_plain_type(type ptr) \
137	0	{ \
138	0	return ptr; \
139	0	} \ Unexecuted instantiation: cred.c:ossl_check_OPENSSL_STRING_lh_plain_type Unexecuted instantiation: cred.c:ossl_check_OPENSSL_CSTRING_lh_plain_type Unexecuted instantiation: cred.c:ossl_check_CONF_VALUE_lh_plain_type Unexecuted instantiation: u2f.c:ossl_check_OPENSSL_STRING_lh_plain_type Unexecuted instantiation: u2f.c:ossl_check_OPENSSL_CSTRING_lh_plain_type Unexecuted instantiation: u2f.c:ossl_check_CONF_VALUE_lh_plain_type
140		static ossl_unused ossl_inline const type ossl_check_const_##type##_lh_plain_type(const type ptr) \
141	0	{ \
142	0	return ptr; \
143	0	} \ Unexecuted instantiation: cred.c:ossl_check_const_OPENSSL_STRING_lh_plain_type Unexecuted instantiation: cred.c:ossl_check_const_OPENSSL_CSTRING_lh_plain_type Unexecuted instantiation: cred.c:ossl_check_const_CONF_VALUE_lh_plain_type Unexecuted instantiation: u2f.c:ossl_check_const_OPENSSL_STRING_lh_plain_type Unexecuted instantiation: u2f.c:ossl_check_const_OPENSSL_CSTRING_lh_plain_type Unexecuted instantiation: u2f.c:ossl_check_const_CONF_VALUE_lh_plain_type
144		static ossl_unused ossl_inline const OPENSSL_LHASH ossl_check_const_##type##_lh_type(const LHASH_OF(type) lh) \
145	0	{ \
146	0	return (const OPENSSL_LHASH *)lh; \
147	0	} \ Unexecuted instantiation: cred.c:ossl_check_const_OPENSSL_STRING_lh_type Unexecuted instantiation: cred.c:ossl_check_const_OPENSSL_CSTRING_lh_type Unexecuted instantiation: cred.c:ossl_check_const_CONF_VALUE_lh_type Unexecuted instantiation: u2f.c:ossl_check_const_OPENSSL_STRING_lh_type Unexecuted instantiation: u2f.c:ossl_check_const_OPENSSL_CSTRING_lh_type Unexecuted instantiation: u2f.c:ossl_check_const_CONF_VALUE_lh_type
148		static ossl_unused ossl_inline OPENSSL_LHASH ossl_check_##type##_lh_type(LHASH_OF(type) lh) \
149	0	{ \
150	0	return (OPENSSL_LHASH *)lh; \
151	0	} \ Unexecuted instantiation: cred.c:ossl_check_OPENSSL_STRING_lh_type Unexecuted instantiation: cred.c:ossl_check_OPENSSL_CSTRING_lh_type Unexecuted instantiation: cred.c:ossl_check_CONF_VALUE_lh_type Unexecuted instantiation: u2f.c:ossl_check_OPENSSL_STRING_lh_type Unexecuted instantiation: u2f.c:ossl_check_OPENSSL_CSTRING_lh_type Unexecuted instantiation: u2f.c:ossl_check_CONF_VALUE_lh_type
152		static ossl_unused ossl_inline OPENSSL_LH_COMPFUNC ossl_check_##type##_lh_compfunc_type(lh_##type##_compfunc cmp) \
153	0	{ \
154	0	return (OPENSSL_LH_COMPFUNC)cmp; \
155	0	} \ Unexecuted instantiation: cred.c:ossl_check_OPENSSL_STRING_lh_compfunc_type Unexecuted instantiation: cred.c:ossl_check_OPENSSL_CSTRING_lh_compfunc_type Unexecuted instantiation: cred.c:ossl_check_CONF_VALUE_lh_compfunc_type Unexecuted instantiation: u2f.c:ossl_check_OPENSSL_STRING_lh_compfunc_type Unexecuted instantiation: u2f.c:ossl_check_OPENSSL_CSTRING_lh_compfunc_type Unexecuted instantiation: u2f.c:ossl_check_CONF_VALUE_lh_compfunc_type
156		static ossl_unused ossl_inline OPENSSL_LH_HASHFUNC ossl_check_##type##_lh_hashfunc_type(lh_##type##_hashfunc hfn) \
157	0	{ \
158	0	return (OPENSSL_LH_HASHFUNC)hfn; \
159	0	} \ Unexecuted instantiation: cred.c:ossl_check_OPENSSL_STRING_lh_hashfunc_type Unexecuted instantiation: cred.c:ossl_check_OPENSSL_CSTRING_lh_hashfunc_type Unexecuted instantiation: cred.c:ossl_check_CONF_VALUE_lh_hashfunc_type Unexecuted instantiation: u2f.c:ossl_check_OPENSSL_STRING_lh_hashfunc_type Unexecuted instantiation: u2f.c:ossl_check_OPENSSL_CSTRING_lh_hashfunc_type Unexecuted instantiation: u2f.c:ossl_check_CONF_VALUE_lh_hashfunc_type
160		static ossl_unused ossl_inline OPENSSL_LH_DOALL_FUNC ossl_check_##type##_lh_doallfunc_type(lh_##type##_doallfunc dfn) \
161	0	{ \
162	0	return (OPENSSL_LH_DOALL_FUNC)dfn; \
163	0	} \ Unexecuted instantiation: cred.c:ossl_check_OPENSSL_STRING_lh_doallfunc_type Unexecuted instantiation: cred.c:ossl_check_OPENSSL_CSTRING_lh_doallfunc_type Unexecuted instantiation: cred.c:ossl_check_CONF_VALUE_lh_doallfunc_type Unexecuted instantiation: u2f.c:ossl_check_OPENSSL_STRING_lh_doallfunc_type Unexecuted instantiation: u2f.c:ossl_check_OPENSSL_CSTRING_lh_doallfunc_type Unexecuted instantiation: u2f.c:ossl_check_CONF_VALUE_lh_doallfunc_type
164		LHASH_OF(type)
165
166		# define DEFINE_LHASH_OF(type) \
167		LHASH_OF(type) { union lh_##type##_dummy { void* d1; unsigned long d2; int d3; } dummy; }; \
168		static ossl_unused ossl_inline LHASH_OF(type) lh_##type##_new(unsigned long (hfn)(const type *), \
169		int (cfn)(const type , const type *)) \
170		{ \
171		return (LHASH_OF(type) *) \
172		OPENSSL_LH_new((OPENSSL_LH_HASHFUNC)hfn, (OPENSSL_LH_COMPFUNC)cfn); \
173		} \
174		static ossl_unused ossl_inline void lh_##type##_free(LHASH_OF(type) *lh) \
175		{ \
176		OPENSSL_LH_free((OPENSSL_LHASH *)lh); \
177		} \
178		static ossl_unused ossl_inline void lh_##type##_flush(LHASH_OF(type) *lh) \
179		{ \
180		OPENSSL_LH_flush((OPENSSL_LHASH *)lh); \
181		} \
182		static ossl_unused ossl_inline type lh_##type##_insert(LHASH_OF(type) lh, type *d) \
183		{ \
184		return (type )OPENSSL_LH_insert((OPENSSL_LHASH )lh, d); \
185		} \
186		static ossl_unused ossl_inline type lh_##type##_delete(LHASH_OF(type) lh, const type *d) \
187		{ \
188		return (type )OPENSSL_LH_delete((OPENSSL_LHASH )lh, d); \
189		} \
190		static ossl_unused ossl_inline type lh_##type##_retrieve(LHASH_OF(type) lh, const type *d) \
191		{ \
192		return (type )OPENSSL_LH_retrieve((OPENSSL_LHASH )lh, d); \
193		} \
194		static ossl_unused ossl_inline int lh_##type##_error(LHASH_OF(type) *lh) \
195		{ \
196		return OPENSSL_LH_error((OPENSSL_LHASH *)lh); \
197		} \
198		static ossl_unused ossl_inline unsigned long lh_##type##_num_items(LHASH_OF(type) *lh) \
199		{ \
200		return OPENSSL_LH_num_items((OPENSSL_LHASH *)lh); \
201		} \
202		static ossl_unused ossl_inline void lh_##type##_node_stats_bio(const LHASH_OF(type) lh, BIO out) \
203		{ \
204		OPENSSL_LH_node_stats_bio((const OPENSSL_LHASH *)lh, out); \
205		} \
206		static ossl_unused ossl_inline void lh_##type##_node_usage_stats_bio(const LHASH_OF(type) lh, BIO out) \
207		{ \
208		OPENSSL_LH_node_usage_stats_bio((const OPENSSL_LHASH *)lh, out); \
209		} \
210		static ossl_unused ossl_inline void lh_##type##_stats_bio(const LHASH_OF(type) lh, BIO out) \
211		{ \
212		OPENSSL_LH_stats_bio((const OPENSSL_LHASH *)lh, out); \
213		} \
214		static ossl_unused ossl_inline unsigned long lh_##type##_get_down_load(LHASH_OF(type) *lh) \
215		{ \
216		return OPENSSL_LH_get_down_load((OPENSSL_LHASH *)lh); \
217		} \
218		static ossl_unused ossl_inline void lh_##type##_set_down_load(LHASH_OF(type) *lh, unsigned long dl) \
219		{ \
220		OPENSSL_LH_set_down_load((OPENSSL_LHASH *)lh, dl); \
221		} \
222		static ossl_unused ossl_inline void lh_##type##_doall(LHASH_OF(type) *lh, \
223		void (doall)(type )) \
224		{ \
225		OPENSSL_LH_doall((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNC)doall); \
226		} \
227		static ossl_unused ossl_inline void lh_##type##_doall_arg(LHASH_OF(type) *lh, \
228		void (doallarg)(type , void *), \
229		void *arg) \
230		{ \
231		OPENSSL_LH_doall_arg((OPENSSL_LHASH *)lh, \
232		(OPENSSL_LH_DOALL_FUNCARG)doallarg, arg); \
233		} \
234		LHASH_OF(type)
235
236		#define IMPLEMENT_LHASH_DOALL_ARG_CONST(type, argtype) \
237		int_implement_lhash_doall(type, argtype, const type)
238
239		#define IMPLEMENT_LHASH_DOALL_ARG(type, argtype) \
240		int_implement_lhash_doall(type, argtype, type)
241
242		#define int_implement_lhash_doall(type, argtype, cbargtype) \
243		static ossl_unused ossl_inline void \
244		lh_##type##_doall_##argtype(LHASH_OF(type) *lh, \
245		void (fn)(cbargtype , argtype *), \
246		argtype *arg) \
247		{ \
248		OPENSSL_LH_doall_arg((OPENSSL_LHASH )lh, (OPENSSL_LH_DOALL_FUNCARG)fn, (void )arg); \
249		} \
250		LHASH_OF(type)
251
252		DEFINE_LHASH_OF_INTERNAL(OPENSSL_STRING);
253		#define lh_OPENSSL_STRING_new(hfn, cmp) ((LHASH_OF(OPENSSL_STRING) *)OPENSSL_LH_new(ossl_check_OPENSSL_STRING_lh_hashfunc_type(hfn), ossl_check_OPENSSL_STRING_lh_compfunc_type(cmp)))
254		#define lh_OPENSSL_STRING_free(lh) OPENSSL_LH_free(ossl_check_OPENSSL_STRING_lh_type(lh))
255		#define lh_OPENSSL_STRING_flush(lh) OPENSSL_LH_flush(ossl_check_OPENSSL_STRING_lh_type(lh))
256		#define lh_OPENSSL_STRING_insert(lh, ptr) ((OPENSSL_STRING *)OPENSSL_LH_insert(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_OPENSSL_STRING_lh_plain_type(ptr)))
257		#define lh_OPENSSL_STRING_delete(lh, ptr) ((OPENSSL_STRING *)OPENSSL_LH_delete(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_const_OPENSSL_STRING_lh_plain_type(ptr)))
258		#define lh_OPENSSL_STRING_retrieve(lh, ptr) ((OPENSSL_STRING *)OPENSSL_LH_retrieve(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_const_OPENSSL_STRING_lh_plain_type(ptr)))
259		#define lh_OPENSSL_STRING_error(lh) OPENSSL_LH_error(ossl_check_OPENSSL_STRING_lh_type(lh))
260		#define lh_OPENSSL_STRING_num_items(lh) OPENSSL_LH_num_items(ossl_check_OPENSSL_STRING_lh_type(lh))
261		#define lh_OPENSSL_STRING_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_OPENSSL_STRING_lh_type(lh), out)
262		#define lh_OPENSSL_STRING_node_usage_stats_bio(lh, out) OPENSSL_LH_node_usage_stats_bio(ossl_check_const_OPENSSL_STRING_lh_type(lh), out)
263		#define lh_OPENSSL_STRING_stats_bio(lh, out) OPENSSL_LH_stats_bio(ossl_check_const_OPENSSL_STRING_lh_type(lh), out)
264		#define lh_OPENSSL_STRING_get_down_load(lh) OPENSSL_LH_get_down_load(ossl_check_OPENSSL_STRING_lh_type(lh))
265		#define lh_OPENSSL_STRING_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_OPENSSL_STRING_lh_type(lh), dl)
266		#define lh_OPENSSL_STRING_doall(lh, dfn) OPENSSL_LH_doall(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_OPENSSL_STRING_lh_doallfunc_type(dfn))
267		DEFINE_LHASH_OF_INTERNAL(OPENSSL_CSTRING);
268		#define lh_OPENSSL_CSTRING_new(hfn, cmp) ((LHASH_OF(OPENSSL_CSTRING) *)OPENSSL_LH_new(ossl_check_OPENSSL_CSTRING_lh_hashfunc_type(hfn), ossl_check_OPENSSL_CSTRING_lh_compfunc_type(cmp)))
269		#define lh_OPENSSL_CSTRING_free(lh) OPENSSL_LH_free(ossl_check_OPENSSL_CSTRING_lh_type(lh))
270		#define lh_OPENSSL_CSTRING_flush(lh) OPENSSL_LH_flush(ossl_check_OPENSSL_CSTRING_lh_type(lh))
271		#define lh_OPENSSL_CSTRING_insert(lh, ptr) ((OPENSSL_CSTRING *)OPENSSL_LH_insert(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_OPENSSL_CSTRING_lh_plain_type(ptr)))
272		#define lh_OPENSSL_CSTRING_delete(lh, ptr) ((OPENSSL_CSTRING *)OPENSSL_LH_delete(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_const_OPENSSL_CSTRING_lh_plain_type(ptr)))
273		#define lh_OPENSSL_CSTRING_retrieve(lh, ptr) ((OPENSSL_CSTRING *)OPENSSL_LH_retrieve(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_const_OPENSSL_CSTRING_lh_plain_type(ptr)))
274		#define lh_OPENSSL_CSTRING_error(lh) OPENSSL_LH_error(ossl_check_OPENSSL_CSTRING_lh_type(lh))
275		#define lh_OPENSSL_CSTRING_num_items(lh) OPENSSL_LH_num_items(ossl_check_OPENSSL_CSTRING_lh_type(lh))
276		#define lh_OPENSSL_CSTRING_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_OPENSSL_CSTRING_lh_type(lh), out)
277		#define lh_OPENSSL_CSTRING_node_usage_stats_bio(lh, out) OPENSSL_LH_node_usage_stats_bio(ossl_check_const_OPENSSL_CSTRING_lh_type(lh), out)
278		#define lh_OPENSSL_CSTRING_stats_bio(lh, out) OPENSSL_LH_stats_bio(ossl_check_const_OPENSSL_CSTRING_lh_type(lh), out)
279		#define lh_OPENSSL_CSTRING_get_down_load(lh) OPENSSL_LH_get_down_load(ossl_check_OPENSSL_CSTRING_lh_type(lh))
280		#define lh_OPENSSL_CSTRING_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_OPENSSL_CSTRING_lh_type(lh), dl)
281		#define lh_OPENSSL_CSTRING_doall(lh, dfn) OPENSSL_LH_doall(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_OPENSSL_CSTRING_lh_doallfunc_type(dfn))
282
283
284		#ifdef __cplusplus
285		}
286		#endif
287
288		#endif