test_asn1.hx
1 /* Generated from /Users/user/Downloads/darling-Heimdal/lib/asn1/test.asn1 */ 2 /* Do not edit */ 3 4 #ifndef __test_asn1_h__ 5 #define __test_asn1_h__ 6 7 #include <stddef.h> 8 #include <time.h> 9 10 #ifndef __asn1_common_definitions__ 11 #define __asn1_common_definitions__ 12 13 #ifndef __HEIM_BASE_DATA__ 14 #define __HEIM_BASE_DATA__ 1 15 struct heim_base_data { 16 size_t length; 17 void *data; 18 }; 19 #endif 20 21 typedef struct heim_integer { 22 size_t length; 23 void *data; 24 int negative; 25 } heim_integer; 26 27 typedef struct heim_base_data heim_octet_string; 28 29 typedef char *heim_general_string; 30 31 typedef char *heim_utf8_string; 32 33 typedef struct heim_base_data heim_printable_string; 34 35 typedef struct heim_base_data heim_ia5_string; 36 37 typedef struct heim_bmp_string { 38 size_t length; 39 uint16_t *data; 40 } heim_bmp_string; 41 42 typedef struct heim_universal_string { 43 size_t length; 44 uint32_t *data; 45 } heim_universal_string; 46 47 typedef char *heim_visible_string; 48 49 typedef struct heim_oid { 50 size_t length; 51 unsigned *components; 52 } heim_oid; 53 54 typedef struct heim_bit_string { 55 size_t length; 56 void *data; 57 } heim_bit_string; 58 59 typedef struct heim_base_data heim_any; 60 typedef struct heim_base_data heim_any_set; 61 62 #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \ 63 do { \ 64 (BL) = length_##T((S)); \ 65 (B) = malloc((BL)); \ 66 if((B) == NULL) { \ 67 (R) = ENOMEM; \ 68 } else { \ 69 (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ 70 (S), (L)); \ 71 if((R) != 0) { \ 72 free((B)); \ 73 (B) = NULL; \ 74 } \ 75 } \ 76 } while (0) 77 78 #define ASN1_ENCODE_CFMutableData(_TYPE, _CFDATA, S, R) \ 79 do { \ 80 size_t __length##_TYPE; \ 81 size_t __size##_TYPE = length_##_TYPE((S)); \ 82 (_CFDATA) = CFDataCreateMutable(NULL, (__size##_TYPE)); \ 83 if((_CFDATA) == NULL) { \ 84 (R) = ENOMEM; \ 85 } else { \ 86 CFDataSetLength((_CFDATA), (__size##_TYPE)); \ 87 (R) = encode_##_TYPE(((unsigned char*)(CFDataGetMutableBytePtr((_CFDATA)))) + (__size##_TYPE) - 1, (__size##_TYPE), \ 88 (S), &(__length##_TYPE)); \ 89 if((R) != 0) { \ 90 CFRelease((_CFDATA)); \ 91 (_CFDATA) = NULL; \ 92 } else if((__size##_TYPE) != (__length##_TYPE)) { \ 93 asn1_abort("internal asn1 error"); \ 94 } \ 95 } \ 96 } while (0) 97 98 #ifdef _WIN32 99 #ifndef ASN1_LIB 100 #define ASN1EXP __declspec(dllimport) 101 #else 102 #define ASN1EXP 103 #endif 104 #define ASN1CALL __stdcall 105 #else 106 #define ASN1EXP 107 #define ASN1CALL 108 #endif 109 struct units; 110 111 #endif 112 113 #include <heim_asn1.h> 114 /* 115 TESTuint32 ::= INTEGER (0..-1) 116 */ 117 118 typedef unsigned int TESTuint32; 119 120 ASN1EXP int ASN1CALL decode_TESTuint32(const unsigned char *, size_t, TESTuint32 *, size_t *); 121 ASN1EXP int ASN1CALL encode_TESTuint32(unsigned char *, size_t, const TESTuint32 *, size_t *); 122 ASN1EXP size_t ASN1CALL length_TESTuint32(const TESTuint32 *); 123 ASN1EXP int ASN1CALL copy_TESTuint32 (const TESTuint32 *, TESTuint32 *); 124 ASN1EXP void ASN1CALL free_TESTuint32 (TESTuint32 *); 125 126 127 /* 128 TESTLargeTag ::= SEQUENCE { 129 foo [127] INTEGER (-2147483648..2147483647), 130 bar [128] INTEGER (-2147483648..2147483647), 131 } 132 */ 133 134 typedef struct TESTLargeTag { 135 int foo; 136 int bar; 137 } TESTLargeTag; 138 139 ASN1EXP int ASN1CALL decode_TESTLargeTag(const unsigned char *, size_t, TESTLargeTag *, size_t *); 140 ASN1EXP int ASN1CALL encode_TESTLargeTag(unsigned char *, size_t, const TESTLargeTag *, size_t *); 141 ASN1EXP size_t ASN1CALL length_TESTLargeTag(const TESTLargeTag *); 142 ASN1EXP int ASN1CALL copy_TESTLargeTag (const TESTLargeTag *, TESTLargeTag *); 143 ASN1EXP void ASN1CALL free_TESTLargeTag (TESTLargeTag *); 144 145 146 /* 147 TESTSeq ::= SEQUENCE { 148 tag0 [0] INTEGER (-2147483648..2147483647), 149 tag1 [1] TESTLargeTag, 150 tagless INTEGER (-2147483648..2147483647), 151 tag3 [2] INTEGER (-2147483648..2147483647), 152 } 153 */ 154 155 typedef struct TESTSeq { 156 int tag0; 157 TESTLargeTag tag1; 158 int tagless; 159 int tag3; 160 } TESTSeq; 161 162 ASN1EXP int ASN1CALL decode_TESTSeq(const unsigned char *, size_t, TESTSeq *, size_t *); 163 ASN1EXP int ASN1CALL encode_TESTSeq(unsigned char *, size_t, const TESTSeq *, size_t *); 164 ASN1EXP size_t ASN1CALL length_TESTSeq(const TESTSeq *); 165 ASN1EXP int ASN1CALL copy_TESTSeq (const TESTSeq *, TESTSeq *); 166 ASN1EXP void ASN1CALL free_TESTSeq (TESTSeq *); 167 168 169 /* 170 TESTChoice1 ::= CHOICE { 171 i1 [1] INTEGER (-2147483648..2147483647), 172 i2 [2] INTEGER (-2147483648..2147483647), 173 ..., 174 } 175 */ 176 177 typedef struct TESTChoice1 { 178 enum TESTChoice1_enum { 179 choice_TESTChoice1_asn1_ellipsis = -1, 180 invalid_choice_TESTChoice1 = 0, 181 choice_TESTChoice1_i1, 182 choice_TESTChoice1_i2 183 /* ... */ 184 } element; 185 union { 186 int i1; 187 int i2; 188 heim_octet_string asn1_ellipsis; 189 } u; 190 } TESTChoice1; 191 192 ASN1EXP int ASN1CALL decode_TESTChoice1(const unsigned char *, size_t, TESTChoice1 *, size_t *); 193 ASN1EXP int ASN1CALL encode_TESTChoice1(unsigned char *, size_t, const TESTChoice1 *, size_t *); 194 ASN1EXP size_t ASN1CALL length_TESTChoice1(const TESTChoice1 *); 195 ASN1EXP int ASN1CALL copy_TESTChoice1 (const TESTChoice1 *, TESTChoice1 *); 196 ASN1EXP void ASN1CALL free_TESTChoice1 (TESTChoice1 *); 197 198 199 /* 200 TESTChoice2 ::= CHOICE { 201 i1 [1] INTEGER (-2147483648..2147483647), 202 ..., 203 } 204 */ 205 206 typedef struct TESTChoice2 { 207 enum TESTChoice2_enum { 208 choice_TESTChoice2_asn1_ellipsis = -1, 209 invalid_choice_TESTChoice2 = 0, 210 choice_TESTChoice2_i1 211 /* ... */ 212 } element; 213 union { 214 int i1; 215 heim_octet_string asn1_ellipsis; 216 } u; 217 } TESTChoice2; 218 219 ASN1EXP int ASN1CALL decode_TESTChoice2(const unsigned char *, size_t, TESTChoice2 *, size_t *); 220 ASN1EXP int ASN1CALL encode_TESTChoice2(unsigned char *, size_t, const TESTChoice2 *, size_t *); 221 ASN1EXP size_t ASN1CALL length_TESTChoice2(const TESTChoice2 *); 222 ASN1EXP int ASN1CALL copy_TESTChoice2 (const TESTChoice2 *, TESTChoice2 *); 223 ASN1EXP void ASN1CALL free_TESTChoice2 (TESTChoice2 *); 224 225 226 /* 227 TESTInteger ::= INTEGER (-2147483648..2147483647) 228 */ 229 230 typedef int TESTInteger; 231 232 ASN1EXP int ASN1CALL decode_TESTInteger(const unsigned char *, size_t, TESTInteger *, size_t *); 233 ASN1EXP int ASN1CALL encode_TESTInteger(unsigned char *, size_t, const TESTInteger *, size_t *); 234 ASN1EXP size_t ASN1CALL length_TESTInteger(const TESTInteger *); 235 ASN1EXP int ASN1CALL copy_TESTInteger (const TESTInteger *, TESTInteger *); 236 ASN1EXP void ASN1CALL free_TESTInteger (TESTInteger *); 237 238 239 /* 240 TESTInteger2 ::= [4] IMPLICIT TESTInteger 241 */ 242 243 typedef TESTInteger TESTInteger2; 244 245 ASN1EXP int ASN1CALL decode_TESTInteger2(const unsigned char *, size_t, TESTInteger2 *, size_t *); 246 ASN1EXP int ASN1CALL encode_TESTInteger2(unsigned char *, size_t, const TESTInteger2 *, size_t *); 247 ASN1EXP size_t ASN1CALL length_TESTInteger2(const TESTInteger2 *); 248 ASN1EXP int ASN1CALL copy_TESTInteger2 (const TESTInteger2 *, TESTInteger2 *); 249 ASN1EXP void ASN1CALL free_TESTInteger2 (TESTInteger2 *); 250 251 252 /* 253 TESTInteger3 ::= [5] IMPLICIT TESTInteger2 254 */ 255 256 typedef TESTInteger2 TESTInteger3; 257 258 ASN1EXP int ASN1CALL decode_TESTInteger3(const unsigned char *, size_t, TESTInteger3 *, size_t *); 259 ASN1EXP int ASN1CALL encode_TESTInteger3(unsigned char *, size_t, const TESTInteger3 *, size_t *); 260 ASN1EXP size_t ASN1CALL length_TESTInteger3(const TESTInteger3 *); 261 ASN1EXP int ASN1CALL copy_TESTInteger3 (const TESTInteger3 *, TESTInteger3 *); 262 ASN1EXP void ASN1CALL free_TESTInteger3 (TESTInteger3 *); 263 264 265 /* 266 TESTImplicit ::= SEQUENCE { 267 ti1 [0] IMPLICIT INTEGER (-2147483648..2147483647), 268 ti2 [1] IMPLICIT SEQUENCE { 269 foo [127] INTEGER (-2147483648..2147483647), 270 }, 271 ti3 [2] IMPLICIT [5] IMPLICIT [4] IMPLICIT INTEGER (-2147483648..2147483647), 272 } 273 */ 274 275 typedef struct TESTImplicit { 276 int ti1; 277 struct TESTImplicit_ti2 { 278 int foo; 279 } ti2; 280 int ti3; 281 } TESTImplicit; 282 283 ASN1EXP int ASN1CALL decode_TESTImplicit(const unsigned char *, size_t, TESTImplicit *, size_t *); 284 ASN1EXP int ASN1CALL encode_TESTImplicit(unsigned char *, size_t, const TESTImplicit *, size_t *); 285 ASN1EXP size_t ASN1CALL length_TESTImplicit(const TESTImplicit *); 286 ASN1EXP int ASN1CALL copy_TESTImplicit (const TESTImplicit *, TESTImplicit *); 287 ASN1EXP void ASN1CALL free_TESTImplicit (TESTImplicit *); 288 289 290 /* 291 TESTImplicit2 ::= SEQUENCE { 292 ti1 [0] IMPLICIT TESTInteger, 293 ti3 [2] IMPLICIT TESTInteger3, 294 } 295 */ 296 297 typedef struct TESTImplicit2 { 298 TESTInteger ti1; 299 TESTInteger3 ti3; 300 } TESTImplicit2; 301 302 ASN1EXP int ASN1CALL decode_TESTImplicit2(const unsigned char *, size_t, TESTImplicit2 *, size_t *); 303 ASN1EXP int ASN1CALL encode_TESTImplicit2(unsigned char *, size_t, const TESTImplicit2 *, size_t *); 304 ASN1EXP size_t ASN1CALL length_TESTImplicit2(const TESTImplicit2 *); 305 ASN1EXP int ASN1CALL copy_TESTImplicit2 (const TESTImplicit2 *, TESTImplicit2 *); 306 ASN1EXP void ASN1CALL free_TESTImplicit2 (TESTImplicit2 *); 307 308 309 /* 310 TESTAllocInner ::= SEQUENCE { 311 ai [0] TESTInteger, 312 } 313 */ 314 315 typedef struct TESTAllocInner { 316 TESTInteger ai; 317 } TESTAllocInner; 318 319 ASN1EXP int ASN1CALL decode_TESTAllocInner(const unsigned char *, size_t, TESTAllocInner *, size_t *); 320 ASN1EXP int ASN1CALL encode_TESTAllocInner(unsigned char *, size_t, const TESTAllocInner *, size_t *); 321 ASN1EXP size_t ASN1CALL length_TESTAllocInner(const TESTAllocInner *); 322 ASN1EXP int ASN1CALL copy_TESTAllocInner (const TESTAllocInner *, TESTAllocInner *); 323 ASN1EXP void ASN1CALL free_TESTAllocInner (TESTAllocInner *); 324 325 326 /* 327 TESTAlloc ::= SEQUENCE { 328 tagless TESTAllocInner OPTIONAL, 329 three [1] INTEGER (-2147483648..2147483647), 330 tagless2 heim_any OPTIONAL, 331 } 332 */ 333 334 typedef struct TESTAlloc { 335 TESTAllocInner *tagless; 336 int three; 337 heim_any *tagless2; 338 } TESTAlloc; 339 340 ASN1EXP int ASN1CALL decode_TESTAlloc(const unsigned char *, size_t, TESTAlloc *, size_t *); 341 ASN1EXP int ASN1CALL encode_TESTAlloc(unsigned char *, size_t, const TESTAlloc *, size_t *); 342 ASN1EXP size_t ASN1CALL length_TESTAlloc(const TESTAlloc *); 343 ASN1EXP int ASN1CALL copy_TESTAlloc (const TESTAlloc *, TESTAlloc *); 344 ASN1EXP void ASN1CALL free_TESTAlloc (TESTAlloc *); 345 346 347 /* 348 TESTOptional ::= SEQUENCE { 349 zero [0] INTEGER (-2147483648..2147483647) OPTIONAL, 350 one [1] INTEGER (-2147483648..2147483647) OPTIONAL, 351 } 352 */ 353 354 typedef struct TESTOptional { 355 int *zero; 356 int *one; 357 } TESTOptional; 358 359 ASN1EXP int ASN1CALL decode_TESTOptional(const unsigned char *, size_t, TESTOptional *, size_t *); 360 ASN1EXP int ASN1CALL encode_TESTOptional(unsigned char *, size_t, const TESTOptional *, size_t *); 361 ASN1EXP size_t ASN1CALL length_TESTOptional(const TESTOptional *); 362 ASN1EXP int ASN1CALL copy_TESTOptional (const TESTOptional *, TESTOptional *); 363 ASN1EXP void ASN1CALL free_TESTOptional (TESTOptional *); 364 365 366 /* 367 TESTCONTAINING ::= OCTET STRING 368 */ 369 370 typedef heim_octet_string TESTCONTAINING; 371 372 ASN1EXP int ASN1CALL decode_TESTCONTAINING(const unsigned char *, size_t, TESTCONTAINING *, size_t *); 373 ASN1EXP int ASN1CALL encode_TESTCONTAINING(unsigned char *, size_t, const TESTCONTAINING *, size_t *); 374 ASN1EXP size_t ASN1CALL length_TESTCONTAINING(const TESTCONTAINING *); 375 ASN1EXP int ASN1CALL copy_TESTCONTAINING (const TESTCONTAINING *, TESTCONTAINING *); 376 ASN1EXP void ASN1CALL free_TESTCONTAINING (TESTCONTAINING *); 377 378 379 /* 380 TESTENCODEDBY ::= OCTET STRING 381 */ 382 383 typedef heim_octet_string TESTENCODEDBY; 384 385 ASN1EXP int ASN1CALL decode_TESTENCODEDBY(const unsigned char *, size_t, TESTENCODEDBY *, size_t *); 386 ASN1EXP int ASN1CALL encode_TESTENCODEDBY(unsigned char *, size_t, const TESTENCODEDBY *, size_t *); 387 ASN1EXP size_t ASN1CALL length_TESTENCODEDBY(const TESTENCODEDBY *); 388 ASN1EXP int ASN1CALL copy_TESTENCODEDBY (const TESTENCODEDBY *, TESTENCODEDBY *); 389 ASN1EXP void ASN1CALL free_TESTENCODEDBY (TESTENCODEDBY *); 390 391 392 /* OBJECT IDENTIFIER TESTDer ::= { joint-iso-itu-t(2) asn(1) ber-derived(2) distinguished-encoding(1) } */ 393 extern ASN1EXP const heim_oid asn1_oid_TESTDer; 394 #define ASN1_OID_TESTDER (&asn1_oid_TESTDer) 395 396 /* 397 TESTCONTAININGENCODEDBY ::= OCTET STRING 398 */ 399 400 typedef heim_octet_string TESTCONTAININGENCODEDBY; 401 402 ASN1EXP int ASN1CALL decode_TESTCONTAININGENCODEDBY(const unsigned char *, size_t, TESTCONTAININGENCODEDBY *, size_t *); 403 ASN1EXP int ASN1CALL encode_TESTCONTAININGENCODEDBY(unsigned char *, size_t, const TESTCONTAININGENCODEDBY *, size_t *); 404 ASN1EXP size_t ASN1CALL length_TESTCONTAININGENCODEDBY(const TESTCONTAININGENCODEDBY *); 405 ASN1EXP int ASN1CALL copy_TESTCONTAININGENCODEDBY (const TESTCONTAININGENCODEDBY *, TESTCONTAININGENCODEDBY *); 406 ASN1EXP void ASN1CALL free_TESTCONTAININGENCODEDBY (TESTCONTAININGENCODEDBY *); 407 408 409 /* 410 TESTCONTAININGENCODEDBY2 ::= OCTET STRING 411 */ 412 413 typedef heim_octet_string TESTCONTAININGENCODEDBY2; 414 415 ASN1EXP int ASN1CALL decode_TESTCONTAININGENCODEDBY2(const unsigned char *, size_t, TESTCONTAININGENCODEDBY2 *, size_t *); 416 ASN1EXP int ASN1CALL encode_TESTCONTAININGENCODEDBY2(unsigned char *, size_t, const TESTCONTAININGENCODEDBY2 *, size_t *); 417 ASN1EXP size_t ASN1CALL length_TESTCONTAININGENCODEDBY2(const TESTCONTAININGENCODEDBY2 *); 418 ASN1EXP int ASN1CALL copy_TESTCONTAININGENCODEDBY2 (const TESTCONTAININGENCODEDBY2 *, TESTCONTAININGENCODEDBY2 *); 419 ASN1EXP void ASN1CALL free_TESTCONTAININGENCODEDBY2 (TESTCONTAININGENCODEDBY2 *); 420 421 422 enum { TESTValue1 = 1 }; 423 424 /* 425 TESTUSERCONSTRAINED ::= OCTET STRING 426 */ 427 428 typedef heim_octet_string TESTUSERCONSTRAINED; 429 430 ASN1EXP int ASN1CALL decode_TESTUSERCONSTRAINED(const unsigned char *, size_t, TESTUSERCONSTRAINED *, size_t *); 431 ASN1EXP int ASN1CALL encode_TESTUSERCONSTRAINED(unsigned char *, size_t, const TESTUSERCONSTRAINED *, size_t *); 432 ASN1EXP size_t ASN1CALL length_TESTUSERCONSTRAINED(const TESTUSERCONSTRAINED *); 433 ASN1EXP int ASN1CALL copy_TESTUSERCONSTRAINED (const TESTUSERCONSTRAINED *, TESTUSERCONSTRAINED *); 434 ASN1EXP void ASN1CALL free_TESTUSERCONSTRAINED (TESTUSERCONSTRAINED *); 435 436 437 /* 438 TESTSeqOf ::= SEQUENCE OF TESTInteger 439 */ 440 441 typedef struct TESTSeqOf { 442 unsigned int len; 443 TESTInteger *val; 444 } TESTSeqOf; 445 446 ASN1EXP int ASN1CALL add_TESTSeqOf (TESTSeqOf *, const TESTInteger *); 447 ASN1EXP int ASN1CALL remove_TESTSeqOf (TESTSeqOf *, unsigned int); 448 ASN1EXP int ASN1CALL decode_TESTSeqOf(const unsigned char *, size_t, TESTSeqOf *, size_t *); 449 ASN1EXP int ASN1CALL encode_TESTSeqOf(unsigned char *, size_t, const TESTSeqOf *, size_t *); 450 ASN1EXP size_t ASN1CALL length_TESTSeqOf(const TESTSeqOf *); 451 ASN1EXP int ASN1CALL copy_TESTSeqOf (const TESTSeqOf *, TESTSeqOf *); 452 ASN1EXP void ASN1CALL free_TESTSeqOf (TESTSeqOf *); 453 454 455 /* 456 TESTSeqSizeOf1 ::= SEQUENCE OF TESTInteger 457 */ 458 459 typedef struct TESTSeqSizeOf1 { 460 unsigned int len; 461 TESTInteger *val; 462 } TESTSeqSizeOf1; 463 464 ASN1EXP int ASN1CALL decode_TESTSeqSizeOf1(const unsigned char *, size_t, TESTSeqSizeOf1 *, size_t *); 465 ASN1EXP int ASN1CALL encode_TESTSeqSizeOf1(unsigned char *, size_t, const TESTSeqSizeOf1 *, size_t *); 466 ASN1EXP size_t ASN1CALL length_TESTSeqSizeOf1(const TESTSeqSizeOf1 *); 467 ASN1EXP int ASN1CALL copy_TESTSeqSizeOf1 (const TESTSeqSizeOf1 *, TESTSeqSizeOf1 *); 468 ASN1EXP void ASN1CALL free_TESTSeqSizeOf1 (TESTSeqSizeOf1 *); 469 470 471 /* 472 TESTSeqSizeOf2 ::= SEQUENCE OF TESTInteger 473 */ 474 475 typedef struct TESTSeqSizeOf2 { 476 unsigned int len; 477 TESTInteger *val; 478 } TESTSeqSizeOf2; 479 480 ASN1EXP int ASN1CALL decode_TESTSeqSizeOf2(const unsigned char *, size_t, TESTSeqSizeOf2 *, size_t *); 481 ASN1EXP int ASN1CALL encode_TESTSeqSizeOf2(unsigned char *, size_t, const TESTSeqSizeOf2 *, size_t *); 482 ASN1EXP size_t ASN1CALL length_TESTSeqSizeOf2(const TESTSeqSizeOf2 *); 483 ASN1EXP int ASN1CALL copy_TESTSeqSizeOf2 (const TESTSeqSizeOf2 *, TESTSeqSizeOf2 *); 484 ASN1EXP void ASN1CALL free_TESTSeqSizeOf2 (TESTSeqSizeOf2 *); 485 486 487 /* 488 TESTSeqSizeOf3 ::= SEQUENCE OF TESTInteger 489 */ 490 491 typedef struct TESTSeqSizeOf3 { 492 unsigned int len; 493 TESTInteger *val; 494 } TESTSeqSizeOf3; 495 496 ASN1EXP int ASN1CALL decode_TESTSeqSizeOf3(const unsigned char *, size_t, TESTSeqSizeOf3 *, size_t *); 497 ASN1EXP int ASN1CALL encode_TESTSeqSizeOf3(unsigned char *, size_t, const TESTSeqSizeOf3 *, size_t *); 498 ASN1EXP size_t ASN1CALL length_TESTSeqSizeOf3(const TESTSeqSizeOf3 *); 499 ASN1EXP int ASN1CALL copy_TESTSeqSizeOf3 (const TESTSeqSizeOf3 *, TESTSeqSizeOf3 *); 500 ASN1EXP void ASN1CALL free_TESTSeqSizeOf3 (TESTSeqSizeOf3 *); 501 502 503 /* 504 TESTSeqSizeOf4 ::= SEQUENCE OF TESTInteger 505 */ 506 507 typedef struct TESTSeqSizeOf4 { 508 unsigned int len; 509 TESTInteger *val; 510 } TESTSeqSizeOf4; 511 512 ASN1EXP int ASN1CALL decode_TESTSeqSizeOf4(const unsigned char *, size_t, TESTSeqSizeOf4 *, size_t *); 513 ASN1EXP int ASN1CALL encode_TESTSeqSizeOf4(unsigned char *, size_t, const TESTSeqSizeOf4 *, size_t *); 514 ASN1EXP size_t ASN1CALL length_TESTSeqSizeOf4(const TESTSeqSizeOf4 *); 515 ASN1EXP int ASN1CALL copy_TESTSeqSizeOf4 (const TESTSeqSizeOf4 *, TESTSeqSizeOf4 *); 516 ASN1EXP void ASN1CALL free_TESTSeqSizeOf4 (TESTSeqSizeOf4 *); 517 518 519 /* 520 TESTOSSize1 ::= OCTET STRING 521 */ 522 523 typedef heim_octet_string TESTOSSize1; 524 525 ASN1EXP int ASN1CALL decode_TESTOSSize1(const unsigned char *, size_t, TESTOSSize1 *, size_t *); 526 ASN1EXP int ASN1CALL encode_TESTOSSize1(unsigned char *, size_t, const TESTOSSize1 *, size_t *); 527 ASN1EXP size_t ASN1CALL length_TESTOSSize1(const TESTOSSize1 *); 528 ASN1EXP int ASN1CALL copy_TESTOSSize1 (const TESTOSSize1 *, TESTOSSize1 *); 529 ASN1EXP void ASN1CALL free_TESTOSSize1 (TESTOSSize1 *); 530 531 532 /* 533 TESTSeqOfSeq ::= SEQUENCE OF SEQUENCE { 534 zero [0] TESTInteger, 535 } 536 */ 537 538 typedef struct TESTSeqOfSeq { 539 unsigned int len; 540 struct TESTSeqOfSeq_val { 541 TESTInteger zero; 542 } *val; 543 } TESTSeqOfSeq; 544 545 ASN1EXP int ASN1CALL decode_TESTSeqOfSeq(const unsigned char *, size_t, TESTSeqOfSeq *, size_t *); 546 ASN1EXP int ASN1CALL encode_TESTSeqOfSeq(unsigned char *, size_t, const TESTSeqOfSeq *, size_t *); 547 ASN1EXP size_t ASN1CALL length_TESTSeqOfSeq(const TESTSeqOfSeq *); 548 ASN1EXP int ASN1CALL copy_TESTSeqOfSeq (const TESTSeqOfSeq *, TESTSeqOfSeq *); 549 ASN1EXP void ASN1CALL free_TESTSeqOfSeq (TESTSeqOfSeq *); 550 551 552 /* 553 TESTSeqOfSeq2 ::= SEQUENCE OF SEQUENCE { 554 string [0] GeneralString, 555 } 556 */ 557 558 typedef struct TESTSeqOfSeq2 { 559 unsigned int len; 560 struct TESTSeqOfSeq2_val { 561 heim_general_string string; 562 } *val; 563 } TESTSeqOfSeq2; 564 565 ASN1EXP int ASN1CALL decode_TESTSeqOfSeq2(const unsigned char *, size_t, TESTSeqOfSeq2 *, size_t *); 566 ASN1EXP int ASN1CALL encode_TESTSeqOfSeq2(unsigned char *, size_t, const TESTSeqOfSeq2 *, size_t *); 567 ASN1EXP size_t ASN1CALL length_TESTSeqOfSeq2(const TESTSeqOfSeq2 *); 568 ASN1EXP int ASN1CALL copy_TESTSeqOfSeq2 (const TESTSeqOfSeq2 *, TESTSeqOfSeq2 *); 569 ASN1EXP void ASN1CALL free_TESTSeqOfSeq2 (TESTSeqOfSeq2 *); 570 571 572 /* 573 TESTSeqOfSeq3 ::= SEQUENCE OF SEQUENCE { 574 zero [0] TESTInteger, 575 string [0] GeneralString, 576 } 577 */ 578 579 typedef struct TESTSeqOfSeq3 { 580 unsigned int len; 581 struct TESTSeqOfSeq3_val { 582 TESTInteger zero; 583 heim_general_string string; 584 } *val; 585 } TESTSeqOfSeq3; 586 587 ASN1EXP int ASN1CALL decode_TESTSeqOfSeq3(const unsigned char *, size_t, TESTSeqOfSeq3 *, size_t *); 588 ASN1EXP int ASN1CALL encode_TESTSeqOfSeq3(unsigned char *, size_t, const TESTSeqOfSeq3 *, size_t *); 589 ASN1EXP size_t ASN1CALL length_TESTSeqOfSeq3(const TESTSeqOfSeq3 *); 590 ASN1EXP int ASN1CALL copy_TESTSeqOfSeq3 (const TESTSeqOfSeq3 *, TESTSeqOfSeq3 *); 591 ASN1EXP void ASN1CALL free_TESTSeqOfSeq3 (TESTSeqOfSeq3 *); 592 593 594 /* 595 TESTSeqOf2 ::= SEQUENCE { 596 strings SEQUENCE OF GeneralString, 597 } 598 */ 599 600 typedef struct TESTSeqOf2 { 601 struct TESTSeqOf2_strings { 602 unsigned int len; 603 heim_general_string *val; 604 } strings; 605 } TESTSeqOf2; 606 607 ASN1EXP int ASN1CALL decode_TESTSeqOf2(const unsigned char *, size_t, TESTSeqOf2 *, size_t *); 608 ASN1EXP int ASN1CALL encode_TESTSeqOf2(unsigned char *, size_t, const TESTSeqOf2 *, size_t *); 609 ASN1EXP size_t ASN1CALL length_TESTSeqOf2(const TESTSeqOf2 *); 610 ASN1EXP int ASN1CALL copy_TESTSeqOf2 (const TESTSeqOf2 *, TESTSeqOf2 *); 611 ASN1EXP void ASN1CALL free_TESTSeqOf2 (TESTSeqOf2 *); 612 613 614 /* 615 TESTSeqOf3 ::= SEQUENCE { 616 strings SEQUENCE OF GeneralString OPTIONAL, 617 } 618 */ 619 620 typedef struct TESTSeqOf3 { 621 struct TESTSeqOf3_strings { 622 unsigned int len; 623 heim_general_string *val; 624 } *strings; 625 } TESTSeqOf3; 626 627 ASN1EXP int ASN1CALL decode_TESTSeqOf3(const unsigned char *, size_t, TESTSeqOf3 *, size_t *); 628 ASN1EXP int ASN1CALL encode_TESTSeqOf3(unsigned char *, size_t, const TESTSeqOf3 *, size_t *); 629 ASN1EXP size_t ASN1CALL length_TESTSeqOf3(const TESTSeqOf3 *); 630 ASN1EXP int ASN1CALL copy_TESTSeqOf3 (const TESTSeqOf3 *, TESTSeqOf3 *); 631 ASN1EXP void ASN1CALL free_TESTSeqOf3 (TESTSeqOf3 *); 632 633 634 /* 635 TESTPreserve ::= SEQUENCE { 636 zero [0] TESTInteger, 637 one [1] TESTInteger, 638 } 639 */ 640 641 typedef struct TESTPreserve { 642 TESTInteger zero; 643 TESTInteger one; 644 } TESTPreserve; 645 646 ASN1EXP int ASN1CALL decode_TESTPreserve(const unsigned char *, size_t, TESTPreserve *, size_t *); 647 ASN1EXP int ASN1CALL encode_TESTPreserve(unsigned char *, size_t, const TESTPreserve *, size_t *); 648 ASN1EXP size_t ASN1CALL length_TESTPreserve(const TESTPreserve *); 649 ASN1EXP int ASN1CALL copy_TESTPreserve (const TESTPreserve *, TESTPreserve *); 650 ASN1EXP void ASN1CALL free_TESTPreserve (TESTPreserve *); 651 652 653 /* 654 TESTBitString ::= BIT STRING { 655 zero(0), 656 eight(8), 657 thirtyone(31) 658 } 659 */ 660 661 typedef struct TESTBitString { 662 unsigned int zero:1; 663 unsigned int _unused1:1; 664 unsigned int _unused2:1; 665 unsigned int _unused3:1; 666 unsigned int _unused4:1; 667 unsigned int _unused5:1; 668 unsigned int _unused6:1; 669 unsigned int _unused7:1; 670 unsigned int eight:1; 671 unsigned int _unused9:1; 672 unsigned int _unused10:1; 673 unsigned int _unused11:1; 674 unsigned int _unused12:1; 675 unsigned int _unused13:1; 676 unsigned int _unused14:1; 677 unsigned int _unused15:1; 678 unsigned int _unused16:1; 679 unsigned int _unused17:1; 680 unsigned int _unused18:1; 681 unsigned int _unused19:1; 682 unsigned int _unused20:1; 683 unsigned int _unused21:1; 684 unsigned int _unused22:1; 685 unsigned int _unused23:1; 686 unsigned int _unused24:1; 687 unsigned int _unused25:1; 688 unsigned int _unused26:1; 689 unsigned int _unused27:1; 690 unsigned int _unused28:1; 691 unsigned int _unused29:1; 692 unsigned int _unused30:1; 693 unsigned int thirtyone:1; 694 } TESTBitString; 695 696 697 unsigned TESTBitString2int(TESTBitString); 698 TESTBitString int2TESTBitString(unsigned); 699 extern const struct units *asn1_TESTBitString_table_units; 700 #define asn1_TESTBitString_units() (asn1_TESTBitString_table_units) 701 ASN1EXP int ASN1CALL decode_TESTBitString(const unsigned char *, size_t, TESTBitString *, size_t *); 702 ASN1EXP int ASN1CALL encode_TESTBitString(unsigned char *, size_t, const TESTBitString *, size_t *); 703 ASN1EXP size_t ASN1CALL length_TESTBitString(const TESTBitString *); 704 ASN1EXP int ASN1CALL copy_TESTBitString (const TESTBitString *, TESTBitString *); 705 ASN1EXP void ASN1CALL free_TESTBitString (TESTBitString *); 706 707 708 /* 709 TESTMechType ::= OBJECT IDENTIFIER 710 */ 711 712 typedef heim_oid TESTMechType; 713 714 ASN1EXP int ASN1CALL decode_TESTMechType(const unsigned char *, size_t, TESTMechType *, size_t *); 715 ASN1EXP int ASN1CALL encode_TESTMechType(unsigned char *, size_t, const TESTMechType *, size_t *); 716 ASN1EXP size_t ASN1CALL length_TESTMechType(const TESTMechType *); 717 ASN1EXP int ASN1CALL copy_TESTMechType (const TESTMechType *, TESTMechType *); 718 ASN1EXP void ASN1CALL free_TESTMechType (TESTMechType *); 719 720 721 /* 722 TESTMechTypeList ::= SEQUENCE OF TESTMechType 723 */ 724 725 typedef struct TESTMechTypeList { 726 unsigned int len; 727 TESTMechType *val; 728 } TESTMechTypeList; 729 730 ASN1EXP int ASN1CALL decode_TESTMechTypeList(const unsigned char *, size_t, TESTMechTypeList *, size_t *); 731 ASN1EXP int ASN1CALL encode_TESTMechTypeList(unsigned char *, size_t, const TESTMechTypeList *, size_t *); 732 ASN1EXP size_t ASN1CALL length_TESTMechTypeList(const TESTMechTypeList *); 733 ASN1EXP int ASN1CALL copy_TESTMechTypeList (const TESTMechTypeList *, TESTMechTypeList *); 734 ASN1EXP void ASN1CALL free_TESTMechTypeList (TESTMechTypeList *); 735 736 737 /* 738 TESTContextFlags ::= BIT STRING { 739 delegFlag(0), 740 mutualFlag(1), 741 replayFlag(2), 742 sequenceFlag(3), 743 anonFlag(4), 744 confFlag(5), 745 integFlag(6) 746 } 747 */ 748 749 typedef struct TESTContextFlags { 750 unsigned int delegFlag:1; 751 unsigned int mutualFlag:1; 752 unsigned int replayFlag:1; 753 unsigned int sequenceFlag:1; 754 unsigned int anonFlag:1; 755 unsigned int confFlag:1; 756 unsigned int integFlag:1; 757 unsigned int _unused7:1; 758 unsigned int _unused8:1; 759 unsigned int _unused9:1; 760 unsigned int _unused10:1; 761 unsigned int _unused11:1; 762 unsigned int _unused12:1; 763 unsigned int _unused13:1; 764 unsigned int _unused14:1; 765 unsigned int _unused15:1; 766 unsigned int _unused16:1; 767 unsigned int _unused17:1; 768 unsigned int _unused18:1; 769 unsigned int _unused19:1; 770 unsigned int _unused20:1; 771 unsigned int _unused21:1; 772 unsigned int _unused22:1; 773 unsigned int _unused23:1; 774 unsigned int _unused24:1; 775 unsigned int _unused25:1; 776 unsigned int _unused26:1; 777 unsigned int _unused27:1; 778 unsigned int _unused28:1; 779 unsigned int _unused29:1; 780 unsigned int _unused30:1; 781 unsigned int _unused31:1; 782 } TESTContextFlags; 783 784 785 unsigned TESTContextFlags2int(TESTContextFlags); 786 TESTContextFlags int2TESTContextFlags(unsigned); 787 extern const struct units *asn1_TESTContextFlags_table_units; 788 #define asn1_TESTContextFlags_units() (asn1_TESTContextFlags_table_units) 789 ASN1EXP int ASN1CALL decode_TESTContextFlags(const unsigned char *, size_t, TESTContextFlags *, size_t *); 790 ASN1EXP int ASN1CALL encode_TESTContextFlags(unsigned char *, size_t, const TESTContextFlags *, size_t *); 791 ASN1EXP size_t ASN1CALL length_TESTContextFlags(const TESTContextFlags *); 792 ASN1EXP int ASN1CALL copy_TESTContextFlags (const TESTContextFlags *, TESTContextFlags *); 793 ASN1EXP void ASN1CALL free_TESTContextFlags (TESTContextFlags *); 794 795 796 /* 797 TESTNegHints ::= SEQUENCE { 798 hintName [0] GeneralString OPTIONAL, 799 hintAddress [1] OCTET STRING OPTIONAL, 800 } 801 */ 802 803 typedef struct TESTNegHints { 804 heim_general_string *hintName; 805 heim_octet_string *hintAddress; 806 } TESTNegHints; 807 808 ASN1EXP int ASN1CALL decode_TESTNegHints(const unsigned char *, size_t, TESTNegHints *, size_t *); 809 ASN1EXP int ASN1CALL encode_TESTNegHints(unsigned char *, size_t, const TESTNegHints *, size_t *); 810 ASN1EXP size_t ASN1CALL length_TESTNegHints(const TESTNegHints *); 811 ASN1EXP int ASN1CALL copy_TESTNegHints (const TESTNegHints *, TESTNegHints *); 812 ASN1EXP void ASN1CALL free_TESTNegHints (TESTNegHints *); 813 814 815 /* 816 TESTNegTokenInit ::= SEQUENCE { 817 mechTypes [0] TESTMechTypeList, 818 reqFlags [1] TESTContextFlags OPTIONAL, 819 mechToken [2] OCTET STRING OPTIONAL, 820 mechListMIC [3] OCTET STRING OPTIONAL, 821 ..., 822 } 823 */ 824 825 typedef struct TESTNegTokenInit { 826 TESTMechTypeList mechTypes; 827 TESTContextFlags *reqFlags; 828 heim_octet_string *mechToken; 829 heim_octet_string *mechListMIC; 830 } TESTNegTokenInit; 831 832 ASN1EXP int ASN1CALL decode_TESTNegTokenInit(const unsigned char *, size_t, TESTNegTokenInit *, size_t *); 833 ASN1EXP int ASN1CALL encode_TESTNegTokenInit(unsigned char *, size_t, const TESTNegTokenInit *, size_t *); 834 ASN1EXP size_t ASN1CALL length_TESTNegTokenInit(const TESTNegTokenInit *); 835 ASN1EXP int ASN1CALL copy_TESTNegTokenInit (const TESTNegTokenInit *, TESTNegTokenInit *); 836 ASN1EXP void ASN1CALL free_TESTNegTokenInit (TESTNegTokenInit *); 837 838 839 /* 840 TESTNegResultEnum ::= INTEGER { 841 accept_completed(0), 842 accept_incomplete(1), 843 reject(2), 844 request_mic(3) 845 } 846 */ 847 848 typedef enum TESTNegResultEnum { 849 accept_completed = 0, 850 accept_incomplete = 1, 851 reject = 2, 852 request_mic = 3 853 } TESTNegResultEnum; 854 855 ASN1EXP int ASN1CALL decode_TESTNegResultEnum(const unsigned char *, size_t, TESTNegResultEnum *, size_t *); 856 ASN1EXP int ASN1CALL encode_TESTNegResultEnum(unsigned char *, size_t, const TESTNegResultEnum *, size_t *); 857 ASN1EXP size_t ASN1CALL length_TESTNegResultEnum(const TESTNegResultEnum *); 858 ASN1EXP int ASN1CALL copy_TESTNegResultEnum (const TESTNegResultEnum *, TESTNegResultEnum *); 859 ASN1EXP void ASN1CALL free_TESTNegResultEnum (TESTNegResultEnum *); 860 861 862 /* 863 TESTNegTokenResp ::= SEQUENCE { 864 negResult [0] TESTNegResultEnum OPTIONAL, 865 supportedMech [1] TESTMechType OPTIONAL, 866 responseToken [2] OCTET STRING OPTIONAL, 867 mechListMIC [3] OCTET STRING OPTIONAL, 868 ..., 869 } 870 */ 871 872 typedef struct TESTNegTokenResp { 873 TESTNegResultEnum *negResult; 874 TESTMechType *supportedMech; 875 heim_octet_string *responseToken; 876 heim_octet_string *mechListMIC; 877 } TESTNegTokenResp; 878 879 ASN1EXP int ASN1CALL decode_TESTNegTokenResp(const unsigned char *, size_t, TESTNegTokenResp *, size_t *); 880 ASN1EXP int ASN1CALL encode_TESTNegTokenResp(unsigned char *, size_t, const TESTNegTokenResp *, size_t *); 881 ASN1EXP size_t ASN1CALL length_TESTNegTokenResp(const TESTNegTokenResp *); 882 ASN1EXP int ASN1CALL copy_TESTNegTokenResp (const TESTNegTokenResp *, TESTNegTokenResp *); 883 ASN1EXP void ASN1CALL free_TESTNegTokenResp (TESTNegTokenResp *); 884 885 886 /* 887 TESTNegotiationToken ::= CHOICE { 888 negTokenInit [0] TESTNegTokenInit, 889 negTokenResp [1] TESTNegTokenResp, 890 } 891 */ 892 893 typedef struct TESTNegotiationToken { 894 enum TESTNegotiationToken_enum { 895 invalid_choice_TESTNegotiationToken = 0, 896 choice_TESTNegotiationToken_negTokenInit = 1, 897 choice_TESTNegotiationToken_negTokenResp 898 } element; 899 union { 900 TESTNegTokenInit negTokenInit; 901 TESTNegTokenResp negTokenResp; 902 } u; 903 } TESTNegotiationToken; 904 905 ASN1EXP int ASN1CALL decode_TESTNegotiationToken(const unsigned char *, size_t, TESTNegotiationToken *, size_t *); 906 ASN1EXP int ASN1CALL encode_TESTNegotiationToken(unsigned char *, size_t, const TESTNegotiationToken *, size_t *); 907 ASN1EXP size_t ASN1CALL length_TESTNegotiationToken(const TESTNegotiationToken *); 908 ASN1EXP int ASN1CALL copy_TESTNegotiationToken (const TESTNegotiationToken *, TESTNegotiationToken *); 909 ASN1EXP void ASN1CALL free_TESTNegotiationToken (TESTNegotiationToken *); 910 911 912 #endif /* __test_asn1_h__ */