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