Back to home page

EIC code displayed by LXR
 
 

    

Warning, file /include/openssl/safestack.h was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

0001 /*
0002  * WARNING: do not edit!
0003  * Generated by Makefile from include/openssl/safestack.h.in
0004  *
0005  * Copyright 1999-2025 The OpenSSL Project Authors. All Rights Reserved.
0006  *
0007  * Licensed under the Apache License 2.0 (the "License").  You may not use
0008  * this file except in compliance with the License.  You can obtain a copy
0009  * in the file LICENSE in the source distribution or at
0010  * https://www.openssl.org/source/license.html
0011  */
0012 
0013 /* clang-format off */
0014 
0015 /* clang-format on */
0016 
0017 #ifndef OPENSSL_SAFESTACK_H
0018 #define OPENSSL_SAFESTACK_H
0019 #pragma once
0020 
0021 #include <openssl/macros.h>
0022 #ifndef OPENSSL_NO_DEPRECATED_3_0
0023 #define HEADER_SAFESTACK_H
0024 #endif
0025 
0026 #include <openssl/stack.h>
0027 #include <openssl/e_os2.h>
0028 
0029 #ifdef __cplusplus
0030 extern "C" {
0031 #endif
0032 
0033 #define STACK_OF(type) struct stack_st_##type
0034 
0035 /* Helper macro for internal use */
0036 #define SKM_DEFINE_STACK_OF_INTERNAL(t1, t2, t3)                                                                \
0037     STACK_OF(t1);                                                                                               \
0038     typedef int (*sk_##t1##_compfunc)(const t3 *const *a, const t3 *const *b);                                  \
0039     typedef void (*sk_##t1##_freefunc)(t3 * a);                                                                 \
0040     typedef t3 *(*sk_##t1##_copyfunc)(const t3 *a);                                                             \
0041     static ossl_inline void sk_##t1##_freefunc_thunk(OPENSSL_sk_freefunc freefunc_arg, void *ptr)               \
0042     {                                                                                                           \
0043         sk_##t1##_freefunc freefunc = (sk_##t1##_freefunc)freefunc_arg;                                         \
0044         freefunc((t3 *)ptr);                                                                                    \
0045     }                                                                                                           \
0046     static ossl_unused ossl_inline t2 *ossl_check_##t1##_type(t2 *ptr)                                          \
0047     {                                                                                                           \
0048         return ptr;                                                                                             \
0049     }                                                                                                           \
0050     static ossl_unused ossl_inline const OPENSSL_STACK *ossl_check_const_##t1##_sk_type(const STACK_OF(t1) *sk) \
0051     {                                                                                                           \
0052         return (const OPENSSL_STACK *)sk;                                                                       \
0053     }                                                                                                           \
0054     static ossl_unused ossl_inline OPENSSL_STACK *ossl_check_##t1##_sk_type(STACK_OF(t1) *sk)                   \
0055     {                                                                                                           \
0056         return (OPENSSL_STACK *)sk;                                                                             \
0057     }                                                                                                           \
0058     static ossl_unused ossl_inline OPENSSL_sk_compfunc ossl_check_##t1##_compfunc_type(sk_##t1##_compfunc cmp)  \
0059     {                                                                                                           \
0060         return (OPENSSL_sk_compfunc)cmp;                                                                        \
0061     }                                                                                                           \
0062     static ossl_unused ossl_inline OPENSSL_sk_copyfunc ossl_check_##t1##_copyfunc_type(sk_##t1##_copyfunc cpy)  \
0063     {                                                                                                           \
0064         return (OPENSSL_sk_copyfunc)cpy;                                                                        \
0065     }                                                                                                           \
0066     static ossl_unused ossl_inline OPENSSL_sk_freefunc ossl_check_##t1##_freefunc_type(sk_##t1##_freefunc fr)   \
0067     {                                                                                                           \
0068         return (OPENSSL_sk_freefunc)fr;                                                                         \
0069     }
0070 
0071 #define SKM_DEFINE_STACK_OF(t1, t2, t3)                                                                                    \
0072     STACK_OF(t1);                                                                                                          \
0073     typedef int (*sk_##t1##_compfunc)(const t3 *const *a, const t3 *const *b);                                             \
0074     typedef void (*sk_##t1##_freefunc)(t3 * a);                                                                            \
0075     typedef t3 *(*sk_##t1##_copyfunc)(const t3 *a);                                                                        \
0076     static ossl_inline void sk_##t1##_freefunc_thunk(OPENSSL_sk_freefunc freefunc_arg, void *ptr)                          \
0077     {                                                                                                                      \
0078         sk_##t1##_freefunc freefunc = (sk_##t1##_freefunc)freefunc_arg;                                                    \
0079         freefunc((t3 *)ptr);                                                                                               \
0080     }                                                                                                                      \
0081     static ossl_unused ossl_inline int sk_##t1##_num(const STACK_OF(t1) *sk)                                               \
0082     {                                                                                                                      \
0083         return OPENSSL_sk_num((const OPENSSL_STACK *)sk);                                                                  \
0084     }                                                                                                                      \
0085     static ossl_unused ossl_inline t2 *sk_##t1##_value(const STACK_OF(t1) *sk, int idx)                                    \
0086     {                                                                                                                      \
0087         return (t2 *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx);                                                     \
0088     }                                                                                                                      \
0089     static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new(sk_##t1##_compfunc compare)                                 \
0090     {                                                                                                                      \
0091         OPENSSL_STACK *ret = OPENSSL_sk_new((OPENSSL_sk_compfunc)compare);                                                 \
0092         OPENSSL_sk_freefunc_thunk f_thunk;                                                                                 \
0093                                                                                                                            \
0094         f_thunk = (OPENSSL_sk_freefunc_thunk)sk_##t1##_freefunc_thunk;                                                     \
0095         return (STACK_OF(t1) *)OPENSSL_sk_set_thunks(ret, f_thunk);                                                        \
0096     }                                                                                                                      \
0097     static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_null(void)                                                  \
0098     {                                                                                                                      \
0099         return (STACK_OF(t1) *)OPENSSL_sk_new_null();                                                                      \
0100     }                                                                                                                      \
0101     static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_reserve(sk_##t1##_compfunc compare, int n)                  \
0102     {                                                                                                                      \
0103         OPENSSL_STACK *ret = OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n);                                      \
0104         OPENSSL_sk_freefunc_thunk f_thunk;                                                                                 \
0105                                                                                                                            \
0106         f_thunk = (OPENSSL_sk_freefunc_thunk)sk_##t1##_freefunc_thunk;                                                     \
0107         return (STACK_OF(t1) *)OPENSSL_sk_set_thunks(ret, f_thunk);                                                        \
0108     }                                                                                                                      \
0109     static ossl_unused ossl_inline int sk_##t1##_reserve(STACK_OF(t1) *sk, int n)                                          \
0110     {                                                                                                                      \
0111         return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n);                                                                 \
0112     }                                                                                                                      \
0113     static ossl_unused ossl_inline void sk_##t1##_free(STACK_OF(t1) *sk)                                                   \
0114     {                                                                                                                      \
0115         OPENSSL_sk_free((OPENSSL_STACK *)sk);                                                                              \
0116     }                                                                                                                      \
0117     static ossl_unused ossl_inline void sk_##t1##_zero(STACK_OF(t1) *sk)                                                   \
0118     {                                                                                                                      \
0119         OPENSSL_sk_zero((OPENSSL_STACK *)sk);                                                                              \
0120     }                                                                                                                      \
0121     static ossl_unused ossl_inline t2 *sk_##t1##_delete(STACK_OF(t1) *sk, int i)                                           \
0122     {                                                                                                                      \
0123         return (t2 *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i);                                                            \
0124     }                                                                                                                      \
0125     static ossl_unused ossl_inline t2 *sk_##t1##_delete_ptr(STACK_OF(t1) *sk, t2 *ptr)                                     \
0126     {                                                                                                                      \
0127         return (t2 *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk,                                                            \
0128             (const void *)ptr);                                                                                            \
0129     }                                                                                                                      \
0130     static ossl_unused ossl_inline int sk_##t1##_push(STACK_OF(t1) *sk, t2 *ptr)                                           \
0131     {                                                                                                                      \
0132         return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr);                                                    \
0133     }                                                                                                                      \
0134     static ossl_unused ossl_inline int sk_##t1##_unshift(STACK_OF(t1) *sk, t2 *ptr)                                        \
0135     {                                                                                                                      \
0136         return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr);                                                 \
0137     }                                                                                                                      \
0138     static ossl_unused ossl_inline t2 *sk_##t1##_pop(STACK_OF(t1) *sk)                                                     \
0139     {                                                                                                                      \
0140         return (t2 *)OPENSSL_sk_pop((OPENSSL_STACK *)sk);                                                                  \
0141     }                                                                                                                      \
0142     static ossl_unused ossl_inline t2 *sk_##t1##_shift(STACK_OF(t1) *sk)                                                   \
0143     {                                                                                                                      \
0144         return (t2 *)OPENSSL_sk_shift((OPENSSL_STACK *)sk);                                                                \
0145     }                                                                                                                      \
0146     static ossl_unused ossl_inline void sk_##t1##_pop_free(STACK_OF(t1) *sk, sk_##t1##_freefunc freefunc)                  \
0147     {                                                                                                                      \
0148         OPENSSL_sk_freefunc_thunk f_thunk;                                                                                 \
0149                                                                                                                            \
0150         f_thunk = (OPENSSL_sk_freefunc_thunk)sk_##t1##_freefunc_thunk;                                                     \
0151         sk = (STACK_OF(t1) *)OPENSSL_sk_set_thunks((OPENSSL_STACK *)sk, f_thunk);                                          \
0152                                                                                                                            \
0153         OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc);                                           \
0154     }                                                                                                                      \
0155     static ossl_unused ossl_inline int sk_##t1##_insert(STACK_OF(t1) *sk, t2 *ptr, int idx)                                \
0156     {                                                                                                                      \
0157         return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx);                                             \
0158     }                                                                                                                      \
0159     static ossl_unused ossl_inline t2 *sk_##t1##_set(STACK_OF(t1) *sk, int idx, t2 *ptr)                                   \
0160     {                                                                                                                      \
0161         return (t2 *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr);                                          \
0162     }                                                                                                                      \
0163     static ossl_unused ossl_inline int sk_##t1##_find(STACK_OF(t1) *sk, t2 *ptr)                                           \
0164     {                                                                                                                      \
0165         return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr);                                                    \
0166     }                                                                                                                      \
0167     static ossl_unused ossl_inline int sk_##t1##_find_ex(STACK_OF(t1) *sk, t2 *ptr)                                        \
0168     {                                                                                                                      \
0169         return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr);                                                 \
0170     }                                                                                                                      \
0171     static ossl_unused ossl_inline int sk_##t1##_find_all(STACK_OF(t1) *sk, t2 *ptr, int *pnum)                            \
0172     {                                                                                                                      \
0173         return OPENSSL_sk_find_all((OPENSSL_STACK *)sk, (const void *)ptr, pnum);                                          \
0174     }                                                                                                                      \
0175     static ossl_unused ossl_inline void sk_##t1##_sort(STACK_OF(t1) *sk)                                                   \
0176     {                                                                                                                      \
0177         OPENSSL_sk_sort((OPENSSL_STACK *)sk);                                                                              \
0178     }                                                                                                                      \
0179     static ossl_unused ossl_inline int sk_##t1##_is_sorted(const STACK_OF(t1) *sk)                                         \
0180     {                                                                                                                      \
0181         return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk);                                                            \
0182     }                                                                                                                      \
0183     static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_dup(const STACK_OF(t1) *sk)                                     \
0184     {                                                                                                                      \
0185         return (STACK_OF(t1) *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk);                                                  \
0186     }                                                                                                                      \
0187     static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_deep_copy(const STACK_OF(t1) *sk,                               \
0188         sk_##t1##_copyfunc copyfunc,                                                                                       \
0189         sk_##t1##_freefunc freefunc)                                                                                       \
0190     {                                                                                                                      \
0191         return (STACK_OF(t1) *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk,                                             \
0192             (OPENSSL_sk_copyfunc)copyfunc,                                                                                 \
0193             (OPENSSL_sk_freefunc)freefunc);                                                                                \
0194     }                                                                                                                      \
0195     static ossl_unused ossl_inline sk_##t1##_compfunc sk_##t1##_set_cmp_func(STACK_OF(t1) *sk, sk_##t1##_compfunc compare) \
0196     {                                                                                                                      \
0197         return (sk_##t1##_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare);             \
0198     }
0199 
0200 #define DEFINE_STACK_OF(t) SKM_DEFINE_STACK_OF(t, t, t)
0201 #define DEFINE_STACK_OF_CONST(t) SKM_DEFINE_STACK_OF(t, const t, t)
0202 #define DEFINE_SPECIAL_STACK_OF(t1, t2) SKM_DEFINE_STACK_OF(t1, t2, t2)
0203 #define DEFINE_SPECIAL_STACK_OF_CONST(t1, t2) \
0204     SKM_DEFINE_STACK_OF(t1, const t2, t2)
0205 
0206 /*-
0207  * Strings are special: normally an lhash entry will point to a single
0208  * (somewhat) mutable object. In the case of strings:
0209  *
0210  * a) Instead of a single char, there is an array of chars, NUL-terminated.
0211  * b) The string may have be immutable.
0212  *
0213  * So, they need their own declarations. Especially important for
0214  * type-checking tools, such as Deputy.
0215  *
0216  * In practice, however, it appears to be hard to have a const
0217  * string. For now, I'm settling for dealing with the fact it is a
0218  * string at all.
0219  */
0220 typedef char *OPENSSL_STRING;
0221 typedef const char *OPENSSL_CSTRING;
0222 
0223 /*-
0224  * Confusingly, LHASH_OF(STRING) deals with char ** throughout, but
0225  * STACK_OF(STRING) is really more like STACK_OF(char), only, as mentioned
0226  * above, instead of a single char each entry is a NUL-terminated array of
0227  * chars. So, we have to implement STRING specially for STACK_OF. This is
0228  * dealt with in the autogenerated macros below.
0229  */
0230 /* clang-format off */
0231 SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_STRING, char, char)
0232 #define sk_OPENSSL_STRING_num(sk) OPENSSL_sk_num(ossl_check_const_OPENSSL_STRING_sk_type(sk))
0233 #define sk_OPENSSL_STRING_value(sk, idx) ((char *)OPENSSL_sk_value(ossl_check_const_OPENSSL_STRING_sk_type(sk), (idx)))
0234 #define sk_OPENSSL_STRING_new(cmp) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_new(ossl_check_OPENSSL_STRING_compfunc_type(cmp)))
0235 #define sk_OPENSSL_STRING_new_null() ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_new_null())
0236 #define sk_OPENSSL_STRING_new_reserve(cmp, n) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_new_reserve(ossl_check_OPENSSL_STRING_compfunc_type(cmp), (n)))
0237 #define sk_OPENSSL_STRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OPENSSL_STRING_sk_type(sk), (n))
0238 #define sk_OPENSSL_STRING_free(sk) OPENSSL_sk_free(ossl_check_OPENSSL_STRING_sk_type(sk))
0239 #define sk_OPENSSL_STRING_zero(sk) OPENSSL_sk_zero(ossl_check_OPENSSL_STRING_sk_type(sk))
0240 #define sk_OPENSSL_STRING_delete(sk, i) ((char *)OPENSSL_sk_delete(ossl_check_OPENSSL_STRING_sk_type(sk), (i)))
0241 #define sk_OPENSSL_STRING_delete_ptr(sk, ptr) ((char *)OPENSSL_sk_delete_ptr(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr)))
0242 #define sk_OPENSSL_STRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr))
0243 #define sk_OPENSSL_STRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr))
0244 #define sk_OPENSSL_STRING_pop(sk) ((char *)OPENSSL_sk_pop(ossl_check_OPENSSL_STRING_sk_type(sk)))
0245 #define sk_OPENSSL_STRING_shift(sk) ((char *)OPENSSL_sk_shift(ossl_check_OPENSSL_STRING_sk_type(sk)))
0246 #define sk_OPENSSL_STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_freefunc_type(freefunc))
0247 #define sk_OPENSSL_STRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr), (idx))
0248 #define sk_OPENSSL_STRING_set(sk, idx, ptr) ((char *)OPENSSL_sk_set(ossl_check_OPENSSL_STRING_sk_type(sk), (idx), ossl_check_OPENSSL_STRING_type(ptr)))
0249 #define sk_OPENSSL_STRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr))
0250 #define sk_OPENSSL_STRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr))
0251 #define sk_OPENSSL_STRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr), pnum)
0252 #define sk_OPENSSL_STRING_sort(sk) OPENSSL_sk_sort(ossl_check_OPENSSL_STRING_sk_type(sk))
0253 #define sk_OPENSSL_STRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OPENSSL_STRING_sk_type(sk))
0254 #define sk_OPENSSL_STRING_dup(sk) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_dup(ossl_check_const_OPENSSL_STRING_sk_type(sk)))
0255 #define sk_OPENSSL_STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_deep_copy(ossl_check_const_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_copyfunc_type(copyfunc), ossl_check_OPENSSL_STRING_freefunc_type(freefunc)))
0256 #define sk_OPENSSL_STRING_set_cmp_func(sk, cmp) ((sk_OPENSSL_STRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_compfunc_type(cmp)))
0257 SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_CSTRING, const char, char)
0258 #define sk_OPENSSL_CSTRING_num(sk) OPENSSL_sk_num(ossl_check_const_OPENSSL_CSTRING_sk_type(sk))
0259 #define sk_OPENSSL_CSTRING_value(sk, idx) ((const char *)OPENSSL_sk_value(ossl_check_const_OPENSSL_CSTRING_sk_type(sk), (idx)))
0260 #define sk_OPENSSL_CSTRING_new(cmp) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_new(ossl_check_OPENSSL_CSTRING_compfunc_type(cmp)))
0261 #define sk_OPENSSL_CSTRING_new_null() ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_new_null())
0262 #define sk_OPENSSL_CSTRING_new_reserve(cmp, n) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_new_reserve(ossl_check_OPENSSL_CSTRING_compfunc_type(cmp), (n)))
0263 #define sk_OPENSSL_CSTRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OPENSSL_CSTRING_sk_type(sk), (n))
0264 #define sk_OPENSSL_CSTRING_free(sk) OPENSSL_sk_free(ossl_check_OPENSSL_CSTRING_sk_type(sk))
0265 #define sk_OPENSSL_CSTRING_zero(sk) OPENSSL_sk_zero(ossl_check_OPENSSL_CSTRING_sk_type(sk))
0266 #define sk_OPENSSL_CSTRING_delete(sk, i) ((const char *)OPENSSL_sk_delete(ossl_check_OPENSSL_CSTRING_sk_type(sk), (i)))
0267 #define sk_OPENSSL_CSTRING_delete_ptr(sk, ptr) ((const char *)OPENSSL_sk_delete_ptr(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr)))
0268 #define sk_OPENSSL_CSTRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr))
0269 #define sk_OPENSSL_CSTRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr))
0270 #define sk_OPENSSL_CSTRING_pop(sk) ((const char *)OPENSSL_sk_pop(ossl_check_OPENSSL_CSTRING_sk_type(sk)))
0271 #define sk_OPENSSL_CSTRING_shift(sk) ((const char *)OPENSSL_sk_shift(ossl_check_OPENSSL_CSTRING_sk_type(sk)))
0272 #define sk_OPENSSL_CSTRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_freefunc_type(freefunc))
0273 #define sk_OPENSSL_CSTRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr), (idx))
0274 #define sk_OPENSSL_CSTRING_set(sk, idx, ptr) ((const char *)OPENSSL_sk_set(ossl_check_OPENSSL_CSTRING_sk_type(sk), (idx), ossl_check_OPENSSL_CSTRING_type(ptr)))
0275 #define sk_OPENSSL_CSTRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr))
0276 #define sk_OPENSSL_CSTRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr))
0277 #define sk_OPENSSL_CSTRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr), pnum)
0278 #define sk_OPENSSL_CSTRING_sort(sk) OPENSSL_sk_sort(ossl_check_OPENSSL_CSTRING_sk_type(sk))
0279 #define sk_OPENSSL_CSTRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OPENSSL_CSTRING_sk_type(sk))
0280 #define sk_OPENSSL_CSTRING_dup(sk) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_dup(ossl_check_const_OPENSSL_CSTRING_sk_type(sk)))
0281 #define sk_OPENSSL_CSTRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_deep_copy(ossl_check_const_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_copyfunc_type(copyfunc), ossl_check_OPENSSL_CSTRING_freefunc_type(freefunc)))
0282 #define sk_OPENSSL_CSTRING_set_cmp_func(sk, cmp) ((sk_OPENSSL_CSTRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_compfunc_type(cmp)))
0283 
0284 /* clang-format on */
0285 
0286 #if !defined(OPENSSL_NO_DEPRECATED_3_0)
0287 /*
0288  * This is not used by OpenSSL.  A block of bytes,  NOT nul-terminated.
0289  * These should also be distinguished from "normal" stacks.
0290  */
0291 typedef void *OPENSSL_BLOCK;
0292 /* clang-format off */
0293 SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_BLOCK, void, void)
0294 #define sk_OPENSSL_BLOCK_num(sk) OPENSSL_sk_num(ossl_check_const_OPENSSL_BLOCK_sk_type(sk))
0295 #define sk_OPENSSL_BLOCK_value(sk, idx) ((void *)OPENSSL_sk_value(ossl_check_const_OPENSSL_BLOCK_sk_type(sk), (idx)))
0296 #define sk_OPENSSL_BLOCK_new(cmp) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_new(ossl_check_OPENSSL_BLOCK_compfunc_type(cmp)))
0297 #define sk_OPENSSL_BLOCK_new_null() ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_new_null())
0298 #define sk_OPENSSL_BLOCK_new_reserve(cmp, n) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_new_reserve(ossl_check_OPENSSL_BLOCK_compfunc_type(cmp), (n)))
0299 #define sk_OPENSSL_BLOCK_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OPENSSL_BLOCK_sk_type(sk), (n))
0300 #define sk_OPENSSL_BLOCK_free(sk) OPENSSL_sk_free(ossl_check_OPENSSL_BLOCK_sk_type(sk))
0301 #define sk_OPENSSL_BLOCK_zero(sk) OPENSSL_sk_zero(ossl_check_OPENSSL_BLOCK_sk_type(sk))
0302 #define sk_OPENSSL_BLOCK_delete(sk, i) ((void *)OPENSSL_sk_delete(ossl_check_OPENSSL_BLOCK_sk_type(sk), (i)))
0303 #define sk_OPENSSL_BLOCK_delete_ptr(sk, ptr) ((void *)OPENSSL_sk_delete_ptr(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr)))
0304 #define sk_OPENSSL_BLOCK_push(sk, ptr) OPENSSL_sk_push(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr))
0305 #define sk_OPENSSL_BLOCK_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr))
0306 #define sk_OPENSSL_BLOCK_pop(sk) ((void *)OPENSSL_sk_pop(ossl_check_OPENSSL_BLOCK_sk_type(sk)))
0307 #define sk_OPENSSL_BLOCK_shift(sk) ((void *)OPENSSL_sk_shift(ossl_check_OPENSSL_BLOCK_sk_type(sk)))
0308 #define sk_OPENSSL_BLOCK_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_freefunc_type(freefunc))
0309 #define sk_OPENSSL_BLOCK_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr), (idx))
0310 #define sk_OPENSSL_BLOCK_set(sk, idx, ptr) ((void *)OPENSSL_sk_set(ossl_check_OPENSSL_BLOCK_sk_type(sk), (idx), ossl_check_OPENSSL_BLOCK_type(ptr)))
0311 #define sk_OPENSSL_BLOCK_find(sk, ptr) OPENSSL_sk_find(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr))
0312 #define sk_OPENSSL_BLOCK_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr))
0313 #define sk_OPENSSL_BLOCK_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr), pnum)
0314 #define sk_OPENSSL_BLOCK_sort(sk) OPENSSL_sk_sort(ossl_check_OPENSSL_BLOCK_sk_type(sk))
0315 #define sk_OPENSSL_BLOCK_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OPENSSL_BLOCK_sk_type(sk))
0316 #define sk_OPENSSL_BLOCK_dup(sk) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_dup(ossl_check_const_OPENSSL_BLOCK_sk_type(sk)))
0317 #define sk_OPENSSL_BLOCK_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_deep_copy(ossl_check_const_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_copyfunc_type(copyfunc), ossl_check_OPENSSL_BLOCK_freefunc_type(freefunc)))
0318 #define sk_OPENSSL_BLOCK_set_cmp_func(sk, cmp) ((sk_OPENSSL_BLOCK_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_compfunc_type(cmp)))
0319 
0320 /* clang-format on */
0321 #endif
0322 
0323 #ifdef __cplusplus
0324 }
0325 #endif
0326 #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!