Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2026-09-21 09:19:19 

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

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!