1 /* Copyright (c) 2014, Google Inc. 2 * 3 * Permission to use, copy, modify, and/or distribute this software for any 4 * purpose with or without fee is hereby granted, provided that the above 5 * copyright notice and this permission notice appear in all copies. 6 * 7 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 8 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 9 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 10 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 11 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION 12 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 13 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ 14 15 #if !defined(IN_STACK_H) 16 #error "Don't include this file directly. Include stack.h." 17 #endif 18 19 /* ACCESS_DESCRIPTION */ 20 #define sk_ACCESS_DESCRIPTION_new(comp) \ 21 ((STACK_OF(ACCESS_DESCRIPTION) *)sk_new(CHECKED_CAST( \ 22 stack_cmp_func, \ 23 int (*)(const ACCESS_DESCRIPTION **a, const ACCESS_DESCRIPTION **b), \ 24 comp))) 25 26 #define sk_ACCESS_DESCRIPTION_new_null() \ 27 ((STACK_OF(ACCESS_DESCRIPTION) *)sk_new_null()) 28 29 #define sk_ACCESS_DESCRIPTION_num(sk) \ 30 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ACCESS_DESCRIPTION) *, sk)) 31 32 #define sk_ACCESS_DESCRIPTION_zero(sk) \ 33 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk)); 34 35 #define sk_ACCESS_DESCRIPTION_value(sk, i) \ 36 ((ACCESS_DESCRIPTION *)sk_value( \ 37 CHECKED_CAST(const _STACK *, const STACK_OF(ACCESS_DESCRIPTION) *, sk), \ 38 (i))) 39 40 #define sk_ACCESS_DESCRIPTION_set(sk, i, p) \ 41 ((ACCESS_DESCRIPTION *)sk_set( \ 42 CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), (i), \ 43 CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p))) 44 45 #define sk_ACCESS_DESCRIPTION_free(sk) \ 46 sk_free(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk)) 47 48 #define sk_ACCESS_DESCRIPTION_pop_free(sk, free_func) \ 49 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \ 50 CHECKED_CAST(void (*)(void *), void (*)(ACCESS_DESCRIPTION *), \ 51 free_func)) 52 53 #define sk_ACCESS_DESCRIPTION_insert(sk, p, where) \ 54 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \ 55 CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p), (where)) 56 57 #define sk_ACCESS_DESCRIPTION_delete(sk, where) \ 58 ((ACCESS_DESCRIPTION *)sk_delete( \ 59 CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), (where))) 60 61 #define sk_ACCESS_DESCRIPTION_delete_ptr(sk, p) \ 62 ((ACCESS_DESCRIPTION *)sk_delete_ptr( \ 63 CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \ 64 CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p))) 65 66 #define sk_ACCESS_DESCRIPTION_find(sk, out_index, p) \ 67 sk_find(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \ 68 (out_index), CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p)) 69 70 #define sk_ACCESS_DESCRIPTION_shift(sk) \ 71 ((ACCESS_DESCRIPTION *)sk_shift( \ 72 CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk))) 73 74 #define sk_ACCESS_DESCRIPTION_push(sk, p) \ 75 sk_push(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \ 76 CHECKED_CAST(void *, ACCESS_DESCRIPTION *, p)) 77 78 #define sk_ACCESS_DESCRIPTION_pop(sk) \ 79 ((ACCESS_DESCRIPTION *)sk_pop( \ 80 CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk))) 81 82 #define sk_ACCESS_DESCRIPTION_dup(sk) \ 83 ((STACK_OF(ACCESS_DESCRIPTION) *)sk_dup( \ 84 CHECKED_CAST(const _STACK *, const STACK_OF(ACCESS_DESCRIPTION) *, sk))) 85 86 #define sk_ACCESS_DESCRIPTION_sort(sk) \ 87 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk)) 88 89 #define sk_ACCESS_DESCRIPTION_is_sorted(sk) \ 90 sk_is_sorted( \ 91 CHECKED_CAST(const _STACK *, const STACK_OF(ACCESS_DESCRIPTION) *, sk)) 92 93 #define sk_ACCESS_DESCRIPTION_set_cmp_func(sk, comp) \ 94 ((int (*)(const ACCESS_DESCRIPTION **a, const ACCESS_DESCRIPTION **b)) \ 95 sk_set_cmp_func( \ 96 CHECKED_CAST(_STACK *, STACK_OF(ACCESS_DESCRIPTION) *, sk), \ 97 CHECKED_CAST(stack_cmp_func, int (*)(const ACCESS_DESCRIPTION **a, \ 98 const ACCESS_DESCRIPTION **b), \ 99 comp))) 100 101 #define sk_ACCESS_DESCRIPTION_deep_copy(sk, copy_func, free_func) \ 102 ((STACK_OF(ACCESS_DESCRIPTION) *)sk_deep_copy( \ 103 CHECKED_CAST(const _STACK *, const STACK_OF(ACCESS_DESCRIPTION) *, sk), \ 104 CHECKED_CAST(void *(*)(void *), \ 105 ACCESS_DESCRIPTION *(*)(ACCESS_DESCRIPTION *), copy_func), \ 106 CHECKED_CAST(void (*)(void *), void (*)(ACCESS_DESCRIPTION *), \ 107 free_func))) 108 109 /* ASN1_ADB_TABLE */ 110 #define sk_ASN1_ADB_TABLE_new(comp) \ 111 ((STACK_OF(ASN1_ADB_TABLE) *)sk_new(CHECKED_CAST( \ 112 stack_cmp_func, \ 113 int (*)(const ASN1_ADB_TABLE **a, const ASN1_ADB_TABLE **b), comp))) 114 115 #define sk_ASN1_ADB_TABLE_new_null() ((STACK_OF(ASN1_ADB_TABLE) *)sk_new_null()) 116 117 #define sk_ASN1_ADB_TABLE_num(sk) \ 118 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_ADB_TABLE) *, sk)) 119 120 #define sk_ASN1_ADB_TABLE_zero(sk) \ 121 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk)); 122 123 #define sk_ASN1_ADB_TABLE_value(sk, i) \ 124 ((ASN1_ADB_TABLE *)sk_value( \ 125 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_ADB_TABLE) *, sk), \ 126 (i))) 127 128 #define sk_ASN1_ADB_TABLE_set(sk, i, p) \ 129 ((ASN1_ADB_TABLE *)sk_set( \ 130 CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), (i), \ 131 CHECKED_CAST(void *, ASN1_ADB_TABLE *, p))) 132 133 #define sk_ASN1_ADB_TABLE_free(sk) \ 134 sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk)) 135 136 #define sk_ASN1_ADB_TABLE_pop_free(sk, free_func) \ 137 sk_pop_free( \ 138 CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), \ 139 CHECKED_CAST(void (*)(void *), void (*)(ASN1_ADB_TABLE *), free_func)) 140 141 #define sk_ASN1_ADB_TABLE_insert(sk, p, where) \ 142 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), \ 143 CHECKED_CAST(void *, ASN1_ADB_TABLE *, p), (where)) 144 145 #define sk_ASN1_ADB_TABLE_delete(sk, where) \ 146 ((ASN1_ADB_TABLE *)sk_delete( \ 147 CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), (where))) 148 149 #define sk_ASN1_ADB_TABLE_delete_ptr(sk, p) \ 150 ((ASN1_ADB_TABLE *)sk_delete_ptr( \ 151 CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), \ 152 CHECKED_CAST(void *, ASN1_ADB_TABLE *, p))) 153 154 #define sk_ASN1_ADB_TABLE_find(sk, out_index, p) \ 155 sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), (out_index), \ 156 CHECKED_CAST(void *, ASN1_ADB_TABLE *, p)) 157 158 #define sk_ASN1_ADB_TABLE_shift(sk) \ 159 ((ASN1_ADB_TABLE *)sk_shift( \ 160 CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk))) 161 162 #define sk_ASN1_ADB_TABLE_push(sk, p) \ 163 sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), \ 164 CHECKED_CAST(void *, ASN1_ADB_TABLE *, p)) 165 166 #define sk_ASN1_ADB_TABLE_pop(sk) \ 167 ((ASN1_ADB_TABLE *)sk_pop( \ 168 CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk))) 169 170 #define sk_ASN1_ADB_TABLE_dup(sk) \ 171 ((STACK_OF(ASN1_ADB_TABLE) *)sk_dup( \ 172 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_ADB_TABLE) *, sk))) 173 174 #define sk_ASN1_ADB_TABLE_sort(sk) \ 175 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk)) 176 177 #define sk_ASN1_ADB_TABLE_is_sorted(sk) \ 178 sk_is_sorted( \ 179 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_ADB_TABLE) *, sk)) 180 181 #define sk_ASN1_ADB_TABLE_set_cmp_func(sk, comp) \ 182 ((int (*)(const ASN1_ADB_TABLE **a, const ASN1_ADB_TABLE **b)) \ 183 sk_set_cmp_func( \ 184 CHECKED_CAST(_STACK *, STACK_OF(ASN1_ADB_TABLE) *, sk), \ 185 CHECKED_CAST(stack_cmp_func, int (*)(const ASN1_ADB_TABLE **a, \ 186 const ASN1_ADB_TABLE **b), \ 187 comp))) 188 189 #define sk_ASN1_ADB_TABLE_deep_copy(sk, copy_func, free_func) \ 190 ((STACK_OF(ASN1_ADB_TABLE) *)sk_deep_copy( \ 191 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_ADB_TABLE) *, sk), \ 192 CHECKED_CAST(void *(*)(void *), ASN1_ADB_TABLE *(*)(ASN1_ADB_TABLE *), \ 193 copy_func), \ 194 CHECKED_CAST(void (*)(void *), void (*)(ASN1_ADB_TABLE *), free_func))) 195 196 /* ASN1_GENERALSTRING */ 197 #define sk_ASN1_GENERALSTRING_new(comp) \ 198 ((STACK_OF(ASN1_GENERALSTRING) *)sk_new(CHECKED_CAST( \ 199 stack_cmp_func, \ 200 int (*)(const ASN1_GENERALSTRING **a, const ASN1_GENERALSTRING **b), \ 201 comp))) 202 203 #define sk_ASN1_GENERALSTRING_new_null() \ 204 ((STACK_OF(ASN1_GENERALSTRING) *)sk_new_null()) 205 206 #define sk_ASN1_GENERALSTRING_num(sk) \ 207 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_GENERALSTRING) *, sk)) 208 209 #define sk_ASN1_GENERALSTRING_zero(sk) \ 210 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk)); 211 212 #define sk_ASN1_GENERALSTRING_value(sk, i) \ 213 ((ASN1_GENERALSTRING *)sk_value( \ 214 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_GENERALSTRING) *, sk), \ 215 (i))) 216 217 #define sk_ASN1_GENERALSTRING_set(sk, i, p) \ 218 ((ASN1_GENERALSTRING *)sk_set( \ 219 CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), (i), \ 220 CHECKED_CAST(void *, ASN1_GENERALSTRING *, p))) 221 222 #define sk_ASN1_GENERALSTRING_free(sk) \ 223 sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk)) 224 225 #define sk_ASN1_GENERALSTRING_pop_free(sk, free_func) \ 226 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \ 227 CHECKED_CAST(void (*)(void *), void (*)(ASN1_GENERALSTRING *), \ 228 free_func)) 229 230 #define sk_ASN1_GENERALSTRING_insert(sk, p, where) \ 231 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \ 232 CHECKED_CAST(void *, ASN1_GENERALSTRING *, p), (where)) 233 234 #define sk_ASN1_GENERALSTRING_delete(sk, where) \ 235 ((ASN1_GENERALSTRING *)sk_delete( \ 236 CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), (where))) 237 238 #define sk_ASN1_GENERALSTRING_delete_ptr(sk, p) \ 239 ((ASN1_GENERALSTRING *)sk_delete_ptr( \ 240 CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \ 241 CHECKED_CAST(void *, ASN1_GENERALSTRING *, p))) 242 243 #define sk_ASN1_GENERALSTRING_find(sk, out_index, p) \ 244 sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \ 245 (out_index), CHECKED_CAST(void *, ASN1_GENERALSTRING *, p)) 246 247 #define sk_ASN1_GENERALSTRING_shift(sk) \ 248 ((ASN1_GENERALSTRING *)sk_shift( \ 249 CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk))) 250 251 #define sk_ASN1_GENERALSTRING_push(sk, p) \ 252 sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \ 253 CHECKED_CAST(void *, ASN1_GENERALSTRING *, p)) 254 255 #define sk_ASN1_GENERALSTRING_pop(sk) \ 256 ((ASN1_GENERALSTRING *)sk_pop( \ 257 CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk))) 258 259 #define sk_ASN1_GENERALSTRING_dup(sk) \ 260 ((STACK_OF(ASN1_GENERALSTRING) *)sk_dup( \ 261 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_GENERALSTRING) *, sk))) 262 263 #define sk_ASN1_GENERALSTRING_sort(sk) \ 264 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk)) 265 266 #define sk_ASN1_GENERALSTRING_is_sorted(sk) \ 267 sk_is_sorted( \ 268 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_GENERALSTRING) *, sk)) 269 270 #define sk_ASN1_GENERALSTRING_set_cmp_func(sk, comp) \ 271 ((int (*)(const ASN1_GENERALSTRING **a, const ASN1_GENERALSTRING **b)) \ 272 sk_set_cmp_func( \ 273 CHECKED_CAST(_STACK *, STACK_OF(ASN1_GENERALSTRING) *, sk), \ 274 CHECKED_CAST(stack_cmp_func, int (*)(const ASN1_GENERALSTRING **a, \ 275 const ASN1_GENERALSTRING **b), \ 276 comp))) 277 278 #define sk_ASN1_GENERALSTRING_deep_copy(sk, copy_func, free_func) \ 279 ((STACK_OF(ASN1_GENERALSTRING) *)sk_deep_copy( \ 280 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_GENERALSTRING) *, sk), \ 281 CHECKED_CAST(void *(*)(void *), \ 282 ASN1_GENERALSTRING *(*)(ASN1_GENERALSTRING *), copy_func), \ 283 CHECKED_CAST(void (*)(void *), void (*)(ASN1_GENERALSTRING *), \ 284 free_func))) 285 286 /* ASN1_INTEGER */ 287 #define sk_ASN1_INTEGER_new(comp) \ 288 ((STACK_OF(ASN1_INTEGER) *)sk_new(CHECKED_CAST( \ 289 stack_cmp_func, int (*)(const ASN1_INTEGER **a, const ASN1_INTEGER **b), \ 290 comp))) 291 292 #define sk_ASN1_INTEGER_new_null() ((STACK_OF(ASN1_INTEGER) *)sk_new_null()) 293 294 #define sk_ASN1_INTEGER_num(sk) \ 295 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_INTEGER) *, sk)) 296 297 #define sk_ASN1_INTEGER_zero(sk) \ 298 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk)); 299 300 #define sk_ASN1_INTEGER_value(sk, i) \ 301 ((ASN1_INTEGER *)sk_value( \ 302 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_INTEGER) *, sk), (i))) 303 304 #define sk_ASN1_INTEGER_set(sk, i, p) \ 305 ((ASN1_INTEGER *)sk_set( \ 306 CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), (i), \ 307 CHECKED_CAST(void *, ASN1_INTEGER *, p))) 308 309 #define sk_ASN1_INTEGER_free(sk) \ 310 sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk)) 311 312 #define sk_ASN1_INTEGER_pop_free(sk, free_func) \ 313 sk_pop_free( \ 314 CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), \ 315 CHECKED_CAST(void (*)(void *), void (*)(ASN1_INTEGER *), free_func)) 316 317 #define sk_ASN1_INTEGER_insert(sk, p, where) \ 318 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), \ 319 CHECKED_CAST(void *, ASN1_INTEGER *, p), (where)) 320 321 #define sk_ASN1_INTEGER_delete(sk, where) \ 322 ((ASN1_INTEGER *)sk_delete( \ 323 CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), (where))) 324 325 #define sk_ASN1_INTEGER_delete_ptr(sk, p) \ 326 ((ASN1_INTEGER *)sk_delete_ptr( \ 327 CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), \ 328 CHECKED_CAST(void *, ASN1_INTEGER *, p))) 329 330 #define sk_ASN1_INTEGER_find(sk, out_index, p) \ 331 sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), (out_index), \ 332 CHECKED_CAST(void *, ASN1_INTEGER *, p)) 333 334 #define sk_ASN1_INTEGER_shift(sk) \ 335 ((ASN1_INTEGER *)sk_shift( \ 336 CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk))) 337 338 #define sk_ASN1_INTEGER_push(sk, p) \ 339 sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), \ 340 CHECKED_CAST(void *, ASN1_INTEGER *, p)) 341 342 #define sk_ASN1_INTEGER_pop(sk) \ 343 ((ASN1_INTEGER *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk))) 344 345 #define sk_ASN1_INTEGER_dup(sk) \ 346 ((STACK_OF(ASN1_INTEGER) *)sk_dup( \ 347 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_INTEGER) *, sk))) 348 349 #define sk_ASN1_INTEGER_sort(sk) \ 350 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk)) 351 352 #define sk_ASN1_INTEGER_is_sorted(sk) \ 353 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_INTEGER) *, sk)) 354 355 #define sk_ASN1_INTEGER_set_cmp_func(sk, comp) \ 356 ((int (*)(const ASN1_INTEGER **a, const ASN1_INTEGER **b))sk_set_cmp_func( \ 357 CHECKED_CAST(_STACK *, STACK_OF(ASN1_INTEGER) *, sk), \ 358 CHECKED_CAST(stack_cmp_func, \ 359 int (*)(const ASN1_INTEGER **a, const ASN1_INTEGER **b), \ 360 comp))) 361 362 #define sk_ASN1_INTEGER_deep_copy(sk, copy_func, free_func) \ 363 ((STACK_OF(ASN1_INTEGER) *)sk_deep_copy( \ 364 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_INTEGER) *, sk), \ 365 CHECKED_CAST(void *(*)(void *), ASN1_INTEGER *(*)(ASN1_INTEGER *), \ 366 copy_func), \ 367 CHECKED_CAST(void (*)(void *), void (*)(ASN1_INTEGER *), free_func))) 368 369 /* ASN1_OBJECT */ 370 #define sk_ASN1_OBJECT_new(comp) \ 371 ((STACK_OF(ASN1_OBJECT) *)sk_new(CHECKED_CAST( \ 372 stack_cmp_func, int (*)(const ASN1_OBJECT **a, const ASN1_OBJECT **b), \ 373 comp))) 374 375 #define sk_ASN1_OBJECT_new_null() ((STACK_OF(ASN1_OBJECT) *)sk_new_null()) 376 377 #define sk_ASN1_OBJECT_num(sk) \ 378 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_OBJECT) *, sk)) 379 380 #define sk_ASN1_OBJECT_zero(sk) \ 381 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk)); 382 383 #define sk_ASN1_OBJECT_value(sk, i) \ 384 ((ASN1_OBJECT *)sk_value( \ 385 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_OBJECT) *, sk), (i))) 386 387 #define sk_ASN1_OBJECT_set(sk, i, p) \ 388 ((ASN1_OBJECT *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \ 389 (i), CHECKED_CAST(void *, ASN1_OBJECT *, p))) 390 391 #define sk_ASN1_OBJECT_free(sk) \ 392 sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk)) 393 394 #define sk_ASN1_OBJECT_pop_free(sk, free_func) \ 395 sk_pop_free( \ 396 CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \ 397 CHECKED_CAST(void (*)(void *), void (*)(ASN1_OBJECT *), free_func)) 398 399 #define sk_ASN1_OBJECT_insert(sk, p, where) \ 400 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \ 401 CHECKED_CAST(void *, ASN1_OBJECT *, p), (where)) 402 403 #define sk_ASN1_OBJECT_delete(sk, where) \ 404 ((ASN1_OBJECT *)sk_delete( \ 405 CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), (where))) 406 407 #define sk_ASN1_OBJECT_delete_ptr(sk, p) \ 408 ((ASN1_OBJECT *)sk_delete_ptr( \ 409 CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \ 410 CHECKED_CAST(void *, ASN1_OBJECT *, p))) 411 412 #define sk_ASN1_OBJECT_find(sk, out_index, p) \ 413 sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), (out_index), \ 414 CHECKED_CAST(void *, ASN1_OBJECT *, p)) 415 416 #define sk_ASN1_OBJECT_shift(sk) \ 417 ((ASN1_OBJECT *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk))) 418 419 #define sk_ASN1_OBJECT_push(sk, p) \ 420 sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \ 421 CHECKED_CAST(void *, ASN1_OBJECT *, p)) 422 423 #define sk_ASN1_OBJECT_pop(sk) \ 424 ((ASN1_OBJECT *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk))) 425 426 #define sk_ASN1_OBJECT_dup(sk) \ 427 ((STACK_OF(ASN1_OBJECT) *)sk_dup( \ 428 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_OBJECT) *, sk))) 429 430 #define sk_ASN1_OBJECT_sort(sk) \ 431 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk)) 432 433 #define sk_ASN1_OBJECT_is_sorted(sk) \ 434 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_OBJECT) *, sk)) 435 436 #define sk_ASN1_OBJECT_set_cmp_func(sk, comp) \ 437 ((int (*)(const ASN1_OBJECT **a, const ASN1_OBJECT **b))sk_set_cmp_func( \ 438 CHECKED_CAST(_STACK *, STACK_OF(ASN1_OBJECT) *, sk), \ 439 CHECKED_CAST(stack_cmp_func, \ 440 int (*)(const ASN1_OBJECT **a, const ASN1_OBJECT **b), \ 441 comp))) 442 443 #define sk_ASN1_OBJECT_deep_copy(sk, copy_func, free_func) \ 444 ((STACK_OF(ASN1_OBJECT) *)sk_deep_copy( \ 445 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_OBJECT) *, sk), \ 446 CHECKED_CAST(void *(*)(void *), ASN1_OBJECT *(*)(ASN1_OBJECT *), \ 447 copy_func), \ 448 CHECKED_CAST(void (*)(void *), void (*)(ASN1_OBJECT *), free_func))) 449 450 /* ASN1_STRING_TABLE */ 451 #define sk_ASN1_STRING_TABLE_new(comp) \ 452 ((STACK_OF(ASN1_STRING_TABLE) *)sk_new(CHECKED_CAST( \ 453 stack_cmp_func, \ 454 int (*)(const ASN1_STRING_TABLE **a, const ASN1_STRING_TABLE **b), \ 455 comp))) 456 457 #define sk_ASN1_STRING_TABLE_new_null() \ 458 ((STACK_OF(ASN1_STRING_TABLE) *)sk_new_null()) 459 460 #define sk_ASN1_STRING_TABLE_num(sk) \ 461 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_STRING_TABLE) *, sk)) 462 463 #define sk_ASN1_STRING_TABLE_zero(sk) \ 464 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk)); 465 466 #define sk_ASN1_STRING_TABLE_value(sk, i) \ 467 ((ASN1_STRING_TABLE *)sk_value( \ 468 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_STRING_TABLE) *, sk), \ 469 (i))) 470 471 #define sk_ASN1_STRING_TABLE_set(sk, i, p) \ 472 ((ASN1_STRING_TABLE *)sk_set( \ 473 CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), (i), \ 474 CHECKED_CAST(void *, ASN1_STRING_TABLE *, p))) 475 476 #define sk_ASN1_STRING_TABLE_free(sk) \ 477 sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk)) 478 479 #define sk_ASN1_STRING_TABLE_pop_free(sk, free_func) \ 480 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \ 481 CHECKED_CAST(void (*)(void *), void (*)(ASN1_STRING_TABLE *), \ 482 free_func)) 483 484 #define sk_ASN1_STRING_TABLE_insert(sk, p, where) \ 485 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \ 486 CHECKED_CAST(void *, ASN1_STRING_TABLE *, p), (where)) 487 488 #define sk_ASN1_STRING_TABLE_delete(sk, where) \ 489 ((ASN1_STRING_TABLE *)sk_delete( \ 490 CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), (where))) 491 492 #define sk_ASN1_STRING_TABLE_delete_ptr(sk, p) \ 493 ((ASN1_STRING_TABLE *)sk_delete_ptr( \ 494 CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \ 495 CHECKED_CAST(void *, ASN1_STRING_TABLE *, p))) 496 497 #define sk_ASN1_STRING_TABLE_find(sk, out_index, p) \ 498 sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \ 499 (out_index), CHECKED_CAST(void *, ASN1_STRING_TABLE *, p)) 500 501 #define sk_ASN1_STRING_TABLE_shift(sk) \ 502 ((ASN1_STRING_TABLE *)sk_shift( \ 503 CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk))) 504 505 #define sk_ASN1_STRING_TABLE_push(sk, p) \ 506 sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \ 507 CHECKED_CAST(void *, ASN1_STRING_TABLE *, p)) 508 509 #define sk_ASN1_STRING_TABLE_pop(sk) \ 510 ((ASN1_STRING_TABLE *)sk_pop( \ 511 CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk))) 512 513 #define sk_ASN1_STRING_TABLE_dup(sk) \ 514 ((STACK_OF(ASN1_STRING_TABLE) *)sk_dup( \ 515 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_STRING_TABLE) *, sk))) 516 517 #define sk_ASN1_STRING_TABLE_sort(sk) \ 518 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk)) 519 520 #define sk_ASN1_STRING_TABLE_is_sorted(sk) \ 521 sk_is_sorted( \ 522 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_STRING_TABLE) *, sk)) 523 524 #define sk_ASN1_STRING_TABLE_set_cmp_func(sk, comp) \ 525 ((int (*)(const ASN1_STRING_TABLE **a, const ASN1_STRING_TABLE **b)) \ 526 sk_set_cmp_func( \ 527 CHECKED_CAST(_STACK *, STACK_OF(ASN1_STRING_TABLE) *, sk), \ 528 CHECKED_CAST(stack_cmp_func, int (*)(const ASN1_STRING_TABLE **a, \ 529 const ASN1_STRING_TABLE **b), \ 530 comp))) 531 532 #define sk_ASN1_STRING_TABLE_deep_copy(sk, copy_func, free_func) \ 533 ((STACK_OF(ASN1_STRING_TABLE) *)sk_deep_copy( \ 534 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_STRING_TABLE) *, sk), \ 535 CHECKED_CAST(void *(*)(void *), \ 536 ASN1_STRING_TABLE *(*)(ASN1_STRING_TABLE *), copy_func), \ 537 CHECKED_CAST(void (*)(void *), void (*)(ASN1_STRING_TABLE *), \ 538 free_func))) 539 540 /* ASN1_TYPE */ 541 #define sk_ASN1_TYPE_new(comp) \ 542 ((STACK_OF(ASN1_TYPE) *)sk_new( \ 543 CHECKED_CAST(stack_cmp_func, \ 544 int (*)(const ASN1_TYPE **a, const ASN1_TYPE **b), comp))) 545 546 #define sk_ASN1_TYPE_new_null() ((STACK_OF(ASN1_TYPE) *)sk_new_null()) 547 548 #define sk_ASN1_TYPE_num(sk) \ 549 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_TYPE) *, sk)) 550 551 #define sk_ASN1_TYPE_zero(sk) \ 552 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk)); 553 554 #define sk_ASN1_TYPE_value(sk, i) \ 555 ((ASN1_TYPE *)sk_value( \ 556 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_TYPE) *, sk), (i))) 557 558 #define sk_ASN1_TYPE_set(sk, i, p) \ 559 ((ASN1_TYPE *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), (i), \ 560 CHECKED_CAST(void *, ASN1_TYPE *, p))) 561 562 #define sk_ASN1_TYPE_free(sk) \ 563 sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk)) 564 565 #define sk_ASN1_TYPE_pop_free(sk, free_func) \ 566 sk_pop_free( \ 567 CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \ 568 CHECKED_CAST(void (*)(void *), void (*)(ASN1_TYPE *), free_func)) 569 570 #define sk_ASN1_TYPE_insert(sk, p, where) \ 571 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \ 572 CHECKED_CAST(void *, ASN1_TYPE *, p), (where)) 573 574 #define sk_ASN1_TYPE_delete(sk, where) \ 575 ((ASN1_TYPE *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \ 576 (where))) 577 578 #define sk_ASN1_TYPE_delete_ptr(sk, p) \ 579 ((ASN1_TYPE *)sk_delete_ptr( \ 580 CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \ 581 CHECKED_CAST(void *, ASN1_TYPE *, p))) 582 583 #define sk_ASN1_TYPE_find(sk, out_index, p) \ 584 sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), (out_index), \ 585 CHECKED_CAST(void *, ASN1_TYPE *, p)) 586 587 #define sk_ASN1_TYPE_shift(sk) \ 588 ((ASN1_TYPE *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk))) 589 590 #define sk_ASN1_TYPE_push(sk, p) \ 591 sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \ 592 CHECKED_CAST(void *, ASN1_TYPE *, p)) 593 594 #define sk_ASN1_TYPE_pop(sk) \ 595 ((ASN1_TYPE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk))) 596 597 #define sk_ASN1_TYPE_dup(sk) \ 598 ((STACK_OF(ASN1_TYPE) *)sk_dup( \ 599 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_TYPE) *, sk))) 600 601 #define sk_ASN1_TYPE_sort(sk) \ 602 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk)) 603 604 #define sk_ASN1_TYPE_is_sorted(sk) \ 605 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_TYPE) *, sk)) 606 607 #define sk_ASN1_TYPE_set_cmp_func(sk, comp) \ 608 ((int (*)(const ASN1_TYPE **a, const ASN1_TYPE **b))sk_set_cmp_func( \ 609 CHECKED_CAST(_STACK *, STACK_OF(ASN1_TYPE) *, sk), \ 610 CHECKED_CAST(stack_cmp_func, \ 611 int (*)(const ASN1_TYPE **a, const ASN1_TYPE **b), comp))) 612 613 #define sk_ASN1_TYPE_deep_copy(sk, copy_func, free_func) \ 614 ((STACK_OF(ASN1_TYPE) *)sk_deep_copy( \ 615 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_TYPE) *, sk), \ 616 CHECKED_CAST(void *(*)(void *), ASN1_TYPE *(*)(ASN1_TYPE *), copy_func), \ 617 CHECKED_CAST(void (*)(void *), void (*)(ASN1_TYPE *), free_func))) 618 619 /* ASN1_VALUE */ 620 #define sk_ASN1_VALUE_new(comp) \ 621 ((STACK_OF(ASN1_VALUE) *)sk_new(CHECKED_CAST( \ 622 stack_cmp_func, int (*)(const ASN1_VALUE **a, const ASN1_VALUE **b), \ 623 comp))) 624 625 #define sk_ASN1_VALUE_new_null() ((STACK_OF(ASN1_VALUE) *)sk_new_null()) 626 627 #define sk_ASN1_VALUE_num(sk) \ 628 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_VALUE) *, sk)) 629 630 #define sk_ASN1_VALUE_zero(sk) \ 631 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk)); 632 633 #define sk_ASN1_VALUE_value(sk, i) \ 634 ((ASN1_VALUE *)sk_value( \ 635 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_VALUE) *, sk), (i))) 636 637 #define sk_ASN1_VALUE_set(sk, i, p) \ 638 ((ASN1_VALUE *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \ 639 (i), CHECKED_CAST(void *, ASN1_VALUE *, p))) 640 641 #define sk_ASN1_VALUE_free(sk) \ 642 sk_free(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk)) 643 644 #define sk_ASN1_VALUE_pop_free(sk, free_func) \ 645 sk_pop_free( \ 646 CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \ 647 CHECKED_CAST(void (*)(void *), void (*)(ASN1_VALUE *), free_func)) 648 649 #define sk_ASN1_VALUE_insert(sk, p, where) \ 650 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \ 651 CHECKED_CAST(void *, ASN1_VALUE *, p), (where)) 652 653 #define sk_ASN1_VALUE_delete(sk, where) \ 654 ((ASN1_VALUE *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \ 655 (where))) 656 657 #define sk_ASN1_VALUE_delete_ptr(sk, p) \ 658 ((ASN1_VALUE *)sk_delete_ptr( \ 659 CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \ 660 CHECKED_CAST(void *, ASN1_VALUE *, p))) 661 662 #define sk_ASN1_VALUE_find(sk, out_index, p) \ 663 sk_find(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), (out_index), \ 664 CHECKED_CAST(void *, ASN1_VALUE *, p)) 665 666 #define sk_ASN1_VALUE_shift(sk) \ 667 ((ASN1_VALUE *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk))) 668 669 #define sk_ASN1_VALUE_push(sk, p) \ 670 sk_push(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \ 671 CHECKED_CAST(void *, ASN1_VALUE *, p)) 672 673 #define sk_ASN1_VALUE_pop(sk) \ 674 ((ASN1_VALUE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk))) 675 676 #define sk_ASN1_VALUE_dup(sk) \ 677 ((STACK_OF(ASN1_VALUE) *)sk_dup( \ 678 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_VALUE) *, sk))) 679 680 #define sk_ASN1_VALUE_sort(sk) \ 681 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk)) 682 683 #define sk_ASN1_VALUE_is_sorted(sk) \ 684 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_VALUE) *, sk)) 685 686 #define sk_ASN1_VALUE_set_cmp_func(sk, comp) \ 687 ((int (*)(const ASN1_VALUE **a, const ASN1_VALUE **b))sk_set_cmp_func( \ 688 CHECKED_CAST(_STACK *, STACK_OF(ASN1_VALUE) *, sk), \ 689 CHECKED_CAST(stack_cmp_func, \ 690 int (*)(const ASN1_VALUE **a, const ASN1_VALUE **b), \ 691 comp))) 692 693 #define sk_ASN1_VALUE_deep_copy(sk, copy_func, free_func) \ 694 ((STACK_OF(ASN1_VALUE) *)sk_deep_copy( \ 695 CHECKED_CAST(const _STACK *, const STACK_OF(ASN1_VALUE) *, sk), \ 696 CHECKED_CAST(void *(*)(void *), ASN1_VALUE *(*)(ASN1_VALUE *), \ 697 copy_func), \ 698 CHECKED_CAST(void (*)(void *), void (*)(ASN1_VALUE *), free_func))) 699 700 /* BIO */ 701 #define sk_BIO_new(comp) \ 702 ((STACK_OF(BIO) *)sk_new(CHECKED_CAST( \ 703 stack_cmp_func, int (*)(const BIO **a, const BIO **b), comp))) 704 705 #define sk_BIO_new_null() ((STACK_OF(BIO) *)sk_new_null()) 706 707 #define sk_BIO_num(sk) \ 708 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(BIO) *, sk)) 709 710 #define sk_BIO_zero(sk) sk_zero(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk)); 711 712 #define sk_BIO_value(sk, i) \ 713 ((BIO *)sk_value(CHECKED_CAST(const _STACK *, const STACK_OF(BIO) *, sk), \ 714 (i))) 715 716 #define sk_BIO_set(sk, i, p) \ 717 ((BIO *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), (i), \ 718 CHECKED_CAST(void *, BIO *, p))) 719 720 #define sk_BIO_free(sk) sk_free(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk)) 721 722 #define sk_BIO_pop_free(sk, free_func) \ 723 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), \ 724 CHECKED_CAST(void (*)(void *), void (*)(BIO *), free_func)) 725 726 #define sk_BIO_insert(sk, p, where) \ 727 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), \ 728 CHECKED_CAST(void *, BIO *, p), (where)) 729 730 #define sk_BIO_delete(sk, where) \ 731 ((BIO *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), (where))) 732 733 #define sk_BIO_delete_ptr(sk, p) \ 734 ((BIO *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), \ 735 CHECKED_CAST(void *, BIO *, p))) 736 737 #define sk_BIO_find(sk, out_index, p) \ 738 sk_find(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), (out_index), \ 739 CHECKED_CAST(void *, BIO *, p)) 740 741 #define sk_BIO_shift(sk) \ 742 ((BIO *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk))) 743 744 #define sk_BIO_push(sk, p) \ 745 sk_push(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), \ 746 CHECKED_CAST(void *, BIO *, p)) 747 748 #define sk_BIO_pop(sk) \ 749 ((BIO *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk))) 750 751 #define sk_BIO_dup(sk) \ 752 ((STACK_OF(BIO) *)sk_dup( \ 753 CHECKED_CAST(const _STACK *, const STACK_OF(BIO) *, sk))) 754 755 #define sk_BIO_sort(sk) sk_sort(CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk)) 756 757 #define sk_BIO_is_sorted(sk) \ 758 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(BIO) *, sk)) 759 760 #define sk_BIO_set_cmp_func(sk, comp) \ 761 ((int (*)(const BIO **a, const BIO **b))sk_set_cmp_func( \ 762 CHECKED_CAST(_STACK *, STACK_OF(BIO) *, sk), \ 763 CHECKED_CAST(stack_cmp_func, int (*)(const BIO **a, const BIO **b), \ 764 comp))) 765 766 #define sk_BIO_deep_copy(sk, copy_func, free_func) \ 767 ((STACK_OF(BIO) *)sk_deep_copy( \ 768 CHECKED_CAST(const _STACK *, const STACK_OF(BIO) *, sk), \ 769 CHECKED_CAST(void *(*)(void *), BIO *(*)(BIO *), copy_func), \ 770 CHECKED_CAST(void (*)(void *), void (*)(BIO *), free_func))) 771 772 /* BY_DIR_ENTRY */ 773 #define sk_BY_DIR_ENTRY_new(comp) \ 774 ((STACK_OF(BY_DIR_ENTRY) *)sk_new(CHECKED_CAST( \ 775 stack_cmp_func, int (*)(const BY_DIR_ENTRY **a, const BY_DIR_ENTRY **b), \ 776 comp))) 777 778 #define sk_BY_DIR_ENTRY_new_null() ((STACK_OF(BY_DIR_ENTRY) *)sk_new_null()) 779 780 #define sk_BY_DIR_ENTRY_num(sk) \ 781 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_ENTRY) *, sk)) 782 783 #define sk_BY_DIR_ENTRY_zero(sk) \ 784 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk)); 785 786 #define sk_BY_DIR_ENTRY_value(sk, i) \ 787 ((BY_DIR_ENTRY *)sk_value( \ 788 CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_ENTRY) *, sk), (i))) 789 790 #define sk_BY_DIR_ENTRY_set(sk, i, p) \ 791 ((BY_DIR_ENTRY *)sk_set( \ 792 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), (i), \ 793 CHECKED_CAST(void *, BY_DIR_ENTRY *, p))) 794 795 #define sk_BY_DIR_ENTRY_free(sk) \ 796 sk_free(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk)) 797 798 #define sk_BY_DIR_ENTRY_pop_free(sk, free_func) \ 799 sk_pop_free( \ 800 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), \ 801 CHECKED_CAST(void (*)(void *), void (*)(BY_DIR_ENTRY *), free_func)) 802 803 #define sk_BY_DIR_ENTRY_insert(sk, p, where) \ 804 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), \ 805 CHECKED_CAST(void *, BY_DIR_ENTRY *, p), (where)) 806 807 #define sk_BY_DIR_ENTRY_delete(sk, where) \ 808 ((BY_DIR_ENTRY *)sk_delete( \ 809 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), (where))) 810 811 #define sk_BY_DIR_ENTRY_delete_ptr(sk, p) \ 812 ((BY_DIR_ENTRY *)sk_delete_ptr( \ 813 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), \ 814 CHECKED_CAST(void *, BY_DIR_ENTRY *, p))) 815 816 #define sk_BY_DIR_ENTRY_find(sk, out_index, p) \ 817 sk_find(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), (out_index), \ 818 CHECKED_CAST(void *, BY_DIR_ENTRY *, p)) 819 820 #define sk_BY_DIR_ENTRY_shift(sk) \ 821 ((BY_DIR_ENTRY *)sk_shift( \ 822 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk))) 823 824 #define sk_BY_DIR_ENTRY_push(sk, p) \ 825 sk_push(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), \ 826 CHECKED_CAST(void *, BY_DIR_ENTRY *, p)) 827 828 #define sk_BY_DIR_ENTRY_pop(sk) \ 829 ((BY_DIR_ENTRY *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk))) 830 831 #define sk_BY_DIR_ENTRY_dup(sk) \ 832 ((STACK_OF(BY_DIR_ENTRY) *)sk_dup( \ 833 CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_ENTRY) *, sk))) 834 835 #define sk_BY_DIR_ENTRY_sort(sk) \ 836 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk)) 837 838 #define sk_BY_DIR_ENTRY_is_sorted(sk) \ 839 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_ENTRY) *, sk)) 840 841 #define sk_BY_DIR_ENTRY_set_cmp_func(sk, comp) \ 842 ((int (*)(const BY_DIR_ENTRY **a, const BY_DIR_ENTRY **b))sk_set_cmp_func( \ 843 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_ENTRY) *, sk), \ 844 CHECKED_CAST(stack_cmp_func, \ 845 int (*)(const BY_DIR_ENTRY **a, const BY_DIR_ENTRY **b), \ 846 comp))) 847 848 #define sk_BY_DIR_ENTRY_deep_copy(sk, copy_func, free_func) \ 849 ((STACK_OF(BY_DIR_ENTRY) *)sk_deep_copy( \ 850 CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_ENTRY) *, sk), \ 851 CHECKED_CAST(void *(*)(void *), BY_DIR_ENTRY *(*)(BY_DIR_ENTRY *), \ 852 copy_func), \ 853 CHECKED_CAST(void (*)(void *), void (*)(BY_DIR_ENTRY *), free_func))) 854 855 /* BY_DIR_HASH */ 856 #define sk_BY_DIR_HASH_new(comp) \ 857 ((STACK_OF(BY_DIR_HASH) *)sk_new(CHECKED_CAST( \ 858 stack_cmp_func, int (*)(const BY_DIR_HASH **a, const BY_DIR_HASH **b), \ 859 comp))) 860 861 #define sk_BY_DIR_HASH_new_null() ((STACK_OF(BY_DIR_HASH) *)sk_new_null()) 862 863 #define sk_BY_DIR_HASH_num(sk) \ 864 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_HASH) *, sk)) 865 866 #define sk_BY_DIR_HASH_zero(sk) \ 867 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk)); 868 869 #define sk_BY_DIR_HASH_value(sk, i) \ 870 ((BY_DIR_HASH *)sk_value( \ 871 CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_HASH) *, sk), (i))) 872 873 #define sk_BY_DIR_HASH_set(sk, i, p) \ 874 ((BY_DIR_HASH *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \ 875 (i), CHECKED_CAST(void *, BY_DIR_HASH *, p))) 876 877 #define sk_BY_DIR_HASH_free(sk) \ 878 sk_free(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk)) 879 880 #define sk_BY_DIR_HASH_pop_free(sk, free_func) \ 881 sk_pop_free( \ 882 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \ 883 CHECKED_CAST(void (*)(void *), void (*)(BY_DIR_HASH *), free_func)) 884 885 #define sk_BY_DIR_HASH_insert(sk, p, where) \ 886 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \ 887 CHECKED_CAST(void *, BY_DIR_HASH *, p), (where)) 888 889 #define sk_BY_DIR_HASH_delete(sk, where) \ 890 ((BY_DIR_HASH *)sk_delete( \ 891 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), (where))) 892 893 #define sk_BY_DIR_HASH_delete_ptr(sk, p) \ 894 ((BY_DIR_HASH *)sk_delete_ptr( \ 895 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \ 896 CHECKED_CAST(void *, BY_DIR_HASH *, p))) 897 898 #define sk_BY_DIR_HASH_find(sk, out_index, p) \ 899 sk_find(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), (out_index), \ 900 CHECKED_CAST(void *, BY_DIR_HASH *, p)) 901 902 #define sk_BY_DIR_HASH_shift(sk) \ 903 ((BY_DIR_HASH *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk))) 904 905 #define sk_BY_DIR_HASH_push(sk, p) \ 906 sk_push(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \ 907 CHECKED_CAST(void *, BY_DIR_HASH *, p)) 908 909 #define sk_BY_DIR_HASH_pop(sk) \ 910 ((BY_DIR_HASH *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk))) 911 912 #define sk_BY_DIR_HASH_dup(sk) \ 913 ((STACK_OF(BY_DIR_HASH) *)sk_dup( \ 914 CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_HASH) *, sk))) 915 916 #define sk_BY_DIR_HASH_sort(sk) \ 917 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk)) 918 919 #define sk_BY_DIR_HASH_is_sorted(sk) \ 920 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_HASH) *, sk)) 921 922 #define sk_BY_DIR_HASH_set_cmp_func(sk, comp) \ 923 ((int (*)(const BY_DIR_HASH **a, const BY_DIR_HASH **b))sk_set_cmp_func( \ 924 CHECKED_CAST(_STACK *, STACK_OF(BY_DIR_HASH) *, sk), \ 925 CHECKED_CAST(stack_cmp_func, \ 926 int (*)(const BY_DIR_HASH **a, const BY_DIR_HASH **b), \ 927 comp))) 928 929 #define sk_BY_DIR_HASH_deep_copy(sk, copy_func, free_func) \ 930 ((STACK_OF(BY_DIR_HASH) *)sk_deep_copy( \ 931 CHECKED_CAST(const _STACK *, const STACK_OF(BY_DIR_HASH) *, sk), \ 932 CHECKED_CAST(void *(*)(void *), BY_DIR_HASH *(*)(BY_DIR_HASH *), \ 933 copy_func), \ 934 CHECKED_CAST(void (*)(void *), void (*)(BY_DIR_HASH *), free_func))) 935 936 /* CONF_VALUE */ 937 #define sk_CONF_VALUE_new(comp) \ 938 ((STACK_OF(CONF_VALUE) *)sk_new(CHECKED_CAST( \ 939 stack_cmp_func, int (*)(const CONF_VALUE **a, const CONF_VALUE **b), \ 940 comp))) 941 942 #define sk_CONF_VALUE_new_null() ((STACK_OF(CONF_VALUE) *)sk_new_null()) 943 944 #define sk_CONF_VALUE_num(sk) \ 945 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(CONF_VALUE) *, sk)) 946 947 #define sk_CONF_VALUE_zero(sk) \ 948 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk)); 949 950 #define sk_CONF_VALUE_value(sk, i) \ 951 ((CONF_VALUE *)sk_value( \ 952 CHECKED_CAST(const _STACK *, const STACK_OF(CONF_VALUE) *, sk), (i))) 953 954 #define sk_CONF_VALUE_set(sk, i, p) \ 955 ((CONF_VALUE *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \ 956 (i), CHECKED_CAST(void *, CONF_VALUE *, p))) 957 958 #define sk_CONF_VALUE_free(sk) \ 959 sk_free(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk)) 960 961 #define sk_CONF_VALUE_pop_free(sk, free_func) \ 962 sk_pop_free( \ 963 CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \ 964 CHECKED_CAST(void (*)(void *), void (*)(CONF_VALUE *), free_func)) 965 966 #define sk_CONF_VALUE_insert(sk, p, where) \ 967 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \ 968 CHECKED_CAST(void *, CONF_VALUE *, p), (where)) 969 970 #define sk_CONF_VALUE_delete(sk, where) \ 971 ((CONF_VALUE *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \ 972 (where))) 973 974 #define sk_CONF_VALUE_delete_ptr(sk, p) \ 975 ((CONF_VALUE *)sk_delete_ptr( \ 976 CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \ 977 CHECKED_CAST(void *, CONF_VALUE *, p))) 978 979 #define sk_CONF_VALUE_find(sk, out_index, p) \ 980 sk_find(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), (out_index), \ 981 CHECKED_CAST(void *, CONF_VALUE *, p)) 982 983 #define sk_CONF_VALUE_shift(sk) \ 984 ((CONF_VALUE *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk))) 985 986 #define sk_CONF_VALUE_push(sk, p) \ 987 sk_push(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \ 988 CHECKED_CAST(void *, CONF_VALUE *, p)) 989 990 #define sk_CONF_VALUE_pop(sk) \ 991 ((CONF_VALUE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk))) 992 993 #define sk_CONF_VALUE_dup(sk) \ 994 ((STACK_OF(CONF_VALUE) *)sk_dup( \ 995 CHECKED_CAST(const _STACK *, const STACK_OF(CONF_VALUE) *, sk))) 996 997 #define sk_CONF_VALUE_sort(sk) \ 998 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk)) 999 1000 #define sk_CONF_VALUE_is_sorted(sk) \ 1001 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(CONF_VALUE) *, sk)) 1002 1003 #define sk_CONF_VALUE_set_cmp_func(sk, comp) \ 1004 ((int (*)(const CONF_VALUE **a, const CONF_VALUE **b))sk_set_cmp_func( \ 1005 CHECKED_CAST(_STACK *, STACK_OF(CONF_VALUE) *, sk), \ 1006 CHECKED_CAST(stack_cmp_func, \ 1007 int (*)(const CONF_VALUE **a, const CONF_VALUE **b), \ 1008 comp))) 1009 1010 #define sk_CONF_VALUE_deep_copy(sk, copy_func, free_func) \ 1011 ((STACK_OF(CONF_VALUE) *)sk_deep_copy( \ 1012 CHECKED_CAST(const _STACK *, const STACK_OF(CONF_VALUE) *, sk), \ 1013 CHECKED_CAST(void *(*)(void *), CONF_VALUE *(*)(CONF_VALUE *), \ 1014 copy_func), \ 1015 CHECKED_CAST(void (*)(void *), void (*)(CONF_VALUE *), free_func))) 1016 1017 /* CRYPTO_EX_DATA_FUNCS */ 1018 #define sk_CRYPTO_EX_DATA_FUNCS_new(comp) \ 1019 ((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_new(CHECKED_CAST( \ 1020 stack_cmp_func, \ 1021 int (*)(const CRYPTO_EX_DATA_FUNCS **a, const CRYPTO_EX_DATA_FUNCS **b), \ 1022 comp))) 1023 1024 #define sk_CRYPTO_EX_DATA_FUNCS_new_null() \ 1025 ((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_new_null()) 1026 1027 #define sk_CRYPTO_EX_DATA_FUNCS_num(sk) \ 1028 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, \ 1029 sk)) 1030 1031 #define sk_CRYPTO_EX_DATA_FUNCS_zero(sk) \ 1032 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk)); 1033 1034 #define sk_CRYPTO_EX_DATA_FUNCS_value(sk, i) \ 1035 ((CRYPTO_EX_DATA_FUNCS *)sk_value( \ 1036 CHECKED_CAST(const _STACK *, const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, \ 1037 sk), \ 1038 (i))) 1039 1040 #define sk_CRYPTO_EX_DATA_FUNCS_set(sk, i, p) \ 1041 ((CRYPTO_EX_DATA_FUNCS *)sk_set( \ 1042 CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), (i), \ 1043 CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p))) 1044 1045 #define sk_CRYPTO_EX_DATA_FUNCS_free(sk) \ 1046 sk_free(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk)) 1047 1048 #define sk_CRYPTO_EX_DATA_FUNCS_pop_free(sk, free_func) \ 1049 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \ 1050 CHECKED_CAST(void (*)(void *), void (*)(CRYPTO_EX_DATA_FUNCS *), \ 1051 free_func)) 1052 1053 #define sk_CRYPTO_EX_DATA_FUNCS_insert(sk, p, where) \ 1054 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \ 1055 CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p), (where)) 1056 1057 #define sk_CRYPTO_EX_DATA_FUNCS_delete(sk, where) \ 1058 ((CRYPTO_EX_DATA_FUNCS *)sk_delete( \ 1059 CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), (where))) 1060 1061 #define sk_CRYPTO_EX_DATA_FUNCS_delete_ptr(sk, p) \ 1062 ((CRYPTO_EX_DATA_FUNCS *)sk_delete_ptr( \ 1063 CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \ 1064 CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p))) 1065 1066 #define sk_CRYPTO_EX_DATA_FUNCS_find(sk, out_index, p) \ 1067 sk_find(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \ 1068 (out_index), CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p)) 1069 1070 #define sk_CRYPTO_EX_DATA_FUNCS_shift(sk) \ 1071 ((CRYPTO_EX_DATA_FUNCS *)sk_shift( \ 1072 CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk))) 1073 1074 #define sk_CRYPTO_EX_DATA_FUNCS_push(sk, p) \ 1075 sk_push(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \ 1076 CHECKED_CAST(void *, CRYPTO_EX_DATA_FUNCS *, p)) 1077 1078 #define sk_CRYPTO_EX_DATA_FUNCS_pop(sk) \ 1079 ((CRYPTO_EX_DATA_FUNCS *)sk_pop( \ 1080 CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk))) 1081 1082 #define sk_CRYPTO_EX_DATA_FUNCS_dup(sk) \ 1083 ((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_dup(CHECKED_CAST( \ 1084 const _STACK *, const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk))) 1085 1086 #define sk_CRYPTO_EX_DATA_FUNCS_sort(sk) \ 1087 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk)) 1088 1089 #define sk_CRYPTO_EX_DATA_FUNCS_is_sorted(sk) \ 1090 sk_is_sorted(CHECKED_CAST(const _STACK *, \ 1091 const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk)) 1092 1093 #define sk_CRYPTO_EX_DATA_FUNCS_set_cmp_func(sk, comp) \ 1094 ((int (*)(const CRYPTO_EX_DATA_FUNCS **a, const CRYPTO_EX_DATA_FUNCS **b)) \ 1095 sk_set_cmp_func( \ 1096 CHECKED_CAST(_STACK *, STACK_OF(CRYPTO_EX_DATA_FUNCS) *, sk), \ 1097 CHECKED_CAST(stack_cmp_func, \ 1098 int (*)(const CRYPTO_EX_DATA_FUNCS **a, \ 1099 const CRYPTO_EX_DATA_FUNCS **b), \ 1100 comp))) 1101 1102 #define sk_CRYPTO_EX_DATA_FUNCS_deep_copy(sk, copy_func, free_func) \ 1103 ((STACK_OF(CRYPTO_EX_DATA_FUNCS) *)sk_deep_copy( \ 1104 CHECKED_CAST(const _STACK *, const STACK_OF(CRYPTO_EX_DATA_FUNCS) *, \ 1105 sk), \ 1106 CHECKED_CAST(void *(*)(void *), \ 1107 CRYPTO_EX_DATA_FUNCS *(*)(CRYPTO_EX_DATA_FUNCS *), \ 1108 copy_func), \ 1109 CHECKED_CAST(void (*)(void *), void (*)(CRYPTO_EX_DATA_FUNCS *), \ 1110 free_func))) 1111 1112 /* DIST_POINT */ 1113 #define sk_DIST_POINT_new(comp) \ 1114 ((STACK_OF(DIST_POINT) *)sk_new(CHECKED_CAST( \ 1115 stack_cmp_func, int (*)(const DIST_POINT **a, const DIST_POINT **b), \ 1116 comp))) 1117 1118 #define sk_DIST_POINT_new_null() ((STACK_OF(DIST_POINT) *)sk_new_null()) 1119 1120 #define sk_DIST_POINT_num(sk) \ 1121 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(DIST_POINT) *, sk)) 1122 1123 #define sk_DIST_POINT_zero(sk) \ 1124 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk)); 1125 1126 #define sk_DIST_POINT_value(sk, i) \ 1127 ((DIST_POINT *)sk_value( \ 1128 CHECKED_CAST(const _STACK *, const STACK_OF(DIST_POINT) *, sk), (i))) 1129 1130 #define sk_DIST_POINT_set(sk, i, p) \ 1131 ((DIST_POINT *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \ 1132 (i), CHECKED_CAST(void *, DIST_POINT *, p))) 1133 1134 #define sk_DIST_POINT_free(sk) \ 1135 sk_free(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk)) 1136 1137 #define sk_DIST_POINT_pop_free(sk, free_func) \ 1138 sk_pop_free( \ 1139 CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \ 1140 CHECKED_CAST(void (*)(void *), void (*)(DIST_POINT *), free_func)) 1141 1142 #define sk_DIST_POINT_insert(sk, p, where) \ 1143 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \ 1144 CHECKED_CAST(void *, DIST_POINT *, p), (where)) 1145 1146 #define sk_DIST_POINT_delete(sk, where) \ 1147 ((DIST_POINT *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \ 1148 (where))) 1149 1150 #define sk_DIST_POINT_delete_ptr(sk, p) \ 1151 ((DIST_POINT *)sk_delete_ptr( \ 1152 CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \ 1153 CHECKED_CAST(void *, DIST_POINT *, p))) 1154 1155 #define sk_DIST_POINT_find(sk, out_index, p) \ 1156 sk_find(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), (out_index), \ 1157 CHECKED_CAST(void *, DIST_POINT *, p)) 1158 1159 #define sk_DIST_POINT_shift(sk) \ 1160 ((DIST_POINT *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk))) 1161 1162 #define sk_DIST_POINT_push(sk, p) \ 1163 sk_push(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \ 1164 CHECKED_CAST(void *, DIST_POINT *, p)) 1165 1166 #define sk_DIST_POINT_pop(sk) \ 1167 ((DIST_POINT *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk))) 1168 1169 #define sk_DIST_POINT_dup(sk) \ 1170 ((STACK_OF(DIST_POINT) *)sk_dup( \ 1171 CHECKED_CAST(const _STACK *, const STACK_OF(DIST_POINT) *, sk))) 1172 1173 #define sk_DIST_POINT_sort(sk) \ 1174 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk)) 1175 1176 #define sk_DIST_POINT_is_sorted(sk) \ 1177 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(DIST_POINT) *, sk)) 1178 1179 #define sk_DIST_POINT_set_cmp_func(sk, comp) \ 1180 ((int (*)(const DIST_POINT **a, const DIST_POINT **b))sk_set_cmp_func( \ 1181 CHECKED_CAST(_STACK *, STACK_OF(DIST_POINT) *, sk), \ 1182 CHECKED_CAST(stack_cmp_func, \ 1183 int (*)(const DIST_POINT **a, const DIST_POINT **b), \ 1184 comp))) 1185 1186 #define sk_DIST_POINT_deep_copy(sk, copy_func, free_func) \ 1187 ((STACK_OF(DIST_POINT) *)sk_deep_copy( \ 1188 CHECKED_CAST(const _STACK *, const STACK_OF(DIST_POINT) *, sk), \ 1189 CHECKED_CAST(void *(*)(void *), DIST_POINT *(*)(DIST_POINT *), \ 1190 copy_func), \ 1191 CHECKED_CAST(void (*)(void *), void (*)(DIST_POINT *), free_func))) 1192 1193 /* GENERAL_NAME */ 1194 #define sk_GENERAL_NAME_new(comp) \ 1195 ((STACK_OF(GENERAL_NAME) *)sk_new(CHECKED_CAST( \ 1196 stack_cmp_func, int (*)(const GENERAL_NAME **a, const GENERAL_NAME **b), \ 1197 comp))) 1198 1199 #define sk_GENERAL_NAME_new_null() ((STACK_OF(GENERAL_NAME) *)sk_new_null()) 1200 1201 #define sk_GENERAL_NAME_num(sk) \ 1202 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAME) *, sk)) 1203 1204 #define sk_GENERAL_NAME_zero(sk) \ 1205 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk)); 1206 1207 #define sk_GENERAL_NAME_value(sk, i) \ 1208 ((GENERAL_NAME *)sk_value( \ 1209 CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAME) *, sk), (i))) 1210 1211 #define sk_GENERAL_NAME_set(sk, i, p) \ 1212 ((GENERAL_NAME *)sk_set( \ 1213 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), (i), \ 1214 CHECKED_CAST(void *, GENERAL_NAME *, p))) 1215 1216 #define sk_GENERAL_NAME_free(sk) \ 1217 sk_free(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk)) 1218 1219 #define sk_GENERAL_NAME_pop_free(sk, free_func) \ 1220 sk_pop_free( \ 1221 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), \ 1222 CHECKED_CAST(void (*)(void *), void (*)(GENERAL_NAME *), free_func)) 1223 1224 #define sk_GENERAL_NAME_insert(sk, p, where) \ 1225 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), \ 1226 CHECKED_CAST(void *, GENERAL_NAME *, p), (where)) 1227 1228 #define sk_GENERAL_NAME_delete(sk, where) \ 1229 ((GENERAL_NAME *)sk_delete( \ 1230 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), (where))) 1231 1232 #define sk_GENERAL_NAME_delete_ptr(sk, p) \ 1233 ((GENERAL_NAME *)sk_delete_ptr( \ 1234 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), \ 1235 CHECKED_CAST(void *, GENERAL_NAME *, p))) 1236 1237 #define sk_GENERAL_NAME_find(sk, out_index, p) \ 1238 sk_find(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), (out_index), \ 1239 CHECKED_CAST(void *, GENERAL_NAME *, p)) 1240 1241 #define sk_GENERAL_NAME_shift(sk) \ 1242 ((GENERAL_NAME *)sk_shift( \ 1243 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk))) 1244 1245 #define sk_GENERAL_NAME_push(sk, p) \ 1246 sk_push(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), \ 1247 CHECKED_CAST(void *, GENERAL_NAME *, p)) 1248 1249 #define sk_GENERAL_NAME_pop(sk) \ 1250 ((GENERAL_NAME *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk))) 1251 1252 #define sk_GENERAL_NAME_dup(sk) \ 1253 ((STACK_OF(GENERAL_NAME) *)sk_dup( \ 1254 CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAME) *, sk))) 1255 1256 #define sk_GENERAL_NAME_sort(sk) \ 1257 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk)) 1258 1259 #define sk_GENERAL_NAME_is_sorted(sk) \ 1260 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAME) *, sk)) 1261 1262 #define sk_GENERAL_NAME_set_cmp_func(sk, comp) \ 1263 ((int (*)(const GENERAL_NAME **a, const GENERAL_NAME **b))sk_set_cmp_func( \ 1264 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAME) *, sk), \ 1265 CHECKED_CAST(stack_cmp_func, \ 1266 int (*)(const GENERAL_NAME **a, const GENERAL_NAME **b), \ 1267 comp))) 1268 1269 #define sk_GENERAL_NAME_deep_copy(sk, copy_func, free_func) \ 1270 ((STACK_OF(GENERAL_NAME) *)sk_deep_copy( \ 1271 CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAME) *, sk), \ 1272 CHECKED_CAST(void *(*)(void *), GENERAL_NAME *(*)(GENERAL_NAME *), \ 1273 copy_func), \ 1274 CHECKED_CAST(void (*)(void *), void (*)(GENERAL_NAME *), free_func))) 1275 1276 /* GENERAL_NAMES */ 1277 #define sk_GENERAL_NAMES_new(comp) \ 1278 ((STACK_OF(GENERAL_NAMES) *)sk_new(CHECKED_CAST( \ 1279 stack_cmp_func, \ 1280 int (*)(const GENERAL_NAMES **a, const GENERAL_NAMES **b), comp))) 1281 1282 #define sk_GENERAL_NAMES_new_null() ((STACK_OF(GENERAL_NAMES) *)sk_new_null()) 1283 1284 #define sk_GENERAL_NAMES_num(sk) \ 1285 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAMES) *, sk)) 1286 1287 #define sk_GENERAL_NAMES_zero(sk) \ 1288 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk)); 1289 1290 #define sk_GENERAL_NAMES_value(sk, i) \ 1291 ((GENERAL_NAMES *)sk_value( \ 1292 CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAMES) *, sk), (i))) 1293 1294 #define sk_GENERAL_NAMES_set(sk, i, p) \ 1295 ((GENERAL_NAMES *)sk_set( \ 1296 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), (i), \ 1297 CHECKED_CAST(void *, GENERAL_NAMES *, p))) 1298 1299 #define sk_GENERAL_NAMES_free(sk) \ 1300 sk_free(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk)) 1301 1302 #define sk_GENERAL_NAMES_pop_free(sk, free_func) \ 1303 sk_pop_free( \ 1304 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), \ 1305 CHECKED_CAST(void (*)(void *), void (*)(GENERAL_NAMES *), free_func)) 1306 1307 #define sk_GENERAL_NAMES_insert(sk, p, where) \ 1308 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), \ 1309 CHECKED_CAST(void *, GENERAL_NAMES *, p), (where)) 1310 1311 #define sk_GENERAL_NAMES_delete(sk, where) \ 1312 ((GENERAL_NAMES *)sk_delete( \ 1313 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), (where))) 1314 1315 #define sk_GENERAL_NAMES_delete_ptr(sk, p) \ 1316 ((GENERAL_NAMES *)sk_delete_ptr( \ 1317 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), \ 1318 CHECKED_CAST(void *, GENERAL_NAMES *, p))) 1319 1320 #define sk_GENERAL_NAMES_find(sk, out_index, p) \ 1321 sk_find(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), (out_index), \ 1322 CHECKED_CAST(void *, GENERAL_NAMES *, p)) 1323 1324 #define sk_GENERAL_NAMES_shift(sk) \ 1325 ((GENERAL_NAMES *)sk_shift( \ 1326 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk))) 1327 1328 #define sk_GENERAL_NAMES_push(sk, p) \ 1329 sk_push(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), \ 1330 CHECKED_CAST(void *, GENERAL_NAMES *, p)) 1331 1332 #define sk_GENERAL_NAMES_pop(sk) \ 1333 ((GENERAL_NAMES *)sk_pop( \ 1334 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk))) 1335 1336 #define sk_GENERAL_NAMES_dup(sk) \ 1337 ((STACK_OF(GENERAL_NAMES) *)sk_dup( \ 1338 CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAMES) *, sk))) 1339 1340 #define sk_GENERAL_NAMES_sort(sk) \ 1341 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk)) 1342 1343 #define sk_GENERAL_NAMES_is_sorted(sk) \ 1344 sk_is_sorted( \ 1345 CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAMES) *, sk)) 1346 1347 #define sk_GENERAL_NAMES_set_cmp_func(sk, comp) \ 1348 ((int (*)(const GENERAL_NAMES **a, const GENERAL_NAMES **b))sk_set_cmp_func( \ 1349 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_NAMES) *, sk), \ 1350 CHECKED_CAST(stack_cmp_func, \ 1351 int (*)(const GENERAL_NAMES **a, const GENERAL_NAMES **b), \ 1352 comp))) 1353 1354 #define sk_GENERAL_NAMES_deep_copy(sk, copy_func, free_func) \ 1355 ((STACK_OF(GENERAL_NAMES) *)sk_deep_copy( \ 1356 CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_NAMES) *, sk), \ 1357 CHECKED_CAST(void *(*)(void *), GENERAL_NAMES *(*)(GENERAL_NAMES *), \ 1358 copy_func), \ 1359 CHECKED_CAST(void (*)(void *), void (*)(GENERAL_NAMES *), free_func))) 1360 1361 /* GENERAL_SUBTREE */ 1362 #define sk_GENERAL_SUBTREE_new(comp) \ 1363 ((STACK_OF(GENERAL_SUBTREE) *)sk_new(CHECKED_CAST( \ 1364 stack_cmp_func, \ 1365 int (*)(const GENERAL_SUBTREE **a, const GENERAL_SUBTREE **b), comp))) 1366 1367 #define sk_GENERAL_SUBTREE_new_null() \ 1368 ((STACK_OF(GENERAL_SUBTREE) *)sk_new_null()) 1369 1370 #define sk_GENERAL_SUBTREE_num(sk) \ 1371 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_SUBTREE) *, sk)) 1372 1373 #define sk_GENERAL_SUBTREE_zero(sk) \ 1374 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk)); 1375 1376 #define sk_GENERAL_SUBTREE_value(sk, i) \ 1377 ((GENERAL_SUBTREE *)sk_value( \ 1378 CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_SUBTREE) *, sk), \ 1379 (i))) 1380 1381 #define sk_GENERAL_SUBTREE_set(sk, i, p) \ 1382 ((GENERAL_SUBTREE *)sk_set( \ 1383 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), (i), \ 1384 CHECKED_CAST(void *, GENERAL_SUBTREE *, p))) 1385 1386 #define sk_GENERAL_SUBTREE_free(sk) \ 1387 sk_free(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk)) 1388 1389 #define sk_GENERAL_SUBTREE_pop_free(sk, free_func) \ 1390 sk_pop_free( \ 1391 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \ 1392 CHECKED_CAST(void (*)(void *), void (*)(GENERAL_SUBTREE *), free_func)) 1393 1394 #define sk_GENERAL_SUBTREE_insert(sk, p, where) \ 1395 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \ 1396 CHECKED_CAST(void *, GENERAL_SUBTREE *, p), (where)) 1397 1398 #define sk_GENERAL_SUBTREE_delete(sk, where) \ 1399 ((GENERAL_SUBTREE *)sk_delete( \ 1400 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), (where))) 1401 1402 #define sk_GENERAL_SUBTREE_delete_ptr(sk, p) \ 1403 ((GENERAL_SUBTREE *)sk_delete_ptr( \ 1404 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \ 1405 CHECKED_CAST(void *, GENERAL_SUBTREE *, p))) 1406 1407 #define sk_GENERAL_SUBTREE_find(sk, out_index, p) \ 1408 sk_find(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \ 1409 (out_index), CHECKED_CAST(void *, GENERAL_SUBTREE *, p)) 1410 1411 #define sk_GENERAL_SUBTREE_shift(sk) \ 1412 ((GENERAL_SUBTREE *)sk_shift( \ 1413 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk))) 1414 1415 #define sk_GENERAL_SUBTREE_push(sk, p) \ 1416 sk_push(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \ 1417 CHECKED_CAST(void *, GENERAL_SUBTREE *, p)) 1418 1419 #define sk_GENERAL_SUBTREE_pop(sk) \ 1420 ((GENERAL_SUBTREE *)sk_pop( \ 1421 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk))) 1422 1423 #define sk_GENERAL_SUBTREE_dup(sk) \ 1424 ((STACK_OF(GENERAL_SUBTREE) *)sk_dup( \ 1425 CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_SUBTREE) *, sk))) 1426 1427 #define sk_GENERAL_SUBTREE_sort(sk) \ 1428 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk)) 1429 1430 #define sk_GENERAL_SUBTREE_is_sorted(sk) \ 1431 sk_is_sorted( \ 1432 CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_SUBTREE) *, sk)) 1433 1434 #define sk_GENERAL_SUBTREE_set_cmp_func(sk, comp) \ 1435 ((int (*)(const GENERAL_SUBTREE **a, const GENERAL_SUBTREE **b)) \ 1436 sk_set_cmp_func( \ 1437 CHECKED_CAST(_STACK *, STACK_OF(GENERAL_SUBTREE) *, sk), \ 1438 CHECKED_CAST(stack_cmp_func, int (*)(const GENERAL_SUBTREE **a, \ 1439 const GENERAL_SUBTREE **b), \ 1440 comp))) 1441 1442 #define sk_GENERAL_SUBTREE_deep_copy(sk, copy_func, free_func) \ 1443 ((STACK_OF(GENERAL_SUBTREE) *)sk_deep_copy( \ 1444 CHECKED_CAST(const _STACK *, const STACK_OF(GENERAL_SUBTREE) *, sk), \ 1445 CHECKED_CAST(void *(*)(void *), GENERAL_SUBTREE *(*)(GENERAL_SUBTREE *), \ 1446 copy_func), \ 1447 CHECKED_CAST(void (*)(void *), void (*)(GENERAL_SUBTREE *), free_func))) 1448 1449 /* POLICYINFO */ 1450 #define sk_POLICYINFO_new(comp) \ 1451 ((STACK_OF(POLICYINFO) *)sk_new(CHECKED_CAST( \ 1452 stack_cmp_func, int (*)(const POLICYINFO **a, const POLICYINFO **b), \ 1453 comp))) 1454 1455 #define sk_POLICYINFO_new_null() ((STACK_OF(POLICYINFO) *)sk_new_null()) 1456 1457 #define sk_POLICYINFO_num(sk) \ 1458 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(POLICYINFO) *, sk)) 1459 1460 #define sk_POLICYINFO_zero(sk) \ 1461 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk)); 1462 1463 #define sk_POLICYINFO_value(sk, i) \ 1464 ((POLICYINFO *)sk_value( \ 1465 CHECKED_CAST(const _STACK *, const STACK_OF(POLICYINFO) *, sk), (i))) 1466 1467 #define sk_POLICYINFO_set(sk, i, p) \ 1468 ((POLICYINFO *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \ 1469 (i), CHECKED_CAST(void *, POLICYINFO *, p))) 1470 1471 #define sk_POLICYINFO_free(sk) \ 1472 sk_free(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk)) 1473 1474 #define sk_POLICYINFO_pop_free(sk, free_func) \ 1475 sk_pop_free( \ 1476 CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \ 1477 CHECKED_CAST(void (*)(void *), void (*)(POLICYINFO *), free_func)) 1478 1479 #define sk_POLICYINFO_insert(sk, p, where) \ 1480 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \ 1481 CHECKED_CAST(void *, POLICYINFO *, p), (where)) 1482 1483 #define sk_POLICYINFO_delete(sk, where) \ 1484 ((POLICYINFO *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \ 1485 (where))) 1486 1487 #define sk_POLICYINFO_delete_ptr(sk, p) \ 1488 ((POLICYINFO *)sk_delete_ptr( \ 1489 CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \ 1490 CHECKED_CAST(void *, POLICYINFO *, p))) 1491 1492 #define sk_POLICYINFO_find(sk, out_index, p) \ 1493 sk_find(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), (out_index), \ 1494 CHECKED_CAST(void *, POLICYINFO *, p)) 1495 1496 #define sk_POLICYINFO_shift(sk) \ 1497 ((POLICYINFO *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk))) 1498 1499 #define sk_POLICYINFO_push(sk, p) \ 1500 sk_push(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \ 1501 CHECKED_CAST(void *, POLICYINFO *, p)) 1502 1503 #define sk_POLICYINFO_pop(sk) \ 1504 ((POLICYINFO *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk))) 1505 1506 #define sk_POLICYINFO_dup(sk) \ 1507 ((STACK_OF(POLICYINFO) *)sk_dup( \ 1508 CHECKED_CAST(const _STACK *, const STACK_OF(POLICYINFO) *, sk))) 1509 1510 #define sk_POLICYINFO_sort(sk) \ 1511 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk)) 1512 1513 #define sk_POLICYINFO_is_sorted(sk) \ 1514 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(POLICYINFO) *, sk)) 1515 1516 #define sk_POLICYINFO_set_cmp_func(sk, comp) \ 1517 ((int (*)(const POLICYINFO **a, const POLICYINFO **b))sk_set_cmp_func( \ 1518 CHECKED_CAST(_STACK *, STACK_OF(POLICYINFO) *, sk), \ 1519 CHECKED_CAST(stack_cmp_func, \ 1520 int (*)(const POLICYINFO **a, const POLICYINFO **b), \ 1521 comp))) 1522 1523 #define sk_POLICYINFO_deep_copy(sk, copy_func, free_func) \ 1524 ((STACK_OF(POLICYINFO) *)sk_deep_copy( \ 1525 CHECKED_CAST(const _STACK *, const STACK_OF(POLICYINFO) *, sk), \ 1526 CHECKED_CAST(void *(*)(void *), POLICYINFO *(*)(POLICYINFO *), \ 1527 copy_func), \ 1528 CHECKED_CAST(void (*)(void *), void (*)(POLICYINFO *), free_func))) 1529 1530 /* POLICYQUALINFO */ 1531 #define sk_POLICYQUALINFO_new(comp) \ 1532 ((STACK_OF(POLICYQUALINFO) *)sk_new(CHECKED_CAST( \ 1533 stack_cmp_func, \ 1534 int (*)(const POLICYQUALINFO **a, const POLICYQUALINFO **b), comp))) 1535 1536 #define sk_POLICYQUALINFO_new_null() ((STACK_OF(POLICYQUALINFO) *)sk_new_null()) 1537 1538 #define sk_POLICYQUALINFO_num(sk) \ 1539 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(POLICYQUALINFO) *, sk)) 1540 1541 #define sk_POLICYQUALINFO_zero(sk) \ 1542 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk)); 1543 1544 #define sk_POLICYQUALINFO_value(sk, i) \ 1545 ((POLICYQUALINFO *)sk_value( \ 1546 CHECKED_CAST(const _STACK *, const STACK_OF(POLICYQUALINFO) *, sk), \ 1547 (i))) 1548 1549 #define sk_POLICYQUALINFO_set(sk, i, p) \ 1550 ((POLICYQUALINFO *)sk_set( \ 1551 CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), (i), \ 1552 CHECKED_CAST(void *, POLICYQUALINFO *, p))) 1553 1554 #define sk_POLICYQUALINFO_free(sk) \ 1555 sk_free(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk)) 1556 1557 #define sk_POLICYQUALINFO_pop_free(sk, free_func) \ 1558 sk_pop_free( \ 1559 CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), \ 1560 CHECKED_CAST(void (*)(void *), void (*)(POLICYQUALINFO *), free_func)) 1561 1562 #define sk_POLICYQUALINFO_insert(sk, p, where) \ 1563 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), \ 1564 CHECKED_CAST(void *, POLICYQUALINFO *, p), (where)) 1565 1566 #define sk_POLICYQUALINFO_delete(sk, where) \ 1567 ((POLICYQUALINFO *)sk_delete( \ 1568 CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), (where))) 1569 1570 #define sk_POLICYQUALINFO_delete_ptr(sk, p) \ 1571 ((POLICYQUALINFO *)sk_delete_ptr( \ 1572 CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), \ 1573 CHECKED_CAST(void *, POLICYQUALINFO *, p))) 1574 1575 #define sk_POLICYQUALINFO_find(sk, out_index, p) \ 1576 sk_find(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), (out_index), \ 1577 CHECKED_CAST(void *, POLICYQUALINFO *, p)) 1578 1579 #define sk_POLICYQUALINFO_shift(sk) \ 1580 ((POLICYQUALINFO *)sk_shift( \ 1581 CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk))) 1582 1583 #define sk_POLICYQUALINFO_push(sk, p) \ 1584 sk_push(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), \ 1585 CHECKED_CAST(void *, POLICYQUALINFO *, p)) 1586 1587 #define sk_POLICYQUALINFO_pop(sk) \ 1588 ((POLICYQUALINFO *)sk_pop( \ 1589 CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk))) 1590 1591 #define sk_POLICYQUALINFO_dup(sk) \ 1592 ((STACK_OF(POLICYQUALINFO) *)sk_dup( \ 1593 CHECKED_CAST(const _STACK *, const STACK_OF(POLICYQUALINFO) *, sk))) 1594 1595 #define sk_POLICYQUALINFO_sort(sk) \ 1596 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk)) 1597 1598 #define sk_POLICYQUALINFO_is_sorted(sk) \ 1599 sk_is_sorted( \ 1600 CHECKED_CAST(const _STACK *, const STACK_OF(POLICYQUALINFO) *, sk)) 1601 1602 #define sk_POLICYQUALINFO_set_cmp_func(sk, comp) \ 1603 ((int (*)(const POLICYQUALINFO **a, const POLICYQUALINFO **b)) \ 1604 sk_set_cmp_func( \ 1605 CHECKED_CAST(_STACK *, STACK_OF(POLICYQUALINFO) *, sk), \ 1606 CHECKED_CAST(stack_cmp_func, int (*)(const POLICYQUALINFO **a, \ 1607 const POLICYQUALINFO **b), \ 1608 comp))) 1609 1610 #define sk_POLICYQUALINFO_deep_copy(sk, copy_func, free_func) \ 1611 ((STACK_OF(POLICYQUALINFO) *)sk_deep_copy( \ 1612 CHECKED_CAST(const _STACK *, const STACK_OF(POLICYQUALINFO) *, sk), \ 1613 CHECKED_CAST(void *(*)(void *), POLICYQUALINFO *(*)(POLICYQUALINFO *), \ 1614 copy_func), \ 1615 CHECKED_CAST(void (*)(void *), void (*)(POLICYQUALINFO *), free_func))) 1616 1617 /* POLICY_MAPPING */ 1618 #define sk_POLICY_MAPPING_new(comp) \ 1619 ((STACK_OF(POLICY_MAPPING) *)sk_new(CHECKED_CAST( \ 1620 stack_cmp_func, \ 1621 int (*)(const POLICY_MAPPING **a, const POLICY_MAPPING **b), comp))) 1622 1623 #define sk_POLICY_MAPPING_new_null() ((STACK_OF(POLICY_MAPPING) *)sk_new_null()) 1624 1625 #define sk_POLICY_MAPPING_num(sk) \ 1626 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(POLICY_MAPPING) *, sk)) 1627 1628 #define sk_POLICY_MAPPING_zero(sk) \ 1629 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk)); 1630 1631 #define sk_POLICY_MAPPING_value(sk, i) \ 1632 ((POLICY_MAPPING *)sk_value( \ 1633 CHECKED_CAST(const _STACK *, const STACK_OF(POLICY_MAPPING) *, sk), \ 1634 (i))) 1635 1636 #define sk_POLICY_MAPPING_set(sk, i, p) \ 1637 ((POLICY_MAPPING *)sk_set( \ 1638 CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), (i), \ 1639 CHECKED_CAST(void *, POLICY_MAPPING *, p))) 1640 1641 #define sk_POLICY_MAPPING_free(sk) \ 1642 sk_free(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk)) 1643 1644 #define sk_POLICY_MAPPING_pop_free(sk, free_func) \ 1645 sk_pop_free( \ 1646 CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), \ 1647 CHECKED_CAST(void (*)(void *), void (*)(POLICY_MAPPING *), free_func)) 1648 1649 #define sk_POLICY_MAPPING_insert(sk, p, where) \ 1650 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), \ 1651 CHECKED_CAST(void *, POLICY_MAPPING *, p), (where)) 1652 1653 #define sk_POLICY_MAPPING_delete(sk, where) \ 1654 ((POLICY_MAPPING *)sk_delete( \ 1655 CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), (where))) 1656 1657 #define sk_POLICY_MAPPING_delete_ptr(sk, p) \ 1658 ((POLICY_MAPPING *)sk_delete_ptr( \ 1659 CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), \ 1660 CHECKED_CAST(void *, POLICY_MAPPING *, p))) 1661 1662 #define sk_POLICY_MAPPING_find(sk, out_index, p) \ 1663 sk_find(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), (out_index), \ 1664 CHECKED_CAST(void *, POLICY_MAPPING *, p)) 1665 1666 #define sk_POLICY_MAPPING_shift(sk) \ 1667 ((POLICY_MAPPING *)sk_shift( \ 1668 CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk))) 1669 1670 #define sk_POLICY_MAPPING_push(sk, p) \ 1671 sk_push(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), \ 1672 CHECKED_CAST(void *, POLICY_MAPPING *, p)) 1673 1674 #define sk_POLICY_MAPPING_pop(sk) \ 1675 ((POLICY_MAPPING *)sk_pop( \ 1676 CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk))) 1677 1678 #define sk_POLICY_MAPPING_dup(sk) \ 1679 ((STACK_OF(POLICY_MAPPING) *)sk_dup( \ 1680 CHECKED_CAST(const _STACK *, const STACK_OF(POLICY_MAPPING) *, sk))) 1681 1682 #define sk_POLICY_MAPPING_sort(sk) \ 1683 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk)) 1684 1685 #define sk_POLICY_MAPPING_is_sorted(sk) \ 1686 sk_is_sorted( \ 1687 CHECKED_CAST(const _STACK *, const STACK_OF(POLICY_MAPPING) *, sk)) 1688 1689 #define sk_POLICY_MAPPING_set_cmp_func(sk, comp) \ 1690 ((int (*)(const POLICY_MAPPING **a, const POLICY_MAPPING **b)) \ 1691 sk_set_cmp_func( \ 1692 CHECKED_CAST(_STACK *, STACK_OF(POLICY_MAPPING) *, sk), \ 1693 CHECKED_CAST(stack_cmp_func, int (*)(const POLICY_MAPPING **a, \ 1694 const POLICY_MAPPING **b), \ 1695 comp))) 1696 1697 #define sk_POLICY_MAPPING_deep_copy(sk, copy_func, free_func) \ 1698 ((STACK_OF(POLICY_MAPPING) *)sk_deep_copy( \ 1699 CHECKED_CAST(const _STACK *, const STACK_OF(POLICY_MAPPING) *, sk), \ 1700 CHECKED_CAST(void *(*)(void *), POLICY_MAPPING *(*)(POLICY_MAPPING *), \ 1701 copy_func), \ 1702 CHECKED_CAST(void (*)(void *), void (*)(POLICY_MAPPING *), free_func))) 1703 1704 /* RSA_additional_prime */ 1705 #define sk_RSA_additional_prime_new(comp) \ 1706 ((STACK_OF(RSA_additional_prime) *)sk_new(CHECKED_CAST( \ 1707 stack_cmp_func, \ 1708 int (*)(const RSA_additional_prime **a, const RSA_additional_prime **b), \ 1709 comp))) 1710 1711 #define sk_RSA_additional_prime_new_null() \ 1712 ((STACK_OF(RSA_additional_prime) *)sk_new_null()) 1713 1714 #define sk_RSA_additional_prime_num(sk) \ 1715 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(RSA_additional_prime) *, \ 1716 sk)) 1717 1718 #define sk_RSA_additional_prime_zero(sk) \ 1719 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk)); 1720 1721 #define sk_RSA_additional_prime_value(sk, i) \ 1722 ((RSA_additional_prime *)sk_value( \ 1723 CHECKED_CAST(const _STACK *, const STACK_OF(RSA_additional_prime) *, \ 1724 sk), \ 1725 (i))) 1726 1727 #define sk_RSA_additional_prime_set(sk, i, p) \ 1728 ((RSA_additional_prime *)sk_set( \ 1729 CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), (i), \ 1730 CHECKED_CAST(void *, RSA_additional_prime *, p))) 1731 1732 #define sk_RSA_additional_prime_free(sk) \ 1733 sk_free(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk)) 1734 1735 #define sk_RSA_additional_prime_pop_free(sk, free_func) \ 1736 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), \ 1737 CHECKED_CAST(void (*)(void *), void (*)(RSA_additional_prime *), \ 1738 free_func)) 1739 1740 #define sk_RSA_additional_prime_insert(sk, p, where) \ 1741 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), \ 1742 CHECKED_CAST(void *, RSA_additional_prime *, p), (where)) 1743 1744 #define sk_RSA_additional_prime_delete(sk, where) \ 1745 ((RSA_additional_prime *)sk_delete( \ 1746 CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), (where))) 1747 1748 #define sk_RSA_additional_prime_delete_ptr(sk, p) \ 1749 ((RSA_additional_prime *)sk_delete_ptr( \ 1750 CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), \ 1751 CHECKED_CAST(void *, RSA_additional_prime *, p))) 1752 1753 #define sk_RSA_additional_prime_find(sk, out_index, p) \ 1754 sk_find(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), \ 1755 (out_index), CHECKED_CAST(void *, RSA_additional_prime *, p)) 1756 1757 #define sk_RSA_additional_prime_shift(sk) \ 1758 ((RSA_additional_prime *)sk_shift( \ 1759 CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk))) 1760 1761 #define sk_RSA_additional_prime_push(sk, p) \ 1762 sk_push(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), \ 1763 CHECKED_CAST(void *, RSA_additional_prime *, p)) 1764 1765 #define sk_RSA_additional_prime_pop(sk) \ 1766 ((RSA_additional_prime *)sk_pop( \ 1767 CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk))) 1768 1769 #define sk_RSA_additional_prime_dup(sk) \ 1770 ((STACK_OF(RSA_additional_prime) *)sk_dup(CHECKED_CAST( \ 1771 const _STACK *, const STACK_OF(RSA_additional_prime) *, sk))) 1772 1773 #define sk_RSA_additional_prime_sort(sk) \ 1774 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk)) 1775 1776 #define sk_RSA_additional_prime_is_sorted(sk) \ 1777 sk_is_sorted(CHECKED_CAST(const _STACK *, \ 1778 const STACK_OF(RSA_additional_prime) *, sk)) 1779 1780 #define sk_RSA_additional_prime_set_cmp_func(sk, comp) \ 1781 ((int (*)(const RSA_additional_prime **a, const RSA_additional_prime **b)) \ 1782 sk_set_cmp_func( \ 1783 CHECKED_CAST(_STACK *, STACK_OF(RSA_additional_prime) *, sk), \ 1784 CHECKED_CAST(stack_cmp_func, \ 1785 int (*)(const RSA_additional_prime **a, \ 1786 const RSA_additional_prime **b), \ 1787 comp))) 1788 1789 #define sk_RSA_additional_prime_deep_copy(sk, copy_func, free_func) \ 1790 ((STACK_OF(RSA_additional_prime) *)sk_deep_copy( \ 1791 CHECKED_CAST(const _STACK *, const STACK_OF(RSA_additional_prime) *, \ 1792 sk), \ 1793 CHECKED_CAST(void *(*)(void *), \ 1794 RSA_additional_prime *(*)(RSA_additional_prime *), \ 1795 copy_func), \ 1796 CHECKED_CAST(void (*)(void *), void (*)(RSA_additional_prime *), \ 1797 free_func))) 1798 1799 /* SSL_COMP */ 1800 #define sk_SSL_COMP_new(comp) \ 1801 ((STACK_OF(SSL_COMP) *)sk_new(CHECKED_CAST( \ 1802 stack_cmp_func, int (*)(const SSL_COMP **a, const SSL_COMP **b), comp))) 1803 1804 #define sk_SSL_COMP_new_null() ((STACK_OF(SSL_COMP) *)sk_new_null()) 1805 1806 #define sk_SSL_COMP_num(sk) \ 1807 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(SSL_COMP) *, sk)) 1808 1809 #define sk_SSL_COMP_zero(sk) \ 1810 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk)); 1811 1812 #define sk_SSL_COMP_value(sk, i) \ 1813 ((SSL_COMP *)sk_value( \ 1814 CHECKED_CAST(const _STACK *, const STACK_OF(SSL_COMP) *, sk), (i))) 1815 1816 #define sk_SSL_COMP_set(sk, i, p) \ 1817 ((SSL_COMP *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), (i), \ 1818 CHECKED_CAST(void *, SSL_COMP *, p))) 1819 1820 #define sk_SSL_COMP_free(sk) \ 1821 sk_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk)) 1822 1823 #define sk_SSL_COMP_pop_free(sk, free_func) \ 1824 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \ 1825 CHECKED_CAST(void (*)(void *), void (*)(SSL_COMP *), free_func)) 1826 1827 #define sk_SSL_COMP_insert(sk, p, where) \ 1828 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \ 1829 CHECKED_CAST(void *, SSL_COMP *, p), (where)) 1830 1831 #define sk_SSL_COMP_delete(sk, where) \ 1832 ((SSL_COMP *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \ 1833 (where))) 1834 1835 #define sk_SSL_COMP_delete_ptr(sk, p) \ 1836 ((SSL_COMP *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \ 1837 CHECKED_CAST(void *, SSL_COMP *, p))) 1838 1839 #define sk_SSL_COMP_find(sk, out_index, p) \ 1840 sk_find(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), (out_index), \ 1841 CHECKED_CAST(void *, SSL_COMP *, p)) 1842 1843 #define sk_SSL_COMP_shift(sk) \ 1844 ((SSL_COMP *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk))) 1845 1846 #define sk_SSL_COMP_push(sk, p) \ 1847 sk_push(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \ 1848 CHECKED_CAST(void *, SSL_COMP *, p)) 1849 1850 #define sk_SSL_COMP_pop(sk) \ 1851 ((SSL_COMP *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk))) 1852 1853 #define sk_SSL_COMP_dup(sk) \ 1854 ((STACK_OF(SSL_COMP) *)sk_dup( \ 1855 CHECKED_CAST(const _STACK *, const STACK_OF(SSL_COMP) *, sk))) 1856 1857 #define sk_SSL_COMP_sort(sk) \ 1858 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk)) 1859 1860 #define sk_SSL_COMP_is_sorted(sk) \ 1861 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(SSL_COMP) *, sk)) 1862 1863 #define sk_SSL_COMP_set_cmp_func(sk, comp) \ 1864 ((int (*)(const SSL_COMP **a, const SSL_COMP **b))sk_set_cmp_func( \ 1865 CHECKED_CAST(_STACK *, STACK_OF(SSL_COMP) *, sk), \ 1866 CHECKED_CAST(stack_cmp_func, \ 1867 int (*)(const SSL_COMP **a, const SSL_COMP **b), comp))) 1868 1869 #define sk_SSL_COMP_deep_copy(sk, copy_func, free_func) \ 1870 ((STACK_OF(SSL_COMP) *)sk_deep_copy( \ 1871 CHECKED_CAST(const _STACK *, const STACK_OF(SSL_COMP) *, sk), \ 1872 CHECKED_CAST(void *(*)(void *), SSL_COMP *(*)(SSL_COMP *), copy_func), \ 1873 CHECKED_CAST(void (*)(void *), void (*)(SSL_COMP *), free_func))) 1874 1875 /* SSL_CUSTOM_EXTENSION */ 1876 #define sk_SSL_CUSTOM_EXTENSION_new(comp) \ 1877 ((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_new(CHECKED_CAST( \ 1878 stack_cmp_func, \ 1879 int (*)(const SSL_CUSTOM_EXTENSION **a, const SSL_CUSTOM_EXTENSION **b), \ 1880 comp))) 1881 1882 #define sk_SSL_CUSTOM_EXTENSION_new_null() \ 1883 ((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_new_null()) 1884 1885 #define sk_SSL_CUSTOM_EXTENSION_num(sk) \ 1886 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, \ 1887 sk)) 1888 1889 #define sk_SSL_CUSTOM_EXTENSION_zero(sk) \ 1890 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk)); 1891 1892 #define sk_SSL_CUSTOM_EXTENSION_value(sk, i) \ 1893 ((SSL_CUSTOM_EXTENSION *)sk_value( \ 1894 CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, \ 1895 sk), \ 1896 (i))) 1897 1898 #define sk_SSL_CUSTOM_EXTENSION_set(sk, i, p) \ 1899 ((SSL_CUSTOM_EXTENSION *)sk_set( \ 1900 CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), (i), \ 1901 CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p))) 1902 1903 #define sk_SSL_CUSTOM_EXTENSION_free(sk) \ 1904 sk_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk)) 1905 1906 #define sk_SSL_CUSTOM_EXTENSION_pop_free(sk, free_func) \ 1907 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \ 1908 CHECKED_CAST(void (*)(void *), void (*)(SSL_CUSTOM_EXTENSION *), \ 1909 free_func)) 1910 1911 #define sk_SSL_CUSTOM_EXTENSION_insert(sk, p, where) \ 1912 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \ 1913 CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p), (where)) 1914 1915 #define sk_SSL_CUSTOM_EXTENSION_delete(sk, where) \ 1916 ((SSL_CUSTOM_EXTENSION *)sk_delete( \ 1917 CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), (where))) 1918 1919 #define sk_SSL_CUSTOM_EXTENSION_delete_ptr(sk, p) \ 1920 ((SSL_CUSTOM_EXTENSION *)sk_delete_ptr( \ 1921 CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \ 1922 CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p))) 1923 1924 #define sk_SSL_CUSTOM_EXTENSION_find(sk, out_index, p) \ 1925 sk_find(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \ 1926 (out_index), CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p)) 1927 1928 #define sk_SSL_CUSTOM_EXTENSION_shift(sk) \ 1929 ((SSL_CUSTOM_EXTENSION *)sk_shift( \ 1930 CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk))) 1931 1932 #define sk_SSL_CUSTOM_EXTENSION_push(sk, p) \ 1933 sk_push(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \ 1934 CHECKED_CAST(void *, SSL_CUSTOM_EXTENSION *, p)) 1935 1936 #define sk_SSL_CUSTOM_EXTENSION_pop(sk) \ 1937 ((SSL_CUSTOM_EXTENSION *)sk_pop( \ 1938 CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk))) 1939 1940 #define sk_SSL_CUSTOM_EXTENSION_dup(sk) \ 1941 ((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_dup(CHECKED_CAST( \ 1942 const _STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, sk))) 1943 1944 #define sk_SSL_CUSTOM_EXTENSION_sort(sk) \ 1945 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk)) 1946 1947 #define sk_SSL_CUSTOM_EXTENSION_is_sorted(sk) \ 1948 sk_is_sorted(CHECKED_CAST(const _STACK *, \ 1949 const STACK_OF(SSL_CUSTOM_EXTENSION) *, sk)) 1950 1951 #define sk_SSL_CUSTOM_EXTENSION_set_cmp_func(sk, comp) \ 1952 ((int (*)(const SSL_CUSTOM_EXTENSION **a, const SSL_CUSTOM_EXTENSION **b)) \ 1953 sk_set_cmp_func( \ 1954 CHECKED_CAST(_STACK *, STACK_OF(SSL_CUSTOM_EXTENSION) *, sk), \ 1955 CHECKED_CAST(stack_cmp_func, \ 1956 int (*)(const SSL_CUSTOM_EXTENSION **a, \ 1957 const SSL_CUSTOM_EXTENSION **b), \ 1958 comp))) 1959 1960 #define sk_SSL_CUSTOM_EXTENSION_deep_copy(sk, copy_func, free_func) \ 1961 ((STACK_OF(SSL_CUSTOM_EXTENSION) *)sk_deep_copy( \ 1962 CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CUSTOM_EXTENSION) *, \ 1963 sk), \ 1964 CHECKED_CAST(void *(*)(void *), \ 1965 SSL_CUSTOM_EXTENSION *(*)(SSL_CUSTOM_EXTENSION *), \ 1966 copy_func), \ 1967 CHECKED_CAST(void (*)(void *), void (*)(SSL_CUSTOM_EXTENSION *), \ 1968 free_func))) 1969 1970 /* STACK_OF_X509_NAME_ENTRY */ 1971 #define sk_STACK_OF_X509_NAME_ENTRY_new(comp) \ 1972 ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_new(CHECKED_CAST( \ 1973 stack_cmp_func, int (*)(const STACK_OF_X509_NAME_ENTRY **a, \ 1974 const STACK_OF_X509_NAME_ENTRY **b), \ 1975 comp))) 1976 1977 #define sk_STACK_OF_X509_NAME_ENTRY_new_null() \ 1978 ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_new_null()) 1979 1980 #define sk_STACK_OF_X509_NAME_ENTRY_num(sk) \ 1981 sk_num(CHECKED_CAST(const _STACK *, \ 1982 const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)) 1983 1984 #define sk_STACK_OF_X509_NAME_ENTRY_zero(sk) \ 1985 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)); 1986 1987 #define sk_STACK_OF_X509_NAME_ENTRY_value(sk, i) \ 1988 ((STACK_OF_X509_NAME_ENTRY *)sk_value( \ 1989 CHECKED_CAST(const _STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, \ 1990 sk), \ 1991 (i))) 1992 1993 #define sk_STACK_OF_X509_NAME_ENTRY_set(sk, i, p) \ 1994 ((STACK_OF_X509_NAME_ENTRY *)sk_set( \ 1995 CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), (i), \ 1996 CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p))) 1997 1998 #define sk_STACK_OF_X509_NAME_ENTRY_free(sk) \ 1999 sk_free(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)) 2000 2001 #define sk_STACK_OF_X509_NAME_ENTRY_pop_free(sk, free_func) \ 2002 sk_pop_free( \ 2003 CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \ 2004 CHECKED_CAST(void (*)(void *), void (*)(STACK_OF_X509_NAME_ENTRY *), \ 2005 free_func)) 2006 2007 #define sk_STACK_OF_X509_NAME_ENTRY_insert(sk, p, where) \ 2008 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \ 2009 CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p), (where)) 2010 2011 #define sk_STACK_OF_X509_NAME_ENTRY_delete(sk, where) \ 2012 ((STACK_OF_X509_NAME_ENTRY *)sk_delete( \ 2013 CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \ 2014 (where))) 2015 2016 #define sk_STACK_OF_X509_NAME_ENTRY_delete_ptr(sk, p) \ 2017 ((STACK_OF_X509_NAME_ENTRY *)sk_delete_ptr( \ 2018 CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \ 2019 CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p))) 2020 2021 #define sk_STACK_OF_X509_NAME_ENTRY_find(sk, out_index, p) \ 2022 sk_find(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \ 2023 (out_index), CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p)) 2024 2025 #define sk_STACK_OF_X509_NAME_ENTRY_shift(sk) \ 2026 ((STACK_OF_X509_NAME_ENTRY *)sk_shift( \ 2027 CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))) 2028 2029 #define sk_STACK_OF_X509_NAME_ENTRY_push(sk, p) \ 2030 sk_push(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \ 2031 CHECKED_CAST(void *, STACK_OF_X509_NAME_ENTRY *, p)) 2032 2033 #define sk_STACK_OF_X509_NAME_ENTRY_pop(sk) \ 2034 ((STACK_OF_X509_NAME_ENTRY *)sk_pop( \ 2035 CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))) 2036 2037 #define sk_STACK_OF_X509_NAME_ENTRY_dup(sk) \ 2038 ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_dup(CHECKED_CAST( \ 2039 const _STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk))) 2040 2041 #define sk_STACK_OF_X509_NAME_ENTRY_sort(sk) \ 2042 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)) 2043 2044 #define sk_STACK_OF_X509_NAME_ENTRY_is_sorted(sk) \ 2045 sk_is_sorted(CHECKED_CAST(const _STACK *, \ 2046 const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk)) 2047 2048 #define sk_STACK_OF_X509_NAME_ENTRY_set_cmp_func(sk, comp) \ 2049 ((int (*)(const STACK_OF_X509_NAME_ENTRY **a, \ 2050 const STACK_OF_X509_NAME_ENTRY **b)) \ 2051 sk_set_cmp_func( \ 2052 CHECKED_CAST(_STACK *, STACK_OF(STACK_OF_X509_NAME_ENTRY) *, sk), \ 2053 CHECKED_CAST(stack_cmp_func, \ 2054 int (*)(const STACK_OF_X509_NAME_ENTRY **a, \ 2055 const STACK_OF_X509_NAME_ENTRY **b), \ 2056 comp))) 2057 2058 #define sk_STACK_OF_X509_NAME_ENTRY_deep_copy(sk, copy_func, free_func) \ 2059 ((STACK_OF(STACK_OF_X509_NAME_ENTRY) *)sk_deep_copy( \ 2060 CHECKED_CAST(const _STACK *, const STACK_OF(STACK_OF_X509_NAME_ENTRY) *, \ 2061 sk), \ 2062 CHECKED_CAST(void *(*)(void *), \ 2063 STACK_OF_X509_NAME_ENTRY *(*)(STACK_OF_X509_NAME_ENTRY *), \ 2064 copy_func), \ 2065 CHECKED_CAST(void (*)(void *), void (*)(STACK_OF_X509_NAME_ENTRY *), \ 2066 free_func))) 2067 2068 /* SXNETID */ 2069 #define sk_SXNETID_new(comp) \ 2070 ((STACK_OF(SXNETID) *)sk_new(CHECKED_CAST( \ 2071 stack_cmp_func, int (*)(const SXNETID **a, const SXNETID **b), comp))) 2072 2073 #define sk_SXNETID_new_null() ((STACK_OF(SXNETID) *)sk_new_null()) 2074 2075 #define sk_SXNETID_num(sk) \ 2076 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(SXNETID) *, sk)) 2077 2078 #define sk_SXNETID_zero(sk) \ 2079 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk)); 2080 2081 #define sk_SXNETID_value(sk, i) \ 2082 ((SXNETID *)sk_value( \ 2083 CHECKED_CAST(const _STACK *, const STACK_OF(SXNETID) *, sk), (i))) 2084 2085 #define sk_SXNETID_set(sk, i, p) \ 2086 ((SXNETID *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), (i), \ 2087 CHECKED_CAST(void *, SXNETID *, p))) 2088 2089 #define sk_SXNETID_free(sk) \ 2090 sk_free(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk)) 2091 2092 #define sk_SXNETID_pop_free(sk, free_func) \ 2093 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \ 2094 CHECKED_CAST(void (*)(void *), void (*)(SXNETID *), free_func)) 2095 2096 #define sk_SXNETID_insert(sk, p, where) \ 2097 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \ 2098 CHECKED_CAST(void *, SXNETID *, p), (where)) 2099 2100 #define sk_SXNETID_delete(sk, where) \ 2101 ((SXNETID *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \ 2102 (where))) 2103 2104 #define sk_SXNETID_delete_ptr(sk, p) \ 2105 ((SXNETID *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \ 2106 CHECKED_CAST(void *, SXNETID *, p))) 2107 2108 #define sk_SXNETID_find(sk, out_index, p) \ 2109 sk_find(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), (out_index), \ 2110 CHECKED_CAST(void *, SXNETID *, p)) 2111 2112 #define sk_SXNETID_shift(sk) \ 2113 ((SXNETID *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk))) 2114 2115 #define sk_SXNETID_push(sk, p) \ 2116 sk_push(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \ 2117 CHECKED_CAST(void *, SXNETID *, p)) 2118 2119 #define sk_SXNETID_pop(sk) \ 2120 ((SXNETID *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk))) 2121 2122 #define sk_SXNETID_dup(sk) \ 2123 ((STACK_OF(SXNETID) *)sk_dup( \ 2124 CHECKED_CAST(const _STACK *, const STACK_OF(SXNETID) *, sk))) 2125 2126 #define sk_SXNETID_sort(sk) \ 2127 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk)) 2128 2129 #define sk_SXNETID_is_sorted(sk) \ 2130 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(SXNETID) *, sk)) 2131 2132 #define sk_SXNETID_set_cmp_func(sk, comp) \ 2133 ((int (*)(const SXNETID **a, const SXNETID **b))sk_set_cmp_func( \ 2134 CHECKED_CAST(_STACK *, STACK_OF(SXNETID) *, sk), \ 2135 CHECKED_CAST(stack_cmp_func, \ 2136 int (*)(const SXNETID **a, const SXNETID **b), comp))) 2137 2138 #define sk_SXNETID_deep_copy(sk, copy_func, free_func) \ 2139 ((STACK_OF(SXNETID) *)sk_deep_copy( \ 2140 CHECKED_CAST(const _STACK *, const STACK_OF(SXNETID) *, sk), \ 2141 CHECKED_CAST(void *(*)(void *), SXNETID *(*)(SXNETID *), copy_func), \ 2142 CHECKED_CAST(void (*)(void *), void (*)(SXNETID *), free_func))) 2143 2144 /* X509 */ 2145 #define sk_X509_new(comp) \ 2146 ((STACK_OF(X509) *)sk_new(CHECKED_CAST( \ 2147 stack_cmp_func, int (*)(const X509 **a, const X509 **b), comp))) 2148 2149 #define sk_X509_new_null() ((STACK_OF(X509) *)sk_new_null()) 2150 2151 #define sk_X509_num(sk) \ 2152 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509) *, sk)) 2153 2154 #define sk_X509_zero(sk) sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk)); 2155 2156 #define sk_X509_value(sk, i) \ 2157 ((X509 *)sk_value(CHECKED_CAST(const _STACK *, const STACK_OF(X509) *, sk), \ 2158 (i))) 2159 2160 #define sk_X509_set(sk, i, p) \ 2161 ((X509 *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (i), \ 2162 CHECKED_CAST(void *, X509 *, p))) 2163 2164 #define sk_X509_free(sk) sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk)) 2165 2166 #define sk_X509_pop_free(sk, free_func) \ 2167 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \ 2168 CHECKED_CAST(void (*)(void *), void (*)(X509 *), free_func)) 2169 2170 #define sk_X509_insert(sk, p, where) \ 2171 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \ 2172 CHECKED_CAST(void *, X509 *, p), (where)) 2173 2174 #define sk_X509_delete(sk, where) \ 2175 ((X509 *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (where))) 2176 2177 #define sk_X509_delete_ptr(sk, p) \ 2178 ((X509 *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \ 2179 CHECKED_CAST(void *, X509 *, p))) 2180 2181 #define sk_X509_find(sk, out_index, p) \ 2182 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), (out_index), \ 2183 CHECKED_CAST(void *, X509 *, p)) 2184 2185 #define sk_X509_shift(sk) \ 2186 ((X509 *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))) 2187 2188 #define sk_X509_push(sk, p) \ 2189 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \ 2190 CHECKED_CAST(void *, X509 *, p)) 2191 2192 #define sk_X509_pop(sk) \ 2193 ((X509 *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk))) 2194 2195 #define sk_X509_dup(sk) \ 2196 ((STACK_OF(X509) *)sk_dup( \ 2197 CHECKED_CAST(const _STACK *, const STACK_OF(X509) *, sk))) 2198 2199 #define sk_X509_sort(sk) sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk)) 2200 2201 #define sk_X509_is_sorted(sk) \ 2202 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509) *, sk)) 2203 2204 #define sk_X509_set_cmp_func(sk, comp) \ 2205 ((int (*)(const X509 **a, const X509 **b))sk_set_cmp_func( \ 2206 CHECKED_CAST(_STACK *, STACK_OF(X509) *, sk), \ 2207 CHECKED_CAST(stack_cmp_func, int (*)(const X509 **a, const X509 **b), \ 2208 comp))) 2209 2210 #define sk_X509_deep_copy(sk, copy_func, free_func) \ 2211 ((STACK_OF(X509) *)sk_deep_copy( \ 2212 CHECKED_CAST(const _STACK *, const STACK_OF(X509) *, sk), \ 2213 CHECKED_CAST(void *(*)(void *), X509 *(*)(X509 *), copy_func), \ 2214 CHECKED_CAST(void (*)(void *), void (*)(X509 *), free_func))) 2215 2216 /* X509V3_EXT_METHOD */ 2217 #define sk_X509V3_EXT_METHOD_new(comp) \ 2218 ((STACK_OF(X509V3_EXT_METHOD) *)sk_new(CHECKED_CAST( \ 2219 stack_cmp_func, \ 2220 int (*)(const X509V3_EXT_METHOD **a, const X509V3_EXT_METHOD **b), \ 2221 comp))) 2222 2223 #define sk_X509V3_EXT_METHOD_new_null() \ 2224 ((STACK_OF(X509V3_EXT_METHOD) *)sk_new_null()) 2225 2226 #define sk_X509V3_EXT_METHOD_num(sk) \ 2227 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk)) 2228 2229 #define sk_X509V3_EXT_METHOD_zero(sk) \ 2230 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk)); 2231 2232 #define sk_X509V3_EXT_METHOD_value(sk, i) \ 2233 ((X509V3_EXT_METHOD *)sk_value( \ 2234 CHECKED_CAST(const _STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk), \ 2235 (i))) 2236 2237 #define sk_X509V3_EXT_METHOD_set(sk, i, p) \ 2238 ((X509V3_EXT_METHOD *)sk_set( \ 2239 CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), (i), \ 2240 CHECKED_CAST(void *, X509V3_EXT_METHOD *, p))) 2241 2242 #define sk_X509V3_EXT_METHOD_free(sk) \ 2243 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk)) 2244 2245 #define sk_X509V3_EXT_METHOD_pop_free(sk, free_func) \ 2246 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \ 2247 CHECKED_CAST(void (*)(void *), void (*)(X509V3_EXT_METHOD *), \ 2248 free_func)) 2249 2250 #define sk_X509V3_EXT_METHOD_insert(sk, p, where) \ 2251 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \ 2252 CHECKED_CAST(void *, X509V3_EXT_METHOD *, p), (where)) 2253 2254 #define sk_X509V3_EXT_METHOD_delete(sk, where) \ 2255 ((X509V3_EXT_METHOD *)sk_delete( \ 2256 CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), (where))) 2257 2258 #define sk_X509V3_EXT_METHOD_delete_ptr(sk, p) \ 2259 ((X509V3_EXT_METHOD *)sk_delete_ptr( \ 2260 CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \ 2261 CHECKED_CAST(void *, X509V3_EXT_METHOD *, p))) 2262 2263 #define sk_X509V3_EXT_METHOD_find(sk, out_index, p) \ 2264 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \ 2265 (out_index), CHECKED_CAST(void *, X509V3_EXT_METHOD *, p)) 2266 2267 #define sk_X509V3_EXT_METHOD_shift(sk) \ 2268 ((X509V3_EXT_METHOD *)sk_shift( \ 2269 CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk))) 2270 2271 #define sk_X509V3_EXT_METHOD_push(sk, p) \ 2272 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \ 2273 CHECKED_CAST(void *, X509V3_EXT_METHOD *, p)) 2274 2275 #define sk_X509V3_EXT_METHOD_pop(sk) \ 2276 ((X509V3_EXT_METHOD *)sk_pop( \ 2277 CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk))) 2278 2279 #define sk_X509V3_EXT_METHOD_dup(sk) \ 2280 ((STACK_OF(X509V3_EXT_METHOD) *)sk_dup( \ 2281 CHECKED_CAST(const _STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk))) 2282 2283 #define sk_X509V3_EXT_METHOD_sort(sk) \ 2284 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk)) 2285 2286 #define sk_X509V3_EXT_METHOD_is_sorted(sk) \ 2287 sk_is_sorted( \ 2288 CHECKED_CAST(const _STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk)) 2289 2290 #define sk_X509V3_EXT_METHOD_set_cmp_func(sk, comp) \ 2291 ((int (*)(const X509V3_EXT_METHOD **a, const X509V3_EXT_METHOD **b)) \ 2292 sk_set_cmp_func( \ 2293 CHECKED_CAST(_STACK *, STACK_OF(X509V3_EXT_METHOD) *, sk), \ 2294 CHECKED_CAST(stack_cmp_func, int (*)(const X509V3_EXT_METHOD **a, \ 2295 const X509V3_EXT_METHOD **b), \ 2296 comp))) 2297 2298 #define sk_X509V3_EXT_METHOD_deep_copy(sk, copy_func, free_func) \ 2299 ((STACK_OF(X509V3_EXT_METHOD) *)sk_deep_copy( \ 2300 CHECKED_CAST(const _STACK *, const STACK_OF(X509V3_EXT_METHOD) *, sk), \ 2301 CHECKED_CAST(void *(*)(void *), \ 2302 X509V3_EXT_METHOD *(*)(X509V3_EXT_METHOD *), copy_func), \ 2303 CHECKED_CAST(void (*)(void *), void (*)(X509V3_EXT_METHOD *), \ 2304 free_func))) 2305 2306 /* X509_ALGOR */ 2307 #define sk_X509_ALGOR_new(comp) \ 2308 ((STACK_OF(X509_ALGOR) *)sk_new(CHECKED_CAST( \ 2309 stack_cmp_func, int (*)(const X509_ALGOR **a, const X509_ALGOR **b), \ 2310 comp))) 2311 2312 #define sk_X509_ALGOR_new_null() ((STACK_OF(X509_ALGOR) *)sk_new_null()) 2313 2314 #define sk_X509_ALGOR_num(sk) \ 2315 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_ALGOR) *, sk)) 2316 2317 #define sk_X509_ALGOR_zero(sk) \ 2318 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk)); 2319 2320 #define sk_X509_ALGOR_value(sk, i) \ 2321 ((X509_ALGOR *)sk_value( \ 2322 CHECKED_CAST(const _STACK *, const STACK_OF(X509_ALGOR) *, sk), (i))) 2323 2324 #define sk_X509_ALGOR_set(sk, i, p) \ 2325 ((X509_ALGOR *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \ 2326 (i), CHECKED_CAST(void *, X509_ALGOR *, p))) 2327 2328 #define sk_X509_ALGOR_free(sk) \ 2329 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk)) 2330 2331 #define sk_X509_ALGOR_pop_free(sk, free_func) \ 2332 sk_pop_free( \ 2333 CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \ 2334 CHECKED_CAST(void (*)(void *), void (*)(X509_ALGOR *), free_func)) 2335 2336 #define sk_X509_ALGOR_insert(sk, p, where) \ 2337 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \ 2338 CHECKED_CAST(void *, X509_ALGOR *, p), (where)) 2339 2340 #define sk_X509_ALGOR_delete(sk, where) \ 2341 ((X509_ALGOR *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \ 2342 (where))) 2343 2344 #define sk_X509_ALGOR_delete_ptr(sk, p) \ 2345 ((X509_ALGOR *)sk_delete_ptr( \ 2346 CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \ 2347 CHECKED_CAST(void *, X509_ALGOR *, p))) 2348 2349 #define sk_X509_ALGOR_find(sk, out_index, p) \ 2350 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), (out_index), \ 2351 CHECKED_CAST(void *, X509_ALGOR *, p)) 2352 2353 #define sk_X509_ALGOR_shift(sk) \ 2354 ((X509_ALGOR *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk))) 2355 2356 #define sk_X509_ALGOR_push(sk, p) \ 2357 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \ 2358 CHECKED_CAST(void *, X509_ALGOR *, p)) 2359 2360 #define sk_X509_ALGOR_pop(sk) \ 2361 ((X509_ALGOR *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk))) 2362 2363 #define sk_X509_ALGOR_dup(sk) \ 2364 ((STACK_OF(X509_ALGOR) *)sk_dup( \ 2365 CHECKED_CAST(const _STACK *, const STACK_OF(X509_ALGOR) *, sk))) 2366 2367 #define sk_X509_ALGOR_sort(sk) \ 2368 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk)) 2369 2370 #define sk_X509_ALGOR_is_sorted(sk) \ 2371 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_ALGOR) *, sk)) 2372 2373 #define sk_X509_ALGOR_set_cmp_func(sk, comp) \ 2374 ((int (*)(const X509_ALGOR **a, const X509_ALGOR **b))sk_set_cmp_func( \ 2375 CHECKED_CAST(_STACK *, STACK_OF(X509_ALGOR) *, sk), \ 2376 CHECKED_CAST(stack_cmp_func, \ 2377 int (*)(const X509_ALGOR **a, const X509_ALGOR **b), \ 2378 comp))) 2379 2380 #define sk_X509_ALGOR_deep_copy(sk, copy_func, free_func) \ 2381 ((STACK_OF(X509_ALGOR) *)sk_deep_copy( \ 2382 CHECKED_CAST(const _STACK *, const STACK_OF(X509_ALGOR) *, sk), \ 2383 CHECKED_CAST(void *(*)(void *), X509_ALGOR *(*)(X509_ALGOR *), \ 2384 copy_func), \ 2385 CHECKED_CAST(void (*)(void *), void (*)(X509_ALGOR *), free_func))) 2386 2387 /* X509_ATTRIBUTE */ 2388 #define sk_X509_ATTRIBUTE_new(comp) \ 2389 ((STACK_OF(X509_ATTRIBUTE) *)sk_new(CHECKED_CAST( \ 2390 stack_cmp_func, \ 2391 int (*)(const X509_ATTRIBUTE **a, const X509_ATTRIBUTE **b), comp))) 2392 2393 #define sk_X509_ATTRIBUTE_new_null() ((STACK_OF(X509_ATTRIBUTE) *)sk_new_null()) 2394 2395 #define sk_X509_ATTRIBUTE_num(sk) \ 2396 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk)) 2397 2398 #define sk_X509_ATTRIBUTE_zero(sk) \ 2399 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk)); 2400 2401 #define sk_X509_ATTRIBUTE_value(sk, i) \ 2402 ((X509_ATTRIBUTE *)sk_value( \ 2403 CHECKED_CAST(const _STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk), \ 2404 (i))) 2405 2406 #define sk_X509_ATTRIBUTE_set(sk, i, p) \ 2407 ((X509_ATTRIBUTE *)sk_set( \ 2408 CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (i), \ 2409 CHECKED_CAST(void *, X509_ATTRIBUTE *, p))) 2410 2411 #define sk_X509_ATTRIBUTE_free(sk) \ 2412 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk)) 2413 2414 #define sk_X509_ATTRIBUTE_pop_free(sk, free_func) \ 2415 sk_pop_free( \ 2416 CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \ 2417 CHECKED_CAST(void (*)(void *), void (*)(X509_ATTRIBUTE *), free_func)) 2418 2419 #define sk_X509_ATTRIBUTE_insert(sk, p, where) \ 2420 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \ 2421 CHECKED_CAST(void *, X509_ATTRIBUTE *, p), (where)) 2422 2423 #define sk_X509_ATTRIBUTE_delete(sk, where) \ 2424 ((X509_ATTRIBUTE *)sk_delete( \ 2425 CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (where))) 2426 2427 #define sk_X509_ATTRIBUTE_delete_ptr(sk, p) \ 2428 ((X509_ATTRIBUTE *)sk_delete_ptr( \ 2429 CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \ 2430 CHECKED_CAST(void *, X509_ATTRIBUTE *, p))) 2431 2432 #define sk_X509_ATTRIBUTE_find(sk, out_index, p) \ 2433 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), (out_index), \ 2434 CHECKED_CAST(void *, X509_ATTRIBUTE *, p)) 2435 2436 #define sk_X509_ATTRIBUTE_shift(sk) \ 2437 ((X509_ATTRIBUTE *)sk_shift( \ 2438 CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk))) 2439 2440 #define sk_X509_ATTRIBUTE_push(sk, p) \ 2441 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \ 2442 CHECKED_CAST(void *, X509_ATTRIBUTE *, p)) 2443 2444 #define sk_X509_ATTRIBUTE_pop(sk) \ 2445 ((X509_ATTRIBUTE *)sk_pop( \ 2446 CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk))) 2447 2448 #define sk_X509_ATTRIBUTE_dup(sk) \ 2449 ((STACK_OF(X509_ATTRIBUTE) *)sk_dup( \ 2450 CHECKED_CAST(const _STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk))) 2451 2452 #define sk_X509_ATTRIBUTE_sort(sk) \ 2453 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk)) 2454 2455 #define sk_X509_ATTRIBUTE_is_sorted(sk) \ 2456 sk_is_sorted( \ 2457 CHECKED_CAST(const _STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk)) 2458 2459 #define sk_X509_ATTRIBUTE_set_cmp_func(sk, comp) \ 2460 ((int (*)(const X509_ATTRIBUTE **a, const X509_ATTRIBUTE **b)) \ 2461 sk_set_cmp_func( \ 2462 CHECKED_CAST(_STACK *, STACK_OF(X509_ATTRIBUTE) *, sk), \ 2463 CHECKED_CAST(stack_cmp_func, int (*)(const X509_ATTRIBUTE **a, \ 2464 const X509_ATTRIBUTE **b), \ 2465 comp))) 2466 2467 #define sk_X509_ATTRIBUTE_deep_copy(sk, copy_func, free_func) \ 2468 ((STACK_OF(X509_ATTRIBUTE) *)sk_deep_copy( \ 2469 CHECKED_CAST(const _STACK *, const STACK_OF(X509_ATTRIBUTE) *, sk), \ 2470 CHECKED_CAST(void *(*)(void *), X509_ATTRIBUTE *(*)(X509_ATTRIBUTE *), \ 2471 copy_func), \ 2472 CHECKED_CAST(void (*)(void *), void (*)(X509_ATTRIBUTE *), free_func))) 2473 2474 /* X509_CRL */ 2475 #define sk_X509_CRL_new(comp) \ 2476 ((STACK_OF(X509_CRL) *)sk_new(CHECKED_CAST( \ 2477 stack_cmp_func, int (*)(const X509_CRL **a, const X509_CRL **b), comp))) 2478 2479 #define sk_X509_CRL_new_null() ((STACK_OF(X509_CRL) *)sk_new_null()) 2480 2481 #define sk_X509_CRL_num(sk) \ 2482 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_CRL) *, sk)) 2483 2484 #define sk_X509_CRL_zero(sk) \ 2485 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk)); 2486 2487 #define sk_X509_CRL_value(sk, i) \ 2488 ((X509_CRL *)sk_value( \ 2489 CHECKED_CAST(const _STACK *, const STACK_OF(X509_CRL) *, sk), (i))) 2490 2491 #define sk_X509_CRL_set(sk, i, p) \ 2492 ((X509_CRL *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), (i), \ 2493 CHECKED_CAST(void *, X509_CRL *, p))) 2494 2495 #define sk_X509_CRL_free(sk) \ 2496 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk)) 2497 2498 #define sk_X509_CRL_pop_free(sk, free_func) \ 2499 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \ 2500 CHECKED_CAST(void (*)(void *), void (*)(X509_CRL *), free_func)) 2501 2502 #define sk_X509_CRL_insert(sk, p, where) \ 2503 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \ 2504 CHECKED_CAST(void *, X509_CRL *, p), (where)) 2505 2506 #define sk_X509_CRL_delete(sk, where) \ 2507 ((X509_CRL *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \ 2508 (where))) 2509 2510 #define sk_X509_CRL_delete_ptr(sk, p) \ 2511 ((X509_CRL *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \ 2512 CHECKED_CAST(void *, X509_CRL *, p))) 2513 2514 #define sk_X509_CRL_find(sk, out_index, p) \ 2515 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), (out_index), \ 2516 CHECKED_CAST(void *, X509_CRL *, p)) 2517 2518 #define sk_X509_CRL_shift(sk) \ 2519 ((X509_CRL *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk))) 2520 2521 #define sk_X509_CRL_push(sk, p) \ 2522 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \ 2523 CHECKED_CAST(void *, X509_CRL *, p)) 2524 2525 #define sk_X509_CRL_pop(sk) \ 2526 ((X509_CRL *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk))) 2527 2528 #define sk_X509_CRL_dup(sk) \ 2529 ((STACK_OF(X509_CRL) *)sk_dup( \ 2530 CHECKED_CAST(const _STACK *, const STACK_OF(X509_CRL) *, sk))) 2531 2532 #define sk_X509_CRL_sort(sk) \ 2533 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk)) 2534 2535 #define sk_X509_CRL_is_sorted(sk) \ 2536 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_CRL) *, sk)) 2537 2538 #define sk_X509_CRL_set_cmp_func(sk, comp) \ 2539 ((int (*)(const X509_CRL **a, const X509_CRL **b))sk_set_cmp_func( \ 2540 CHECKED_CAST(_STACK *, STACK_OF(X509_CRL) *, sk), \ 2541 CHECKED_CAST(stack_cmp_func, \ 2542 int (*)(const X509_CRL **a, const X509_CRL **b), comp))) 2543 2544 #define sk_X509_CRL_deep_copy(sk, copy_func, free_func) \ 2545 ((STACK_OF(X509_CRL) *)sk_deep_copy( \ 2546 CHECKED_CAST(const _STACK *, const STACK_OF(X509_CRL) *, sk), \ 2547 CHECKED_CAST(void *(*)(void *), X509_CRL *(*)(X509_CRL *), copy_func), \ 2548 CHECKED_CAST(void (*)(void *), void (*)(X509_CRL *), free_func))) 2549 2550 /* X509_EXTENSION */ 2551 #define sk_X509_EXTENSION_new(comp) \ 2552 ((STACK_OF(X509_EXTENSION) *)sk_new(CHECKED_CAST( \ 2553 stack_cmp_func, \ 2554 int (*)(const X509_EXTENSION **a, const X509_EXTENSION **b), comp))) 2555 2556 #define sk_X509_EXTENSION_new_null() ((STACK_OF(X509_EXTENSION) *)sk_new_null()) 2557 2558 #define sk_X509_EXTENSION_num(sk) \ 2559 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_EXTENSION) *, sk)) 2560 2561 #define sk_X509_EXTENSION_zero(sk) \ 2562 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk)); 2563 2564 #define sk_X509_EXTENSION_value(sk, i) \ 2565 ((X509_EXTENSION *)sk_value( \ 2566 CHECKED_CAST(const _STACK *, const STACK_OF(X509_EXTENSION) *, sk), \ 2567 (i))) 2568 2569 #define sk_X509_EXTENSION_set(sk, i, p) \ 2570 ((X509_EXTENSION *)sk_set( \ 2571 CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (i), \ 2572 CHECKED_CAST(void *, X509_EXTENSION *, p))) 2573 2574 #define sk_X509_EXTENSION_free(sk) \ 2575 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk)) 2576 2577 #define sk_X509_EXTENSION_pop_free(sk, free_func) \ 2578 sk_pop_free( \ 2579 CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \ 2580 CHECKED_CAST(void (*)(void *), void (*)(X509_EXTENSION *), free_func)) 2581 2582 #define sk_X509_EXTENSION_insert(sk, p, where) \ 2583 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \ 2584 CHECKED_CAST(void *, X509_EXTENSION *, p), (where)) 2585 2586 #define sk_X509_EXTENSION_delete(sk, where) \ 2587 ((X509_EXTENSION *)sk_delete( \ 2588 CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (where))) 2589 2590 #define sk_X509_EXTENSION_delete_ptr(sk, p) \ 2591 ((X509_EXTENSION *)sk_delete_ptr( \ 2592 CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \ 2593 CHECKED_CAST(void *, X509_EXTENSION *, p))) 2594 2595 #define sk_X509_EXTENSION_find(sk, out_index, p) \ 2596 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), (out_index), \ 2597 CHECKED_CAST(void *, X509_EXTENSION *, p)) 2598 2599 #define sk_X509_EXTENSION_shift(sk) \ 2600 ((X509_EXTENSION *)sk_shift( \ 2601 CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk))) 2602 2603 #define sk_X509_EXTENSION_push(sk, p) \ 2604 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \ 2605 CHECKED_CAST(void *, X509_EXTENSION *, p)) 2606 2607 #define sk_X509_EXTENSION_pop(sk) \ 2608 ((X509_EXTENSION *)sk_pop( \ 2609 CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk))) 2610 2611 #define sk_X509_EXTENSION_dup(sk) \ 2612 ((STACK_OF(X509_EXTENSION) *)sk_dup( \ 2613 CHECKED_CAST(const _STACK *, const STACK_OF(X509_EXTENSION) *, sk))) 2614 2615 #define sk_X509_EXTENSION_sort(sk) \ 2616 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk)) 2617 2618 #define sk_X509_EXTENSION_is_sorted(sk) \ 2619 sk_is_sorted( \ 2620 CHECKED_CAST(const _STACK *, const STACK_OF(X509_EXTENSION) *, sk)) 2621 2622 #define sk_X509_EXTENSION_set_cmp_func(sk, comp) \ 2623 ((int (*)(const X509_EXTENSION **a, const X509_EXTENSION **b)) \ 2624 sk_set_cmp_func( \ 2625 CHECKED_CAST(_STACK *, STACK_OF(X509_EXTENSION) *, sk), \ 2626 CHECKED_CAST(stack_cmp_func, int (*)(const X509_EXTENSION **a, \ 2627 const X509_EXTENSION **b), \ 2628 comp))) 2629 2630 #define sk_X509_EXTENSION_deep_copy(sk, copy_func, free_func) \ 2631 ((STACK_OF(X509_EXTENSION) *)sk_deep_copy( \ 2632 CHECKED_CAST(const _STACK *, const STACK_OF(X509_EXTENSION) *, sk), \ 2633 CHECKED_CAST(void *(*)(void *), X509_EXTENSION *(*)(X509_EXTENSION *), \ 2634 copy_func), \ 2635 CHECKED_CAST(void (*)(void *), void (*)(X509_EXTENSION *), free_func))) 2636 2637 /* X509_INFO */ 2638 #define sk_X509_INFO_new(comp) \ 2639 ((STACK_OF(X509_INFO) *)sk_new( \ 2640 CHECKED_CAST(stack_cmp_func, \ 2641 int (*)(const X509_INFO **a, const X509_INFO **b), comp))) 2642 2643 #define sk_X509_INFO_new_null() ((STACK_OF(X509_INFO) *)sk_new_null()) 2644 2645 #define sk_X509_INFO_num(sk) \ 2646 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_INFO) *, sk)) 2647 2648 #define sk_X509_INFO_zero(sk) \ 2649 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk)); 2650 2651 #define sk_X509_INFO_value(sk, i) \ 2652 ((X509_INFO *)sk_value( \ 2653 CHECKED_CAST(const _STACK *, const STACK_OF(X509_INFO) *, sk), (i))) 2654 2655 #define sk_X509_INFO_set(sk, i, p) \ 2656 ((X509_INFO *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), (i), \ 2657 CHECKED_CAST(void *, X509_INFO *, p))) 2658 2659 #define sk_X509_INFO_free(sk) \ 2660 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk)) 2661 2662 #define sk_X509_INFO_pop_free(sk, free_func) \ 2663 sk_pop_free( \ 2664 CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \ 2665 CHECKED_CAST(void (*)(void *), void (*)(X509_INFO *), free_func)) 2666 2667 #define sk_X509_INFO_insert(sk, p, where) \ 2668 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \ 2669 CHECKED_CAST(void *, X509_INFO *, p), (where)) 2670 2671 #define sk_X509_INFO_delete(sk, where) \ 2672 ((X509_INFO *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \ 2673 (where))) 2674 2675 #define sk_X509_INFO_delete_ptr(sk, p) \ 2676 ((X509_INFO *)sk_delete_ptr( \ 2677 CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \ 2678 CHECKED_CAST(void *, X509_INFO *, p))) 2679 2680 #define sk_X509_INFO_find(sk, out_index, p) \ 2681 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), (out_index), \ 2682 CHECKED_CAST(void *, X509_INFO *, p)) 2683 2684 #define sk_X509_INFO_shift(sk) \ 2685 ((X509_INFO *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk))) 2686 2687 #define sk_X509_INFO_push(sk, p) \ 2688 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \ 2689 CHECKED_CAST(void *, X509_INFO *, p)) 2690 2691 #define sk_X509_INFO_pop(sk) \ 2692 ((X509_INFO *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk))) 2693 2694 #define sk_X509_INFO_dup(sk) \ 2695 ((STACK_OF(X509_INFO) *)sk_dup( \ 2696 CHECKED_CAST(const _STACK *, const STACK_OF(X509_INFO) *, sk))) 2697 2698 #define sk_X509_INFO_sort(sk) \ 2699 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk)) 2700 2701 #define sk_X509_INFO_is_sorted(sk) \ 2702 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_INFO) *, sk)) 2703 2704 #define sk_X509_INFO_set_cmp_func(sk, comp) \ 2705 ((int (*)(const X509_INFO **a, const X509_INFO **b))sk_set_cmp_func( \ 2706 CHECKED_CAST(_STACK *, STACK_OF(X509_INFO) *, sk), \ 2707 CHECKED_CAST(stack_cmp_func, \ 2708 int (*)(const X509_INFO **a, const X509_INFO **b), comp))) 2709 2710 #define sk_X509_INFO_deep_copy(sk, copy_func, free_func) \ 2711 ((STACK_OF(X509_INFO) *)sk_deep_copy( \ 2712 CHECKED_CAST(const _STACK *, const STACK_OF(X509_INFO) *, sk), \ 2713 CHECKED_CAST(void *(*)(void *), X509_INFO *(*)(X509_INFO *), copy_func), \ 2714 CHECKED_CAST(void (*)(void *), void (*)(X509_INFO *), free_func))) 2715 2716 /* X509_LOOKUP */ 2717 #define sk_X509_LOOKUP_new(comp) \ 2718 ((STACK_OF(X509_LOOKUP) *)sk_new(CHECKED_CAST( \ 2719 stack_cmp_func, int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b), \ 2720 comp))) 2721 2722 #define sk_X509_LOOKUP_new_null() ((STACK_OF(X509_LOOKUP) *)sk_new_null()) 2723 2724 #define sk_X509_LOOKUP_num(sk) \ 2725 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_LOOKUP) *, sk)) 2726 2727 #define sk_X509_LOOKUP_zero(sk) \ 2728 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk)); 2729 2730 #define sk_X509_LOOKUP_value(sk, i) \ 2731 ((X509_LOOKUP *)sk_value( \ 2732 CHECKED_CAST(const _STACK *, const STACK_OF(X509_LOOKUP) *, sk), (i))) 2733 2734 #define sk_X509_LOOKUP_set(sk, i, p) \ 2735 ((X509_LOOKUP *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \ 2736 (i), CHECKED_CAST(void *, X509_LOOKUP *, p))) 2737 2738 #define sk_X509_LOOKUP_free(sk) \ 2739 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk)) 2740 2741 #define sk_X509_LOOKUP_pop_free(sk, free_func) \ 2742 sk_pop_free( \ 2743 CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \ 2744 CHECKED_CAST(void (*)(void *), void (*)(X509_LOOKUP *), free_func)) 2745 2746 #define sk_X509_LOOKUP_insert(sk, p, where) \ 2747 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \ 2748 CHECKED_CAST(void *, X509_LOOKUP *, p), (where)) 2749 2750 #define sk_X509_LOOKUP_delete(sk, where) \ 2751 ((X509_LOOKUP *)sk_delete( \ 2752 CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), (where))) 2753 2754 #define sk_X509_LOOKUP_delete_ptr(sk, p) \ 2755 ((X509_LOOKUP *)sk_delete_ptr( \ 2756 CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \ 2757 CHECKED_CAST(void *, X509_LOOKUP *, p))) 2758 2759 #define sk_X509_LOOKUP_find(sk, out_index, p) \ 2760 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), (out_index), \ 2761 CHECKED_CAST(void *, X509_LOOKUP *, p)) 2762 2763 #define sk_X509_LOOKUP_shift(sk) \ 2764 ((X509_LOOKUP *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk))) 2765 2766 #define sk_X509_LOOKUP_push(sk, p) \ 2767 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \ 2768 CHECKED_CAST(void *, X509_LOOKUP *, p)) 2769 2770 #define sk_X509_LOOKUP_pop(sk) \ 2771 ((X509_LOOKUP *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk))) 2772 2773 #define sk_X509_LOOKUP_dup(sk) \ 2774 ((STACK_OF(X509_LOOKUP) *)sk_dup( \ 2775 CHECKED_CAST(const _STACK *, const STACK_OF(X509_LOOKUP) *, sk))) 2776 2777 #define sk_X509_LOOKUP_sort(sk) \ 2778 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk)) 2779 2780 #define sk_X509_LOOKUP_is_sorted(sk) \ 2781 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_LOOKUP) *, sk)) 2782 2783 #define sk_X509_LOOKUP_set_cmp_func(sk, comp) \ 2784 ((int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b))sk_set_cmp_func( \ 2785 CHECKED_CAST(_STACK *, STACK_OF(X509_LOOKUP) *, sk), \ 2786 CHECKED_CAST(stack_cmp_func, \ 2787 int (*)(const X509_LOOKUP **a, const X509_LOOKUP **b), \ 2788 comp))) 2789 2790 #define sk_X509_LOOKUP_deep_copy(sk, copy_func, free_func) \ 2791 ((STACK_OF(X509_LOOKUP) *)sk_deep_copy( \ 2792 CHECKED_CAST(const _STACK *, const STACK_OF(X509_LOOKUP) *, sk), \ 2793 CHECKED_CAST(void *(*)(void *), X509_LOOKUP *(*)(X509_LOOKUP *), \ 2794 copy_func), \ 2795 CHECKED_CAST(void (*)(void *), void (*)(X509_LOOKUP *), free_func))) 2796 2797 /* X509_NAME */ 2798 #define sk_X509_NAME_new(comp) \ 2799 ((STACK_OF(X509_NAME) *)sk_new( \ 2800 CHECKED_CAST(stack_cmp_func, \ 2801 int (*)(const X509_NAME **a, const X509_NAME **b), comp))) 2802 2803 #define sk_X509_NAME_new_null() ((STACK_OF(X509_NAME) *)sk_new_null()) 2804 2805 #define sk_X509_NAME_num(sk) \ 2806 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME) *, sk)) 2807 2808 #define sk_X509_NAME_zero(sk) \ 2809 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk)); 2810 2811 #define sk_X509_NAME_value(sk, i) \ 2812 ((X509_NAME *)sk_value( \ 2813 CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME) *, sk), (i))) 2814 2815 #define sk_X509_NAME_set(sk, i, p) \ 2816 ((X509_NAME *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), (i), \ 2817 CHECKED_CAST(void *, X509_NAME *, p))) 2818 2819 #define sk_X509_NAME_free(sk) \ 2820 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk)) 2821 2822 #define sk_X509_NAME_pop_free(sk, free_func) \ 2823 sk_pop_free( \ 2824 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \ 2825 CHECKED_CAST(void (*)(void *), void (*)(X509_NAME *), free_func)) 2826 2827 #define sk_X509_NAME_insert(sk, p, where) \ 2828 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \ 2829 CHECKED_CAST(void *, X509_NAME *, p), (where)) 2830 2831 #define sk_X509_NAME_delete(sk, where) \ 2832 ((X509_NAME *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \ 2833 (where))) 2834 2835 #define sk_X509_NAME_delete_ptr(sk, p) \ 2836 ((X509_NAME *)sk_delete_ptr( \ 2837 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \ 2838 CHECKED_CAST(void *, X509_NAME *, p))) 2839 2840 #define sk_X509_NAME_find(sk, out_index, p) \ 2841 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), (out_index), \ 2842 CHECKED_CAST(void *, X509_NAME *, p)) 2843 2844 #define sk_X509_NAME_shift(sk) \ 2845 ((X509_NAME *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk))) 2846 2847 #define sk_X509_NAME_push(sk, p) \ 2848 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \ 2849 CHECKED_CAST(void *, X509_NAME *, p)) 2850 2851 #define sk_X509_NAME_pop(sk) \ 2852 ((X509_NAME *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk))) 2853 2854 #define sk_X509_NAME_dup(sk) \ 2855 ((STACK_OF(X509_NAME) *)sk_dup( \ 2856 CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME) *, sk))) 2857 2858 #define sk_X509_NAME_sort(sk) \ 2859 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk)) 2860 2861 #define sk_X509_NAME_is_sorted(sk) \ 2862 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME) *, sk)) 2863 2864 #define sk_X509_NAME_set_cmp_func(sk, comp) \ 2865 ((int (*)(const X509_NAME **a, const X509_NAME **b))sk_set_cmp_func( \ 2866 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME) *, sk), \ 2867 CHECKED_CAST(stack_cmp_func, \ 2868 int (*)(const X509_NAME **a, const X509_NAME **b), comp))) 2869 2870 #define sk_X509_NAME_deep_copy(sk, copy_func, free_func) \ 2871 ((STACK_OF(X509_NAME) *)sk_deep_copy( \ 2872 CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME) *, sk), \ 2873 CHECKED_CAST(void *(*)(void *), X509_NAME *(*)(X509_NAME *), copy_func), \ 2874 CHECKED_CAST(void (*)(void *), void (*)(X509_NAME *), free_func))) 2875 2876 /* X509_NAME_ENTRY */ 2877 #define sk_X509_NAME_ENTRY_new(comp) \ 2878 ((STACK_OF(X509_NAME_ENTRY) *)sk_new(CHECKED_CAST( \ 2879 stack_cmp_func, \ 2880 int (*)(const X509_NAME_ENTRY **a, const X509_NAME_ENTRY **b), comp))) 2881 2882 #define sk_X509_NAME_ENTRY_new_null() \ 2883 ((STACK_OF(X509_NAME_ENTRY) *)sk_new_null()) 2884 2885 #define sk_X509_NAME_ENTRY_num(sk) \ 2886 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk)) 2887 2888 #define sk_X509_NAME_ENTRY_zero(sk) \ 2889 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk)); 2890 2891 #define sk_X509_NAME_ENTRY_value(sk, i) \ 2892 ((X509_NAME_ENTRY *)sk_value( \ 2893 CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk), \ 2894 (i))) 2895 2896 #define sk_X509_NAME_ENTRY_set(sk, i, p) \ 2897 ((X509_NAME_ENTRY *)sk_set( \ 2898 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), (i), \ 2899 CHECKED_CAST(void *, X509_NAME_ENTRY *, p))) 2900 2901 #define sk_X509_NAME_ENTRY_free(sk) \ 2902 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk)) 2903 2904 #define sk_X509_NAME_ENTRY_pop_free(sk, free_func) \ 2905 sk_pop_free( \ 2906 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \ 2907 CHECKED_CAST(void (*)(void *), void (*)(X509_NAME_ENTRY *), free_func)) 2908 2909 #define sk_X509_NAME_ENTRY_insert(sk, p, where) \ 2910 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \ 2911 CHECKED_CAST(void *, X509_NAME_ENTRY *, p), (where)) 2912 2913 #define sk_X509_NAME_ENTRY_delete(sk, where) \ 2914 ((X509_NAME_ENTRY *)sk_delete( \ 2915 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), (where))) 2916 2917 #define sk_X509_NAME_ENTRY_delete_ptr(sk, p) \ 2918 ((X509_NAME_ENTRY *)sk_delete_ptr( \ 2919 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \ 2920 CHECKED_CAST(void *, X509_NAME_ENTRY *, p))) 2921 2922 #define sk_X509_NAME_ENTRY_find(sk, out_index, p) \ 2923 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \ 2924 (out_index), CHECKED_CAST(void *, X509_NAME_ENTRY *, p)) 2925 2926 #define sk_X509_NAME_ENTRY_shift(sk) \ 2927 ((X509_NAME_ENTRY *)sk_shift( \ 2928 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))) 2929 2930 #define sk_X509_NAME_ENTRY_push(sk, p) \ 2931 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \ 2932 CHECKED_CAST(void *, X509_NAME_ENTRY *, p)) 2933 2934 #define sk_X509_NAME_ENTRY_pop(sk) \ 2935 ((X509_NAME_ENTRY *)sk_pop( \ 2936 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk))) 2937 2938 #define sk_X509_NAME_ENTRY_dup(sk) \ 2939 ((STACK_OF(X509_NAME_ENTRY) *)sk_dup( \ 2940 CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk))) 2941 2942 #define sk_X509_NAME_ENTRY_sort(sk) \ 2943 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk)) 2944 2945 #define sk_X509_NAME_ENTRY_is_sorted(sk) \ 2946 sk_is_sorted( \ 2947 CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk)) 2948 2949 #define sk_X509_NAME_ENTRY_set_cmp_func(sk, comp) \ 2950 ((int (*)(const X509_NAME_ENTRY **a, const X509_NAME_ENTRY **b)) \ 2951 sk_set_cmp_func( \ 2952 CHECKED_CAST(_STACK *, STACK_OF(X509_NAME_ENTRY) *, sk), \ 2953 CHECKED_CAST(stack_cmp_func, int (*)(const X509_NAME_ENTRY **a, \ 2954 const X509_NAME_ENTRY **b), \ 2955 comp))) 2956 2957 #define sk_X509_NAME_ENTRY_deep_copy(sk, copy_func, free_func) \ 2958 ((STACK_OF(X509_NAME_ENTRY) *)sk_deep_copy( \ 2959 CHECKED_CAST(const _STACK *, const STACK_OF(X509_NAME_ENTRY) *, sk), \ 2960 CHECKED_CAST(void *(*)(void *), X509_NAME_ENTRY *(*)(X509_NAME_ENTRY *), \ 2961 copy_func), \ 2962 CHECKED_CAST(void (*)(void *), void (*)(X509_NAME_ENTRY *), free_func))) 2963 2964 /* X509_OBJECT */ 2965 #define sk_X509_OBJECT_new(comp) \ 2966 ((STACK_OF(X509_OBJECT) *)sk_new(CHECKED_CAST( \ 2967 stack_cmp_func, int (*)(const X509_OBJECT **a, const X509_OBJECT **b), \ 2968 comp))) 2969 2970 #define sk_X509_OBJECT_new_null() ((STACK_OF(X509_OBJECT) *)sk_new_null()) 2971 2972 #define sk_X509_OBJECT_num(sk) \ 2973 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk)) 2974 2975 #define sk_X509_OBJECT_zero(sk) \ 2976 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk)); 2977 2978 #define sk_X509_OBJECT_value(sk, i) \ 2979 ((X509_OBJECT *)sk_value( \ 2980 CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk), (i))) 2981 2982 #define sk_X509_OBJECT_set(sk, i, p) \ 2983 ((X509_OBJECT *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \ 2984 (i), CHECKED_CAST(void *, X509_OBJECT *, p))) 2985 2986 #define sk_X509_OBJECT_free(sk) \ 2987 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk)) 2988 2989 #define sk_X509_OBJECT_pop_free(sk, free_func) \ 2990 sk_pop_free( \ 2991 CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \ 2992 CHECKED_CAST(void (*)(void *), void (*)(X509_OBJECT *), free_func)) 2993 2994 #define sk_X509_OBJECT_insert(sk, p, where) \ 2995 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \ 2996 CHECKED_CAST(void *, X509_OBJECT *, p), (where)) 2997 2998 #define sk_X509_OBJECT_delete(sk, where) \ 2999 ((X509_OBJECT *)sk_delete( \ 3000 CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), (where))) 3001 3002 #define sk_X509_OBJECT_delete_ptr(sk, p) \ 3003 ((X509_OBJECT *)sk_delete_ptr( \ 3004 CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \ 3005 CHECKED_CAST(void *, X509_OBJECT *, p))) 3006 3007 #define sk_X509_OBJECT_find(sk, out_index, p) \ 3008 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), (out_index), \ 3009 CHECKED_CAST(void *, X509_OBJECT *, p)) 3010 3011 #define sk_X509_OBJECT_shift(sk) \ 3012 ((X509_OBJECT *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))) 3013 3014 #define sk_X509_OBJECT_push(sk, p) \ 3015 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \ 3016 CHECKED_CAST(void *, X509_OBJECT *, p)) 3017 3018 #define sk_X509_OBJECT_pop(sk) \ 3019 ((X509_OBJECT *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk))) 3020 3021 #define sk_X509_OBJECT_dup(sk) \ 3022 ((STACK_OF(X509_OBJECT) *)sk_dup( \ 3023 CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk))) 3024 3025 #define sk_X509_OBJECT_sort(sk) \ 3026 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk)) 3027 3028 #define sk_X509_OBJECT_is_sorted(sk) \ 3029 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk)) 3030 3031 #define sk_X509_OBJECT_set_cmp_func(sk, comp) \ 3032 ((int (*)(const X509_OBJECT **a, const X509_OBJECT **b))sk_set_cmp_func( \ 3033 CHECKED_CAST(_STACK *, STACK_OF(X509_OBJECT) *, sk), \ 3034 CHECKED_CAST(stack_cmp_func, \ 3035 int (*)(const X509_OBJECT **a, const X509_OBJECT **b), \ 3036 comp))) 3037 3038 #define sk_X509_OBJECT_deep_copy(sk, copy_func, free_func) \ 3039 ((STACK_OF(X509_OBJECT) *)sk_deep_copy( \ 3040 CHECKED_CAST(const _STACK *, const STACK_OF(X509_OBJECT) *, sk), \ 3041 CHECKED_CAST(void *(*)(void *), X509_OBJECT *(*)(X509_OBJECT *), \ 3042 copy_func), \ 3043 CHECKED_CAST(void (*)(void *), void (*)(X509_OBJECT *), free_func))) 3044 3045 /* X509_POLICY_DATA */ 3046 #define sk_X509_POLICY_DATA_new(comp) \ 3047 ((STACK_OF(X509_POLICY_DATA) *)sk_new(CHECKED_CAST( \ 3048 stack_cmp_func, \ 3049 int (*)(const X509_POLICY_DATA **a, const X509_POLICY_DATA **b), comp))) 3050 3051 #define sk_X509_POLICY_DATA_new_null() \ 3052 ((STACK_OF(X509_POLICY_DATA) *)sk_new_null()) 3053 3054 #define sk_X509_POLICY_DATA_num(sk) \ 3055 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_DATA) *, sk)) 3056 3057 #define sk_X509_POLICY_DATA_zero(sk) \ 3058 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk)); 3059 3060 #define sk_X509_POLICY_DATA_value(sk, i) \ 3061 ((X509_POLICY_DATA *)sk_value( \ 3062 CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_DATA) *, sk), \ 3063 (i))) 3064 3065 #define sk_X509_POLICY_DATA_set(sk, i, p) \ 3066 ((X509_POLICY_DATA *)sk_set( \ 3067 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), (i), \ 3068 CHECKED_CAST(void *, X509_POLICY_DATA *, p))) 3069 3070 #define sk_X509_POLICY_DATA_free(sk) \ 3071 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk)) 3072 3073 #define sk_X509_POLICY_DATA_pop_free(sk, free_func) \ 3074 sk_pop_free( \ 3075 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \ 3076 CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_DATA *), free_func)) 3077 3078 #define sk_X509_POLICY_DATA_insert(sk, p, where) \ 3079 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \ 3080 CHECKED_CAST(void *, X509_POLICY_DATA *, p), (where)) 3081 3082 #define sk_X509_POLICY_DATA_delete(sk, where) \ 3083 ((X509_POLICY_DATA *)sk_delete( \ 3084 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), (where))) 3085 3086 #define sk_X509_POLICY_DATA_delete_ptr(sk, p) \ 3087 ((X509_POLICY_DATA *)sk_delete_ptr( \ 3088 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \ 3089 CHECKED_CAST(void *, X509_POLICY_DATA *, p))) 3090 3091 #define sk_X509_POLICY_DATA_find(sk, out_index, p) \ 3092 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \ 3093 (out_index), CHECKED_CAST(void *, X509_POLICY_DATA *, p)) 3094 3095 #define sk_X509_POLICY_DATA_shift(sk) \ 3096 ((X509_POLICY_DATA *)sk_shift( \ 3097 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))) 3098 3099 #define sk_X509_POLICY_DATA_push(sk, p) \ 3100 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \ 3101 CHECKED_CAST(void *, X509_POLICY_DATA *, p)) 3102 3103 #define sk_X509_POLICY_DATA_pop(sk) \ 3104 ((X509_POLICY_DATA *)sk_pop( \ 3105 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk))) 3106 3107 #define sk_X509_POLICY_DATA_dup(sk) \ 3108 ((STACK_OF(X509_POLICY_DATA) *)sk_dup( \ 3109 CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_DATA) *, sk))) 3110 3111 #define sk_X509_POLICY_DATA_sort(sk) \ 3112 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk)) 3113 3114 #define sk_X509_POLICY_DATA_is_sorted(sk) \ 3115 sk_is_sorted( \ 3116 CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_DATA) *, sk)) 3117 3118 #define sk_X509_POLICY_DATA_set_cmp_func(sk, comp) \ 3119 ((int (*)(const X509_POLICY_DATA **a, const X509_POLICY_DATA **b)) \ 3120 sk_set_cmp_func( \ 3121 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_DATA) *, sk), \ 3122 CHECKED_CAST(stack_cmp_func, int (*)(const X509_POLICY_DATA **a, \ 3123 const X509_POLICY_DATA **b), \ 3124 comp))) 3125 3126 #define sk_X509_POLICY_DATA_deep_copy(sk, copy_func, free_func) \ 3127 ((STACK_OF(X509_POLICY_DATA) *)sk_deep_copy( \ 3128 CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_DATA) *, sk), \ 3129 CHECKED_CAST(void *(*)(void *), \ 3130 X509_POLICY_DATA *(*)(X509_POLICY_DATA *), copy_func), \ 3131 CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_DATA *), \ 3132 free_func))) 3133 3134 /* X509_POLICY_NODE */ 3135 #define sk_X509_POLICY_NODE_new(comp) \ 3136 ((STACK_OF(X509_POLICY_NODE) *)sk_new(CHECKED_CAST( \ 3137 stack_cmp_func, \ 3138 int (*)(const X509_POLICY_NODE **a, const X509_POLICY_NODE **b), comp))) 3139 3140 #define sk_X509_POLICY_NODE_new_null() \ 3141 ((STACK_OF(X509_POLICY_NODE) *)sk_new_null()) 3142 3143 #define sk_X509_POLICY_NODE_num(sk) \ 3144 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_NODE) *, sk)) 3145 3146 #define sk_X509_POLICY_NODE_zero(sk) \ 3147 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk)); 3148 3149 #define sk_X509_POLICY_NODE_value(sk, i) \ 3150 ((X509_POLICY_NODE *)sk_value( \ 3151 CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_NODE) *, sk), \ 3152 (i))) 3153 3154 #define sk_X509_POLICY_NODE_set(sk, i, p) \ 3155 ((X509_POLICY_NODE *)sk_set( \ 3156 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), (i), \ 3157 CHECKED_CAST(void *, X509_POLICY_NODE *, p))) 3158 3159 #define sk_X509_POLICY_NODE_free(sk) \ 3160 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk)) 3161 3162 #define sk_X509_POLICY_NODE_pop_free(sk, free_func) \ 3163 sk_pop_free( \ 3164 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \ 3165 CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_NODE *), free_func)) 3166 3167 #define sk_X509_POLICY_NODE_insert(sk, p, where) \ 3168 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \ 3169 CHECKED_CAST(void *, X509_POLICY_NODE *, p), (where)) 3170 3171 #define sk_X509_POLICY_NODE_delete(sk, where) \ 3172 ((X509_POLICY_NODE *)sk_delete( \ 3173 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), (where))) 3174 3175 #define sk_X509_POLICY_NODE_delete_ptr(sk, p) \ 3176 ((X509_POLICY_NODE *)sk_delete_ptr( \ 3177 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \ 3178 CHECKED_CAST(void *, X509_POLICY_NODE *, p))) 3179 3180 #define sk_X509_POLICY_NODE_find(sk, out_index, p) \ 3181 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \ 3182 (out_index), CHECKED_CAST(void *, X509_POLICY_NODE *, p)) 3183 3184 #define sk_X509_POLICY_NODE_shift(sk) \ 3185 ((X509_POLICY_NODE *)sk_shift( \ 3186 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))) 3187 3188 #define sk_X509_POLICY_NODE_push(sk, p) \ 3189 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \ 3190 CHECKED_CAST(void *, X509_POLICY_NODE *, p)) 3191 3192 #define sk_X509_POLICY_NODE_pop(sk) \ 3193 ((X509_POLICY_NODE *)sk_pop( \ 3194 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk))) 3195 3196 #define sk_X509_POLICY_NODE_dup(sk) \ 3197 ((STACK_OF(X509_POLICY_NODE) *)sk_dup( \ 3198 CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_NODE) *, sk))) 3199 3200 #define sk_X509_POLICY_NODE_sort(sk) \ 3201 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk)) 3202 3203 #define sk_X509_POLICY_NODE_is_sorted(sk) \ 3204 sk_is_sorted( \ 3205 CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_NODE) *, sk)) 3206 3207 #define sk_X509_POLICY_NODE_set_cmp_func(sk, comp) \ 3208 ((int (*)(const X509_POLICY_NODE **a, const X509_POLICY_NODE **b)) \ 3209 sk_set_cmp_func( \ 3210 CHECKED_CAST(_STACK *, STACK_OF(X509_POLICY_NODE) *, sk), \ 3211 CHECKED_CAST(stack_cmp_func, int (*)(const X509_POLICY_NODE **a, \ 3212 const X509_POLICY_NODE **b), \ 3213 comp))) 3214 3215 #define sk_X509_POLICY_NODE_deep_copy(sk, copy_func, free_func) \ 3216 ((STACK_OF(X509_POLICY_NODE) *)sk_deep_copy( \ 3217 CHECKED_CAST(const _STACK *, const STACK_OF(X509_POLICY_NODE) *, sk), \ 3218 CHECKED_CAST(void *(*)(void *), \ 3219 X509_POLICY_NODE *(*)(X509_POLICY_NODE *), copy_func), \ 3220 CHECKED_CAST(void (*)(void *), void (*)(X509_POLICY_NODE *), \ 3221 free_func))) 3222 3223 /* X509_PURPOSE */ 3224 #define sk_X509_PURPOSE_new(comp) \ 3225 ((STACK_OF(X509_PURPOSE) *)sk_new(CHECKED_CAST( \ 3226 stack_cmp_func, int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b), \ 3227 comp))) 3228 3229 #define sk_X509_PURPOSE_new_null() ((STACK_OF(X509_PURPOSE) *)sk_new_null()) 3230 3231 #define sk_X509_PURPOSE_num(sk) \ 3232 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk)) 3233 3234 #define sk_X509_PURPOSE_zero(sk) \ 3235 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk)); 3236 3237 #define sk_X509_PURPOSE_value(sk, i) \ 3238 ((X509_PURPOSE *)sk_value( \ 3239 CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk), (i))) 3240 3241 #define sk_X509_PURPOSE_set(sk, i, p) \ 3242 ((X509_PURPOSE *)sk_set( \ 3243 CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (i), \ 3244 CHECKED_CAST(void *, X509_PURPOSE *, p))) 3245 3246 #define sk_X509_PURPOSE_free(sk) \ 3247 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk)) 3248 3249 #define sk_X509_PURPOSE_pop_free(sk, free_func) \ 3250 sk_pop_free( \ 3251 CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \ 3252 CHECKED_CAST(void (*)(void *), void (*)(X509_PURPOSE *), free_func)) 3253 3254 #define sk_X509_PURPOSE_insert(sk, p, where) \ 3255 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \ 3256 CHECKED_CAST(void *, X509_PURPOSE *, p), (where)) 3257 3258 #define sk_X509_PURPOSE_delete(sk, where) \ 3259 ((X509_PURPOSE *)sk_delete( \ 3260 CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (where))) 3261 3262 #define sk_X509_PURPOSE_delete_ptr(sk, p) \ 3263 ((X509_PURPOSE *)sk_delete_ptr( \ 3264 CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \ 3265 CHECKED_CAST(void *, X509_PURPOSE *, p))) 3266 3267 #define sk_X509_PURPOSE_find(sk, out_index, p) \ 3268 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), (out_index), \ 3269 CHECKED_CAST(void *, X509_PURPOSE *, p)) 3270 3271 #define sk_X509_PURPOSE_shift(sk) \ 3272 ((X509_PURPOSE *)sk_shift( \ 3273 CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))) 3274 3275 #define sk_X509_PURPOSE_push(sk, p) \ 3276 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \ 3277 CHECKED_CAST(void *, X509_PURPOSE *, p)) 3278 3279 #define sk_X509_PURPOSE_pop(sk) \ 3280 ((X509_PURPOSE *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk))) 3281 3282 #define sk_X509_PURPOSE_dup(sk) \ 3283 ((STACK_OF(X509_PURPOSE) *)sk_dup( \ 3284 CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk))) 3285 3286 #define sk_X509_PURPOSE_sort(sk) \ 3287 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk)) 3288 3289 #define sk_X509_PURPOSE_is_sorted(sk) \ 3290 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk)) 3291 3292 #define sk_X509_PURPOSE_set_cmp_func(sk, comp) \ 3293 ((int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b))sk_set_cmp_func( \ 3294 CHECKED_CAST(_STACK *, STACK_OF(X509_PURPOSE) *, sk), \ 3295 CHECKED_CAST(stack_cmp_func, \ 3296 int (*)(const X509_PURPOSE **a, const X509_PURPOSE **b), \ 3297 comp))) 3298 3299 #define sk_X509_PURPOSE_deep_copy(sk, copy_func, free_func) \ 3300 ((STACK_OF(X509_PURPOSE) *)sk_deep_copy( \ 3301 CHECKED_CAST(const _STACK *, const STACK_OF(X509_PURPOSE) *, sk), \ 3302 CHECKED_CAST(void *(*)(void *), X509_PURPOSE *(*)(X509_PURPOSE *), \ 3303 copy_func), \ 3304 CHECKED_CAST(void (*)(void *), void (*)(X509_PURPOSE *), free_func))) 3305 3306 /* X509_REVOKED */ 3307 #define sk_X509_REVOKED_new(comp) \ 3308 ((STACK_OF(X509_REVOKED) *)sk_new(CHECKED_CAST( \ 3309 stack_cmp_func, int (*)(const X509_REVOKED **a, const X509_REVOKED **b), \ 3310 comp))) 3311 3312 #define sk_X509_REVOKED_new_null() ((STACK_OF(X509_REVOKED) *)sk_new_null()) 3313 3314 #define sk_X509_REVOKED_num(sk) \ 3315 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk)) 3316 3317 #define sk_X509_REVOKED_zero(sk) \ 3318 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk)); 3319 3320 #define sk_X509_REVOKED_value(sk, i) \ 3321 ((X509_REVOKED *)sk_value( \ 3322 CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk), (i))) 3323 3324 #define sk_X509_REVOKED_set(sk, i, p) \ 3325 ((X509_REVOKED *)sk_set( \ 3326 CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (i), \ 3327 CHECKED_CAST(void *, X509_REVOKED *, p))) 3328 3329 #define sk_X509_REVOKED_free(sk) \ 3330 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk)) 3331 3332 #define sk_X509_REVOKED_pop_free(sk, free_func) \ 3333 sk_pop_free( \ 3334 CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \ 3335 CHECKED_CAST(void (*)(void *), void (*)(X509_REVOKED *), free_func)) 3336 3337 #define sk_X509_REVOKED_insert(sk, p, where) \ 3338 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \ 3339 CHECKED_CAST(void *, X509_REVOKED *, p), (where)) 3340 3341 #define sk_X509_REVOKED_delete(sk, where) \ 3342 ((X509_REVOKED *)sk_delete( \ 3343 CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (where))) 3344 3345 #define sk_X509_REVOKED_delete_ptr(sk, p) \ 3346 ((X509_REVOKED *)sk_delete_ptr( \ 3347 CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \ 3348 CHECKED_CAST(void *, X509_REVOKED *, p))) 3349 3350 #define sk_X509_REVOKED_find(sk, out_index, p) \ 3351 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), (out_index), \ 3352 CHECKED_CAST(void *, X509_REVOKED *, p)) 3353 3354 #define sk_X509_REVOKED_shift(sk) \ 3355 ((X509_REVOKED *)sk_shift( \ 3356 CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))) 3357 3358 #define sk_X509_REVOKED_push(sk, p) \ 3359 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \ 3360 CHECKED_CAST(void *, X509_REVOKED *, p)) 3361 3362 #define sk_X509_REVOKED_pop(sk) \ 3363 ((X509_REVOKED *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk))) 3364 3365 #define sk_X509_REVOKED_dup(sk) \ 3366 ((STACK_OF(X509_REVOKED) *)sk_dup( \ 3367 CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk))) 3368 3369 #define sk_X509_REVOKED_sort(sk) \ 3370 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk)) 3371 3372 #define sk_X509_REVOKED_is_sorted(sk) \ 3373 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk)) 3374 3375 #define sk_X509_REVOKED_set_cmp_func(sk, comp) \ 3376 ((int (*)(const X509_REVOKED **a, const X509_REVOKED **b))sk_set_cmp_func( \ 3377 CHECKED_CAST(_STACK *, STACK_OF(X509_REVOKED) *, sk), \ 3378 CHECKED_CAST(stack_cmp_func, \ 3379 int (*)(const X509_REVOKED **a, const X509_REVOKED **b), \ 3380 comp))) 3381 3382 #define sk_X509_REVOKED_deep_copy(sk, copy_func, free_func) \ 3383 ((STACK_OF(X509_REVOKED) *)sk_deep_copy( \ 3384 CHECKED_CAST(const _STACK *, const STACK_OF(X509_REVOKED) *, sk), \ 3385 CHECKED_CAST(void *(*)(void *), X509_REVOKED *(*)(X509_REVOKED *), \ 3386 copy_func), \ 3387 CHECKED_CAST(void (*)(void *), void (*)(X509_REVOKED *), free_func))) 3388 3389 /* X509_TRUST */ 3390 #define sk_X509_TRUST_new(comp) \ 3391 ((STACK_OF(X509_TRUST) *)sk_new(CHECKED_CAST( \ 3392 stack_cmp_func, int (*)(const X509_TRUST **a, const X509_TRUST **b), \ 3393 comp))) 3394 3395 #define sk_X509_TRUST_new_null() ((STACK_OF(X509_TRUST) *)sk_new_null()) 3396 3397 #define sk_X509_TRUST_num(sk) \ 3398 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk)) 3399 3400 #define sk_X509_TRUST_zero(sk) \ 3401 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk)); 3402 3403 #define sk_X509_TRUST_value(sk, i) \ 3404 ((X509_TRUST *)sk_value( \ 3405 CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk), (i))) 3406 3407 #define sk_X509_TRUST_set(sk, i, p) \ 3408 ((X509_TRUST *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \ 3409 (i), CHECKED_CAST(void *, X509_TRUST *, p))) 3410 3411 #define sk_X509_TRUST_free(sk) \ 3412 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk)) 3413 3414 #define sk_X509_TRUST_pop_free(sk, free_func) \ 3415 sk_pop_free( \ 3416 CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \ 3417 CHECKED_CAST(void (*)(void *), void (*)(X509_TRUST *), free_func)) 3418 3419 #define sk_X509_TRUST_insert(sk, p, where) \ 3420 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \ 3421 CHECKED_CAST(void *, X509_TRUST *, p), (where)) 3422 3423 #define sk_X509_TRUST_delete(sk, where) \ 3424 ((X509_TRUST *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \ 3425 (where))) 3426 3427 #define sk_X509_TRUST_delete_ptr(sk, p) \ 3428 ((X509_TRUST *)sk_delete_ptr( \ 3429 CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \ 3430 CHECKED_CAST(void *, X509_TRUST *, p))) 3431 3432 #define sk_X509_TRUST_find(sk, out_index, p) \ 3433 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), (out_index), \ 3434 CHECKED_CAST(void *, X509_TRUST *, p)) 3435 3436 #define sk_X509_TRUST_shift(sk) \ 3437 ((X509_TRUST *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))) 3438 3439 #define sk_X509_TRUST_push(sk, p) \ 3440 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \ 3441 CHECKED_CAST(void *, X509_TRUST *, p)) 3442 3443 #define sk_X509_TRUST_pop(sk) \ 3444 ((X509_TRUST *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk))) 3445 3446 #define sk_X509_TRUST_dup(sk) \ 3447 ((STACK_OF(X509_TRUST) *)sk_dup( \ 3448 CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk))) 3449 3450 #define sk_X509_TRUST_sort(sk) \ 3451 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk)) 3452 3453 #define sk_X509_TRUST_is_sorted(sk) \ 3454 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk)) 3455 3456 #define sk_X509_TRUST_set_cmp_func(sk, comp) \ 3457 ((int (*)(const X509_TRUST **a, const X509_TRUST **b))sk_set_cmp_func( \ 3458 CHECKED_CAST(_STACK *, STACK_OF(X509_TRUST) *, sk), \ 3459 CHECKED_CAST(stack_cmp_func, \ 3460 int (*)(const X509_TRUST **a, const X509_TRUST **b), \ 3461 comp))) 3462 3463 #define sk_X509_TRUST_deep_copy(sk, copy_func, free_func) \ 3464 ((STACK_OF(X509_TRUST) *)sk_deep_copy( \ 3465 CHECKED_CAST(const _STACK *, const STACK_OF(X509_TRUST) *, sk), \ 3466 CHECKED_CAST(void *(*)(void *), X509_TRUST *(*)(X509_TRUST *), \ 3467 copy_func), \ 3468 CHECKED_CAST(void (*)(void *), void (*)(X509_TRUST *), free_func))) 3469 3470 /* X509_VERIFY_PARAM */ 3471 #define sk_X509_VERIFY_PARAM_new(comp) \ 3472 ((STACK_OF(X509_VERIFY_PARAM) *)sk_new(CHECKED_CAST( \ 3473 stack_cmp_func, \ 3474 int (*)(const X509_VERIFY_PARAM **a, const X509_VERIFY_PARAM **b), \ 3475 comp))) 3476 3477 #define sk_X509_VERIFY_PARAM_new_null() \ 3478 ((STACK_OF(X509_VERIFY_PARAM) *)sk_new_null()) 3479 3480 #define sk_X509_VERIFY_PARAM_num(sk) \ 3481 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk)) 3482 3483 #define sk_X509_VERIFY_PARAM_zero(sk) \ 3484 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk)); 3485 3486 #define sk_X509_VERIFY_PARAM_value(sk, i) \ 3487 ((X509_VERIFY_PARAM *)sk_value( \ 3488 CHECKED_CAST(const _STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk), \ 3489 (i))) 3490 3491 #define sk_X509_VERIFY_PARAM_set(sk, i, p) \ 3492 ((X509_VERIFY_PARAM *)sk_set( \ 3493 CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), (i), \ 3494 CHECKED_CAST(void *, X509_VERIFY_PARAM *, p))) 3495 3496 #define sk_X509_VERIFY_PARAM_free(sk) \ 3497 sk_free(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk)) 3498 3499 #define sk_X509_VERIFY_PARAM_pop_free(sk, free_func) \ 3500 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \ 3501 CHECKED_CAST(void (*)(void *), void (*)(X509_VERIFY_PARAM *), \ 3502 free_func)) 3503 3504 #define sk_X509_VERIFY_PARAM_insert(sk, p, where) \ 3505 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \ 3506 CHECKED_CAST(void *, X509_VERIFY_PARAM *, p), (where)) 3507 3508 #define sk_X509_VERIFY_PARAM_delete(sk, where) \ 3509 ((X509_VERIFY_PARAM *)sk_delete( \ 3510 CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), (where))) 3511 3512 #define sk_X509_VERIFY_PARAM_delete_ptr(sk, p) \ 3513 ((X509_VERIFY_PARAM *)sk_delete_ptr( \ 3514 CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \ 3515 CHECKED_CAST(void *, X509_VERIFY_PARAM *, p))) 3516 3517 #define sk_X509_VERIFY_PARAM_find(sk, out_index, p) \ 3518 sk_find(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \ 3519 (out_index), CHECKED_CAST(void *, X509_VERIFY_PARAM *, p)) 3520 3521 #define sk_X509_VERIFY_PARAM_shift(sk) \ 3522 ((X509_VERIFY_PARAM *)sk_shift( \ 3523 CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))) 3524 3525 #define sk_X509_VERIFY_PARAM_push(sk, p) \ 3526 sk_push(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \ 3527 CHECKED_CAST(void *, X509_VERIFY_PARAM *, p)) 3528 3529 #define sk_X509_VERIFY_PARAM_pop(sk) \ 3530 ((X509_VERIFY_PARAM *)sk_pop( \ 3531 CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk))) 3532 3533 #define sk_X509_VERIFY_PARAM_dup(sk) \ 3534 ((STACK_OF(X509_VERIFY_PARAM) *)sk_dup( \ 3535 CHECKED_CAST(const _STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk))) 3536 3537 #define sk_X509_VERIFY_PARAM_sort(sk) \ 3538 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk)) 3539 3540 #define sk_X509_VERIFY_PARAM_is_sorted(sk) \ 3541 sk_is_sorted( \ 3542 CHECKED_CAST(const _STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk)) 3543 3544 #define sk_X509_VERIFY_PARAM_set_cmp_func(sk, comp) \ 3545 ((int (*)(const X509_VERIFY_PARAM **a, const X509_VERIFY_PARAM **b)) \ 3546 sk_set_cmp_func( \ 3547 CHECKED_CAST(_STACK *, STACK_OF(X509_VERIFY_PARAM) *, sk), \ 3548 CHECKED_CAST(stack_cmp_func, int (*)(const X509_VERIFY_PARAM **a, \ 3549 const X509_VERIFY_PARAM **b), \ 3550 comp))) 3551 3552 #define sk_X509_VERIFY_PARAM_deep_copy(sk, copy_func, free_func) \ 3553 ((STACK_OF(X509_VERIFY_PARAM) *)sk_deep_copy( \ 3554 CHECKED_CAST(const _STACK *, const STACK_OF(X509_VERIFY_PARAM) *, sk), \ 3555 CHECKED_CAST(void *(*)(void *), \ 3556 X509_VERIFY_PARAM *(*)(X509_VERIFY_PARAM *), copy_func), \ 3557 CHECKED_CAST(void (*)(void *), void (*)(X509_VERIFY_PARAM *), \ 3558 free_func))) 3559 3560 /* void */ 3561 #define sk_void_new(comp) \ 3562 ((STACK_OF(void) *)sk_new(CHECKED_CAST( \ 3563 stack_cmp_func, int (*)(const void **a, const void **b), comp))) 3564 3565 #define sk_void_new_null() ((STACK_OF(void) *)sk_new_null()) 3566 3567 #define sk_void_num(sk) \ 3568 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk)) 3569 3570 #define sk_void_zero(sk) sk_zero(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk)); 3571 3572 #define sk_void_value(sk, i) \ 3573 ((void *)sk_value(CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk), \ 3574 (i))) 3575 3576 #define sk_void_set(sk, i, p) \ 3577 ((void *)sk_set(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), (i), \ 3578 CHECKED_CAST(void *, void *, p))) 3579 3580 #define sk_void_free(sk) sk_free(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk)) 3581 3582 #define sk_void_pop_free(sk, free_func) \ 3583 sk_pop_free(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \ 3584 CHECKED_CAST(void (*)(void *), void (*)(void *), free_func)) 3585 3586 #define sk_void_insert(sk, p, where) \ 3587 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \ 3588 CHECKED_CAST(void *, void *, p), (where)) 3589 3590 #define sk_void_delete(sk, where) \ 3591 ((void *)sk_delete(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), (where))) 3592 3593 #define sk_void_delete_ptr(sk, p) \ 3594 ((void *)sk_delete_ptr(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \ 3595 CHECKED_CAST(void *, void *, p))) 3596 3597 #define sk_void_find(sk, out_index, p) \ 3598 sk_find(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), (out_index), \ 3599 CHECKED_CAST(void *, void *, p)) 3600 3601 #define sk_void_shift(sk) \ 3602 ((void *)sk_shift(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk))) 3603 3604 #define sk_void_push(sk, p) \ 3605 sk_push(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \ 3606 CHECKED_CAST(void *, void *, p)) 3607 3608 #define sk_void_pop(sk) \ 3609 ((void *)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk))) 3610 3611 #define sk_void_dup(sk) \ 3612 ((STACK_OF(void) *)sk_dup( \ 3613 CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk))) 3614 3615 #define sk_void_sort(sk) sk_sort(CHECKED_CAST(_STACK *, STACK_OF(void) *, sk)) 3616 3617 #define sk_void_is_sorted(sk) \ 3618 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk)) 3619 3620 #define sk_void_set_cmp_func(sk, comp) \ 3621 ((int (*)(const void **a, const void **b))sk_set_cmp_func( \ 3622 CHECKED_CAST(_STACK *, STACK_OF(void) *, sk), \ 3623 CHECKED_CAST(stack_cmp_func, int (*)(const void **a, const void **b), \ 3624 comp))) 3625 3626 #define sk_void_deep_copy(sk, copy_func, free_func) \ 3627 ((STACK_OF(void) *)sk_deep_copy( \ 3628 CHECKED_CAST(const _STACK *, const STACK_OF(void) *, sk), \ 3629 CHECKED_CAST(void *(*)(void *), void *(*)(void *), copy_func), \ 3630 CHECKED_CAST(void (*)(void *), void (*)(void *), free_func))) 3631 3632 /* SRTP_PROTECTION_PROFILE */ 3633 #define sk_SRTP_PROTECTION_PROFILE_new(comp) \ 3634 ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_new(CHECKED_CAST( \ 3635 stack_cmp_func, int (*)(const const SRTP_PROTECTION_PROFILE **a, \ 3636 const const SRTP_PROTECTION_PROFILE **b), \ 3637 comp))) 3638 3639 #define sk_SRTP_PROTECTION_PROFILE_new_null() \ 3640 ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_new_null()) 3641 3642 #define sk_SRTP_PROTECTION_PROFILE_num(sk) \ 3643 sk_num(CHECKED_CAST(const _STACK *, \ 3644 const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)) 3645 3646 #define sk_SRTP_PROTECTION_PROFILE_zero(sk) \ 3647 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)); 3648 3649 #define sk_SRTP_PROTECTION_PROFILE_value(sk, i) \ 3650 ((const SRTP_PROTECTION_PROFILE *)sk_value( \ 3651 CHECKED_CAST(const _STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, \ 3652 sk), \ 3653 (i))) 3654 3655 #define sk_SRTP_PROTECTION_PROFILE_set(sk, i, p) \ 3656 ((const SRTP_PROTECTION_PROFILE *)sk_set( \ 3657 CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), (i), \ 3658 CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p))) 3659 3660 #define sk_SRTP_PROTECTION_PROFILE_free(sk) \ 3661 sk_free(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)) 3662 3663 #define sk_SRTP_PROTECTION_PROFILE_pop_free(sk, free_func) \ 3664 sk_pop_free( \ 3665 CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \ 3666 CHECKED_CAST(void (*)(void *), \ 3667 void (*)(const SRTP_PROTECTION_PROFILE *), free_func)) 3668 3669 #define sk_SRTP_PROTECTION_PROFILE_insert(sk, p, where) \ 3670 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \ 3671 CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p), (where)) 3672 3673 #define sk_SRTP_PROTECTION_PROFILE_delete(sk, where) \ 3674 ((const SRTP_PROTECTION_PROFILE *)sk_delete( \ 3675 CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \ 3676 (where))) 3677 3678 #define sk_SRTP_PROTECTION_PROFILE_delete_ptr(sk, p) \ 3679 ((const SRTP_PROTECTION_PROFILE *)sk_delete_ptr( \ 3680 CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \ 3681 CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p))) 3682 3683 #define sk_SRTP_PROTECTION_PROFILE_find(sk, out_index, p) \ 3684 sk_find(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \ 3685 (out_index), \ 3686 CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p)) 3687 3688 #define sk_SRTP_PROTECTION_PROFILE_shift(sk) \ 3689 ((const SRTP_PROTECTION_PROFILE *)sk_shift( \ 3690 CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))) 3691 3692 #define sk_SRTP_PROTECTION_PROFILE_push(sk, p) \ 3693 sk_push(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \ 3694 CHECKED_CAST(void *, const SRTP_PROTECTION_PROFILE *, p)) 3695 3696 #define sk_SRTP_PROTECTION_PROFILE_pop(sk) \ 3697 ((const SRTP_PROTECTION_PROFILE *)sk_pop( \ 3698 CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))) 3699 3700 #define sk_SRTP_PROTECTION_PROFILE_dup(sk) \ 3701 ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_dup(CHECKED_CAST( \ 3702 const _STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk))) 3703 3704 #define sk_SRTP_PROTECTION_PROFILE_sort(sk) \ 3705 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)) 3706 3707 #define sk_SRTP_PROTECTION_PROFILE_is_sorted(sk) \ 3708 sk_is_sorted(CHECKED_CAST(const _STACK *, \ 3709 const STACK_OF(SRTP_PROTECTION_PROFILE) *, sk)) 3710 3711 #define sk_SRTP_PROTECTION_PROFILE_set_cmp_func(sk, comp) \ 3712 ((int (*)(const SRTP_PROTECTION_PROFILE **a, \ 3713 const SRTP_PROTECTION_PROFILE **b)) \ 3714 sk_set_cmp_func( \ 3715 CHECKED_CAST(_STACK *, STACK_OF(SRTP_PROTECTION_PROFILE) *, sk), \ 3716 CHECKED_CAST(stack_cmp_func, \ 3717 int (*)(const SRTP_PROTECTION_PROFILE **a, \ 3718 const SRTP_PROTECTION_PROFILE **b), \ 3719 comp))) 3720 3721 #define sk_SRTP_PROTECTION_PROFILE_deep_copy(sk, copy_func, free_func) \ 3722 ((STACK_OF(SRTP_PROTECTION_PROFILE) *)sk_deep_copy( \ 3723 CHECKED_CAST(const _STACK *, const STACK_OF(SRTP_PROTECTION_PROFILE) *, \ 3724 sk), \ 3725 CHECKED_CAST( \ 3726 void *(*)(void *), \ 3727 const SRTP_PROTECTION_PROFILE *(*)(const SRTP_PROTECTION_PROFILE *), \ 3728 copy_func), \ 3729 CHECKED_CAST(void (*)(void *), \ 3730 void (*)(const SRTP_PROTECTION_PROFILE *), free_func))) 3731 3732 /* SSL_CIPHER */ 3733 #define sk_SSL_CIPHER_new(comp) \ 3734 ((STACK_OF(SSL_CIPHER) *)sk_new(CHECKED_CAST( \ 3735 stack_cmp_func, \ 3736 int (*)(const const SSL_CIPHER **a, const const SSL_CIPHER **b), comp))) 3737 3738 #define sk_SSL_CIPHER_new_null() ((STACK_OF(SSL_CIPHER) *)sk_new_null()) 3739 3740 #define sk_SSL_CIPHER_num(sk) \ 3741 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk)) 3742 3743 #define sk_SSL_CIPHER_zero(sk) \ 3744 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk)); 3745 3746 #define sk_SSL_CIPHER_value(sk, i) \ 3747 ((const SSL_CIPHER *)sk_value( \ 3748 CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk), (i))) 3749 3750 #define sk_SSL_CIPHER_set(sk, i, p) \ 3751 ((const SSL_CIPHER *)sk_set( \ 3752 CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (i), \ 3753 CHECKED_CAST(void *, const SSL_CIPHER *, p))) 3754 3755 #define sk_SSL_CIPHER_free(sk) \ 3756 sk_free(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk)) 3757 3758 #define sk_SSL_CIPHER_pop_free(sk, free_func) \ 3759 sk_pop_free( \ 3760 CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \ 3761 CHECKED_CAST(void (*)(void *), void (*)(const SSL_CIPHER *), free_func)) 3762 3763 #define sk_SSL_CIPHER_insert(sk, p, where) \ 3764 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \ 3765 CHECKED_CAST(void *, const SSL_CIPHER *, p), (where)) 3766 3767 #define sk_SSL_CIPHER_delete(sk, where) \ 3768 ((const SSL_CIPHER *)sk_delete( \ 3769 CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (where))) 3770 3771 #define sk_SSL_CIPHER_delete_ptr(sk, p) \ 3772 ((const SSL_CIPHER *)sk_delete_ptr( \ 3773 CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \ 3774 CHECKED_CAST(void *, const SSL_CIPHER *, p))) 3775 3776 #define sk_SSL_CIPHER_find(sk, out_index, p) \ 3777 sk_find(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), (out_index), \ 3778 CHECKED_CAST(void *, const SSL_CIPHER *, p)) 3779 3780 #define sk_SSL_CIPHER_shift(sk) \ 3781 ((const SSL_CIPHER *)sk_shift( \ 3782 CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))) 3783 3784 #define sk_SSL_CIPHER_push(sk, p) \ 3785 sk_push(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \ 3786 CHECKED_CAST(void *, const SSL_CIPHER *, p)) 3787 3788 #define sk_SSL_CIPHER_pop(sk) \ 3789 ((const SSL_CIPHER *)sk_pop( \ 3790 CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk))) 3791 3792 #define sk_SSL_CIPHER_dup(sk) \ 3793 ((STACK_OF(SSL_CIPHER) *)sk_dup( \ 3794 CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk))) 3795 3796 #define sk_SSL_CIPHER_sort(sk) \ 3797 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk)) 3798 3799 #define sk_SSL_CIPHER_is_sorted(sk) \ 3800 sk_is_sorted(CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk)) 3801 3802 #define sk_SSL_CIPHER_set_cmp_func(sk, comp) \ 3803 ((int (*)(const SSL_CIPHER **a, const SSL_CIPHER **b))sk_set_cmp_func( \ 3804 CHECKED_CAST(_STACK *, STACK_OF(SSL_CIPHER) *, sk), \ 3805 CHECKED_CAST(stack_cmp_func, \ 3806 int (*)(const SSL_CIPHER **a, const SSL_CIPHER **b), \ 3807 comp))) 3808 3809 #define sk_SSL_CIPHER_deep_copy(sk, copy_func, free_func) \ 3810 ((STACK_OF(SSL_CIPHER) *)sk_deep_copy( \ 3811 CHECKED_CAST(const _STACK *, const STACK_OF(SSL_CIPHER) *, sk), \ 3812 CHECKED_CAST(void *(*)(void *), \ 3813 const SSL_CIPHER *(*)(const SSL_CIPHER *), copy_func), \ 3814 CHECKED_CAST(void (*)(void *), void (*)(const SSL_CIPHER *), \ 3815 free_func))) 3816 3817 /* OPENSSL_STRING */ 3818 #define sk_OPENSSL_STRING_new(comp) \ 3819 ((STACK_OF(OPENSSL_STRING) *)sk_new(CHECKED_CAST( \ 3820 stack_cmp_func, \ 3821 int (*)(const OPENSSL_STRING *a, const OPENSSL_STRING *b), comp))) 3822 3823 #define sk_OPENSSL_STRING_new_null() ((STACK_OF(OPENSSL_STRING) *)sk_new_null()) 3824 3825 #define sk_OPENSSL_STRING_num(sk) \ 3826 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_STRING) *, sk)) 3827 3828 #define sk_OPENSSL_STRING_zero(sk) \ 3829 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk)); 3830 3831 #define sk_OPENSSL_STRING_value(sk, i) \ 3832 ((OPENSSL_STRING)sk_value( \ 3833 CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_STRING) *, sk), \ 3834 (i))) 3835 3836 #define sk_OPENSSL_STRING_set(sk, i, p) \ 3837 ((OPENSSL_STRING)sk_set( \ 3838 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (i), \ 3839 CHECKED_CAST(void *, OPENSSL_STRING, p))) 3840 3841 #define sk_OPENSSL_STRING_free(sk) \ 3842 sk_free(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk)) 3843 3844 #define sk_OPENSSL_STRING_pop_free(sk, free_func) \ 3845 sk_pop_free( \ 3846 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \ 3847 CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_STRING), free_func)) 3848 3849 #define sk_OPENSSL_STRING_insert(sk, p, where) \ 3850 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \ 3851 CHECKED_CAST(void *, OPENSSL_STRING, p), (where)) 3852 3853 #define sk_OPENSSL_STRING_delete(sk, where) \ 3854 ((OPENSSL_STRING)sk_delete( \ 3855 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (where))) 3856 3857 #define sk_OPENSSL_STRING_delete_ptr(sk, p) \ 3858 ((OPENSSL_STRING)sk_delete_ptr( \ 3859 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \ 3860 CHECKED_CAST(void *, OPENSSL_STRING, p))) 3861 3862 #define sk_OPENSSL_STRING_find(sk, out_index, p) \ 3863 sk_find(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), (out_index), \ 3864 CHECKED_CAST(void *, OPENSSL_STRING, p)) 3865 3866 #define sk_OPENSSL_STRING_shift(sk) \ 3867 ((OPENSSL_STRING)sk_shift( \ 3868 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))) 3869 3870 #define sk_OPENSSL_STRING_push(sk, p) \ 3871 sk_push(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \ 3872 CHECKED_CAST(void *, OPENSSL_STRING, p)) 3873 3874 #define sk_OPENSSL_STRING_pop(sk) \ 3875 ((OPENSSL_STRING)sk_pop( \ 3876 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk))) 3877 3878 #define sk_OPENSSL_STRING_dup(sk) \ 3879 ((STACK_OF(OPENSSL_STRING) *)sk_dup( \ 3880 CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_STRING) *, sk))) 3881 3882 #define sk_OPENSSL_STRING_sort(sk) \ 3883 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk)) 3884 3885 #define sk_OPENSSL_STRING_is_sorted(sk) \ 3886 sk_is_sorted( \ 3887 CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_STRING) *, sk)) 3888 3889 #define sk_OPENSSL_STRING_set_cmp_func(sk, comp) \ 3890 ((int (*)(const OPENSSL_STRING **a, const OPENSSL_STRING **b)) \ 3891 sk_set_cmp_func( \ 3892 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_STRING) *, sk), \ 3893 CHECKED_CAST(stack_cmp_func, int (*)(const OPENSSL_STRING **a, \ 3894 const OPENSSL_STRING **b), \ 3895 comp))) 3896 3897 #define sk_OPENSSL_STRING_deep_copy(sk, copy_func, free_func) \ 3898 ((STACK_OF(OPENSSL_STRING) *)sk_deep_copy( \ 3899 CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_STRING) *, sk), \ 3900 CHECKED_CAST(void *(*)(void *), OPENSSL_STRING (*)(OPENSSL_STRING), \ 3901 copy_func), \ 3902 CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_STRING), free_func))) 3903 3904 /* OPENSSL_BLOCK */ 3905 #define sk_OPENSSL_BLOCK_new(comp) \ 3906 ((STACK_OF(OPENSSL_BLOCK) *)sk_new(CHECKED_CAST( \ 3907 stack_cmp_func, int (*)(const OPENSSL_BLOCK *a, const OPENSSL_BLOCK *b), \ 3908 comp))) 3909 3910 #define sk_OPENSSL_BLOCK_new_null() ((STACK_OF(OPENSSL_BLOCK) *)sk_new_null()) 3911 3912 #define sk_OPENSSL_BLOCK_num(sk) \ 3913 sk_num(CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk)) 3914 3915 #define sk_OPENSSL_BLOCK_zero(sk) \ 3916 sk_zero(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk)); 3917 3918 #define sk_OPENSSL_BLOCK_value(sk, i) \ 3919 ((OPENSSL_BLOCK)sk_value( \ 3920 CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk), (i))) 3921 3922 #define sk_OPENSSL_BLOCK_set(sk, i, p) \ 3923 ((OPENSSL_BLOCK)sk_set( \ 3924 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), (i), \ 3925 CHECKED_CAST(void *, OPENSSL_BLOCK, p))) 3926 3927 #define sk_OPENSSL_BLOCK_free(sk) \ 3928 sk_free(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk)) 3929 3930 #define sk_OPENSSL_BLOCK_pop_free(sk, free_func) \ 3931 sk_pop_free( \ 3932 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \ 3933 CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_BLOCK), free_func)) 3934 3935 #define sk_OPENSSL_BLOCK_insert(sk, p, where) \ 3936 sk_insert(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \ 3937 CHECKED_CAST(void *, OPENSSL_BLOCK, p), (where)) 3938 3939 #define sk_OPENSSL_BLOCK_delete(sk, where) \ 3940 ((OPENSSL_BLOCK)sk_delete( \ 3941 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), (where))) 3942 3943 #define sk_OPENSSL_BLOCK_delete_ptr(sk, p) \ 3944 ((OPENSSL_BLOCK)sk_delete_ptr( \ 3945 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \ 3946 CHECKED_CAST(void *, OPENSSL_BLOCK, p))) 3947 3948 #define sk_OPENSSL_BLOCK_find(sk, out_index, p) \ 3949 sk_find(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), (out_index), \ 3950 CHECKED_CAST(void *, OPENSSL_BLOCK, p)) 3951 3952 #define sk_OPENSSL_BLOCK_shift(sk) \ 3953 ((OPENSSL_BLOCK)sk_shift( \ 3954 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk))) 3955 3956 #define sk_OPENSSL_BLOCK_push(sk, p) \ 3957 sk_push(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \ 3958 CHECKED_CAST(void *, OPENSSL_BLOCK, p)) 3959 3960 #define sk_OPENSSL_BLOCK_pop(sk) \ 3961 ((OPENSSL_BLOCK)sk_pop(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk))) 3962 3963 #define sk_OPENSSL_BLOCK_dup(sk) \ 3964 ((STACK_OF(OPENSSL_BLOCK) *)sk_dup( \ 3965 CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk))) 3966 3967 #define sk_OPENSSL_BLOCK_sort(sk) \ 3968 sk_sort(CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk)) 3969 3970 #define sk_OPENSSL_BLOCK_is_sorted(sk) \ 3971 sk_is_sorted( \ 3972 CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk)) 3973 3974 #define sk_OPENSSL_BLOCK_set_cmp_func(sk, comp) \ 3975 ((int (*)(const OPENSSL_BLOCK **a, const OPENSSL_BLOCK **b))sk_set_cmp_func( \ 3976 CHECKED_CAST(_STACK *, STACK_OF(OPENSSL_BLOCK) *, sk), \ 3977 CHECKED_CAST(stack_cmp_func, \ 3978 int (*)(const OPENSSL_BLOCK **a, const OPENSSL_BLOCK **b), \ 3979 comp))) 3980 3981 #define sk_OPENSSL_BLOCK_deep_copy(sk, copy_func, free_func) \ 3982 ((STACK_OF(OPENSSL_BLOCK) *)sk_deep_copy( \ 3983 CHECKED_CAST(const _STACK *, const STACK_OF(OPENSSL_BLOCK) *, sk), \ 3984 CHECKED_CAST(void *(*)(void *), OPENSSL_BLOCK (*)(OPENSSL_BLOCK), \ 3985 copy_func), \ 3986 CHECKED_CAST(void (*)(void *), void (*)(OPENSSL_BLOCK), free_func))) 3987