lib/asn1/gen_template.c

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