1/* 2 * Copyright (c) 1997 - 2005 Kungliga Tekniska H�gskolan 3 * (Royal Institute of Technology, Stockholm, Sweden). 4 * All rights reserved. 5 * 6 * Portions Copyright (c) 2009 - 2010 Apple Inc. All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * 3. Neither the name of the Institute nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 */ 35 36#include "gen_locl.h" 37 38static const char *symbol_name(const char *, const Type *); 39static void generate_template_type(const char *, const char **, const char *, const char *, const char *, 40 Type *, int, int, int); 41 42static const char * 43ttype_symbol(const char *basename, const Type *t) 44{ 45 return t->symbol->gen_name; 46} 47 48static const char * 49integer_symbol(const char *basename, const Type *t) 50{ 51 if (t->members) 52 return "int"; /* XXX enum foo */ 53 else if (t->range == NULL) 54 return "heim_integer"; 55 else if (t->range->min == INT_MIN && t->range->max == INT_MAX) 56 return "int"; 57 else if (t->range->min == 0 && (unsigned int)t->range->max == UINT_MAX) 58 return "unsigned"; 59 else if (t->range->min == 0 && t->range->max == INT_MAX) 60 return "unsigned"; 61 else { 62 abort(); 63 UNREACHABLE(return NULL); 64 } 65} 66 67static const char * 68boolean_symbol(const char *basename, const Type *t) 69{ 70 return "int"; 71} 72 73 74static const char * 75octetstring_symbol(const char *basename, const Type *t) 76{ 77 return "heim_octet_string"; 78} 79 80static const char * 81sequence_symbol(const char *basename, const Type *t) 82{ 83 return basename; 84} 85 86static const char * 87time_symbol(const char *basename, const Type *t) 88{ 89 return "time_t"; 90} 91 92static const char * 93tag_symbol(const char *basename, const Type *t) 94{ 95 return symbol_name(basename, t->subtype); 96} 97 98static const char * 99generalstring_symbol(const char *basename, const Type *t) 100{ 101 return "heim_general_string"; 102} 103 104static const char * 105printablestring_symbol(const char *basename, const Type *t) 106{ 107 return "heim_printable_string"; 108} 109 110static const char * 111ia5string_symbol(const char *basename, const Type *t) 112{ 113 return "heim_ia5_string"; 114} 115 116static const char * 117teletexstring_symbol(const char *basename, const Type *t) 118{ 119 return "heim_teletex_string"; 120} 121 122static const char * 123visiblestring_symbol(const char *basename, const Type *t) 124{ 125 return "heim_visible_string"; 126} 127 128static const char * 129utf8string_symbol(const char *basename, const Type *t) 130{ 131 return "heim_utf8_string"; 132} 133 134static const char * 135bmpstring_symbol(const char *basename, const Type *t) 136{ 137 return "heim_bmp_string"; 138} 139 140static const char * 141universalstring_symbol(const char *basename, const Type *t) 142{ 143 return "heim_universal_string"; 144} 145 146static const char * 147oid_symbol(const char *basename, const Type *t) 148{ 149 return "heim_oid"; 150} 151 152static const char * 153bitstring_symbol(const char *basename, const Type *t) 154{ 155 if (t->members) 156 return basename; 157 return "heim_bit_string"; 158} 159 160 161 162struct { 163 enum typetype type; 164 const char *(*symbol_name)(const char *, const Type *); 165 int is_struct; 166} types[] = { 167 { TBMPString, bmpstring_symbol, 0 }, 168 { TBitString, bitstring_symbol, 0 }, 169 { TBoolean, boolean_symbol, 0 }, 170 { TGeneralString, generalstring_symbol, 0 }, 171 { TGeneralizedTime, time_symbol, 0 }, 172 { TIA5String, ia5string_symbol, 0 }, 173 { TTeletexString, generalstring_symbol, 0 }, 174 { TInteger, integer_symbol, 0 }, 175 { TOID, oid_symbol, 0 }, 176 { TOctetString, octetstring_symbol, 0 }, 177 { TPrintableString, printablestring_symbol, 0 }, 178 { TSequence, sequence_symbol, 1 }, 179 { TSequenceOf, tag_symbol, 1 }, 180 { TSetOf, tag_symbol, 1 }, 181 { TTag, tag_symbol, 1 }, 182 { TType, ttype_symbol, 1 }, 183 { TUTCTime, time_symbol, 0 }, 184 { TUniversalString, universalstring_symbol, 0 }, 185 { TTeletexString, teletexstring_symbol, 0 }, 186 { TVisibleString, visiblestring_symbol, 0 }, 187 { TUTF8String, utf8string_symbol, 0 }, 188 { TChoice, sequence_symbol, 1 }, 189 { TNull, integer_symbol, 1 } 190}; 191 192static FILE * 193get_code_file(void) 194{ 195 if (!one_code_file) 196 return templatefile; 197 return codefile; 198} 199 200 201static int 202is_supported_type_p(const Type *t) 203{ 204 size_t i; 205 206 for (i = 0; i < sizeof(types)/sizeof(types[0]); i++) 207 if (t->type == types[i].type) 208 return 1; 209 return 0; 210} 211 212int 213is_template_compat (const Symbol *s) 214{ 215 return is_supported_type_p(s->type); 216} 217 218static const char * 219symbol_name(const char *basename, const Type *t) 220{ 221 size_t i; 222 223 for (i = 0; i < sizeof(types)/sizeof(types[0]); i++) 224 if (t->type == types[i].type) 225 return (types[i].symbol_name)(basename, t); 226 printf("unknown der type: %d\n", t->type); 227 exit(1); 228} 229 230 231static char * 232partial_offset(const char *basetype, const char *name, int need_offset, int isstruct) 233{ 234 char *str; 235 if (name == NULL || need_offset == 0) 236 return strdup("0"); 237 if (asprintf(&str, "offsetof(%s%s, %s)", isstruct ? "struct " : "", basetype, name) < 0 || str == NULL) 238 errx(1, "malloc"); 239 return str; 240} 241 242struct template { 243 char *line; 244 char *tt; 245 char *offset; 246 char *ptr; 247 ASN1_TAILQ_ENTRY(template) members; 248}; 249 250ASN1_TAILQ_HEAD(templatehead, template); 251 252struct tlist { 253 char *name; 254 char *header; 255 struct templatehead template; 256 ASN1_TAILQ_ENTRY(tlist) tmembers; 257}; 258 259ASN1_TAILQ_HEAD(tlisthead, tlist); 260 261static void tlist_header(struct tlist *, const char *, ...) __attribute__((__format__(__printf__, 2, 3))); 262static struct template * 263 add_line(struct templatehead *, const char *, ...) __attribute__((__format__(__printf__, 2, 3))); 264static int tlist_cmp(const struct tlist *, const struct tlist *); 265 266static void add_line_pointer(struct templatehead *, const char *, const char *, const char *, ...) 267 __attribute__((__format__(__printf__, 4, 5))); 268 269 270static struct tlisthead tlistmaster = ASN1_TAILQ_HEAD_INITIALIZER(tlistmaster); 271static unsigned long numdups = 0; 272 273static struct tlist * 274tlist_new(const char *name) 275{ 276 struct tlist *tl = calloc(1, sizeof(*tl)); 277 tl->name = strdup(name); 278 ASN1_TAILQ_INIT(&tl->template); 279 return tl; 280} 281 282static void 283tlist_header(struct tlist *t, const char *fmt, ...) 284{ 285 va_list ap; 286 va_start(ap, fmt); 287 if (vasprintf(&t->header, fmt, ap) < 0 || t->header == NULL) 288 errx(1, "malloc"); 289 va_end(ap); 290} 291 292static unsigned long 293tlist_count(struct tlist *tl) 294{ 295 unsigned int count = 0; 296 struct template *q; 297 298 ASN1_TAILQ_FOREACH(q, &tl->template, members) { 299 count++; 300 } 301 return count; 302} 303 304static void 305tlist_add(struct tlist *tl) 306{ 307 ASN1_TAILQ_INSERT_TAIL(&tlistmaster, tl, tmembers); 308} 309 310static void 311tlist_print(struct tlist *tl) 312{ 313 struct template *q; 314 unsigned int i = 1; 315 FILE *f = get_code_file(); 316 317 fprintf(f, "const struct asn1_template asn1_%s[] = {\n", tl->name); 318 fprintf(f, "/* 0 */ %s,\n", tl->header); 319 ASN1_TAILQ_FOREACH(q, &tl->template, members) { 320 int last = (ASN1_TAILQ_LAST(&tl->template, templatehead) == q); 321 fprintf(f, "/* %lu */ %s%s\n", (unsigned long)i++, q->line, last ? "" : ","); 322 } 323 fprintf(f, "};\n"); 324} 325 326static struct tlist * 327tlist_find_by_name(const char *name) 328{ 329 struct tlist *ql; 330 ASN1_TAILQ_FOREACH(ql, &tlistmaster, tmembers) { 331 if (strcmp(ql->name, name) == 0) 332 return ql; 333 } 334 return NULL; 335} 336 337static int 338tlist_cmp_name(const char *tname, const char *qname) 339{ 340 struct tlist *tl = tlist_find_by_name(tname); 341 struct tlist *ql = tlist_find_by_name(qname); 342 if (tl == NULL) 343 return 1; 344 if (ql == NULL) 345 return -1; 346 return tlist_cmp(tl, ql); 347} 348 349static int 350tlist_cmp(const struct tlist *tl, const struct tlist *ql) 351{ 352 int ret; 353 struct template *t, *q; 354 355 ret = strcmp(tl->header, ql->header); 356 if (ret) return ret; 357 358 q = ASN1_TAILQ_FIRST(&ql->template); 359 ASN1_TAILQ_FOREACH(t, &tl->template, members) { 360 if (q == NULL) return 1; 361 362 if (t->ptr == NULL || q->ptr == NULL) { 363 ret = strcmp(t->line, q->line); 364 if (ret) return ret; 365 } else { 366 ret = strcmp(t->tt, q->tt); 367 if (ret) return ret; 368 369 ret = strcmp(t->offset, q->offset); 370 if (ret) return ret; 371 372 if ((ret = strcmp(t->ptr, q->ptr)) != 0 || 373 (ret = tlist_cmp_name(t->ptr, q->ptr)) != 0) 374 return ret; 375 } 376 q = ASN1_TAILQ_NEXT(q, members); 377 } 378 if (q != NULL) return -1; 379 return 0; 380} 381 382 383static const char * 384tlist_find_dup(const struct tlist *tl) 385{ 386 struct tlist *ql; 387 388 ASN1_TAILQ_FOREACH(ql, &tlistmaster, tmembers) { 389 if (tlist_cmp(ql, tl) == 0) { 390 numdups++; 391 return ql->name; 392 } 393 } 394 return NULL; 395} 396 397 398/* 399 * 400 */ 401 402static struct template * 403add_line(struct templatehead *t, const char *fmt, ...) 404{ 405 struct template *q = calloc(1, sizeof(*q)); 406 va_list ap; 407 va_start(ap, fmt); 408 if (vasprintf(&q->line, fmt, ap) < 0 || q->line == NULL) 409 errx(1, "malloc"); 410 va_end(ap); 411 ASN1_TAILQ_INSERT_TAIL(t, q, members); 412 return q; 413} 414 415static void 416add_line_pointer(struct templatehead *t, 417 const char *ptr, 418 const char *offset, 419 const char *ttfmt, 420 ...) 421{ 422 struct template *q; 423 va_list ap; 424 char *tt = NULL; 425 426 va_start(ap, ttfmt); 427 if (vasprintf(&tt, ttfmt, ap) < 0 || tt == NULL) 428 errx(1, "malloc"); 429 va_end(ap); 430 431 q = add_line(t, "{ %s, %s, asn1_%s }", tt, offset, ptr); 432 q->tt = tt; 433 q->offset = strdup(offset); 434 q->ptr = strdup(ptr); 435} 436 437static int 438use_extern(const Symbol *s) 439{ 440 if (s->type == NULL) 441 return 1; 442 return 0; 443} 444 445static int 446is_struct(const Type *t, int isstruct) 447{ 448 size_t i; 449 450 if (t->type == TType) 451 return 0; 452 if (t->type == TSequence || t->type == TSet || t->type == TChoice) 453 return 1; 454 if (t->type == TTag) 455 return is_struct(t->subtype, isstruct); 456 457 for (i = 0; i < sizeof(types)/sizeof(types[0]); i++) { 458 if (t->type == types[i].type) { 459 if (types[i].is_struct == 0) 460 return 0; 461 else 462 break; 463 } 464 } 465 466 return isstruct; 467} 468 469static const Type * 470compact_tag(const Type *t) 471{ 472 while (t->type == TTag) 473 t = t->subtype; 474 return t; 475} 476 477static void 478template_members(struct templatehead *temp, const char *basetype, const char *name, const Type *t, int optional, int implicit, int isstruct, int need_offset) 479{ 480 char *poffset = NULL; 481 482 if (optional && t->type != TTag && t->type != TType) 483 errx(1, "%s...%s is optional and not a (TTag or TType)", basetype, name); 484 485 poffset = partial_offset(basetype, name, need_offset, isstruct); 486 487 switch (t->type) { 488 case TType: 489 if (use_extern(t->symbol)) { 490 add_line(temp, "{ A1_OP_TYPE_EXTERN %s%s, %s, &asn1_extern_%s}", 491 optional ? "|A1_FLAG_OPTIONAL" : "", 492 implicit ? "|A1_FLAG_IMPLICIT" : "", 493 poffset, t->symbol->gen_name); 494 } else { 495 add_line_pointer(temp, t->symbol->gen_name, poffset, 496 "A1_OP_TYPE %s%s", 497 optional ? "|A1_FLAG_OPTIONAL" : "", 498 implicit ? "|A1_FLAG_IMPLICIT" : ""); 499 500 } 501 break; 502 case TInteger: { 503 char *itype = NULL; 504 505 if (t->members) 506 itype = "IMEMBER"; 507 else if (t->range == NULL) 508 itype = "HEIM_INTEGER"; 509 else if (t->range->min == INT_MIN && t->range->max == INT_MAX) 510 itype = "INTEGER"; 511 else if (t->range->min == 0 && (unsigned int)t->range->max == UINT_MAX) 512 itype = "UNSIGNED"; 513 else if (t->range->min == 0 && t->range->max == INT_MAX) 514 itype = "UNSIGNED"; 515 else 516 errx(1, "%s: unsupported range %d -> %d", 517 name, t->range->min, t->range->max); 518 519 add_line(temp, "{ A1_PARSE_T(A1T_%s), %s, NULL }", itype, poffset); 520 break; 521 } 522 case TGeneralString: 523 add_line(temp, "{ A1_PARSE_T(A1T_GENERAL_STRING), %s, NULL }", poffset); 524 break; 525 case TTeletexString: 526 add_line(temp, "{ A1_PARSE_T(A1T_TELETEX_STRING), %s, NULL }", poffset); 527 break; 528 case TPrintableString: 529 add_line(temp, "{ A1_PARSE_T(A1T_PRINTABLE_STRING), %s, NULL }", poffset); 530 break; 531 case TOctetString: 532 add_line(temp, "{ A1_PARSE_T(A1T_OCTET_STRING), %s, NULL }", poffset); 533 break; 534 case TIA5String: 535 add_line(temp, "{ A1_PARSE_T(A1T_IA5_STRING), %s, NULL }", poffset); 536 break; 537 case TBMPString: 538 add_line(temp, "{ A1_PARSE_T(A1T_BMP_STRING), %s, NULL }", poffset); 539 break; 540 case TUniversalString: 541 add_line(temp, "{ A1_PARSE_T(A1T_UNIVERSAL_STRING), %s, NULL }", poffset); 542 break; 543 case TVisibleString: 544 add_line(temp, "{ A1_PARSE_T(A1T_VISIBLE_STRING), %s, NULL }", poffset); 545 break; 546 case TUTF8String: 547 add_line(temp, "{ A1_PARSE_T(A1T_UTF8_STRING), %s, NULL }", poffset); 548 break; 549 case TGeneralizedTime: 550 add_line(temp, "{ A1_PARSE_T(A1T_GENERALIZED_TIME), %s, NULL }", poffset); 551 break; 552 case TUTCTime: 553 add_line(temp, "{ A1_PARSE_T(A1T_UTC_TIME), %s, NULL }", poffset); 554 break; 555 case TBoolean: 556 add_line(temp, "{ A1_PARSE_T(A1T_BOOLEAN), %s, NULL }", poffset); 557 break; 558 case TOID: 559 add_line(temp, "{ A1_PARSE_T(A1T_OID), %s, NULL }", poffset); 560 break; 561 case TNull: 562 break; 563 case TBitString: { 564 struct templatehead template = ASN1_TAILQ_HEAD_INITIALIZER(template); 565 struct template *q; 566 Member *m; 567 size_t count = 0, i; 568 char *bname = NULL; 569 FILE *f = get_code_file(); 570 static unsigned long bmember_counter = 0; 571 572 if (ASN1_TAILQ_EMPTY(t->members)) { 573 add_line(temp, "{ A1_PARSE_T(A1T_HEIM_BIT_STRING), %s, NULL }", poffset); 574 break; 575 } 576 577 if (asprintf(&bname, "bmember_%s_%lu", name ? name : "", bmember_counter++) < 0 || bname == NULL) 578 errx(1, "malloc"); 579 output_name(bname); 580 581 ASN1_TAILQ_FOREACH(m, t->members, members) { 582 add_line(&template, "{ 0, %d, 0 } /* %s */", m->val, m->gen_name); 583 } 584 585 ASN1_TAILQ_FOREACH(q, &template, members) { 586 count++; 587 } 588 589 fprintf(f, "static const struct asn1_template asn1_%s_%s[] = {\n", basetype, bname); 590 fprintf(f, "/* 0 */ { 0%s, sizeof(%s), ((void *)%lu) },\n", 591 rfc1510_bitstring ? "|A1_HBF_RFC1510" : "", 592 basetype, (unsigned long)count); 593 i = 1; 594 ASN1_TAILQ_FOREACH(q, &template, members) { 595 int last = (ASN1_TAILQ_LAST(&template, templatehead) == q); 596 fprintf(f, "/* %lu */ %s%s\n", (unsigned long)i++, q->line, last ? "" : ","); 597 } 598 fprintf(f, "};\n"); 599 600 add_line(temp, "{ A1_OP_BMEMBER, %s, asn1_%s_%s }", poffset, basetype, bname); 601 602 free(bname); 603 604 break; 605 } 606 case TSequence: { 607 Member *m; 608 609 fprintf(get_code_file(), "/* tsequence: members isstruct: %d */\n", isstruct); 610 611 ASN1_TAILQ_FOREACH(m, t->members, members) { 612 char *newbasename = NULL; 613 614 if (m->ellipsis) 615 continue; 616 617 if (name) { 618 if (asprintf(&newbasename, "%s_%s", basetype, name) < 0) 619 errx(1, "malloc"); 620 } else 621 newbasename = strdup(basetype); 622 if (newbasename == NULL) 623 errx(1, "malloc"); 624 625 template_members(temp, newbasename, m->gen_name, m->type, m->optional, 0, isstruct, 1); 626 627 free(newbasename); 628 } 629 630 break; 631 } 632 case TTag: { 633 char *tname = NULL, *elname = NULL; 634 const char *sename, *dupname; 635 int subtype_is_struct = is_struct(t->subtype, isstruct); 636 static unsigned long tag_counter = 0; 637 int tagimplicit = (t->tag.tagenv == TE_IMPLICIT); 638 struct type *subtype; 639 640 fprintf(get_code_file(), "/* template_members: %s %s %s */\n", basetype, implicit ? "imp" : "exp", tagimplicit ? "imp" : "exp"); 641 642 if (tagimplicit) { 643 644 struct type *type = t->subtype; 645 int have_tag = 0; 646 647 while (!have_tag) { 648 if (type->type == TTag) { 649 fprintf(get_code_file(), "/* template_members: imp skip tag */\n"); 650 type = type->subtype; 651 have_tag = 1; 652 } else if(type->type == TType && type->symbol && type->symbol->type) { 653 /* XXX really, we should stop here and find a 654 * pointer to where this is encoded instead of 655 * generated an new structure and hope that the 656 * optimizer catch it later. 657 */ 658 subtype_is_struct = is_struct(type, isstruct); 659 fprintf(get_code_file(), "/* template_members: imp skip type %s isstruct: %d */\n", 660 type->symbol->name, subtype_is_struct); 661 type = type->symbol->type; 662 } else { 663 have_tag = 1; 664 } 665 } 666 subtype = type; 667 } else { 668 subtype = t->subtype; 669 } 670 671 if (subtype_is_struct) 672 sename = basetype; 673 else 674 sename = symbol_name(basetype, subtype); 675 676 if (asprintf(&tname, "tag_%s_%lu", name ? name : "", tag_counter++) < 0 || tname == NULL) 677 errx(1, "malloc"); 678 output_name(tname); 679 680 if (asprintf(&elname, "%s_%s", basetype, tname) < 0 || elname == NULL) 681 errx(1, "malloc"); 682 683 generate_template_type(elname, &dupname, NULL, sename, name, 684 subtype, 0, subtype_is_struct, 0); 685 686 add_line_pointer(temp, dupname, poffset, 687 "A1_TAG_T(%s,%s,%s)%s%s", 688 classname(t->tag.tagclass), 689 is_primitive_type(subtype->type) ? "PRIM" : "CONS", 690 valuename(t->tag.tagclass, t->tag.tagvalue), 691 optional ? "|A1_FLAG_OPTIONAL" : "", 692 tagimplicit ? "|A1_FLAG_IMPLICIT" : ""); 693 694 free(tname); 695 free(elname); 696 697 break; 698 } 699 case TSetOf: 700 case TSequenceOf: { 701 const char *type = NULL, *tname, *dupname; 702 char *sename = NULL, *elname = NULL; 703 int subtype_is_struct = is_struct(t->subtype, 0); 704 static unsigned long seof_counter = 0; 705 706 if (name && subtype_is_struct) { 707 tname = "seofTstruct"; 708 if (asprintf(&sename, "%s_%s_val", basetype, name) < 0) 709 errx(1, "malloc"); 710 } else if (subtype_is_struct) { 711 tname = "seofTstruct"; 712 if (asprintf(&sename, "%s_val", symbol_name(basetype, t->subtype)) < 0) 713 errx(1, "malloc"); 714 } else { 715 if (name) 716 tname = name; 717 else 718 tname = "seofTstruct"; 719 sename = strdup(symbol_name(basetype, t->subtype)); 720 } 721 if (sename == NULL) 722 errx(1, "malloc"); 723 724 if (t->type == TSetOf) type = "A1_OP_SETOF"; 725 else if (t->type == TSequenceOf) type = "A1_OP_SEQOF"; 726 else abort(); 727 728 if (asprintf(&elname, "%s_%s_%lu", basetype, tname, seof_counter++) < 0 || elname == NULL) 729 errx(1, "malloc"); 730 731 generate_template_type(elname, &dupname, NULL, sename, NULL, t->subtype, 732 0, subtype_is_struct, need_offset); 733 734 add_line(temp, "{ %s, %s, asn1_%s }", type, poffset, dupname); 735 free(sename); 736 break; 737 } 738 case TChoice: { 739 struct templatehead template = ASN1_TAILQ_HEAD_INITIALIZER(template); 740 struct template *q; 741 size_t count = 0, i; 742 char *tname = NULL; 743 FILE *f = get_code_file(); 744 Member *m; 745 int ellipsis = 0; 746 char *e; 747 static unsigned long choice_counter = 0; 748 749 if (asprintf(&tname, "asn1_choice_%s_%s%lu", 750 basetype, name ? name : "", choice_counter++) < 0 || tname == NULL) 751 errx(1, "malloc"); 752 753 ASN1_TAILQ_FOREACH(m, t->members, members) { 754 const char *dupname; 755 char *elname = NULL; 756 char *newbasename = NULL; 757 int subtype_is_struct; 758 759 if (m->ellipsis) { 760 ellipsis = 1; 761 continue; 762 } 763 764 subtype_is_struct = is_struct(m->type, 0); 765 766 if (asprintf(&elname, "%s_choice_%s", basetype, m->gen_name) < 0 || elname == NULL) 767 errx(1, "malloc"); 768 769 if (subtype_is_struct) { 770 if (asprintf(&newbasename, "%s_%s", basetype, m->gen_name) < 0) 771 errx(1, "malloc"); 772 } else 773 newbasename = strdup(basetype); 774 775 if (newbasename == NULL) 776 errx(1, "malloc"); 777 778 779 generate_template_type(elname, &dupname, NULL, 780 symbol_name(newbasename, m->type), 781 NULL, m->type, 0, subtype_is_struct, 1); 782 783 add_line(&template, "{ %s, offsetof(%s%s, u.%s), asn1_%s }", 784 m->label, isstruct ? "struct " : "", 785 basetype, m->gen_name, 786 dupname); 787 788 free(elname); 789 free(newbasename); 790 } 791 792 e = NULL; 793 if (ellipsis) { 794 if (asprintf(&e, "offsetof(%s%s, u.asn1_ellipsis)", isstruct ? "struct " : "", basetype) < 0 || e == NULL) 795 errx(1, "malloc"); 796 } 797 798 ASN1_TAILQ_FOREACH(q, &template, members) { 799 count++; 800 } 801 802 fprintf(f, "static const struct asn1_template %s[] = {\n", tname); 803 fprintf(f, "/* 0 */ { %s, offsetof(%s%s, element), ((void *)%lu) },\n", 804 e ? e : "0", isstruct ? "struct " : "", basetype, (unsigned long)count); 805 i = 1; 806 ASN1_TAILQ_FOREACH(q, &template, members) { 807 int last = (ASN1_TAILQ_LAST(&template, templatehead) == q); 808 fprintf(f, "/* %lu */ %s%s\n", (unsigned long)i++, q->line, last ? "" : ","); 809 } 810 fprintf(f, "};\n"); 811 812 add_line(temp, "{ A1_OP_CHOICE, %s, %s }", poffset, tname); 813 814 free(e); 815 free(tname); 816 break; 817 } 818 default: 819 abort (); 820 } 821 if (poffset) 822 free(poffset); 823} 824 825static void 826gen_extern_stubs(FILE *f, const char *name) 827{ 828 fprintf(f, 829 "static const struct asn1_type_func asn1_extern_%s = {\n" 830 "\t(asn1_type_encode)encode_%s,\n" 831 "\t(asn1_type_decode)decode_%s,\n" 832 "\t(asn1_type_length)length_%s,\n" 833 "\t(asn1_type_copy)copy_%s,\n" 834 "\t(asn1_type_release)free_%s,\n" 835 "\tsizeof(%s)\n" 836 "};\n", 837 name, name, name, name, 838 name, name, name); 839} 840 841void 842gen_template_import(const Symbol *s) 843{ 844 FILE *f = get_code_file(); 845 846 if (template_flag == 0) 847 return; 848 849 gen_extern_stubs(f, s->gen_name); 850} 851 852static void 853generate_template_type(const char *varname, 854 const char **dupname, 855 const char *symname, 856 const char *basetype, 857 const char *name, 858 Type *type, 859 int optional, int isstruct, int need_offset) 860{ 861 struct tlist *tl; 862 const char *dup; 863 int have_ellipsis = 0; 864 int implicit = 0; 865 int preservep = 0; 866 867 preservep = (symname && preserve_type(symname)); 868 869 if (preservep) 870 check_preserve_type(symname, type); 871 872 tl = tlist_new(varname); 873 874 if (type->type == TTag) 875 implicit = (type->tag.tagenv == TE_IMPLICIT); 876 877 fprintf(get_code_file(), "extern const struct asn1_template asn1_%s[];\n", tl->name); 878 879 template_members(&tl->template, basetype, name, type, optional, implicit, isstruct, need_offset); 880 881 /* if its a sequence or set type, check if there is a ellipsis */ 882 if (type->type == TSequence || type->type == TSet) { 883 Member *m; 884 ASN1_TAILQ_FOREACH(m, type->members, members) { 885 if (m->ellipsis) 886 have_ellipsis = 1; 887 } 888 } 889 890 if (ASN1_TAILQ_EMPTY(&tl->template) && compact_tag(type)->type != TNull) 891 errx(1, "Tag %s...%s with no content ?", basetype, name ? name : ""); 892 893 fprintf(get_code_file(), "/* generate_template_type: %s */\n", tl->name); 894 895 tlist_header(tl, "{ 0%s%s, sizeof(%s%s), ((void *)%lu) }", 896 preservep ? "|A1_HF_PRESERVE" : "", 897 have_ellipsis ? "|A1_HF_ELLIPSIS" : "", 898 isstruct ? "struct " : "", basetype, tlist_count(tl)); 899 900 dup = tlist_find_dup(tl); 901 if (dup) { 902#if 0 903 if (strcmp(dup, tl->name) == 0) 904 errx(1, "found dup of ourself: %s", dup); 905#endif 906 *dupname = dup; 907 } else { 908 *dupname = tl->name; 909 tlist_print(tl); 910 tlist_add(tl); 911 } 912} 913 914 915void 916generate_template(const Symbol *s) 917{ 918 FILE *f = get_code_file(); 919 const char *dupname; 920 921 if (use_extern(s)) { 922 gen_extern_stubs(f, s->gen_name); 923 return; 924 } 925 926 generate_template_type(s->gen_name, &dupname, s->name, s->gen_name, NULL, s->type, 0, 0, 1); 927 928 fprintf(f, 929 "\n" 930 "int\n" 931 "decode_%s(const unsigned char *p, size_t len, %s *data, size_t *size)\n" 932 "{\n" 933#ifdef ASN1_CAPTURE_DATA 934 " _asn1_capture_data(\"%s\", p, len);\n" 935#endif 936 " return _asn1_decode_top(asn1_%s, 0|%s, p, len, data, size);\n" 937 "}\n" 938 "\n", 939 s->gen_name, 940 s->gen_name, 941 dupname, 942#ifdef ASN1_CAPTURE_DATA 943 dupname, 944#endif 945 support_ber ? "A1_PF_ALLOW_BER" : "0"); 946 947 fprintf(f, 948 "\n" 949 "int\n" 950 "encode_%s(unsigned char *p, size_t len, const %s *data, size_t *size)\n" 951 "{\n" 952 " int ret = _asn1_encode%s(asn1_%s, p, len, data, size);\n" 953#ifdef ASN1_CAPTURE_DATA 954 " if (ret == 0) { _asn1_capture_data(\"%s\", p - len - 1, len); };\n" 955#endif 956 " return ret;\n" 957 "}\n" 958 "\n", 959 s->gen_name, 960 s->gen_name, 961 fuzzer_string, 962 dupname 963#ifdef ASN1_CAPTURE_DATA 964 , dupname 965#endif 966 ); 967 968 fprintf(f, 969 "\n" 970 "size_t\n" 971 "length_%s(const %s *data)\n" 972 "{\n" 973 " return _asn1_length%s(asn1_%s, data);\n" 974 "}\n" 975 "\n", 976 s->gen_name, 977 s->gen_name, 978 fuzzer_string, 979 dupname); 980 981 982 fprintf(f, 983 "\n" 984 "void\n" 985 "free_%s(%s *data)\n" 986 "{\n" 987 " _asn1_free_top(asn1_%s, data);\n" 988 "}\n" 989 "\n", 990 s->gen_name, 991 s->gen_name, 992 dupname); 993 994 fprintf(f, 995 "\n" 996 "int\n" 997 "copy_%s(const %s *from, %s *to)\n" 998 "{\n" 999 " return _asn1_copy_top(asn1_%s, from, to);\n" 1000 "}\n" 1001 "\n", 1002 s->gen_name, 1003 s->gen_name, 1004 s->gen_name, 1005 dupname); 1006} 1007