1 /* 2 * Copyright 1999-2019 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the OpenSSL license (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 #ifndef HEADER_SAFESTACK_H 11 # define HEADER_SAFESTACK_H 12 13 # include <openssl/stack.h> 14 # include <openssl/e_os2.h> 15 16 #ifdef __cplusplus 17 extern "C" { 18 #endif 19 20 # define STACK_OF(type) struct stack_st_##type 21 22 # define SKM_DEFINE_STACK_OF(t1, t2, t3) \ 23 STACK_OF(t1); \ 24 typedef int (*sk_##t1##_compfunc)(const t3 * const *a, const t3 *const *b); \ 25 typedef void (*sk_##t1##_freefunc)(t3 *a); \ 26 typedef t3 * (*sk_##t1##_copyfunc)(const t3 *a); \ 27 static ossl_unused ossl_inline int sk_##t1##_num(const STACK_OF(t1) *sk) \ 28 { \ 29 return OPENSSL_sk_num((const OPENSSL_STACK *)(const void *)sk); \ 30 } \ 31 static ossl_unused ossl_inline t2 *sk_##t1##_value(const STACK_OF(t1)*sk, int idx) \ 32 { \ 33 return (t2 *)(void *)OPENSSL_sk_value((const OPENSSL_STACK *)(const void *)sk, idx); \ 34 } \ 35 static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new(sk_##t1##_compfunc compare) \ 36 { \ 37 return (STACK_OF(t1) *)(void *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); \ 38 } \ 39 static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_null(void) \ 40 { \ 41 return (STACK_OF(t1) *)(void *)OPENSSL_sk_new_null(); \ 42 } \ 43 static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_reserve(sk_##t1##_compfunc compare, int n) \ 44 { \ 45 return (STACK_OF(t1) *)(void *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); \ 46 } \ 47 static ossl_unused ossl_inline int sk_##t1##_reserve(STACK_OF(t1) *sk, int n) \ 48 { \ 49 return OPENSSL_sk_reserve((OPENSSL_STACK *)(void *)sk, n); \ 50 } \ 51 static ossl_unused ossl_inline void sk_##t1##_free(STACK_OF(t1) *sk) \ 52 { \ 53 OPENSSL_sk_free((OPENSSL_STACK *)(void *)sk); \ 54 } \ 55 static ossl_unused ossl_inline void sk_##t1##_zero(STACK_OF(t1) *sk) \ 56 { \ 57 OPENSSL_sk_zero((OPENSSL_STACK *)(void *)sk); \ 58 } \ 59 static ossl_unused ossl_inline t2 *sk_##t1##_delete(STACK_OF(t1) *sk, int i) \ 60 { \ 61 return (t2 *)(void *)OPENSSL_sk_delete((OPENSSL_STACK *)(void *)sk, i); \ 62 } \ 63 static ossl_unused ossl_inline t2 *sk_##t1##_delete_ptr(STACK_OF(t1) *sk, t2 *ptr) \ 64 { \ 65 return (t2 *)(void *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)(void *)sk, \ 66 (const void *)ptr); \ 67 } \ 68 static ossl_unused ossl_inline int sk_##t1##_push(STACK_OF(t1) *sk, t2 *ptr) \ 69 { \ 70 return OPENSSL_sk_push((OPENSSL_STACK *)(void *)sk, (const void *)ptr); \ 71 } \ 72 static ossl_unused ossl_inline int sk_##t1##_unshift(STACK_OF(t1) *sk, t2 *ptr) \ 73 { \ 74 return OPENSSL_sk_unshift((OPENSSL_STACK *)(void *)sk, (const void *)ptr); \ 75 } \ 76 static ossl_unused ossl_inline t2 *sk_##t1##_pop(STACK_OF(t1) *sk) \ 77 { \ 78 return (t2 *)(void *)OPENSSL_sk_pop((OPENSSL_STACK *)(void *)sk); \ 79 } \ 80 static ossl_unused ossl_inline t2 *sk_##t1##_shift(STACK_OF(t1) *sk) \ 81 { \ 82 return (t2 *)(void *)OPENSSL_sk_shift((OPENSSL_STACK *)(void *)sk); \ 83 } \ 84 static ossl_unused ossl_inline void sk_##t1##_pop_free(STACK_OF(t1) *sk, sk_##t1##_freefunc freefunc) \ 85 { \ 86 OPENSSL_sk_pop_free((OPENSSL_STACK *)(void *)sk, (OPENSSL_sk_freefunc)freefunc); \ 87 } \ 88 static ossl_unused ossl_inline int sk_##t1##_insert(STACK_OF(t1) *sk, t2 *ptr, int idx) \ 89 { \ 90 return OPENSSL_sk_insert((OPENSSL_STACK *)(void *)sk, (const void *)ptr, idx); \ 91 } \ 92 static ossl_unused ossl_inline t2 *sk_##t1##_set(STACK_OF(t1) *sk, int idx, t2 *ptr) \ 93 { \ 94 return (t2 *)(void *)OPENSSL_sk_set((OPENSSL_STACK *)(void *)sk, idx, (const void *)ptr); \ 95 } \ 96 static ossl_unused ossl_inline int sk_##t1##_find(STACK_OF(t1) *sk, t2 *ptr) \ 97 { \ 98 return OPENSSL_sk_find((OPENSSL_STACK *)(void *)sk, (const void *)ptr); \ 99 } \ 100 static ossl_unused ossl_inline int sk_##t1##_find_ex(STACK_OF(t1) *sk, t2 *ptr) \ 101 { \ 102 return OPENSSL_sk_find_ex((OPENSSL_STACK *)(void *)sk, (const void *)ptr); \ 103 } \ 104 static ossl_unused ossl_inline void sk_##t1##_sort(STACK_OF(t1) *sk) \ 105 { \ 106 OPENSSL_sk_sort((OPENSSL_STACK *)(void *)sk); \ 107 } \ 108 static ossl_unused ossl_inline int sk_##t1##_is_sorted(const STACK_OF(t1) *sk) \ 109 { \ 110 return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)(const void *)sk); \ 111 } \ 112 static ossl_unused ossl_inline STACK_OF(t1) * sk_##t1##_dup(const STACK_OF(t1) *sk) \ 113 { \ 114 return (STACK_OF(t1) *)(void *)OPENSSL_sk_dup((const OPENSSL_STACK *)(const void *)sk); \ 115 } \ 116 static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_deep_copy(const STACK_OF(t1) *sk, \ 117 sk_##t1##_copyfunc copyfunc, \ 118 sk_##t1##_freefunc freefunc) \ 119 { \ 120 return (STACK_OF(t1) *)(void *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)(const void *)sk, \ 121 (OPENSSL_sk_copyfunc)copyfunc, \ 122 (OPENSSL_sk_freefunc)freefunc); \ 123 } \ 124 static ossl_unused ossl_inline sk_##t1##_compfunc sk_##t1##_set_cmp_func(STACK_OF(t1) *sk, sk_##t1##_compfunc compare) \ 125 { \ 126 return (sk_##t1##_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)(void *)sk, (OPENSSL_sk_compfunc)compare); \ 127 } 128 129 # define DEFINE_SPECIAL_STACK_OF(t1, t2) SKM_DEFINE_STACK_OF(t1, t2, t2) 130 # define DEFINE_STACK_OF(t) SKM_DEFINE_STACK_OF(t, t, t) 131 # define DEFINE_SPECIAL_STACK_OF_CONST(t1, t2) \ 132 SKM_DEFINE_STACK_OF(t1, const t2, t2) 133 # define DEFINE_STACK_OF_CONST(t) SKM_DEFINE_STACK_OF(t, const t, t) 134 135 /*- 136 * Strings are special: normally an lhash entry will point to a single 137 * (somewhat) mutable object. In the case of strings: 138 * 139 * a) Instead of a single char, there is an array of chars, NUL-terminated. 140 * b) The string may have be immutable. 141 * 142 * So, they need their own declarations. Especially important for 143 * type-checking tools, such as Deputy. 144 * 145 * In practice, however, it appears to be hard to have a const 146 * string. For now, I'm settling for dealing with the fact it is a 147 * string at all. 148 */ 149 typedef char *OPENSSL_STRING; 150 typedef const char *OPENSSL_CSTRING; 151 152 /*- 153 * Confusingly, LHASH_OF(STRING) deals with char ** throughout, but 154 * STACK_OF(STRING) is really more like STACK_OF(char), only, as mentioned 155 * above, instead of a single char each entry is a NUL-terminated array of 156 * chars. So, we have to implement STRING specially for STACK_OF. This is 157 * dealt with in the autogenerated macros below. 158 */ 159 DEFINE_SPECIAL_STACK_OF(OPENSSL_STRING, char) 160 DEFINE_SPECIAL_STACK_OF_CONST(OPENSSL_CSTRING, char) 161 162 /* 163 * Similarly, we sometimes use a block of characters, NOT nul-terminated. 164 * These should also be distinguished from "normal" stacks. 165 */ 166 typedef void *OPENSSL_BLOCK; 167 DEFINE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void) 168 169 /* 170 * If called without higher optimization (min. -xO3) the Oracle Developer 171 * Studio compiler generates code for the defined (static inline) functions 172 * above. 173 * This would later lead to the linker complaining about missing symbols when 174 * this header file is included but the resulting object is not linked against 175 * the Crypto library (openssl#6912). 176 */ 177 # ifdef __SUNPRO_C 178 # pragma weak OPENSSL_sk_num 179 # pragma weak OPENSSL_sk_value 180 # pragma weak OPENSSL_sk_new 181 # pragma weak OPENSSL_sk_new_null 182 # pragma weak OPENSSL_sk_new_reserve 183 # pragma weak OPENSSL_sk_reserve 184 # pragma weak OPENSSL_sk_free 185 # pragma weak OPENSSL_sk_zero 186 # pragma weak OPENSSL_sk_delete 187 # pragma weak OPENSSL_sk_delete_ptr 188 # pragma weak OPENSSL_sk_push 189 # pragma weak OPENSSL_sk_unshift 190 # pragma weak OPENSSL_sk_pop 191 # pragma weak OPENSSL_sk_shift 192 # pragma weak OPENSSL_sk_pop_free 193 # pragma weak OPENSSL_sk_insert 194 # pragma weak OPENSSL_sk_set 195 # pragma weak OPENSSL_sk_find 196 # pragma weak OPENSSL_sk_find_ex 197 # pragma weak OPENSSL_sk_sort 198 # pragma weak OPENSSL_sk_is_sorted 199 # pragma weak OPENSSL_sk_dup 200 # pragma weak OPENSSL_sk_deep_copy 201 # pragma weak OPENSSL_sk_set_cmp_func 202 # endif /* __SUNPRO_C */ 203 204 # ifdef __cplusplus 205 } 206 # endif 207 #endif 208
Indexes created Sat Feb 28 05:31:39 UTC 2026