include/openssl/lhash.h

0001 /*
0002  * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
0003  *
0004  * Licensed under the Apache License 2.0 (the "License").  You may not use
0005  * this file except in compliance with the License.  You can obtain a copy
0006  * in the file LICENSE in the source distribution or at
0007  * https://www.openssl.org/source/license.html
0008  */
0009
0010
0011
0012 /*
0013  * Header for dynamic hash table routines Author - Eric Young
0014  */
0015
0016 #ifndef OPENSSL_LHASH_H
0017 # define OPENSSL_LHASH_H
0018 # pragma once
0019
0020 # include <openssl/macros.h>
0021 # ifndef OPENSSL_NO_DEPRECATED_3_0
0022 #  define HEADER_LHASH_H
0023 # endif
0024
0025 # include <openssl/e_os2.h>
0026 # include <openssl/bio.h>
0027 # ifndef OPENSSL_NO_STDIO
0028 #  include <stdio.h>
0029 # endif
0030
0031 #ifdef  __cplusplus
0032 extern "C" {
0033 #endif
0034
0035 typedef struct lhash_node_st OPENSSL_LH_NODE;
0036 typedef int (*OPENSSL_LH_COMPFUNC) (const void *, const void *);
0037 typedef int (*OPENSSL_LH_COMPFUNCTHUNK) (const void *, const void *, OPENSSL_LH_COMPFUNC cfn);
0038 typedef unsigned long (*OPENSSL_LH_HASHFUNC) (const void *);
0039 typedef unsigned long (*OPENSSL_LH_HASHFUNCTHUNK) (const void *, OPENSSL_LH_HASHFUNC hfn);
0040 typedef void (*OPENSSL_LH_DOALL_FUNC) (void *);
0041 typedef void (*OPENSSL_LH_DOALL_FUNC_THUNK) (void *, OPENSSL_LH_DOALL_FUNC doall);
0042 typedef void (*OPENSSL_LH_DOALL_FUNCARG) (void *, void *);
0043 typedef void (*OPENSSL_LH_DOALL_FUNCARG_THUNK) (void *, void *, OPENSSL_LH_DOALL_FUNCARG doall);
0044 typedef struct lhash_st OPENSSL_LHASH;
0045
0046 /*
0047  * Macros for declaring and implementing type-safe wrappers for LHASH
0048  * callbacks. This way, callbacks can be provided to LHASH structures without
0049  * function pointer casting and the macro-defined callbacks provide
0050  * per-variable casting before deferring to the underlying type-specific
0051  * callbacks. NB: It is possible to place a "static" in front of both the
0052  * DECLARE and IMPLEMENT macros if the functions are strictly internal.
0053  */
0054
0055 /* First: "hash" functions */
0056 # define DECLARE_LHASH_HASH_FN(name, o_type) \
0057         unsigned long name##_LHASH_HASH(const void *);
0058 # define IMPLEMENT_LHASH_HASH_FN(name, o_type) \
0059         unsigned long name##_LHASH_HASH(const void *arg) { \
0060                 const o_type *a = arg; \
0061                 return name##_hash(a); }
0062 # define LHASH_HASH_FN(name) name##_LHASH_HASH
0063
0064 /* Second: "compare" functions */
0065 # define DECLARE_LHASH_COMP_FN(name, o_type) \
0066         int name##_LHASH_COMP(const void *, const void *);
0067 # define IMPLEMENT_LHASH_COMP_FN(name, o_type) \
0068         int name##_LHASH_COMP(const void *arg1, const void *arg2) { \
0069                 const o_type *a = arg1;             \
0070                 const o_type *b = arg2; \
0071                 return name##_cmp(a,b); }
0072 # define LHASH_COMP_FN(name) name##_LHASH_COMP
0073
0074 /* Fourth: "doall_arg" functions */
0075 # define DECLARE_LHASH_DOALL_ARG_FN(name, o_type, a_type) \
0076         void name##_LHASH_DOALL_ARG(void *, void *);
0077 # define IMPLEMENT_LHASH_DOALL_ARG_FN(name, o_type, a_type) \
0078         void name##_LHASH_DOALL_ARG(void *arg1, void *arg2) { \
0079                 o_type *a = arg1; \
0080                 a_type *b = arg2; \
0081                 name##_doall_arg(a, b); }
0082 # define LHASH_DOALL_ARG_FN(name) name##_LHASH_DOALL_ARG
0083
0084
0085 # define LH_LOAD_MULT    256
0086
0087 int OPENSSL_LH_error(OPENSSL_LHASH *lh);
0088 OPENSSL_LHASH *OPENSSL_LH_new(OPENSSL_LH_HASHFUNC h, OPENSSL_LH_COMPFUNC c);
0089 OPENSSL_LHASH *OPENSSL_LH_set_thunks(OPENSSL_LHASH *lh,
0090                                      OPENSSL_LH_HASHFUNCTHUNK hw,
0091                                      OPENSSL_LH_COMPFUNCTHUNK cw,
0092                                      OPENSSL_LH_DOALL_FUNC_THUNK daw,
0093                                      OPENSSL_LH_DOALL_FUNCARG_THUNK daaw);
0094 void OPENSSL_LH_free(OPENSSL_LHASH *lh);
0095 void OPENSSL_LH_flush(OPENSSL_LHASH *lh);
0096 void *OPENSSL_LH_insert(OPENSSL_LHASH *lh, void *data);
0097 void *OPENSSL_LH_delete(OPENSSL_LHASH *lh, const void *data);
0098 void *OPENSSL_LH_retrieve(OPENSSL_LHASH *lh, const void *data);
0099 void OPENSSL_LH_doall(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNC func);
0100 void OPENSSL_LH_doall_arg(OPENSSL_LHASH *lh,
0101                           OPENSSL_LH_DOALL_FUNCARG func, void *arg);
0102 void OPENSSL_LH_doall_arg_thunk(OPENSSL_LHASH *lh,
0103                           OPENSSL_LH_DOALL_FUNCARG_THUNK daaw,
0104                           OPENSSL_LH_DOALL_FUNCARG fn, void *arg);
0105
0106 unsigned long OPENSSL_LH_strhash(const char *c);
0107 unsigned long OPENSSL_LH_num_items(const OPENSSL_LHASH *lh);
0108 unsigned long OPENSSL_LH_get_down_load(const OPENSSL_LHASH *lh);
0109 void OPENSSL_LH_set_down_load(OPENSSL_LHASH *lh, unsigned long down_load);
0110
0111 # ifndef OPENSSL_NO_STDIO
0112 #  ifndef OPENSSL_NO_DEPRECATED_3_1
0113 OSSL_DEPRECATEDIN_3_1 void OPENSSL_LH_stats(const OPENSSL_LHASH *lh, FILE *fp);
0114 OSSL_DEPRECATEDIN_3_1 void OPENSSL_LH_node_stats(const OPENSSL_LHASH *lh, FILE *fp);
0115 OSSL_DEPRECATEDIN_3_1 void OPENSSL_LH_node_usage_stats(const OPENSSL_LHASH *lh, FILE *fp);
0116 #  endif
0117 # endif
0118 # ifndef OPENSSL_NO_DEPRECATED_3_1
0119 OSSL_DEPRECATEDIN_3_1 void OPENSSL_LH_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
0120 OSSL_DEPRECATEDIN_3_1 void OPENSSL_LH_node_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
0121 OSSL_DEPRECATEDIN_3_1 void OPENSSL_LH_node_usage_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
0122 # endif
0123
0124 # ifndef OPENSSL_NO_DEPRECATED_1_1_0
0125 #  define _LHASH OPENSSL_LHASH
0126 #  define LHASH_NODE OPENSSL_LH_NODE
0127 #  define lh_error OPENSSL_LH_error
0128 #  define lh_new OPENSSL_LH_new
0129 #  define lh_free OPENSSL_LH_free
0130 #  define lh_insert OPENSSL_LH_insert
0131 #  define lh_delete OPENSSL_LH_delete
0132 #  define lh_retrieve OPENSSL_LH_retrieve
0133 #  define lh_doall OPENSSL_LH_doall
0134 #  define lh_doall_arg OPENSSL_LH_doall_arg
0135 #  define lh_strhash OPENSSL_LH_strhash
0136 #  define lh_num_items OPENSSL_LH_num_items
0137 #  ifndef OPENSSL_NO_STDIO
0138 #   define lh_stats OPENSSL_LH_stats
0139 #   define lh_node_stats OPENSSL_LH_node_stats
0140 #   define lh_node_usage_stats OPENSSL_LH_node_usage_stats
0141 #  endif
0142 #  define lh_stats_bio OPENSSL_LH_stats_bio
0143 #  define lh_node_stats_bio OPENSSL_LH_node_stats_bio
0144 #  define lh_node_usage_stats_bio OPENSSL_LH_node_usage_stats_bio
0145 # endif
0146
0147 /* Type checking... */
0148
0149 # define LHASH_OF(type) struct lhash_st_##type
0150
0151 /* Helper macro for internal use */
0152 # define DEFINE_LHASH_OF_INTERNAL(type) \
0153     LHASH_OF(type) { \
0154         union lh_##type##_dummy { void* d1; unsigned long d2; int d3; } dummy; \
0155     }; \
0156     typedef int (*lh_##type##_compfunc)(const type *a, const type *b); \
0157     typedef unsigned long (*lh_##type##_hashfunc)(const type *a); \
0158     typedef void (*lh_##type##_doallfunc)(type *a); \
0159     static ossl_inline unsigned long lh_##type##_hash_thunk(const void *data, OPENSSL_LH_HASHFUNC hfn) \
0160     { \
0161         unsigned long (*hfn_conv)(const type *) = (unsigned long (*)(const type *))hfn; \
0162         return hfn_conv((const type *)data); \
0163     } \
0164     static ossl_inline int lh_##type##_comp_thunk(const void *da, const void *db, OPENSSL_LH_COMPFUNC cfn) \
0165     { \
0166         int (*cfn_conv)(const type *, const type *) = (int (*)(const type *, const type *))cfn; \
0167         return cfn_conv((const type *)da, (const type *)db); \
0168     } \
0169     static ossl_inline void lh_##type##_doall_thunk(void *node, OPENSSL_LH_DOALL_FUNC doall) \
0170     { \
0171         void (*doall_conv)(type *) = (void (*)(type *))doall; \
0172         doall_conv((type *)node); \
0173     } \
0174     static ossl_inline void lh_##type##_doall_arg_thunk(void *node, void *arg, OPENSSL_LH_DOALL_FUNCARG doall) \
0175     { \
0176         void (*doall_conv)(type *, void *) = (void (*)(type *, void *))doall; \
0177         doall_conv((type *)node, arg); \
0178     } \
0179     static ossl_unused ossl_inline type *\
0180     ossl_check_##type##_lh_plain_type(type *ptr) \
0181     { \
0182         return ptr; \
0183     } \
0184     static ossl_unused ossl_inline const type * \
0185     ossl_check_const_##type##_lh_plain_type(const type *ptr) \
0186     { \
0187         return ptr; \
0188     } \
0189     static ossl_unused ossl_inline const OPENSSL_LHASH * \
0190     ossl_check_const_##type##_lh_type(const LHASH_OF(type) *lh) \
0191     { \
0192         return (const OPENSSL_LHASH *)lh; \
0193     } \
0194     static ossl_unused ossl_inline OPENSSL_LHASH * \
0195     ossl_check_##type##_lh_type(LHASH_OF(type) *lh) \
0196     { \
0197         return (OPENSSL_LHASH *)lh; \
0198     } \
0199     static ossl_unused ossl_inline OPENSSL_LH_COMPFUNC \
0200     ossl_check_##type##_lh_compfunc_type(lh_##type##_compfunc cmp) \
0201     { \
0202         return (OPENSSL_LH_COMPFUNC)cmp; \
0203     } \
0204     static ossl_unused ossl_inline OPENSSL_LH_HASHFUNC \
0205     ossl_check_##type##_lh_hashfunc_type(lh_##type##_hashfunc hfn) \
0206     { \
0207         return (OPENSSL_LH_HASHFUNC)hfn; \
0208     } \
0209     static ossl_unused ossl_inline OPENSSL_LH_DOALL_FUNC \
0210     ossl_check_##type##_lh_doallfunc_type(lh_##type##_doallfunc dfn) \
0211     { \
0212         return (OPENSSL_LH_DOALL_FUNC)dfn; \
0213     } \
0214     LHASH_OF(type)
0215
0216 # ifndef OPENSSL_NO_DEPRECATED_3_1
0217 #  define DEFINE_LHASH_OF_DEPRECATED(type) \
0218     static ossl_unused ossl_inline void \
0219     lh_##type##_node_stats_bio(const LHASH_OF(type) *lh, BIO *out) \
0220     { \
0221         OPENSSL_LH_node_stats_bio((const OPENSSL_LHASH *)lh, out); \
0222     } \
0223     static ossl_unused ossl_inline void \
0224     lh_##type##_node_usage_stats_bio(const LHASH_OF(type) *lh, BIO *out) \
0225     { \
0226         OPENSSL_LH_node_usage_stats_bio((const OPENSSL_LHASH *)lh, out); \
0227     } \
0228     static ossl_unused ossl_inline void \
0229     lh_##type##_stats_bio(const LHASH_OF(type) *lh, BIO *out) \
0230     { \
0231         OPENSSL_LH_stats_bio((const OPENSSL_LHASH *)lh, out); \
0232     }
0233 # else
0234 #  define DEFINE_LHASH_OF_DEPRECATED(type)
0235 # endif
0236
0237 # define DEFINE_LHASH_OF_EX(type) \
0238     LHASH_OF(type) { \
0239         union lh_##type##_dummy { void* d1; unsigned long d2; int d3; } dummy; \
0240     }; \
0241     static unsigned long \
0242     lh_##type##_hfn_thunk(const void *data, OPENSSL_LH_HASHFUNC hfn) \
0243     { \
0244         unsigned long (*hfn_conv)(const type *) = (unsigned long (*)(const type *))hfn; \
0245         return hfn_conv((const type *)data); \
0246     } \
0247     static int lh_##type##_cfn_thunk(const void *da, const void *db, OPENSSL_LH_COMPFUNC cfn) \
0248     { \
0249         int (*cfn_conv)(const type *, const type *) = (int (*)(const type *, const type *))cfn; \
0250         return cfn_conv((const type *)da, (const type *)db); \
0251     } \
0252     static ossl_unused ossl_inline void \
0253     lh_##type##_free(LHASH_OF(type) *lh) \
0254     { \
0255         OPENSSL_LH_free((OPENSSL_LHASH *)lh); \
0256     } \
0257     static ossl_unused ossl_inline void \
0258     lh_##type##_flush(LHASH_OF(type) *lh) \
0259     { \
0260         OPENSSL_LH_flush((OPENSSL_LHASH *)lh); \
0261     } \
0262     static ossl_unused ossl_inline type * \
0263     lh_##type##_insert(LHASH_OF(type) *lh, type *d) \
0264     { \
0265         return (type *)OPENSSL_LH_insert((OPENSSL_LHASH *)lh, d); \
0266     } \
0267     static ossl_unused ossl_inline type * \
0268     lh_##type##_delete(LHASH_OF(type) *lh, const type *d) \
0269     { \
0270         return (type *)OPENSSL_LH_delete((OPENSSL_LHASH *)lh, d); \
0271     } \
0272     static ossl_unused ossl_inline type * \
0273     lh_##type##_retrieve(LHASH_OF(type) *lh, const type *d) \
0274     { \
0275         return (type *)OPENSSL_LH_retrieve((OPENSSL_LHASH *)lh, d); \
0276     } \
0277     static ossl_unused ossl_inline int \
0278     lh_##type##_error(LHASH_OF(type) *lh) \
0279     { \
0280         return OPENSSL_LH_error((OPENSSL_LHASH *)lh); \
0281     } \
0282     static ossl_unused ossl_inline unsigned long \
0283     lh_##type##_num_items(LHASH_OF(type) *lh) \
0284     { \
0285         return OPENSSL_LH_num_items((OPENSSL_LHASH *)lh); \
0286     } \
0287     static ossl_unused ossl_inline unsigned long \
0288     lh_##type##_get_down_load(LHASH_OF(type) *lh) \
0289     { \
0290         return OPENSSL_LH_get_down_load((OPENSSL_LHASH *)lh); \
0291     } \
0292     static ossl_unused ossl_inline void \
0293     lh_##type##_set_down_load(LHASH_OF(type) *lh, unsigned long dl) \
0294     { \
0295         OPENSSL_LH_set_down_load((OPENSSL_LHASH *)lh, dl); \
0296     } \
0297     static ossl_unused ossl_inline void \
0298     lh_##type##_doall_thunk(void *node, OPENSSL_LH_DOALL_FUNC doall) \
0299     { \
0300         void (*doall_conv)(type *) = (void (*)(type *))doall; \
0301         doall_conv((type *)node); \
0302     } \
0303     static ossl_unused ossl_inline void \
0304     lh_##type##_doall_arg_thunk(void *node, void *arg, OPENSSL_LH_DOALL_FUNCARG doall) \
0305     { \
0306         void (*doall_conv)(type *, void *) = (void (*)(type *, void *))doall; \
0307         doall_conv((type *)node, arg); \
0308     } \
0309     static ossl_unused ossl_inline void \
0310     lh_##type##_doall(LHASH_OF(type) *lh, void (*doall)(type *)) \
0311     { \
0312         OPENSSL_LH_doall((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNC)doall); \
0313     } \
0314     static ossl_unused ossl_inline LHASH_OF(type) * \
0315     lh_##type##_new(unsigned long (*hfn)(const type *), \
0316                     int (*cfn)(const type *, const type *)) \
0317     { \
0318         return (LHASH_OF(type) *)OPENSSL_LH_set_thunks(OPENSSL_LH_new((OPENSSL_LH_HASHFUNC)hfn, (OPENSSL_LH_COMPFUNC)cfn), \
0319                                 lh_##type##_hfn_thunk, lh_##type##_cfn_thunk, \
0320                                 lh_##type##_doall_thunk, \
0321                                 lh_##type##_doall_arg_thunk); \
0322     } \
0323     static ossl_unused ossl_inline void \
0324     lh_##type##_doall_arg(LHASH_OF(type) *lh, \
0325                           void (*doallarg)(type *, void *), void *arg) \
0326     { \
0327         OPENSSL_LH_doall_arg((OPENSSL_LHASH *)lh, \
0328                              (OPENSSL_LH_DOALL_FUNCARG)doallarg, arg); \
0329     } \
0330     LHASH_OF(type)
0331
0332 # define DEFINE_LHASH_OF(type) \
0333     DEFINE_LHASH_OF_EX(type); \
0334     DEFINE_LHASH_OF_DEPRECATED(type) \
0335     LHASH_OF(type)
0336
0337 #define IMPLEMENT_LHASH_DOALL_ARG_CONST(type, argtype) \
0338     int_implement_lhash_doall(type, argtype, const type)
0339
0340 #define IMPLEMENT_LHASH_DOALL_ARG(type, argtype) \
0341     int_implement_lhash_doall(type, argtype, type)
0342
0343 #define int_implement_lhash_doall(type, argtype, cbargtype) \
0344     static ossl_unused ossl_inline void \
0345     lh_##type##_doall_##argtype##_thunk(void *node, void *arg, OPENSSL_LH_DOALL_FUNCARG fn) \
0346     { \
0347         void (*fn_conv)(cbargtype *, argtype *) = (void (*)(cbargtype *, argtype *))fn; \
0348         fn_conv((cbargtype *)node, (argtype *)arg); \
0349     } \
0350     static ossl_unused ossl_inline void \
0351         lh_##type##_doall_##argtype(LHASH_OF(type) *lh, \
0352                                    void (*fn)(cbargtype *, argtype *), \
0353                                    argtype *arg) \
0354     { \
0355         OPENSSL_LH_doall_arg_thunk((OPENSSL_LHASH *)lh, \
0356                              lh_##type##_doall_##argtype##_thunk, \
0357                              (OPENSSL_LH_DOALL_FUNCARG)fn, \
0358                              (void *)arg); \
0359     } \
0360     LHASH_OF(type)
0361
0362 DEFINE_LHASH_OF_INTERNAL(OPENSSL_STRING);
0363 #define lh_OPENSSL_STRING_new(hfn, cmp) ((LHASH_OF(OPENSSL_STRING) *)OPENSSL_LH_set_thunks(OPENSSL_LH_new(ossl_check_OPENSSL_STRING_lh_hashfunc_type(hfn), ossl_check_OPENSSL_STRING_lh_compfunc_type(cmp)), lh_OPENSSL_STRING_hash_thunk, lh_OPENSSL_STRING_comp_thunk, lh_OPENSSL_STRING_doall_thunk, lh_OPENSSL_STRING_doall_arg_thunk))
0364 #define lh_OPENSSL_STRING_free(lh) OPENSSL_LH_free(ossl_check_OPENSSL_STRING_lh_type(lh))
0365 #define lh_OPENSSL_STRING_flush(lh) OPENSSL_LH_flush(ossl_check_OPENSSL_STRING_lh_type(lh))
0366 #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)))
0367 #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)))
0368 #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)))
0369 #define lh_OPENSSL_STRING_error(lh) OPENSSL_LH_error(ossl_check_OPENSSL_STRING_lh_type(lh))
0370 #define lh_OPENSSL_STRING_num_items(lh) OPENSSL_LH_num_items(ossl_check_OPENSSL_STRING_lh_type(lh))
0371 #define lh_OPENSSL_STRING_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_OPENSSL_STRING_lh_type(lh), out)
0372 #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)
0373 #define lh_OPENSSL_STRING_stats_bio(lh, out) OPENSSL_LH_stats_bio(ossl_check_const_OPENSSL_STRING_lh_type(lh), out)
0374 #define lh_OPENSSL_STRING_get_down_load(lh) OPENSSL_LH_get_down_load(ossl_check_OPENSSL_STRING_lh_type(lh))
0375 #define lh_OPENSSL_STRING_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_OPENSSL_STRING_lh_type(lh), dl)
0376 #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))
0377 DEFINE_LHASH_OF_INTERNAL(OPENSSL_CSTRING);
0378 #define lh_OPENSSL_CSTRING_new(hfn, cmp) ((LHASH_OF(OPENSSL_CSTRING) *)OPENSSL_LH_set_thunks(OPENSSL_LH_new(ossl_check_OPENSSL_CSTRING_lh_hashfunc_type(hfn), ossl_check_OPENSSL_CSTRING_lh_compfunc_type(cmp)), lh_OPENSSL_CSTRING_hash_thunk, lh_OPENSSL_CSTRING_comp_thunk, lh_OPENSSL_CSTRING_doall_thunk, lh_OPENSSL_CSTRING_doall_arg_thunk))
0379 #define lh_OPENSSL_CSTRING_free(lh) OPENSSL_LH_free(ossl_check_OPENSSL_CSTRING_lh_type(lh))
0380 #define lh_OPENSSL_CSTRING_flush(lh) OPENSSL_LH_flush(ossl_check_OPENSSL_CSTRING_lh_type(lh))
0381 #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)))
0382 #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)))
0383 #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)))
0384 #define lh_OPENSSL_CSTRING_error(lh) OPENSSL_LH_error(ossl_check_OPENSSL_CSTRING_lh_type(lh))
0385 #define lh_OPENSSL_CSTRING_num_items(lh) OPENSSL_LH_num_items(ossl_check_OPENSSL_CSTRING_lh_type(lh))
0386 #define lh_OPENSSL_CSTRING_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_OPENSSL_CSTRING_lh_type(lh), out)
0387 #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)
0388 #define lh_OPENSSL_CSTRING_stats_bio(lh, out) OPENSSL_LH_stats_bio(ossl_check_const_OPENSSL_CSTRING_lh_type(lh), out)
0389 #define lh_OPENSSL_CSTRING_get_down_load(lh) OPENSSL_LH_get_down_load(ossl_check_OPENSSL_CSTRING_lh_type(lh))
0390 #define lh_OPENSSL_CSTRING_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_OPENSSL_CSTRING_lh_type(lh), dl)
0391 #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))
0392
0393
0394 #ifdef  __cplusplus
0395 }
0396 #endif
0397
0398 #endif