|
1 /* ==================================================================== |
|
2 * Copyright (c) 1999 The OpenSSL Project. All rights reserved. |
|
3 * |
|
4 * Redistribution and use in source and binary forms, with or without |
|
5 * modification, are permitted provided that the following conditions |
|
6 * are met: |
|
7 * |
|
8 * 1. Redistributions of source code must retain the above copyright |
|
9 * notice, this list of conditions and the following disclaimer. |
|
10 * |
|
11 * 2. Redistributions in binary form must reproduce the above copyright |
|
12 * notice, this list of conditions and the following disclaimer in |
|
13 * the documentation and/or other materials provided with the |
|
14 * distribution. |
|
15 * |
|
16 * 3. All advertising materials mentioning features or use of this |
|
17 * software must display the following acknowledgment: |
|
18 * "This product includes software developed by the OpenSSL Project |
|
19 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" |
|
20 * |
|
21 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|
22 * endorse or promote products derived from this software without |
|
23 * prior written permission. For written permission, please contact |
|
24 * openssl-core@openssl.org. |
|
25 * |
|
26 * 5. Products derived from this software may not be called "OpenSSL" |
|
27 * nor may "OpenSSL" appear in their names without prior written |
|
28 * permission of the OpenSSL Project. |
|
29 * |
|
30 * 6. Redistributions of any form whatsoever must retain the following |
|
31 * acknowledgment: |
|
32 * "This product includes software developed by the OpenSSL Project |
|
33 * for use in the OpenSSL Toolkit (http://www.openssl.org/)" |
|
34 * |
|
35 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|
36 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|
37 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|
38 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|
39 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
40 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|
41 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|
42 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|
43 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|
44 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|
45 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|
46 * OF THE POSSIBILITY OF SUCH DAMAGE. |
|
47 * ==================================================================== |
|
48 * |
|
49 * This product includes cryptographic software written by Eric Young |
|
50 * (eay@cryptsoft.com). This product includes software written by Tim |
|
51 * Hudson (tjh@cryptsoft.com). |
|
52 * |
|
53 */ |
|
54 |
|
55 #ifndef HEADER_SAFESTACK_H |
|
56 #define HEADER_SAFESTACK_H |
|
57 |
|
58 #include <openssl/stack.h> |
|
59 |
|
60 #ifdef DEBUG_SAFESTACK |
|
61 |
|
62 #define STACK_OF(type) struct stack_st_##type |
|
63 #define PREDECLARE_STACK_OF(type) STACK_OF(type); |
|
64 |
|
65 #define DECLARE_STACK_OF(type) \ |
|
66 STACK_OF(type) \ |
|
67 { \ |
|
68 STACK stack; \ |
|
69 }; |
|
70 |
|
71 #define IMPLEMENT_STACK_OF(type) /* nada (obsolete in new safestack approach)*/ |
|
72 |
|
73 /* SKM_sk_... stack macros are internal to safestack.h: |
|
74 * never use them directly, use sk_<type>_... instead */ |
|
75 #define SKM_sk_new(type, cmp) \ |
|
76 ((STACK_OF(type) * (*)(int (*)(const type * const *, const type * const *)))sk_new)(cmp) |
|
77 #define SKM_sk_new_null(type) \ |
|
78 ((STACK_OF(type) * (*)(void))sk_new_null)() |
|
79 #define SKM_sk_free(type, st) \ |
|
80 ((void (*)(STACK_OF(type) *))sk_free)(st) |
|
81 #define SKM_sk_num(type, st) \ |
|
82 ((int (*)(const STACK_OF(type) *))sk_num)(st) |
|
83 #define SKM_sk_value(type, st,i) \ |
|
84 ((type * (*)(const STACK_OF(type) *, int))sk_value)(st, i) |
|
85 #define SKM_sk_set(type, st,i,val) \ |
|
86 ((type * (*)(STACK_OF(type) *, int, type *))sk_set)(st, i, val) |
|
87 #define SKM_sk_zero(type, st) \ |
|
88 ((void (*)(STACK_OF(type) *))sk_zero)(st) |
|
89 #define SKM_sk_push(type, st,val) \ |
|
90 ((int (*)(STACK_OF(type) *, type *))sk_push)(st, val) |
|
91 #define SKM_sk_unshift(type, st,val) \ |
|
92 ((int (*)(STACK_OF(type) *, type *))sk_unshift)(st, val) |
|
93 #define SKM_sk_find(type, st,val) \ |
|
94 ((int (*)(STACK_OF(type) *, type *))sk_find)(st, val) |
|
95 #define SKM_sk_delete(type, st,i) \ |
|
96 ((type * (*)(STACK_OF(type) *, int))sk_delete)(st, i) |
|
97 #define SKM_sk_delete_ptr(type, st,ptr) \ |
|
98 ((type * (*)(STACK_OF(type) *, type *))sk_delete_ptr)(st, ptr) |
|
99 #define SKM_sk_insert(type, st,val,i) \ |
|
100 ((int (*)(STACK_OF(type) *, type *, int))sk_insert)(st, val, i) |
|
101 #define SKM_sk_set_cmp_func(type, st,cmp) \ |
|
102 ((int (*(*)(STACK_OF(type) *, int (*)(const type * const *, const type * const *))) \ |
|
103 (const type * const *, const type * const *))sk_set_cmp_func)\ |
|
104 (st, cmp) |
|
105 #define SKM_sk_dup(type, st) \ |
|
106 ((STACK_OF(type) *(*)(STACK_OF(type) *))sk_dup)(st) |
|
107 #define SKM_sk_pop_free(type, st,free_func) \ |
|
108 ((void (*)(STACK_OF(type) *, void (*)(type *)))sk_pop_free)\ |
|
109 (st, free_func) |
|
110 #define SKM_sk_shift(type, st) \ |
|
111 ((type * (*)(STACK_OF(type) *))sk_shift)(st) |
|
112 #define SKM_sk_pop(type, st) \ |
|
113 ((type * (*)(STACK_OF(type) *))sk_pop)(st) |
|
114 #define SKM_sk_sort(type, st) \ |
|
115 ((void (*)(STACK_OF(type) *))sk_sort)(st) |
|
116 |
|
117 #define SKM_ASN1_SET_OF_d2i(type, st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
118 ((STACK_OF(type) * (*) (STACK_OF(type) **,unsigned char **, long , \ |
|
119 type *(*)(type **, unsigned char **,long), \ |
|
120 void (*)(type *), int ,int )) d2i_ASN1_SET) \ |
|
121 (st,pp,length, d2i_func, free_func, ex_tag,ex_class) |
|
122 #define SKM_ASN1_SET_OF_i2d(type, st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
123 ((int (*)(STACK_OF(type) *,unsigned char **, \ |
|
124 int (*)(type *,unsigned char **), int , int , int)) i2d_ASN1_SET) \ |
|
125 (st,pp,i2d_func,ex_tag,ex_class,is_set) |
|
126 |
|
127 #define SKM_ASN1_seq_pack(type, st, i2d_func, buf, len) \ |
|
128 ((unsigned char *(*)(STACK_OF(type) *, \ |
|
129 int (*)(type *,unsigned char **), unsigned char **,int *)) ASN1_seq_pack) \ |
|
130 (st, i2d_func, buf, len) |
|
131 #define SKM_ASN1_seq_unpack(type, buf, len, d2i_func, free_func) \ |
|
132 ((STACK_OF(type) * (*)(unsigned char *,int, \ |
|
133 type *(*)(type **,unsigned char **, long), \ |
|
134 void (*)(type *)))ASN1_seq_unpack) \ |
|
135 (buf,len,d2i_func, free_func) |
|
136 |
|
137 #define SKM_PKCS12_decrypt_d2i(type, algor, d2i_func, free_func, pass, passlen, oct, seq) \ |
|
138 ((STACK_OF(type) * (*)(X509_ALGOR *, \ |
|
139 type *(*)(type **, unsigned char **, long), void (*)(type *), \ |
|
140 const char *, int, \ |
|
141 ASN1_STRING *, int))PKCS12_decrypt_d2i) \ |
|
142 (algor,d2i_func,free_func,pass,passlen,oct,seq) |
|
143 |
|
144 #else |
|
145 |
|
146 #define STACK_OF(type) STACK |
|
147 #define PREDECLARE_STACK_OF(type) /* nada */ |
|
148 #define DECLARE_STACK_OF(type) /* nada */ |
|
149 #define IMPLEMENT_STACK_OF(type) /* nada */ |
|
150 |
|
151 #define SKM_sk_new(type, cmp) \ |
|
152 sk_new((int (*)(const char * const *, const char * const *))(cmp)) |
|
153 #define SKM_sk_new_null(type) \ |
|
154 sk_new_null() |
|
155 #define SKM_sk_free(type, st) \ |
|
156 sk_free(st) |
|
157 #define SKM_sk_num(type, st) \ |
|
158 sk_num(st) |
|
159 #define SKM_sk_value(type, st,i) \ |
|
160 ((type *)sk_value(st, i)) |
|
161 #define SKM_sk_set(type, st,i,val) \ |
|
162 ((type *)sk_set(st, i,(char *)val)) |
|
163 #define SKM_sk_zero(type, st) \ |
|
164 sk_zero(st) |
|
165 #define SKM_sk_push(type, st,val) \ |
|
166 sk_push(st, (char *)val) |
|
167 #define SKM_sk_unshift(type, st,val) \ |
|
168 sk_unshift(st, val) |
|
169 #define SKM_sk_find(type, st,val) \ |
|
170 sk_find(st, (char *)val) |
|
171 #define SKM_sk_delete(type, st,i) \ |
|
172 ((type *)sk_delete(st, i)) |
|
173 #define SKM_sk_delete_ptr(type, st,ptr) \ |
|
174 ((type *)sk_delete_ptr(st,(char *)ptr)) |
|
175 #define SKM_sk_insert(type, st,val,i) \ |
|
176 sk_insert(st, (char *)val, i) |
|
177 #define SKM_sk_set_cmp_func(type, st,cmp) \ |
|
178 ((int (*)(const type * const *,const type * const *)) \ |
|
179 sk_set_cmp_func(st, (int (*)(const char * const *, const char * const *))(cmp))) |
|
180 #define SKM_sk_dup(type, st) \ |
|
181 sk_dup(st) |
|
182 #define SKM_sk_pop_free(type, st,free_func) \ |
|
183 sk_pop_free(st, (void (*)(void *))free_func) |
|
184 #define SKM_sk_shift(type, st) \ |
|
185 ((type *)sk_shift(st)) |
|
186 #define SKM_sk_pop(type, st) \ |
|
187 ((type *)sk_pop(st)) |
|
188 #define SKM_sk_sort(type, st) \ |
|
189 sk_sort(st) |
|
190 |
|
191 #define SKM_ASN1_SET_OF_d2i(type, st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
192 d2i_ASN1_SET(st,pp,length, (char *(*)())d2i_func, (void (*)(void *))free_func, ex_tag,ex_class) |
|
193 #define SKM_ASN1_SET_OF_i2d(type, st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
194 i2d_ASN1_SET(st,pp,i2d_func,ex_tag,ex_class,is_set) |
|
195 |
|
196 #define SKM_ASN1_seq_pack(type, st, i2d_func, buf, len) \ |
|
197 ASN1_seq_pack(st, i2d_func, buf, len) |
|
198 #define SKM_ASN1_seq_unpack(type, buf, len, d2i_func, free_func) \ |
|
199 ASN1_seq_unpack(buf,len,(char *(*)())d2i_func, (void(*)(void *))free_func) |
|
200 |
|
201 #define SKM_PKCS12_decrypt_d2i(type, algor, d2i_func, free_func, pass, passlen, oct, seq) \ |
|
202 ((STACK *)PKCS12_decrypt_d2i(algor,(char *(*)())d2i_func, (void(*)(void *))free_func,pass,passlen,oct,seq)) |
|
203 |
|
204 #endif |
|
205 |
|
206 /* This block of defines is updated by util/mkstack.pl, please do not touch! */ |
|
207 #define sk_ACCESS_DESCRIPTION_new(st) SKM_sk_new(ACCESS_DESCRIPTION, (st)) |
|
208 #define sk_ACCESS_DESCRIPTION_new_null() SKM_sk_new_null(ACCESS_DESCRIPTION) |
|
209 #define sk_ACCESS_DESCRIPTION_free(st) SKM_sk_free(ACCESS_DESCRIPTION, (st)) |
|
210 #define sk_ACCESS_DESCRIPTION_num(st) SKM_sk_num(ACCESS_DESCRIPTION, (st)) |
|
211 #define sk_ACCESS_DESCRIPTION_value(st, i) SKM_sk_value(ACCESS_DESCRIPTION, (st), (i)) |
|
212 #define sk_ACCESS_DESCRIPTION_set(st, i, val) SKM_sk_set(ACCESS_DESCRIPTION, (st), (i), (val)) |
|
213 #define sk_ACCESS_DESCRIPTION_zero(st) SKM_sk_zero(ACCESS_DESCRIPTION, (st)) |
|
214 #define sk_ACCESS_DESCRIPTION_push(st, val) SKM_sk_push(ACCESS_DESCRIPTION, (st), (val)) |
|
215 #define sk_ACCESS_DESCRIPTION_unshift(st, val) SKM_sk_unshift(ACCESS_DESCRIPTION, (st), (val)) |
|
216 #define sk_ACCESS_DESCRIPTION_find(st, val) SKM_sk_find(ACCESS_DESCRIPTION, (st), (val)) |
|
217 #define sk_ACCESS_DESCRIPTION_delete(st, i) SKM_sk_delete(ACCESS_DESCRIPTION, (st), (i)) |
|
218 #define sk_ACCESS_DESCRIPTION_delete_ptr(st, ptr) SKM_sk_delete_ptr(ACCESS_DESCRIPTION, (st), (ptr)) |
|
219 #define sk_ACCESS_DESCRIPTION_insert(st, val, i) SKM_sk_insert(ACCESS_DESCRIPTION, (st), (val), (i)) |
|
220 #define sk_ACCESS_DESCRIPTION_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ACCESS_DESCRIPTION, (st), (cmp)) |
|
221 #define sk_ACCESS_DESCRIPTION_dup(st) SKM_sk_dup(ACCESS_DESCRIPTION, st) |
|
222 #define sk_ACCESS_DESCRIPTION_pop_free(st, free_func) SKM_sk_pop_free(ACCESS_DESCRIPTION, (st), (free_func)) |
|
223 #define sk_ACCESS_DESCRIPTION_shift(st) SKM_sk_shift(ACCESS_DESCRIPTION, (st)) |
|
224 #define sk_ACCESS_DESCRIPTION_pop(st) SKM_sk_pop(ACCESS_DESCRIPTION, (st)) |
|
225 #define sk_ACCESS_DESCRIPTION_sort(st) SKM_sk_sort(ACCESS_DESCRIPTION, (st)) |
|
226 |
|
227 #define sk_ASN1_GENERALSTRING_new(st) SKM_sk_new(ASN1_GENERALSTRING, (st)) |
|
228 #define sk_ASN1_GENERALSTRING_new_null() SKM_sk_new_null(ASN1_GENERALSTRING) |
|
229 #define sk_ASN1_GENERALSTRING_free(st) SKM_sk_free(ASN1_GENERALSTRING, (st)) |
|
230 #define sk_ASN1_GENERALSTRING_num(st) SKM_sk_num(ASN1_GENERALSTRING, (st)) |
|
231 #define sk_ASN1_GENERALSTRING_value(st, i) SKM_sk_value(ASN1_GENERALSTRING, (st), (i)) |
|
232 #define sk_ASN1_GENERALSTRING_set(st, i, val) SKM_sk_set(ASN1_GENERALSTRING, (st), (i), (val)) |
|
233 #define sk_ASN1_GENERALSTRING_zero(st) SKM_sk_zero(ASN1_GENERALSTRING, (st)) |
|
234 #define sk_ASN1_GENERALSTRING_push(st, val) SKM_sk_push(ASN1_GENERALSTRING, (st), (val)) |
|
235 #define sk_ASN1_GENERALSTRING_unshift(st, val) SKM_sk_unshift(ASN1_GENERALSTRING, (st), (val)) |
|
236 #define sk_ASN1_GENERALSTRING_find(st, val) SKM_sk_find(ASN1_GENERALSTRING, (st), (val)) |
|
237 #define sk_ASN1_GENERALSTRING_delete(st, i) SKM_sk_delete(ASN1_GENERALSTRING, (st), (i)) |
|
238 #define sk_ASN1_GENERALSTRING_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_GENERALSTRING, (st), (ptr)) |
|
239 #define sk_ASN1_GENERALSTRING_insert(st, val, i) SKM_sk_insert(ASN1_GENERALSTRING, (st), (val), (i)) |
|
240 #define sk_ASN1_GENERALSTRING_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_GENERALSTRING, (st), (cmp)) |
|
241 #define sk_ASN1_GENERALSTRING_dup(st) SKM_sk_dup(ASN1_GENERALSTRING, st) |
|
242 #define sk_ASN1_GENERALSTRING_pop_free(st, free_func) SKM_sk_pop_free(ASN1_GENERALSTRING, (st), (free_func)) |
|
243 #define sk_ASN1_GENERALSTRING_shift(st) SKM_sk_shift(ASN1_GENERALSTRING, (st)) |
|
244 #define sk_ASN1_GENERALSTRING_pop(st) SKM_sk_pop(ASN1_GENERALSTRING, (st)) |
|
245 #define sk_ASN1_GENERALSTRING_sort(st) SKM_sk_sort(ASN1_GENERALSTRING, (st)) |
|
246 |
|
247 #define sk_ASN1_INTEGER_new(st) SKM_sk_new(ASN1_INTEGER, (st)) |
|
248 #define sk_ASN1_INTEGER_new_null() SKM_sk_new_null(ASN1_INTEGER) |
|
249 #define sk_ASN1_INTEGER_free(st) SKM_sk_free(ASN1_INTEGER, (st)) |
|
250 #define sk_ASN1_INTEGER_num(st) SKM_sk_num(ASN1_INTEGER, (st)) |
|
251 #define sk_ASN1_INTEGER_value(st, i) SKM_sk_value(ASN1_INTEGER, (st), (i)) |
|
252 #define sk_ASN1_INTEGER_set(st, i, val) SKM_sk_set(ASN1_INTEGER, (st), (i), (val)) |
|
253 #define sk_ASN1_INTEGER_zero(st) SKM_sk_zero(ASN1_INTEGER, (st)) |
|
254 #define sk_ASN1_INTEGER_push(st, val) SKM_sk_push(ASN1_INTEGER, (st), (val)) |
|
255 #define sk_ASN1_INTEGER_unshift(st, val) SKM_sk_unshift(ASN1_INTEGER, (st), (val)) |
|
256 #define sk_ASN1_INTEGER_find(st, val) SKM_sk_find(ASN1_INTEGER, (st), (val)) |
|
257 #define sk_ASN1_INTEGER_delete(st, i) SKM_sk_delete(ASN1_INTEGER, (st), (i)) |
|
258 #define sk_ASN1_INTEGER_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_INTEGER, (st), (ptr)) |
|
259 #define sk_ASN1_INTEGER_insert(st, val, i) SKM_sk_insert(ASN1_INTEGER, (st), (val), (i)) |
|
260 #define sk_ASN1_INTEGER_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_INTEGER, (st), (cmp)) |
|
261 #define sk_ASN1_INTEGER_dup(st) SKM_sk_dup(ASN1_INTEGER, st) |
|
262 #define sk_ASN1_INTEGER_pop_free(st, free_func) SKM_sk_pop_free(ASN1_INTEGER, (st), (free_func)) |
|
263 #define sk_ASN1_INTEGER_shift(st) SKM_sk_shift(ASN1_INTEGER, (st)) |
|
264 #define sk_ASN1_INTEGER_pop(st) SKM_sk_pop(ASN1_INTEGER, (st)) |
|
265 #define sk_ASN1_INTEGER_sort(st) SKM_sk_sort(ASN1_INTEGER, (st)) |
|
266 |
|
267 #define sk_ASN1_OBJECT_new(st) SKM_sk_new(ASN1_OBJECT, (st)) |
|
268 #define sk_ASN1_OBJECT_new_null() SKM_sk_new_null(ASN1_OBJECT) |
|
269 #define sk_ASN1_OBJECT_free(st) SKM_sk_free(ASN1_OBJECT, (st)) |
|
270 #define sk_ASN1_OBJECT_num(st) SKM_sk_num(ASN1_OBJECT, (st)) |
|
271 #define sk_ASN1_OBJECT_value(st, i) SKM_sk_value(ASN1_OBJECT, (st), (i)) |
|
272 #define sk_ASN1_OBJECT_set(st, i, val) SKM_sk_set(ASN1_OBJECT, (st), (i), (val)) |
|
273 #define sk_ASN1_OBJECT_zero(st) SKM_sk_zero(ASN1_OBJECT, (st)) |
|
274 #define sk_ASN1_OBJECT_push(st, val) SKM_sk_push(ASN1_OBJECT, (st), (val)) |
|
275 #define sk_ASN1_OBJECT_unshift(st, val) SKM_sk_unshift(ASN1_OBJECT, (st), (val)) |
|
276 #define sk_ASN1_OBJECT_find(st, val) SKM_sk_find(ASN1_OBJECT, (st), (val)) |
|
277 #define sk_ASN1_OBJECT_delete(st, i) SKM_sk_delete(ASN1_OBJECT, (st), (i)) |
|
278 #define sk_ASN1_OBJECT_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_OBJECT, (st), (ptr)) |
|
279 #define sk_ASN1_OBJECT_insert(st, val, i) SKM_sk_insert(ASN1_OBJECT, (st), (val), (i)) |
|
280 #define sk_ASN1_OBJECT_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_OBJECT, (st), (cmp)) |
|
281 #define sk_ASN1_OBJECT_dup(st) SKM_sk_dup(ASN1_OBJECT, st) |
|
282 #define sk_ASN1_OBJECT_pop_free(st, free_func) SKM_sk_pop_free(ASN1_OBJECT, (st), (free_func)) |
|
283 #define sk_ASN1_OBJECT_shift(st) SKM_sk_shift(ASN1_OBJECT, (st)) |
|
284 #define sk_ASN1_OBJECT_pop(st) SKM_sk_pop(ASN1_OBJECT, (st)) |
|
285 #define sk_ASN1_OBJECT_sort(st) SKM_sk_sort(ASN1_OBJECT, (st)) |
|
286 |
|
287 #define sk_ASN1_STRING_TABLE_new(st) SKM_sk_new(ASN1_STRING_TABLE, (st)) |
|
288 #define sk_ASN1_STRING_TABLE_new_null() SKM_sk_new_null(ASN1_STRING_TABLE) |
|
289 #define sk_ASN1_STRING_TABLE_free(st) SKM_sk_free(ASN1_STRING_TABLE, (st)) |
|
290 #define sk_ASN1_STRING_TABLE_num(st) SKM_sk_num(ASN1_STRING_TABLE, (st)) |
|
291 #define sk_ASN1_STRING_TABLE_value(st, i) SKM_sk_value(ASN1_STRING_TABLE, (st), (i)) |
|
292 #define sk_ASN1_STRING_TABLE_set(st, i, val) SKM_sk_set(ASN1_STRING_TABLE, (st), (i), (val)) |
|
293 #define sk_ASN1_STRING_TABLE_zero(st) SKM_sk_zero(ASN1_STRING_TABLE, (st)) |
|
294 #define sk_ASN1_STRING_TABLE_push(st, val) SKM_sk_push(ASN1_STRING_TABLE, (st), (val)) |
|
295 #define sk_ASN1_STRING_TABLE_unshift(st, val) SKM_sk_unshift(ASN1_STRING_TABLE, (st), (val)) |
|
296 #define sk_ASN1_STRING_TABLE_find(st, val) SKM_sk_find(ASN1_STRING_TABLE, (st), (val)) |
|
297 #define sk_ASN1_STRING_TABLE_delete(st, i) SKM_sk_delete(ASN1_STRING_TABLE, (st), (i)) |
|
298 #define sk_ASN1_STRING_TABLE_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_STRING_TABLE, (st), (ptr)) |
|
299 #define sk_ASN1_STRING_TABLE_insert(st, val, i) SKM_sk_insert(ASN1_STRING_TABLE, (st), (val), (i)) |
|
300 #define sk_ASN1_STRING_TABLE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_STRING_TABLE, (st), (cmp)) |
|
301 #define sk_ASN1_STRING_TABLE_dup(st) SKM_sk_dup(ASN1_STRING_TABLE, st) |
|
302 #define sk_ASN1_STRING_TABLE_pop_free(st, free_func) SKM_sk_pop_free(ASN1_STRING_TABLE, (st), (free_func)) |
|
303 #define sk_ASN1_STRING_TABLE_shift(st) SKM_sk_shift(ASN1_STRING_TABLE, (st)) |
|
304 #define sk_ASN1_STRING_TABLE_pop(st) SKM_sk_pop(ASN1_STRING_TABLE, (st)) |
|
305 #define sk_ASN1_STRING_TABLE_sort(st) SKM_sk_sort(ASN1_STRING_TABLE, (st)) |
|
306 |
|
307 #define sk_ASN1_TYPE_new(st) SKM_sk_new(ASN1_TYPE, (st)) |
|
308 #define sk_ASN1_TYPE_new_null() SKM_sk_new_null(ASN1_TYPE) |
|
309 #define sk_ASN1_TYPE_free(st) SKM_sk_free(ASN1_TYPE, (st)) |
|
310 #define sk_ASN1_TYPE_num(st) SKM_sk_num(ASN1_TYPE, (st)) |
|
311 #define sk_ASN1_TYPE_value(st, i) SKM_sk_value(ASN1_TYPE, (st), (i)) |
|
312 #define sk_ASN1_TYPE_set(st, i, val) SKM_sk_set(ASN1_TYPE, (st), (i), (val)) |
|
313 #define sk_ASN1_TYPE_zero(st) SKM_sk_zero(ASN1_TYPE, (st)) |
|
314 #define sk_ASN1_TYPE_push(st, val) SKM_sk_push(ASN1_TYPE, (st), (val)) |
|
315 #define sk_ASN1_TYPE_unshift(st, val) SKM_sk_unshift(ASN1_TYPE, (st), (val)) |
|
316 #define sk_ASN1_TYPE_find(st, val) SKM_sk_find(ASN1_TYPE, (st), (val)) |
|
317 #define sk_ASN1_TYPE_delete(st, i) SKM_sk_delete(ASN1_TYPE, (st), (i)) |
|
318 #define sk_ASN1_TYPE_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_TYPE, (st), (ptr)) |
|
319 #define sk_ASN1_TYPE_insert(st, val, i) SKM_sk_insert(ASN1_TYPE, (st), (val), (i)) |
|
320 #define sk_ASN1_TYPE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_TYPE, (st), (cmp)) |
|
321 #define sk_ASN1_TYPE_dup(st) SKM_sk_dup(ASN1_TYPE, st) |
|
322 #define sk_ASN1_TYPE_pop_free(st, free_func) SKM_sk_pop_free(ASN1_TYPE, (st), (free_func)) |
|
323 #define sk_ASN1_TYPE_shift(st) SKM_sk_shift(ASN1_TYPE, (st)) |
|
324 #define sk_ASN1_TYPE_pop(st) SKM_sk_pop(ASN1_TYPE, (st)) |
|
325 #define sk_ASN1_TYPE_sort(st) SKM_sk_sort(ASN1_TYPE, (st)) |
|
326 |
|
327 #define sk_ASN1_VALUE_new(st) SKM_sk_new(ASN1_VALUE, (st)) |
|
328 #define sk_ASN1_VALUE_new_null() SKM_sk_new_null(ASN1_VALUE) |
|
329 #define sk_ASN1_VALUE_free(st) SKM_sk_free(ASN1_VALUE, (st)) |
|
330 #define sk_ASN1_VALUE_num(st) SKM_sk_num(ASN1_VALUE, (st)) |
|
331 #define sk_ASN1_VALUE_value(st, i) SKM_sk_value(ASN1_VALUE, (st), (i)) |
|
332 #define sk_ASN1_VALUE_set(st, i, val) SKM_sk_set(ASN1_VALUE, (st), (i), (val)) |
|
333 #define sk_ASN1_VALUE_zero(st) SKM_sk_zero(ASN1_VALUE, (st)) |
|
334 #define sk_ASN1_VALUE_push(st, val) SKM_sk_push(ASN1_VALUE, (st), (val)) |
|
335 #define sk_ASN1_VALUE_unshift(st, val) SKM_sk_unshift(ASN1_VALUE, (st), (val)) |
|
336 #define sk_ASN1_VALUE_find(st, val) SKM_sk_find(ASN1_VALUE, (st), (val)) |
|
337 #define sk_ASN1_VALUE_delete(st, i) SKM_sk_delete(ASN1_VALUE, (st), (i)) |
|
338 #define sk_ASN1_VALUE_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_VALUE, (st), (ptr)) |
|
339 #define sk_ASN1_VALUE_insert(st, val, i) SKM_sk_insert(ASN1_VALUE, (st), (val), (i)) |
|
340 #define sk_ASN1_VALUE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_VALUE, (st), (cmp)) |
|
341 #define sk_ASN1_VALUE_dup(st) SKM_sk_dup(ASN1_VALUE, st) |
|
342 #define sk_ASN1_VALUE_pop_free(st, free_func) SKM_sk_pop_free(ASN1_VALUE, (st), (free_func)) |
|
343 #define sk_ASN1_VALUE_shift(st) SKM_sk_shift(ASN1_VALUE, (st)) |
|
344 #define sk_ASN1_VALUE_pop(st) SKM_sk_pop(ASN1_VALUE, (st)) |
|
345 #define sk_ASN1_VALUE_sort(st) SKM_sk_sort(ASN1_VALUE, (st)) |
|
346 |
|
347 #define sk_BIO_new(st) SKM_sk_new(BIO, (st)) |
|
348 #define sk_BIO_new_null() SKM_sk_new_null(BIO) |
|
349 #define sk_BIO_free(st) SKM_sk_free(BIO, (st)) |
|
350 #define sk_BIO_num(st) SKM_sk_num(BIO, (st)) |
|
351 #define sk_BIO_value(st, i) SKM_sk_value(BIO, (st), (i)) |
|
352 #define sk_BIO_set(st, i, val) SKM_sk_set(BIO, (st), (i), (val)) |
|
353 #define sk_BIO_zero(st) SKM_sk_zero(BIO, (st)) |
|
354 #define sk_BIO_push(st, val) SKM_sk_push(BIO, (st), (val)) |
|
355 #define sk_BIO_unshift(st, val) SKM_sk_unshift(BIO, (st), (val)) |
|
356 #define sk_BIO_find(st, val) SKM_sk_find(BIO, (st), (val)) |
|
357 #define sk_BIO_delete(st, i) SKM_sk_delete(BIO, (st), (i)) |
|
358 #define sk_BIO_delete_ptr(st, ptr) SKM_sk_delete_ptr(BIO, (st), (ptr)) |
|
359 #define sk_BIO_insert(st, val, i) SKM_sk_insert(BIO, (st), (val), (i)) |
|
360 #define sk_BIO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(BIO, (st), (cmp)) |
|
361 #define sk_BIO_dup(st) SKM_sk_dup(BIO, st) |
|
362 #define sk_BIO_pop_free(st, free_func) SKM_sk_pop_free(BIO, (st), (free_func)) |
|
363 #define sk_BIO_shift(st) SKM_sk_shift(BIO, (st)) |
|
364 #define sk_BIO_pop(st) SKM_sk_pop(BIO, (st)) |
|
365 #define sk_BIO_sort(st) SKM_sk_sort(BIO, (st)) |
|
366 |
|
367 #define sk_CONF_IMODULE_new(st) SKM_sk_new(CONF_IMODULE, (st)) |
|
368 #define sk_CONF_IMODULE_new_null() SKM_sk_new_null(CONF_IMODULE) |
|
369 #define sk_CONF_IMODULE_free(st) SKM_sk_free(CONF_IMODULE, (st)) |
|
370 #define sk_CONF_IMODULE_num(st) SKM_sk_num(CONF_IMODULE, (st)) |
|
371 #define sk_CONF_IMODULE_value(st, i) SKM_sk_value(CONF_IMODULE, (st), (i)) |
|
372 #define sk_CONF_IMODULE_set(st, i, val) SKM_sk_set(CONF_IMODULE, (st), (i), (val)) |
|
373 #define sk_CONF_IMODULE_zero(st) SKM_sk_zero(CONF_IMODULE, (st)) |
|
374 #define sk_CONF_IMODULE_push(st, val) SKM_sk_push(CONF_IMODULE, (st), (val)) |
|
375 #define sk_CONF_IMODULE_unshift(st, val) SKM_sk_unshift(CONF_IMODULE, (st), (val)) |
|
376 #define sk_CONF_IMODULE_find(st, val) SKM_sk_find(CONF_IMODULE, (st), (val)) |
|
377 #define sk_CONF_IMODULE_delete(st, i) SKM_sk_delete(CONF_IMODULE, (st), (i)) |
|
378 #define sk_CONF_IMODULE_delete_ptr(st, ptr) SKM_sk_delete_ptr(CONF_IMODULE, (st), (ptr)) |
|
379 #define sk_CONF_IMODULE_insert(st, val, i) SKM_sk_insert(CONF_IMODULE, (st), (val), (i)) |
|
380 #define sk_CONF_IMODULE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CONF_IMODULE, (st), (cmp)) |
|
381 #define sk_CONF_IMODULE_dup(st) SKM_sk_dup(CONF_IMODULE, st) |
|
382 #define sk_CONF_IMODULE_pop_free(st, free_func) SKM_sk_pop_free(CONF_IMODULE, (st), (free_func)) |
|
383 #define sk_CONF_IMODULE_shift(st) SKM_sk_shift(CONF_IMODULE, (st)) |
|
384 #define sk_CONF_IMODULE_pop(st) SKM_sk_pop(CONF_IMODULE, (st)) |
|
385 #define sk_CONF_IMODULE_sort(st) SKM_sk_sort(CONF_IMODULE, (st)) |
|
386 |
|
387 #define sk_CONF_MODULE_new(st) SKM_sk_new(CONF_MODULE, (st)) |
|
388 #define sk_CONF_MODULE_new_null() SKM_sk_new_null(CONF_MODULE) |
|
389 #define sk_CONF_MODULE_free(st) SKM_sk_free(CONF_MODULE, (st)) |
|
390 #define sk_CONF_MODULE_num(st) SKM_sk_num(CONF_MODULE, (st)) |
|
391 #define sk_CONF_MODULE_value(st, i) SKM_sk_value(CONF_MODULE, (st), (i)) |
|
392 #define sk_CONF_MODULE_set(st, i, val) SKM_sk_set(CONF_MODULE, (st), (i), (val)) |
|
393 #define sk_CONF_MODULE_zero(st) SKM_sk_zero(CONF_MODULE, (st)) |
|
394 #define sk_CONF_MODULE_push(st, val) SKM_sk_push(CONF_MODULE, (st), (val)) |
|
395 #define sk_CONF_MODULE_unshift(st, val) SKM_sk_unshift(CONF_MODULE, (st), (val)) |
|
396 #define sk_CONF_MODULE_find(st, val) SKM_sk_find(CONF_MODULE, (st), (val)) |
|
397 #define sk_CONF_MODULE_delete(st, i) SKM_sk_delete(CONF_MODULE, (st), (i)) |
|
398 #define sk_CONF_MODULE_delete_ptr(st, ptr) SKM_sk_delete_ptr(CONF_MODULE, (st), (ptr)) |
|
399 #define sk_CONF_MODULE_insert(st, val, i) SKM_sk_insert(CONF_MODULE, (st), (val), (i)) |
|
400 #define sk_CONF_MODULE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CONF_MODULE, (st), (cmp)) |
|
401 #define sk_CONF_MODULE_dup(st) SKM_sk_dup(CONF_MODULE, st) |
|
402 #define sk_CONF_MODULE_pop_free(st, free_func) SKM_sk_pop_free(CONF_MODULE, (st), (free_func)) |
|
403 #define sk_CONF_MODULE_shift(st) SKM_sk_shift(CONF_MODULE, (st)) |
|
404 #define sk_CONF_MODULE_pop(st) SKM_sk_pop(CONF_MODULE, (st)) |
|
405 #define sk_CONF_MODULE_sort(st) SKM_sk_sort(CONF_MODULE, (st)) |
|
406 |
|
407 #define sk_CONF_VALUE_new(st) SKM_sk_new(CONF_VALUE, (st)) |
|
408 #define sk_CONF_VALUE_new_null() SKM_sk_new_null(CONF_VALUE) |
|
409 #define sk_CONF_VALUE_free(st) SKM_sk_free(CONF_VALUE, (st)) |
|
410 #define sk_CONF_VALUE_num(st) SKM_sk_num(CONF_VALUE, (st)) |
|
411 #define sk_CONF_VALUE_value(st, i) SKM_sk_value(CONF_VALUE, (st), (i)) |
|
412 #define sk_CONF_VALUE_set(st, i, val) SKM_sk_set(CONF_VALUE, (st), (i), (val)) |
|
413 #define sk_CONF_VALUE_zero(st) SKM_sk_zero(CONF_VALUE, (st)) |
|
414 #define sk_CONF_VALUE_push(st, val) SKM_sk_push(CONF_VALUE, (st), (val)) |
|
415 #define sk_CONF_VALUE_unshift(st, val) SKM_sk_unshift(CONF_VALUE, (st), (val)) |
|
416 #define sk_CONF_VALUE_find(st, val) SKM_sk_find(CONF_VALUE, (st), (val)) |
|
417 #define sk_CONF_VALUE_delete(st, i) SKM_sk_delete(CONF_VALUE, (st), (i)) |
|
418 #define sk_CONF_VALUE_delete_ptr(st, ptr) SKM_sk_delete_ptr(CONF_VALUE, (st), (ptr)) |
|
419 #define sk_CONF_VALUE_insert(st, val, i) SKM_sk_insert(CONF_VALUE, (st), (val), (i)) |
|
420 #define sk_CONF_VALUE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CONF_VALUE, (st), (cmp)) |
|
421 #define sk_CONF_VALUE_dup(st) SKM_sk_dup(CONF_VALUE, st) |
|
422 #define sk_CONF_VALUE_pop_free(st, free_func) SKM_sk_pop_free(CONF_VALUE, (st), (free_func)) |
|
423 #define sk_CONF_VALUE_shift(st) SKM_sk_shift(CONF_VALUE, (st)) |
|
424 #define sk_CONF_VALUE_pop(st) SKM_sk_pop(CONF_VALUE, (st)) |
|
425 #define sk_CONF_VALUE_sort(st) SKM_sk_sort(CONF_VALUE, (st)) |
|
426 |
|
427 #define sk_CRYPTO_EX_DATA_FUNCS_new(st) SKM_sk_new(CRYPTO_EX_DATA_FUNCS, (st)) |
|
428 #define sk_CRYPTO_EX_DATA_FUNCS_new_null() SKM_sk_new_null(CRYPTO_EX_DATA_FUNCS) |
|
429 #define sk_CRYPTO_EX_DATA_FUNCS_free(st) SKM_sk_free(CRYPTO_EX_DATA_FUNCS, (st)) |
|
430 #define sk_CRYPTO_EX_DATA_FUNCS_num(st) SKM_sk_num(CRYPTO_EX_DATA_FUNCS, (st)) |
|
431 #define sk_CRYPTO_EX_DATA_FUNCS_value(st, i) SKM_sk_value(CRYPTO_EX_DATA_FUNCS, (st), (i)) |
|
432 #define sk_CRYPTO_EX_DATA_FUNCS_set(st, i, val) SKM_sk_set(CRYPTO_EX_DATA_FUNCS, (st), (i), (val)) |
|
433 #define sk_CRYPTO_EX_DATA_FUNCS_zero(st) SKM_sk_zero(CRYPTO_EX_DATA_FUNCS, (st)) |
|
434 #define sk_CRYPTO_EX_DATA_FUNCS_push(st, val) SKM_sk_push(CRYPTO_EX_DATA_FUNCS, (st), (val)) |
|
435 #define sk_CRYPTO_EX_DATA_FUNCS_unshift(st, val) SKM_sk_unshift(CRYPTO_EX_DATA_FUNCS, (st), (val)) |
|
436 #define sk_CRYPTO_EX_DATA_FUNCS_find(st, val) SKM_sk_find(CRYPTO_EX_DATA_FUNCS, (st), (val)) |
|
437 #define sk_CRYPTO_EX_DATA_FUNCS_delete(st, i) SKM_sk_delete(CRYPTO_EX_DATA_FUNCS, (st), (i)) |
|
438 #define sk_CRYPTO_EX_DATA_FUNCS_delete_ptr(st, ptr) SKM_sk_delete_ptr(CRYPTO_EX_DATA_FUNCS, (st), (ptr)) |
|
439 #define sk_CRYPTO_EX_DATA_FUNCS_insert(st, val, i) SKM_sk_insert(CRYPTO_EX_DATA_FUNCS, (st), (val), (i)) |
|
440 #define sk_CRYPTO_EX_DATA_FUNCS_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CRYPTO_EX_DATA_FUNCS, (st), (cmp)) |
|
441 #define sk_CRYPTO_EX_DATA_FUNCS_dup(st) SKM_sk_dup(CRYPTO_EX_DATA_FUNCS, st) |
|
442 #define sk_CRYPTO_EX_DATA_FUNCS_pop_free(st, free_func) SKM_sk_pop_free(CRYPTO_EX_DATA_FUNCS, (st), (free_func)) |
|
443 #define sk_CRYPTO_EX_DATA_FUNCS_shift(st) SKM_sk_shift(CRYPTO_EX_DATA_FUNCS, (st)) |
|
444 #define sk_CRYPTO_EX_DATA_FUNCS_pop(st) SKM_sk_pop(CRYPTO_EX_DATA_FUNCS, (st)) |
|
445 #define sk_CRYPTO_EX_DATA_FUNCS_sort(st) SKM_sk_sort(CRYPTO_EX_DATA_FUNCS, (st)) |
|
446 |
|
447 #define sk_CRYPTO_dynlock_new(st) SKM_sk_new(CRYPTO_dynlock, (st)) |
|
448 #define sk_CRYPTO_dynlock_new_null() SKM_sk_new_null(CRYPTO_dynlock) |
|
449 #define sk_CRYPTO_dynlock_free(st) SKM_sk_free(CRYPTO_dynlock, (st)) |
|
450 #define sk_CRYPTO_dynlock_num(st) SKM_sk_num(CRYPTO_dynlock, (st)) |
|
451 #define sk_CRYPTO_dynlock_value(st, i) SKM_sk_value(CRYPTO_dynlock, (st), (i)) |
|
452 #define sk_CRYPTO_dynlock_set(st, i, val) SKM_sk_set(CRYPTO_dynlock, (st), (i), (val)) |
|
453 #define sk_CRYPTO_dynlock_zero(st) SKM_sk_zero(CRYPTO_dynlock, (st)) |
|
454 #define sk_CRYPTO_dynlock_push(st, val) SKM_sk_push(CRYPTO_dynlock, (st), (val)) |
|
455 #define sk_CRYPTO_dynlock_unshift(st, val) SKM_sk_unshift(CRYPTO_dynlock, (st), (val)) |
|
456 #define sk_CRYPTO_dynlock_find(st, val) SKM_sk_find(CRYPTO_dynlock, (st), (val)) |
|
457 #define sk_CRYPTO_dynlock_delete(st, i) SKM_sk_delete(CRYPTO_dynlock, (st), (i)) |
|
458 #define sk_CRYPTO_dynlock_delete_ptr(st, ptr) SKM_sk_delete_ptr(CRYPTO_dynlock, (st), (ptr)) |
|
459 #define sk_CRYPTO_dynlock_insert(st, val, i) SKM_sk_insert(CRYPTO_dynlock, (st), (val), (i)) |
|
460 #define sk_CRYPTO_dynlock_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CRYPTO_dynlock, (st), (cmp)) |
|
461 #define sk_CRYPTO_dynlock_dup(st) SKM_sk_dup(CRYPTO_dynlock, st) |
|
462 #define sk_CRYPTO_dynlock_pop_free(st, free_func) SKM_sk_pop_free(CRYPTO_dynlock, (st), (free_func)) |
|
463 #define sk_CRYPTO_dynlock_shift(st) SKM_sk_shift(CRYPTO_dynlock, (st)) |
|
464 #define sk_CRYPTO_dynlock_pop(st) SKM_sk_pop(CRYPTO_dynlock, (st)) |
|
465 #define sk_CRYPTO_dynlock_sort(st) SKM_sk_sort(CRYPTO_dynlock, (st)) |
|
466 |
|
467 #define sk_DIST_POINT_new(st) SKM_sk_new(DIST_POINT, (st)) |
|
468 #define sk_DIST_POINT_new_null() SKM_sk_new_null(DIST_POINT) |
|
469 #define sk_DIST_POINT_free(st) SKM_sk_free(DIST_POINT, (st)) |
|
470 #define sk_DIST_POINT_num(st) SKM_sk_num(DIST_POINT, (st)) |
|
471 #define sk_DIST_POINT_value(st, i) SKM_sk_value(DIST_POINT, (st), (i)) |
|
472 #define sk_DIST_POINT_set(st, i, val) SKM_sk_set(DIST_POINT, (st), (i), (val)) |
|
473 #define sk_DIST_POINT_zero(st) SKM_sk_zero(DIST_POINT, (st)) |
|
474 #define sk_DIST_POINT_push(st, val) SKM_sk_push(DIST_POINT, (st), (val)) |
|
475 #define sk_DIST_POINT_unshift(st, val) SKM_sk_unshift(DIST_POINT, (st), (val)) |
|
476 #define sk_DIST_POINT_find(st, val) SKM_sk_find(DIST_POINT, (st), (val)) |
|
477 #define sk_DIST_POINT_delete(st, i) SKM_sk_delete(DIST_POINT, (st), (i)) |
|
478 #define sk_DIST_POINT_delete_ptr(st, ptr) SKM_sk_delete_ptr(DIST_POINT, (st), (ptr)) |
|
479 #define sk_DIST_POINT_insert(st, val, i) SKM_sk_insert(DIST_POINT, (st), (val), (i)) |
|
480 #define sk_DIST_POINT_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(DIST_POINT, (st), (cmp)) |
|
481 #define sk_DIST_POINT_dup(st) SKM_sk_dup(DIST_POINT, st) |
|
482 #define sk_DIST_POINT_pop_free(st, free_func) SKM_sk_pop_free(DIST_POINT, (st), (free_func)) |
|
483 #define sk_DIST_POINT_shift(st) SKM_sk_shift(DIST_POINT, (st)) |
|
484 #define sk_DIST_POINT_pop(st) SKM_sk_pop(DIST_POINT, (st)) |
|
485 #define sk_DIST_POINT_sort(st) SKM_sk_sort(DIST_POINT, (st)) |
|
486 |
|
487 #define sk_ENGINE_new(st) SKM_sk_new(ENGINE, (st)) |
|
488 #define sk_ENGINE_new_null() SKM_sk_new_null(ENGINE) |
|
489 #define sk_ENGINE_free(st) SKM_sk_free(ENGINE, (st)) |
|
490 #define sk_ENGINE_num(st) SKM_sk_num(ENGINE, (st)) |
|
491 #define sk_ENGINE_value(st, i) SKM_sk_value(ENGINE, (st), (i)) |
|
492 #define sk_ENGINE_set(st, i, val) SKM_sk_set(ENGINE, (st), (i), (val)) |
|
493 #define sk_ENGINE_zero(st) SKM_sk_zero(ENGINE, (st)) |
|
494 #define sk_ENGINE_push(st, val) SKM_sk_push(ENGINE, (st), (val)) |
|
495 #define sk_ENGINE_unshift(st, val) SKM_sk_unshift(ENGINE, (st), (val)) |
|
496 #define sk_ENGINE_find(st, val) SKM_sk_find(ENGINE, (st), (val)) |
|
497 #define sk_ENGINE_delete(st, i) SKM_sk_delete(ENGINE, (st), (i)) |
|
498 #define sk_ENGINE_delete_ptr(st, ptr) SKM_sk_delete_ptr(ENGINE, (st), (ptr)) |
|
499 #define sk_ENGINE_insert(st, val, i) SKM_sk_insert(ENGINE, (st), (val), (i)) |
|
500 #define sk_ENGINE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ENGINE, (st), (cmp)) |
|
501 #define sk_ENGINE_dup(st) SKM_sk_dup(ENGINE, st) |
|
502 #define sk_ENGINE_pop_free(st, free_func) SKM_sk_pop_free(ENGINE, (st), (free_func)) |
|
503 #define sk_ENGINE_shift(st) SKM_sk_shift(ENGINE, (st)) |
|
504 #define sk_ENGINE_pop(st) SKM_sk_pop(ENGINE, (st)) |
|
505 #define sk_ENGINE_sort(st) SKM_sk_sort(ENGINE, (st)) |
|
506 |
|
507 #define sk_ENGINE_CLEANUP_ITEM_new(st) SKM_sk_new(ENGINE_CLEANUP_ITEM, (st)) |
|
508 #define sk_ENGINE_CLEANUP_ITEM_new_null() SKM_sk_new_null(ENGINE_CLEANUP_ITEM) |
|
509 #define sk_ENGINE_CLEANUP_ITEM_free(st) SKM_sk_free(ENGINE_CLEANUP_ITEM, (st)) |
|
510 #define sk_ENGINE_CLEANUP_ITEM_num(st) SKM_sk_num(ENGINE_CLEANUP_ITEM, (st)) |
|
511 #define sk_ENGINE_CLEANUP_ITEM_value(st, i) SKM_sk_value(ENGINE_CLEANUP_ITEM, (st), (i)) |
|
512 #define sk_ENGINE_CLEANUP_ITEM_set(st, i, val) SKM_sk_set(ENGINE_CLEANUP_ITEM, (st), (i), (val)) |
|
513 #define sk_ENGINE_CLEANUP_ITEM_zero(st) SKM_sk_zero(ENGINE_CLEANUP_ITEM, (st)) |
|
514 #define sk_ENGINE_CLEANUP_ITEM_push(st, val) SKM_sk_push(ENGINE_CLEANUP_ITEM, (st), (val)) |
|
515 #define sk_ENGINE_CLEANUP_ITEM_unshift(st, val) SKM_sk_unshift(ENGINE_CLEANUP_ITEM, (st), (val)) |
|
516 #define sk_ENGINE_CLEANUP_ITEM_find(st, val) SKM_sk_find(ENGINE_CLEANUP_ITEM, (st), (val)) |
|
517 #define sk_ENGINE_CLEANUP_ITEM_delete(st, i) SKM_sk_delete(ENGINE_CLEANUP_ITEM, (st), (i)) |
|
518 #define sk_ENGINE_CLEANUP_ITEM_delete_ptr(st, ptr) SKM_sk_delete_ptr(ENGINE_CLEANUP_ITEM, (st), (ptr)) |
|
519 #define sk_ENGINE_CLEANUP_ITEM_insert(st, val, i) SKM_sk_insert(ENGINE_CLEANUP_ITEM, (st), (val), (i)) |
|
520 #define sk_ENGINE_CLEANUP_ITEM_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ENGINE_CLEANUP_ITEM, (st), (cmp)) |
|
521 #define sk_ENGINE_CLEANUP_ITEM_dup(st) SKM_sk_dup(ENGINE_CLEANUP_ITEM, st) |
|
522 #define sk_ENGINE_CLEANUP_ITEM_pop_free(st, free_func) SKM_sk_pop_free(ENGINE_CLEANUP_ITEM, (st), (free_func)) |
|
523 #define sk_ENGINE_CLEANUP_ITEM_shift(st) SKM_sk_shift(ENGINE_CLEANUP_ITEM, (st)) |
|
524 #define sk_ENGINE_CLEANUP_ITEM_pop(st) SKM_sk_pop(ENGINE_CLEANUP_ITEM, (st)) |
|
525 #define sk_ENGINE_CLEANUP_ITEM_sort(st) SKM_sk_sort(ENGINE_CLEANUP_ITEM, (st)) |
|
526 |
|
527 #define sk_GENERAL_NAME_new(st) SKM_sk_new(GENERAL_NAME, (st)) |
|
528 #define sk_GENERAL_NAME_new_null() SKM_sk_new_null(GENERAL_NAME) |
|
529 #define sk_GENERAL_NAME_free(st) SKM_sk_free(GENERAL_NAME, (st)) |
|
530 #define sk_GENERAL_NAME_num(st) SKM_sk_num(GENERAL_NAME, (st)) |
|
531 #define sk_GENERAL_NAME_value(st, i) SKM_sk_value(GENERAL_NAME, (st), (i)) |
|
532 #define sk_GENERAL_NAME_set(st, i, val) SKM_sk_set(GENERAL_NAME, (st), (i), (val)) |
|
533 #define sk_GENERAL_NAME_zero(st) SKM_sk_zero(GENERAL_NAME, (st)) |
|
534 #define sk_GENERAL_NAME_push(st, val) SKM_sk_push(GENERAL_NAME, (st), (val)) |
|
535 #define sk_GENERAL_NAME_unshift(st, val) SKM_sk_unshift(GENERAL_NAME, (st), (val)) |
|
536 #define sk_GENERAL_NAME_find(st, val) SKM_sk_find(GENERAL_NAME, (st), (val)) |
|
537 #define sk_GENERAL_NAME_delete(st, i) SKM_sk_delete(GENERAL_NAME, (st), (i)) |
|
538 #define sk_GENERAL_NAME_delete_ptr(st, ptr) SKM_sk_delete_ptr(GENERAL_NAME, (st), (ptr)) |
|
539 #define sk_GENERAL_NAME_insert(st, val, i) SKM_sk_insert(GENERAL_NAME, (st), (val), (i)) |
|
540 #define sk_GENERAL_NAME_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(GENERAL_NAME, (st), (cmp)) |
|
541 #define sk_GENERAL_NAME_dup(st) SKM_sk_dup(GENERAL_NAME, st) |
|
542 #define sk_GENERAL_NAME_pop_free(st, free_func) SKM_sk_pop_free(GENERAL_NAME, (st), (free_func)) |
|
543 #define sk_GENERAL_NAME_shift(st) SKM_sk_shift(GENERAL_NAME, (st)) |
|
544 #define sk_GENERAL_NAME_pop(st) SKM_sk_pop(GENERAL_NAME, (st)) |
|
545 #define sk_GENERAL_NAME_sort(st) SKM_sk_sort(GENERAL_NAME, (st)) |
|
546 |
|
547 #define sk_KRB5_APREQBODY_new(st) SKM_sk_new(KRB5_APREQBODY, (st)) |
|
548 #define sk_KRB5_APREQBODY_new_null() SKM_sk_new_null(KRB5_APREQBODY) |
|
549 #define sk_KRB5_APREQBODY_free(st) SKM_sk_free(KRB5_APREQBODY, (st)) |
|
550 #define sk_KRB5_APREQBODY_num(st) SKM_sk_num(KRB5_APREQBODY, (st)) |
|
551 #define sk_KRB5_APREQBODY_value(st, i) SKM_sk_value(KRB5_APREQBODY, (st), (i)) |
|
552 #define sk_KRB5_APREQBODY_set(st, i, val) SKM_sk_set(KRB5_APREQBODY, (st), (i), (val)) |
|
553 #define sk_KRB5_APREQBODY_zero(st) SKM_sk_zero(KRB5_APREQBODY, (st)) |
|
554 #define sk_KRB5_APREQBODY_push(st, val) SKM_sk_push(KRB5_APREQBODY, (st), (val)) |
|
555 #define sk_KRB5_APREQBODY_unshift(st, val) SKM_sk_unshift(KRB5_APREQBODY, (st), (val)) |
|
556 #define sk_KRB5_APREQBODY_find(st, val) SKM_sk_find(KRB5_APREQBODY, (st), (val)) |
|
557 #define sk_KRB5_APREQBODY_delete(st, i) SKM_sk_delete(KRB5_APREQBODY, (st), (i)) |
|
558 #define sk_KRB5_APREQBODY_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_APREQBODY, (st), (ptr)) |
|
559 #define sk_KRB5_APREQBODY_insert(st, val, i) SKM_sk_insert(KRB5_APREQBODY, (st), (val), (i)) |
|
560 #define sk_KRB5_APREQBODY_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_APREQBODY, (st), (cmp)) |
|
561 #define sk_KRB5_APREQBODY_dup(st) SKM_sk_dup(KRB5_APREQBODY, st) |
|
562 #define sk_KRB5_APREQBODY_pop_free(st, free_func) SKM_sk_pop_free(KRB5_APREQBODY, (st), (free_func)) |
|
563 #define sk_KRB5_APREQBODY_shift(st) SKM_sk_shift(KRB5_APREQBODY, (st)) |
|
564 #define sk_KRB5_APREQBODY_pop(st) SKM_sk_pop(KRB5_APREQBODY, (st)) |
|
565 #define sk_KRB5_APREQBODY_sort(st) SKM_sk_sort(KRB5_APREQBODY, (st)) |
|
566 |
|
567 #define sk_KRB5_AUTHDATA_new(st) SKM_sk_new(KRB5_AUTHDATA, (st)) |
|
568 #define sk_KRB5_AUTHDATA_new_null() SKM_sk_new_null(KRB5_AUTHDATA) |
|
569 #define sk_KRB5_AUTHDATA_free(st) SKM_sk_free(KRB5_AUTHDATA, (st)) |
|
570 #define sk_KRB5_AUTHDATA_num(st) SKM_sk_num(KRB5_AUTHDATA, (st)) |
|
571 #define sk_KRB5_AUTHDATA_value(st, i) SKM_sk_value(KRB5_AUTHDATA, (st), (i)) |
|
572 #define sk_KRB5_AUTHDATA_set(st, i, val) SKM_sk_set(KRB5_AUTHDATA, (st), (i), (val)) |
|
573 #define sk_KRB5_AUTHDATA_zero(st) SKM_sk_zero(KRB5_AUTHDATA, (st)) |
|
574 #define sk_KRB5_AUTHDATA_push(st, val) SKM_sk_push(KRB5_AUTHDATA, (st), (val)) |
|
575 #define sk_KRB5_AUTHDATA_unshift(st, val) SKM_sk_unshift(KRB5_AUTHDATA, (st), (val)) |
|
576 #define sk_KRB5_AUTHDATA_find(st, val) SKM_sk_find(KRB5_AUTHDATA, (st), (val)) |
|
577 #define sk_KRB5_AUTHDATA_delete(st, i) SKM_sk_delete(KRB5_AUTHDATA, (st), (i)) |
|
578 #define sk_KRB5_AUTHDATA_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_AUTHDATA, (st), (ptr)) |
|
579 #define sk_KRB5_AUTHDATA_insert(st, val, i) SKM_sk_insert(KRB5_AUTHDATA, (st), (val), (i)) |
|
580 #define sk_KRB5_AUTHDATA_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_AUTHDATA, (st), (cmp)) |
|
581 #define sk_KRB5_AUTHDATA_dup(st) SKM_sk_dup(KRB5_AUTHDATA, st) |
|
582 #define sk_KRB5_AUTHDATA_pop_free(st, free_func) SKM_sk_pop_free(KRB5_AUTHDATA, (st), (free_func)) |
|
583 #define sk_KRB5_AUTHDATA_shift(st) SKM_sk_shift(KRB5_AUTHDATA, (st)) |
|
584 #define sk_KRB5_AUTHDATA_pop(st) SKM_sk_pop(KRB5_AUTHDATA, (st)) |
|
585 #define sk_KRB5_AUTHDATA_sort(st) SKM_sk_sort(KRB5_AUTHDATA, (st)) |
|
586 |
|
587 #define sk_KRB5_AUTHENTBODY_new(st) SKM_sk_new(KRB5_AUTHENTBODY, (st)) |
|
588 #define sk_KRB5_AUTHENTBODY_new_null() SKM_sk_new_null(KRB5_AUTHENTBODY) |
|
589 #define sk_KRB5_AUTHENTBODY_free(st) SKM_sk_free(KRB5_AUTHENTBODY, (st)) |
|
590 #define sk_KRB5_AUTHENTBODY_num(st) SKM_sk_num(KRB5_AUTHENTBODY, (st)) |
|
591 #define sk_KRB5_AUTHENTBODY_value(st, i) SKM_sk_value(KRB5_AUTHENTBODY, (st), (i)) |
|
592 #define sk_KRB5_AUTHENTBODY_set(st, i, val) SKM_sk_set(KRB5_AUTHENTBODY, (st), (i), (val)) |
|
593 #define sk_KRB5_AUTHENTBODY_zero(st) SKM_sk_zero(KRB5_AUTHENTBODY, (st)) |
|
594 #define sk_KRB5_AUTHENTBODY_push(st, val) SKM_sk_push(KRB5_AUTHENTBODY, (st), (val)) |
|
595 #define sk_KRB5_AUTHENTBODY_unshift(st, val) SKM_sk_unshift(KRB5_AUTHENTBODY, (st), (val)) |
|
596 #define sk_KRB5_AUTHENTBODY_find(st, val) SKM_sk_find(KRB5_AUTHENTBODY, (st), (val)) |
|
597 #define sk_KRB5_AUTHENTBODY_delete(st, i) SKM_sk_delete(KRB5_AUTHENTBODY, (st), (i)) |
|
598 #define sk_KRB5_AUTHENTBODY_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_AUTHENTBODY, (st), (ptr)) |
|
599 #define sk_KRB5_AUTHENTBODY_insert(st, val, i) SKM_sk_insert(KRB5_AUTHENTBODY, (st), (val), (i)) |
|
600 #define sk_KRB5_AUTHENTBODY_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_AUTHENTBODY, (st), (cmp)) |
|
601 #define sk_KRB5_AUTHENTBODY_dup(st) SKM_sk_dup(KRB5_AUTHENTBODY, st) |
|
602 #define sk_KRB5_AUTHENTBODY_pop_free(st, free_func) SKM_sk_pop_free(KRB5_AUTHENTBODY, (st), (free_func)) |
|
603 #define sk_KRB5_AUTHENTBODY_shift(st) SKM_sk_shift(KRB5_AUTHENTBODY, (st)) |
|
604 #define sk_KRB5_AUTHENTBODY_pop(st) SKM_sk_pop(KRB5_AUTHENTBODY, (st)) |
|
605 #define sk_KRB5_AUTHENTBODY_sort(st) SKM_sk_sort(KRB5_AUTHENTBODY, (st)) |
|
606 |
|
607 #define sk_KRB5_CHECKSUM_new(st) SKM_sk_new(KRB5_CHECKSUM, (st)) |
|
608 #define sk_KRB5_CHECKSUM_new_null() SKM_sk_new_null(KRB5_CHECKSUM) |
|
609 #define sk_KRB5_CHECKSUM_free(st) SKM_sk_free(KRB5_CHECKSUM, (st)) |
|
610 #define sk_KRB5_CHECKSUM_num(st) SKM_sk_num(KRB5_CHECKSUM, (st)) |
|
611 #define sk_KRB5_CHECKSUM_value(st, i) SKM_sk_value(KRB5_CHECKSUM, (st), (i)) |
|
612 #define sk_KRB5_CHECKSUM_set(st, i, val) SKM_sk_set(KRB5_CHECKSUM, (st), (i), (val)) |
|
613 #define sk_KRB5_CHECKSUM_zero(st) SKM_sk_zero(KRB5_CHECKSUM, (st)) |
|
614 #define sk_KRB5_CHECKSUM_push(st, val) SKM_sk_push(KRB5_CHECKSUM, (st), (val)) |
|
615 #define sk_KRB5_CHECKSUM_unshift(st, val) SKM_sk_unshift(KRB5_CHECKSUM, (st), (val)) |
|
616 #define sk_KRB5_CHECKSUM_find(st, val) SKM_sk_find(KRB5_CHECKSUM, (st), (val)) |
|
617 #define sk_KRB5_CHECKSUM_delete(st, i) SKM_sk_delete(KRB5_CHECKSUM, (st), (i)) |
|
618 #define sk_KRB5_CHECKSUM_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_CHECKSUM, (st), (ptr)) |
|
619 #define sk_KRB5_CHECKSUM_insert(st, val, i) SKM_sk_insert(KRB5_CHECKSUM, (st), (val), (i)) |
|
620 #define sk_KRB5_CHECKSUM_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_CHECKSUM, (st), (cmp)) |
|
621 #define sk_KRB5_CHECKSUM_dup(st) SKM_sk_dup(KRB5_CHECKSUM, st) |
|
622 #define sk_KRB5_CHECKSUM_pop_free(st, free_func) SKM_sk_pop_free(KRB5_CHECKSUM, (st), (free_func)) |
|
623 #define sk_KRB5_CHECKSUM_shift(st) SKM_sk_shift(KRB5_CHECKSUM, (st)) |
|
624 #define sk_KRB5_CHECKSUM_pop(st) SKM_sk_pop(KRB5_CHECKSUM, (st)) |
|
625 #define sk_KRB5_CHECKSUM_sort(st) SKM_sk_sort(KRB5_CHECKSUM, (st)) |
|
626 |
|
627 #define sk_KRB5_ENCDATA_new(st) SKM_sk_new(KRB5_ENCDATA, (st)) |
|
628 #define sk_KRB5_ENCDATA_new_null() SKM_sk_new_null(KRB5_ENCDATA) |
|
629 #define sk_KRB5_ENCDATA_free(st) SKM_sk_free(KRB5_ENCDATA, (st)) |
|
630 #define sk_KRB5_ENCDATA_num(st) SKM_sk_num(KRB5_ENCDATA, (st)) |
|
631 #define sk_KRB5_ENCDATA_value(st, i) SKM_sk_value(KRB5_ENCDATA, (st), (i)) |
|
632 #define sk_KRB5_ENCDATA_set(st, i, val) SKM_sk_set(KRB5_ENCDATA, (st), (i), (val)) |
|
633 #define sk_KRB5_ENCDATA_zero(st) SKM_sk_zero(KRB5_ENCDATA, (st)) |
|
634 #define sk_KRB5_ENCDATA_push(st, val) SKM_sk_push(KRB5_ENCDATA, (st), (val)) |
|
635 #define sk_KRB5_ENCDATA_unshift(st, val) SKM_sk_unshift(KRB5_ENCDATA, (st), (val)) |
|
636 #define sk_KRB5_ENCDATA_find(st, val) SKM_sk_find(KRB5_ENCDATA, (st), (val)) |
|
637 #define sk_KRB5_ENCDATA_delete(st, i) SKM_sk_delete(KRB5_ENCDATA, (st), (i)) |
|
638 #define sk_KRB5_ENCDATA_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_ENCDATA, (st), (ptr)) |
|
639 #define sk_KRB5_ENCDATA_insert(st, val, i) SKM_sk_insert(KRB5_ENCDATA, (st), (val), (i)) |
|
640 #define sk_KRB5_ENCDATA_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_ENCDATA, (st), (cmp)) |
|
641 #define sk_KRB5_ENCDATA_dup(st) SKM_sk_dup(KRB5_ENCDATA, st) |
|
642 #define sk_KRB5_ENCDATA_pop_free(st, free_func) SKM_sk_pop_free(KRB5_ENCDATA, (st), (free_func)) |
|
643 #define sk_KRB5_ENCDATA_shift(st) SKM_sk_shift(KRB5_ENCDATA, (st)) |
|
644 #define sk_KRB5_ENCDATA_pop(st) SKM_sk_pop(KRB5_ENCDATA, (st)) |
|
645 #define sk_KRB5_ENCDATA_sort(st) SKM_sk_sort(KRB5_ENCDATA, (st)) |
|
646 |
|
647 #define sk_KRB5_ENCKEY_new(st) SKM_sk_new(KRB5_ENCKEY, (st)) |
|
648 #define sk_KRB5_ENCKEY_new_null() SKM_sk_new_null(KRB5_ENCKEY) |
|
649 #define sk_KRB5_ENCKEY_free(st) SKM_sk_free(KRB5_ENCKEY, (st)) |
|
650 #define sk_KRB5_ENCKEY_num(st) SKM_sk_num(KRB5_ENCKEY, (st)) |
|
651 #define sk_KRB5_ENCKEY_value(st, i) SKM_sk_value(KRB5_ENCKEY, (st), (i)) |
|
652 #define sk_KRB5_ENCKEY_set(st, i, val) SKM_sk_set(KRB5_ENCKEY, (st), (i), (val)) |
|
653 #define sk_KRB5_ENCKEY_zero(st) SKM_sk_zero(KRB5_ENCKEY, (st)) |
|
654 #define sk_KRB5_ENCKEY_push(st, val) SKM_sk_push(KRB5_ENCKEY, (st), (val)) |
|
655 #define sk_KRB5_ENCKEY_unshift(st, val) SKM_sk_unshift(KRB5_ENCKEY, (st), (val)) |
|
656 #define sk_KRB5_ENCKEY_find(st, val) SKM_sk_find(KRB5_ENCKEY, (st), (val)) |
|
657 #define sk_KRB5_ENCKEY_delete(st, i) SKM_sk_delete(KRB5_ENCKEY, (st), (i)) |
|
658 #define sk_KRB5_ENCKEY_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_ENCKEY, (st), (ptr)) |
|
659 #define sk_KRB5_ENCKEY_insert(st, val, i) SKM_sk_insert(KRB5_ENCKEY, (st), (val), (i)) |
|
660 #define sk_KRB5_ENCKEY_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_ENCKEY, (st), (cmp)) |
|
661 #define sk_KRB5_ENCKEY_dup(st) SKM_sk_dup(KRB5_ENCKEY, st) |
|
662 #define sk_KRB5_ENCKEY_pop_free(st, free_func) SKM_sk_pop_free(KRB5_ENCKEY, (st), (free_func)) |
|
663 #define sk_KRB5_ENCKEY_shift(st) SKM_sk_shift(KRB5_ENCKEY, (st)) |
|
664 #define sk_KRB5_ENCKEY_pop(st) SKM_sk_pop(KRB5_ENCKEY, (st)) |
|
665 #define sk_KRB5_ENCKEY_sort(st) SKM_sk_sort(KRB5_ENCKEY, (st)) |
|
666 |
|
667 #define sk_KRB5_PRINCNAME_new(st) SKM_sk_new(KRB5_PRINCNAME, (st)) |
|
668 #define sk_KRB5_PRINCNAME_new_null() SKM_sk_new_null(KRB5_PRINCNAME) |
|
669 #define sk_KRB5_PRINCNAME_free(st) SKM_sk_free(KRB5_PRINCNAME, (st)) |
|
670 #define sk_KRB5_PRINCNAME_num(st) SKM_sk_num(KRB5_PRINCNAME, (st)) |
|
671 #define sk_KRB5_PRINCNAME_value(st, i) SKM_sk_value(KRB5_PRINCNAME, (st), (i)) |
|
672 #define sk_KRB5_PRINCNAME_set(st, i, val) SKM_sk_set(KRB5_PRINCNAME, (st), (i), (val)) |
|
673 #define sk_KRB5_PRINCNAME_zero(st) SKM_sk_zero(KRB5_PRINCNAME, (st)) |
|
674 #define sk_KRB5_PRINCNAME_push(st, val) SKM_sk_push(KRB5_PRINCNAME, (st), (val)) |
|
675 #define sk_KRB5_PRINCNAME_unshift(st, val) SKM_sk_unshift(KRB5_PRINCNAME, (st), (val)) |
|
676 #define sk_KRB5_PRINCNAME_find(st, val) SKM_sk_find(KRB5_PRINCNAME, (st), (val)) |
|
677 #define sk_KRB5_PRINCNAME_delete(st, i) SKM_sk_delete(KRB5_PRINCNAME, (st), (i)) |
|
678 #define sk_KRB5_PRINCNAME_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_PRINCNAME, (st), (ptr)) |
|
679 #define sk_KRB5_PRINCNAME_insert(st, val, i) SKM_sk_insert(KRB5_PRINCNAME, (st), (val), (i)) |
|
680 #define sk_KRB5_PRINCNAME_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_PRINCNAME, (st), (cmp)) |
|
681 #define sk_KRB5_PRINCNAME_dup(st) SKM_sk_dup(KRB5_PRINCNAME, st) |
|
682 #define sk_KRB5_PRINCNAME_pop_free(st, free_func) SKM_sk_pop_free(KRB5_PRINCNAME, (st), (free_func)) |
|
683 #define sk_KRB5_PRINCNAME_shift(st) SKM_sk_shift(KRB5_PRINCNAME, (st)) |
|
684 #define sk_KRB5_PRINCNAME_pop(st) SKM_sk_pop(KRB5_PRINCNAME, (st)) |
|
685 #define sk_KRB5_PRINCNAME_sort(st) SKM_sk_sort(KRB5_PRINCNAME, (st)) |
|
686 |
|
687 #define sk_KRB5_TKTBODY_new(st) SKM_sk_new(KRB5_TKTBODY, (st)) |
|
688 #define sk_KRB5_TKTBODY_new_null() SKM_sk_new_null(KRB5_TKTBODY) |
|
689 #define sk_KRB5_TKTBODY_free(st) SKM_sk_free(KRB5_TKTBODY, (st)) |
|
690 #define sk_KRB5_TKTBODY_num(st) SKM_sk_num(KRB5_TKTBODY, (st)) |
|
691 #define sk_KRB5_TKTBODY_value(st, i) SKM_sk_value(KRB5_TKTBODY, (st), (i)) |
|
692 #define sk_KRB5_TKTBODY_set(st, i, val) SKM_sk_set(KRB5_TKTBODY, (st), (i), (val)) |
|
693 #define sk_KRB5_TKTBODY_zero(st) SKM_sk_zero(KRB5_TKTBODY, (st)) |
|
694 #define sk_KRB5_TKTBODY_push(st, val) SKM_sk_push(KRB5_TKTBODY, (st), (val)) |
|
695 #define sk_KRB5_TKTBODY_unshift(st, val) SKM_sk_unshift(KRB5_TKTBODY, (st), (val)) |
|
696 #define sk_KRB5_TKTBODY_find(st, val) SKM_sk_find(KRB5_TKTBODY, (st), (val)) |
|
697 #define sk_KRB5_TKTBODY_delete(st, i) SKM_sk_delete(KRB5_TKTBODY, (st), (i)) |
|
698 #define sk_KRB5_TKTBODY_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_TKTBODY, (st), (ptr)) |
|
699 #define sk_KRB5_TKTBODY_insert(st, val, i) SKM_sk_insert(KRB5_TKTBODY, (st), (val), (i)) |
|
700 #define sk_KRB5_TKTBODY_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_TKTBODY, (st), (cmp)) |
|
701 #define sk_KRB5_TKTBODY_dup(st) SKM_sk_dup(KRB5_TKTBODY, st) |
|
702 #define sk_KRB5_TKTBODY_pop_free(st, free_func) SKM_sk_pop_free(KRB5_TKTBODY, (st), (free_func)) |
|
703 #define sk_KRB5_TKTBODY_shift(st) SKM_sk_shift(KRB5_TKTBODY, (st)) |
|
704 #define sk_KRB5_TKTBODY_pop(st) SKM_sk_pop(KRB5_TKTBODY, (st)) |
|
705 #define sk_KRB5_TKTBODY_sort(st) SKM_sk_sort(KRB5_TKTBODY, (st)) |
|
706 |
|
707 #define sk_MIME_HEADER_new(st) SKM_sk_new(MIME_HEADER, (st)) |
|
708 #define sk_MIME_HEADER_new_null() SKM_sk_new_null(MIME_HEADER) |
|
709 #define sk_MIME_HEADER_free(st) SKM_sk_free(MIME_HEADER, (st)) |
|
710 #define sk_MIME_HEADER_num(st) SKM_sk_num(MIME_HEADER, (st)) |
|
711 #define sk_MIME_HEADER_value(st, i) SKM_sk_value(MIME_HEADER, (st), (i)) |
|
712 #define sk_MIME_HEADER_set(st, i, val) SKM_sk_set(MIME_HEADER, (st), (i), (val)) |
|
713 #define sk_MIME_HEADER_zero(st) SKM_sk_zero(MIME_HEADER, (st)) |
|
714 #define sk_MIME_HEADER_push(st, val) SKM_sk_push(MIME_HEADER, (st), (val)) |
|
715 #define sk_MIME_HEADER_unshift(st, val) SKM_sk_unshift(MIME_HEADER, (st), (val)) |
|
716 #define sk_MIME_HEADER_find(st, val) SKM_sk_find(MIME_HEADER, (st), (val)) |
|
717 #define sk_MIME_HEADER_delete(st, i) SKM_sk_delete(MIME_HEADER, (st), (i)) |
|
718 #define sk_MIME_HEADER_delete_ptr(st, ptr) SKM_sk_delete_ptr(MIME_HEADER, (st), (ptr)) |
|
719 #define sk_MIME_HEADER_insert(st, val, i) SKM_sk_insert(MIME_HEADER, (st), (val), (i)) |
|
720 #define sk_MIME_HEADER_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(MIME_HEADER, (st), (cmp)) |
|
721 #define sk_MIME_HEADER_dup(st) SKM_sk_dup(MIME_HEADER, st) |
|
722 #define sk_MIME_HEADER_pop_free(st, free_func) SKM_sk_pop_free(MIME_HEADER, (st), (free_func)) |
|
723 #define sk_MIME_HEADER_shift(st) SKM_sk_shift(MIME_HEADER, (st)) |
|
724 #define sk_MIME_HEADER_pop(st) SKM_sk_pop(MIME_HEADER, (st)) |
|
725 #define sk_MIME_HEADER_sort(st) SKM_sk_sort(MIME_HEADER, (st)) |
|
726 |
|
727 #define sk_MIME_PARAM_new(st) SKM_sk_new(MIME_PARAM, (st)) |
|
728 #define sk_MIME_PARAM_new_null() SKM_sk_new_null(MIME_PARAM) |
|
729 #define sk_MIME_PARAM_free(st) SKM_sk_free(MIME_PARAM, (st)) |
|
730 #define sk_MIME_PARAM_num(st) SKM_sk_num(MIME_PARAM, (st)) |
|
731 #define sk_MIME_PARAM_value(st, i) SKM_sk_value(MIME_PARAM, (st), (i)) |
|
732 #define sk_MIME_PARAM_set(st, i, val) SKM_sk_set(MIME_PARAM, (st), (i), (val)) |
|
733 #define sk_MIME_PARAM_zero(st) SKM_sk_zero(MIME_PARAM, (st)) |
|
734 #define sk_MIME_PARAM_push(st, val) SKM_sk_push(MIME_PARAM, (st), (val)) |
|
735 #define sk_MIME_PARAM_unshift(st, val) SKM_sk_unshift(MIME_PARAM, (st), (val)) |
|
736 #define sk_MIME_PARAM_find(st, val) SKM_sk_find(MIME_PARAM, (st), (val)) |
|
737 #define sk_MIME_PARAM_delete(st, i) SKM_sk_delete(MIME_PARAM, (st), (i)) |
|
738 #define sk_MIME_PARAM_delete_ptr(st, ptr) SKM_sk_delete_ptr(MIME_PARAM, (st), (ptr)) |
|
739 #define sk_MIME_PARAM_insert(st, val, i) SKM_sk_insert(MIME_PARAM, (st), (val), (i)) |
|
740 #define sk_MIME_PARAM_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(MIME_PARAM, (st), (cmp)) |
|
741 #define sk_MIME_PARAM_dup(st) SKM_sk_dup(MIME_PARAM, st) |
|
742 #define sk_MIME_PARAM_pop_free(st, free_func) SKM_sk_pop_free(MIME_PARAM, (st), (free_func)) |
|
743 #define sk_MIME_PARAM_shift(st) SKM_sk_shift(MIME_PARAM, (st)) |
|
744 #define sk_MIME_PARAM_pop(st) SKM_sk_pop(MIME_PARAM, (st)) |
|
745 #define sk_MIME_PARAM_sort(st) SKM_sk_sort(MIME_PARAM, (st)) |
|
746 |
|
747 #define sk_NAME_FUNCS_new(st) SKM_sk_new(NAME_FUNCS, (st)) |
|
748 #define sk_NAME_FUNCS_new_null() SKM_sk_new_null(NAME_FUNCS) |
|
749 #define sk_NAME_FUNCS_free(st) SKM_sk_free(NAME_FUNCS, (st)) |
|
750 #define sk_NAME_FUNCS_num(st) SKM_sk_num(NAME_FUNCS, (st)) |
|
751 #define sk_NAME_FUNCS_value(st, i) SKM_sk_value(NAME_FUNCS, (st), (i)) |
|
752 #define sk_NAME_FUNCS_set(st, i, val) SKM_sk_set(NAME_FUNCS, (st), (i), (val)) |
|
753 #define sk_NAME_FUNCS_zero(st) SKM_sk_zero(NAME_FUNCS, (st)) |
|
754 #define sk_NAME_FUNCS_push(st, val) SKM_sk_push(NAME_FUNCS, (st), (val)) |
|
755 #define sk_NAME_FUNCS_unshift(st, val) SKM_sk_unshift(NAME_FUNCS, (st), (val)) |
|
756 #define sk_NAME_FUNCS_find(st, val) SKM_sk_find(NAME_FUNCS, (st), (val)) |
|
757 #define sk_NAME_FUNCS_delete(st, i) SKM_sk_delete(NAME_FUNCS, (st), (i)) |
|
758 #define sk_NAME_FUNCS_delete_ptr(st, ptr) SKM_sk_delete_ptr(NAME_FUNCS, (st), (ptr)) |
|
759 #define sk_NAME_FUNCS_insert(st, val, i) SKM_sk_insert(NAME_FUNCS, (st), (val), (i)) |
|
760 #define sk_NAME_FUNCS_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(NAME_FUNCS, (st), (cmp)) |
|
761 #define sk_NAME_FUNCS_dup(st) SKM_sk_dup(NAME_FUNCS, st) |
|
762 #define sk_NAME_FUNCS_pop_free(st, free_func) SKM_sk_pop_free(NAME_FUNCS, (st), (free_func)) |
|
763 #define sk_NAME_FUNCS_shift(st) SKM_sk_shift(NAME_FUNCS, (st)) |
|
764 #define sk_NAME_FUNCS_pop(st) SKM_sk_pop(NAME_FUNCS, (st)) |
|
765 #define sk_NAME_FUNCS_sort(st) SKM_sk_sort(NAME_FUNCS, (st)) |
|
766 |
|
767 #define sk_OCSP_CERTID_new(st) SKM_sk_new(OCSP_CERTID, (st)) |
|
768 #define sk_OCSP_CERTID_new_null() SKM_sk_new_null(OCSP_CERTID) |
|
769 #define sk_OCSP_CERTID_free(st) SKM_sk_free(OCSP_CERTID, (st)) |
|
770 #define sk_OCSP_CERTID_num(st) SKM_sk_num(OCSP_CERTID, (st)) |
|
771 #define sk_OCSP_CERTID_value(st, i) SKM_sk_value(OCSP_CERTID, (st), (i)) |
|
772 #define sk_OCSP_CERTID_set(st, i, val) SKM_sk_set(OCSP_CERTID, (st), (i), (val)) |
|
773 #define sk_OCSP_CERTID_zero(st) SKM_sk_zero(OCSP_CERTID, (st)) |
|
774 #define sk_OCSP_CERTID_push(st, val) SKM_sk_push(OCSP_CERTID, (st), (val)) |
|
775 #define sk_OCSP_CERTID_unshift(st, val) SKM_sk_unshift(OCSP_CERTID, (st), (val)) |
|
776 #define sk_OCSP_CERTID_find(st, val) SKM_sk_find(OCSP_CERTID, (st), (val)) |
|
777 #define sk_OCSP_CERTID_delete(st, i) SKM_sk_delete(OCSP_CERTID, (st), (i)) |
|
778 #define sk_OCSP_CERTID_delete_ptr(st, ptr) SKM_sk_delete_ptr(OCSP_CERTID, (st), (ptr)) |
|
779 #define sk_OCSP_CERTID_insert(st, val, i) SKM_sk_insert(OCSP_CERTID, (st), (val), (i)) |
|
780 #define sk_OCSP_CERTID_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(OCSP_CERTID, (st), (cmp)) |
|
781 #define sk_OCSP_CERTID_dup(st) SKM_sk_dup(OCSP_CERTID, st) |
|
782 #define sk_OCSP_CERTID_pop_free(st, free_func) SKM_sk_pop_free(OCSP_CERTID, (st), (free_func)) |
|
783 #define sk_OCSP_CERTID_shift(st) SKM_sk_shift(OCSP_CERTID, (st)) |
|
784 #define sk_OCSP_CERTID_pop(st) SKM_sk_pop(OCSP_CERTID, (st)) |
|
785 #define sk_OCSP_CERTID_sort(st) SKM_sk_sort(OCSP_CERTID, (st)) |
|
786 |
|
787 #define sk_OCSP_ONEREQ_new(st) SKM_sk_new(OCSP_ONEREQ, (st)) |
|
788 #define sk_OCSP_ONEREQ_new_null() SKM_sk_new_null(OCSP_ONEREQ) |
|
789 #define sk_OCSP_ONEREQ_free(st) SKM_sk_free(OCSP_ONEREQ, (st)) |
|
790 #define sk_OCSP_ONEREQ_num(st) SKM_sk_num(OCSP_ONEREQ, (st)) |
|
791 #define sk_OCSP_ONEREQ_value(st, i) SKM_sk_value(OCSP_ONEREQ, (st), (i)) |
|
792 #define sk_OCSP_ONEREQ_set(st, i, val) SKM_sk_set(OCSP_ONEREQ, (st), (i), (val)) |
|
793 #define sk_OCSP_ONEREQ_zero(st) SKM_sk_zero(OCSP_ONEREQ, (st)) |
|
794 #define sk_OCSP_ONEREQ_push(st, val) SKM_sk_push(OCSP_ONEREQ, (st), (val)) |
|
795 #define sk_OCSP_ONEREQ_unshift(st, val) SKM_sk_unshift(OCSP_ONEREQ, (st), (val)) |
|
796 #define sk_OCSP_ONEREQ_find(st, val) SKM_sk_find(OCSP_ONEREQ, (st), (val)) |
|
797 #define sk_OCSP_ONEREQ_delete(st, i) SKM_sk_delete(OCSP_ONEREQ, (st), (i)) |
|
798 #define sk_OCSP_ONEREQ_delete_ptr(st, ptr) SKM_sk_delete_ptr(OCSP_ONEREQ, (st), (ptr)) |
|
799 #define sk_OCSP_ONEREQ_insert(st, val, i) SKM_sk_insert(OCSP_ONEREQ, (st), (val), (i)) |
|
800 #define sk_OCSP_ONEREQ_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(OCSP_ONEREQ, (st), (cmp)) |
|
801 #define sk_OCSP_ONEREQ_dup(st) SKM_sk_dup(OCSP_ONEREQ, st) |
|
802 #define sk_OCSP_ONEREQ_pop_free(st, free_func) SKM_sk_pop_free(OCSP_ONEREQ, (st), (free_func)) |
|
803 #define sk_OCSP_ONEREQ_shift(st) SKM_sk_shift(OCSP_ONEREQ, (st)) |
|
804 #define sk_OCSP_ONEREQ_pop(st) SKM_sk_pop(OCSP_ONEREQ, (st)) |
|
805 #define sk_OCSP_ONEREQ_sort(st) SKM_sk_sort(OCSP_ONEREQ, (st)) |
|
806 |
|
807 #define sk_OCSP_SINGLERESP_new(st) SKM_sk_new(OCSP_SINGLERESP, (st)) |
|
808 #define sk_OCSP_SINGLERESP_new_null() SKM_sk_new_null(OCSP_SINGLERESP) |
|
809 #define sk_OCSP_SINGLERESP_free(st) SKM_sk_free(OCSP_SINGLERESP, (st)) |
|
810 #define sk_OCSP_SINGLERESP_num(st) SKM_sk_num(OCSP_SINGLERESP, (st)) |
|
811 #define sk_OCSP_SINGLERESP_value(st, i) SKM_sk_value(OCSP_SINGLERESP, (st), (i)) |
|
812 #define sk_OCSP_SINGLERESP_set(st, i, val) SKM_sk_set(OCSP_SINGLERESP, (st), (i), (val)) |
|
813 #define sk_OCSP_SINGLERESP_zero(st) SKM_sk_zero(OCSP_SINGLERESP, (st)) |
|
814 #define sk_OCSP_SINGLERESP_push(st, val) SKM_sk_push(OCSP_SINGLERESP, (st), (val)) |
|
815 #define sk_OCSP_SINGLERESP_unshift(st, val) SKM_sk_unshift(OCSP_SINGLERESP, (st), (val)) |
|
816 #define sk_OCSP_SINGLERESP_find(st, val) SKM_sk_find(OCSP_SINGLERESP, (st), (val)) |
|
817 #define sk_OCSP_SINGLERESP_delete(st, i) SKM_sk_delete(OCSP_SINGLERESP, (st), (i)) |
|
818 #define sk_OCSP_SINGLERESP_delete_ptr(st, ptr) SKM_sk_delete_ptr(OCSP_SINGLERESP, (st), (ptr)) |
|
819 #define sk_OCSP_SINGLERESP_insert(st, val, i) SKM_sk_insert(OCSP_SINGLERESP, (st), (val), (i)) |
|
820 #define sk_OCSP_SINGLERESP_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(OCSP_SINGLERESP, (st), (cmp)) |
|
821 #define sk_OCSP_SINGLERESP_dup(st) SKM_sk_dup(OCSP_SINGLERESP, st) |
|
822 #define sk_OCSP_SINGLERESP_pop_free(st, free_func) SKM_sk_pop_free(OCSP_SINGLERESP, (st), (free_func)) |
|
823 #define sk_OCSP_SINGLERESP_shift(st) SKM_sk_shift(OCSP_SINGLERESP, (st)) |
|
824 #define sk_OCSP_SINGLERESP_pop(st) SKM_sk_pop(OCSP_SINGLERESP, (st)) |
|
825 #define sk_OCSP_SINGLERESP_sort(st) SKM_sk_sort(OCSP_SINGLERESP, (st)) |
|
826 |
|
827 #define sk_PKCS12_SAFEBAG_new(st) SKM_sk_new(PKCS12_SAFEBAG, (st)) |
|
828 #define sk_PKCS12_SAFEBAG_new_null() SKM_sk_new_null(PKCS12_SAFEBAG) |
|
829 #define sk_PKCS12_SAFEBAG_free(st) SKM_sk_free(PKCS12_SAFEBAG, (st)) |
|
830 #define sk_PKCS12_SAFEBAG_num(st) SKM_sk_num(PKCS12_SAFEBAG, (st)) |
|
831 #define sk_PKCS12_SAFEBAG_value(st, i) SKM_sk_value(PKCS12_SAFEBAG, (st), (i)) |
|
832 #define sk_PKCS12_SAFEBAG_set(st, i, val) SKM_sk_set(PKCS12_SAFEBAG, (st), (i), (val)) |
|
833 #define sk_PKCS12_SAFEBAG_zero(st) SKM_sk_zero(PKCS12_SAFEBAG, (st)) |
|
834 #define sk_PKCS12_SAFEBAG_push(st, val) SKM_sk_push(PKCS12_SAFEBAG, (st), (val)) |
|
835 #define sk_PKCS12_SAFEBAG_unshift(st, val) SKM_sk_unshift(PKCS12_SAFEBAG, (st), (val)) |
|
836 #define sk_PKCS12_SAFEBAG_find(st, val) SKM_sk_find(PKCS12_SAFEBAG, (st), (val)) |
|
837 #define sk_PKCS12_SAFEBAG_delete(st, i) SKM_sk_delete(PKCS12_SAFEBAG, (st), (i)) |
|
838 #define sk_PKCS12_SAFEBAG_delete_ptr(st, ptr) SKM_sk_delete_ptr(PKCS12_SAFEBAG, (st), (ptr)) |
|
839 #define sk_PKCS12_SAFEBAG_insert(st, val, i) SKM_sk_insert(PKCS12_SAFEBAG, (st), (val), (i)) |
|
840 #define sk_PKCS12_SAFEBAG_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(PKCS12_SAFEBAG, (st), (cmp)) |
|
841 #define sk_PKCS12_SAFEBAG_dup(st) SKM_sk_dup(PKCS12_SAFEBAG, st) |
|
842 #define sk_PKCS12_SAFEBAG_pop_free(st, free_func) SKM_sk_pop_free(PKCS12_SAFEBAG, (st), (free_func)) |
|
843 #define sk_PKCS12_SAFEBAG_shift(st) SKM_sk_shift(PKCS12_SAFEBAG, (st)) |
|
844 #define sk_PKCS12_SAFEBAG_pop(st) SKM_sk_pop(PKCS12_SAFEBAG, (st)) |
|
845 #define sk_PKCS12_SAFEBAG_sort(st) SKM_sk_sort(PKCS12_SAFEBAG, (st)) |
|
846 |
|
847 #define sk_PKCS7_new(st) SKM_sk_new(PKCS7, (st)) |
|
848 #define sk_PKCS7_new_null() SKM_sk_new_null(PKCS7) |
|
849 #define sk_PKCS7_free(st) SKM_sk_free(PKCS7, (st)) |
|
850 #define sk_PKCS7_num(st) SKM_sk_num(PKCS7, (st)) |
|
851 #define sk_PKCS7_value(st, i) SKM_sk_value(PKCS7, (st), (i)) |
|
852 #define sk_PKCS7_set(st, i, val) SKM_sk_set(PKCS7, (st), (i), (val)) |
|
853 #define sk_PKCS7_zero(st) SKM_sk_zero(PKCS7, (st)) |
|
854 #define sk_PKCS7_push(st, val) SKM_sk_push(PKCS7, (st), (val)) |
|
855 #define sk_PKCS7_unshift(st, val) SKM_sk_unshift(PKCS7, (st), (val)) |
|
856 #define sk_PKCS7_find(st, val) SKM_sk_find(PKCS7, (st), (val)) |
|
857 #define sk_PKCS7_delete(st, i) SKM_sk_delete(PKCS7, (st), (i)) |
|
858 #define sk_PKCS7_delete_ptr(st, ptr) SKM_sk_delete_ptr(PKCS7, (st), (ptr)) |
|
859 #define sk_PKCS7_insert(st, val, i) SKM_sk_insert(PKCS7, (st), (val), (i)) |
|
860 #define sk_PKCS7_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(PKCS7, (st), (cmp)) |
|
861 #define sk_PKCS7_dup(st) SKM_sk_dup(PKCS7, st) |
|
862 #define sk_PKCS7_pop_free(st, free_func) SKM_sk_pop_free(PKCS7, (st), (free_func)) |
|
863 #define sk_PKCS7_shift(st) SKM_sk_shift(PKCS7, (st)) |
|
864 #define sk_PKCS7_pop(st) SKM_sk_pop(PKCS7, (st)) |
|
865 #define sk_PKCS7_sort(st) SKM_sk_sort(PKCS7, (st)) |
|
866 |
|
867 #define sk_PKCS7_RECIP_INFO_new(st) SKM_sk_new(PKCS7_RECIP_INFO, (st)) |
|
868 #define sk_PKCS7_RECIP_INFO_new_null() SKM_sk_new_null(PKCS7_RECIP_INFO) |
|
869 #define sk_PKCS7_RECIP_INFO_free(st) SKM_sk_free(PKCS7_RECIP_INFO, (st)) |
|
870 #define sk_PKCS7_RECIP_INFO_num(st) SKM_sk_num(PKCS7_RECIP_INFO, (st)) |
|
871 #define sk_PKCS7_RECIP_INFO_value(st, i) SKM_sk_value(PKCS7_RECIP_INFO, (st), (i)) |
|
872 #define sk_PKCS7_RECIP_INFO_set(st, i, val) SKM_sk_set(PKCS7_RECIP_INFO, (st), (i), (val)) |
|
873 #define sk_PKCS7_RECIP_INFO_zero(st) SKM_sk_zero(PKCS7_RECIP_INFO, (st)) |
|
874 #define sk_PKCS7_RECIP_INFO_push(st, val) SKM_sk_push(PKCS7_RECIP_INFO, (st), (val)) |
|
875 #define sk_PKCS7_RECIP_INFO_unshift(st, val) SKM_sk_unshift(PKCS7_RECIP_INFO, (st), (val)) |
|
876 #define sk_PKCS7_RECIP_INFO_find(st, val) SKM_sk_find(PKCS7_RECIP_INFO, (st), (val)) |
|
877 #define sk_PKCS7_RECIP_INFO_delete(st, i) SKM_sk_delete(PKCS7_RECIP_INFO, (st), (i)) |
|
878 #define sk_PKCS7_RECIP_INFO_delete_ptr(st, ptr) SKM_sk_delete_ptr(PKCS7_RECIP_INFO, (st), (ptr)) |
|
879 #define sk_PKCS7_RECIP_INFO_insert(st, val, i) SKM_sk_insert(PKCS7_RECIP_INFO, (st), (val), (i)) |
|
880 #define sk_PKCS7_RECIP_INFO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(PKCS7_RECIP_INFO, (st), (cmp)) |
|
881 #define sk_PKCS7_RECIP_INFO_dup(st) SKM_sk_dup(PKCS7_RECIP_INFO, st) |
|
882 #define sk_PKCS7_RECIP_INFO_pop_free(st, free_func) SKM_sk_pop_free(PKCS7_RECIP_INFO, (st), (free_func)) |
|
883 #define sk_PKCS7_RECIP_INFO_shift(st) SKM_sk_shift(PKCS7_RECIP_INFO, (st)) |
|
884 #define sk_PKCS7_RECIP_INFO_pop(st) SKM_sk_pop(PKCS7_RECIP_INFO, (st)) |
|
885 #define sk_PKCS7_RECIP_INFO_sort(st) SKM_sk_sort(PKCS7_RECIP_INFO, (st)) |
|
886 |
|
887 #define sk_PKCS7_SIGNER_INFO_new(st) SKM_sk_new(PKCS7_SIGNER_INFO, (st)) |
|
888 #define sk_PKCS7_SIGNER_INFO_new_null() SKM_sk_new_null(PKCS7_SIGNER_INFO) |
|
889 #define sk_PKCS7_SIGNER_INFO_free(st) SKM_sk_free(PKCS7_SIGNER_INFO, (st)) |
|
890 #define sk_PKCS7_SIGNER_INFO_num(st) SKM_sk_num(PKCS7_SIGNER_INFO, (st)) |
|
891 #define sk_PKCS7_SIGNER_INFO_value(st, i) SKM_sk_value(PKCS7_SIGNER_INFO, (st), (i)) |
|
892 #define sk_PKCS7_SIGNER_INFO_set(st, i, val) SKM_sk_set(PKCS7_SIGNER_INFO, (st), (i), (val)) |
|
893 #define sk_PKCS7_SIGNER_INFO_zero(st) SKM_sk_zero(PKCS7_SIGNER_INFO, (st)) |
|
894 #define sk_PKCS7_SIGNER_INFO_push(st, val) SKM_sk_push(PKCS7_SIGNER_INFO, (st), (val)) |
|
895 #define sk_PKCS7_SIGNER_INFO_unshift(st, val) SKM_sk_unshift(PKCS7_SIGNER_INFO, (st), (val)) |
|
896 #define sk_PKCS7_SIGNER_INFO_find(st, val) SKM_sk_find(PKCS7_SIGNER_INFO, (st), (val)) |
|
897 #define sk_PKCS7_SIGNER_INFO_delete(st, i) SKM_sk_delete(PKCS7_SIGNER_INFO, (st), (i)) |
|
898 #define sk_PKCS7_SIGNER_INFO_delete_ptr(st, ptr) SKM_sk_delete_ptr(PKCS7_SIGNER_INFO, (st), (ptr)) |
|
899 #define sk_PKCS7_SIGNER_INFO_insert(st, val, i) SKM_sk_insert(PKCS7_SIGNER_INFO, (st), (val), (i)) |
|
900 #define sk_PKCS7_SIGNER_INFO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(PKCS7_SIGNER_INFO, (st), (cmp)) |
|
901 #define sk_PKCS7_SIGNER_INFO_dup(st) SKM_sk_dup(PKCS7_SIGNER_INFO, st) |
|
902 #define sk_PKCS7_SIGNER_INFO_pop_free(st, free_func) SKM_sk_pop_free(PKCS7_SIGNER_INFO, (st), (free_func)) |
|
903 #define sk_PKCS7_SIGNER_INFO_shift(st) SKM_sk_shift(PKCS7_SIGNER_INFO, (st)) |
|
904 #define sk_PKCS7_SIGNER_INFO_pop(st) SKM_sk_pop(PKCS7_SIGNER_INFO, (st)) |
|
905 #define sk_PKCS7_SIGNER_INFO_sort(st) SKM_sk_sort(PKCS7_SIGNER_INFO, (st)) |
|
906 |
|
907 #define sk_POLICYINFO_new(st) SKM_sk_new(POLICYINFO, (st)) |
|
908 #define sk_POLICYINFO_new_null() SKM_sk_new_null(POLICYINFO) |
|
909 #define sk_POLICYINFO_free(st) SKM_sk_free(POLICYINFO, (st)) |
|
910 #define sk_POLICYINFO_num(st) SKM_sk_num(POLICYINFO, (st)) |
|
911 #define sk_POLICYINFO_value(st, i) SKM_sk_value(POLICYINFO, (st), (i)) |
|
912 #define sk_POLICYINFO_set(st, i, val) SKM_sk_set(POLICYINFO, (st), (i), (val)) |
|
913 #define sk_POLICYINFO_zero(st) SKM_sk_zero(POLICYINFO, (st)) |
|
914 #define sk_POLICYINFO_push(st, val) SKM_sk_push(POLICYINFO, (st), (val)) |
|
915 #define sk_POLICYINFO_unshift(st, val) SKM_sk_unshift(POLICYINFO, (st), (val)) |
|
916 #define sk_POLICYINFO_find(st, val) SKM_sk_find(POLICYINFO, (st), (val)) |
|
917 #define sk_POLICYINFO_delete(st, i) SKM_sk_delete(POLICYINFO, (st), (i)) |
|
918 #define sk_POLICYINFO_delete_ptr(st, ptr) SKM_sk_delete_ptr(POLICYINFO, (st), (ptr)) |
|
919 #define sk_POLICYINFO_insert(st, val, i) SKM_sk_insert(POLICYINFO, (st), (val), (i)) |
|
920 #define sk_POLICYINFO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(POLICYINFO, (st), (cmp)) |
|
921 #define sk_POLICYINFO_dup(st) SKM_sk_dup(POLICYINFO, st) |
|
922 #define sk_POLICYINFO_pop_free(st, free_func) SKM_sk_pop_free(POLICYINFO, (st), (free_func)) |
|
923 #define sk_POLICYINFO_shift(st) SKM_sk_shift(POLICYINFO, (st)) |
|
924 #define sk_POLICYINFO_pop(st) SKM_sk_pop(POLICYINFO, (st)) |
|
925 #define sk_POLICYINFO_sort(st) SKM_sk_sort(POLICYINFO, (st)) |
|
926 |
|
927 #define sk_POLICYQUALINFO_new(st) SKM_sk_new(POLICYQUALINFO, (st)) |
|
928 #define sk_POLICYQUALINFO_new_null() SKM_sk_new_null(POLICYQUALINFO) |
|
929 #define sk_POLICYQUALINFO_free(st) SKM_sk_free(POLICYQUALINFO, (st)) |
|
930 #define sk_POLICYQUALINFO_num(st) SKM_sk_num(POLICYQUALINFO, (st)) |
|
931 #define sk_POLICYQUALINFO_value(st, i) SKM_sk_value(POLICYQUALINFO, (st), (i)) |
|
932 #define sk_POLICYQUALINFO_set(st, i, val) SKM_sk_set(POLICYQUALINFO, (st), (i), (val)) |
|
933 #define sk_POLICYQUALINFO_zero(st) SKM_sk_zero(POLICYQUALINFO, (st)) |
|
934 #define sk_POLICYQUALINFO_push(st, val) SKM_sk_push(POLICYQUALINFO, (st), (val)) |
|
935 #define sk_POLICYQUALINFO_unshift(st, val) SKM_sk_unshift(POLICYQUALINFO, (st), (val)) |
|
936 #define sk_POLICYQUALINFO_find(st, val) SKM_sk_find(POLICYQUALINFO, (st), (val)) |
|
937 #define sk_POLICYQUALINFO_delete(st, i) SKM_sk_delete(POLICYQUALINFO, (st), (i)) |
|
938 #define sk_POLICYQUALINFO_delete_ptr(st, ptr) SKM_sk_delete_ptr(POLICYQUALINFO, (st), (ptr)) |
|
939 #define sk_POLICYQUALINFO_insert(st, val, i) SKM_sk_insert(POLICYQUALINFO, (st), (val), (i)) |
|
940 #define sk_POLICYQUALINFO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(POLICYQUALINFO, (st), (cmp)) |
|
941 #define sk_POLICYQUALINFO_dup(st) SKM_sk_dup(POLICYQUALINFO, st) |
|
942 #define sk_POLICYQUALINFO_pop_free(st, free_func) SKM_sk_pop_free(POLICYQUALINFO, (st), (free_func)) |
|
943 #define sk_POLICYQUALINFO_shift(st) SKM_sk_shift(POLICYQUALINFO, (st)) |
|
944 #define sk_POLICYQUALINFO_pop(st) SKM_sk_pop(POLICYQUALINFO, (st)) |
|
945 #define sk_POLICYQUALINFO_sort(st) SKM_sk_sort(POLICYQUALINFO, (st)) |
|
946 |
|
947 #define sk_SSL_CIPHER_new(st) SKM_sk_new(SSL_CIPHER, (st)) |
|
948 #define sk_SSL_CIPHER_new_null() SKM_sk_new_null(SSL_CIPHER) |
|
949 #define sk_SSL_CIPHER_free(st) SKM_sk_free(SSL_CIPHER, (st)) |
|
950 #define sk_SSL_CIPHER_num(st) SKM_sk_num(SSL_CIPHER, (st)) |
|
951 #define sk_SSL_CIPHER_value(st, i) SKM_sk_value(SSL_CIPHER, (st), (i)) |
|
952 #define sk_SSL_CIPHER_set(st, i, val) SKM_sk_set(SSL_CIPHER, (st), (i), (val)) |
|
953 #define sk_SSL_CIPHER_zero(st) SKM_sk_zero(SSL_CIPHER, (st)) |
|
954 #define sk_SSL_CIPHER_push(st, val) SKM_sk_push(SSL_CIPHER, (st), (val)) |
|
955 #define sk_SSL_CIPHER_unshift(st, val) SKM_sk_unshift(SSL_CIPHER, (st), (val)) |
|
956 #define sk_SSL_CIPHER_find(st, val) SKM_sk_find(SSL_CIPHER, (st), (val)) |
|
957 #define sk_SSL_CIPHER_delete(st, i) SKM_sk_delete(SSL_CIPHER, (st), (i)) |
|
958 #define sk_SSL_CIPHER_delete_ptr(st, ptr) SKM_sk_delete_ptr(SSL_CIPHER, (st), (ptr)) |
|
959 #define sk_SSL_CIPHER_insert(st, val, i) SKM_sk_insert(SSL_CIPHER, (st), (val), (i)) |
|
960 #define sk_SSL_CIPHER_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(SSL_CIPHER, (st), (cmp)) |
|
961 #define sk_SSL_CIPHER_dup(st) SKM_sk_dup(SSL_CIPHER, st) |
|
962 #define sk_SSL_CIPHER_pop_free(st, free_func) SKM_sk_pop_free(SSL_CIPHER, (st), (free_func)) |
|
963 #define sk_SSL_CIPHER_shift(st) SKM_sk_shift(SSL_CIPHER, (st)) |
|
964 #define sk_SSL_CIPHER_pop(st) SKM_sk_pop(SSL_CIPHER, (st)) |
|
965 #define sk_SSL_CIPHER_sort(st) SKM_sk_sort(SSL_CIPHER, (st)) |
|
966 |
|
967 #define sk_SSL_COMP_new(st) SKM_sk_new(SSL_COMP, (st)) |
|
968 #define sk_SSL_COMP_new_null() SKM_sk_new_null(SSL_COMP) |
|
969 #define sk_SSL_COMP_free(st) SKM_sk_free(SSL_COMP, (st)) |
|
970 #define sk_SSL_COMP_num(st) SKM_sk_num(SSL_COMP, (st)) |
|
971 #define sk_SSL_COMP_value(st, i) SKM_sk_value(SSL_COMP, (st), (i)) |
|
972 #define sk_SSL_COMP_set(st, i, val) SKM_sk_set(SSL_COMP, (st), (i), (val)) |
|
973 #define sk_SSL_COMP_zero(st) SKM_sk_zero(SSL_COMP, (st)) |
|
974 #define sk_SSL_COMP_push(st, val) SKM_sk_push(SSL_COMP, (st), (val)) |
|
975 #define sk_SSL_COMP_unshift(st, val) SKM_sk_unshift(SSL_COMP, (st), (val)) |
|
976 #define sk_SSL_COMP_find(st, val) SKM_sk_find(SSL_COMP, (st), (val)) |
|
977 #define sk_SSL_COMP_delete(st, i) SKM_sk_delete(SSL_COMP, (st), (i)) |
|
978 #define sk_SSL_COMP_delete_ptr(st, ptr) SKM_sk_delete_ptr(SSL_COMP, (st), (ptr)) |
|
979 #define sk_SSL_COMP_insert(st, val, i) SKM_sk_insert(SSL_COMP, (st), (val), (i)) |
|
980 #define sk_SSL_COMP_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(SSL_COMP, (st), (cmp)) |
|
981 #define sk_SSL_COMP_dup(st) SKM_sk_dup(SSL_COMP, st) |
|
982 #define sk_SSL_COMP_pop_free(st, free_func) SKM_sk_pop_free(SSL_COMP, (st), (free_func)) |
|
983 #define sk_SSL_COMP_shift(st) SKM_sk_shift(SSL_COMP, (st)) |
|
984 #define sk_SSL_COMP_pop(st) SKM_sk_pop(SSL_COMP, (st)) |
|
985 #define sk_SSL_COMP_sort(st) SKM_sk_sort(SSL_COMP, (st)) |
|
986 |
|
987 #define sk_SXNETID_new(st) SKM_sk_new(SXNETID, (st)) |
|
988 #define sk_SXNETID_new_null() SKM_sk_new_null(SXNETID) |
|
989 #define sk_SXNETID_free(st) SKM_sk_free(SXNETID, (st)) |
|
990 #define sk_SXNETID_num(st) SKM_sk_num(SXNETID, (st)) |
|
991 #define sk_SXNETID_value(st, i) SKM_sk_value(SXNETID, (st), (i)) |
|
992 #define sk_SXNETID_set(st, i, val) SKM_sk_set(SXNETID, (st), (i), (val)) |
|
993 #define sk_SXNETID_zero(st) SKM_sk_zero(SXNETID, (st)) |
|
994 #define sk_SXNETID_push(st, val) SKM_sk_push(SXNETID, (st), (val)) |
|
995 #define sk_SXNETID_unshift(st, val) SKM_sk_unshift(SXNETID, (st), (val)) |
|
996 #define sk_SXNETID_find(st, val) SKM_sk_find(SXNETID, (st), (val)) |
|
997 #define sk_SXNETID_delete(st, i) SKM_sk_delete(SXNETID, (st), (i)) |
|
998 #define sk_SXNETID_delete_ptr(st, ptr) SKM_sk_delete_ptr(SXNETID, (st), (ptr)) |
|
999 #define sk_SXNETID_insert(st, val, i) SKM_sk_insert(SXNETID, (st), (val), (i)) |
|
1000 #define sk_SXNETID_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(SXNETID, (st), (cmp)) |
|
1001 #define sk_SXNETID_dup(st) SKM_sk_dup(SXNETID, st) |
|
1002 #define sk_SXNETID_pop_free(st, free_func) SKM_sk_pop_free(SXNETID, (st), (free_func)) |
|
1003 #define sk_SXNETID_shift(st) SKM_sk_shift(SXNETID, (st)) |
|
1004 #define sk_SXNETID_pop(st) SKM_sk_pop(SXNETID, (st)) |
|
1005 #define sk_SXNETID_sort(st) SKM_sk_sort(SXNETID, (st)) |
|
1006 |
|
1007 #define sk_UI_STRING_new(st) SKM_sk_new(UI_STRING, (st)) |
|
1008 #define sk_UI_STRING_new_null() SKM_sk_new_null(UI_STRING) |
|
1009 #define sk_UI_STRING_free(st) SKM_sk_free(UI_STRING, (st)) |
|
1010 #define sk_UI_STRING_num(st) SKM_sk_num(UI_STRING, (st)) |
|
1011 #define sk_UI_STRING_value(st, i) SKM_sk_value(UI_STRING, (st), (i)) |
|
1012 #define sk_UI_STRING_set(st, i, val) SKM_sk_set(UI_STRING, (st), (i), (val)) |
|
1013 #define sk_UI_STRING_zero(st) SKM_sk_zero(UI_STRING, (st)) |
|
1014 #define sk_UI_STRING_push(st, val) SKM_sk_push(UI_STRING, (st), (val)) |
|
1015 #define sk_UI_STRING_unshift(st, val) SKM_sk_unshift(UI_STRING, (st), (val)) |
|
1016 #define sk_UI_STRING_find(st, val) SKM_sk_find(UI_STRING, (st), (val)) |
|
1017 #define sk_UI_STRING_delete(st, i) SKM_sk_delete(UI_STRING, (st), (i)) |
|
1018 #define sk_UI_STRING_delete_ptr(st, ptr) SKM_sk_delete_ptr(UI_STRING, (st), (ptr)) |
|
1019 #define sk_UI_STRING_insert(st, val, i) SKM_sk_insert(UI_STRING, (st), (val), (i)) |
|
1020 #define sk_UI_STRING_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(UI_STRING, (st), (cmp)) |
|
1021 #define sk_UI_STRING_dup(st) SKM_sk_dup(UI_STRING, st) |
|
1022 #define sk_UI_STRING_pop_free(st, free_func) SKM_sk_pop_free(UI_STRING, (st), (free_func)) |
|
1023 #define sk_UI_STRING_shift(st) SKM_sk_shift(UI_STRING, (st)) |
|
1024 #define sk_UI_STRING_pop(st) SKM_sk_pop(UI_STRING, (st)) |
|
1025 #define sk_UI_STRING_sort(st) SKM_sk_sort(UI_STRING, (st)) |
|
1026 |
|
1027 #define sk_X509_new(st) SKM_sk_new(X509, (st)) |
|
1028 #define sk_X509_new_null() SKM_sk_new_null(X509) |
|
1029 #define sk_X509_free(st) SKM_sk_free(X509, (st)) |
|
1030 #define sk_X509_num(st) SKM_sk_num(X509, (st)) |
|
1031 #define sk_X509_value(st, i) SKM_sk_value(X509, (st), (i)) |
|
1032 #define sk_X509_set(st, i, val) SKM_sk_set(X509, (st), (i), (val)) |
|
1033 #define sk_X509_zero(st) SKM_sk_zero(X509, (st)) |
|
1034 #define sk_X509_push(st, val) SKM_sk_push(X509, (st), (val)) |
|
1035 #define sk_X509_unshift(st, val) SKM_sk_unshift(X509, (st), (val)) |
|
1036 #define sk_X509_find(st, val) SKM_sk_find(X509, (st), (val)) |
|
1037 #define sk_X509_delete(st, i) SKM_sk_delete(X509, (st), (i)) |
|
1038 #define sk_X509_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509, (st), (ptr)) |
|
1039 #define sk_X509_insert(st, val, i) SKM_sk_insert(X509, (st), (val), (i)) |
|
1040 #define sk_X509_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509, (st), (cmp)) |
|
1041 #define sk_X509_dup(st) SKM_sk_dup(X509, st) |
|
1042 #define sk_X509_pop_free(st, free_func) SKM_sk_pop_free(X509, (st), (free_func)) |
|
1043 #define sk_X509_shift(st) SKM_sk_shift(X509, (st)) |
|
1044 #define sk_X509_pop(st) SKM_sk_pop(X509, (st)) |
|
1045 #define sk_X509_sort(st) SKM_sk_sort(X509, (st)) |
|
1046 |
|
1047 #define sk_X509V3_EXT_METHOD_new(st) SKM_sk_new(X509V3_EXT_METHOD, (st)) |
|
1048 #define sk_X509V3_EXT_METHOD_new_null() SKM_sk_new_null(X509V3_EXT_METHOD) |
|
1049 #define sk_X509V3_EXT_METHOD_free(st) SKM_sk_free(X509V3_EXT_METHOD, (st)) |
|
1050 #define sk_X509V3_EXT_METHOD_num(st) SKM_sk_num(X509V3_EXT_METHOD, (st)) |
|
1051 #define sk_X509V3_EXT_METHOD_value(st, i) SKM_sk_value(X509V3_EXT_METHOD, (st), (i)) |
|
1052 #define sk_X509V3_EXT_METHOD_set(st, i, val) SKM_sk_set(X509V3_EXT_METHOD, (st), (i), (val)) |
|
1053 #define sk_X509V3_EXT_METHOD_zero(st) SKM_sk_zero(X509V3_EXT_METHOD, (st)) |
|
1054 #define sk_X509V3_EXT_METHOD_push(st, val) SKM_sk_push(X509V3_EXT_METHOD, (st), (val)) |
|
1055 #define sk_X509V3_EXT_METHOD_unshift(st, val) SKM_sk_unshift(X509V3_EXT_METHOD, (st), (val)) |
|
1056 #define sk_X509V3_EXT_METHOD_find(st, val) SKM_sk_find(X509V3_EXT_METHOD, (st), (val)) |
|
1057 #define sk_X509V3_EXT_METHOD_delete(st, i) SKM_sk_delete(X509V3_EXT_METHOD, (st), (i)) |
|
1058 #define sk_X509V3_EXT_METHOD_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509V3_EXT_METHOD, (st), (ptr)) |
|
1059 #define sk_X509V3_EXT_METHOD_insert(st, val, i) SKM_sk_insert(X509V3_EXT_METHOD, (st), (val), (i)) |
|
1060 #define sk_X509V3_EXT_METHOD_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509V3_EXT_METHOD, (st), (cmp)) |
|
1061 #define sk_X509V3_EXT_METHOD_dup(st) SKM_sk_dup(X509V3_EXT_METHOD, st) |
|
1062 #define sk_X509V3_EXT_METHOD_pop_free(st, free_func) SKM_sk_pop_free(X509V3_EXT_METHOD, (st), (free_func)) |
|
1063 #define sk_X509V3_EXT_METHOD_shift(st) SKM_sk_shift(X509V3_EXT_METHOD, (st)) |
|
1064 #define sk_X509V3_EXT_METHOD_pop(st) SKM_sk_pop(X509V3_EXT_METHOD, (st)) |
|
1065 #define sk_X509V3_EXT_METHOD_sort(st) SKM_sk_sort(X509V3_EXT_METHOD, (st)) |
|
1066 |
|
1067 #define sk_X509_ALGOR_new(st) SKM_sk_new(X509_ALGOR, (st)) |
|
1068 #define sk_X509_ALGOR_new_null() SKM_sk_new_null(X509_ALGOR) |
|
1069 #define sk_X509_ALGOR_free(st) SKM_sk_free(X509_ALGOR, (st)) |
|
1070 #define sk_X509_ALGOR_num(st) SKM_sk_num(X509_ALGOR, (st)) |
|
1071 #define sk_X509_ALGOR_value(st, i) SKM_sk_value(X509_ALGOR, (st), (i)) |
|
1072 #define sk_X509_ALGOR_set(st, i, val) SKM_sk_set(X509_ALGOR, (st), (i), (val)) |
|
1073 #define sk_X509_ALGOR_zero(st) SKM_sk_zero(X509_ALGOR, (st)) |
|
1074 #define sk_X509_ALGOR_push(st, val) SKM_sk_push(X509_ALGOR, (st), (val)) |
|
1075 #define sk_X509_ALGOR_unshift(st, val) SKM_sk_unshift(X509_ALGOR, (st), (val)) |
|
1076 #define sk_X509_ALGOR_find(st, val) SKM_sk_find(X509_ALGOR, (st), (val)) |
|
1077 #define sk_X509_ALGOR_delete(st, i) SKM_sk_delete(X509_ALGOR, (st), (i)) |
|
1078 #define sk_X509_ALGOR_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_ALGOR, (st), (ptr)) |
|
1079 #define sk_X509_ALGOR_insert(st, val, i) SKM_sk_insert(X509_ALGOR, (st), (val), (i)) |
|
1080 #define sk_X509_ALGOR_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_ALGOR, (st), (cmp)) |
|
1081 #define sk_X509_ALGOR_dup(st) SKM_sk_dup(X509_ALGOR, st) |
|
1082 #define sk_X509_ALGOR_pop_free(st, free_func) SKM_sk_pop_free(X509_ALGOR, (st), (free_func)) |
|
1083 #define sk_X509_ALGOR_shift(st) SKM_sk_shift(X509_ALGOR, (st)) |
|
1084 #define sk_X509_ALGOR_pop(st) SKM_sk_pop(X509_ALGOR, (st)) |
|
1085 #define sk_X509_ALGOR_sort(st) SKM_sk_sort(X509_ALGOR, (st)) |
|
1086 |
|
1087 #define sk_X509_ATTRIBUTE_new(st) SKM_sk_new(X509_ATTRIBUTE, (st)) |
|
1088 #define sk_X509_ATTRIBUTE_new_null() SKM_sk_new_null(X509_ATTRIBUTE) |
|
1089 #define sk_X509_ATTRIBUTE_free(st) SKM_sk_free(X509_ATTRIBUTE, (st)) |
|
1090 #define sk_X509_ATTRIBUTE_num(st) SKM_sk_num(X509_ATTRIBUTE, (st)) |
|
1091 #define sk_X509_ATTRIBUTE_value(st, i) SKM_sk_value(X509_ATTRIBUTE, (st), (i)) |
|
1092 #define sk_X509_ATTRIBUTE_set(st, i, val) SKM_sk_set(X509_ATTRIBUTE, (st), (i), (val)) |
|
1093 #define sk_X509_ATTRIBUTE_zero(st) SKM_sk_zero(X509_ATTRIBUTE, (st)) |
|
1094 #define sk_X509_ATTRIBUTE_push(st, val) SKM_sk_push(X509_ATTRIBUTE, (st), (val)) |
|
1095 #define sk_X509_ATTRIBUTE_unshift(st, val) SKM_sk_unshift(X509_ATTRIBUTE, (st), (val)) |
|
1096 #define sk_X509_ATTRIBUTE_find(st, val) SKM_sk_find(X509_ATTRIBUTE, (st), (val)) |
|
1097 #define sk_X509_ATTRIBUTE_delete(st, i) SKM_sk_delete(X509_ATTRIBUTE, (st), (i)) |
|
1098 #define sk_X509_ATTRIBUTE_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_ATTRIBUTE, (st), (ptr)) |
|
1099 #define sk_X509_ATTRIBUTE_insert(st, val, i) SKM_sk_insert(X509_ATTRIBUTE, (st), (val), (i)) |
|
1100 #define sk_X509_ATTRIBUTE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_ATTRIBUTE, (st), (cmp)) |
|
1101 #define sk_X509_ATTRIBUTE_dup(st) SKM_sk_dup(X509_ATTRIBUTE, st) |
|
1102 #define sk_X509_ATTRIBUTE_pop_free(st, free_func) SKM_sk_pop_free(X509_ATTRIBUTE, (st), (free_func)) |
|
1103 #define sk_X509_ATTRIBUTE_shift(st) SKM_sk_shift(X509_ATTRIBUTE, (st)) |
|
1104 #define sk_X509_ATTRIBUTE_pop(st) SKM_sk_pop(X509_ATTRIBUTE, (st)) |
|
1105 #define sk_X509_ATTRIBUTE_sort(st) SKM_sk_sort(X509_ATTRIBUTE, (st)) |
|
1106 |
|
1107 #define sk_X509_CRL_new(st) SKM_sk_new(X509_CRL, (st)) |
|
1108 #define sk_X509_CRL_new_null() SKM_sk_new_null(X509_CRL) |
|
1109 #define sk_X509_CRL_free(st) SKM_sk_free(X509_CRL, (st)) |
|
1110 #define sk_X509_CRL_num(st) SKM_sk_num(X509_CRL, (st)) |
|
1111 #define sk_X509_CRL_value(st, i) SKM_sk_value(X509_CRL, (st), (i)) |
|
1112 #define sk_X509_CRL_set(st, i, val) SKM_sk_set(X509_CRL, (st), (i), (val)) |
|
1113 #define sk_X509_CRL_zero(st) SKM_sk_zero(X509_CRL, (st)) |
|
1114 #define sk_X509_CRL_push(st, val) SKM_sk_push(X509_CRL, (st), (val)) |
|
1115 #define sk_X509_CRL_unshift(st, val) SKM_sk_unshift(X509_CRL, (st), (val)) |
|
1116 #define sk_X509_CRL_find(st, val) SKM_sk_find(X509_CRL, (st), (val)) |
|
1117 #define sk_X509_CRL_delete(st, i) SKM_sk_delete(X509_CRL, (st), (i)) |
|
1118 #define sk_X509_CRL_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_CRL, (st), (ptr)) |
|
1119 #define sk_X509_CRL_insert(st, val, i) SKM_sk_insert(X509_CRL, (st), (val), (i)) |
|
1120 #define sk_X509_CRL_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_CRL, (st), (cmp)) |
|
1121 #define sk_X509_CRL_dup(st) SKM_sk_dup(X509_CRL, st) |
|
1122 #define sk_X509_CRL_pop_free(st, free_func) SKM_sk_pop_free(X509_CRL, (st), (free_func)) |
|
1123 #define sk_X509_CRL_shift(st) SKM_sk_shift(X509_CRL, (st)) |
|
1124 #define sk_X509_CRL_pop(st) SKM_sk_pop(X509_CRL, (st)) |
|
1125 #define sk_X509_CRL_sort(st) SKM_sk_sort(X509_CRL, (st)) |
|
1126 |
|
1127 #define sk_X509_EXTENSION_new(st) SKM_sk_new(X509_EXTENSION, (st)) |
|
1128 #define sk_X509_EXTENSION_new_null() SKM_sk_new_null(X509_EXTENSION) |
|
1129 #define sk_X509_EXTENSION_free(st) SKM_sk_free(X509_EXTENSION, (st)) |
|
1130 #define sk_X509_EXTENSION_num(st) SKM_sk_num(X509_EXTENSION, (st)) |
|
1131 #define sk_X509_EXTENSION_value(st, i) SKM_sk_value(X509_EXTENSION, (st), (i)) |
|
1132 #define sk_X509_EXTENSION_set(st, i, val) SKM_sk_set(X509_EXTENSION, (st), (i), (val)) |
|
1133 #define sk_X509_EXTENSION_zero(st) SKM_sk_zero(X509_EXTENSION, (st)) |
|
1134 #define sk_X509_EXTENSION_push(st, val) SKM_sk_push(X509_EXTENSION, (st), (val)) |
|
1135 #define sk_X509_EXTENSION_unshift(st, val) SKM_sk_unshift(X509_EXTENSION, (st), (val)) |
|
1136 #define sk_X509_EXTENSION_find(st, val) SKM_sk_find(X509_EXTENSION, (st), (val)) |
|
1137 #define sk_X509_EXTENSION_delete(st, i) SKM_sk_delete(X509_EXTENSION, (st), (i)) |
|
1138 #define sk_X509_EXTENSION_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_EXTENSION, (st), (ptr)) |
|
1139 #define sk_X509_EXTENSION_insert(st, val, i) SKM_sk_insert(X509_EXTENSION, (st), (val), (i)) |
|
1140 #define sk_X509_EXTENSION_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_EXTENSION, (st), (cmp)) |
|
1141 #define sk_X509_EXTENSION_dup(st) SKM_sk_dup(X509_EXTENSION, st) |
|
1142 #define sk_X509_EXTENSION_pop_free(st, free_func) SKM_sk_pop_free(X509_EXTENSION, (st), (free_func)) |
|
1143 #define sk_X509_EXTENSION_shift(st) SKM_sk_shift(X509_EXTENSION, (st)) |
|
1144 #define sk_X509_EXTENSION_pop(st) SKM_sk_pop(X509_EXTENSION, (st)) |
|
1145 #define sk_X509_EXTENSION_sort(st) SKM_sk_sort(X509_EXTENSION, (st)) |
|
1146 |
|
1147 #define sk_X509_INFO_new(st) SKM_sk_new(X509_INFO, (st)) |
|
1148 #define sk_X509_INFO_new_null() SKM_sk_new_null(X509_INFO) |
|
1149 #define sk_X509_INFO_free(st) SKM_sk_free(X509_INFO, (st)) |
|
1150 #define sk_X509_INFO_num(st) SKM_sk_num(X509_INFO, (st)) |
|
1151 #define sk_X509_INFO_value(st, i) SKM_sk_value(X509_INFO, (st), (i)) |
|
1152 #define sk_X509_INFO_set(st, i, val) SKM_sk_set(X509_INFO, (st), (i), (val)) |
|
1153 #define sk_X509_INFO_zero(st) SKM_sk_zero(X509_INFO, (st)) |
|
1154 #define sk_X509_INFO_push(st, val) SKM_sk_push(X509_INFO, (st), (val)) |
|
1155 #define sk_X509_INFO_unshift(st, val) SKM_sk_unshift(X509_INFO, (st), (val)) |
|
1156 #define sk_X509_INFO_find(st, val) SKM_sk_find(X509_INFO, (st), (val)) |
|
1157 #define sk_X509_INFO_delete(st, i) SKM_sk_delete(X509_INFO, (st), (i)) |
|
1158 #define sk_X509_INFO_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_INFO, (st), (ptr)) |
|
1159 #define sk_X509_INFO_insert(st, val, i) SKM_sk_insert(X509_INFO, (st), (val), (i)) |
|
1160 #define sk_X509_INFO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_INFO, (st), (cmp)) |
|
1161 #define sk_X509_INFO_dup(st) SKM_sk_dup(X509_INFO, st) |
|
1162 #define sk_X509_INFO_pop_free(st, free_func) SKM_sk_pop_free(X509_INFO, (st), (free_func)) |
|
1163 #define sk_X509_INFO_shift(st) SKM_sk_shift(X509_INFO, (st)) |
|
1164 #define sk_X509_INFO_pop(st) SKM_sk_pop(X509_INFO, (st)) |
|
1165 #define sk_X509_INFO_sort(st) SKM_sk_sort(X509_INFO, (st)) |
|
1166 |
|
1167 #define sk_X509_LOOKUP_new(st) SKM_sk_new(X509_LOOKUP, (st)) |
|
1168 #define sk_X509_LOOKUP_new_null() SKM_sk_new_null(X509_LOOKUP) |
|
1169 #define sk_X509_LOOKUP_free(st) SKM_sk_free(X509_LOOKUP, (st)) |
|
1170 #define sk_X509_LOOKUP_num(st) SKM_sk_num(X509_LOOKUP, (st)) |
|
1171 #define sk_X509_LOOKUP_value(st, i) SKM_sk_value(X509_LOOKUP, (st), (i)) |
|
1172 #define sk_X509_LOOKUP_set(st, i, val) SKM_sk_set(X509_LOOKUP, (st), (i), (val)) |
|
1173 #define sk_X509_LOOKUP_zero(st) SKM_sk_zero(X509_LOOKUP, (st)) |
|
1174 #define sk_X509_LOOKUP_push(st, val) SKM_sk_push(X509_LOOKUP, (st), (val)) |
|
1175 #define sk_X509_LOOKUP_unshift(st, val) SKM_sk_unshift(X509_LOOKUP, (st), (val)) |
|
1176 #define sk_X509_LOOKUP_find(st, val) SKM_sk_find(X509_LOOKUP, (st), (val)) |
|
1177 #define sk_X509_LOOKUP_delete(st, i) SKM_sk_delete(X509_LOOKUP, (st), (i)) |
|
1178 #define sk_X509_LOOKUP_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_LOOKUP, (st), (ptr)) |
|
1179 #define sk_X509_LOOKUP_insert(st, val, i) SKM_sk_insert(X509_LOOKUP, (st), (val), (i)) |
|
1180 #define sk_X509_LOOKUP_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_LOOKUP, (st), (cmp)) |
|
1181 #define sk_X509_LOOKUP_dup(st) SKM_sk_dup(X509_LOOKUP, st) |
|
1182 #define sk_X509_LOOKUP_pop_free(st, free_func) SKM_sk_pop_free(X509_LOOKUP, (st), (free_func)) |
|
1183 #define sk_X509_LOOKUP_shift(st) SKM_sk_shift(X509_LOOKUP, (st)) |
|
1184 #define sk_X509_LOOKUP_pop(st) SKM_sk_pop(X509_LOOKUP, (st)) |
|
1185 #define sk_X509_LOOKUP_sort(st) SKM_sk_sort(X509_LOOKUP, (st)) |
|
1186 |
|
1187 #define sk_X509_NAME_new(st) SKM_sk_new(X509_NAME, (st)) |
|
1188 #define sk_X509_NAME_new_null() SKM_sk_new_null(X509_NAME) |
|
1189 #define sk_X509_NAME_free(st) SKM_sk_free(X509_NAME, (st)) |
|
1190 #define sk_X509_NAME_num(st) SKM_sk_num(X509_NAME, (st)) |
|
1191 #define sk_X509_NAME_value(st, i) SKM_sk_value(X509_NAME, (st), (i)) |
|
1192 #define sk_X509_NAME_set(st, i, val) SKM_sk_set(X509_NAME, (st), (i), (val)) |
|
1193 #define sk_X509_NAME_zero(st) SKM_sk_zero(X509_NAME, (st)) |
|
1194 #define sk_X509_NAME_push(st, val) SKM_sk_push(X509_NAME, (st), (val)) |
|
1195 #define sk_X509_NAME_unshift(st, val) SKM_sk_unshift(X509_NAME, (st), (val)) |
|
1196 #define sk_X509_NAME_find(st, val) SKM_sk_find(X509_NAME, (st), (val)) |
|
1197 #define sk_X509_NAME_delete(st, i) SKM_sk_delete(X509_NAME, (st), (i)) |
|
1198 #define sk_X509_NAME_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_NAME, (st), (ptr)) |
|
1199 #define sk_X509_NAME_insert(st, val, i) SKM_sk_insert(X509_NAME, (st), (val), (i)) |
|
1200 #define sk_X509_NAME_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_NAME, (st), (cmp)) |
|
1201 #define sk_X509_NAME_dup(st) SKM_sk_dup(X509_NAME, st) |
|
1202 #define sk_X509_NAME_pop_free(st, free_func) SKM_sk_pop_free(X509_NAME, (st), (free_func)) |
|
1203 #define sk_X509_NAME_shift(st) SKM_sk_shift(X509_NAME, (st)) |
|
1204 #define sk_X509_NAME_pop(st) SKM_sk_pop(X509_NAME, (st)) |
|
1205 #define sk_X509_NAME_sort(st) SKM_sk_sort(X509_NAME, (st)) |
|
1206 |
|
1207 #define sk_X509_NAME_ENTRY_new(st) SKM_sk_new(X509_NAME_ENTRY, (st)) |
|
1208 #define sk_X509_NAME_ENTRY_new_null() SKM_sk_new_null(X509_NAME_ENTRY) |
|
1209 #define sk_X509_NAME_ENTRY_free(st) SKM_sk_free(X509_NAME_ENTRY, (st)) |
|
1210 #define sk_X509_NAME_ENTRY_num(st) SKM_sk_num(X509_NAME_ENTRY, (st)) |
|
1211 #define sk_X509_NAME_ENTRY_value(st, i) SKM_sk_value(X509_NAME_ENTRY, (st), (i)) |
|
1212 #define sk_X509_NAME_ENTRY_set(st, i, val) SKM_sk_set(X509_NAME_ENTRY, (st), (i), (val)) |
|
1213 #define sk_X509_NAME_ENTRY_zero(st) SKM_sk_zero(X509_NAME_ENTRY, (st)) |
|
1214 #define sk_X509_NAME_ENTRY_push(st, val) SKM_sk_push(X509_NAME_ENTRY, (st), (val)) |
|
1215 #define sk_X509_NAME_ENTRY_unshift(st, val) SKM_sk_unshift(X509_NAME_ENTRY, (st), (val)) |
|
1216 #define sk_X509_NAME_ENTRY_find(st, val) SKM_sk_find(X509_NAME_ENTRY, (st), (val)) |
|
1217 #define sk_X509_NAME_ENTRY_delete(st, i) SKM_sk_delete(X509_NAME_ENTRY, (st), (i)) |
|
1218 #define sk_X509_NAME_ENTRY_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_NAME_ENTRY, (st), (ptr)) |
|
1219 #define sk_X509_NAME_ENTRY_insert(st, val, i) SKM_sk_insert(X509_NAME_ENTRY, (st), (val), (i)) |
|
1220 #define sk_X509_NAME_ENTRY_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_NAME_ENTRY, (st), (cmp)) |
|
1221 #define sk_X509_NAME_ENTRY_dup(st) SKM_sk_dup(X509_NAME_ENTRY, st) |
|
1222 #define sk_X509_NAME_ENTRY_pop_free(st, free_func) SKM_sk_pop_free(X509_NAME_ENTRY, (st), (free_func)) |
|
1223 #define sk_X509_NAME_ENTRY_shift(st) SKM_sk_shift(X509_NAME_ENTRY, (st)) |
|
1224 #define sk_X509_NAME_ENTRY_pop(st) SKM_sk_pop(X509_NAME_ENTRY, (st)) |
|
1225 #define sk_X509_NAME_ENTRY_sort(st) SKM_sk_sort(X509_NAME_ENTRY, (st)) |
|
1226 |
|
1227 #define sk_X509_OBJECT_new(st) SKM_sk_new(X509_OBJECT, (st)) |
|
1228 #define sk_X509_OBJECT_new_null() SKM_sk_new_null(X509_OBJECT) |
|
1229 #define sk_X509_OBJECT_free(st) SKM_sk_free(X509_OBJECT, (st)) |
|
1230 #define sk_X509_OBJECT_num(st) SKM_sk_num(X509_OBJECT, (st)) |
|
1231 #define sk_X509_OBJECT_value(st, i) SKM_sk_value(X509_OBJECT, (st), (i)) |
|
1232 #define sk_X509_OBJECT_set(st, i, val) SKM_sk_set(X509_OBJECT, (st), (i), (val)) |
|
1233 #define sk_X509_OBJECT_zero(st) SKM_sk_zero(X509_OBJECT, (st)) |
|
1234 #define sk_X509_OBJECT_push(st, val) SKM_sk_push(X509_OBJECT, (st), (val)) |
|
1235 #define sk_X509_OBJECT_unshift(st, val) SKM_sk_unshift(X509_OBJECT, (st), (val)) |
|
1236 #define sk_X509_OBJECT_find(st, val) SKM_sk_find(X509_OBJECT, (st), (val)) |
|
1237 #define sk_X509_OBJECT_delete(st, i) SKM_sk_delete(X509_OBJECT, (st), (i)) |
|
1238 #define sk_X509_OBJECT_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_OBJECT, (st), (ptr)) |
|
1239 #define sk_X509_OBJECT_insert(st, val, i) SKM_sk_insert(X509_OBJECT, (st), (val), (i)) |
|
1240 #define sk_X509_OBJECT_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_OBJECT, (st), (cmp)) |
|
1241 #define sk_X509_OBJECT_dup(st) SKM_sk_dup(X509_OBJECT, st) |
|
1242 #define sk_X509_OBJECT_pop_free(st, free_func) SKM_sk_pop_free(X509_OBJECT, (st), (free_func)) |
|
1243 #define sk_X509_OBJECT_shift(st) SKM_sk_shift(X509_OBJECT, (st)) |
|
1244 #define sk_X509_OBJECT_pop(st) SKM_sk_pop(X509_OBJECT, (st)) |
|
1245 #define sk_X509_OBJECT_sort(st) SKM_sk_sort(X509_OBJECT, (st)) |
|
1246 |
|
1247 #define sk_X509_PURPOSE_new(st) SKM_sk_new(X509_PURPOSE, (st)) |
|
1248 #define sk_X509_PURPOSE_new_null() SKM_sk_new_null(X509_PURPOSE) |
|
1249 #define sk_X509_PURPOSE_free(st) SKM_sk_free(X509_PURPOSE, (st)) |
|
1250 #define sk_X509_PURPOSE_num(st) SKM_sk_num(X509_PURPOSE, (st)) |
|
1251 #define sk_X509_PURPOSE_value(st, i) SKM_sk_value(X509_PURPOSE, (st), (i)) |
|
1252 #define sk_X509_PURPOSE_set(st, i, val) SKM_sk_set(X509_PURPOSE, (st), (i), (val)) |
|
1253 #define sk_X509_PURPOSE_zero(st) SKM_sk_zero(X509_PURPOSE, (st)) |
|
1254 #define sk_X509_PURPOSE_push(st, val) SKM_sk_push(X509_PURPOSE, (st), (val)) |
|
1255 #define sk_X509_PURPOSE_unshift(st, val) SKM_sk_unshift(X509_PURPOSE, (st), (val)) |
|
1256 #define sk_X509_PURPOSE_find(st, val) SKM_sk_find(X509_PURPOSE, (st), (val)) |
|
1257 #define sk_X509_PURPOSE_delete(st, i) SKM_sk_delete(X509_PURPOSE, (st), (i)) |
|
1258 #define sk_X509_PURPOSE_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_PURPOSE, (st), (ptr)) |
|
1259 #define sk_X509_PURPOSE_insert(st, val, i) SKM_sk_insert(X509_PURPOSE, (st), (val), (i)) |
|
1260 #define sk_X509_PURPOSE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_PURPOSE, (st), (cmp)) |
|
1261 #define sk_X509_PURPOSE_dup(st) SKM_sk_dup(X509_PURPOSE, st) |
|
1262 #define sk_X509_PURPOSE_pop_free(st, free_func) SKM_sk_pop_free(X509_PURPOSE, (st), (free_func)) |
|
1263 #define sk_X509_PURPOSE_shift(st) SKM_sk_shift(X509_PURPOSE, (st)) |
|
1264 #define sk_X509_PURPOSE_pop(st) SKM_sk_pop(X509_PURPOSE, (st)) |
|
1265 #define sk_X509_PURPOSE_sort(st) SKM_sk_sort(X509_PURPOSE, (st)) |
|
1266 |
|
1267 #define sk_X509_REVOKED_new(st) SKM_sk_new(X509_REVOKED, (st)) |
|
1268 #define sk_X509_REVOKED_new_null() SKM_sk_new_null(X509_REVOKED) |
|
1269 #define sk_X509_REVOKED_free(st) SKM_sk_free(X509_REVOKED, (st)) |
|
1270 #define sk_X509_REVOKED_num(st) SKM_sk_num(X509_REVOKED, (st)) |
|
1271 #define sk_X509_REVOKED_value(st, i) SKM_sk_value(X509_REVOKED, (st), (i)) |
|
1272 #define sk_X509_REVOKED_set(st, i, val) SKM_sk_set(X509_REVOKED, (st), (i), (val)) |
|
1273 #define sk_X509_REVOKED_zero(st) SKM_sk_zero(X509_REVOKED, (st)) |
|
1274 #define sk_X509_REVOKED_push(st, val) SKM_sk_push(X509_REVOKED, (st), (val)) |
|
1275 #define sk_X509_REVOKED_unshift(st, val) SKM_sk_unshift(X509_REVOKED, (st), (val)) |
|
1276 #define sk_X509_REVOKED_find(st, val) SKM_sk_find(X509_REVOKED, (st), (val)) |
|
1277 #define sk_X509_REVOKED_delete(st, i) SKM_sk_delete(X509_REVOKED, (st), (i)) |
|
1278 #define sk_X509_REVOKED_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_REVOKED, (st), (ptr)) |
|
1279 #define sk_X509_REVOKED_insert(st, val, i) SKM_sk_insert(X509_REVOKED, (st), (val), (i)) |
|
1280 #define sk_X509_REVOKED_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_REVOKED, (st), (cmp)) |
|
1281 #define sk_X509_REVOKED_dup(st) SKM_sk_dup(X509_REVOKED, st) |
|
1282 #define sk_X509_REVOKED_pop_free(st, free_func) SKM_sk_pop_free(X509_REVOKED, (st), (free_func)) |
|
1283 #define sk_X509_REVOKED_shift(st) SKM_sk_shift(X509_REVOKED, (st)) |
|
1284 #define sk_X509_REVOKED_pop(st) SKM_sk_pop(X509_REVOKED, (st)) |
|
1285 #define sk_X509_REVOKED_sort(st) SKM_sk_sort(X509_REVOKED, (st)) |
|
1286 |
|
1287 #define sk_X509_TRUST_new(st) SKM_sk_new(X509_TRUST, (st)) |
|
1288 #define sk_X509_TRUST_new_null() SKM_sk_new_null(X509_TRUST) |
|
1289 #define sk_X509_TRUST_free(st) SKM_sk_free(X509_TRUST, (st)) |
|
1290 #define sk_X509_TRUST_num(st) SKM_sk_num(X509_TRUST, (st)) |
|
1291 #define sk_X509_TRUST_value(st, i) SKM_sk_value(X509_TRUST, (st), (i)) |
|
1292 #define sk_X509_TRUST_set(st, i, val) SKM_sk_set(X509_TRUST, (st), (i), (val)) |
|
1293 #define sk_X509_TRUST_zero(st) SKM_sk_zero(X509_TRUST, (st)) |
|
1294 #define sk_X509_TRUST_push(st, val) SKM_sk_push(X509_TRUST, (st), (val)) |
|
1295 #define sk_X509_TRUST_unshift(st, val) SKM_sk_unshift(X509_TRUST, (st), (val)) |
|
1296 #define sk_X509_TRUST_find(st, val) SKM_sk_find(X509_TRUST, (st), (val)) |
|
1297 #define sk_X509_TRUST_delete(st, i) SKM_sk_delete(X509_TRUST, (st), (i)) |
|
1298 #define sk_X509_TRUST_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_TRUST, (st), (ptr)) |
|
1299 #define sk_X509_TRUST_insert(st, val, i) SKM_sk_insert(X509_TRUST, (st), (val), (i)) |
|
1300 #define sk_X509_TRUST_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_TRUST, (st), (cmp)) |
|
1301 #define sk_X509_TRUST_dup(st) SKM_sk_dup(X509_TRUST, st) |
|
1302 #define sk_X509_TRUST_pop_free(st, free_func) SKM_sk_pop_free(X509_TRUST, (st), (free_func)) |
|
1303 #define sk_X509_TRUST_shift(st) SKM_sk_shift(X509_TRUST, (st)) |
|
1304 #define sk_X509_TRUST_pop(st) SKM_sk_pop(X509_TRUST, (st)) |
|
1305 #define sk_X509_TRUST_sort(st) SKM_sk_sort(X509_TRUST, (st)) |
|
1306 |
|
1307 #define d2i_ASN1_SET_OF_ACCESS_DESCRIPTION(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1308 SKM_ASN1_SET_OF_d2i(ACCESS_DESCRIPTION, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1309 #define i2d_ASN1_SET_OF_ACCESS_DESCRIPTION(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1310 SKM_ASN1_SET_OF_i2d(ACCESS_DESCRIPTION, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1311 #define ASN1_seq_pack_ACCESS_DESCRIPTION(st, i2d_func, buf, len) \ |
|
1312 SKM_ASN1_seq_pack(ACCESS_DESCRIPTION, (st), (i2d_func), (buf), (len)) |
|
1313 #define ASN1_seq_unpack_ACCESS_DESCRIPTION(buf, len, d2i_func, free_func) \ |
|
1314 SKM_ASN1_seq_unpack(ACCESS_DESCRIPTION, (buf), (len), (d2i_func), (free_func)) |
|
1315 |
|
1316 #define d2i_ASN1_SET_OF_ASN1_INTEGER(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1317 SKM_ASN1_SET_OF_d2i(ASN1_INTEGER, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1318 #define i2d_ASN1_SET_OF_ASN1_INTEGER(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1319 SKM_ASN1_SET_OF_i2d(ASN1_INTEGER, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1320 #define ASN1_seq_pack_ASN1_INTEGER(st, i2d_func, buf, len) \ |
|
1321 SKM_ASN1_seq_pack(ASN1_INTEGER, (st), (i2d_func), (buf), (len)) |
|
1322 #define ASN1_seq_unpack_ASN1_INTEGER(buf, len, d2i_func, free_func) \ |
|
1323 SKM_ASN1_seq_unpack(ASN1_INTEGER, (buf), (len), (d2i_func), (free_func)) |
|
1324 |
|
1325 #define d2i_ASN1_SET_OF_ASN1_OBJECT(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1326 SKM_ASN1_SET_OF_d2i(ASN1_OBJECT, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1327 #define i2d_ASN1_SET_OF_ASN1_OBJECT(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1328 SKM_ASN1_SET_OF_i2d(ASN1_OBJECT, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1329 #define ASN1_seq_pack_ASN1_OBJECT(st, i2d_func, buf, len) \ |
|
1330 SKM_ASN1_seq_pack(ASN1_OBJECT, (st), (i2d_func), (buf), (len)) |
|
1331 #define ASN1_seq_unpack_ASN1_OBJECT(buf, len, d2i_func, free_func) \ |
|
1332 SKM_ASN1_seq_unpack(ASN1_OBJECT, (buf), (len), (d2i_func), (free_func)) |
|
1333 |
|
1334 #define d2i_ASN1_SET_OF_ASN1_TYPE(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1335 SKM_ASN1_SET_OF_d2i(ASN1_TYPE, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1336 #define i2d_ASN1_SET_OF_ASN1_TYPE(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1337 SKM_ASN1_SET_OF_i2d(ASN1_TYPE, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1338 #define ASN1_seq_pack_ASN1_TYPE(st, i2d_func, buf, len) \ |
|
1339 SKM_ASN1_seq_pack(ASN1_TYPE, (st), (i2d_func), (buf), (len)) |
|
1340 #define ASN1_seq_unpack_ASN1_TYPE(buf, len, d2i_func, free_func) \ |
|
1341 SKM_ASN1_seq_unpack(ASN1_TYPE, (buf), (len), (d2i_func), (free_func)) |
|
1342 |
|
1343 #define d2i_ASN1_SET_OF_DIST_POINT(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1344 SKM_ASN1_SET_OF_d2i(DIST_POINT, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1345 #define i2d_ASN1_SET_OF_DIST_POINT(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1346 SKM_ASN1_SET_OF_i2d(DIST_POINT, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1347 #define ASN1_seq_pack_DIST_POINT(st, i2d_func, buf, len) \ |
|
1348 SKM_ASN1_seq_pack(DIST_POINT, (st), (i2d_func), (buf), (len)) |
|
1349 #define ASN1_seq_unpack_DIST_POINT(buf, len, d2i_func, free_func) \ |
|
1350 SKM_ASN1_seq_unpack(DIST_POINT, (buf), (len), (d2i_func), (free_func)) |
|
1351 |
|
1352 #define d2i_ASN1_SET_OF_GENERAL_NAME(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1353 SKM_ASN1_SET_OF_d2i(GENERAL_NAME, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1354 #define i2d_ASN1_SET_OF_GENERAL_NAME(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1355 SKM_ASN1_SET_OF_i2d(GENERAL_NAME, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1356 #define ASN1_seq_pack_GENERAL_NAME(st, i2d_func, buf, len) \ |
|
1357 SKM_ASN1_seq_pack(GENERAL_NAME, (st), (i2d_func), (buf), (len)) |
|
1358 #define ASN1_seq_unpack_GENERAL_NAME(buf, len, d2i_func, free_func) \ |
|
1359 SKM_ASN1_seq_unpack(GENERAL_NAME, (buf), (len), (d2i_func), (free_func)) |
|
1360 |
|
1361 #define d2i_ASN1_SET_OF_OCSP_ONEREQ(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1362 SKM_ASN1_SET_OF_d2i(OCSP_ONEREQ, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1363 #define i2d_ASN1_SET_OF_OCSP_ONEREQ(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1364 SKM_ASN1_SET_OF_i2d(OCSP_ONEREQ, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1365 #define ASN1_seq_pack_OCSP_ONEREQ(st, i2d_func, buf, len) \ |
|
1366 SKM_ASN1_seq_pack(OCSP_ONEREQ, (st), (i2d_func), (buf), (len)) |
|
1367 #define ASN1_seq_unpack_OCSP_ONEREQ(buf, len, d2i_func, free_func) \ |
|
1368 SKM_ASN1_seq_unpack(OCSP_ONEREQ, (buf), (len), (d2i_func), (free_func)) |
|
1369 |
|
1370 #define d2i_ASN1_SET_OF_OCSP_SINGLERESP(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1371 SKM_ASN1_SET_OF_d2i(OCSP_SINGLERESP, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1372 #define i2d_ASN1_SET_OF_OCSP_SINGLERESP(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1373 SKM_ASN1_SET_OF_i2d(OCSP_SINGLERESP, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1374 #define ASN1_seq_pack_OCSP_SINGLERESP(st, i2d_func, buf, len) \ |
|
1375 SKM_ASN1_seq_pack(OCSP_SINGLERESP, (st), (i2d_func), (buf), (len)) |
|
1376 #define ASN1_seq_unpack_OCSP_SINGLERESP(buf, len, d2i_func, free_func) \ |
|
1377 SKM_ASN1_seq_unpack(OCSP_SINGLERESP, (buf), (len), (d2i_func), (free_func)) |
|
1378 |
|
1379 #define d2i_ASN1_SET_OF_PKCS12_SAFEBAG(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1380 SKM_ASN1_SET_OF_d2i(PKCS12_SAFEBAG, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1381 #define i2d_ASN1_SET_OF_PKCS12_SAFEBAG(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1382 SKM_ASN1_SET_OF_i2d(PKCS12_SAFEBAG, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1383 #define ASN1_seq_pack_PKCS12_SAFEBAG(st, i2d_func, buf, len) \ |
|
1384 SKM_ASN1_seq_pack(PKCS12_SAFEBAG, (st), (i2d_func), (buf), (len)) |
|
1385 #define ASN1_seq_unpack_PKCS12_SAFEBAG(buf, len, d2i_func, free_func) \ |
|
1386 SKM_ASN1_seq_unpack(PKCS12_SAFEBAG, (buf), (len), (d2i_func), (free_func)) |
|
1387 |
|
1388 #define d2i_ASN1_SET_OF_PKCS7(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1389 SKM_ASN1_SET_OF_d2i(PKCS7, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1390 #define i2d_ASN1_SET_OF_PKCS7(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1391 SKM_ASN1_SET_OF_i2d(PKCS7, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1392 #define ASN1_seq_pack_PKCS7(st, i2d_func, buf, len) \ |
|
1393 SKM_ASN1_seq_pack(PKCS7, (st), (i2d_func), (buf), (len)) |
|
1394 #define ASN1_seq_unpack_PKCS7(buf, len, d2i_func, free_func) \ |
|
1395 SKM_ASN1_seq_unpack(PKCS7, (buf), (len), (d2i_func), (free_func)) |
|
1396 |
|
1397 #define d2i_ASN1_SET_OF_PKCS7_RECIP_INFO(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1398 SKM_ASN1_SET_OF_d2i(PKCS7_RECIP_INFO, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1399 #define i2d_ASN1_SET_OF_PKCS7_RECIP_INFO(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1400 SKM_ASN1_SET_OF_i2d(PKCS7_RECIP_INFO, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1401 #define ASN1_seq_pack_PKCS7_RECIP_INFO(st, i2d_func, buf, len) \ |
|
1402 SKM_ASN1_seq_pack(PKCS7_RECIP_INFO, (st), (i2d_func), (buf), (len)) |
|
1403 #define ASN1_seq_unpack_PKCS7_RECIP_INFO(buf, len, d2i_func, free_func) \ |
|
1404 SKM_ASN1_seq_unpack(PKCS7_RECIP_INFO, (buf), (len), (d2i_func), (free_func)) |
|
1405 |
|
1406 #define d2i_ASN1_SET_OF_PKCS7_SIGNER_INFO(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1407 SKM_ASN1_SET_OF_d2i(PKCS7_SIGNER_INFO, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1408 #define i2d_ASN1_SET_OF_PKCS7_SIGNER_INFO(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1409 SKM_ASN1_SET_OF_i2d(PKCS7_SIGNER_INFO, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1410 #define ASN1_seq_pack_PKCS7_SIGNER_INFO(st, i2d_func, buf, len) \ |
|
1411 SKM_ASN1_seq_pack(PKCS7_SIGNER_INFO, (st), (i2d_func), (buf), (len)) |
|
1412 #define ASN1_seq_unpack_PKCS7_SIGNER_INFO(buf, len, d2i_func, free_func) \ |
|
1413 SKM_ASN1_seq_unpack(PKCS7_SIGNER_INFO, (buf), (len), (d2i_func), (free_func)) |
|
1414 |
|
1415 #define d2i_ASN1_SET_OF_POLICYINFO(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1416 SKM_ASN1_SET_OF_d2i(POLICYINFO, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1417 #define i2d_ASN1_SET_OF_POLICYINFO(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1418 SKM_ASN1_SET_OF_i2d(POLICYINFO, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1419 #define ASN1_seq_pack_POLICYINFO(st, i2d_func, buf, len) \ |
|
1420 SKM_ASN1_seq_pack(POLICYINFO, (st), (i2d_func), (buf), (len)) |
|
1421 #define ASN1_seq_unpack_POLICYINFO(buf, len, d2i_func, free_func) \ |
|
1422 SKM_ASN1_seq_unpack(POLICYINFO, (buf), (len), (d2i_func), (free_func)) |
|
1423 |
|
1424 #define d2i_ASN1_SET_OF_POLICYQUALINFO(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1425 SKM_ASN1_SET_OF_d2i(POLICYQUALINFO, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1426 #define i2d_ASN1_SET_OF_POLICYQUALINFO(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1427 SKM_ASN1_SET_OF_i2d(POLICYQUALINFO, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1428 #define ASN1_seq_pack_POLICYQUALINFO(st, i2d_func, buf, len) \ |
|
1429 SKM_ASN1_seq_pack(POLICYQUALINFO, (st), (i2d_func), (buf), (len)) |
|
1430 #define ASN1_seq_unpack_POLICYQUALINFO(buf, len, d2i_func, free_func) \ |
|
1431 SKM_ASN1_seq_unpack(POLICYQUALINFO, (buf), (len), (d2i_func), (free_func)) |
|
1432 |
|
1433 #define d2i_ASN1_SET_OF_SXNETID(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1434 SKM_ASN1_SET_OF_d2i(SXNETID, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1435 #define i2d_ASN1_SET_OF_SXNETID(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1436 SKM_ASN1_SET_OF_i2d(SXNETID, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1437 #define ASN1_seq_pack_SXNETID(st, i2d_func, buf, len) \ |
|
1438 SKM_ASN1_seq_pack(SXNETID, (st), (i2d_func), (buf), (len)) |
|
1439 #define ASN1_seq_unpack_SXNETID(buf, len, d2i_func, free_func) \ |
|
1440 SKM_ASN1_seq_unpack(SXNETID, (buf), (len), (d2i_func), (free_func)) |
|
1441 |
|
1442 #define d2i_ASN1_SET_OF_X509(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1443 SKM_ASN1_SET_OF_d2i(X509, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1444 #define i2d_ASN1_SET_OF_X509(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1445 SKM_ASN1_SET_OF_i2d(X509, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1446 #define ASN1_seq_pack_X509(st, i2d_func, buf, len) \ |
|
1447 SKM_ASN1_seq_pack(X509, (st), (i2d_func), (buf), (len)) |
|
1448 #define ASN1_seq_unpack_X509(buf, len, d2i_func, free_func) \ |
|
1449 SKM_ASN1_seq_unpack(X509, (buf), (len), (d2i_func), (free_func)) |
|
1450 |
|
1451 #define d2i_ASN1_SET_OF_X509_ALGOR(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1452 SKM_ASN1_SET_OF_d2i(X509_ALGOR, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1453 #define i2d_ASN1_SET_OF_X509_ALGOR(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1454 SKM_ASN1_SET_OF_i2d(X509_ALGOR, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1455 #define ASN1_seq_pack_X509_ALGOR(st, i2d_func, buf, len) \ |
|
1456 SKM_ASN1_seq_pack(X509_ALGOR, (st), (i2d_func), (buf), (len)) |
|
1457 #define ASN1_seq_unpack_X509_ALGOR(buf, len, d2i_func, free_func) \ |
|
1458 SKM_ASN1_seq_unpack(X509_ALGOR, (buf), (len), (d2i_func), (free_func)) |
|
1459 |
|
1460 #define d2i_ASN1_SET_OF_X509_ATTRIBUTE(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1461 SKM_ASN1_SET_OF_d2i(X509_ATTRIBUTE, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1462 #define i2d_ASN1_SET_OF_X509_ATTRIBUTE(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1463 SKM_ASN1_SET_OF_i2d(X509_ATTRIBUTE, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1464 #define ASN1_seq_pack_X509_ATTRIBUTE(st, i2d_func, buf, len) \ |
|
1465 SKM_ASN1_seq_pack(X509_ATTRIBUTE, (st), (i2d_func), (buf), (len)) |
|
1466 #define ASN1_seq_unpack_X509_ATTRIBUTE(buf, len, d2i_func, free_func) \ |
|
1467 SKM_ASN1_seq_unpack(X509_ATTRIBUTE, (buf), (len), (d2i_func), (free_func)) |
|
1468 |
|
1469 #define d2i_ASN1_SET_OF_X509_CRL(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1470 SKM_ASN1_SET_OF_d2i(X509_CRL, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1471 #define i2d_ASN1_SET_OF_X509_CRL(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1472 SKM_ASN1_SET_OF_i2d(X509_CRL, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1473 #define ASN1_seq_pack_X509_CRL(st, i2d_func, buf, len) \ |
|
1474 SKM_ASN1_seq_pack(X509_CRL, (st), (i2d_func), (buf), (len)) |
|
1475 #define ASN1_seq_unpack_X509_CRL(buf, len, d2i_func, free_func) \ |
|
1476 SKM_ASN1_seq_unpack(X509_CRL, (buf), (len), (d2i_func), (free_func)) |
|
1477 |
|
1478 #define d2i_ASN1_SET_OF_X509_EXTENSION(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1479 SKM_ASN1_SET_OF_d2i(X509_EXTENSION, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1480 #define i2d_ASN1_SET_OF_X509_EXTENSION(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1481 SKM_ASN1_SET_OF_i2d(X509_EXTENSION, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1482 #define ASN1_seq_pack_X509_EXTENSION(st, i2d_func, buf, len) \ |
|
1483 SKM_ASN1_seq_pack(X509_EXTENSION, (st), (i2d_func), (buf), (len)) |
|
1484 #define ASN1_seq_unpack_X509_EXTENSION(buf, len, d2i_func, free_func) \ |
|
1485 SKM_ASN1_seq_unpack(X509_EXTENSION, (buf), (len), (d2i_func), (free_func)) |
|
1486 |
|
1487 #define d2i_ASN1_SET_OF_X509_NAME_ENTRY(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1488 SKM_ASN1_SET_OF_d2i(X509_NAME_ENTRY, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1489 #define i2d_ASN1_SET_OF_X509_NAME_ENTRY(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1490 SKM_ASN1_SET_OF_i2d(X509_NAME_ENTRY, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1491 #define ASN1_seq_pack_X509_NAME_ENTRY(st, i2d_func, buf, len) \ |
|
1492 SKM_ASN1_seq_pack(X509_NAME_ENTRY, (st), (i2d_func), (buf), (len)) |
|
1493 #define ASN1_seq_unpack_X509_NAME_ENTRY(buf, len, d2i_func, free_func) \ |
|
1494 SKM_ASN1_seq_unpack(X509_NAME_ENTRY, (buf), (len), (d2i_func), (free_func)) |
|
1495 |
|
1496 #define d2i_ASN1_SET_OF_X509_REVOKED(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ |
|
1497 SKM_ASN1_SET_OF_d2i(X509_REVOKED, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) |
|
1498 #define i2d_ASN1_SET_OF_X509_REVOKED(st, pp, i2d_func, ex_tag, ex_class, is_set) \ |
|
1499 SKM_ASN1_SET_OF_i2d(X509_REVOKED, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) |
|
1500 #define ASN1_seq_pack_X509_REVOKED(st, i2d_func, buf, len) \ |
|
1501 SKM_ASN1_seq_pack(X509_REVOKED, (st), (i2d_func), (buf), (len)) |
|
1502 #define ASN1_seq_unpack_X509_REVOKED(buf, len, d2i_func, free_func) \ |
|
1503 SKM_ASN1_seq_unpack(X509_REVOKED, (buf), (len), (d2i_func), (free_func)) |
|
1504 |
|
1505 #define PKCS12_decrypt_d2i_PKCS12_SAFEBAG(algor, d2i_func, free_func, pass, passlen, oct, seq) \ |
|
1506 SKM_PKCS12_decrypt_d2i(PKCS12_SAFEBAG, (algor), (d2i_func), (free_func), (pass), (passlen), (oct), (seq)) |
|
1507 |
|
1508 #define PKCS12_decrypt_d2i_PKCS7(algor, d2i_func, free_func, pass, passlen, oct, seq) \ |
|
1509 SKM_PKCS12_decrypt_d2i(PKCS7, (algor), (d2i_func), (free_func), (pass), (passlen), (oct), (seq)) |
|
1510 /* End of util/mkstack.pl block, you may now edit :-) */ |
|
1511 |
|
1512 #endif /* !defined HEADER_SAFESTACK_H */ |
|
1513 |