]>
Commit | Line | Data |
---|---|---|
21dcbebc RS |
1 | /* |
2 | * Copyright 1999-2016 The OpenSSL Project Authors. All Rights Reserved. | |
f73e07cf | 3 | * |
21dcbebc RS |
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 | |
f73e07cf BL |
8 | */ |
9 | ||
10 | #ifndef HEADER_SAFESTACK_H | |
0f113f3e | 11 | # define HEADER_SAFESTACK_H |
f73e07cf | 12 | |
0f113f3e | 13 | # include <openssl/stack.h> |
411abf2d | 14 | # include <openssl/e_os2.h> |
f73e07cf | 15 | |
17e80c6b RS |
16 | #ifdef __cplusplus |
17 | extern "C" { | |
18 | #endif | |
19 | ||
0f113f3e | 20 | # ifndef CHECKED_PTR_OF |
5b18d302 | 21 | # define CHECKED_PTR_OF(type, p) ((void*) (1 ? p : (type*)0)) |
0f113f3e | 22 | # endif |
1d1a6465 | 23 | |
0f113f3e MC |
24 | /* |
25 | * In C++ we get problems because an explicit cast is needed from (void *) we | |
26 | * use CHECKED_STACK_OF to ensure the correct type is passed in the macros | |
27 | * below. | |
5f8f94a6 DSH |
28 | */ |
29 | ||
0f113f3e | 30 | # define CHECKED_STACK_OF(type, p) \ |
5f8f94a6 DSH |
31 | ((_STACK*) (1 ? p : (STACK_OF(type)*)0)) |
32 | ||
0f113f3e | 33 | # define CHECKED_SK_COPY_FUNC(type, p) \ |
66d884f0 VD |
34 | ((void *(*)(void *)) ((1 ? p : (type *(*)(const type *))0))) |
35 | ||
0f113f3e | 36 | # define CHECKED_SK_FREE_FUNC(type, p) \ |
a6fbcb42 | 37 | ((void (*)(void *)) ((1 ? p : (void (*)(type *))0))) |
1d1a6465 | 38 | |
0f113f3e | 39 | # define CHECKED_SK_CMP_FUNC(type, p) \ |
1ea6472e | 40 | ((int (*)(const void *, const void *)) \ |
0f113f3e | 41 | ((1 ? p : (int (*)(const type * const *, const type * const *))0))) |
1d1a6465 | 42 | |
0f113f3e | 43 | # define STACK_OF(type) struct stack_st_##type |
1d1a6465 | 44 | |
85885715 | 45 | # define SKM_DEFINE_STACK_OF(t1, t2, t3) \ |
411abf2d DSH |
46 | STACK_OF(t1); \ |
47 | static ossl_inline int sk_##t1##_num(const STACK_OF(t1) *sk) \ | |
48 | { \ | |
afdd82fb | 49 | return sk_num((const _STACK *)sk); \ |
411abf2d DSH |
50 | } \ |
51 | static ossl_inline t2 *sk_##t1##_value(const STACK_OF(t1) *sk, int idx) \ | |
52 | { \ | |
afdd82fb | 53 | return (t2 *)sk_value((const _STACK *)sk, idx); \ |
411abf2d DSH |
54 | } \ |
55 | static ossl_inline STACK_OF(t1) *sk_##t1##_new(int (*cmpf)(const t3 * const *a, const t3 * const *b)) \ | |
56 | { \ | |
57 | return (STACK_OF(t1) *)sk_new((int (*)(const void *a, const void *b))cmpf); \ | |
58 | } \ | |
59 | static ossl_inline STACK_OF(t1) *sk_##t1##_new_null(void) \ | |
60 | { \ | |
61 | return (STACK_OF(t1) *)sk_new_null(); \ | |
62 | } \ | |
afdd82fb | 63 | static ossl_inline void sk_##t1##_free(STACK_OF(t1) *sk) \ |
411abf2d DSH |
64 | { \ |
65 | sk_free((_STACK *)sk); \ | |
66 | } \ | |
afdd82fb | 67 | static ossl_inline void sk_##t1##_zero(STACK_OF(t1) *sk) \ |
411abf2d DSH |
68 | { \ |
69 | sk_zero((_STACK *)sk); \ | |
70 | } \ | |
71 | static ossl_inline t2 *sk_##t1##_delete(STACK_OF(t1) *sk, int i) \ | |
72 | { \ | |
77f31b3a | 73 | return (t2 *)sk_delete((_STACK *)sk, i); \ |
411abf2d DSH |
74 | } \ |
75 | static ossl_inline t2 *sk_##t1##_delete_ptr(STACK_OF(t1) *sk, t2 *ptr) \ | |
76 | { \ | |
77f31b3a | 77 | return (t2 *)sk_delete_ptr((_STACK *)sk, (void *)ptr); \ |
411abf2d DSH |
78 | } \ |
79 | static ossl_inline int sk_##t1##_push(STACK_OF(t1) *sk, t2 *ptr) \ | |
80 | { \ | |
81 | return sk_push((_STACK *)sk, (void *)ptr); \ | |
82 | } \ | |
83 | static ossl_inline int sk_##t1##_unshift(STACK_OF(t1) *sk, t2 *ptr) \ | |
84 | { \ | |
85 | return sk_unshift((_STACK *)sk, (void *)ptr); \ | |
86 | } \ | |
87 | static ossl_inline t2 *sk_##t1##_pop(STACK_OF(t1) *sk) \ | |
88 | { \ | |
89 | return (t2 *)sk_pop((_STACK *)sk); \ | |
90 | } \ | |
91 | static ossl_inline t2 *sk_##t1##_shift(STACK_OF(t1) *sk) \ | |
92 | { \ | |
93 | return (t2 *)sk_shift((_STACK *)sk); \ | |
94 | } \ | |
95 | static ossl_inline void sk_##t1##_pop_free(STACK_OF(t1) *sk, void (*func)(t3 *a)) \ | |
96 | { \ | |
97 | sk_pop_free((_STACK *)sk, (void (*)(void *))func); \ | |
98 | } \ | |
99 | static ossl_inline int sk_##t1##_insert(STACK_OF(t1) *sk, t2 *ptr, int idx) \ | |
100 | { \ | |
101 | return sk_insert((_STACK *)sk, (void *)ptr, idx); \ | |
102 | } \ | |
103 | static ossl_inline t2 *sk_##t1##_set(STACK_OF(t1) *sk, int idx, t2 *ptr) \ | |
104 | { \ | |
77f31b3a | 105 | return (t2 *)sk_set((_STACK *)sk, idx, (void *)ptr); \ |
411abf2d DSH |
106 | } \ |
107 | static ossl_inline int sk_##t1##_find(STACK_OF(t1) *sk, t2 *ptr) \ | |
108 | { \ | |
109 | return sk_find((_STACK *)sk, (void *)ptr); \ | |
110 | } \ | |
111 | static ossl_inline int sk_##t1##_find_ex(STACK_OF(t1) *sk, t2 *ptr) \ | |
112 | { \ | |
113 | return sk_find_ex((_STACK *)sk, (void *)ptr); \ | |
114 | } \ | |
afdd82fb | 115 | static ossl_inline void sk_##t1##_sort(STACK_OF(t1) *sk) \ |
411abf2d DSH |
116 | { \ |
117 | sk_sort((_STACK *)sk); \ | |
118 | } \ | |
119 | static ossl_inline int sk_##t1##_is_sorted(const STACK_OF(t1) *sk) \ | |
120 | { \ | |
afdd82fb | 121 | return sk_is_sorted((const _STACK *)sk); \ |
411abf2d DSH |
122 | } \ |
123 | static ossl_inline STACK_OF(t1) * sk_##t1##_dup(STACK_OF(t1) *sk) \ | |
124 | { \ | |
125 | return (STACK_OF(t1) *)sk_dup((_STACK *)sk); \ | |
126 | } \ | |
127 | static ossl_inline STACK_OF(t1) *sk_##t1##_deep_copy(STACK_OF(t1) *sk, \ | |
128 | t3 *(*copyfn)(const t3 *), \ | |
129 | void (*freefn)(t3 *)) \ | |
130 | { \ | |
131 | return (STACK_OF(t1) *)sk_deep_copy((_STACK *)sk, \ | |
132 | (void * (*)(void *a))copyfn, \ | |
133 | (void (*)(void *a))freefn); \ | |
134 | } \ | |
135 | static ossl_inline int (*sk_##t1##_set_cmp_func(STACK_OF(t1) *sk, int (*cmpf)(const t3 * const *a, const t3 * const *b)))(const t3 * const *, const t3 * const *) \ | |
136 | { \ | |
137 | return (int (*)(const t3 * const *,const t3 * const *))sk_set_cmp_func((_STACK *)sk, (int (*)(const void *a, const void *b))cmpf); \ | |
138 | } | |
139 | ||
85885715 DSH |
140 | # define DEFINE_SPECIAL_STACK_OF(t1, t2) SKM_DEFINE_STACK_OF(t1, t2, t2) |
141 | # define DEFINE_STACK_OF(t) SKM_DEFINE_STACK_OF(t, t, t) | |
a8eba56e | 142 | # define DEFINE_STACK_OF_CONST(t) SKM_DEFINE_STACK_OF(t, const t, t) |
1d1a6465 | 143 | |
1d97c843 TH |
144 | /*- |
145 | * Strings are special: normally an lhash entry will point to a single | |
5ce278a7 BL |
146 | * (somewhat) mutable object. In the case of strings: |
147 | * | |
148 | * a) Instead of a single char, there is an array of chars, NUL-terminated. | |
149 | * b) The string may have be immutable. | |
150 | * | |
151 | * So, they need their own declarations. Especially important for | |
152 | * type-checking tools, such as Deputy. | |
153 | * | |
1d97c843 | 154 | * In practice, however, it appears to be hard to have a const |
5ce278a7 BL |
155 | * string. For now, I'm settling for dealing with the fact it is a |
156 | * string at all. | |
157 | */ | |
c869da88 | 158 | typedef char *OPENSSL_STRING; |
c869da88 | 159 | typedef const char *OPENSSL_CSTRING; |
5ce278a7 | 160 | |
5b18d302 | 161 | /*- |
0f113f3e MC |
162 | * Confusingly, LHASH_OF(STRING) deals with char ** throughout, but |
163 | * STACK_OF(STRING) is really more like STACK_OF(char), only, as mentioned | |
164 | * above, instead of a single char each entry is a NUL-terminated array of | |
165 | * chars. So, we have to implement STRING specially for STACK_OF. This is | |
166 | * dealt with in the autogenerated macros below. | |
5ce278a7 | 167 | */ |
85885715 | 168 | DEFINE_SPECIAL_STACK_OF(OPENSSL_STRING, char) |
5ce278a7 | 169 | |
0f113f3e MC |
170 | /* |
171 | * Similarly, we sometimes use a block of characters, NOT nul-terminated. | |
172 | * These should also be distinguished from "normal" stacks. | |
173 | */ | |
512d359e | 174 | typedef void *OPENSSL_BLOCK; |
85885715 | 175 | DEFINE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void) |
5ce278a7 | 176 | |
5b18d302 | 177 | # ifdef __cplusplus |
17e80c6b | 178 | } |
5b18d302 | 179 | # endif |
17e80c6b | 180 | #endif |