]>
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 | # define STACK_OF(type) struct stack_st_##type |
1d1a6465 | 21 | |
85885715 | 22 | # define SKM_DEFINE_STACK_OF(t1, t2, t3) \ |
411abf2d | 23 | STACK_OF(t1); \ |
739a1eb1 RS |
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); \ | |
411abf2d DSH |
27 | static ossl_inline int sk_##t1##_num(const STACK_OF(t1) *sk) \ |
28 | { \ | |
739a1eb1 | 29 | return OPENSSL_sk_num((const OPENSSL_STACK *)sk); \ |
411abf2d DSH |
30 | } \ |
31 | static ossl_inline t2 *sk_##t1##_value(const STACK_OF(t1) *sk, int idx) \ | |
32 | { \ | |
739a1eb1 | 33 | return (t2 *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); \ |
411abf2d | 34 | } \ |
739a1eb1 | 35 | static ossl_inline STACK_OF(t1) *sk_##t1##_new(sk_##t1##_compfunc compare) \ |
411abf2d | 36 | { \ |
739a1eb1 | 37 | return (STACK_OF(t1) *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); \ |
411abf2d DSH |
38 | } \ |
39 | static ossl_inline STACK_OF(t1) *sk_##t1##_new_null(void) \ | |
40 | { \ | |
739a1eb1 | 41 | return (STACK_OF(t1) *)OPENSSL_sk_new_null(); \ |
411abf2d | 42 | } \ |
afdd82fb | 43 | static ossl_inline void sk_##t1##_free(STACK_OF(t1) *sk) \ |
411abf2d | 44 | { \ |
739a1eb1 | 45 | OPENSSL_sk_free((OPENSSL_STACK *)sk); \ |
411abf2d | 46 | } \ |
afdd82fb | 47 | static ossl_inline void sk_##t1##_zero(STACK_OF(t1) *sk) \ |
411abf2d | 48 | { \ |
739a1eb1 | 49 | OPENSSL_sk_zero((OPENSSL_STACK *)sk); \ |
411abf2d DSH |
50 | } \ |
51 | static ossl_inline t2 *sk_##t1##_delete(STACK_OF(t1) *sk, int i) \ | |
52 | { \ | |
739a1eb1 | 53 | return (t2 *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); \ |
411abf2d DSH |
54 | } \ |
55 | static ossl_inline t2 *sk_##t1##_delete_ptr(STACK_OF(t1) *sk, t2 *ptr) \ | |
56 | { \ | |
4591e5fb DSH |
57 | return (t2 *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, \ |
58 | (const void *)ptr); \ | |
411abf2d DSH |
59 | } \ |
60 | static ossl_inline int sk_##t1##_push(STACK_OF(t1) *sk, t2 *ptr) \ | |
61 | { \ | |
739a1eb1 | 62 | return OPENSSL_sk_push((OPENSSL_STACK *)sk, (void *)ptr); \ |
411abf2d DSH |
63 | } \ |
64 | static ossl_inline int sk_##t1##_unshift(STACK_OF(t1) *sk, t2 *ptr) \ | |
65 | { \ | |
739a1eb1 | 66 | return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (void *)ptr); \ |
411abf2d DSH |
67 | } \ |
68 | static ossl_inline t2 *sk_##t1##_pop(STACK_OF(t1) *sk) \ | |
69 | { \ | |
739a1eb1 | 70 | return (t2 *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); \ |
411abf2d DSH |
71 | } \ |
72 | static ossl_inline t2 *sk_##t1##_shift(STACK_OF(t1) *sk) \ | |
73 | { \ | |
739a1eb1 | 74 | return (t2 *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); \ |
411abf2d | 75 | } \ |
739a1eb1 | 76 | static ossl_inline void sk_##t1##_pop_free(STACK_OF(t1) *sk, sk_##t1##_freefunc freefunc) \ |
411abf2d | 77 | { \ |
739a1eb1 | 78 | OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); \ |
411abf2d DSH |
79 | } \ |
80 | static ossl_inline int sk_##t1##_insert(STACK_OF(t1) *sk, t2 *ptr, int idx) \ | |
81 | { \ | |
739a1eb1 | 82 | return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (void *)ptr, idx); \ |
411abf2d DSH |
83 | } \ |
84 | static ossl_inline t2 *sk_##t1##_set(STACK_OF(t1) *sk, int idx, t2 *ptr) \ | |
85 | { \ | |
739a1eb1 | 86 | return (t2 *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (void *)ptr); \ |
411abf2d DSH |
87 | } \ |
88 | static ossl_inline int sk_##t1##_find(STACK_OF(t1) *sk, t2 *ptr) \ | |
89 | { \ | |
4591e5fb | 90 | return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); \ |
411abf2d DSH |
91 | } \ |
92 | static ossl_inline int sk_##t1##_find_ex(STACK_OF(t1) *sk, t2 *ptr) \ | |
93 | { \ | |
4591e5fb | 94 | return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); \ |
411abf2d | 95 | } \ |
afdd82fb | 96 | static ossl_inline void sk_##t1##_sort(STACK_OF(t1) *sk) \ |
411abf2d | 97 | { \ |
739a1eb1 | 98 | OPENSSL_sk_sort((OPENSSL_STACK *)sk); \ |
411abf2d DSH |
99 | } \ |
100 | static ossl_inline int sk_##t1##_is_sorted(const STACK_OF(t1) *sk) \ | |
101 | { \ | |
739a1eb1 | 102 | return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); \ |
411abf2d DSH |
103 | } \ |
104 | static ossl_inline STACK_OF(t1) * sk_##t1##_dup(STACK_OF(t1) *sk) \ | |
105 | { \ | |
739a1eb1 | 106 | return (STACK_OF(t1) *)OPENSSL_sk_dup((OPENSSL_STACK *)sk); \ |
411abf2d DSH |
107 | } \ |
108 | static ossl_inline STACK_OF(t1) *sk_##t1##_deep_copy(STACK_OF(t1) *sk, \ | |
739a1eb1 RS |
109 | sk_##t1##_copyfunc copyfunc, \ |
110 | sk_##t1##_freefunc freefunc) \ | |
411abf2d | 111 | { \ |
739a1eb1 RS |
112 | return (STACK_OF(t1) *)OPENSSL_sk_deep_copy((OPENSSL_STACK *)sk, \ |
113 | (OPENSSL_sk_copyfunc)copyfunc, \ | |
114 | (OPENSSL_sk_freefunc)freefunc); \ | |
411abf2d | 115 | } \ |
739a1eb1 | 116 | static ossl_inline sk_##t1##_compfunc sk_##t1##_set_cmp_func(STACK_OF(t1) *sk, sk_##t1##_compfunc compare) \ |
411abf2d | 117 | { \ |
739a1eb1 | 118 | return (sk_##t1##_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); \ |
411abf2d DSH |
119 | } |
120 | ||
85885715 DSH |
121 | # define DEFINE_SPECIAL_STACK_OF(t1, t2) SKM_DEFINE_STACK_OF(t1, t2, t2) |
122 | # define DEFINE_STACK_OF(t) SKM_DEFINE_STACK_OF(t, t, t) | |
a8eba56e | 123 | # define DEFINE_STACK_OF_CONST(t) SKM_DEFINE_STACK_OF(t, const t, t) |
1d1a6465 | 124 | |
1d97c843 TH |
125 | /*- |
126 | * Strings are special: normally an lhash entry will point to a single | |
5ce278a7 BL |
127 | * (somewhat) mutable object. In the case of strings: |
128 | * | |
129 | * a) Instead of a single char, there is an array of chars, NUL-terminated. | |
130 | * b) The string may have be immutable. | |
131 | * | |
132 | * So, they need their own declarations. Especially important for | |
133 | * type-checking tools, such as Deputy. | |
134 | * | |
1d97c843 | 135 | * In practice, however, it appears to be hard to have a const |
5ce278a7 BL |
136 | * string. For now, I'm settling for dealing with the fact it is a |
137 | * string at all. | |
138 | */ | |
c869da88 | 139 | typedef char *OPENSSL_STRING; |
c869da88 | 140 | typedef const char *OPENSSL_CSTRING; |
5ce278a7 | 141 | |
5b18d302 | 142 | /*- |
0f113f3e MC |
143 | * Confusingly, LHASH_OF(STRING) deals with char ** throughout, but |
144 | * STACK_OF(STRING) is really more like STACK_OF(char), only, as mentioned | |
145 | * above, instead of a single char each entry is a NUL-terminated array of | |
146 | * chars. So, we have to implement STRING specially for STACK_OF. This is | |
147 | * dealt with in the autogenerated macros below. | |
5ce278a7 | 148 | */ |
85885715 | 149 | DEFINE_SPECIAL_STACK_OF(OPENSSL_STRING, char) |
5ce278a7 | 150 | |
0f113f3e MC |
151 | /* |
152 | * Similarly, we sometimes use a block of characters, NOT nul-terminated. | |
153 | * These should also be distinguished from "normal" stacks. | |
154 | */ | |
512d359e | 155 | typedef void *OPENSSL_BLOCK; |
85885715 | 156 | DEFINE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void) |
5ce278a7 | 157 | |
5b18d302 | 158 | # ifdef __cplusplus |
17e80c6b | 159 | } |
5b18d302 | 160 | # endif |
17e80c6b | 161 | #endif |