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 # ifndef CHECKED_PTR_OF 63 # define CHECKED_PTR_OF(type, p) \ 64 ((void*) (1 ? p : (type*)0)) 65 # endif 66 67 # define CHECKED_SK_FREE_FUNC(type, p) \ 68 ((void (*)(void *)) ((1 ? p : (void (*)(type *))0))) 69 70 # define CHECKED_SK_CMP_FUNC(type, p) \ 71 ((int (*)(const char * const *, const char * const *)) \ 72 ((1 ? p : (int (*)(const type * const *, const type * const *))0))) 73 74 # define STACK_OF(type) struct stack_st_##type 75 # define PREDECLARE_STACK_OF(type) STACK_OF(type); 76 77 # define DECLARE_STACK_OF(type) \ 78 STACK_OF(type) \ 79 { \ 80 STACK stack; \ 81 }; 82 83 /* nada (obsolete in new safestack approach)*/ 84 # define IMPLEMENT_STACK_OF(type) 85 86 /* 87 * SKM_sk_... stack macros are internal to safestack.h: never use them 88 * directly, use sk_<type>_... instead 89 */ 90 # define SKM_sk_new(type, cmp) \ 91 ((STACK_OF(type) *)sk_new(CHECKED_SK_CMP_FUNC(type, cmp))) 92 # define SKM_sk_new_null(type) \ 93 ((STACK_OF(type) *)sk_new_null()) 94 # define SKM_sk_free(type, st) \ 95 sk_free(CHECKED_PTR_OF(STACK_OF(type), st)) 96 # define SKM_sk_num(type, st) \ 97 sk_num(CHECKED_PTR_OF(STACK_OF(type), st)) 98 # define SKM_sk_value(type, st,i) \ 99 ((type *)sk_value(CHECKED_PTR_OF(STACK_OF(type), st), i)) 100 # define SKM_sk_set(type, st,i,val) \ 101 sk_set(CHECKED_PTR_OF(STACK_OF(type), st), i, CHECKED_PTR_OF(type, val)) 102 # define SKM_sk_zero(type, st) \ 103 sk_zero(CHECKED_PTR_OF(STACK_OF(type), st)) 104 # define SKM_sk_push(type, st,val) \ 105 sk_push(CHECKED_PTR_OF(STACK_OF(type), st), CHECKED_PTR_OF(type, val)) 106 # define SKM_sk_unshift(type, st,val) \ 107 sk_unshift(CHECKED_PTR_OF(STACK_OF(type), st), CHECKED_PTR_OF(type, val)) 108 # define SKM_sk_find(type, st,val) \ 109 sk_find(CHECKED_PTR_OF(STACK_OF(type), st), CHECKED_PTR_OF(type, val)) 110 # define SKM_sk_delete(type, st,i) \ 111 (type *)sk_delete(CHECKED_PTR_OF(STACK_OF(type), st), i) 112 # define SKM_sk_delete_ptr(type, st,ptr) \ 113 (type *)sk_delete_ptr(CHECKED_PTR_OF(STACK_OF(type), st), CHECKED_PTR_OF(type, ptr)) 114 # define SKM_sk_insert(type, st,val,i) \ 115 sk_insert(CHECKED_PTR_OF(STACK_OF(type), st), CHECKED_PTR_OF(type, val), i) 116 # define SKM_sk_set_cmp_func(type, st,cmp) \ 117 ((int (*)(const type * const *,const type * const *)) \ 118 sk_set_cmp_func(CHECKED_PTR_OF(STACK_OF(type), st), CHECKED_SK_CMP_FUNC(type, cmp))) 119 # define SKM_sk_dup(type, st) \ 120 (STACK_OF(type) *)sk_dup(CHECKED_PTR_OF(STACK_OF(type), st)) 121 # define SKM_sk_pop_free(type, st,free_func) \ 122 sk_pop_free(CHECKED_PTR_OF(STACK_OF(type), st), CHECKED_SK_FREE_FUNC(type, free_func)) 123 # define SKM_sk_shift(type, st) \ 124 (type *)sk_shift(CHECKED_PTR_OF(STACK_OF(type), st)) 125 # define SKM_sk_pop(type, st) \ 126 (type *)sk_pop(CHECKED_PTR_OF(STACK_OF(type), st)) 127 # define SKM_sk_sort(type, st) \ 128 sk_sort(CHECKED_PTR_OF(STACK_OF(type), st)) 129 # define SKM_sk_is_sorted(type, st) \ 130 sk_is_sorted(CHECKED_PTR_OF(STACK_OF(type), st)) 131 132 # define SKM_ASN1_SET_OF_d2i(type, st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 133 (STACK_OF(type) *)d2i_ASN1_SET(CHECKED_PTR_OF(STACK_OF(type)*, st), \ 134 pp, length, \ 135 CHECKED_D2I_OF(type, d2i_func), \ 136 CHECKED_SK_FREE_FUNC(type, free_func), \ 137 ex_tag, ex_class) 138 139 # define SKM_ASN1_SET_OF_i2d(type, st, pp, i2d_func, ex_tag, ex_class, is_set) \ 140 i2d_ASN1_SET(CHECKED_PTR_OF(STACK_OF(type), st), pp, \ 141 CHECKED_I2D_OF(type, i2d_func), \ 142 ex_tag, ex_class, is_set) 143 144 # define SKM_ASN1_seq_pack(type, st, i2d_func, buf, len) \ 145 ASN1_seq_pack(CHECKED_PTR_OF(STACK_OF(type), st), \ 146 CHECKED_I2D_OF(type, i2d_func), buf, len) 147 148 # define SKM_ASN1_seq_unpack(type, buf, len, d2i_func, free_func) \ 149 (STACK_OF(type) *)ASN1_seq_unpack(buf, len, CHECKED_D2I_OF(type, d2i_func), CHECKED_SK_FREE_FUNC(type, free_func)) 150 151 # define SKM_PKCS12_decrypt_d2i(type, algor, d2i_func, free_func, pass, passlen, oct, seq) \ 152 (STACK_OF(type) *)PKCS12_decrypt_d2i(algor, \ 153 CHECKED_D2I_OF(type, d2i_func), \ 154 CHECKED_SK_FREE_FUNC(type, free_func), \ 155 pass, passlen, oct, seq) 156 157 # else 158 159 # define STACK_OF(type) STACK 160 # define PREDECLARE_STACK_OF(type) 161 /* nada */ 162 # define DECLARE_STACK_OF(type)/* nada */ 163 # define IMPLEMENT_STACK_OF(type) 164 /* nada */ 165 166 # define SKM_sk_new(type, cmp) \ 167 sk_new((int (*)(const char * const *, const char * const *))(cmp)) 168 # define SKM_sk_new_null(type) \ 169 sk_new_null() 170 # define SKM_sk_free(type, st) \ 171 sk_free(st) 172 # define SKM_sk_num(type, st) \ 173 sk_num(st) 174 # define SKM_sk_value(type, st,i) \ 175 ((type *)sk_value(st, i)) 176 # define SKM_sk_set(type, st,i,val) \ 177 ((type *)sk_set(st, i,(char *)val)) 178 # define SKM_sk_zero(type, st) \ 179 sk_zero(st) 180 # define SKM_sk_push(type, st,val) \ 181 sk_push(st, (char *)val) 182 # define SKM_sk_unshift(type, st,val) \ 183 sk_unshift(st, (char *)val) 184 # define SKM_sk_find(type, st,val) \ 185 sk_find(st, (char *)val) 186 # define SKM_sk_delete(type, st,i) \ 187 ((type *)sk_delete(st, i)) 188 # define SKM_sk_delete_ptr(type, st,ptr) \ 189 ((type *)sk_delete_ptr(st,(char *)ptr)) 190 # define SKM_sk_insert(type, st,val,i) \ 191 sk_insert(st, (char *)val, i) 192 # define SKM_sk_set_cmp_func(type, st,cmp) \ 193 ((int (*)(const type * const *,const type * const *)) \ 194 sk_set_cmp_func(st, (int (*)(const char * const *, const char * const *))(cmp))) 195 # define SKM_sk_dup(type, st) \ 196 sk_dup(st) 197 # define SKM_sk_pop_free(type, st,free_func) \ 198 sk_pop_free(st, (void (*)(void *))free_func) 199 # define SKM_sk_shift(type, st) \ 200 ((type *)sk_shift(st)) 201 # define SKM_sk_pop(type, st) \ 202 ((type *)sk_pop(st)) 203 # define SKM_sk_sort(type, st) \ 204 sk_sort(st) 205 # define SKM_sk_is_sorted(type, st) \ 206 sk_is_sorted(st) 207 208 # define SKM_ASN1_SET_OF_d2i(type, st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 209 d2i_ASN1_SET(st,pp,length, (void *(*)(void ** ,const unsigned char ** ,long))d2i_func, (void (*)(void *))free_func, ex_tag,ex_class) 210 # define SKM_ASN1_SET_OF_i2d(type, st, pp, i2d_func, ex_tag, ex_class, is_set) \ 211 i2d_ASN1_SET(st,pp,(int (*)(void *, unsigned char **))i2d_func,ex_tag,ex_class,is_set) 212 213 # define SKM_ASN1_seq_pack(type, st, i2d_func, buf, len) \ 214 ASN1_seq_pack(st, (int (*)(void *, unsigned char **))i2d_func, buf, len) 215 # define SKM_ASN1_seq_unpack(type, buf, len, d2i_func, free_func) \ 216 ASN1_seq_unpack(buf,len,(void *(*)(void **,const unsigned char **,long))d2i_func, (void(*)(void *))free_func) 217 218 # define SKM_PKCS12_decrypt_d2i(type, algor, d2i_func, free_func, pass, passlen, oct, seq) \ 219 ((STACK *)PKCS12_decrypt_d2i(algor,(char *(*)())d2i_func, (void(*)(void *))free_func,pass,passlen,oct,seq)) 220 221 # endif 222 223 /* 224 * This block of defines is updated by util/mkstack.pl, please do not touch! 225 */ 226 # define sk_ACCESS_DESCRIPTION_new(st) SKM_sk_new(ACCESS_DESCRIPTION, (st)) 227 # define sk_ACCESS_DESCRIPTION_new_null() SKM_sk_new_null(ACCESS_DESCRIPTION) 228 # define sk_ACCESS_DESCRIPTION_free(st) SKM_sk_free(ACCESS_DESCRIPTION, (st)) 229 # define sk_ACCESS_DESCRIPTION_num(st) SKM_sk_num(ACCESS_DESCRIPTION, (st)) 230 # define sk_ACCESS_DESCRIPTION_value(st, i) SKM_sk_value(ACCESS_DESCRIPTION, (st), (i)) 231 # define sk_ACCESS_DESCRIPTION_set(st, i, val) SKM_sk_set(ACCESS_DESCRIPTION, (st), (i), (val)) 232 # define sk_ACCESS_DESCRIPTION_zero(st) SKM_sk_zero(ACCESS_DESCRIPTION, (st)) 233 # define sk_ACCESS_DESCRIPTION_push(st, val) SKM_sk_push(ACCESS_DESCRIPTION, (st), (val)) 234 # define sk_ACCESS_DESCRIPTION_unshift(st, val) SKM_sk_unshift(ACCESS_DESCRIPTION, (st), (val)) 235 # define sk_ACCESS_DESCRIPTION_find(st, val) SKM_sk_find(ACCESS_DESCRIPTION, (st), (val)) 236 # define sk_ACCESS_DESCRIPTION_find_ex(st, val) SKM_sk_find_ex(ACCESS_DESCRIPTION, (st), (val)) 237 # define sk_ACCESS_DESCRIPTION_delete(st, i) SKM_sk_delete(ACCESS_DESCRIPTION, (st), (i)) 238 # define sk_ACCESS_DESCRIPTION_delete_ptr(st, ptr) SKM_sk_delete_ptr(ACCESS_DESCRIPTION, (st), (ptr)) 239 # define sk_ACCESS_DESCRIPTION_insert(st, val, i) SKM_sk_insert(ACCESS_DESCRIPTION, (st), (val), (i)) 240 # define sk_ACCESS_DESCRIPTION_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ACCESS_DESCRIPTION, (st), (cmp)) 241 # define sk_ACCESS_DESCRIPTION_dup(st) SKM_sk_dup(ACCESS_DESCRIPTION, st) 242 # define sk_ACCESS_DESCRIPTION_pop_free(st, free_func) SKM_sk_pop_free(ACCESS_DESCRIPTION, (st), (free_func)) 243 # define sk_ACCESS_DESCRIPTION_shift(st) SKM_sk_shift(ACCESS_DESCRIPTION, (st)) 244 # define sk_ACCESS_DESCRIPTION_pop(st) SKM_sk_pop(ACCESS_DESCRIPTION, (st)) 245 # define sk_ACCESS_DESCRIPTION_sort(st) SKM_sk_sort(ACCESS_DESCRIPTION, (st)) 246 # define sk_ACCESS_DESCRIPTION_is_sorted(st) SKM_sk_is_sorted(ACCESS_DESCRIPTION, (st)) 247 248 # define sk_ASIdOrRange_new(st) SKM_sk_new(ASIdOrRange, (st)) 249 # define sk_ASIdOrRange_new_null() SKM_sk_new_null(ASIdOrRange) 250 # define sk_ASIdOrRange_free(st) SKM_sk_free(ASIdOrRange, (st)) 251 # define sk_ASIdOrRange_num(st) SKM_sk_num(ASIdOrRange, (st)) 252 # define sk_ASIdOrRange_value(st, i) SKM_sk_value(ASIdOrRange, (st), (i)) 253 # define sk_ASIdOrRange_set(st, i, val) SKM_sk_set(ASIdOrRange, (st), (i), (val)) 254 # define sk_ASIdOrRange_zero(st) SKM_sk_zero(ASIdOrRange, (st)) 255 # define sk_ASIdOrRange_push(st, val) SKM_sk_push(ASIdOrRange, (st), (val)) 256 # define sk_ASIdOrRange_unshift(st, val) SKM_sk_unshift(ASIdOrRange, (st), (val)) 257 # define sk_ASIdOrRange_find(st, val) SKM_sk_find(ASIdOrRange, (st), (val)) 258 # define sk_ASIdOrRange_find_ex(st, val) SKM_sk_find_ex(ASIdOrRange, (st), (val)) 259 # define sk_ASIdOrRange_delete(st, i) SKM_sk_delete(ASIdOrRange, (st), (i)) 260 # define sk_ASIdOrRange_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASIdOrRange, (st), (ptr)) 261 # define sk_ASIdOrRange_insert(st, val, i) SKM_sk_insert(ASIdOrRange, (st), (val), (i)) 262 # define sk_ASIdOrRange_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASIdOrRange, (st), (cmp)) 263 # define sk_ASIdOrRange_dup(st) SKM_sk_dup(ASIdOrRange, st) 264 # define sk_ASIdOrRange_pop_free(st, free_func) SKM_sk_pop_free(ASIdOrRange, (st), (free_func)) 265 # define sk_ASIdOrRange_shift(st) SKM_sk_shift(ASIdOrRange, (st)) 266 # define sk_ASIdOrRange_pop(st) SKM_sk_pop(ASIdOrRange, (st)) 267 # define sk_ASIdOrRange_sort(st) SKM_sk_sort(ASIdOrRange, (st)) 268 # define sk_ASIdOrRange_is_sorted(st) SKM_sk_is_sorted(ASIdOrRange, (st)) 269 270 # define sk_ASN1_GENERALSTRING_new(st) SKM_sk_new(ASN1_GENERALSTRING, (st)) 271 # define sk_ASN1_GENERALSTRING_new_null() SKM_sk_new_null(ASN1_GENERALSTRING) 272 # define sk_ASN1_GENERALSTRING_free(st) SKM_sk_free(ASN1_GENERALSTRING, (st)) 273 # define sk_ASN1_GENERALSTRING_num(st) SKM_sk_num(ASN1_GENERALSTRING, (st)) 274 # define sk_ASN1_GENERALSTRING_value(st, i) SKM_sk_value(ASN1_GENERALSTRING, (st), (i)) 275 # define sk_ASN1_GENERALSTRING_set(st, i, val) SKM_sk_set(ASN1_GENERALSTRING, (st), (i), (val)) 276 # define sk_ASN1_GENERALSTRING_zero(st) SKM_sk_zero(ASN1_GENERALSTRING, (st)) 277 # define sk_ASN1_GENERALSTRING_push(st, val) SKM_sk_push(ASN1_GENERALSTRING, (st), (val)) 278 # define sk_ASN1_GENERALSTRING_unshift(st, val) SKM_sk_unshift(ASN1_GENERALSTRING, (st), (val)) 279 # define sk_ASN1_GENERALSTRING_find(st, val) SKM_sk_find(ASN1_GENERALSTRING, (st), (val)) 280 # define sk_ASN1_GENERALSTRING_find_ex(st, val) SKM_sk_find_ex(ASN1_GENERALSTRING, (st), (val)) 281 # define sk_ASN1_GENERALSTRING_delete(st, i) SKM_sk_delete(ASN1_GENERALSTRING, (st), (i)) 282 # define sk_ASN1_GENERALSTRING_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_GENERALSTRING, (st), (ptr)) 283 # define sk_ASN1_GENERALSTRING_insert(st, val, i) SKM_sk_insert(ASN1_GENERALSTRING, (st), (val), (i)) 284 # define sk_ASN1_GENERALSTRING_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_GENERALSTRING, (st), (cmp)) 285 # define sk_ASN1_GENERALSTRING_dup(st) SKM_sk_dup(ASN1_GENERALSTRING, st) 286 # define sk_ASN1_GENERALSTRING_pop_free(st, free_func) SKM_sk_pop_free(ASN1_GENERALSTRING, (st), (free_func)) 287 # define sk_ASN1_GENERALSTRING_shift(st) SKM_sk_shift(ASN1_GENERALSTRING, (st)) 288 # define sk_ASN1_GENERALSTRING_pop(st) SKM_sk_pop(ASN1_GENERALSTRING, (st)) 289 # define sk_ASN1_GENERALSTRING_sort(st) SKM_sk_sort(ASN1_GENERALSTRING, (st)) 290 # define sk_ASN1_GENERALSTRING_is_sorted(st) SKM_sk_is_sorted(ASN1_GENERALSTRING, (st)) 291 292 # define sk_ASN1_INTEGER_new(st) SKM_sk_new(ASN1_INTEGER, (st)) 293 # define sk_ASN1_INTEGER_new_null() SKM_sk_new_null(ASN1_INTEGER) 294 # define sk_ASN1_INTEGER_free(st) SKM_sk_free(ASN1_INTEGER, (st)) 295 # define sk_ASN1_INTEGER_num(st) SKM_sk_num(ASN1_INTEGER, (st)) 296 # define sk_ASN1_INTEGER_value(st, i) SKM_sk_value(ASN1_INTEGER, (st), (i)) 297 # define sk_ASN1_INTEGER_set(st, i, val) SKM_sk_set(ASN1_INTEGER, (st), (i), (val)) 298 # define sk_ASN1_INTEGER_zero(st) SKM_sk_zero(ASN1_INTEGER, (st)) 299 # define sk_ASN1_INTEGER_push(st, val) SKM_sk_push(ASN1_INTEGER, (st), (val)) 300 # define sk_ASN1_INTEGER_unshift(st, val) SKM_sk_unshift(ASN1_INTEGER, (st), (val)) 301 # define sk_ASN1_INTEGER_find(st, val) SKM_sk_find(ASN1_INTEGER, (st), (val)) 302 # define sk_ASN1_INTEGER_find_ex(st, val) SKM_sk_find_ex(ASN1_INTEGER, (st), (val)) 303 # define sk_ASN1_INTEGER_delete(st, i) SKM_sk_delete(ASN1_INTEGER, (st), (i)) 304 # define sk_ASN1_INTEGER_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_INTEGER, (st), (ptr)) 305 # define sk_ASN1_INTEGER_insert(st, val, i) SKM_sk_insert(ASN1_INTEGER, (st), (val), (i)) 306 # define sk_ASN1_INTEGER_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_INTEGER, (st), (cmp)) 307 # define sk_ASN1_INTEGER_dup(st) SKM_sk_dup(ASN1_INTEGER, st) 308 # define sk_ASN1_INTEGER_pop_free(st, free_func) SKM_sk_pop_free(ASN1_INTEGER, (st), (free_func)) 309 # define sk_ASN1_INTEGER_shift(st) SKM_sk_shift(ASN1_INTEGER, (st)) 310 # define sk_ASN1_INTEGER_pop(st) SKM_sk_pop(ASN1_INTEGER, (st)) 311 # define sk_ASN1_INTEGER_sort(st) SKM_sk_sort(ASN1_INTEGER, (st)) 312 # define sk_ASN1_INTEGER_is_sorted(st) SKM_sk_is_sorted(ASN1_INTEGER, (st)) 313 314 # define sk_ASN1_OBJECT_new(st) SKM_sk_new(ASN1_OBJECT, (st)) 315 # define sk_ASN1_OBJECT_new_null() SKM_sk_new_null(ASN1_OBJECT) 316 # define sk_ASN1_OBJECT_free(st) SKM_sk_free(ASN1_OBJECT, (st)) 317 # define sk_ASN1_OBJECT_num(st) SKM_sk_num(ASN1_OBJECT, (st)) 318 # define sk_ASN1_OBJECT_value(st, i) SKM_sk_value(ASN1_OBJECT, (st), (i)) 319 # define sk_ASN1_OBJECT_set(st, i, val) SKM_sk_set(ASN1_OBJECT, (st), (i), (val)) 320 # define sk_ASN1_OBJECT_zero(st) SKM_sk_zero(ASN1_OBJECT, (st)) 321 # define sk_ASN1_OBJECT_push(st, val) SKM_sk_push(ASN1_OBJECT, (st), (val)) 322 # define sk_ASN1_OBJECT_unshift(st, val) SKM_sk_unshift(ASN1_OBJECT, (st), (val)) 323 # define sk_ASN1_OBJECT_find(st, val) SKM_sk_find(ASN1_OBJECT, (st), (val)) 324 # define sk_ASN1_OBJECT_find_ex(st, val) SKM_sk_find_ex(ASN1_OBJECT, (st), (val)) 325 # define sk_ASN1_OBJECT_delete(st, i) SKM_sk_delete(ASN1_OBJECT, (st), (i)) 326 # define sk_ASN1_OBJECT_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_OBJECT, (st), (ptr)) 327 # define sk_ASN1_OBJECT_insert(st, val, i) SKM_sk_insert(ASN1_OBJECT, (st), (val), (i)) 328 # define sk_ASN1_OBJECT_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_OBJECT, (st), (cmp)) 329 # define sk_ASN1_OBJECT_dup(st) SKM_sk_dup(ASN1_OBJECT, st) 330 # define sk_ASN1_OBJECT_pop_free(st, free_func) SKM_sk_pop_free(ASN1_OBJECT, (st), (free_func)) 331 # define sk_ASN1_OBJECT_shift(st) SKM_sk_shift(ASN1_OBJECT, (st)) 332 # define sk_ASN1_OBJECT_pop(st) SKM_sk_pop(ASN1_OBJECT, (st)) 333 # define sk_ASN1_OBJECT_sort(st) SKM_sk_sort(ASN1_OBJECT, (st)) 334 # define sk_ASN1_OBJECT_is_sorted(st) SKM_sk_is_sorted(ASN1_OBJECT, (st)) 335 336 # define sk_ASN1_STRING_TABLE_new(st) SKM_sk_new(ASN1_STRING_TABLE, (st)) 337 # define sk_ASN1_STRING_TABLE_new_null() SKM_sk_new_null(ASN1_STRING_TABLE) 338 # define sk_ASN1_STRING_TABLE_free(st) SKM_sk_free(ASN1_STRING_TABLE, (st)) 339 # define sk_ASN1_STRING_TABLE_num(st) SKM_sk_num(ASN1_STRING_TABLE, (st)) 340 # define sk_ASN1_STRING_TABLE_value(st, i) SKM_sk_value(ASN1_STRING_TABLE, (st), (i)) 341 # define sk_ASN1_STRING_TABLE_set(st, i, val) SKM_sk_set(ASN1_STRING_TABLE, (st), (i), (val)) 342 # define sk_ASN1_STRING_TABLE_zero(st) SKM_sk_zero(ASN1_STRING_TABLE, (st)) 343 # define sk_ASN1_STRING_TABLE_push(st, val) SKM_sk_push(ASN1_STRING_TABLE, (st), (val)) 344 # define sk_ASN1_STRING_TABLE_unshift(st, val) SKM_sk_unshift(ASN1_STRING_TABLE, (st), (val)) 345 # define sk_ASN1_STRING_TABLE_find(st, val) SKM_sk_find(ASN1_STRING_TABLE, (st), (val)) 346 # define sk_ASN1_STRING_TABLE_find_ex(st, val) SKM_sk_find_ex(ASN1_STRING_TABLE, (st), (val)) 347 # define sk_ASN1_STRING_TABLE_delete(st, i) SKM_sk_delete(ASN1_STRING_TABLE, (st), (i)) 348 # define sk_ASN1_STRING_TABLE_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_STRING_TABLE, (st), (ptr)) 349 # define sk_ASN1_STRING_TABLE_insert(st, val, i) SKM_sk_insert(ASN1_STRING_TABLE, (st), (val), (i)) 350 # define sk_ASN1_STRING_TABLE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_STRING_TABLE, (st), (cmp)) 351 # define sk_ASN1_STRING_TABLE_dup(st) SKM_sk_dup(ASN1_STRING_TABLE, st) 352 # define sk_ASN1_STRING_TABLE_pop_free(st, free_func) SKM_sk_pop_free(ASN1_STRING_TABLE, (st), (free_func)) 353 # define sk_ASN1_STRING_TABLE_shift(st) SKM_sk_shift(ASN1_STRING_TABLE, (st)) 354 # define sk_ASN1_STRING_TABLE_pop(st) SKM_sk_pop(ASN1_STRING_TABLE, (st)) 355 # define sk_ASN1_STRING_TABLE_sort(st) SKM_sk_sort(ASN1_STRING_TABLE, (st)) 356 # define sk_ASN1_STRING_TABLE_is_sorted(st) SKM_sk_is_sorted(ASN1_STRING_TABLE, (st)) 357 358 # define sk_ASN1_TYPE_new(st) SKM_sk_new(ASN1_TYPE, (st)) 359 # define sk_ASN1_TYPE_new_null() SKM_sk_new_null(ASN1_TYPE) 360 # define sk_ASN1_TYPE_free(st) SKM_sk_free(ASN1_TYPE, (st)) 361 # define sk_ASN1_TYPE_num(st) SKM_sk_num(ASN1_TYPE, (st)) 362 # define sk_ASN1_TYPE_value(st, i) SKM_sk_value(ASN1_TYPE, (st), (i)) 363 # define sk_ASN1_TYPE_set(st, i, val) SKM_sk_set(ASN1_TYPE, (st), (i), (val)) 364 # define sk_ASN1_TYPE_zero(st) SKM_sk_zero(ASN1_TYPE, (st)) 365 # define sk_ASN1_TYPE_push(st, val) SKM_sk_push(ASN1_TYPE, (st), (val)) 366 # define sk_ASN1_TYPE_unshift(st, val) SKM_sk_unshift(ASN1_TYPE, (st), (val)) 367 # define sk_ASN1_TYPE_find(st, val) SKM_sk_find(ASN1_TYPE, (st), (val)) 368 # define sk_ASN1_TYPE_find_ex(st, val) SKM_sk_find_ex(ASN1_TYPE, (st), (val)) 369 # define sk_ASN1_TYPE_delete(st, i) SKM_sk_delete(ASN1_TYPE, (st), (i)) 370 # define sk_ASN1_TYPE_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_TYPE, (st), (ptr)) 371 # define sk_ASN1_TYPE_insert(st, val, i) SKM_sk_insert(ASN1_TYPE, (st), (val), (i)) 372 # define sk_ASN1_TYPE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_TYPE, (st), (cmp)) 373 # define sk_ASN1_TYPE_dup(st) SKM_sk_dup(ASN1_TYPE, st) 374 # define sk_ASN1_TYPE_pop_free(st, free_func) SKM_sk_pop_free(ASN1_TYPE, (st), (free_func)) 375 # define sk_ASN1_TYPE_shift(st) SKM_sk_shift(ASN1_TYPE, (st)) 376 # define sk_ASN1_TYPE_pop(st) SKM_sk_pop(ASN1_TYPE, (st)) 377 # define sk_ASN1_TYPE_sort(st) SKM_sk_sort(ASN1_TYPE, (st)) 378 # define sk_ASN1_TYPE_is_sorted(st) SKM_sk_is_sorted(ASN1_TYPE, (st)) 379 380 # define sk_ASN1_VALUE_new(st) SKM_sk_new(ASN1_VALUE, (st)) 381 # define sk_ASN1_VALUE_new_null() SKM_sk_new_null(ASN1_VALUE) 382 # define sk_ASN1_VALUE_free(st) SKM_sk_free(ASN1_VALUE, (st)) 383 # define sk_ASN1_VALUE_num(st) SKM_sk_num(ASN1_VALUE, (st)) 384 # define sk_ASN1_VALUE_value(st, i) SKM_sk_value(ASN1_VALUE, (st), (i)) 385 # define sk_ASN1_VALUE_set(st, i, val) SKM_sk_set(ASN1_VALUE, (st), (i), (val)) 386 # define sk_ASN1_VALUE_zero(st) SKM_sk_zero(ASN1_VALUE, (st)) 387 # define sk_ASN1_VALUE_push(st, val) SKM_sk_push(ASN1_VALUE, (st), (val)) 388 # define sk_ASN1_VALUE_unshift(st, val) SKM_sk_unshift(ASN1_VALUE, (st), (val)) 389 # define sk_ASN1_VALUE_find(st, val) SKM_sk_find(ASN1_VALUE, (st), (val)) 390 # define sk_ASN1_VALUE_find_ex(st, val) SKM_sk_find_ex(ASN1_VALUE, (st), (val)) 391 # define sk_ASN1_VALUE_delete(st, i) SKM_sk_delete(ASN1_VALUE, (st), (i)) 392 # define sk_ASN1_VALUE_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_VALUE, (st), (ptr)) 393 # define sk_ASN1_VALUE_insert(st, val, i) SKM_sk_insert(ASN1_VALUE, (st), (val), (i)) 394 # define sk_ASN1_VALUE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_VALUE, (st), (cmp)) 395 # define sk_ASN1_VALUE_dup(st) SKM_sk_dup(ASN1_VALUE, st) 396 # define sk_ASN1_VALUE_pop_free(st, free_func) SKM_sk_pop_free(ASN1_VALUE, (st), (free_func)) 397 # define sk_ASN1_VALUE_shift(st) SKM_sk_shift(ASN1_VALUE, (st)) 398 # define sk_ASN1_VALUE_pop(st) SKM_sk_pop(ASN1_VALUE, (st)) 399 # define sk_ASN1_VALUE_sort(st) SKM_sk_sort(ASN1_VALUE, (st)) 400 # define sk_ASN1_VALUE_is_sorted(st) SKM_sk_is_sorted(ASN1_VALUE, (st)) 401 402 # define sk_BIO_new(st) SKM_sk_new(BIO, (st)) 403 # define sk_BIO_new_null() SKM_sk_new_null(BIO) 404 # define sk_BIO_free(st) SKM_sk_free(BIO, (st)) 405 # define sk_BIO_num(st) SKM_sk_num(BIO, (st)) 406 # define sk_BIO_value(st, i) SKM_sk_value(BIO, (st), (i)) 407 # define sk_BIO_set(st, i, val) SKM_sk_set(BIO, (st), (i), (val)) 408 # define sk_BIO_zero(st) SKM_sk_zero(BIO, (st)) 409 # define sk_BIO_push(st, val) SKM_sk_push(BIO, (st), (val)) 410 # define sk_BIO_unshift(st, val) SKM_sk_unshift(BIO, (st), (val)) 411 # define sk_BIO_find(st, val) SKM_sk_find(BIO, (st), (val)) 412 # define sk_BIO_find_ex(st, val) SKM_sk_find_ex(BIO, (st), (val)) 413 # define sk_BIO_delete(st, i) SKM_sk_delete(BIO, (st), (i)) 414 # define sk_BIO_delete_ptr(st, ptr) SKM_sk_delete_ptr(BIO, (st), (ptr)) 415 # define sk_BIO_insert(st, val, i) SKM_sk_insert(BIO, (st), (val), (i)) 416 # define sk_BIO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(BIO, (st), (cmp)) 417 # define sk_BIO_dup(st) SKM_sk_dup(BIO, st) 418 # define sk_BIO_pop_free(st, free_func) SKM_sk_pop_free(BIO, (st), (free_func)) 419 # define sk_BIO_shift(st) SKM_sk_shift(BIO, (st)) 420 # define sk_BIO_pop(st) SKM_sk_pop(BIO, (st)) 421 # define sk_BIO_sort(st) SKM_sk_sort(BIO, (st)) 422 # define sk_BIO_is_sorted(st) SKM_sk_is_sorted(BIO, (st)) 423 424 # define sk_CMS_CertificateChoices_new(st) SKM_sk_new(CMS_CertificateChoices, (st)) 425 # define sk_CMS_CertificateChoices_new_null() SKM_sk_new_null(CMS_CertificateChoices) 426 # define sk_CMS_CertificateChoices_free(st) SKM_sk_free(CMS_CertificateChoices, (st)) 427 # define sk_CMS_CertificateChoices_num(st) SKM_sk_num(CMS_CertificateChoices, (st)) 428 # define sk_CMS_CertificateChoices_value(st, i) SKM_sk_value(CMS_CertificateChoices, (st), (i)) 429 # define sk_CMS_CertificateChoices_set(st, i, val) SKM_sk_set(CMS_CertificateChoices, (st), (i), (val)) 430 # define sk_CMS_CertificateChoices_zero(st) SKM_sk_zero(CMS_CertificateChoices, (st)) 431 # define sk_CMS_CertificateChoices_push(st, val) SKM_sk_push(CMS_CertificateChoices, (st), (val)) 432 # define sk_CMS_CertificateChoices_unshift(st, val) SKM_sk_unshift(CMS_CertificateChoices, (st), (val)) 433 # define sk_CMS_CertificateChoices_find(st, val) SKM_sk_find(CMS_CertificateChoices, (st), (val)) 434 # define sk_CMS_CertificateChoices_find_ex(st, val) SKM_sk_find_ex(CMS_CertificateChoices, (st), (val)) 435 # define sk_CMS_CertificateChoices_delete(st, i) SKM_sk_delete(CMS_CertificateChoices, (st), (i)) 436 # define sk_CMS_CertificateChoices_delete_ptr(st, ptr) SKM_sk_delete_ptr(CMS_CertificateChoices, (st), (ptr)) 437 # define sk_CMS_CertificateChoices_insert(st, val, i) SKM_sk_insert(CMS_CertificateChoices, (st), (val), (i)) 438 # define sk_CMS_CertificateChoices_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CMS_CertificateChoices, (st), (cmp)) 439 # define sk_CMS_CertificateChoices_dup(st) SKM_sk_dup(CMS_CertificateChoices, st) 440 # define sk_CMS_CertificateChoices_pop_free(st, free_func) SKM_sk_pop_free(CMS_CertificateChoices, (st), (free_func)) 441 # define sk_CMS_CertificateChoices_shift(st) SKM_sk_shift(CMS_CertificateChoices, (st)) 442 # define sk_CMS_CertificateChoices_pop(st) SKM_sk_pop(CMS_CertificateChoices, (st)) 443 # define sk_CMS_CertificateChoices_sort(st) SKM_sk_sort(CMS_CertificateChoices, (st)) 444 # define sk_CMS_CertificateChoices_is_sorted(st) SKM_sk_is_sorted(CMS_CertificateChoices, (st)) 445 446 # define sk_CMS_RecipientInfo_new(st) SKM_sk_new(CMS_RecipientInfo, (st)) 447 # define sk_CMS_RecipientInfo_new_null() SKM_sk_new_null(CMS_RecipientInfo) 448 # define sk_CMS_RecipientInfo_free(st) SKM_sk_free(CMS_RecipientInfo, (st)) 449 # define sk_CMS_RecipientInfo_num(st) SKM_sk_num(CMS_RecipientInfo, (st)) 450 # define sk_CMS_RecipientInfo_value(st, i) SKM_sk_value(CMS_RecipientInfo, (st), (i)) 451 # define sk_CMS_RecipientInfo_set(st, i, val) SKM_sk_set(CMS_RecipientInfo, (st), (i), (val)) 452 # define sk_CMS_RecipientInfo_zero(st) SKM_sk_zero(CMS_RecipientInfo, (st)) 453 # define sk_CMS_RecipientInfo_push(st, val) SKM_sk_push(CMS_RecipientInfo, (st), (val)) 454 # define sk_CMS_RecipientInfo_unshift(st, val) SKM_sk_unshift(CMS_RecipientInfo, (st), (val)) 455 # define sk_CMS_RecipientInfo_find(st, val) SKM_sk_find(CMS_RecipientInfo, (st), (val)) 456 # define sk_CMS_RecipientInfo_find_ex(st, val) SKM_sk_find_ex(CMS_RecipientInfo, (st), (val)) 457 # define sk_CMS_RecipientInfo_delete(st, i) SKM_sk_delete(CMS_RecipientInfo, (st), (i)) 458 # define sk_CMS_RecipientInfo_delete_ptr(st, ptr) SKM_sk_delete_ptr(CMS_RecipientInfo, (st), (ptr)) 459 # define sk_CMS_RecipientInfo_insert(st, val, i) SKM_sk_insert(CMS_RecipientInfo, (st), (val), (i)) 460 # define sk_CMS_RecipientInfo_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CMS_RecipientInfo, (st), (cmp)) 461 # define sk_CMS_RecipientInfo_dup(st) SKM_sk_dup(CMS_RecipientInfo, st) 462 # define sk_CMS_RecipientInfo_pop_free(st, free_func) SKM_sk_pop_free(CMS_RecipientInfo, (st), (free_func)) 463 # define sk_CMS_RecipientInfo_shift(st) SKM_sk_shift(CMS_RecipientInfo, (st)) 464 # define sk_CMS_RecipientInfo_pop(st) SKM_sk_pop(CMS_RecipientInfo, (st)) 465 # define sk_CMS_RecipientInfo_sort(st) SKM_sk_sort(CMS_RecipientInfo, (st)) 466 # define sk_CMS_RecipientInfo_is_sorted(st) SKM_sk_is_sorted(CMS_RecipientInfo, (st)) 467 468 # define sk_CMS_RevocationInfoChoice_new(st) SKM_sk_new(CMS_RevocationInfoChoice, (st)) 469 # define sk_CMS_RevocationInfoChoice_new_null() SKM_sk_new_null(CMS_RevocationInfoChoice) 470 # define sk_CMS_RevocationInfoChoice_free(st) SKM_sk_free(CMS_RevocationInfoChoice, (st)) 471 # define sk_CMS_RevocationInfoChoice_num(st) SKM_sk_num(CMS_RevocationInfoChoice, (st)) 472 # define sk_CMS_RevocationInfoChoice_value(st, i) SKM_sk_value(CMS_RevocationInfoChoice, (st), (i)) 473 # define sk_CMS_RevocationInfoChoice_set(st, i, val) SKM_sk_set(CMS_RevocationInfoChoice, (st), (i), (val)) 474 # define sk_CMS_RevocationInfoChoice_zero(st) SKM_sk_zero(CMS_RevocationInfoChoice, (st)) 475 # define sk_CMS_RevocationInfoChoice_push(st, val) SKM_sk_push(CMS_RevocationInfoChoice, (st), (val)) 476 # define sk_CMS_RevocationInfoChoice_unshift(st, val) SKM_sk_unshift(CMS_RevocationInfoChoice, (st), (val)) 477 # define sk_CMS_RevocationInfoChoice_find(st, val) SKM_sk_find(CMS_RevocationInfoChoice, (st), (val)) 478 # define sk_CMS_RevocationInfoChoice_find_ex(st, val) SKM_sk_find_ex(CMS_RevocationInfoChoice, (st), (val)) 479 # define sk_CMS_RevocationInfoChoice_delete(st, i) SKM_sk_delete(CMS_RevocationInfoChoice, (st), (i)) 480 # define sk_CMS_RevocationInfoChoice_delete_ptr(st, ptr) SKM_sk_delete_ptr(CMS_RevocationInfoChoice, (st), (ptr)) 481 # define sk_CMS_RevocationInfoChoice_insert(st, val, i) SKM_sk_insert(CMS_RevocationInfoChoice, (st), (val), (i)) 482 # define sk_CMS_RevocationInfoChoice_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CMS_RevocationInfoChoice, (st), (cmp)) 483 # define sk_CMS_RevocationInfoChoice_dup(st) SKM_sk_dup(CMS_RevocationInfoChoice, st) 484 # define sk_CMS_RevocationInfoChoice_pop_free(st, free_func) SKM_sk_pop_free(CMS_RevocationInfoChoice, (st), (free_func)) 485 # define sk_CMS_RevocationInfoChoice_shift(st) SKM_sk_shift(CMS_RevocationInfoChoice, (st)) 486 # define sk_CMS_RevocationInfoChoice_pop(st) SKM_sk_pop(CMS_RevocationInfoChoice, (st)) 487 # define sk_CMS_RevocationInfoChoice_sort(st) SKM_sk_sort(CMS_RevocationInfoChoice, (st)) 488 # define sk_CMS_RevocationInfoChoice_is_sorted(st) SKM_sk_is_sorted(CMS_RevocationInfoChoice, (st)) 489 490 # define sk_CMS_SignerInfo_new(st) SKM_sk_new(CMS_SignerInfo, (st)) 491 # define sk_CMS_SignerInfo_new_null() SKM_sk_new_null(CMS_SignerInfo) 492 # define sk_CMS_SignerInfo_free(st) SKM_sk_free(CMS_SignerInfo, (st)) 493 # define sk_CMS_SignerInfo_num(st) SKM_sk_num(CMS_SignerInfo, (st)) 494 # define sk_CMS_SignerInfo_value(st, i) SKM_sk_value(CMS_SignerInfo, (st), (i)) 495 # define sk_CMS_SignerInfo_set(st, i, val) SKM_sk_set(CMS_SignerInfo, (st), (i), (val)) 496 # define sk_CMS_SignerInfo_zero(st) SKM_sk_zero(CMS_SignerInfo, (st)) 497 # define sk_CMS_SignerInfo_push(st, val) SKM_sk_push(CMS_SignerInfo, (st), (val)) 498 # define sk_CMS_SignerInfo_unshift(st, val) SKM_sk_unshift(CMS_SignerInfo, (st), (val)) 499 # define sk_CMS_SignerInfo_find(st, val) SKM_sk_find(CMS_SignerInfo, (st), (val)) 500 # define sk_CMS_SignerInfo_find_ex(st, val) SKM_sk_find_ex(CMS_SignerInfo, (st), (val)) 501 # define sk_CMS_SignerInfo_delete(st, i) SKM_sk_delete(CMS_SignerInfo, (st), (i)) 502 # define sk_CMS_SignerInfo_delete_ptr(st, ptr) SKM_sk_delete_ptr(CMS_SignerInfo, (st), (ptr)) 503 # define sk_CMS_SignerInfo_insert(st, val, i) SKM_sk_insert(CMS_SignerInfo, (st), (val), (i)) 504 # define sk_CMS_SignerInfo_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CMS_SignerInfo, (st), (cmp)) 505 # define sk_CMS_SignerInfo_dup(st) SKM_sk_dup(CMS_SignerInfo, st) 506 # define sk_CMS_SignerInfo_pop_free(st, free_func) SKM_sk_pop_free(CMS_SignerInfo, (st), (free_func)) 507 # define sk_CMS_SignerInfo_shift(st) SKM_sk_shift(CMS_SignerInfo, (st)) 508 # define sk_CMS_SignerInfo_pop(st) SKM_sk_pop(CMS_SignerInfo, (st)) 509 # define sk_CMS_SignerInfo_sort(st) SKM_sk_sort(CMS_SignerInfo, (st)) 510 # define sk_CMS_SignerInfo_is_sorted(st) SKM_sk_is_sorted(CMS_SignerInfo, (st)) 511 512 # define sk_CONF_IMODULE_new(st) SKM_sk_new(CONF_IMODULE, (st)) 513 # define sk_CONF_IMODULE_new_null() SKM_sk_new_null(CONF_IMODULE) 514 # define sk_CONF_IMODULE_free(st) SKM_sk_free(CONF_IMODULE, (st)) 515 # define sk_CONF_IMODULE_num(st) SKM_sk_num(CONF_IMODULE, (st)) 516 # define sk_CONF_IMODULE_value(st, i) SKM_sk_value(CONF_IMODULE, (st), (i)) 517 # define sk_CONF_IMODULE_set(st, i, val) SKM_sk_set(CONF_IMODULE, (st), (i), (val)) 518 # define sk_CONF_IMODULE_zero(st) SKM_sk_zero(CONF_IMODULE, (st)) 519 # define sk_CONF_IMODULE_push(st, val) SKM_sk_push(CONF_IMODULE, (st), (val)) 520 # define sk_CONF_IMODULE_unshift(st, val) SKM_sk_unshift(CONF_IMODULE, (st), (val)) 521 # define sk_CONF_IMODULE_find(st, val) SKM_sk_find(CONF_IMODULE, (st), (val)) 522 # define sk_CONF_IMODULE_find_ex(st, val) SKM_sk_find_ex(CONF_IMODULE, (st), (val)) 523 # define sk_CONF_IMODULE_delete(st, i) SKM_sk_delete(CONF_IMODULE, (st), (i)) 524 # define sk_CONF_IMODULE_delete_ptr(st, ptr) SKM_sk_delete_ptr(CONF_IMODULE, (st), (ptr)) 525 # define sk_CONF_IMODULE_insert(st, val, i) SKM_sk_insert(CONF_IMODULE, (st), (val), (i)) 526 # define sk_CONF_IMODULE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CONF_IMODULE, (st), (cmp)) 527 # define sk_CONF_IMODULE_dup(st) SKM_sk_dup(CONF_IMODULE, st) 528 # define sk_CONF_IMODULE_pop_free(st, free_func) SKM_sk_pop_free(CONF_IMODULE, (st), (free_func)) 529 # define sk_CONF_IMODULE_shift(st) SKM_sk_shift(CONF_IMODULE, (st)) 530 # define sk_CONF_IMODULE_pop(st) SKM_sk_pop(CONF_IMODULE, (st)) 531 # define sk_CONF_IMODULE_sort(st) SKM_sk_sort(CONF_IMODULE, (st)) 532 # define sk_CONF_IMODULE_is_sorted(st) SKM_sk_is_sorted(CONF_IMODULE, (st)) 533 534 # define sk_CONF_MODULE_new(st) SKM_sk_new(CONF_MODULE, (st)) 535 # define sk_CONF_MODULE_new_null() SKM_sk_new_null(CONF_MODULE) 536 # define sk_CONF_MODULE_free(st) SKM_sk_free(CONF_MODULE, (st)) 537 # define sk_CONF_MODULE_num(st) SKM_sk_num(CONF_MODULE, (st)) 538 # define sk_CONF_MODULE_value(st, i) SKM_sk_value(CONF_MODULE, (st), (i)) 539 # define sk_CONF_MODULE_set(st, i, val) SKM_sk_set(CONF_MODULE, (st), (i), (val)) 540 # define sk_CONF_MODULE_zero(st) SKM_sk_zero(CONF_MODULE, (st)) 541 # define sk_CONF_MODULE_push(st, val) SKM_sk_push(CONF_MODULE, (st), (val)) 542 # define sk_CONF_MODULE_unshift(st, val) SKM_sk_unshift(CONF_MODULE, (st), (val)) 543 # define sk_CONF_MODULE_find(st, val) SKM_sk_find(CONF_MODULE, (st), (val)) 544 # define sk_CONF_MODULE_find_ex(st, val) SKM_sk_find_ex(CONF_MODULE, (st), (val)) 545 # define sk_CONF_MODULE_delete(st, i) SKM_sk_delete(CONF_MODULE, (st), (i)) 546 # define sk_CONF_MODULE_delete_ptr(st, ptr) SKM_sk_delete_ptr(CONF_MODULE, (st), (ptr)) 547 # define sk_CONF_MODULE_insert(st, val, i) SKM_sk_insert(CONF_MODULE, (st), (val), (i)) 548 # define sk_CONF_MODULE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CONF_MODULE, (st), (cmp)) 549 # define sk_CONF_MODULE_dup(st) SKM_sk_dup(CONF_MODULE, st) 550 # define sk_CONF_MODULE_pop_free(st, free_func) SKM_sk_pop_free(CONF_MODULE, (st), (free_func)) 551 # define sk_CONF_MODULE_shift(st) SKM_sk_shift(CONF_MODULE, (st)) 552 # define sk_CONF_MODULE_pop(st) SKM_sk_pop(CONF_MODULE, (st)) 553 # define sk_CONF_MODULE_sort(st) SKM_sk_sort(CONF_MODULE, (st)) 554 # define sk_CONF_MODULE_is_sorted(st) SKM_sk_is_sorted(CONF_MODULE, (st)) 555 556 # define sk_CONF_VALUE_new(st) SKM_sk_new(CONF_VALUE, (st)) 557 # define sk_CONF_VALUE_new_null() SKM_sk_new_null(CONF_VALUE) 558 # define sk_CONF_VALUE_free(st) SKM_sk_free(CONF_VALUE, (st)) 559 # define sk_CONF_VALUE_num(st) SKM_sk_num(CONF_VALUE, (st)) 560 # define sk_CONF_VALUE_value(st, i) SKM_sk_value(CONF_VALUE, (st), (i)) 561 # define sk_CONF_VALUE_set(st, i, val) SKM_sk_set(CONF_VALUE, (st), (i), (val)) 562 # define sk_CONF_VALUE_zero(st) SKM_sk_zero(CONF_VALUE, (st)) 563 # define sk_CONF_VALUE_push(st, val) SKM_sk_push(CONF_VALUE, (st), (val)) 564 # define sk_CONF_VALUE_unshift(st, val) SKM_sk_unshift(CONF_VALUE, (st), (val)) 565 # define sk_CONF_VALUE_find(st, val) SKM_sk_find(CONF_VALUE, (st), (val)) 566 # define sk_CONF_VALUE_find_ex(st, val) SKM_sk_find_ex(CONF_VALUE, (st), (val)) 567 # define sk_CONF_VALUE_delete(st, i) SKM_sk_delete(CONF_VALUE, (st), (i)) 568 # define sk_CONF_VALUE_delete_ptr(st, ptr) SKM_sk_delete_ptr(CONF_VALUE, (st), (ptr)) 569 # define sk_CONF_VALUE_insert(st, val, i) SKM_sk_insert(CONF_VALUE, (st), (val), (i)) 570 # define sk_CONF_VALUE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CONF_VALUE, (st), (cmp)) 571 # define sk_CONF_VALUE_dup(st) SKM_sk_dup(CONF_VALUE, st) 572 # define sk_CONF_VALUE_pop_free(st, free_func) SKM_sk_pop_free(CONF_VALUE, (st), (free_func)) 573 # define sk_CONF_VALUE_shift(st) SKM_sk_shift(CONF_VALUE, (st)) 574 # define sk_CONF_VALUE_pop(st) SKM_sk_pop(CONF_VALUE, (st)) 575 # define sk_CONF_VALUE_sort(st) SKM_sk_sort(CONF_VALUE, (st)) 576 # define sk_CONF_VALUE_is_sorted(st) SKM_sk_is_sorted(CONF_VALUE, (st)) 577 578 # define sk_CRYPTO_EX_DATA_FUNCS_new(st) SKM_sk_new(CRYPTO_EX_DATA_FUNCS, (st)) 579 # define sk_CRYPTO_EX_DATA_FUNCS_new_null() SKM_sk_new_null(CRYPTO_EX_DATA_FUNCS) 580 # define sk_CRYPTO_EX_DATA_FUNCS_free(st) SKM_sk_free(CRYPTO_EX_DATA_FUNCS, (st)) 581 # define sk_CRYPTO_EX_DATA_FUNCS_num(st) SKM_sk_num(CRYPTO_EX_DATA_FUNCS, (st)) 582 # define sk_CRYPTO_EX_DATA_FUNCS_value(st, i) SKM_sk_value(CRYPTO_EX_DATA_FUNCS, (st), (i)) 583 # define sk_CRYPTO_EX_DATA_FUNCS_set(st, i, val) SKM_sk_set(CRYPTO_EX_DATA_FUNCS, (st), (i), (val)) 584 # define sk_CRYPTO_EX_DATA_FUNCS_zero(st) SKM_sk_zero(CRYPTO_EX_DATA_FUNCS, (st)) 585 # define sk_CRYPTO_EX_DATA_FUNCS_push(st, val) SKM_sk_push(CRYPTO_EX_DATA_FUNCS, (st), (val)) 586 # define sk_CRYPTO_EX_DATA_FUNCS_unshift(st, val) SKM_sk_unshift(CRYPTO_EX_DATA_FUNCS, (st), (val)) 587 # define sk_CRYPTO_EX_DATA_FUNCS_find(st, val) SKM_sk_find(CRYPTO_EX_DATA_FUNCS, (st), (val)) 588 # define sk_CRYPTO_EX_DATA_FUNCS_find_ex(st, val) SKM_sk_find_ex(CRYPTO_EX_DATA_FUNCS, (st), (val)) 589 # define sk_CRYPTO_EX_DATA_FUNCS_delete(st, i) SKM_sk_delete(CRYPTO_EX_DATA_FUNCS, (st), (i)) 590 # define sk_CRYPTO_EX_DATA_FUNCS_delete_ptr(st, ptr) SKM_sk_delete_ptr(CRYPTO_EX_DATA_FUNCS, (st), (ptr)) 591 # define sk_CRYPTO_EX_DATA_FUNCS_insert(st, val, i) SKM_sk_insert(CRYPTO_EX_DATA_FUNCS, (st), (val), (i)) 592 # define sk_CRYPTO_EX_DATA_FUNCS_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CRYPTO_EX_DATA_FUNCS, (st), (cmp)) 593 # define sk_CRYPTO_EX_DATA_FUNCS_dup(st) SKM_sk_dup(CRYPTO_EX_DATA_FUNCS, st) 594 # define sk_CRYPTO_EX_DATA_FUNCS_pop_free(st, free_func) SKM_sk_pop_free(CRYPTO_EX_DATA_FUNCS, (st), (free_func)) 595 # define sk_CRYPTO_EX_DATA_FUNCS_shift(st) SKM_sk_shift(CRYPTO_EX_DATA_FUNCS, (st)) 596 # define sk_CRYPTO_EX_DATA_FUNCS_pop(st) SKM_sk_pop(CRYPTO_EX_DATA_FUNCS, (st)) 597 # define sk_CRYPTO_EX_DATA_FUNCS_sort(st) SKM_sk_sort(CRYPTO_EX_DATA_FUNCS, (st)) 598 # define sk_CRYPTO_EX_DATA_FUNCS_is_sorted(st) SKM_sk_is_sorted(CRYPTO_EX_DATA_FUNCS, (st)) 599 600 # define sk_CRYPTO_dynlock_new(st) SKM_sk_new(CRYPTO_dynlock, (st)) 601 # define sk_CRYPTO_dynlock_new_null() SKM_sk_new_null(CRYPTO_dynlock) 602 # define sk_CRYPTO_dynlock_free(st) SKM_sk_free(CRYPTO_dynlock, (st)) 603 # define sk_CRYPTO_dynlock_num(st) SKM_sk_num(CRYPTO_dynlock, (st)) 604 # define sk_CRYPTO_dynlock_value(st, i) SKM_sk_value(CRYPTO_dynlock, (st), (i)) 605 # define sk_CRYPTO_dynlock_set(st, i, val) SKM_sk_set(CRYPTO_dynlock, (st), (i), (val)) 606 # define sk_CRYPTO_dynlock_zero(st) SKM_sk_zero(CRYPTO_dynlock, (st)) 607 # define sk_CRYPTO_dynlock_push(st, val) SKM_sk_push(CRYPTO_dynlock, (st), (val)) 608 # define sk_CRYPTO_dynlock_unshift(st, val) SKM_sk_unshift(CRYPTO_dynlock, (st), (val)) 609 # define sk_CRYPTO_dynlock_find(st, val) SKM_sk_find(CRYPTO_dynlock, (st), (val)) 610 # define sk_CRYPTO_dynlock_find_ex(st, val) SKM_sk_find_ex(CRYPTO_dynlock, (st), (val)) 611 # define sk_CRYPTO_dynlock_delete(st, i) SKM_sk_delete(CRYPTO_dynlock, (st), (i)) 612 # define sk_CRYPTO_dynlock_delete_ptr(st, ptr) SKM_sk_delete_ptr(CRYPTO_dynlock, (st), (ptr)) 613 # define sk_CRYPTO_dynlock_insert(st, val, i) SKM_sk_insert(CRYPTO_dynlock, (st), (val), (i)) 614 # define sk_CRYPTO_dynlock_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CRYPTO_dynlock, (st), (cmp)) 615 # define sk_CRYPTO_dynlock_dup(st) SKM_sk_dup(CRYPTO_dynlock, st) 616 # define sk_CRYPTO_dynlock_pop_free(st, free_func) SKM_sk_pop_free(CRYPTO_dynlock, (st), (free_func)) 617 # define sk_CRYPTO_dynlock_shift(st) SKM_sk_shift(CRYPTO_dynlock, (st)) 618 # define sk_CRYPTO_dynlock_pop(st) SKM_sk_pop(CRYPTO_dynlock, (st)) 619 # define sk_CRYPTO_dynlock_sort(st) SKM_sk_sort(CRYPTO_dynlock, (st)) 620 # define sk_CRYPTO_dynlock_is_sorted(st) SKM_sk_is_sorted(CRYPTO_dynlock, (st)) 621 622 # define sk_DIST_POINT_new(st) SKM_sk_new(DIST_POINT, (st)) 623 # define sk_DIST_POINT_new_null() SKM_sk_new_null(DIST_POINT) 624 # define sk_DIST_POINT_free(st) SKM_sk_free(DIST_POINT, (st)) 625 # define sk_DIST_POINT_num(st) SKM_sk_num(DIST_POINT, (st)) 626 # define sk_DIST_POINT_value(st, i) SKM_sk_value(DIST_POINT, (st), (i)) 627 # define sk_DIST_POINT_set(st, i, val) SKM_sk_set(DIST_POINT, (st), (i), (val)) 628 # define sk_DIST_POINT_zero(st) SKM_sk_zero(DIST_POINT, (st)) 629 # define sk_DIST_POINT_push(st, val) SKM_sk_push(DIST_POINT, (st), (val)) 630 # define sk_DIST_POINT_unshift(st, val) SKM_sk_unshift(DIST_POINT, (st), (val)) 631 # define sk_DIST_POINT_find(st, val) SKM_sk_find(DIST_POINT, (st), (val)) 632 # define sk_DIST_POINT_find_ex(st, val) SKM_sk_find_ex(DIST_POINT, (st), (val)) 633 # define sk_DIST_POINT_delete(st, i) SKM_sk_delete(DIST_POINT, (st), (i)) 634 # define sk_DIST_POINT_delete_ptr(st, ptr) SKM_sk_delete_ptr(DIST_POINT, (st), (ptr)) 635 # define sk_DIST_POINT_insert(st, val, i) SKM_sk_insert(DIST_POINT, (st), (val), (i)) 636 # define sk_DIST_POINT_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(DIST_POINT, (st), (cmp)) 637 # define sk_DIST_POINT_dup(st) SKM_sk_dup(DIST_POINT, st) 638 # define sk_DIST_POINT_pop_free(st, free_func) SKM_sk_pop_free(DIST_POINT, (st), (free_func)) 639 # define sk_DIST_POINT_shift(st) SKM_sk_shift(DIST_POINT, (st)) 640 # define sk_DIST_POINT_pop(st) SKM_sk_pop(DIST_POINT, (st)) 641 # define sk_DIST_POINT_sort(st) SKM_sk_sort(DIST_POINT, (st)) 642 # define sk_DIST_POINT_is_sorted(st) SKM_sk_is_sorted(DIST_POINT, (st)) 643 644 # define sk_ENGINE_new(st) SKM_sk_new(ENGINE, (st)) 645 # define sk_ENGINE_new_null() SKM_sk_new_null(ENGINE) 646 # define sk_ENGINE_free(st) SKM_sk_free(ENGINE, (st)) 647 # define sk_ENGINE_num(st) SKM_sk_num(ENGINE, (st)) 648 # define sk_ENGINE_value(st, i) SKM_sk_value(ENGINE, (st), (i)) 649 # define sk_ENGINE_set(st, i, val) SKM_sk_set(ENGINE, (st), (i), (val)) 650 # define sk_ENGINE_zero(st) SKM_sk_zero(ENGINE, (st)) 651 # define sk_ENGINE_push(st, val) SKM_sk_push(ENGINE, (st), (val)) 652 # define sk_ENGINE_unshift(st, val) SKM_sk_unshift(ENGINE, (st), (val)) 653 # define sk_ENGINE_find(st, val) SKM_sk_find(ENGINE, (st), (val)) 654 # define sk_ENGINE_find_ex(st, val) SKM_sk_find_ex(ENGINE, (st), (val)) 655 # define sk_ENGINE_delete(st, i) SKM_sk_delete(ENGINE, (st), (i)) 656 # define sk_ENGINE_delete_ptr(st, ptr) SKM_sk_delete_ptr(ENGINE, (st), (ptr)) 657 # define sk_ENGINE_insert(st, val, i) SKM_sk_insert(ENGINE, (st), (val), (i)) 658 # define sk_ENGINE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ENGINE, (st), (cmp)) 659 # define sk_ENGINE_dup(st) SKM_sk_dup(ENGINE, st) 660 # define sk_ENGINE_pop_free(st, free_func) SKM_sk_pop_free(ENGINE, (st), (free_func)) 661 # define sk_ENGINE_shift(st) SKM_sk_shift(ENGINE, (st)) 662 # define sk_ENGINE_pop(st) SKM_sk_pop(ENGINE, (st)) 663 # define sk_ENGINE_sort(st) SKM_sk_sort(ENGINE, (st)) 664 # define sk_ENGINE_is_sorted(st) SKM_sk_is_sorted(ENGINE, (st)) 665 666 # define sk_ENGINE_CLEANUP_ITEM_new(st) SKM_sk_new(ENGINE_CLEANUP_ITEM, (st)) 667 # define sk_ENGINE_CLEANUP_ITEM_new_null() SKM_sk_new_null(ENGINE_CLEANUP_ITEM) 668 # define sk_ENGINE_CLEANUP_ITEM_free(st) SKM_sk_free(ENGINE_CLEANUP_ITEM, (st)) 669 # define sk_ENGINE_CLEANUP_ITEM_num(st) SKM_sk_num(ENGINE_CLEANUP_ITEM, (st)) 670 # define sk_ENGINE_CLEANUP_ITEM_value(st, i) SKM_sk_value(ENGINE_CLEANUP_ITEM, (st), (i)) 671 # define sk_ENGINE_CLEANUP_ITEM_set(st, i, val) SKM_sk_set(ENGINE_CLEANUP_ITEM, (st), (i), (val)) 672 # define sk_ENGINE_CLEANUP_ITEM_zero(st) SKM_sk_zero(ENGINE_CLEANUP_ITEM, (st)) 673 # define sk_ENGINE_CLEANUP_ITEM_push(st, val) SKM_sk_push(ENGINE_CLEANUP_ITEM, (st), (val)) 674 # define sk_ENGINE_CLEANUP_ITEM_unshift(st, val) SKM_sk_unshift(ENGINE_CLEANUP_ITEM, (st), (val)) 675 # define sk_ENGINE_CLEANUP_ITEM_find(st, val) SKM_sk_find(ENGINE_CLEANUP_ITEM, (st), (val)) 676 # define sk_ENGINE_CLEANUP_ITEM_find_ex(st, val) SKM_sk_find_ex(ENGINE_CLEANUP_ITEM, (st), (val)) 677 # define sk_ENGINE_CLEANUP_ITEM_delete(st, i) SKM_sk_delete(ENGINE_CLEANUP_ITEM, (st), (i)) 678 # define sk_ENGINE_CLEANUP_ITEM_delete_ptr(st, ptr) SKM_sk_delete_ptr(ENGINE_CLEANUP_ITEM, (st), (ptr)) 679 # define sk_ENGINE_CLEANUP_ITEM_insert(st, val, i) SKM_sk_insert(ENGINE_CLEANUP_ITEM, (st), (val), (i)) 680 # define sk_ENGINE_CLEANUP_ITEM_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ENGINE_CLEANUP_ITEM, (st), (cmp)) 681 # define sk_ENGINE_CLEANUP_ITEM_dup(st) SKM_sk_dup(ENGINE_CLEANUP_ITEM, st) 682 # define sk_ENGINE_CLEANUP_ITEM_pop_free(st, free_func) SKM_sk_pop_free(ENGINE_CLEANUP_ITEM, (st), (free_func)) 683 # define sk_ENGINE_CLEANUP_ITEM_shift(st) SKM_sk_shift(ENGINE_CLEANUP_ITEM, (st)) 684 # define sk_ENGINE_CLEANUP_ITEM_pop(st) SKM_sk_pop(ENGINE_CLEANUP_ITEM, (st)) 685 # define sk_ENGINE_CLEANUP_ITEM_sort(st) SKM_sk_sort(ENGINE_CLEANUP_ITEM, (st)) 686 # define sk_ENGINE_CLEANUP_ITEM_is_sorted(st) SKM_sk_is_sorted(ENGINE_CLEANUP_ITEM, (st)) 687 688 # define sk_GENERAL_NAME_new(st) SKM_sk_new(GENERAL_NAME, (st)) 689 # define sk_GENERAL_NAME_new_null() SKM_sk_new_null(GENERAL_NAME) 690 # define sk_GENERAL_NAME_free(st) SKM_sk_free(GENERAL_NAME, (st)) 691 # define sk_GENERAL_NAME_num(st) SKM_sk_num(GENERAL_NAME, (st)) 692 # define sk_GENERAL_NAME_value(st, i) SKM_sk_value(GENERAL_NAME, (st), (i)) 693 # define sk_GENERAL_NAME_set(st, i, val) SKM_sk_set(GENERAL_NAME, (st), (i), (val)) 694 # define sk_GENERAL_NAME_zero(st) SKM_sk_zero(GENERAL_NAME, (st)) 695 # define sk_GENERAL_NAME_push(st, val) SKM_sk_push(GENERAL_NAME, (st), (val)) 696 # define sk_GENERAL_NAME_unshift(st, val) SKM_sk_unshift(GENERAL_NAME, (st), (val)) 697 # define sk_GENERAL_NAME_find(st, val) SKM_sk_find(GENERAL_NAME, (st), (val)) 698 # define sk_GENERAL_NAME_find_ex(st, val) SKM_sk_find_ex(GENERAL_NAME, (st), (val)) 699 # define sk_GENERAL_NAME_delete(st, i) SKM_sk_delete(GENERAL_NAME, (st), (i)) 700 # define sk_GENERAL_NAME_delete_ptr(st, ptr) SKM_sk_delete_ptr(GENERAL_NAME, (st), (ptr)) 701 # define sk_GENERAL_NAME_insert(st, val, i) SKM_sk_insert(GENERAL_NAME, (st), (val), (i)) 702 # define sk_GENERAL_NAME_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(GENERAL_NAME, (st), (cmp)) 703 # define sk_GENERAL_NAME_dup(st) SKM_sk_dup(GENERAL_NAME, st) 704 # define sk_GENERAL_NAME_pop_free(st, free_func) SKM_sk_pop_free(GENERAL_NAME, (st), (free_func)) 705 # define sk_GENERAL_NAME_shift(st) SKM_sk_shift(GENERAL_NAME, (st)) 706 # define sk_GENERAL_NAME_pop(st) SKM_sk_pop(GENERAL_NAME, (st)) 707 # define sk_GENERAL_NAME_sort(st) SKM_sk_sort(GENERAL_NAME, (st)) 708 # define sk_GENERAL_NAME_is_sorted(st) SKM_sk_is_sorted(GENERAL_NAME, (st)) 709 710 # define sk_GENERAL_NAMES_new(st) SKM_sk_new(GENERAL_NAMES, (st)) 711 # define sk_GENERAL_NAMES_new_null() SKM_sk_new_null(GENERAL_NAMES) 712 # define sk_GENERAL_NAMES_free(st) SKM_sk_free(GENERAL_NAMES, (st)) 713 # define sk_GENERAL_NAMES_num(st) SKM_sk_num(GENERAL_NAMES, (st)) 714 # define sk_GENERAL_NAMES_value(st, i) SKM_sk_value(GENERAL_NAMES, (st), (i)) 715 # define sk_GENERAL_NAMES_set(st, i, val) SKM_sk_set(GENERAL_NAMES, (st), (i), (val)) 716 # define sk_GENERAL_NAMES_zero(st) SKM_sk_zero(GENERAL_NAMES, (st)) 717 # define sk_GENERAL_NAMES_push(st, val) SKM_sk_push(GENERAL_NAMES, (st), (val)) 718 # define sk_GENERAL_NAMES_unshift(st, val) SKM_sk_unshift(GENERAL_NAMES, (st), (val)) 719 # define sk_GENERAL_NAMES_find(st, val) SKM_sk_find(GENERAL_NAMES, (st), (val)) 720 # define sk_GENERAL_NAMES_find_ex(st, val) SKM_sk_find_ex(GENERAL_NAMES, (st), (val)) 721 # define sk_GENERAL_NAMES_delete(st, i) SKM_sk_delete(GENERAL_NAMES, (st), (i)) 722 # define sk_GENERAL_NAMES_delete_ptr(st, ptr) SKM_sk_delete_ptr(GENERAL_NAMES, (st), (ptr)) 723 # define sk_GENERAL_NAMES_insert(st, val, i) SKM_sk_insert(GENERAL_NAMES, (st), (val), (i)) 724 # define sk_GENERAL_NAMES_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(GENERAL_NAMES, (st), (cmp)) 725 # define sk_GENERAL_NAMES_dup(st) SKM_sk_dup(GENERAL_NAMES, st) 726 # define sk_GENERAL_NAMES_pop_free(st, free_func) SKM_sk_pop_free(GENERAL_NAMES, (st), (free_func)) 727 # define sk_GENERAL_NAMES_shift(st) SKM_sk_shift(GENERAL_NAMES, (st)) 728 # define sk_GENERAL_NAMES_pop(st) SKM_sk_pop(GENERAL_NAMES, (st)) 729 # define sk_GENERAL_NAMES_sort(st) SKM_sk_sort(GENERAL_NAMES, (st)) 730 # define sk_GENERAL_NAMES_is_sorted(st) SKM_sk_is_sorted(GENERAL_NAMES, (st)) 731 732 # define sk_GENERAL_SUBTREE_new(st) SKM_sk_new(GENERAL_SUBTREE, (st)) 733 # define sk_GENERAL_SUBTREE_new_null() SKM_sk_new_null(GENERAL_SUBTREE) 734 # define sk_GENERAL_SUBTREE_free(st) SKM_sk_free(GENERAL_SUBTREE, (st)) 735 # define sk_GENERAL_SUBTREE_num(st) SKM_sk_num(GENERAL_SUBTREE, (st)) 736 # define sk_GENERAL_SUBTREE_value(st, i) SKM_sk_value(GENERAL_SUBTREE, (st), (i)) 737 # define sk_GENERAL_SUBTREE_set(st, i, val) SKM_sk_set(GENERAL_SUBTREE, (st), (i), (val)) 738 # define sk_GENERAL_SUBTREE_zero(st) SKM_sk_zero(GENERAL_SUBTREE, (st)) 739 # define sk_GENERAL_SUBTREE_push(st, val) SKM_sk_push(GENERAL_SUBTREE, (st), (val)) 740 # define sk_GENERAL_SUBTREE_unshift(st, val) SKM_sk_unshift(GENERAL_SUBTREE, (st), (val)) 741 # define sk_GENERAL_SUBTREE_find(st, val) SKM_sk_find(GENERAL_SUBTREE, (st), (val)) 742 # define sk_GENERAL_SUBTREE_find_ex(st, val) SKM_sk_find_ex(GENERAL_SUBTREE, (st), (val)) 743 # define sk_GENERAL_SUBTREE_delete(st, i) SKM_sk_delete(GENERAL_SUBTREE, (st), (i)) 744 # define sk_GENERAL_SUBTREE_delete_ptr(st, ptr) SKM_sk_delete_ptr(GENERAL_SUBTREE, (st), (ptr)) 745 # define sk_GENERAL_SUBTREE_insert(st, val, i) SKM_sk_insert(GENERAL_SUBTREE, (st), (val), (i)) 746 # define sk_GENERAL_SUBTREE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(GENERAL_SUBTREE, (st), (cmp)) 747 # define sk_GENERAL_SUBTREE_dup(st) SKM_sk_dup(GENERAL_SUBTREE, st) 748 # define sk_GENERAL_SUBTREE_pop_free(st, free_func) SKM_sk_pop_free(GENERAL_SUBTREE, (st), (free_func)) 749 # define sk_GENERAL_SUBTREE_shift(st) SKM_sk_shift(GENERAL_SUBTREE, (st)) 750 # define sk_GENERAL_SUBTREE_pop(st) SKM_sk_pop(GENERAL_SUBTREE, (st)) 751 # define sk_GENERAL_SUBTREE_sort(st) SKM_sk_sort(GENERAL_SUBTREE, (st)) 752 # define sk_GENERAL_SUBTREE_is_sorted(st) SKM_sk_is_sorted(GENERAL_SUBTREE, (st)) 753 754 # define sk_IPAddressFamily_new(st) SKM_sk_new(IPAddressFamily, (st)) 755 # define sk_IPAddressFamily_new_null() SKM_sk_new_null(IPAddressFamily) 756 # define sk_IPAddressFamily_free(st) SKM_sk_free(IPAddressFamily, (st)) 757 # define sk_IPAddressFamily_num(st) SKM_sk_num(IPAddressFamily, (st)) 758 # define sk_IPAddressFamily_value(st, i) SKM_sk_value(IPAddressFamily, (st), (i)) 759 # define sk_IPAddressFamily_set(st, i, val) SKM_sk_set(IPAddressFamily, (st), (i), (val)) 760 # define sk_IPAddressFamily_zero(st) SKM_sk_zero(IPAddressFamily, (st)) 761 # define sk_IPAddressFamily_push(st, val) SKM_sk_push(IPAddressFamily, (st), (val)) 762 # define sk_IPAddressFamily_unshift(st, val) SKM_sk_unshift(IPAddressFamily, (st), (val)) 763 # define sk_IPAddressFamily_find(st, val) SKM_sk_find(IPAddressFamily, (st), (val)) 764 # define sk_IPAddressFamily_find_ex(st, val) SKM_sk_find_ex(IPAddressFamily, (st), (val)) 765 # define sk_IPAddressFamily_delete(st, i) SKM_sk_delete(IPAddressFamily, (st), (i)) 766 # define sk_IPAddressFamily_delete_ptr(st, ptr) SKM_sk_delete_ptr(IPAddressFamily, (st), (ptr)) 767 # define sk_IPAddressFamily_insert(st, val, i) SKM_sk_insert(IPAddressFamily, (st), (val), (i)) 768 # define sk_IPAddressFamily_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(IPAddressFamily, (st), (cmp)) 769 # define sk_IPAddressFamily_dup(st) SKM_sk_dup(IPAddressFamily, st) 770 # define sk_IPAddressFamily_pop_free(st, free_func) SKM_sk_pop_free(IPAddressFamily, (st), (free_func)) 771 # define sk_IPAddressFamily_shift(st) SKM_sk_shift(IPAddressFamily, (st)) 772 # define sk_IPAddressFamily_pop(st) SKM_sk_pop(IPAddressFamily, (st)) 773 # define sk_IPAddressFamily_sort(st) SKM_sk_sort(IPAddressFamily, (st)) 774 # define sk_IPAddressFamily_is_sorted(st) SKM_sk_is_sorted(IPAddressFamily, (st)) 775 776 # define sk_IPAddressOrRange_new(st) SKM_sk_new(IPAddressOrRange, (st)) 777 # define sk_IPAddressOrRange_new_null() SKM_sk_new_null(IPAddressOrRange) 778 # define sk_IPAddressOrRange_free(st) SKM_sk_free(IPAddressOrRange, (st)) 779 # define sk_IPAddressOrRange_num(st) SKM_sk_num(IPAddressOrRange, (st)) 780 # define sk_IPAddressOrRange_value(st, i) SKM_sk_value(IPAddressOrRange, (st), (i)) 781 # define sk_IPAddressOrRange_set(st, i, val) SKM_sk_set(IPAddressOrRange, (st), (i), (val)) 782 # define sk_IPAddressOrRange_zero(st) SKM_sk_zero(IPAddressOrRange, (st)) 783 # define sk_IPAddressOrRange_push(st, val) SKM_sk_push(IPAddressOrRange, (st), (val)) 784 # define sk_IPAddressOrRange_unshift(st, val) SKM_sk_unshift(IPAddressOrRange, (st), (val)) 785 # define sk_IPAddressOrRange_find(st, val) SKM_sk_find(IPAddressOrRange, (st), (val)) 786 # define sk_IPAddressOrRange_find_ex(st, val) SKM_sk_find_ex(IPAddressOrRange, (st), (val)) 787 # define sk_IPAddressOrRange_delete(st, i) SKM_sk_delete(IPAddressOrRange, (st), (i)) 788 # define sk_IPAddressOrRange_delete_ptr(st, ptr) SKM_sk_delete_ptr(IPAddressOrRange, (st), (ptr)) 789 # define sk_IPAddressOrRange_insert(st, val, i) SKM_sk_insert(IPAddressOrRange, (st), (val), (i)) 790 # define sk_IPAddressOrRange_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(IPAddressOrRange, (st), (cmp)) 791 # define sk_IPAddressOrRange_dup(st) SKM_sk_dup(IPAddressOrRange, st) 792 # define sk_IPAddressOrRange_pop_free(st, free_func) SKM_sk_pop_free(IPAddressOrRange, (st), (free_func)) 793 # define sk_IPAddressOrRange_shift(st) SKM_sk_shift(IPAddressOrRange, (st)) 794 # define sk_IPAddressOrRange_pop(st) SKM_sk_pop(IPAddressOrRange, (st)) 795 # define sk_IPAddressOrRange_sort(st) SKM_sk_sort(IPAddressOrRange, (st)) 796 # define sk_IPAddressOrRange_is_sorted(st) SKM_sk_is_sorted(IPAddressOrRange, (st)) 797 798 # define sk_KRB5_APREQBODY_new(st) SKM_sk_new(KRB5_APREQBODY, (st)) 799 # define sk_KRB5_APREQBODY_new_null() SKM_sk_new_null(KRB5_APREQBODY) 800 # define sk_KRB5_APREQBODY_free(st) SKM_sk_free(KRB5_APREQBODY, (st)) 801 # define sk_KRB5_APREQBODY_num(st) SKM_sk_num(KRB5_APREQBODY, (st)) 802 # define sk_KRB5_APREQBODY_value(st, i) SKM_sk_value(KRB5_APREQBODY, (st), (i)) 803 # define sk_KRB5_APREQBODY_set(st, i, val) SKM_sk_set(KRB5_APREQBODY, (st), (i), (val)) 804 # define sk_KRB5_APREQBODY_zero(st) SKM_sk_zero(KRB5_APREQBODY, (st)) 805 # define sk_KRB5_APREQBODY_push(st, val) SKM_sk_push(KRB5_APREQBODY, (st), (val)) 806 # define sk_KRB5_APREQBODY_unshift(st, val) SKM_sk_unshift(KRB5_APREQBODY, (st), (val)) 807 # define sk_KRB5_APREQBODY_find(st, val) SKM_sk_find(KRB5_APREQBODY, (st), (val)) 808 # define sk_KRB5_APREQBODY_find_ex(st, val) SKM_sk_find_ex(KRB5_APREQBODY, (st), (val)) 809 # define sk_KRB5_APREQBODY_delete(st, i) SKM_sk_delete(KRB5_APREQBODY, (st), (i)) 810 # define sk_KRB5_APREQBODY_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_APREQBODY, (st), (ptr)) 811 # define sk_KRB5_APREQBODY_insert(st, val, i) SKM_sk_insert(KRB5_APREQBODY, (st), (val), (i)) 812 # define sk_KRB5_APREQBODY_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_APREQBODY, (st), (cmp)) 813 # define sk_KRB5_APREQBODY_dup(st) SKM_sk_dup(KRB5_APREQBODY, st) 814 # define sk_KRB5_APREQBODY_pop_free(st, free_func) SKM_sk_pop_free(KRB5_APREQBODY, (st), (free_func)) 815 # define sk_KRB5_APREQBODY_shift(st) SKM_sk_shift(KRB5_APREQBODY, (st)) 816 # define sk_KRB5_APREQBODY_pop(st) SKM_sk_pop(KRB5_APREQBODY, (st)) 817 # define sk_KRB5_APREQBODY_sort(st) SKM_sk_sort(KRB5_APREQBODY, (st)) 818 # define sk_KRB5_APREQBODY_is_sorted(st) SKM_sk_is_sorted(KRB5_APREQBODY, (st)) 819 820 # define sk_KRB5_AUTHDATA_new(st) SKM_sk_new(KRB5_AUTHDATA, (st)) 821 # define sk_KRB5_AUTHDATA_new_null() SKM_sk_new_null(KRB5_AUTHDATA) 822 # define sk_KRB5_AUTHDATA_free(st) SKM_sk_free(KRB5_AUTHDATA, (st)) 823 # define sk_KRB5_AUTHDATA_num(st) SKM_sk_num(KRB5_AUTHDATA, (st)) 824 # define sk_KRB5_AUTHDATA_value(st, i) SKM_sk_value(KRB5_AUTHDATA, (st), (i)) 825 # define sk_KRB5_AUTHDATA_set(st, i, val) SKM_sk_set(KRB5_AUTHDATA, (st), (i), (val)) 826 # define sk_KRB5_AUTHDATA_zero(st) SKM_sk_zero(KRB5_AUTHDATA, (st)) 827 # define sk_KRB5_AUTHDATA_push(st, val) SKM_sk_push(KRB5_AUTHDATA, (st), (val)) 828 # define sk_KRB5_AUTHDATA_unshift(st, val) SKM_sk_unshift(KRB5_AUTHDATA, (st), (val)) 829 # define sk_KRB5_AUTHDATA_find(st, val) SKM_sk_find(KRB5_AUTHDATA, (st), (val)) 830 # define sk_KRB5_AUTHDATA_find_ex(st, val) SKM_sk_find_ex(KRB5_AUTHDATA, (st), (val)) 831 # define sk_KRB5_AUTHDATA_delete(st, i) SKM_sk_delete(KRB5_AUTHDATA, (st), (i)) 832 # define sk_KRB5_AUTHDATA_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_AUTHDATA, (st), (ptr)) 833 # define sk_KRB5_AUTHDATA_insert(st, val, i) SKM_sk_insert(KRB5_AUTHDATA, (st), (val), (i)) 834 # define sk_KRB5_AUTHDATA_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_AUTHDATA, (st), (cmp)) 835 # define sk_KRB5_AUTHDATA_dup(st) SKM_sk_dup(KRB5_AUTHDATA, st) 836 # define sk_KRB5_AUTHDATA_pop_free(st, free_func) SKM_sk_pop_free(KRB5_AUTHDATA, (st), (free_func)) 837 # define sk_KRB5_AUTHDATA_shift(st) SKM_sk_shift(KRB5_AUTHDATA, (st)) 838 # define sk_KRB5_AUTHDATA_pop(st) SKM_sk_pop(KRB5_AUTHDATA, (st)) 839 # define sk_KRB5_AUTHDATA_sort(st) SKM_sk_sort(KRB5_AUTHDATA, (st)) 840 # define sk_KRB5_AUTHDATA_is_sorted(st) SKM_sk_is_sorted(KRB5_AUTHDATA, (st)) 841 842 # define sk_KRB5_AUTHENTBODY_new(st) SKM_sk_new(KRB5_AUTHENTBODY, (st)) 843 # define sk_KRB5_AUTHENTBODY_new_null() SKM_sk_new_null(KRB5_AUTHENTBODY) 844 # define sk_KRB5_AUTHENTBODY_free(st) SKM_sk_free(KRB5_AUTHENTBODY, (st)) 845 # define sk_KRB5_AUTHENTBODY_num(st) SKM_sk_num(KRB5_AUTHENTBODY, (st)) 846 # define sk_KRB5_AUTHENTBODY_value(st, i) SKM_sk_value(KRB5_AUTHENTBODY, (st), (i)) 847 # define sk_KRB5_AUTHENTBODY_set(st, i, val) SKM_sk_set(KRB5_AUTHENTBODY, (st), (i), (val)) 848 # define sk_KRB5_AUTHENTBODY_zero(st) SKM_sk_zero(KRB5_AUTHENTBODY, (st)) 849 # define sk_KRB5_AUTHENTBODY_push(st, val) SKM_sk_push(KRB5_AUTHENTBODY, (st), (val)) 850 # define sk_KRB5_AUTHENTBODY_unshift(st, val) SKM_sk_unshift(KRB5_AUTHENTBODY, (st), (val)) 851 # define sk_KRB5_AUTHENTBODY_find(st, val) SKM_sk_find(KRB5_AUTHENTBODY, (st), (val)) 852 # define sk_KRB5_AUTHENTBODY_find_ex(st, val) SKM_sk_find_ex(KRB5_AUTHENTBODY, (st), (val)) 853 # define sk_KRB5_AUTHENTBODY_delete(st, i) SKM_sk_delete(KRB5_AUTHENTBODY, (st), (i)) 854 # define sk_KRB5_AUTHENTBODY_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_AUTHENTBODY, (st), (ptr)) 855 # define sk_KRB5_AUTHENTBODY_insert(st, val, i) SKM_sk_insert(KRB5_AUTHENTBODY, (st), (val), (i)) 856 # define sk_KRB5_AUTHENTBODY_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_AUTHENTBODY, (st), (cmp)) 857 # define sk_KRB5_AUTHENTBODY_dup(st) SKM_sk_dup(KRB5_AUTHENTBODY, st) 858 # define sk_KRB5_AUTHENTBODY_pop_free(st, free_func) SKM_sk_pop_free(KRB5_AUTHENTBODY, (st), (free_func)) 859 # define sk_KRB5_AUTHENTBODY_shift(st) SKM_sk_shift(KRB5_AUTHENTBODY, (st)) 860 # define sk_KRB5_AUTHENTBODY_pop(st) SKM_sk_pop(KRB5_AUTHENTBODY, (st)) 861 # define sk_KRB5_AUTHENTBODY_sort(st) SKM_sk_sort(KRB5_AUTHENTBODY, (st)) 862 # define sk_KRB5_AUTHENTBODY_is_sorted(st) SKM_sk_is_sorted(KRB5_AUTHENTBODY, (st)) 863 864 # define sk_KRB5_CHECKSUM_new(st) SKM_sk_new(KRB5_CHECKSUM, (st)) 865 # define sk_KRB5_CHECKSUM_new_null() SKM_sk_new_null(KRB5_CHECKSUM) 866 # define sk_KRB5_CHECKSUM_free(st) SKM_sk_free(KRB5_CHECKSUM, (st)) 867 # define sk_KRB5_CHECKSUM_num(st) SKM_sk_num(KRB5_CHECKSUM, (st)) 868 # define sk_KRB5_CHECKSUM_value(st, i) SKM_sk_value(KRB5_CHECKSUM, (st), (i)) 869 # define sk_KRB5_CHECKSUM_set(st, i, val) SKM_sk_set(KRB5_CHECKSUM, (st), (i), (val)) 870 # define sk_KRB5_CHECKSUM_zero(st) SKM_sk_zero(KRB5_CHECKSUM, (st)) 871 # define sk_KRB5_CHECKSUM_push(st, val) SKM_sk_push(KRB5_CHECKSUM, (st), (val)) 872 # define sk_KRB5_CHECKSUM_unshift(st, val) SKM_sk_unshift(KRB5_CHECKSUM, (st), (val)) 873 # define sk_KRB5_CHECKSUM_find(st, val) SKM_sk_find(KRB5_CHECKSUM, (st), (val)) 874 # define sk_KRB5_CHECKSUM_find_ex(st, val) SKM_sk_find_ex(KRB5_CHECKSUM, (st), (val)) 875 # define sk_KRB5_CHECKSUM_delete(st, i) SKM_sk_delete(KRB5_CHECKSUM, (st), (i)) 876 # define sk_KRB5_CHECKSUM_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_CHECKSUM, (st), (ptr)) 877 # define sk_KRB5_CHECKSUM_insert(st, val, i) SKM_sk_insert(KRB5_CHECKSUM, (st), (val), (i)) 878 # define sk_KRB5_CHECKSUM_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_CHECKSUM, (st), (cmp)) 879 # define sk_KRB5_CHECKSUM_dup(st) SKM_sk_dup(KRB5_CHECKSUM, st) 880 # define sk_KRB5_CHECKSUM_pop_free(st, free_func) SKM_sk_pop_free(KRB5_CHECKSUM, (st), (free_func)) 881 # define sk_KRB5_CHECKSUM_shift(st) SKM_sk_shift(KRB5_CHECKSUM, (st)) 882 # define sk_KRB5_CHECKSUM_pop(st) SKM_sk_pop(KRB5_CHECKSUM, (st)) 883 # define sk_KRB5_CHECKSUM_sort(st) SKM_sk_sort(KRB5_CHECKSUM, (st)) 884 # define sk_KRB5_CHECKSUM_is_sorted(st) SKM_sk_is_sorted(KRB5_CHECKSUM, (st)) 885 886 # define sk_KRB5_ENCDATA_new(st) SKM_sk_new(KRB5_ENCDATA, (st)) 887 # define sk_KRB5_ENCDATA_new_null() SKM_sk_new_null(KRB5_ENCDATA) 888 # define sk_KRB5_ENCDATA_free(st) SKM_sk_free(KRB5_ENCDATA, (st)) 889 # define sk_KRB5_ENCDATA_num(st) SKM_sk_num(KRB5_ENCDATA, (st)) 890 # define sk_KRB5_ENCDATA_value(st, i) SKM_sk_value(KRB5_ENCDATA, (st), (i)) 891 # define sk_KRB5_ENCDATA_set(st, i, val) SKM_sk_set(KRB5_ENCDATA, (st), (i), (val)) 892 # define sk_KRB5_ENCDATA_zero(st) SKM_sk_zero(KRB5_ENCDATA, (st)) 893 # define sk_KRB5_ENCDATA_push(st, val) SKM_sk_push(KRB5_ENCDATA, (st), (val)) 894 # define sk_KRB5_ENCDATA_unshift(st, val) SKM_sk_unshift(KRB5_ENCDATA, (st), (val)) 895 # define sk_KRB5_ENCDATA_find(st, val) SKM_sk_find(KRB5_ENCDATA, (st), (val)) 896 # define sk_KRB5_ENCDATA_find_ex(st, val) SKM_sk_find_ex(KRB5_ENCDATA, (st), (val)) 897 # define sk_KRB5_ENCDATA_delete(st, i) SKM_sk_delete(KRB5_ENCDATA, (st), (i)) 898 # define sk_KRB5_ENCDATA_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_ENCDATA, (st), (ptr)) 899 # define sk_KRB5_ENCDATA_insert(st, val, i) SKM_sk_insert(KRB5_ENCDATA, (st), (val), (i)) 900 # define sk_KRB5_ENCDATA_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_ENCDATA, (st), (cmp)) 901 # define sk_KRB5_ENCDATA_dup(st) SKM_sk_dup(KRB5_ENCDATA, st) 902 # define sk_KRB5_ENCDATA_pop_free(st, free_func) SKM_sk_pop_free(KRB5_ENCDATA, (st), (free_func)) 903 # define sk_KRB5_ENCDATA_shift(st) SKM_sk_shift(KRB5_ENCDATA, (st)) 904 # define sk_KRB5_ENCDATA_pop(st) SKM_sk_pop(KRB5_ENCDATA, (st)) 905 # define sk_KRB5_ENCDATA_sort(st) SKM_sk_sort(KRB5_ENCDATA, (st)) 906 # define sk_KRB5_ENCDATA_is_sorted(st) SKM_sk_is_sorted(KRB5_ENCDATA, (st)) 907 908 # define sk_KRB5_ENCKEY_new(st) SKM_sk_new(KRB5_ENCKEY, (st)) 909 # define sk_KRB5_ENCKEY_new_null() SKM_sk_new_null(KRB5_ENCKEY) 910 # define sk_KRB5_ENCKEY_free(st) SKM_sk_free(KRB5_ENCKEY, (st)) 911 # define sk_KRB5_ENCKEY_num(st) SKM_sk_num(KRB5_ENCKEY, (st)) 912 # define sk_KRB5_ENCKEY_value(st, i) SKM_sk_value(KRB5_ENCKEY, (st), (i)) 913 # define sk_KRB5_ENCKEY_set(st, i, val) SKM_sk_set(KRB5_ENCKEY, (st), (i), (val)) 914 # define sk_KRB5_ENCKEY_zero(st) SKM_sk_zero(KRB5_ENCKEY, (st)) 915 # define sk_KRB5_ENCKEY_push(st, val) SKM_sk_push(KRB5_ENCKEY, (st), (val)) 916 # define sk_KRB5_ENCKEY_unshift(st, val) SKM_sk_unshift(KRB5_ENCKEY, (st), (val)) 917 # define sk_KRB5_ENCKEY_find(st, val) SKM_sk_find(KRB5_ENCKEY, (st), (val)) 918 # define sk_KRB5_ENCKEY_find_ex(st, val) SKM_sk_find_ex(KRB5_ENCKEY, (st), (val)) 919 # define sk_KRB5_ENCKEY_delete(st, i) SKM_sk_delete(KRB5_ENCKEY, (st), (i)) 920 # define sk_KRB5_ENCKEY_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_ENCKEY, (st), (ptr)) 921 # define sk_KRB5_ENCKEY_insert(st, val, i) SKM_sk_insert(KRB5_ENCKEY, (st), (val), (i)) 922 # define sk_KRB5_ENCKEY_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_ENCKEY, (st), (cmp)) 923 # define sk_KRB5_ENCKEY_dup(st) SKM_sk_dup(KRB5_ENCKEY, st) 924 # define sk_KRB5_ENCKEY_pop_free(st, free_func) SKM_sk_pop_free(KRB5_ENCKEY, (st), (free_func)) 925 # define sk_KRB5_ENCKEY_shift(st) SKM_sk_shift(KRB5_ENCKEY, (st)) 926 # define sk_KRB5_ENCKEY_pop(st) SKM_sk_pop(KRB5_ENCKEY, (st)) 927 # define sk_KRB5_ENCKEY_sort(st) SKM_sk_sort(KRB5_ENCKEY, (st)) 928 # define sk_KRB5_ENCKEY_is_sorted(st) SKM_sk_is_sorted(KRB5_ENCKEY, (st)) 929 930 # define sk_KRB5_PRINCNAME_new(st) SKM_sk_new(KRB5_PRINCNAME, (st)) 931 # define sk_KRB5_PRINCNAME_new_null() SKM_sk_new_null(KRB5_PRINCNAME) 932 # define sk_KRB5_PRINCNAME_free(st) SKM_sk_free(KRB5_PRINCNAME, (st)) 933 # define sk_KRB5_PRINCNAME_num(st) SKM_sk_num(KRB5_PRINCNAME, (st)) 934 # define sk_KRB5_PRINCNAME_value(st, i) SKM_sk_value(KRB5_PRINCNAME, (st), (i)) 935 # define sk_KRB5_PRINCNAME_set(st, i, val) SKM_sk_set(KRB5_PRINCNAME, (st), (i), (val)) 936 # define sk_KRB5_PRINCNAME_zero(st) SKM_sk_zero(KRB5_PRINCNAME, (st)) 937 # define sk_KRB5_PRINCNAME_push(st, val) SKM_sk_push(KRB5_PRINCNAME, (st), (val)) 938 # define sk_KRB5_PRINCNAME_unshift(st, val) SKM_sk_unshift(KRB5_PRINCNAME, (st), (val)) 939 # define sk_KRB5_PRINCNAME_find(st, val) SKM_sk_find(KRB5_PRINCNAME, (st), (val)) 940 # define sk_KRB5_PRINCNAME_find_ex(st, val) SKM_sk_find_ex(KRB5_PRINCNAME, (st), (val)) 941 # define sk_KRB5_PRINCNAME_delete(st, i) SKM_sk_delete(KRB5_PRINCNAME, (st), (i)) 942 # define sk_KRB5_PRINCNAME_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_PRINCNAME, (st), (ptr)) 943 # define sk_KRB5_PRINCNAME_insert(st, val, i) SKM_sk_insert(KRB5_PRINCNAME, (st), (val), (i)) 944 # define sk_KRB5_PRINCNAME_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_PRINCNAME, (st), (cmp)) 945 # define sk_KRB5_PRINCNAME_dup(st) SKM_sk_dup(KRB5_PRINCNAME, st) 946 # define sk_KRB5_PRINCNAME_pop_free(st, free_func) SKM_sk_pop_free(KRB5_PRINCNAME, (st), (free_func)) 947 # define sk_KRB5_PRINCNAME_shift(st) SKM_sk_shift(KRB5_PRINCNAME, (st)) 948 # define sk_KRB5_PRINCNAME_pop(st) SKM_sk_pop(KRB5_PRINCNAME, (st)) 949 # define sk_KRB5_PRINCNAME_sort(st) SKM_sk_sort(KRB5_PRINCNAME, (st)) 950 # define sk_KRB5_PRINCNAME_is_sorted(st) SKM_sk_is_sorted(KRB5_PRINCNAME, (st)) 951 952 # define sk_KRB5_TKTBODY_new(st) SKM_sk_new(KRB5_TKTBODY, (st)) 953 # define sk_KRB5_TKTBODY_new_null() SKM_sk_new_null(KRB5_TKTBODY) 954 # define sk_KRB5_TKTBODY_free(st) SKM_sk_free(KRB5_TKTBODY, (st)) 955 # define sk_KRB5_TKTBODY_num(st) SKM_sk_num(KRB5_TKTBODY, (st)) 956 # define sk_KRB5_TKTBODY_value(st, i) SKM_sk_value(KRB5_TKTBODY, (st), (i)) 957 # define sk_KRB5_TKTBODY_set(st, i, val) SKM_sk_set(KRB5_TKTBODY, (st), (i), (val)) 958 # define sk_KRB5_TKTBODY_zero(st) SKM_sk_zero(KRB5_TKTBODY, (st)) 959 # define sk_KRB5_TKTBODY_push(st, val) SKM_sk_push(KRB5_TKTBODY, (st), (val)) 960 # define sk_KRB5_TKTBODY_unshift(st, val) SKM_sk_unshift(KRB5_TKTBODY, (st), (val)) 961 # define sk_KRB5_TKTBODY_find(st, val) SKM_sk_find(KRB5_TKTBODY, (st), (val)) 962 # define sk_KRB5_TKTBODY_find_ex(st, val) SKM_sk_find_ex(KRB5_TKTBODY, (st), (val)) 963 # define sk_KRB5_TKTBODY_delete(st, i) SKM_sk_delete(KRB5_TKTBODY, (st), (i)) 964 # define sk_KRB5_TKTBODY_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_TKTBODY, (st), (ptr)) 965 # define sk_KRB5_TKTBODY_insert(st, val, i) SKM_sk_insert(KRB5_TKTBODY, (st), (val), (i)) 966 # define sk_KRB5_TKTBODY_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_TKTBODY, (st), (cmp)) 967 # define sk_KRB5_TKTBODY_dup(st) SKM_sk_dup(KRB5_TKTBODY, st) 968 # define sk_KRB5_TKTBODY_pop_free(st, free_func) SKM_sk_pop_free(KRB5_TKTBODY, (st), (free_func)) 969 # define sk_KRB5_TKTBODY_shift(st) SKM_sk_shift(KRB5_TKTBODY, (st)) 970 # define sk_KRB5_TKTBODY_pop(st) SKM_sk_pop(KRB5_TKTBODY, (st)) 971 # define sk_KRB5_TKTBODY_sort(st) SKM_sk_sort(KRB5_TKTBODY, (st)) 972 # define sk_KRB5_TKTBODY_is_sorted(st) SKM_sk_is_sorted(KRB5_TKTBODY, (st)) 973 974 # define sk_MIME_HEADER_new(st) SKM_sk_new(MIME_HEADER, (st)) 975 # define sk_MIME_HEADER_new_null() SKM_sk_new_null(MIME_HEADER) 976 # define sk_MIME_HEADER_free(st) SKM_sk_free(MIME_HEADER, (st)) 977 # define sk_MIME_HEADER_num(st) SKM_sk_num(MIME_HEADER, (st)) 978 # define sk_MIME_HEADER_value(st, i) SKM_sk_value(MIME_HEADER, (st), (i)) 979 # define sk_MIME_HEADER_set(st, i, val) SKM_sk_set(MIME_HEADER, (st), (i), (val)) 980 # define sk_MIME_HEADER_zero(st) SKM_sk_zero(MIME_HEADER, (st)) 981 # define sk_MIME_HEADER_push(st, val) SKM_sk_push(MIME_HEADER, (st), (val)) 982 # define sk_MIME_HEADER_unshift(st, val) SKM_sk_unshift(MIME_HEADER, (st), (val)) 983 # define sk_MIME_HEADER_find(st, val) SKM_sk_find(MIME_HEADER, (st), (val)) 984 # define sk_MIME_HEADER_find_ex(st, val) SKM_sk_find_ex(MIME_HEADER, (st), (val)) 985 # define sk_MIME_HEADER_delete(st, i) SKM_sk_delete(MIME_HEADER, (st), (i)) 986 # define sk_MIME_HEADER_delete_ptr(st, ptr) SKM_sk_delete_ptr(MIME_HEADER, (st), (ptr)) 987 # define sk_MIME_HEADER_insert(st, val, i) SKM_sk_insert(MIME_HEADER, (st), (val), (i)) 988 # define sk_MIME_HEADER_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(MIME_HEADER, (st), (cmp)) 989 # define sk_MIME_HEADER_dup(st) SKM_sk_dup(MIME_HEADER, st) 990 # define sk_MIME_HEADER_pop_free(st, free_func) SKM_sk_pop_free(MIME_HEADER, (st), (free_func)) 991 # define sk_MIME_HEADER_shift(st) SKM_sk_shift(MIME_HEADER, (st)) 992 # define sk_MIME_HEADER_pop(st) SKM_sk_pop(MIME_HEADER, (st)) 993 # define sk_MIME_HEADER_sort(st) SKM_sk_sort(MIME_HEADER, (st)) 994 # define sk_MIME_HEADER_is_sorted(st) SKM_sk_is_sorted(MIME_HEADER, (st)) 995 996 # define sk_MIME_PARAM_new(st) SKM_sk_new(MIME_PARAM, (st)) 997 # define sk_MIME_PARAM_new_null() SKM_sk_new_null(MIME_PARAM) 998 # define sk_MIME_PARAM_free(st) SKM_sk_free(MIME_PARAM, (st)) 999 # define sk_MIME_PARAM_num(st) SKM_sk_num(MIME_PARAM, (st)) 1000 # define sk_MIME_PARAM_value(st, i) SKM_sk_value(MIME_PARAM, (st), (i)) 1001 # define sk_MIME_PARAM_set(st, i, val) SKM_sk_set(MIME_PARAM, (st), (i), (val)) 1002 # define sk_MIME_PARAM_zero(st) SKM_sk_zero(MIME_PARAM, (st)) 1003 # define sk_MIME_PARAM_push(st, val) SKM_sk_push(MIME_PARAM, (st), (val)) 1004 # define sk_MIME_PARAM_unshift(st, val) SKM_sk_unshift(MIME_PARAM, (st), (val)) 1005 # define sk_MIME_PARAM_find(st, val) SKM_sk_find(MIME_PARAM, (st), (val)) 1006 # define sk_MIME_PARAM_find_ex(st, val) SKM_sk_find_ex(MIME_PARAM, (st), (val)) 1007 # define sk_MIME_PARAM_delete(st, i) SKM_sk_delete(MIME_PARAM, (st), (i)) 1008 # define sk_MIME_PARAM_delete_ptr(st, ptr) SKM_sk_delete_ptr(MIME_PARAM, (st), (ptr)) 1009 # define sk_MIME_PARAM_insert(st, val, i) SKM_sk_insert(MIME_PARAM, (st), (val), (i)) 1010 # define sk_MIME_PARAM_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(MIME_PARAM, (st), (cmp)) 1011 # define sk_MIME_PARAM_dup(st) SKM_sk_dup(MIME_PARAM, st) 1012 # define sk_MIME_PARAM_pop_free(st, free_func) SKM_sk_pop_free(MIME_PARAM, (st), (free_func)) 1013 # define sk_MIME_PARAM_shift(st) SKM_sk_shift(MIME_PARAM, (st)) 1014 # define sk_MIME_PARAM_pop(st) SKM_sk_pop(MIME_PARAM, (st)) 1015 # define sk_MIME_PARAM_sort(st) SKM_sk_sort(MIME_PARAM, (st)) 1016 # define sk_MIME_PARAM_is_sorted(st) SKM_sk_is_sorted(MIME_PARAM, (st)) 1017 1018 # define sk_NAME_FUNCS_new(st) SKM_sk_new(NAME_FUNCS, (st)) 1019 # define sk_NAME_FUNCS_new_null() SKM_sk_new_null(NAME_FUNCS) 1020 # define sk_NAME_FUNCS_free(st) SKM_sk_free(NAME_FUNCS, (st)) 1021 # define sk_NAME_FUNCS_num(st) SKM_sk_num(NAME_FUNCS, (st)) 1022 # define sk_NAME_FUNCS_value(st, i) SKM_sk_value(NAME_FUNCS, (st), (i)) 1023 # define sk_NAME_FUNCS_set(st, i, val) SKM_sk_set(NAME_FUNCS, (st), (i), (val)) 1024 # define sk_NAME_FUNCS_zero(st) SKM_sk_zero(NAME_FUNCS, (st)) 1025 # define sk_NAME_FUNCS_push(st, val) SKM_sk_push(NAME_FUNCS, (st), (val)) 1026 # define sk_NAME_FUNCS_unshift(st, val) SKM_sk_unshift(NAME_FUNCS, (st), (val)) 1027 # define sk_NAME_FUNCS_find(st, val) SKM_sk_find(NAME_FUNCS, (st), (val)) 1028 # define sk_NAME_FUNCS_find_ex(st, val) SKM_sk_find_ex(NAME_FUNCS, (st), (val)) 1029 # define sk_NAME_FUNCS_delete(st, i) SKM_sk_delete(NAME_FUNCS, (st), (i)) 1030 # define sk_NAME_FUNCS_delete_ptr(st, ptr) SKM_sk_delete_ptr(NAME_FUNCS, (st), (ptr)) 1031 # define sk_NAME_FUNCS_insert(st, val, i) SKM_sk_insert(NAME_FUNCS, (st), (val), (i)) 1032 # define sk_NAME_FUNCS_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(NAME_FUNCS, (st), (cmp)) 1033 # define sk_NAME_FUNCS_dup(st) SKM_sk_dup(NAME_FUNCS, st) 1034 # define sk_NAME_FUNCS_pop_free(st, free_func) SKM_sk_pop_free(NAME_FUNCS, (st), (free_func)) 1035 # define sk_NAME_FUNCS_shift(st) SKM_sk_shift(NAME_FUNCS, (st)) 1036 # define sk_NAME_FUNCS_pop(st) SKM_sk_pop(NAME_FUNCS, (st)) 1037 # define sk_NAME_FUNCS_sort(st) SKM_sk_sort(NAME_FUNCS, (st)) 1038 # define sk_NAME_FUNCS_is_sorted(st) SKM_sk_is_sorted(NAME_FUNCS, (st)) 1039 1040 # define sk_OCSP_CERTID_new(st) SKM_sk_new(OCSP_CERTID, (st)) 1041 # define sk_OCSP_CERTID_new_null() SKM_sk_new_null(OCSP_CERTID) 1042 # define sk_OCSP_CERTID_free(st) SKM_sk_free(OCSP_CERTID, (st)) 1043 # define sk_OCSP_CERTID_num(st) SKM_sk_num(OCSP_CERTID, (st)) 1044 # define sk_OCSP_CERTID_value(st, i) SKM_sk_value(OCSP_CERTID, (st), (i)) 1045 # define sk_OCSP_CERTID_set(st, i, val) SKM_sk_set(OCSP_CERTID, (st), (i), (val)) 1046 # define sk_OCSP_CERTID_zero(st) SKM_sk_zero(OCSP_CERTID, (st)) 1047 # define sk_OCSP_CERTID_push(st, val) SKM_sk_push(OCSP_CERTID, (st), (val)) 1048 # define sk_OCSP_CERTID_unshift(st, val) SKM_sk_unshift(OCSP_CERTID, (st), (val)) 1049 # define sk_OCSP_CERTID_find(st, val) SKM_sk_find(OCSP_CERTID, (st), (val)) 1050 # define sk_OCSP_CERTID_find_ex(st, val) SKM_sk_find_ex(OCSP_CERTID, (st), (val)) 1051 # define sk_OCSP_CERTID_delete(st, i) SKM_sk_delete(OCSP_CERTID, (st), (i)) 1052 # define sk_OCSP_CERTID_delete_ptr(st, ptr) SKM_sk_delete_ptr(OCSP_CERTID, (st), (ptr)) 1053 # define sk_OCSP_CERTID_insert(st, val, i) SKM_sk_insert(OCSP_CERTID, (st), (val), (i)) 1054 # define sk_OCSP_CERTID_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(OCSP_CERTID, (st), (cmp)) 1055 # define sk_OCSP_CERTID_dup(st) SKM_sk_dup(OCSP_CERTID, st) 1056 # define sk_OCSP_CERTID_pop_free(st, free_func) SKM_sk_pop_free(OCSP_CERTID, (st), (free_func)) 1057 # define sk_OCSP_CERTID_shift(st) SKM_sk_shift(OCSP_CERTID, (st)) 1058 # define sk_OCSP_CERTID_pop(st) SKM_sk_pop(OCSP_CERTID, (st)) 1059 # define sk_OCSP_CERTID_sort(st) SKM_sk_sort(OCSP_CERTID, (st)) 1060 # define sk_OCSP_CERTID_is_sorted(st) SKM_sk_is_sorted(OCSP_CERTID, (st)) 1061 1062 # define sk_OCSP_ONEREQ_new(st) SKM_sk_new(OCSP_ONEREQ, (st)) 1063 # define sk_OCSP_ONEREQ_new_null() SKM_sk_new_null(OCSP_ONEREQ) 1064 # define sk_OCSP_ONEREQ_free(st) SKM_sk_free(OCSP_ONEREQ, (st)) 1065 # define sk_OCSP_ONEREQ_num(st) SKM_sk_num(OCSP_ONEREQ, (st)) 1066 # define sk_OCSP_ONEREQ_value(st, i) SKM_sk_value(OCSP_ONEREQ, (st), (i)) 1067 # define sk_OCSP_ONEREQ_set(st, i, val) SKM_sk_set(OCSP_ONEREQ, (st), (i), (val)) 1068 # define sk_OCSP_ONEREQ_zero(st) SKM_sk_zero(OCSP_ONEREQ, (st)) 1069 # define sk_OCSP_ONEREQ_push(st, val) SKM_sk_push(OCSP_ONEREQ, (st), (val)) 1070 # define sk_OCSP_ONEREQ_unshift(st, val) SKM_sk_unshift(OCSP_ONEREQ, (st), (val)) 1071 # define sk_OCSP_ONEREQ_find(st, val) SKM_sk_find(OCSP_ONEREQ, (st), (val)) 1072 # define sk_OCSP_ONEREQ_find_ex(st, val) SKM_sk_find_ex(OCSP_ONEREQ, (st), (val)) 1073 # define sk_OCSP_ONEREQ_delete(st, i) SKM_sk_delete(OCSP_ONEREQ, (st), (i)) 1074 # define sk_OCSP_ONEREQ_delete_ptr(st, ptr) SKM_sk_delete_ptr(OCSP_ONEREQ, (st), (ptr)) 1075 # define sk_OCSP_ONEREQ_insert(st, val, i) SKM_sk_insert(OCSP_ONEREQ, (st), (val), (i)) 1076 # define sk_OCSP_ONEREQ_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(OCSP_ONEREQ, (st), (cmp)) 1077 # define sk_OCSP_ONEREQ_dup(st) SKM_sk_dup(OCSP_ONEREQ, st) 1078 # define sk_OCSP_ONEREQ_pop_free(st, free_func) SKM_sk_pop_free(OCSP_ONEREQ, (st), (free_func)) 1079 # define sk_OCSP_ONEREQ_shift(st) SKM_sk_shift(OCSP_ONEREQ, (st)) 1080 # define sk_OCSP_ONEREQ_pop(st) SKM_sk_pop(OCSP_ONEREQ, (st)) 1081 # define sk_OCSP_ONEREQ_sort(st) SKM_sk_sort(OCSP_ONEREQ, (st)) 1082 # define sk_OCSP_ONEREQ_is_sorted(st) SKM_sk_is_sorted(OCSP_ONEREQ, (st)) 1083 1084 # define sk_OCSP_RESPID_new(st) SKM_sk_new(OCSP_RESPID, (st)) 1085 # define sk_OCSP_RESPID_new_null() SKM_sk_new_null(OCSP_RESPID) 1086 # define sk_OCSP_RESPID_free(st) SKM_sk_free(OCSP_RESPID, (st)) 1087 # define sk_OCSP_RESPID_num(st) SKM_sk_num(OCSP_RESPID, (st)) 1088 # define sk_OCSP_RESPID_value(st, i) SKM_sk_value(OCSP_RESPID, (st), (i)) 1089 # define sk_OCSP_RESPID_set(st, i, val) SKM_sk_set(OCSP_RESPID, (st), (i), (val)) 1090 # define sk_OCSP_RESPID_zero(st) SKM_sk_zero(OCSP_RESPID, (st)) 1091 # define sk_OCSP_RESPID_push(st, val) SKM_sk_push(OCSP_RESPID, (st), (val)) 1092 # define sk_OCSP_RESPID_unshift(st, val) SKM_sk_unshift(OCSP_RESPID, (st), (val)) 1093 # define sk_OCSP_RESPID_find(st, val) SKM_sk_find(OCSP_RESPID, (st), (val)) 1094 # define sk_OCSP_RESPID_find_ex(st, val) SKM_sk_find_ex(OCSP_RESPID, (st), (val)) 1095 # define sk_OCSP_RESPID_delete(st, i) SKM_sk_delete(OCSP_RESPID, (st), (i)) 1096 # define sk_OCSP_RESPID_delete_ptr(st, ptr) SKM_sk_delete_ptr(OCSP_RESPID, (st), (ptr)) 1097 # define sk_OCSP_RESPID_insert(st, val, i) SKM_sk_insert(OCSP_RESPID, (st), (val), (i)) 1098 # define sk_OCSP_RESPID_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(OCSP_RESPID, (st), (cmp)) 1099 # define sk_OCSP_RESPID_dup(st) SKM_sk_dup(OCSP_RESPID, st) 1100 # define sk_OCSP_RESPID_pop_free(st, free_func) SKM_sk_pop_free(OCSP_RESPID, (st), (free_func)) 1101 # define sk_OCSP_RESPID_shift(st) SKM_sk_shift(OCSP_RESPID, (st)) 1102 # define sk_OCSP_RESPID_pop(st) SKM_sk_pop(OCSP_RESPID, (st)) 1103 # define sk_OCSP_RESPID_sort(st) SKM_sk_sort(OCSP_RESPID, (st)) 1104 # define sk_OCSP_RESPID_is_sorted(st) SKM_sk_is_sorted(OCSP_RESPID, (st)) 1105 1106 # define sk_OCSP_SINGLERESP_new(st) SKM_sk_new(OCSP_SINGLERESP, (st)) 1107 # define sk_OCSP_SINGLERESP_new_null() SKM_sk_new_null(OCSP_SINGLERESP) 1108 # define sk_OCSP_SINGLERESP_free(st) SKM_sk_free(OCSP_SINGLERESP, (st)) 1109 # define sk_OCSP_SINGLERESP_num(st) SKM_sk_num(OCSP_SINGLERESP, (st)) 1110 # define sk_OCSP_SINGLERESP_value(st, i) SKM_sk_value(OCSP_SINGLERESP, (st), (i)) 1111 # define sk_OCSP_SINGLERESP_set(st, i, val) SKM_sk_set(OCSP_SINGLERESP, (st), (i), (val)) 1112 # define sk_OCSP_SINGLERESP_zero(st) SKM_sk_zero(OCSP_SINGLERESP, (st)) 1113 # define sk_OCSP_SINGLERESP_push(st, val) SKM_sk_push(OCSP_SINGLERESP, (st), (val)) 1114 # define sk_OCSP_SINGLERESP_unshift(st, val) SKM_sk_unshift(OCSP_SINGLERESP, (st), (val)) 1115 # define sk_OCSP_SINGLERESP_find(st, val) SKM_sk_find(OCSP_SINGLERESP, (st), (val)) 1116 # define sk_OCSP_SINGLERESP_find_ex(st, val) SKM_sk_find_ex(OCSP_SINGLERESP, (st), (val)) 1117 # define sk_OCSP_SINGLERESP_delete(st, i) SKM_sk_delete(OCSP_SINGLERESP, (st), (i)) 1118 # define sk_OCSP_SINGLERESP_delete_ptr(st, ptr) SKM_sk_delete_ptr(OCSP_SINGLERESP, (st), (ptr)) 1119 # define sk_OCSP_SINGLERESP_insert(st, val, i) SKM_sk_insert(OCSP_SINGLERESP, (st), (val), (i)) 1120 # define sk_OCSP_SINGLERESP_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(OCSP_SINGLERESP, (st), (cmp)) 1121 # define sk_OCSP_SINGLERESP_dup(st) SKM_sk_dup(OCSP_SINGLERESP, st) 1122 # define sk_OCSP_SINGLERESP_pop_free(st, free_func) SKM_sk_pop_free(OCSP_SINGLERESP, (st), (free_func)) 1123 # define sk_OCSP_SINGLERESP_shift(st) SKM_sk_shift(OCSP_SINGLERESP, (st)) 1124 # define sk_OCSP_SINGLERESP_pop(st) SKM_sk_pop(OCSP_SINGLERESP, (st)) 1125 # define sk_OCSP_SINGLERESP_sort(st) SKM_sk_sort(OCSP_SINGLERESP, (st)) 1126 # define sk_OCSP_SINGLERESP_is_sorted(st) SKM_sk_is_sorted(OCSP_SINGLERESP, (st)) 1127 1128 # define sk_PKCS12_SAFEBAG_new(st) SKM_sk_new(PKCS12_SAFEBAG, (st)) 1129 # define sk_PKCS12_SAFEBAG_new_null() SKM_sk_new_null(PKCS12_SAFEBAG) 1130 # define sk_PKCS12_SAFEBAG_free(st) SKM_sk_free(PKCS12_SAFEBAG, (st)) 1131 # define sk_PKCS12_SAFEBAG_num(st) SKM_sk_num(PKCS12_SAFEBAG, (st)) 1132 # define sk_PKCS12_SAFEBAG_value(st, i) SKM_sk_value(PKCS12_SAFEBAG, (st), (i)) 1133 # define sk_PKCS12_SAFEBAG_set(st, i, val) SKM_sk_set(PKCS12_SAFEBAG, (st), (i), (val)) 1134 # define sk_PKCS12_SAFEBAG_zero(st) SKM_sk_zero(PKCS12_SAFEBAG, (st)) 1135 # define sk_PKCS12_SAFEBAG_push(st, val) SKM_sk_push(PKCS12_SAFEBAG, (st), (val)) 1136 # define sk_PKCS12_SAFEBAG_unshift(st, val) SKM_sk_unshift(PKCS12_SAFEBAG, (st), (val)) 1137 # define sk_PKCS12_SAFEBAG_find(st, val) SKM_sk_find(PKCS12_SAFEBAG, (st), (val)) 1138 # define sk_PKCS12_SAFEBAG_find_ex(st, val) SKM_sk_find_ex(PKCS12_SAFEBAG, (st), (val)) 1139 # define sk_PKCS12_SAFEBAG_delete(st, i) SKM_sk_delete(PKCS12_SAFEBAG, (st), (i)) 1140 # define sk_PKCS12_SAFEBAG_delete_ptr(st, ptr) SKM_sk_delete_ptr(PKCS12_SAFEBAG, (st), (ptr)) 1141 # define sk_PKCS12_SAFEBAG_insert(st, val, i) SKM_sk_insert(PKCS12_SAFEBAG, (st), (val), (i)) 1142 # define sk_PKCS12_SAFEBAG_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(PKCS12_SAFEBAG, (st), (cmp)) 1143 # define sk_PKCS12_SAFEBAG_dup(st) SKM_sk_dup(PKCS12_SAFEBAG, st) 1144 # define sk_PKCS12_SAFEBAG_pop_free(st, free_func) SKM_sk_pop_free(PKCS12_SAFEBAG, (st), (free_func)) 1145 # define sk_PKCS12_SAFEBAG_shift(st) SKM_sk_shift(PKCS12_SAFEBAG, (st)) 1146 # define sk_PKCS12_SAFEBAG_pop(st) SKM_sk_pop(PKCS12_SAFEBAG, (st)) 1147 # define sk_PKCS12_SAFEBAG_sort(st) SKM_sk_sort(PKCS12_SAFEBAG, (st)) 1148 # define sk_PKCS12_SAFEBAG_is_sorted(st) SKM_sk_is_sorted(PKCS12_SAFEBAG, (st)) 1149 1150 # define sk_PKCS7_new(st) SKM_sk_new(PKCS7, (st)) 1151 # define sk_PKCS7_new_null() SKM_sk_new_null(PKCS7) 1152 # define sk_PKCS7_free(st) SKM_sk_free(PKCS7, (st)) 1153 # define sk_PKCS7_num(st) SKM_sk_num(PKCS7, (st)) 1154 # define sk_PKCS7_value(st, i) SKM_sk_value(PKCS7, (st), (i)) 1155 # define sk_PKCS7_set(st, i, val) SKM_sk_set(PKCS7, (st), (i), (val)) 1156 # define sk_PKCS7_zero(st) SKM_sk_zero(PKCS7, (st)) 1157 # define sk_PKCS7_push(st, val) SKM_sk_push(PKCS7, (st), (val)) 1158 # define sk_PKCS7_unshift(st, val) SKM_sk_unshift(PKCS7, (st), (val)) 1159 # define sk_PKCS7_find(st, val) SKM_sk_find(PKCS7, (st), (val)) 1160 # define sk_PKCS7_find_ex(st, val) SKM_sk_find_ex(PKCS7, (st), (val)) 1161 # define sk_PKCS7_delete(st, i) SKM_sk_delete(PKCS7, (st), (i)) 1162 # define sk_PKCS7_delete_ptr(st, ptr) SKM_sk_delete_ptr(PKCS7, (st), (ptr)) 1163 # define sk_PKCS7_insert(st, val, i) SKM_sk_insert(PKCS7, (st), (val), (i)) 1164 # define sk_PKCS7_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(PKCS7, (st), (cmp)) 1165 # define sk_PKCS7_dup(st) SKM_sk_dup(PKCS7, st) 1166 # define sk_PKCS7_pop_free(st, free_func) SKM_sk_pop_free(PKCS7, (st), (free_func)) 1167 # define sk_PKCS7_shift(st) SKM_sk_shift(PKCS7, (st)) 1168 # define sk_PKCS7_pop(st) SKM_sk_pop(PKCS7, (st)) 1169 # define sk_PKCS7_sort(st) SKM_sk_sort(PKCS7, (st)) 1170 # define sk_PKCS7_is_sorted(st) SKM_sk_is_sorted(PKCS7, (st)) 1171 1172 # define sk_PKCS7_RECIP_INFO_new(st) SKM_sk_new(PKCS7_RECIP_INFO, (st)) 1173 # define sk_PKCS7_RECIP_INFO_new_null() SKM_sk_new_null(PKCS7_RECIP_INFO) 1174 # define sk_PKCS7_RECIP_INFO_free(st) SKM_sk_free(PKCS7_RECIP_INFO, (st)) 1175 # define sk_PKCS7_RECIP_INFO_num(st) SKM_sk_num(PKCS7_RECIP_INFO, (st)) 1176 # define sk_PKCS7_RECIP_INFO_value(st, i) SKM_sk_value(PKCS7_RECIP_INFO, (st), (i)) 1177 # define sk_PKCS7_RECIP_INFO_set(st, i, val) SKM_sk_set(PKCS7_RECIP_INFO, (st), (i), (val)) 1178 # define sk_PKCS7_RECIP_INFO_zero(st) SKM_sk_zero(PKCS7_RECIP_INFO, (st)) 1179 # define sk_PKCS7_RECIP_INFO_push(st, val) SKM_sk_push(PKCS7_RECIP_INFO, (st), (val)) 1180 # define sk_PKCS7_RECIP_INFO_unshift(st, val) SKM_sk_unshift(PKCS7_RECIP_INFO, (st), (val)) 1181 # define sk_PKCS7_RECIP_INFO_find(st, val) SKM_sk_find(PKCS7_RECIP_INFO, (st), (val)) 1182 # define sk_PKCS7_RECIP_INFO_find_ex(st, val) SKM_sk_find_ex(PKCS7_RECIP_INFO, (st), (val)) 1183 # define sk_PKCS7_RECIP_INFO_delete(st, i) SKM_sk_delete(PKCS7_RECIP_INFO, (st), (i)) 1184 # define sk_PKCS7_RECIP_INFO_delete_ptr(st, ptr) SKM_sk_delete_ptr(PKCS7_RECIP_INFO, (st), (ptr)) 1185 # define sk_PKCS7_RECIP_INFO_insert(st, val, i) SKM_sk_insert(PKCS7_RECIP_INFO, (st), (val), (i)) 1186 # define sk_PKCS7_RECIP_INFO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(PKCS7_RECIP_INFO, (st), (cmp)) 1187 # define sk_PKCS7_RECIP_INFO_dup(st) SKM_sk_dup(PKCS7_RECIP_INFO, st) 1188 # define sk_PKCS7_RECIP_INFO_pop_free(st, free_func) SKM_sk_pop_free(PKCS7_RECIP_INFO, (st), (free_func)) 1189 # define sk_PKCS7_RECIP_INFO_shift(st) SKM_sk_shift(PKCS7_RECIP_INFO, (st)) 1190 # define sk_PKCS7_RECIP_INFO_pop(st) SKM_sk_pop(PKCS7_RECIP_INFO, (st)) 1191 # define sk_PKCS7_RECIP_INFO_sort(st) SKM_sk_sort(PKCS7_RECIP_INFO, (st)) 1192 # define sk_PKCS7_RECIP_INFO_is_sorted(st) SKM_sk_is_sorted(PKCS7_RECIP_INFO, (st)) 1193 1194 # define sk_PKCS7_SIGNER_INFO_new(st) SKM_sk_new(PKCS7_SIGNER_INFO, (st)) 1195 # define sk_PKCS7_SIGNER_INFO_new_null() SKM_sk_new_null(PKCS7_SIGNER_INFO) 1196 # define sk_PKCS7_SIGNER_INFO_free(st) SKM_sk_free(PKCS7_SIGNER_INFO, (st)) 1197 # define sk_PKCS7_SIGNER_INFO_num(st) SKM_sk_num(PKCS7_SIGNER_INFO, (st)) 1198 # define sk_PKCS7_SIGNER_INFO_value(st, i) SKM_sk_value(PKCS7_SIGNER_INFO, (st), (i)) 1199 # define sk_PKCS7_SIGNER_INFO_set(st, i, val) SKM_sk_set(PKCS7_SIGNER_INFO, (st), (i), (val)) 1200 # define sk_PKCS7_SIGNER_INFO_zero(st) SKM_sk_zero(PKCS7_SIGNER_INFO, (st)) 1201 # define sk_PKCS7_SIGNER_INFO_push(st, val) SKM_sk_push(PKCS7_SIGNER_INFO, (st), (val)) 1202 # define sk_PKCS7_SIGNER_INFO_unshift(st, val) SKM_sk_unshift(PKCS7_SIGNER_INFO, (st), (val)) 1203 # define sk_PKCS7_SIGNER_INFO_find(st, val) SKM_sk_find(PKCS7_SIGNER_INFO, (st), (val)) 1204 # define sk_PKCS7_SIGNER_INFO_find_ex(st, val) SKM_sk_find_ex(PKCS7_SIGNER_INFO, (st), (val)) 1205 # define sk_PKCS7_SIGNER_INFO_delete(st, i) SKM_sk_delete(PKCS7_SIGNER_INFO, (st), (i)) 1206 # define sk_PKCS7_SIGNER_INFO_delete_ptr(st, ptr) SKM_sk_delete_ptr(PKCS7_SIGNER_INFO, (st), (ptr)) 1207 # define sk_PKCS7_SIGNER_INFO_insert(st, val, i) SKM_sk_insert(PKCS7_SIGNER_INFO, (st), (val), (i)) 1208 # define sk_PKCS7_SIGNER_INFO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(PKCS7_SIGNER_INFO, (st), (cmp)) 1209 # define sk_PKCS7_SIGNER_INFO_dup(st) SKM_sk_dup(PKCS7_SIGNER_INFO, st) 1210 # define sk_PKCS7_SIGNER_INFO_pop_free(st, free_func) SKM_sk_pop_free(PKCS7_SIGNER_INFO, (st), (free_func)) 1211 # define sk_PKCS7_SIGNER_INFO_shift(st) SKM_sk_shift(PKCS7_SIGNER_INFO, (st)) 1212 # define sk_PKCS7_SIGNER_INFO_pop(st) SKM_sk_pop(PKCS7_SIGNER_INFO, (st)) 1213 # define sk_PKCS7_SIGNER_INFO_sort(st) SKM_sk_sort(PKCS7_SIGNER_INFO, (st)) 1214 # define sk_PKCS7_SIGNER_INFO_is_sorted(st) SKM_sk_is_sorted(PKCS7_SIGNER_INFO, (st)) 1215 1216 # define sk_POLICYINFO_new(st) SKM_sk_new(POLICYINFO, (st)) 1217 # define sk_POLICYINFO_new_null() SKM_sk_new_null(POLICYINFO) 1218 # define sk_POLICYINFO_free(st) SKM_sk_free(POLICYINFO, (st)) 1219 # define sk_POLICYINFO_num(st) SKM_sk_num(POLICYINFO, (st)) 1220 # define sk_POLICYINFO_value(st, i) SKM_sk_value(POLICYINFO, (st), (i)) 1221 # define sk_POLICYINFO_set(st, i, val) SKM_sk_set(POLICYINFO, (st), (i), (val)) 1222 # define sk_POLICYINFO_zero(st) SKM_sk_zero(POLICYINFO, (st)) 1223 # define sk_POLICYINFO_push(st, val) SKM_sk_push(POLICYINFO, (st), (val)) 1224 # define sk_POLICYINFO_unshift(st, val) SKM_sk_unshift(POLICYINFO, (st), (val)) 1225 # define sk_POLICYINFO_find(st, val) SKM_sk_find(POLICYINFO, (st), (val)) 1226 # define sk_POLICYINFO_find_ex(st, val) SKM_sk_find_ex(POLICYINFO, (st), (val)) 1227 # define sk_POLICYINFO_delete(st, i) SKM_sk_delete(POLICYINFO, (st), (i)) 1228 # define sk_POLICYINFO_delete_ptr(st, ptr) SKM_sk_delete_ptr(POLICYINFO, (st), (ptr)) 1229 # define sk_POLICYINFO_insert(st, val, i) SKM_sk_insert(POLICYINFO, (st), (val), (i)) 1230 # define sk_POLICYINFO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(POLICYINFO, (st), (cmp)) 1231 # define sk_POLICYINFO_dup(st) SKM_sk_dup(POLICYINFO, st) 1232 # define sk_POLICYINFO_pop_free(st, free_func) SKM_sk_pop_free(POLICYINFO, (st), (free_func)) 1233 # define sk_POLICYINFO_shift(st) SKM_sk_shift(POLICYINFO, (st)) 1234 # define sk_POLICYINFO_pop(st) SKM_sk_pop(POLICYINFO, (st)) 1235 # define sk_POLICYINFO_sort(st) SKM_sk_sort(POLICYINFO, (st)) 1236 # define sk_POLICYINFO_is_sorted(st) SKM_sk_is_sorted(POLICYINFO, (st)) 1237 1238 # define sk_POLICYQUALINFO_new(st) SKM_sk_new(POLICYQUALINFO, (st)) 1239 # define sk_POLICYQUALINFO_new_null() SKM_sk_new_null(POLICYQUALINFO) 1240 # define sk_POLICYQUALINFO_free(st) SKM_sk_free(POLICYQUALINFO, (st)) 1241 # define sk_POLICYQUALINFO_num(st) SKM_sk_num(POLICYQUALINFO, (st)) 1242 # define sk_POLICYQUALINFO_value(st, i) SKM_sk_value(POLICYQUALINFO, (st), (i)) 1243 # define sk_POLICYQUALINFO_set(st, i, val) SKM_sk_set(POLICYQUALINFO, (st), (i), (val)) 1244 # define sk_POLICYQUALINFO_zero(st) SKM_sk_zero(POLICYQUALINFO, (st)) 1245 # define sk_POLICYQUALINFO_push(st, val) SKM_sk_push(POLICYQUALINFO, (st), (val)) 1246 # define sk_POLICYQUALINFO_unshift(st, val) SKM_sk_unshift(POLICYQUALINFO, (st), (val)) 1247 # define sk_POLICYQUALINFO_find(st, val) SKM_sk_find(POLICYQUALINFO, (st), (val)) 1248 # define sk_POLICYQUALINFO_find_ex(st, val) SKM_sk_find_ex(POLICYQUALINFO, (st), (val)) 1249 # define sk_POLICYQUALINFO_delete(st, i) SKM_sk_delete(POLICYQUALINFO, (st), (i)) 1250 # define sk_POLICYQUALINFO_delete_ptr(st, ptr) SKM_sk_delete_ptr(POLICYQUALINFO, (st), (ptr)) 1251 # define sk_POLICYQUALINFO_insert(st, val, i) SKM_sk_insert(POLICYQUALINFO, (st), (val), (i)) 1252 # define sk_POLICYQUALINFO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(POLICYQUALINFO, (st), (cmp)) 1253 # define sk_POLICYQUALINFO_dup(st) SKM_sk_dup(POLICYQUALINFO, st) 1254 # define sk_POLICYQUALINFO_pop_free(st, free_func) SKM_sk_pop_free(POLICYQUALINFO, (st), (free_func)) 1255 # define sk_POLICYQUALINFO_shift(st) SKM_sk_shift(POLICYQUALINFO, (st)) 1256 # define sk_POLICYQUALINFO_pop(st) SKM_sk_pop(POLICYQUALINFO, (st)) 1257 # define sk_POLICYQUALINFO_sort(st) SKM_sk_sort(POLICYQUALINFO, (st)) 1258 # define sk_POLICYQUALINFO_is_sorted(st) SKM_sk_is_sorted(POLICYQUALINFO, (st)) 1259 1260 # define sk_POLICY_MAPPING_new(st) SKM_sk_new(POLICY_MAPPING, (st)) 1261 # define sk_POLICY_MAPPING_new_null() SKM_sk_new_null(POLICY_MAPPING) 1262 # define sk_POLICY_MAPPING_free(st) SKM_sk_free(POLICY_MAPPING, (st)) 1263 # define sk_POLICY_MAPPING_num(st) SKM_sk_num(POLICY_MAPPING, (st)) 1264 # define sk_POLICY_MAPPING_value(st, i) SKM_sk_value(POLICY_MAPPING, (st), (i)) 1265 # define sk_POLICY_MAPPING_set(st, i, val) SKM_sk_set(POLICY_MAPPING, (st), (i), (val)) 1266 # define sk_POLICY_MAPPING_zero(st) SKM_sk_zero(POLICY_MAPPING, (st)) 1267 # define sk_POLICY_MAPPING_push(st, val) SKM_sk_push(POLICY_MAPPING, (st), (val)) 1268 # define sk_POLICY_MAPPING_unshift(st, val) SKM_sk_unshift(POLICY_MAPPING, (st), (val)) 1269 # define sk_POLICY_MAPPING_find(st, val) SKM_sk_find(POLICY_MAPPING, (st), (val)) 1270 # define sk_POLICY_MAPPING_find_ex(st, val) SKM_sk_find_ex(POLICY_MAPPING, (st), (val)) 1271 # define sk_POLICY_MAPPING_delete(st, i) SKM_sk_delete(POLICY_MAPPING, (st), (i)) 1272 # define sk_POLICY_MAPPING_delete_ptr(st, ptr) SKM_sk_delete_ptr(POLICY_MAPPING, (st), (ptr)) 1273 # define sk_POLICY_MAPPING_insert(st, val, i) SKM_sk_insert(POLICY_MAPPING, (st), (val), (i)) 1274 # define sk_POLICY_MAPPING_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(POLICY_MAPPING, (st), (cmp)) 1275 # define sk_POLICY_MAPPING_dup(st) SKM_sk_dup(POLICY_MAPPING, st) 1276 # define sk_POLICY_MAPPING_pop_free(st, free_func) SKM_sk_pop_free(POLICY_MAPPING, (st), (free_func)) 1277 # define sk_POLICY_MAPPING_shift(st) SKM_sk_shift(POLICY_MAPPING, (st)) 1278 # define sk_POLICY_MAPPING_pop(st) SKM_sk_pop(POLICY_MAPPING, (st)) 1279 # define sk_POLICY_MAPPING_sort(st) SKM_sk_sort(POLICY_MAPPING, (st)) 1280 # define sk_POLICY_MAPPING_is_sorted(st) SKM_sk_is_sorted(POLICY_MAPPING, (st)) 1281 1282 # define sk_SSL_CIPHER_new(st) SKM_sk_new(SSL_CIPHER, (st)) 1283 # define sk_SSL_CIPHER_new_null() SKM_sk_new_null(SSL_CIPHER) 1284 # define sk_SSL_CIPHER_free(st) SKM_sk_free(SSL_CIPHER, (st)) 1285 # define sk_SSL_CIPHER_num(st) SKM_sk_num(SSL_CIPHER, (st)) 1286 # define sk_SSL_CIPHER_value(st, i) SKM_sk_value(SSL_CIPHER, (st), (i)) 1287 # define sk_SSL_CIPHER_set(st, i, val) SKM_sk_set(SSL_CIPHER, (st), (i), (val)) 1288 # define sk_SSL_CIPHER_zero(st) SKM_sk_zero(SSL_CIPHER, (st)) 1289 # define sk_SSL_CIPHER_push(st, val) SKM_sk_push(SSL_CIPHER, (st), (val)) 1290 # define sk_SSL_CIPHER_unshift(st, val) SKM_sk_unshift(SSL_CIPHER, (st), (val)) 1291 # define sk_SSL_CIPHER_find(st, val) SKM_sk_find(SSL_CIPHER, (st), (val)) 1292 # define sk_SSL_CIPHER_find_ex(st, val) SKM_sk_find_ex(SSL_CIPHER, (st), (val)) 1293 # define sk_SSL_CIPHER_delete(st, i) SKM_sk_delete(SSL_CIPHER, (st), (i)) 1294 # define sk_SSL_CIPHER_delete_ptr(st, ptr) SKM_sk_delete_ptr(SSL_CIPHER, (st), (ptr)) 1295 # define sk_SSL_CIPHER_insert(st, val, i) SKM_sk_insert(SSL_CIPHER, (st), (val), (i)) 1296 # define sk_SSL_CIPHER_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(SSL_CIPHER, (st), (cmp)) 1297 # define sk_SSL_CIPHER_dup(st) SKM_sk_dup(SSL_CIPHER, st) 1298 # define sk_SSL_CIPHER_pop_free(st, free_func) SKM_sk_pop_free(SSL_CIPHER, (st), (free_func)) 1299 # define sk_SSL_CIPHER_shift(st) SKM_sk_shift(SSL_CIPHER, (st)) 1300 # define sk_SSL_CIPHER_pop(st) SKM_sk_pop(SSL_CIPHER, (st)) 1301 # define sk_SSL_CIPHER_sort(st) SKM_sk_sort(SSL_CIPHER, (st)) 1302 # define sk_SSL_CIPHER_is_sorted(st) SKM_sk_is_sorted(SSL_CIPHER, (st)) 1303 1304 # define sk_SSL_COMP_new(st) SKM_sk_new(SSL_COMP, (st)) 1305 # define sk_SSL_COMP_new_null() SKM_sk_new_null(SSL_COMP) 1306 # define sk_SSL_COMP_free(st) SKM_sk_free(SSL_COMP, (st)) 1307 # define sk_SSL_COMP_num(st) SKM_sk_num(SSL_COMP, (st)) 1308 # define sk_SSL_COMP_value(st, i) SKM_sk_value(SSL_COMP, (st), (i)) 1309 # define sk_SSL_COMP_set(st, i, val) SKM_sk_set(SSL_COMP, (st), (i), (val)) 1310 # define sk_SSL_COMP_zero(st) SKM_sk_zero(SSL_COMP, (st)) 1311 # define sk_SSL_COMP_push(st, val) SKM_sk_push(SSL_COMP, (st), (val)) 1312 # define sk_SSL_COMP_unshift(st, val) SKM_sk_unshift(SSL_COMP, (st), (val)) 1313 # define sk_SSL_COMP_find(st, val) SKM_sk_find(SSL_COMP, (st), (val)) 1314 # define sk_SSL_COMP_find_ex(st, val) SKM_sk_find_ex(SSL_COMP, (st), (val)) 1315 # define sk_SSL_COMP_delete(st, i) SKM_sk_delete(SSL_COMP, (st), (i)) 1316 # define sk_SSL_COMP_delete_ptr(st, ptr) SKM_sk_delete_ptr(SSL_COMP, (st), (ptr)) 1317 # define sk_SSL_COMP_insert(st, val, i) SKM_sk_insert(SSL_COMP, (st), (val), (i)) 1318 # define sk_SSL_COMP_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(SSL_COMP, (st), (cmp)) 1319 # define sk_SSL_COMP_dup(st) SKM_sk_dup(SSL_COMP, st) 1320 # define sk_SSL_COMP_pop_free(st, free_func) SKM_sk_pop_free(SSL_COMP, (st), (free_func)) 1321 # define sk_SSL_COMP_shift(st) SKM_sk_shift(SSL_COMP, (st)) 1322 # define sk_SSL_COMP_pop(st) SKM_sk_pop(SSL_COMP, (st)) 1323 # define sk_SSL_COMP_sort(st) SKM_sk_sort(SSL_COMP, (st)) 1324 # define sk_SSL_COMP_is_sorted(st) SKM_sk_is_sorted(SSL_COMP, (st)) 1325 1326 # define sk_STORE_OBJECT_new(st) SKM_sk_new(STORE_OBJECT, (st)) 1327 # define sk_STORE_OBJECT_new_null() SKM_sk_new_null(STORE_OBJECT) 1328 # define sk_STORE_OBJECT_free(st) SKM_sk_free(STORE_OBJECT, (st)) 1329 # define sk_STORE_OBJECT_num(st) SKM_sk_num(STORE_OBJECT, (st)) 1330 # define sk_STORE_OBJECT_value(st, i) SKM_sk_value(STORE_OBJECT, (st), (i)) 1331 # define sk_STORE_OBJECT_set(st, i, val) SKM_sk_set(STORE_OBJECT, (st), (i), (val)) 1332 # define sk_STORE_OBJECT_zero(st) SKM_sk_zero(STORE_OBJECT, (st)) 1333 # define sk_STORE_OBJECT_push(st, val) SKM_sk_push(STORE_OBJECT, (st), (val)) 1334 # define sk_STORE_OBJECT_unshift(st, val) SKM_sk_unshift(STORE_OBJECT, (st), (val)) 1335 # define sk_STORE_OBJECT_find(st, val) SKM_sk_find(STORE_OBJECT, (st), (val)) 1336 # define sk_STORE_OBJECT_find_ex(st, val) SKM_sk_find_ex(STORE_OBJECT, (st), (val)) 1337 # define sk_STORE_OBJECT_delete(st, i) SKM_sk_delete(STORE_OBJECT, (st), (i)) 1338 # define sk_STORE_OBJECT_delete_ptr(st, ptr) SKM_sk_delete_ptr(STORE_OBJECT, (st), (ptr)) 1339 # define sk_STORE_OBJECT_insert(st, val, i) SKM_sk_insert(STORE_OBJECT, (st), (val), (i)) 1340 # define sk_STORE_OBJECT_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(STORE_OBJECT, (st), (cmp)) 1341 # define sk_STORE_OBJECT_dup(st) SKM_sk_dup(STORE_OBJECT, st) 1342 # define sk_STORE_OBJECT_pop_free(st, free_func) SKM_sk_pop_free(STORE_OBJECT, (st), (free_func)) 1343 # define sk_STORE_OBJECT_shift(st) SKM_sk_shift(STORE_OBJECT, (st)) 1344 # define sk_STORE_OBJECT_pop(st) SKM_sk_pop(STORE_OBJECT, (st)) 1345 # define sk_STORE_OBJECT_sort(st) SKM_sk_sort(STORE_OBJECT, (st)) 1346 # define sk_STORE_OBJECT_is_sorted(st) SKM_sk_is_sorted(STORE_OBJECT, (st)) 1347 1348 # define sk_SXNETID_new(st) SKM_sk_new(SXNETID, (st)) 1349 # define sk_SXNETID_new_null() SKM_sk_new_null(SXNETID) 1350 # define sk_SXNETID_free(st) SKM_sk_free(SXNETID, (st)) 1351 # define sk_SXNETID_num(st) SKM_sk_num(SXNETID, (st)) 1352 # define sk_SXNETID_value(st, i) SKM_sk_value(SXNETID, (st), (i)) 1353 # define sk_SXNETID_set(st, i, val) SKM_sk_set(SXNETID, (st), (i), (val)) 1354 # define sk_SXNETID_zero(st) SKM_sk_zero(SXNETID, (st)) 1355 # define sk_SXNETID_push(st, val) SKM_sk_push(SXNETID, (st), (val)) 1356 # define sk_SXNETID_unshift(st, val) SKM_sk_unshift(SXNETID, (st), (val)) 1357 # define sk_SXNETID_find(st, val) SKM_sk_find(SXNETID, (st), (val)) 1358 # define sk_SXNETID_find_ex(st, val) SKM_sk_find_ex(SXNETID, (st), (val)) 1359 # define sk_SXNETID_delete(st, i) SKM_sk_delete(SXNETID, (st), (i)) 1360 # define sk_SXNETID_delete_ptr(st, ptr) SKM_sk_delete_ptr(SXNETID, (st), (ptr)) 1361 # define sk_SXNETID_insert(st, val, i) SKM_sk_insert(SXNETID, (st), (val), (i)) 1362 # define sk_SXNETID_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(SXNETID, (st), (cmp)) 1363 # define sk_SXNETID_dup(st) SKM_sk_dup(SXNETID, st) 1364 # define sk_SXNETID_pop_free(st, free_func) SKM_sk_pop_free(SXNETID, (st), (free_func)) 1365 # define sk_SXNETID_shift(st) SKM_sk_shift(SXNETID, (st)) 1366 # define sk_SXNETID_pop(st) SKM_sk_pop(SXNETID, (st)) 1367 # define sk_SXNETID_sort(st) SKM_sk_sort(SXNETID, (st)) 1368 # define sk_SXNETID_is_sorted(st) SKM_sk_is_sorted(SXNETID, (st)) 1369 1370 # define sk_UI_STRING_new(st) SKM_sk_new(UI_STRING, (st)) 1371 # define sk_UI_STRING_new_null() SKM_sk_new_null(UI_STRING) 1372 # define sk_UI_STRING_free(st) SKM_sk_free(UI_STRING, (st)) 1373 # define sk_UI_STRING_num(st) SKM_sk_num(UI_STRING, (st)) 1374 # define sk_UI_STRING_value(st, i) SKM_sk_value(UI_STRING, (st), (i)) 1375 # define sk_UI_STRING_set(st, i, val) SKM_sk_set(UI_STRING, (st), (i), (val)) 1376 # define sk_UI_STRING_zero(st) SKM_sk_zero(UI_STRING, (st)) 1377 # define sk_UI_STRING_push(st, val) SKM_sk_push(UI_STRING, (st), (val)) 1378 # define sk_UI_STRING_unshift(st, val) SKM_sk_unshift(UI_STRING, (st), (val)) 1379 # define sk_UI_STRING_find(st, val) SKM_sk_find(UI_STRING, (st), (val)) 1380 # define sk_UI_STRING_find_ex(st, val) SKM_sk_find_ex(UI_STRING, (st), (val)) 1381 # define sk_UI_STRING_delete(st, i) SKM_sk_delete(UI_STRING, (st), (i)) 1382 # define sk_UI_STRING_delete_ptr(st, ptr) SKM_sk_delete_ptr(UI_STRING, (st), (ptr)) 1383 # define sk_UI_STRING_insert(st, val, i) SKM_sk_insert(UI_STRING, (st), (val), (i)) 1384 # define sk_UI_STRING_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(UI_STRING, (st), (cmp)) 1385 # define sk_UI_STRING_dup(st) SKM_sk_dup(UI_STRING, st) 1386 # define sk_UI_STRING_pop_free(st, free_func) SKM_sk_pop_free(UI_STRING, (st), (free_func)) 1387 # define sk_UI_STRING_shift(st) SKM_sk_shift(UI_STRING, (st)) 1388 # define sk_UI_STRING_pop(st) SKM_sk_pop(UI_STRING, (st)) 1389 # define sk_UI_STRING_sort(st) SKM_sk_sort(UI_STRING, (st)) 1390 # define sk_UI_STRING_is_sorted(st) SKM_sk_is_sorted(UI_STRING, (st)) 1391 1392 # define sk_X509_new(st) SKM_sk_new(X509, (st)) 1393 # define sk_X509_new_null() SKM_sk_new_null(X509) 1394 # define sk_X509_free(st) SKM_sk_free(X509, (st)) 1395 # define sk_X509_num(st) SKM_sk_num(X509, (st)) 1396 # define sk_X509_value(st, i) SKM_sk_value(X509, (st), (i)) 1397 # define sk_X509_set(st, i, val) SKM_sk_set(X509, (st), (i), (val)) 1398 # define sk_X509_zero(st) SKM_sk_zero(X509, (st)) 1399 # define sk_X509_push(st, val) SKM_sk_push(X509, (st), (val)) 1400 # define sk_X509_unshift(st, val) SKM_sk_unshift(X509, (st), (val)) 1401 # define sk_X509_find(st, val) SKM_sk_find(X509, (st), (val)) 1402 # define sk_X509_find_ex(st, val) SKM_sk_find_ex(X509, (st), (val)) 1403 # define sk_X509_delete(st, i) SKM_sk_delete(X509, (st), (i)) 1404 # define sk_X509_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509, (st), (ptr)) 1405 # define sk_X509_insert(st, val, i) SKM_sk_insert(X509, (st), (val), (i)) 1406 # define sk_X509_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509, (st), (cmp)) 1407 # define sk_X509_dup(st) SKM_sk_dup(X509, st) 1408 # define sk_X509_pop_free(st, free_func) SKM_sk_pop_free(X509, (st), (free_func)) 1409 # define sk_X509_shift(st) SKM_sk_shift(X509, (st)) 1410 # define sk_X509_pop(st) SKM_sk_pop(X509, (st)) 1411 # define sk_X509_sort(st) SKM_sk_sort(X509, (st)) 1412 # define sk_X509_is_sorted(st) SKM_sk_is_sorted(X509, (st)) 1413 1414 # define sk_X509V3_EXT_METHOD_new(st) SKM_sk_new(X509V3_EXT_METHOD, (st)) 1415 # define sk_X509V3_EXT_METHOD_new_null() SKM_sk_new_null(X509V3_EXT_METHOD) 1416 # define sk_X509V3_EXT_METHOD_free(st) SKM_sk_free(X509V3_EXT_METHOD, (st)) 1417 # define sk_X509V3_EXT_METHOD_num(st) SKM_sk_num(X509V3_EXT_METHOD, (st)) 1418 # define sk_X509V3_EXT_METHOD_value(st, i) SKM_sk_value(X509V3_EXT_METHOD, (st), (i)) 1419 # define sk_X509V3_EXT_METHOD_set(st, i, val) SKM_sk_set(X509V3_EXT_METHOD, (st), (i), (val)) 1420 # define sk_X509V3_EXT_METHOD_zero(st) SKM_sk_zero(X509V3_EXT_METHOD, (st)) 1421 # define sk_X509V3_EXT_METHOD_push(st, val) SKM_sk_push(X509V3_EXT_METHOD, (st), (val)) 1422 # define sk_X509V3_EXT_METHOD_unshift(st, val) SKM_sk_unshift(X509V3_EXT_METHOD, (st), (val)) 1423 # define sk_X509V3_EXT_METHOD_find(st, val) SKM_sk_find(X509V3_EXT_METHOD, (st), (val)) 1424 # define sk_X509V3_EXT_METHOD_find_ex(st, val) SKM_sk_find_ex(X509V3_EXT_METHOD, (st), (val)) 1425 # define sk_X509V3_EXT_METHOD_delete(st, i) SKM_sk_delete(X509V3_EXT_METHOD, (st), (i)) 1426 # define sk_X509V3_EXT_METHOD_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509V3_EXT_METHOD, (st), (ptr)) 1427 # define sk_X509V3_EXT_METHOD_insert(st, val, i) SKM_sk_insert(X509V3_EXT_METHOD, (st), (val), (i)) 1428 # define sk_X509V3_EXT_METHOD_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509V3_EXT_METHOD, (st), (cmp)) 1429 # define sk_X509V3_EXT_METHOD_dup(st) SKM_sk_dup(X509V3_EXT_METHOD, st) 1430 # define sk_X509V3_EXT_METHOD_pop_free(st, free_func) SKM_sk_pop_free(X509V3_EXT_METHOD, (st), (free_func)) 1431 # define sk_X509V3_EXT_METHOD_shift(st) SKM_sk_shift(X509V3_EXT_METHOD, (st)) 1432 # define sk_X509V3_EXT_METHOD_pop(st) SKM_sk_pop(X509V3_EXT_METHOD, (st)) 1433 # define sk_X509V3_EXT_METHOD_sort(st) SKM_sk_sort(X509V3_EXT_METHOD, (st)) 1434 # define sk_X509V3_EXT_METHOD_is_sorted(st) SKM_sk_is_sorted(X509V3_EXT_METHOD, (st)) 1435 1436 # define sk_X509_ALGOR_new(st) SKM_sk_new(X509_ALGOR, (st)) 1437 # define sk_X509_ALGOR_new_null() SKM_sk_new_null(X509_ALGOR) 1438 # define sk_X509_ALGOR_free(st) SKM_sk_free(X509_ALGOR, (st)) 1439 # define sk_X509_ALGOR_num(st) SKM_sk_num(X509_ALGOR, (st)) 1440 # define sk_X509_ALGOR_value(st, i) SKM_sk_value(X509_ALGOR, (st), (i)) 1441 # define sk_X509_ALGOR_set(st, i, val) SKM_sk_set(X509_ALGOR, (st), (i), (val)) 1442 # define sk_X509_ALGOR_zero(st) SKM_sk_zero(X509_ALGOR, (st)) 1443 # define sk_X509_ALGOR_push(st, val) SKM_sk_push(X509_ALGOR, (st), (val)) 1444 # define sk_X509_ALGOR_unshift(st, val) SKM_sk_unshift(X509_ALGOR, (st), (val)) 1445 # define sk_X509_ALGOR_find(st, val) SKM_sk_find(X509_ALGOR, (st), (val)) 1446 # define sk_X509_ALGOR_find_ex(st, val) SKM_sk_find_ex(X509_ALGOR, (st), (val)) 1447 # define sk_X509_ALGOR_delete(st, i) SKM_sk_delete(X509_ALGOR, (st), (i)) 1448 # define sk_X509_ALGOR_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_ALGOR, (st), (ptr)) 1449 # define sk_X509_ALGOR_insert(st, val, i) SKM_sk_insert(X509_ALGOR, (st), (val), (i)) 1450 # define sk_X509_ALGOR_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_ALGOR, (st), (cmp)) 1451 # define sk_X509_ALGOR_dup(st) SKM_sk_dup(X509_ALGOR, st) 1452 # define sk_X509_ALGOR_pop_free(st, free_func) SKM_sk_pop_free(X509_ALGOR, (st), (free_func)) 1453 # define sk_X509_ALGOR_shift(st) SKM_sk_shift(X509_ALGOR, (st)) 1454 # define sk_X509_ALGOR_pop(st) SKM_sk_pop(X509_ALGOR, (st)) 1455 # define sk_X509_ALGOR_sort(st) SKM_sk_sort(X509_ALGOR, (st)) 1456 # define sk_X509_ALGOR_is_sorted(st) SKM_sk_is_sorted(X509_ALGOR, (st)) 1457 1458 # define sk_X509_ATTRIBUTE_new(st) SKM_sk_new(X509_ATTRIBUTE, (st)) 1459 # define sk_X509_ATTRIBUTE_new_null() SKM_sk_new_null(X509_ATTRIBUTE) 1460 # define sk_X509_ATTRIBUTE_free(st) SKM_sk_free(X509_ATTRIBUTE, (st)) 1461 # define sk_X509_ATTRIBUTE_num(st) SKM_sk_num(X509_ATTRIBUTE, (st)) 1462 # define sk_X509_ATTRIBUTE_value(st, i) SKM_sk_value(X509_ATTRIBUTE, (st), (i)) 1463 # define sk_X509_ATTRIBUTE_set(st, i, val) SKM_sk_set(X509_ATTRIBUTE, (st), (i), (val)) 1464 # define sk_X509_ATTRIBUTE_zero(st) SKM_sk_zero(X509_ATTRIBUTE, (st)) 1465 # define sk_X509_ATTRIBUTE_push(st, val) SKM_sk_push(X509_ATTRIBUTE, (st), (val)) 1466 # define sk_X509_ATTRIBUTE_unshift(st, val) SKM_sk_unshift(X509_ATTRIBUTE, (st), (val)) 1467 # define sk_X509_ATTRIBUTE_find(st, val) SKM_sk_find(X509_ATTRIBUTE, (st), (val)) 1468 # define sk_X509_ATTRIBUTE_find_ex(st, val) SKM_sk_find_ex(X509_ATTRIBUTE, (st), (val)) 1469 # define sk_X509_ATTRIBUTE_delete(st, i) SKM_sk_delete(X509_ATTRIBUTE, (st), (i)) 1470 # define sk_X509_ATTRIBUTE_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_ATTRIBUTE, (st), (ptr)) 1471 # define sk_X509_ATTRIBUTE_insert(st, val, i) SKM_sk_insert(X509_ATTRIBUTE, (st), (val), (i)) 1472 # define sk_X509_ATTRIBUTE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_ATTRIBUTE, (st), (cmp)) 1473 # define sk_X509_ATTRIBUTE_dup(st) SKM_sk_dup(X509_ATTRIBUTE, st) 1474 # define sk_X509_ATTRIBUTE_pop_free(st, free_func) SKM_sk_pop_free(X509_ATTRIBUTE, (st), (free_func)) 1475 # define sk_X509_ATTRIBUTE_shift(st) SKM_sk_shift(X509_ATTRIBUTE, (st)) 1476 # define sk_X509_ATTRIBUTE_pop(st) SKM_sk_pop(X509_ATTRIBUTE, (st)) 1477 # define sk_X509_ATTRIBUTE_sort(st) SKM_sk_sort(X509_ATTRIBUTE, (st)) 1478 # define sk_X509_ATTRIBUTE_is_sorted(st) SKM_sk_is_sorted(X509_ATTRIBUTE, (st)) 1479 1480 # define sk_X509_CRL_new(st) SKM_sk_new(X509_CRL, (st)) 1481 # define sk_X509_CRL_new_null() SKM_sk_new_null(X509_CRL) 1482 # define sk_X509_CRL_free(st) SKM_sk_free(X509_CRL, (st)) 1483 # define sk_X509_CRL_num(st) SKM_sk_num(X509_CRL, (st)) 1484 # define sk_X509_CRL_value(st, i) SKM_sk_value(X509_CRL, (st), (i)) 1485 # define sk_X509_CRL_set(st, i, val) SKM_sk_set(X509_CRL, (st), (i), (val)) 1486 # define sk_X509_CRL_zero(st) SKM_sk_zero(X509_CRL, (st)) 1487 # define sk_X509_CRL_push(st, val) SKM_sk_push(X509_CRL, (st), (val)) 1488 # define sk_X509_CRL_unshift(st, val) SKM_sk_unshift(X509_CRL, (st), (val)) 1489 # define sk_X509_CRL_find(st, val) SKM_sk_find(X509_CRL, (st), (val)) 1490 # define sk_X509_CRL_find_ex(st, val) SKM_sk_find_ex(X509_CRL, (st), (val)) 1491 # define sk_X509_CRL_delete(st, i) SKM_sk_delete(X509_CRL, (st), (i)) 1492 # define sk_X509_CRL_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_CRL, (st), (ptr)) 1493 # define sk_X509_CRL_insert(st, val, i) SKM_sk_insert(X509_CRL, (st), (val), (i)) 1494 # define sk_X509_CRL_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_CRL, (st), (cmp)) 1495 # define sk_X509_CRL_dup(st) SKM_sk_dup(X509_CRL, st) 1496 # define sk_X509_CRL_pop_free(st, free_func) SKM_sk_pop_free(X509_CRL, (st), (free_func)) 1497 # define sk_X509_CRL_shift(st) SKM_sk_shift(X509_CRL, (st)) 1498 # define sk_X509_CRL_pop(st) SKM_sk_pop(X509_CRL, (st)) 1499 # define sk_X509_CRL_sort(st) SKM_sk_sort(X509_CRL, (st)) 1500 # define sk_X509_CRL_is_sorted(st) SKM_sk_is_sorted(X509_CRL, (st)) 1501 1502 # define sk_X509_EXTENSION_new(st) SKM_sk_new(X509_EXTENSION, (st)) 1503 # define sk_X509_EXTENSION_new_null() SKM_sk_new_null(X509_EXTENSION) 1504 # define sk_X509_EXTENSION_free(st) SKM_sk_free(X509_EXTENSION, (st)) 1505 # define sk_X509_EXTENSION_num(st) SKM_sk_num(X509_EXTENSION, (st)) 1506 # define sk_X509_EXTENSION_value(st, i) SKM_sk_value(X509_EXTENSION, (st), (i)) 1507 # define sk_X509_EXTENSION_set(st, i, val) SKM_sk_set(X509_EXTENSION, (st), (i), (val)) 1508 # define sk_X509_EXTENSION_zero(st) SKM_sk_zero(X509_EXTENSION, (st)) 1509 # define sk_X509_EXTENSION_push(st, val) SKM_sk_push(X509_EXTENSION, (st), (val)) 1510 # define sk_X509_EXTENSION_unshift(st, val) SKM_sk_unshift(X509_EXTENSION, (st), (val)) 1511 # define sk_X509_EXTENSION_find(st, val) SKM_sk_find(X509_EXTENSION, (st), (val)) 1512 # define sk_X509_EXTENSION_find_ex(st, val) SKM_sk_find_ex(X509_EXTENSION, (st), (val)) 1513 # define sk_X509_EXTENSION_delete(st, i) SKM_sk_delete(X509_EXTENSION, (st), (i)) 1514 # define sk_X509_EXTENSION_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_EXTENSION, (st), (ptr)) 1515 # define sk_X509_EXTENSION_insert(st, val, i) SKM_sk_insert(X509_EXTENSION, (st), (val), (i)) 1516 # define sk_X509_EXTENSION_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_EXTENSION, (st), (cmp)) 1517 # define sk_X509_EXTENSION_dup(st) SKM_sk_dup(X509_EXTENSION, st) 1518 # define sk_X509_EXTENSION_pop_free(st, free_func) SKM_sk_pop_free(X509_EXTENSION, (st), (free_func)) 1519 # define sk_X509_EXTENSION_shift(st) SKM_sk_shift(X509_EXTENSION, (st)) 1520 # define sk_X509_EXTENSION_pop(st) SKM_sk_pop(X509_EXTENSION, (st)) 1521 # define sk_X509_EXTENSION_sort(st) SKM_sk_sort(X509_EXTENSION, (st)) 1522 # define sk_X509_EXTENSION_is_sorted(st) SKM_sk_is_sorted(X509_EXTENSION, (st)) 1523 1524 # define sk_X509_INFO_new(st) SKM_sk_new(X509_INFO, (st)) 1525 # define sk_X509_INFO_new_null() SKM_sk_new_null(X509_INFO) 1526 # define sk_X509_INFO_free(st) SKM_sk_free(X509_INFO, (st)) 1527 # define sk_X509_INFO_num(st) SKM_sk_num(X509_INFO, (st)) 1528 # define sk_X509_INFO_value(st, i) SKM_sk_value(X509_INFO, (st), (i)) 1529 # define sk_X509_INFO_set(st, i, val) SKM_sk_set(X509_INFO, (st), (i), (val)) 1530 # define sk_X509_INFO_zero(st) SKM_sk_zero(X509_INFO, (st)) 1531 # define sk_X509_INFO_push(st, val) SKM_sk_push(X509_INFO, (st), (val)) 1532 # define sk_X509_INFO_unshift(st, val) SKM_sk_unshift(X509_INFO, (st), (val)) 1533 # define sk_X509_INFO_find(st, val) SKM_sk_find(X509_INFO, (st), (val)) 1534 # define sk_X509_INFO_find_ex(st, val) SKM_sk_find_ex(X509_INFO, (st), (val)) 1535 # define sk_X509_INFO_delete(st, i) SKM_sk_delete(X509_INFO, (st), (i)) 1536 # define sk_X509_INFO_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_INFO, (st), (ptr)) 1537 # define sk_X509_INFO_insert(st, val, i) SKM_sk_insert(X509_INFO, (st), (val), (i)) 1538 # define sk_X509_INFO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_INFO, (st), (cmp)) 1539 # define sk_X509_INFO_dup(st) SKM_sk_dup(X509_INFO, st) 1540 # define sk_X509_INFO_pop_free(st, free_func) SKM_sk_pop_free(X509_INFO, (st), (free_func)) 1541 # define sk_X509_INFO_shift(st) SKM_sk_shift(X509_INFO, (st)) 1542 # define sk_X509_INFO_pop(st) SKM_sk_pop(X509_INFO, (st)) 1543 # define sk_X509_INFO_sort(st) SKM_sk_sort(X509_INFO, (st)) 1544 # define sk_X509_INFO_is_sorted(st) SKM_sk_is_sorted(X509_INFO, (st)) 1545 1546 # define sk_X509_LOOKUP_new(st) SKM_sk_new(X509_LOOKUP, (st)) 1547 # define sk_X509_LOOKUP_new_null() SKM_sk_new_null(X509_LOOKUP) 1548 # define sk_X509_LOOKUP_free(st) SKM_sk_free(X509_LOOKUP, (st)) 1549 # define sk_X509_LOOKUP_num(st) SKM_sk_num(X509_LOOKUP, (st)) 1550 # define sk_X509_LOOKUP_value(st, i) SKM_sk_value(X509_LOOKUP, (st), (i)) 1551 # define sk_X509_LOOKUP_set(st, i, val) SKM_sk_set(X509_LOOKUP, (st), (i), (val)) 1552 # define sk_X509_LOOKUP_zero(st) SKM_sk_zero(X509_LOOKUP, (st)) 1553 # define sk_X509_LOOKUP_push(st, val) SKM_sk_push(X509_LOOKUP, (st), (val)) 1554 # define sk_X509_LOOKUP_unshift(st, val) SKM_sk_unshift(X509_LOOKUP, (st), (val)) 1555 # define sk_X509_LOOKUP_find(st, val) SKM_sk_find(X509_LOOKUP, (st), (val)) 1556 # define sk_X509_LOOKUP_find_ex(st, val) SKM_sk_find_ex(X509_LOOKUP, (st), (val)) 1557 # define sk_X509_LOOKUP_delete(st, i) SKM_sk_delete(X509_LOOKUP, (st), (i)) 1558 # define sk_X509_LOOKUP_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_LOOKUP, (st), (ptr)) 1559 # define sk_X509_LOOKUP_insert(st, val, i) SKM_sk_insert(X509_LOOKUP, (st), (val), (i)) 1560 # define sk_X509_LOOKUP_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_LOOKUP, (st), (cmp)) 1561 # define sk_X509_LOOKUP_dup(st) SKM_sk_dup(X509_LOOKUP, st) 1562 # define sk_X509_LOOKUP_pop_free(st, free_func) SKM_sk_pop_free(X509_LOOKUP, (st), (free_func)) 1563 # define sk_X509_LOOKUP_shift(st) SKM_sk_shift(X509_LOOKUP, (st)) 1564 # define sk_X509_LOOKUP_pop(st) SKM_sk_pop(X509_LOOKUP, (st)) 1565 # define sk_X509_LOOKUP_sort(st) SKM_sk_sort(X509_LOOKUP, (st)) 1566 # define sk_X509_LOOKUP_is_sorted(st) SKM_sk_is_sorted(X509_LOOKUP, (st)) 1567 1568 # define sk_X509_NAME_new(st) SKM_sk_new(X509_NAME, (st)) 1569 # define sk_X509_NAME_new_null() SKM_sk_new_null(X509_NAME) 1570 # define sk_X509_NAME_free(st) SKM_sk_free(X509_NAME, (st)) 1571 # define sk_X509_NAME_num(st) SKM_sk_num(X509_NAME, (st)) 1572 # define sk_X509_NAME_value(st, i) SKM_sk_value(X509_NAME, (st), (i)) 1573 # define sk_X509_NAME_set(st, i, val) SKM_sk_set(X509_NAME, (st), (i), (val)) 1574 # define sk_X509_NAME_zero(st) SKM_sk_zero(X509_NAME, (st)) 1575 # define sk_X509_NAME_push(st, val) SKM_sk_push(X509_NAME, (st), (val)) 1576 # define sk_X509_NAME_unshift(st, val) SKM_sk_unshift(X509_NAME, (st), (val)) 1577 # define sk_X509_NAME_find(st, val) SKM_sk_find(X509_NAME, (st), (val)) 1578 # define sk_X509_NAME_find_ex(st, val) SKM_sk_find_ex(X509_NAME, (st), (val)) 1579 # define sk_X509_NAME_delete(st, i) SKM_sk_delete(X509_NAME, (st), (i)) 1580 # define sk_X509_NAME_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_NAME, (st), (ptr)) 1581 # define sk_X509_NAME_insert(st, val, i) SKM_sk_insert(X509_NAME, (st), (val), (i)) 1582 # define sk_X509_NAME_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_NAME, (st), (cmp)) 1583 # define sk_X509_NAME_dup(st) SKM_sk_dup(X509_NAME, st) 1584 # define sk_X509_NAME_pop_free(st, free_func) SKM_sk_pop_free(X509_NAME, (st), (free_func)) 1585 # define sk_X509_NAME_shift(st) SKM_sk_shift(X509_NAME, (st)) 1586 # define sk_X509_NAME_pop(st) SKM_sk_pop(X509_NAME, (st)) 1587 # define sk_X509_NAME_sort(st) SKM_sk_sort(X509_NAME, (st)) 1588 # define sk_X509_NAME_is_sorted(st) SKM_sk_is_sorted(X509_NAME, (st)) 1589 1590 # define sk_X509_NAME_ENTRY_new(st) SKM_sk_new(X509_NAME_ENTRY, (st)) 1591 # define sk_X509_NAME_ENTRY_new_null() SKM_sk_new_null(X509_NAME_ENTRY) 1592 # define sk_X509_NAME_ENTRY_free(st) SKM_sk_free(X509_NAME_ENTRY, (st)) 1593 # define sk_X509_NAME_ENTRY_num(st) SKM_sk_num(X509_NAME_ENTRY, (st)) 1594 # define sk_X509_NAME_ENTRY_value(st, i) SKM_sk_value(X509_NAME_ENTRY, (st), (i)) 1595 # define sk_X509_NAME_ENTRY_set(st, i, val) SKM_sk_set(X509_NAME_ENTRY, (st), (i), (val)) 1596 # define sk_X509_NAME_ENTRY_zero(st) SKM_sk_zero(X509_NAME_ENTRY, (st)) 1597 # define sk_X509_NAME_ENTRY_push(st, val) SKM_sk_push(X509_NAME_ENTRY, (st), (val)) 1598 # define sk_X509_NAME_ENTRY_unshift(st, val) SKM_sk_unshift(X509_NAME_ENTRY, (st), (val)) 1599 # define sk_X509_NAME_ENTRY_find(st, val) SKM_sk_find(X509_NAME_ENTRY, (st), (val)) 1600 # define sk_X509_NAME_ENTRY_find_ex(st, val) SKM_sk_find_ex(X509_NAME_ENTRY, (st), (val)) 1601 # define sk_X509_NAME_ENTRY_delete(st, i) SKM_sk_delete(X509_NAME_ENTRY, (st), (i)) 1602 # define sk_X509_NAME_ENTRY_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_NAME_ENTRY, (st), (ptr)) 1603 # define sk_X509_NAME_ENTRY_insert(st, val, i) SKM_sk_insert(X509_NAME_ENTRY, (st), (val), (i)) 1604 # define sk_X509_NAME_ENTRY_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_NAME_ENTRY, (st), (cmp)) 1605 # define sk_X509_NAME_ENTRY_dup(st) SKM_sk_dup(X509_NAME_ENTRY, st) 1606 # define sk_X509_NAME_ENTRY_pop_free(st, free_func) SKM_sk_pop_free(X509_NAME_ENTRY, (st), (free_func)) 1607 # define sk_X509_NAME_ENTRY_shift(st) SKM_sk_shift(X509_NAME_ENTRY, (st)) 1608 # define sk_X509_NAME_ENTRY_pop(st) SKM_sk_pop(X509_NAME_ENTRY, (st)) 1609 # define sk_X509_NAME_ENTRY_sort(st) SKM_sk_sort(X509_NAME_ENTRY, (st)) 1610 # define sk_X509_NAME_ENTRY_is_sorted(st) SKM_sk_is_sorted(X509_NAME_ENTRY, (st)) 1611 1612 # define sk_X509_OBJECT_new(st) SKM_sk_new(X509_OBJECT, (st)) 1613 # define sk_X509_OBJECT_new_null() SKM_sk_new_null(X509_OBJECT) 1614 # define sk_X509_OBJECT_free(st) SKM_sk_free(X509_OBJECT, (st)) 1615 # define sk_X509_OBJECT_num(st) SKM_sk_num(X509_OBJECT, (st)) 1616 # define sk_X509_OBJECT_value(st, i) SKM_sk_value(X509_OBJECT, (st), (i)) 1617 # define sk_X509_OBJECT_set(st, i, val) SKM_sk_set(X509_OBJECT, (st), (i), (val)) 1618 # define sk_X509_OBJECT_zero(st) SKM_sk_zero(X509_OBJECT, (st)) 1619 # define sk_X509_OBJECT_push(st, val) SKM_sk_push(X509_OBJECT, (st), (val)) 1620 # define sk_X509_OBJECT_unshift(st, val) SKM_sk_unshift(X509_OBJECT, (st), (val)) 1621 # define sk_X509_OBJECT_find(st, val) SKM_sk_find(X509_OBJECT, (st), (val)) 1622 # define sk_X509_OBJECT_find_ex(st, val) SKM_sk_find_ex(X509_OBJECT, (st), (val)) 1623 # define sk_X509_OBJECT_delete(st, i) SKM_sk_delete(X509_OBJECT, (st), (i)) 1624 # define sk_X509_OBJECT_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_OBJECT, (st), (ptr)) 1625 # define sk_X509_OBJECT_insert(st, val, i) SKM_sk_insert(X509_OBJECT, (st), (val), (i)) 1626 # define sk_X509_OBJECT_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_OBJECT, (st), (cmp)) 1627 # define sk_X509_OBJECT_dup(st) SKM_sk_dup(X509_OBJECT, st) 1628 # define sk_X509_OBJECT_pop_free(st, free_func) SKM_sk_pop_free(X509_OBJECT, (st), (free_func)) 1629 # define sk_X509_OBJECT_shift(st) SKM_sk_shift(X509_OBJECT, (st)) 1630 # define sk_X509_OBJECT_pop(st) SKM_sk_pop(X509_OBJECT, (st)) 1631 # define sk_X509_OBJECT_sort(st) SKM_sk_sort(X509_OBJECT, (st)) 1632 # define sk_X509_OBJECT_is_sorted(st) SKM_sk_is_sorted(X509_OBJECT, (st)) 1633 1634 # define sk_X509_POLICY_DATA_new(st) SKM_sk_new(X509_POLICY_DATA, (st)) 1635 # define sk_X509_POLICY_DATA_new_null() SKM_sk_new_null(X509_POLICY_DATA) 1636 # define sk_X509_POLICY_DATA_free(st) SKM_sk_free(X509_POLICY_DATA, (st)) 1637 # define sk_X509_POLICY_DATA_num(st) SKM_sk_num(X509_POLICY_DATA, (st)) 1638 # define sk_X509_POLICY_DATA_value(st, i) SKM_sk_value(X509_POLICY_DATA, (st), (i)) 1639 # define sk_X509_POLICY_DATA_set(st, i, val) SKM_sk_set(X509_POLICY_DATA, (st), (i), (val)) 1640 # define sk_X509_POLICY_DATA_zero(st) SKM_sk_zero(X509_POLICY_DATA, (st)) 1641 # define sk_X509_POLICY_DATA_push(st, val) SKM_sk_push(X509_POLICY_DATA, (st), (val)) 1642 # define sk_X509_POLICY_DATA_unshift(st, val) SKM_sk_unshift(X509_POLICY_DATA, (st), (val)) 1643 # define sk_X509_POLICY_DATA_find(st, val) SKM_sk_find(X509_POLICY_DATA, (st), (val)) 1644 # define sk_X509_POLICY_DATA_find_ex(st, val) SKM_sk_find_ex(X509_POLICY_DATA, (st), (val)) 1645 # define sk_X509_POLICY_DATA_delete(st, i) SKM_sk_delete(X509_POLICY_DATA, (st), (i)) 1646 # define sk_X509_POLICY_DATA_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_POLICY_DATA, (st), (ptr)) 1647 # define sk_X509_POLICY_DATA_insert(st, val, i) SKM_sk_insert(X509_POLICY_DATA, (st), (val), (i)) 1648 # define sk_X509_POLICY_DATA_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_POLICY_DATA, (st), (cmp)) 1649 # define sk_X509_POLICY_DATA_dup(st) SKM_sk_dup(X509_POLICY_DATA, st) 1650 # define sk_X509_POLICY_DATA_pop_free(st, free_func) SKM_sk_pop_free(X509_POLICY_DATA, (st), (free_func)) 1651 # define sk_X509_POLICY_DATA_shift(st) SKM_sk_shift(X509_POLICY_DATA, (st)) 1652 # define sk_X509_POLICY_DATA_pop(st) SKM_sk_pop(X509_POLICY_DATA, (st)) 1653 # define sk_X509_POLICY_DATA_sort(st) SKM_sk_sort(X509_POLICY_DATA, (st)) 1654 # define sk_X509_POLICY_DATA_is_sorted(st) SKM_sk_is_sorted(X509_POLICY_DATA, (st)) 1655 1656 # define sk_X509_POLICY_NODE_new(st) SKM_sk_new(X509_POLICY_NODE, (st)) 1657 # define sk_X509_POLICY_NODE_new_null() SKM_sk_new_null(X509_POLICY_NODE) 1658 # define sk_X509_POLICY_NODE_free(st) SKM_sk_free(X509_POLICY_NODE, (st)) 1659 # define sk_X509_POLICY_NODE_num(st) SKM_sk_num(X509_POLICY_NODE, (st)) 1660 # define sk_X509_POLICY_NODE_value(st, i) SKM_sk_value(X509_POLICY_NODE, (st), (i)) 1661 # define sk_X509_POLICY_NODE_set(st, i, val) SKM_sk_set(X509_POLICY_NODE, (st), (i), (val)) 1662 # define sk_X509_POLICY_NODE_zero(st) SKM_sk_zero(X509_POLICY_NODE, (st)) 1663 # define sk_X509_POLICY_NODE_push(st, val) SKM_sk_push(X509_POLICY_NODE, (st), (val)) 1664 # define sk_X509_POLICY_NODE_unshift(st, val) SKM_sk_unshift(X509_POLICY_NODE, (st), (val)) 1665 # define sk_X509_POLICY_NODE_find(st, val) SKM_sk_find(X509_POLICY_NODE, (st), (val)) 1666 # define sk_X509_POLICY_NODE_find_ex(st, val) SKM_sk_find_ex(X509_POLICY_NODE, (st), (val)) 1667 # define sk_X509_POLICY_NODE_delete(st, i) SKM_sk_delete(X509_POLICY_NODE, (st), (i)) 1668 # define sk_X509_POLICY_NODE_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_POLICY_NODE, (st), (ptr)) 1669 # define sk_X509_POLICY_NODE_insert(st, val, i) SKM_sk_insert(X509_POLICY_NODE, (st), (val), (i)) 1670 # define sk_X509_POLICY_NODE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_POLICY_NODE, (st), (cmp)) 1671 # define sk_X509_POLICY_NODE_dup(st) SKM_sk_dup(X509_POLICY_NODE, st) 1672 # define sk_X509_POLICY_NODE_pop_free(st, free_func) SKM_sk_pop_free(X509_POLICY_NODE, (st), (free_func)) 1673 # define sk_X509_POLICY_NODE_shift(st) SKM_sk_shift(X509_POLICY_NODE, (st)) 1674 # define sk_X509_POLICY_NODE_pop(st) SKM_sk_pop(X509_POLICY_NODE, (st)) 1675 # define sk_X509_POLICY_NODE_sort(st) SKM_sk_sort(X509_POLICY_NODE, (st)) 1676 # define sk_X509_POLICY_NODE_is_sorted(st) SKM_sk_is_sorted(X509_POLICY_NODE, (st)) 1677 1678 # define sk_X509_POLICY_REF_new(st) SKM_sk_new(X509_POLICY_REF, (st)) 1679 # define sk_X509_POLICY_REF_new_null() SKM_sk_new_null(X509_POLICY_REF) 1680 # define sk_X509_POLICY_REF_free(st) SKM_sk_free(X509_POLICY_REF, (st)) 1681 # define sk_X509_POLICY_REF_num(st) SKM_sk_num(X509_POLICY_REF, (st)) 1682 # define sk_X509_POLICY_REF_value(st, i) SKM_sk_value(X509_POLICY_REF, (st), (i)) 1683 # define sk_X509_POLICY_REF_set(st, i, val) SKM_sk_set(X509_POLICY_REF, (st), (i), (val)) 1684 # define sk_X509_POLICY_REF_zero(st) SKM_sk_zero(X509_POLICY_REF, (st)) 1685 # define sk_X509_POLICY_REF_push(st, val) SKM_sk_push(X509_POLICY_REF, (st), (val)) 1686 # define sk_X509_POLICY_REF_unshift(st, val) SKM_sk_unshift(X509_POLICY_REF, (st), (val)) 1687 # define sk_X509_POLICY_REF_find(st, val) SKM_sk_find(X509_POLICY_REF, (st), (val)) 1688 # define sk_X509_POLICY_REF_find_ex(st, val) SKM_sk_find_ex(X509_POLICY_REF, (st), (val)) 1689 # define sk_X509_POLICY_REF_delete(st, i) SKM_sk_delete(X509_POLICY_REF, (st), (i)) 1690 # define sk_X509_POLICY_REF_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_POLICY_REF, (st), (ptr)) 1691 # define sk_X509_POLICY_REF_insert(st, val, i) SKM_sk_insert(X509_POLICY_REF, (st), (val), (i)) 1692 # define sk_X509_POLICY_REF_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_POLICY_REF, (st), (cmp)) 1693 # define sk_X509_POLICY_REF_dup(st) SKM_sk_dup(X509_POLICY_REF, st) 1694 # define sk_X509_POLICY_REF_pop_free(st, free_func) SKM_sk_pop_free(X509_POLICY_REF, (st), (free_func)) 1695 # define sk_X509_POLICY_REF_shift(st) SKM_sk_shift(X509_POLICY_REF, (st)) 1696 # define sk_X509_POLICY_REF_pop(st) SKM_sk_pop(X509_POLICY_REF, (st)) 1697 # define sk_X509_POLICY_REF_sort(st) SKM_sk_sort(X509_POLICY_REF, (st)) 1698 # define sk_X509_POLICY_REF_is_sorted(st) SKM_sk_is_sorted(X509_POLICY_REF, (st)) 1699 1700 # define sk_X509_PURPOSE_new(st) SKM_sk_new(X509_PURPOSE, (st)) 1701 # define sk_X509_PURPOSE_new_null() SKM_sk_new_null(X509_PURPOSE) 1702 # define sk_X509_PURPOSE_free(st) SKM_sk_free(X509_PURPOSE, (st)) 1703 # define sk_X509_PURPOSE_num(st) SKM_sk_num(X509_PURPOSE, (st)) 1704 # define sk_X509_PURPOSE_value(st, i) SKM_sk_value(X509_PURPOSE, (st), (i)) 1705 # define sk_X509_PURPOSE_set(st, i, val) SKM_sk_set(X509_PURPOSE, (st), (i), (val)) 1706 # define sk_X509_PURPOSE_zero(st) SKM_sk_zero(X509_PURPOSE, (st)) 1707 # define sk_X509_PURPOSE_push(st, val) SKM_sk_push(X509_PURPOSE, (st), (val)) 1708 # define sk_X509_PURPOSE_unshift(st, val) SKM_sk_unshift(X509_PURPOSE, (st), (val)) 1709 # define sk_X509_PURPOSE_find(st, val) SKM_sk_find(X509_PURPOSE, (st), (val)) 1710 # define sk_X509_PURPOSE_find_ex(st, val) SKM_sk_find_ex(X509_PURPOSE, (st), (val)) 1711 # define sk_X509_PURPOSE_delete(st, i) SKM_sk_delete(X509_PURPOSE, (st), (i)) 1712 # define sk_X509_PURPOSE_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_PURPOSE, (st), (ptr)) 1713 # define sk_X509_PURPOSE_insert(st, val, i) SKM_sk_insert(X509_PURPOSE, (st), (val), (i)) 1714 # define sk_X509_PURPOSE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_PURPOSE, (st), (cmp)) 1715 # define sk_X509_PURPOSE_dup(st) SKM_sk_dup(X509_PURPOSE, st) 1716 # define sk_X509_PURPOSE_pop_free(st, free_func) SKM_sk_pop_free(X509_PURPOSE, (st), (free_func)) 1717 # define sk_X509_PURPOSE_shift(st) SKM_sk_shift(X509_PURPOSE, (st)) 1718 # define sk_X509_PURPOSE_pop(st) SKM_sk_pop(X509_PURPOSE, (st)) 1719 # define sk_X509_PURPOSE_sort(st) SKM_sk_sort(X509_PURPOSE, (st)) 1720 # define sk_X509_PURPOSE_is_sorted(st) SKM_sk_is_sorted(X509_PURPOSE, (st)) 1721 1722 # define sk_X509_REVOKED_new(st) SKM_sk_new(X509_REVOKED, (st)) 1723 # define sk_X509_REVOKED_new_null() SKM_sk_new_null(X509_REVOKED) 1724 # define sk_X509_REVOKED_free(st) SKM_sk_free(X509_REVOKED, (st)) 1725 # define sk_X509_REVOKED_num(st) SKM_sk_num(X509_REVOKED, (st)) 1726 # define sk_X509_REVOKED_value(st, i) SKM_sk_value(X509_REVOKED, (st), (i)) 1727 # define sk_X509_REVOKED_set(st, i, val) SKM_sk_set(X509_REVOKED, (st), (i), (val)) 1728 # define sk_X509_REVOKED_zero(st) SKM_sk_zero(X509_REVOKED, (st)) 1729 # define sk_X509_REVOKED_push(st, val) SKM_sk_push(X509_REVOKED, (st), (val)) 1730 # define sk_X509_REVOKED_unshift(st, val) SKM_sk_unshift(X509_REVOKED, (st), (val)) 1731 # define sk_X509_REVOKED_find(st, val) SKM_sk_find(X509_REVOKED, (st), (val)) 1732 # define sk_X509_REVOKED_find_ex(st, val) SKM_sk_find_ex(X509_REVOKED, (st), (val)) 1733 # define sk_X509_REVOKED_delete(st, i) SKM_sk_delete(X509_REVOKED, (st), (i)) 1734 # define sk_X509_REVOKED_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_REVOKED, (st), (ptr)) 1735 # define sk_X509_REVOKED_insert(st, val, i) SKM_sk_insert(X509_REVOKED, (st), (val), (i)) 1736 # define sk_X509_REVOKED_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_REVOKED, (st), (cmp)) 1737 # define sk_X509_REVOKED_dup(st) SKM_sk_dup(X509_REVOKED, st) 1738 # define sk_X509_REVOKED_pop_free(st, free_func) SKM_sk_pop_free(X509_REVOKED, (st), (free_func)) 1739 # define sk_X509_REVOKED_shift(st) SKM_sk_shift(X509_REVOKED, (st)) 1740 # define sk_X509_REVOKED_pop(st) SKM_sk_pop(X509_REVOKED, (st)) 1741 # define sk_X509_REVOKED_sort(st) SKM_sk_sort(X509_REVOKED, (st)) 1742 # define sk_X509_REVOKED_is_sorted(st) SKM_sk_is_sorted(X509_REVOKED, (st)) 1743 1744 # define sk_X509_TRUST_new(st) SKM_sk_new(X509_TRUST, (st)) 1745 # define sk_X509_TRUST_new_null() SKM_sk_new_null(X509_TRUST) 1746 # define sk_X509_TRUST_free(st) SKM_sk_free(X509_TRUST, (st)) 1747 # define sk_X509_TRUST_num(st) SKM_sk_num(X509_TRUST, (st)) 1748 # define sk_X509_TRUST_value(st, i) SKM_sk_value(X509_TRUST, (st), (i)) 1749 # define sk_X509_TRUST_set(st, i, val) SKM_sk_set(X509_TRUST, (st), (i), (val)) 1750 # define sk_X509_TRUST_zero(st) SKM_sk_zero(X509_TRUST, (st)) 1751 # define sk_X509_TRUST_push(st, val) SKM_sk_push(X509_TRUST, (st), (val)) 1752 # define sk_X509_TRUST_unshift(st, val) SKM_sk_unshift(X509_TRUST, (st), (val)) 1753 # define sk_X509_TRUST_find(st, val) SKM_sk_find(X509_TRUST, (st), (val)) 1754 # define sk_X509_TRUST_find_ex(st, val) SKM_sk_find_ex(X509_TRUST, (st), (val)) 1755 # define sk_X509_TRUST_delete(st, i) SKM_sk_delete(X509_TRUST, (st), (i)) 1756 # define sk_X509_TRUST_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_TRUST, (st), (ptr)) 1757 # define sk_X509_TRUST_insert(st, val, i) SKM_sk_insert(X509_TRUST, (st), (val), (i)) 1758 # define sk_X509_TRUST_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_TRUST, (st), (cmp)) 1759 # define sk_X509_TRUST_dup(st) SKM_sk_dup(X509_TRUST, st) 1760 # define sk_X509_TRUST_pop_free(st, free_func) SKM_sk_pop_free(X509_TRUST, (st), (free_func)) 1761 # define sk_X509_TRUST_shift(st) SKM_sk_shift(X509_TRUST, (st)) 1762 # define sk_X509_TRUST_pop(st) SKM_sk_pop(X509_TRUST, (st)) 1763 # define sk_X509_TRUST_sort(st) SKM_sk_sort(X509_TRUST, (st)) 1764 # define sk_X509_TRUST_is_sorted(st) SKM_sk_is_sorted(X509_TRUST, (st)) 1765 1766 # define sk_X509_VERIFY_PARAM_new(st) SKM_sk_new(X509_VERIFY_PARAM, (st)) 1767 # define sk_X509_VERIFY_PARAM_new_null() SKM_sk_new_null(X509_VERIFY_PARAM) 1768 # define sk_X509_VERIFY_PARAM_free(st) SKM_sk_free(X509_VERIFY_PARAM, (st)) 1769 # define sk_X509_VERIFY_PARAM_num(st) SKM_sk_num(X509_VERIFY_PARAM, (st)) 1770 # define sk_X509_VERIFY_PARAM_value(st, i) SKM_sk_value(X509_VERIFY_PARAM, (st), (i)) 1771 # define sk_X509_VERIFY_PARAM_set(st, i, val) SKM_sk_set(X509_VERIFY_PARAM, (st), (i), (val)) 1772 # define sk_X509_VERIFY_PARAM_zero(st) SKM_sk_zero(X509_VERIFY_PARAM, (st)) 1773 # define sk_X509_VERIFY_PARAM_push(st, val) SKM_sk_push(X509_VERIFY_PARAM, (st), (val)) 1774 # define sk_X509_VERIFY_PARAM_unshift(st, val) SKM_sk_unshift(X509_VERIFY_PARAM, (st), (val)) 1775 # define sk_X509_VERIFY_PARAM_find(st, val) SKM_sk_find(X509_VERIFY_PARAM, (st), (val)) 1776 # define sk_X509_VERIFY_PARAM_find_ex(st, val) SKM_sk_find_ex(X509_VERIFY_PARAM, (st), (val)) 1777 # define sk_X509_VERIFY_PARAM_delete(st, i) SKM_sk_delete(X509_VERIFY_PARAM, (st), (i)) 1778 # define sk_X509_VERIFY_PARAM_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_VERIFY_PARAM, (st), (ptr)) 1779 # define sk_X509_VERIFY_PARAM_insert(st, val, i) SKM_sk_insert(X509_VERIFY_PARAM, (st), (val), (i)) 1780 # define sk_X509_VERIFY_PARAM_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_VERIFY_PARAM, (st), (cmp)) 1781 # define sk_X509_VERIFY_PARAM_dup(st) SKM_sk_dup(X509_VERIFY_PARAM, st) 1782 # define sk_X509_VERIFY_PARAM_pop_free(st, free_func) SKM_sk_pop_free(X509_VERIFY_PARAM, (st), (free_func)) 1783 # define sk_X509_VERIFY_PARAM_shift(st) SKM_sk_shift(X509_VERIFY_PARAM, (st)) 1784 # define sk_X509_VERIFY_PARAM_pop(st) SKM_sk_pop(X509_VERIFY_PARAM, (st)) 1785 # define sk_X509_VERIFY_PARAM_sort(st) SKM_sk_sort(X509_VERIFY_PARAM, (st)) 1786 # define sk_X509_VERIFY_PARAM_is_sorted(st) SKM_sk_is_sorted(X509_VERIFY_PARAM, (st)) 1787 1788 # define d2i_ASN1_SET_OF_ACCESS_DESCRIPTION(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1789 SKM_ASN1_SET_OF_d2i(ACCESS_DESCRIPTION, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1790 # define i2d_ASN1_SET_OF_ACCESS_DESCRIPTION(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1791 SKM_ASN1_SET_OF_i2d(ACCESS_DESCRIPTION, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1792 # define ASN1_seq_pack_ACCESS_DESCRIPTION(st, i2d_func, buf, len) \ 1793 SKM_ASN1_seq_pack(ACCESS_DESCRIPTION, (st), (i2d_func), (buf), (len)) 1794 # define ASN1_seq_unpack_ACCESS_DESCRIPTION(buf, len, d2i_func, free_func) \ 1795 SKM_ASN1_seq_unpack(ACCESS_DESCRIPTION, (buf), (len), (d2i_func), (free_func)) 1796 1797 # define d2i_ASN1_SET_OF_ASN1_INTEGER(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1798 SKM_ASN1_SET_OF_d2i(ASN1_INTEGER, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1799 # define i2d_ASN1_SET_OF_ASN1_INTEGER(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1800 SKM_ASN1_SET_OF_i2d(ASN1_INTEGER, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1801 # define ASN1_seq_pack_ASN1_INTEGER(st, i2d_func, buf, len) \ 1802 SKM_ASN1_seq_pack(ASN1_INTEGER, (st), (i2d_func), (buf), (len)) 1803 # define ASN1_seq_unpack_ASN1_INTEGER(buf, len, d2i_func, free_func) \ 1804 SKM_ASN1_seq_unpack(ASN1_INTEGER, (buf), (len), (d2i_func), (free_func)) 1805 1806 # define d2i_ASN1_SET_OF_ASN1_OBJECT(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1807 SKM_ASN1_SET_OF_d2i(ASN1_OBJECT, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1808 # define i2d_ASN1_SET_OF_ASN1_OBJECT(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1809 SKM_ASN1_SET_OF_i2d(ASN1_OBJECT, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1810 # define ASN1_seq_pack_ASN1_OBJECT(st, i2d_func, buf, len) \ 1811 SKM_ASN1_seq_pack(ASN1_OBJECT, (st), (i2d_func), (buf), (len)) 1812 # define ASN1_seq_unpack_ASN1_OBJECT(buf, len, d2i_func, free_func) \ 1813 SKM_ASN1_seq_unpack(ASN1_OBJECT, (buf), (len), (d2i_func), (free_func)) 1814 1815 # define d2i_ASN1_SET_OF_ASN1_TYPE(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1816 SKM_ASN1_SET_OF_d2i(ASN1_TYPE, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1817 # define i2d_ASN1_SET_OF_ASN1_TYPE(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1818 SKM_ASN1_SET_OF_i2d(ASN1_TYPE, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1819 # define ASN1_seq_pack_ASN1_TYPE(st, i2d_func, buf, len) \ 1820 SKM_ASN1_seq_pack(ASN1_TYPE, (st), (i2d_func), (buf), (len)) 1821 # define ASN1_seq_unpack_ASN1_TYPE(buf, len, d2i_func, free_func) \ 1822 SKM_ASN1_seq_unpack(ASN1_TYPE, (buf), (len), (d2i_func), (free_func)) 1823 1824 # define d2i_ASN1_SET_OF_DIST_POINT(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1825 SKM_ASN1_SET_OF_d2i(DIST_POINT, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1826 # define i2d_ASN1_SET_OF_DIST_POINT(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1827 SKM_ASN1_SET_OF_i2d(DIST_POINT, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1828 # define ASN1_seq_pack_DIST_POINT(st, i2d_func, buf, len) \ 1829 SKM_ASN1_seq_pack(DIST_POINT, (st), (i2d_func), (buf), (len)) 1830 # define ASN1_seq_unpack_DIST_POINT(buf, len, d2i_func, free_func) \ 1831 SKM_ASN1_seq_unpack(DIST_POINT, (buf), (len), (d2i_func), (free_func)) 1832 1833 # define d2i_ASN1_SET_OF_GENERAL_NAME(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1834 SKM_ASN1_SET_OF_d2i(GENERAL_NAME, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1835 # define i2d_ASN1_SET_OF_GENERAL_NAME(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1836 SKM_ASN1_SET_OF_i2d(GENERAL_NAME, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1837 # define ASN1_seq_pack_GENERAL_NAME(st, i2d_func, buf, len) \ 1838 SKM_ASN1_seq_pack(GENERAL_NAME, (st), (i2d_func), (buf), (len)) 1839 # define ASN1_seq_unpack_GENERAL_NAME(buf, len, d2i_func, free_func) \ 1840 SKM_ASN1_seq_unpack(GENERAL_NAME, (buf), (len), (d2i_func), (free_func)) 1841 1842 # define d2i_ASN1_SET_OF_OCSP_ONEREQ(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1843 SKM_ASN1_SET_OF_d2i(OCSP_ONEREQ, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1844 # define i2d_ASN1_SET_OF_OCSP_ONEREQ(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1845 SKM_ASN1_SET_OF_i2d(OCSP_ONEREQ, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1846 # define ASN1_seq_pack_OCSP_ONEREQ(st, i2d_func, buf, len) \ 1847 SKM_ASN1_seq_pack(OCSP_ONEREQ, (st), (i2d_func), (buf), (len)) 1848 # define ASN1_seq_unpack_OCSP_ONEREQ(buf, len, d2i_func, free_func) \ 1849 SKM_ASN1_seq_unpack(OCSP_ONEREQ, (buf), (len), (d2i_func), (free_func)) 1850 1851 # define d2i_ASN1_SET_OF_OCSP_SINGLERESP(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1852 SKM_ASN1_SET_OF_d2i(OCSP_SINGLERESP, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1853 # define i2d_ASN1_SET_OF_OCSP_SINGLERESP(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1854 SKM_ASN1_SET_OF_i2d(OCSP_SINGLERESP, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1855 # define ASN1_seq_pack_OCSP_SINGLERESP(st, i2d_func, buf, len) \ 1856 SKM_ASN1_seq_pack(OCSP_SINGLERESP, (st), (i2d_func), (buf), (len)) 1857 # define ASN1_seq_unpack_OCSP_SINGLERESP(buf, len, d2i_func, free_func) \ 1858 SKM_ASN1_seq_unpack(OCSP_SINGLERESP, (buf), (len), (d2i_func), (free_func)) 1859 1860 # define d2i_ASN1_SET_OF_PKCS12_SAFEBAG(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1861 SKM_ASN1_SET_OF_d2i(PKCS12_SAFEBAG, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1862 # define i2d_ASN1_SET_OF_PKCS12_SAFEBAG(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1863 SKM_ASN1_SET_OF_i2d(PKCS12_SAFEBAG, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1864 # define ASN1_seq_pack_PKCS12_SAFEBAG(st, i2d_func, buf, len) \ 1865 SKM_ASN1_seq_pack(PKCS12_SAFEBAG, (st), (i2d_func), (buf), (len)) 1866 # define ASN1_seq_unpack_PKCS12_SAFEBAG(buf, len, d2i_func, free_func) \ 1867 SKM_ASN1_seq_unpack(PKCS12_SAFEBAG, (buf), (len), (d2i_func), (free_func)) 1868 1869 # define d2i_ASN1_SET_OF_PKCS7(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1870 SKM_ASN1_SET_OF_d2i(PKCS7, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1871 # define i2d_ASN1_SET_OF_PKCS7(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1872 SKM_ASN1_SET_OF_i2d(PKCS7, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1873 # define ASN1_seq_pack_PKCS7(st, i2d_func, buf, len) \ 1874 SKM_ASN1_seq_pack(PKCS7, (st), (i2d_func), (buf), (len)) 1875 # define ASN1_seq_unpack_PKCS7(buf, len, d2i_func, free_func) \ 1876 SKM_ASN1_seq_unpack(PKCS7, (buf), (len), (d2i_func), (free_func)) 1877 1878 # define d2i_ASN1_SET_OF_PKCS7_RECIP_INFO(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1879 SKM_ASN1_SET_OF_d2i(PKCS7_RECIP_INFO, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1880 # define i2d_ASN1_SET_OF_PKCS7_RECIP_INFO(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1881 SKM_ASN1_SET_OF_i2d(PKCS7_RECIP_INFO, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1882 # define ASN1_seq_pack_PKCS7_RECIP_INFO(st, i2d_func, buf, len) \ 1883 SKM_ASN1_seq_pack(PKCS7_RECIP_INFO, (st), (i2d_func), (buf), (len)) 1884 # define ASN1_seq_unpack_PKCS7_RECIP_INFO(buf, len, d2i_func, free_func) \ 1885 SKM_ASN1_seq_unpack(PKCS7_RECIP_INFO, (buf), (len), (d2i_func), (free_func)) 1886 1887 # define d2i_ASN1_SET_OF_PKCS7_SIGNER_INFO(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1888 SKM_ASN1_SET_OF_d2i(PKCS7_SIGNER_INFO, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1889 # define i2d_ASN1_SET_OF_PKCS7_SIGNER_INFO(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1890 SKM_ASN1_SET_OF_i2d(PKCS7_SIGNER_INFO, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1891 # define ASN1_seq_pack_PKCS7_SIGNER_INFO(st, i2d_func, buf, len) \ 1892 SKM_ASN1_seq_pack(PKCS7_SIGNER_INFO, (st), (i2d_func), (buf), (len)) 1893 # define ASN1_seq_unpack_PKCS7_SIGNER_INFO(buf, len, d2i_func, free_func) \ 1894 SKM_ASN1_seq_unpack(PKCS7_SIGNER_INFO, (buf), (len), (d2i_func), (free_func)) 1895 1896 # define d2i_ASN1_SET_OF_POLICYINFO(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1897 SKM_ASN1_SET_OF_d2i(POLICYINFO, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1898 # define i2d_ASN1_SET_OF_POLICYINFO(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1899 SKM_ASN1_SET_OF_i2d(POLICYINFO, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1900 # define ASN1_seq_pack_POLICYINFO(st, i2d_func, buf, len) \ 1901 SKM_ASN1_seq_pack(POLICYINFO, (st), (i2d_func), (buf), (len)) 1902 # define ASN1_seq_unpack_POLICYINFO(buf, len, d2i_func, free_func) \ 1903 SKM_ASN1_seq_unpack(POLICYINFO, (buf), (len), (d2i_func), (free_func)) 1904 1905 # define d2i_ASN1_SET_OF_POLICYQUALINFO(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1906 SKM_ASN1_SET_OF_d2i(POLICYQUALINFO, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1907 # define i2d_ASN1_SET_OF_POLICYQUALINFO(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1908 SKM_ASN1_SET_OF_i2d(POLICYQUALINFO, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1909 # define ASN1_seq_pack_POLICYQUALINFO(st, i2d_func, buf, len) \ 1910 SKM_ASN1_seq_pack(POLICYQUALINFO, (st), (i2d_func), (buf), (len)) 1911 # define ASN1_seq_unpack_POLICYQUALINFO(buf, len, d2i_func, free_func) \ 1912 SKM_ASN1_seq_unpack(POLICYQUALINFO, (buf), (len), (d2i_func), (free_func)) 1913 1914 # define d2i_ASN1_SET_OF_SXNETID(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1915 SKM_ASN1_SET_OF_d2i(SXNETID, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1916 # define i2d_ASN1_SET_OF_SXNETID(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1917 SKM_ASN1_SET_OF_i2d(SXNETID, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1918 # define ASN1_seq_pack_SXNETID(st, i2d_func, buf, len) \ 1919 SKM_ASN1_seq_pack(SXNETID, (st), (i2d_func), (buf), (len)) 1920 # define ASN1_seq_unpack_SXNETID(buf, len, d2i_func, free_func) \ 1921 SKM_ASN1_seq_unpack(SXNETID, (buf), (len), (d2i_func), (free_func)) 1922 1923 # define d2i_ASN1_SET_OF_X509(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1924 SKM_ASN1_SET_OF_d2i(X509, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1925 # define i2d_ASN1_SET_OF_X509(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1926 SKM_ASN1_SET_OF_i2d(X509, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1927 # define ASN1_seq_pack_X509(st, i2d_func, buf, len) \ 1928 SKM_ASN1_seq_pack(X509, (st), (i2d_func), (buf), (len)) 1929 # define ASN1_seq_unpack_X509(buf, len, d2i_func, free_func) \ 1930 SKM_ASN1_seq_unpack(X509, (buf), (len), (d2i_func), (free_func)) 1931 1932 # define d2i_ASN1_SET_OF_X509_ALGOR(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1933 SKM_ASN1_SET_OF_d2i(X509_ALGOR, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1934 # define i2d_ASN1_SET_OF_X509_ALGOR(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1935 SKM_ASN1_SET_OF_i2d(X509_ALGOR, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1936 # define ASN1_seq_pack_X509_ALGOR(st, i2d_func, buf, len) \ 1937 SKM_ASN1_seq_pack(X509_ALGOR, (st), (i2d_func), (buf), (len)) 1938 # define ASN1_seq_unpack_X509_ALGOR(buf, len, d2i_func, free_func) \ 1939 SKM_ASN1_seq_unpack(X509_ALGOR, (buf), (len), (d2i_func), (free_func)) 1940 1941 # define d2i_ASN1_SET_OF_X509_ATTRIBUTE(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1942 SKM_ASN1_SET_OF_d2i(X509_ATTRIBUTE, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1943 # define i2d_ASN1_SET_OF_X509_ATTRIBUTE(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1944 SKM_ASN1_SET_OF_i2d(X509_ATTRIBUTE, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1945 # define ASN1_seq_pack_X509_ATTRIBUTE(st, i2d_func, buf, len) \ 1946 SKM_ASN1_seq_pack(X509_ATTRIBUTE, (st), (i2d_func), (buf), (len)) 1947 # define ASN1_seq_unpack_X509_ATTRIBUTE(buf, len, d2i_func, free_func) \ 1948 SKM_ASN1_seq_unpack(X509_ATTRIBUTE, (buf), (len), (d2i_func), (free_func)) 1949 1950 # define d2i_ASN1_SET_OF_X509_CRL(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1951 SKM_ASN1_SET_OF_d2i(X509_CRL, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1952 # define i2d_ASN1_SET_OF_X509_CRL(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1953 SKM_ASN1_SET_OF_i2d(X509_CRL, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1954 # define ASN1_seq_pack_X509_CRL(st, i2d_func, buf, len) \ 1955 SKM_ASN1_seq_pack(X509_CRL, (st), (i2d_func), (buf), (len)) 1956 # define ASN1_seq_unpack_X509_CRL(buf, len, d2i_func, free_func) \ 1957 SKM_ASN1_seq_unpack(X509_CRL, (buf), (len), (d2i_func), (free_func)) 1958 1959 # define d2i_ASN1_SET_OF_X509_EXTENSION(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1960 SKM_ASN1_SET_OF_d2i(X509_EXTENSION, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1961 # define i2d_ASN1_SET_OF_X509_EXTENSION(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1962 SKM_ASN1_SET_OF_i2d(X509_EXTENSION, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1963 # define ASN1_seq_pack_X509_EXTENSION(st, i2d_func, buf, len) \ 1964 SKM_ASN1_seq_pack(X509_EXTENSION, (st), (i2d_func), (buf), (len)) 1965 # define ASN1_seq_unpack_X509_EXTENSION(buf, len, d2i_func, free_func) \ 1966 SKM_ASN1_seq_unpack(X509_EXTENSION, (buf), (len), (d2i_func), (free_func)) 1967 1968 # define d2i_ASN1_SET_OF_X509_NAME_ENTRY(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1969 SKM_ASN1_SET_OF_d2i(X509_NAME_ENTRY, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1970 # define i2d_ASN1_SET_OF_X509_NAME_ENTRY(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1971 SKM_ASN1_SET_OF_i2d(X509_NAME_ENTRY, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1972 # define ASN1_seq_pack_X509_NAME_ENTRY(st, i2d_func, buf, len) \ 1973 SKM_ASN1_seq_pack(X509_NAME_ENTRY, (st), (i2d_func), (buf), (len)) 1974 # define ASN1_seq_unpack_X509_NAME_ENTRY(buf, len, d2i_func, free_func) \ 1975 SKM_ASN1_seq_unpack(X509_NAME_ENTRY, (buf), (len), (d2i_func), (free_func)) 1976 1977 # define d2i_ASN1_SET_OF_X509_REVOKED(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ 1978 SKM_ASN1_SET_OF_d2i(X509_REVOKED, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) 1979 # define i2d_ASN1_SET_OF_X509_REVOKED(st, pp, i2d_func, ex_tag, ex_class, is_set) \ 1980 SKM_ASN1_SET_OF_i2d(X509_REVOKED, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) 1981 # define ASN1_seq_pack_X509_REVOKED(st, i2d_func, buf, len) \ 1982 SKM_ASN1_seq_pack(X509_REVOKED, (st), (i2d_func), (buf), (len)) 1983 # define ASN1_seq_unpack_X509_REVOKED(buf, len, d2i_func, free_func) \ 1984 SKM_ASN1_seq_unpack(X509_REVOKED, (buf), (len), (d2i_func), (free_func)) 1985 1986 # define PKCS12_decrypt_d2i_PKCS12_SAFEBAG(algor, d2i_func, free_func, pass, passlen, oct, seq) \ 1987 SKM_PKCS12_decrypt_d2i(PKCS12_SAFEBAG, (algor), (d2i_func), (free_func), (pass), (passlen), (oct), (seq)) 1988 1989 # define PKCS12_decrypt_d2i_PKCS7(algor, d2i_func, free_func, pass, passlen, oct, seq) \ 1990 SKM_PKCS12_decrypt_d2i(PKCS7, (algor), (d2i_func), (free_func), (pass), (passlen), (oct), (seq)) 1991 1992 #endif /* !defined HEADER_SAFESTACK_H */ 1993