lib/asn1/gen.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 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 RCSID("$Id$");
  39
  40 FILE *privheaderfile, *headerfile, *codefile, *logfile, *templatefile;
  41
  42 #define STEM "asn1"
  43
  44 static const char *orig_filename;
  45 static char *privheader, *header, *template;
  46 static const char *headerbase = STEM;
  47
  48 /*
  49  * list of all IMPORTs
  50  */
  51
  52 struct import {
  53     const char *module;
  54     struct import *next;
  55 };
  56
  57 static struct import *imports = NULL;
  58
  59 void
  60 add_import (const char *module)
  61 {
  62     struct import *tmp = emalloc (sizeof(*tmp));
  63
  64     tmp->module = module;
  65     tmp->next   = imports;
  66     imports     = tmp;
  67
  68     fprintf (headerfile, "#include <%s_asn1.h>\n", module);
  69 }
  70
  71 /*
  72  * List of all exported symbols
  73  */
  74
  75 struct sexport {
  76     const char *name;
  77     int defined;
  78     struct sexport *next;
  79 };
  80
  81 static struct sexport *exports = NULL;
  82
  83 void
  84 add_export (const char *name)
  85 {
  86     struct sexport *tmp = emalloc (sizeof(*tmp));
  87
  88     tmp->name   = name;
  89     tmp->next   = exports;
  90     exports     = tmp;
  91 }
  92
  93 int
  94 is_export(const char *name)
  95 {
  96     struct sexport *tmp;
  97
  98     if (exports == NULL) /* no export list, all exported */
  99         return 1;
 100
 101     for (tmp = exports; tmp != NULL; tmp = tmp->next) {
 102         if (strcmp(tmp->name, name) == 0) {
 103             tmp->defined = 1;
 104             return 1;
 105         }
 106     }
 107     return 0;
 108 }
 109
 110 const char *
 111 get_filename (void)
 112 {
 113     return orig_filename;
 114 }
 115
 116 void
 117 init_generate (const char *filename, const char *base)
 118 {
 119     char *fn = NULL;
 120
 121     orig_filename = filename;
 122     if (base != NULL) {
 123         headerbase = strdup(base);
 124         if (headerbase == NULL)
 125             errx(1, "strdup");
 126     }
 127
 128     /* public header file */
 129     if (asprintf(&header, "%s.h", headerbase) < 0 || header == NULL)
 130         errx(1, "malloc");
 131     if (asprintf(&fn, "%s.hx", headerbase) < 0 || fn == NULL)
 132         errx(1, "malloc");
 133     headerfile = fopen (fn, "w");
 134     if (headerfile == NULL)
 135         err (1, "open %s", fn);
 136     free(fn);
 137     fn = NULL;
 138
 139     /* private header file */
 140     if (asprintf(&privheader, "%s-priv.h", headerbase) < 0 || privheader == NULL)
 141         errx(1, "malloc");
 142     if (asprintf(&fn, "%s-priv.hx", headerbase) < 0 || fn == NULL)
 143         errx(1, "malloc");
 144     privheaderfile = fopen (fn, "w");
 145     if (privheaderfile == NULL)
 146         err (1, "open %s", fn);
 147     free(fn);
 148     fn = NULL;
 149
 150     /* template file */
 151     if (asprintf(&template, "%s-template.c", headerbase) < 0 || template == NULL)
 152         errx(1, "malloc");
 153     fprintf (headerfile,
 154              "/* Generated from %s */\n"
 155              "/* Do not edit */\n\n",
 156              filename);
 157     fprintf (headerfile,
 158              "#ifndef __%s_h__\n"
 159              "#define __%s_h__\n\n", headerbase, headerbase);
 160     fprintf (headerfile,
 161              "#include <stddef.h>\n"
 162              "#include <time.h>\n\n");
 163     fprintf (headerfile,
 164              "#ifndef __asn1_common_definitions__\n"
 165              "#define __asn1_common_definitions__\n\n");
 166     fprintf (headerfile,
 167              "typedef struct heim_integer {\n"
 168              "  size_t length;\n"
 169              "  void *data;\n"
 170              "  int negative;\n"
 171              "} heim_integer;\n\n");
 172     fprintf (headerfile,
 173              "#ifndef __HEIM_OCTET_STRING__\n"
 174              "#define __HEIM_OCTET_STRING__\n"
 175              "typedef struct heim_octet_string {\n"
 176              "  size_t length;\n"
 177              "  void *data;\n"
 178              "} heim_octet_string;\n"
 179              "#endif\n\n");
 180     fprintf (headerfile,
 181              "typedef char *heim_general_string;\n\n"
 182              );
 183     fprintf (headerfile,
 184              "typedef char *heim_utf8_string;\n\n"
 185              );
 186     fprintf (headerfile,
 187              "typedef struct heim_octet_string heim_printable_string;\n\n"
 188              );
 189     fprintf (headerfile,
 190              "typedef struct heim_octet_string heim_ia5_string;\n\n"
 191              );
 192     fprintf (headerfile,
 193              "typedef struct heim_bmp_string {\n"
 194              "  size_t length;\n"
 195              "  uint16_t *data;\n"
 196              "} heim_bmp_string;\n\n");
 197     fprintf (headerfile,
 198              "typedef struct heim_universal_string {\n"
 199              "  size_t length;\n"
 200              "  uint32_t *data;\n"
 201              "} heim_universal_string;\n\n");
 202     fprintf (headerfile,
 203              "typedef char *heim_visible_string;\n\n"
 204              );
 205     fprintf (headerfile,
 206              "typedef struct heim_oid {\n"
 207              "  size_t length;\n"
 208              "  unsigned *components;\n"
 209              "} heim_oid;\n\n");
 210     fprintf (headerfile,
 211              "typedef struct heim_bit_string {\n"
 212              "  size_t length;\n"
 213              "  void *data;\n"
 214              "} heim_bit_string;\n\n");
 215     fprintf (headerfile,
 216              "typedef struct heim_octet_string heim_any;\n"
 217              "typedef struct heim_octet_string heim_any_set;\n\n");
 218     fputs("#define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R)                  \\\n"
 219           "  do {                                                         \\\n"
 220           "    (BL) = length_##T((S));                                    \\\n"
 221           "    (B) = malloc((BL));                                        \\\n"
 222           "    if((B) == NULL) {                                          \\\n"
 223           "      (R) = ENOMEM;                                            \\\n"
 224           "    } else {                                                   \\\n"
 225           "      (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \\\n"
 226           "                       (S), (L));                              \\\n"
 227           "      if((R) != 0) {                                           \\\n"
 228           "        free((B));                                             \\\n"
 229           "        (B) = NULL;                                            \\\n"
 230           "      }                                                        \\\n"
 231           "    }                                                          \\\n"
 232           "  } while (0)\n\n",
 233           headerfile);
 234     fputs("#ifdef _WIN32\n"
 235           "#ifndef ASN1_LIB\n"
 236           "#define ASN1EXP  __declspec(dllimport)\n"
 237           "#else\n"
 238           "#define ASN1EXP\n"
 239           "#endif\n"
 240           "#define ASN1CALL __stdcall\n"
 241           "#else\n"
 242           "#define ASN1EXP\n"
 243           "#define ASN1CALL\n"
 244           "#endif\n",
 245           headerfile);
 246     fprintf (headerfile, "struct units;\n\n");
 247     fprintf (headerfile, "#endif\n\n");
 248     if (asprintf(&fn, "%s_files", base) < 0 || fn == NULL)
 249         errx(1, "malloc");
 250     logfile = fopen(fn, "w");
 251     if (logfile == NULL)
 252         err (1, "open %s", fn);
 253
 254     /* if one code file, write into the one codefile */
 255     if (one_code_file)
 256         return;
 257
 258     templatefile = fopen (template, "w");
 259     if (templatefile == NULL)
 260         err (1, "open %s", template);
 261
 262     fprintf (templatefile,
 263              "/* Generated from %s */\n"
 264              "/* Do not edit */\n\n"
 265              "#include <stdio.h>\n"
 266              "#include <stdlib.h>\n"
 267              "#include <time.h>\n"
 268              "#include <string.h>\n"
 269              "#include <errno.h>\n"
 270              "#include <limits.h>\n"
 271              "#include <krb5-types.h>\n",
 272              filename);
 273
 274     fprintf (templatefile,
 275              "#include <%s>\n"
 276              "#include <%s>\n"
 277              "#include <der.h>\n"
 278              "#include <der-private.h>\n"
 279              "#include <asn1-template.h>\n",
 280              header, privheader);
 281
 282
 283 }
 284
 285 void
 286 close_generate (void)
 287 {
 288     fprintf (headerfile, "#endif /* __%s_h__ */\n", headerbase);
 289
 290     if (headerfile)
 291         fclose (headerfile);
 292     if (privheaderfile)
 293         fclose (privheaderfile);
 294     if (templatefile)
 295         fclose (templatefile);
 296     if (logfile)
 297         fprintf (logfile, "\n");
 298         fclose (logfile);
 299 }
 300
 301 void
 302 gen_assign_defval(const char *var, struct value *val)
 303 {
 304     switch(val->type) {
 305     case stringvalue:
 306         fprintf(codefile, "if((%s = strdup(\"%s\")) == NULL)\nreturn ENOMEM;\n", var, val->u.stringvalue);
 307         break;
 308     case integervalue:
 309         fprintf(codefile, "%s = %d;\n", var, val->u.integervalue);
 310         break;
 311     case booleanvalue:
 312         if(val->u.booleanvalue)
 313             fprintf(codefile, "%s = TRUE;\n", var);
 314         else
 315             fprintf(codefile, "%s = FALSE;\n", var);
 316         break;
 317     default:
 318         abort();
 319     }
 320 }
 321
 322 void
 323 gen_compare_defval(const char *var, struct value *val)
 324 {
 325     switch(val->type) {
 326     case stringvalue:
 327         fprintf(codefile, "if(strcmp(%s, \"%s\") != 0)\n", var, val->u.stringvalue);
 328         break;
 329     case integervalue:
 330         fprintf(codefile, "if(%s != %d)\n", var, val->u.integervalue);
 331         break;
 332     case booleanvalue:
 333         if(val->u.booleanvalue)
 334             fprintf(codefile, "if(!%s)\n", var);
 335         else
 336             fprintf(codefile, "if(%s)\n", var);
 337         break;
 338     default:
 339         abort();
 340     }
 341 }
 342
 343 void
 344 generate_header_of_codefile(const char *name)
 345 {
 346     char *filename = NULL;
 347
 348     if (codefile != NULL)
 349         abort();
 350
 351     if (asprintf (&filename, "%s_%s.x", STEM, name) < 0 || filename == NULL)
 352         errx(1, "malloc");
 353     codefile = fopen (filename, "w");
 354     if (codefile == NULL)
 355         err (1, "fopen %s", filename);
 356     fprintf(logfile, "%s ", filename);
 357     free(filename);
 358     filename = NULL;
 359     fprintf (codefile,
 360              "/* Generated from %s */\n"
 361              "/* Do not edit */\n\n"
 362              "#define  ASN1_LIB\n\n"
 363              "#include <stdio.h>\n"
 364              "#include <stdlib.h>\n"
 365              "#include <time.h>\n"
 366              "#include <string.h>\n"
 367              "#include <errno.h>\n"
 368              "#include <limits.h>\n"
 369              "#include <krb5-types.h>\n",
 370              orig_filename);
 371
 372     fprintf (codefile,
 373              "#include <%s>\n"
 374              "#include <%s>\n",
 375              header, privheader);
 376     fprintf (codefile,
 377              "#include <asn1_err.h>\n"
 378              "#include <der.h>\n"
 379              "#include <der-private.h>\n"
 380              "#include <asn1-template.h>\n"
 381              "#include <parse_units.h>\n\n");
 382
 383 }
 384
 385 void
 386 close_codefile(void)
 387 {
 388     if (codefile == NULL)
 389         abort();
 390
 391     fclose(codefile);
 392     codefile = NULL;
 393 }
 394
 395
 396 void
 397 generate_constant (const Symbol *s)
 398 {
 399     switch(s->value->type) {
 400     case booleanvalue:
 401         break;
 402     case integervalue:
 403         fprintf (headerfile, "enum { %s = %d };\n\n",
 404                  s->gen_name, s->value->u.integervalue);
 405         break;
 406     case nullvalue:
 407         break;
 408     case stringvalue:
 409         break;
 410     case objectidentifiervalue: {
 411         struct objid *o, **list;
 412         unsigned int i, len;
 413         char *gen_upper;
 414
 415         if (!one_code_file)
 416             generate_header_of_codefile(s->gen_name);
 417
 418         len = 0;
 419         for (o = s->value->u.objectidentifiervalue; o != NULL; o = o->next)
 420             len++;
 421         if (len == 0) {
 422             printf("s->gen_name: %s",s->gen_name);
 423             fflush(stdout);
 424             break;
 425         }
 426         list = emalloc(sizeof(*list) * len);
 427
 428         i = 0;
 429         for (o = s->value->u.objectidentifiervalue; o != NULL; o = o->next)
 430             list[i++] = o;
 431
 432         fprintf (headerfile, "/* OBJECT IDENTIFIER %s ::= { ", s->name);
 433         for (i = len ; i > 0; i--) {
 434             o = list[i - 1];
 435             fprintf(headerfile, "%s(%d) ",
 436                     o->label ? o->label : "label-less", o->value);
 437         }
 438
 439         fprintf (codefile, "static unsigned oid_%s_variable_num[%d] =  {",
 440                  s->gen_name, len);
 441         for (i = len ; i > 0; i--) {
 442             fprintf(codefile, "%d%s ", list[i - 1]->value, i > 1 ? "," : "");
 443         }
 444         fprintf(codefile, "};\n");
 445
 446         fprintf (codefile, "const heim_oid asn1_oid_%s = "
 447                  "{ %d, oid_%s_variable_num };\n\n",
 448                  s->gen_name, len, s->gen_name);
 449
 450         free(list);
 451
 452         /* header file */
 453
 454         gen_upper = strdup(s->gen_name);
 455         len = strlen(gen_upper);
 456         for (i = 0; i < len; i++)
 457             gen_upper[i] = toupper((int)s->gen_name[i]);
 458
 459         fprintf (headerfile, "} */\n");
 460         fprintf (headerfile,
 461                  "extern ASN1EXP const heim_oid asn1_oid_%s;\n"
 462                  "#define ASN1_OID_%s (&asn1_oid_%s)\n\n",
 463                  s->gen_name,
 464                  gen_upper,
 465                  s->gen_name);
 466
 467         free(gen_upper);
 468
 469         if (!one_code_file)
 470             close_codefile();
 471
 472         break;
 473     }
 474     default:
 475         abort();
 476     }
 477 }
 478
 479 int
 480 is_primitive_type(int type)
 481 {
 482     switch(type) {
 483     case TInteger:
 484     case TBoolean:
 485     case TOctetString:
 486     case TBitString:
 487     case TEnumerated:
 488     case TGeneralizedTime:
 489     case TGeneralString:
 490     case TTeletexString:
 491     case TOID:
 492     case TUTCTime:
 493     case TUTF8String:
 494     case TPrintableString:
 495     case TIA5String:
 496     case TBMPString:
 497     case TUniversalString:
 498     case TVisibleString:
 499     case TNull:
 500         return 1;
 501     default:
 502         return 0;
 503     }
 504 }
 505
 506 static void
 507 space(int level)
 508 {
 509     while(level-- > 0)
 510         fprintf(headerfile, "  ");
 511 }
 512
 513 static const char *
 514 last_member_p(struct member *m)
 515 {
 516     struct member *n = ASN1_TAILQ_NEXT(m, members);
 517     if (n == NULL)
 518         return "";
 519     if (n->ellipsis && ASN1_TAILQ_NEXT(n, members) == NULL)
 520         return "";
 521     return ",";
 522 }
 523
 524 static struct member *
 525 have_ellipsis(Type *t)
 526 {
 527     struct member *m;
 528     ASN1_TAILQ_FOREACH(m, t->members, members) {
 529         if (m->ellipsis)
 530             return m;
 531     }
 532     return NULL;
 533 }
 534
 535 static void
 536 define_asn1 (int level, Type *t)
 537 {
 538     switch (t->type) {
 539     case TType:
 540         fprintf (headerfile, "%s", t->symbol->name);
 541         break;
 542     case TInteger:
 543         if(t->members == NULL) {
 544             fprintf (headerfile, "INTEGER");
 545             if (t->range)
 546                 fprintf (headerfile, " (%d..%d)",
 547                          t->range->min, t->range->max);
 548         } else {
 549             Member *m;
 550             fprintf (headerfile, "INTEGER {\n");
 551             ASN1_TAILQ_FOREACH(m, t->members, members) {
 552                 space (level + 1);
 553                 fprintf(headerfile, "%s(%d)%s\n", m->gen_name, m->val,
 554                         last_member_p(m));
 555             }
 556             space(level);
 557             fprintf (headerfile, "}");
 558         }
 559         break;
 560     case TBoolean:
 561         fprintf (headerfile, "BOOLEAN");
 562         break;
 563     case TOctetString:
 564         fprintf (headerfile, "OCTET STRING");
 565         break;
 566     case TEnumerated :
 567     case TBitString: {
 568         Member *m;
 569
 570         space(level);
 571         if(t->type == TBitString)
 572             fprintf (headerfile, "BIT STRING {\n");
 573         else
 574             fprintf (headerfile, "ENUMERATED {\n");
 575         ASN1_TAILQ_FOREACH(m, t->members, members) {
 576             space(level + 1);
 577             fprintf (headerfile, "%s(%d)%s\n", m->name, m->val,
 578                      last_member_p(m));
 579         }
 580         space(level);
 581         fprintf (headerfile, "}");
 582         break;
 583     }
 584     case TChoice:
 585     case TSet:
 586     case TSequence: {
 587         Member *m;
 588         int max_width = 0;
 589
 590         if(t->type == TChoice)
 591             fprintf(headerfile, "CHOICE {\n");
 592         else if(t->type == TSet)
 593             fprintf(headerfile, "SET {\n");
 594         else
 595             fprintf(headerfile, "SEQUENCE {\n");
 596         ASN1_TAILQ_FOREACH(m, t->members, members) {
 597             if(strlen(m->name) > max_width)
 598                 max_width = strlen(m->name);
 599         }
 600         max_width += 3;
 601         if(max_width < 16) max_width = 16;
 602         ASN1_TAILQ_FOREACH(m, t->members, members) {
 603             int width = max_width;
 604             space(level + 1);
 605             if (m->ellipsis) {
 606                 fprintf (headerfile, "...");
 607             } else {
 608                 width -= fprintf(headerfile, "%s", m->name);
 609                 fprintf(headerfile, "%*s", width, "");
 610                 define_asn1(level + 1, m->type);
 611                 if(m->optional)
 612                     fprintf(headerfile, " OPTIONAL");
 613             }
 614             if(last_member_p(m))
 615                 fprintf (headerfile, ",");
 616             fprintf (headerfile, "\n");
 617         }
 618         space(level);
 619         fprintf (headerfile, "}");
 620         break;
 621     }
 622     case TSequenceOf:
 623         fprintf (headerfile, "SEQUENCE OF ");
 624         define_asn1 (0, t->subtype);
 625         break;
 626     case TSetOf:
 627         fprintf (headerfile, "SET OF ");
 628         define_asn1 (0, t->subtype);
 629         break;
 630     case TGeneralizedTime:
 631         fprintf (headerfile, "GeneralizedTime");
 632         break;
 633     case TGeneralString:
 634         fprintf (headerfile, "GeneralString");
 635         break;
 636     case TTeletexString:
 637         fprintf (headerfile, "TeletexString");
 638         break;
 639     case TTag: {
 640         const char *classnames[] = { "UNIVERSAL ", "APPLICATION ",
 641                                      "" /* CONTEXT */, "PRIVATE " };
 642         if(t->tag.tagclass != ASN1_C_UNIV)
 643             fprintf (headerfile, "[%s%d] ",
 644                      classnames[t->tag.tagclass],
 645                      t->tag.tagvalue);
 646         if(t->tag.tagenv == TE_IMPLICIT)
 647             fprintf (headerfile, "IMPLICIT ");
 648         define_asn1 (level, t->subtype);
 649         break;
 650     }
 651     case TUTCTime:
 652         fprintf (headerfile, "UTCTime");
 653         break;
 654     case TUTF8String:
 655         space(level);
 656         fprintf (headerfile, "UTF8String");
 657         break;
 658     case TPrintableString:
 659         space(level);
 660         fprintf (headerfile, "PrintableString");
 661         break;
 662     case TIA5String:
 663         space(level);
 664         fprintf (headerfile, "IA5String");
 665         break;
 666     case TBMPString:
 667         space(level);
 668         fprintf (headerfile, "BMPString");
 669         break;
 670     case TUniversalString:
 671         space(level);
 672         fprintf (headerfile, "UniversalString");
 673         break;
 674     case TVisibleString:
 675         space(level);
 676         fprintf (headerfile, "VisibleString");
 677         break;
 678     case TOID :
 679         space(level);
 680         fprintf(headerfile, "OBJECT IDENTIFIER");
 681         break;
 682     case TNull:
 683         space(level);
 684         fprintf (headerfile, "NULL");
 685         break;
 686     default:
 687         abort ();
 688     }
 689 }
 690
 691 static void
 692 getnewbasename(char **newbasename, int typedefp, const char *basename, const char *name)
 693 {
 694     if (typedefp)
 695         *newbasename = strdup(name);
 696     else {
 697         if (name[0] == '*')
 698             name++;
 699         if (asprintf(newbasename, "%s_%s", basename, name) < 0)
 700             errx(1, "malloc");
 701     }
 702     if (*newbasename == NULL)
 703         err(1, "malloc");
 704 }
 705
 706 static void
 707 define_type (int level, const char *name, const char *basename, Type *t, int typedefp, int preservep)
 708 {
 709     char *newbasename = NULL;
 710
 711     switch (t->type) {
 712     case TType:
 713         space(level);
 714         fprintf (headerfile, "%s %s;\n", t->symbol->gen_name, name);
 715         break;
 716     case TInteger:
 717         space(level);
 718         if(t->members) {
 719             Member *m;
 720             fprintf (headerfile, "enum %s {\n", typedefp ? name : "");
 721             ASN1_TAILQ_FOREACH(m, t->members, members) {
 722                 space (level + 1);
 723                 fprintf(headerfile, "%s = %d%s\n", m->gen_name, m->val,
 724                         last_member_p(m));
 725             }
 726             fprintf (headerfile, "} %s;\n", name);
 727         } else if (t->range == NULL) {
 728             fprintf (headerfile, "heim_integer %s;\n", name);
 729         } else if (t->range->min == INT_MIN && t->range->max == INT_MAX) {
 730             fprintf (headerfile, "int %s;\n", name);
 731         } else if (t->range->min == 0 && t->range->max == UINT_MAX) {
 732             fprintf (headerfile, "unsigned int %s;\n", name);
 733         } else if (t->range->min == 0 && t->range->max == INT_MAX) {
 734             fprintf (headerfile, "unsigned int %s;\n", name);
 735         } else
 736             errx(1, "%s: unsupported range %d -> %d",
 737                  name, t->range->min, t->range->max);
 738         break;
 739     case TBoolean:
 740         space(level);
 741         fprintf (headerfile, "int %s;\n", name);
 742         break;
 743     case TOctetString:
 744         space(level);
 745         fprintf (headerfile, "heim_octet_string %s;\n", name);
 746         break;
 747     case TBitString: {
 748         Member *m;
 749         Type i;
 750         struct range range = { 0, INT_MAX };
 751
 752         i.type = TInteger;
 753         i.range = &range;
 754         i.members = NULL;
 755         i.constraint = NULL;
 756
 757         space(level);
 758         if(ASN1_TAILQ_EMPTY(t->members))
 759             fprintf (headerfile, "heim_bit_string %s;\n", name);
 760         else {
 761             int pos = 0;
 762             getnewbasename(&newbasename, typedefp, basename, name);
 763
 764             fprintf (headerfile, "struct %s {\n", newbasename);
 765             ASN1_TAILQ_FOREACH(m, t->members, members) {
 766                 char *n = NULL;
 767
 768                 /* pad unused */
 769                 while (pos < m->val) {
 770                     if (asprintf (&n, "_unused%d:1", pos) < 0 || n == NULL)
 771                         errx(1, "malloc");
 772                     define_type (level + 1, n, newbasename, &i, FALSE, FALSE);
 773                     free(n);
 774                     pos++;
 775                 }
 776
 777                 n = NULL;
 778                 if (asprintf (&n, "%s:1", m->gen_name) < 0 || n == NULL)
 779                     errx(1, "malloc");
 780                 define_type (level + 1, n, newbasename, &i, FALSE, FALSE);
 781                 free (n);
 782                 n = NULL;
 783                 pos++;
 784             }
 785             /* pad to 32 elements */
 786             while (pos < 32) {
 787                 char *n = NULL;
 788                 if (asprintf (&n, "_unused%d:1", pos) < 0 || n == NULL)
 789                     errx(1, "malloc");
 790                 define_type (level + 1, n, newbasename, &i, FALSE, FALSE);
 791                 free(n);
 792                 pos++;
 793             }
 794
 795             space(level);
 796             fprintf (headerfile, "} %s;\n\n", name);
 797         }
 798         break;
 799     }
 800     case TEnumerated: {
 801         Member *m;
 802
 803         space(level);
 804         fprintf (headerfile, "enum %s {\n", typedefp ? name : "");
 805         ASN1_TAILQ_FOREACH(m, t->members, members) {
 806             space(level + 1);
 807             if (m->ellipsis)
 808                 fprintf (headerfile, "/* ... */\n");
 809             else
 810                 fprintf (headerfile, "%s = %d%s\n", m->gen_name, m->val,
 811                          last_member_p(m));
 812         }
 813         space(level);
 814         fprintf (headerfile, "} %s;\n\n", name);
 815         break;
 816     }
 817     case TSet:
 818     case TSequence: {
 819         Member *m;
 820
 821         getnewbasename(&newbasename, typedefp, basename, name);
 822
 823         space(level);
 824         fprintf (headerfile, "struct %s {\n", newbasename);
 825         if (t->type == TSequence && preservep) {
 826             space(level + 1);
 827             fprintf(headerfile, "heim_octet_string _save;\n");
 828         }
 829         ASN1_TAILQ_FOREACH(m, t->members, members) {
 830             if (m->ellipsis) {
 831                 ;
 832             } else if (m->optional) {
 833                 char *n = NULL;
 834
 835                 if (asprintf (&n, "*%s", m->gen_name) < 0 || n == NULL)
 836                     errx(1, "malloc");
 837                 define_type (level + 1, n, newbasename, m->type, FALSE, FALSE);
 838                 free (n);
 839             } else
 840                 define_type (level + 1, m->gen_name, newbasename, m->type, FALSE, FALSE);
 841         }
 842         space(level);
 843         fprintf (headerfile, "} %s;\n", name);
 844         break;
 845     }
 846     case TSetOf:
 847     case TSequenceOf: {
 848         Type i;
 849         struct range range = { 0, INT_MAX };
 850
 851         getnewbasename(&newbasename, typedefp, basename, name);
 852
 853         i.type = TInteger;
 854         i.range = &range;
 855         i.members = NULL;
 856         i.constraint = NULL;
 857
 858         space(level);
 859         fprintf (headerfile, "struct %s {\n", newbasename);
 860         define_type (level + 1, "len", newbasename, &i, FALSE, FALSE);
 861         define_type (level + 1, "*val", newbasename, t->subtype, FALSE, FALSE);
 862         space(level);
 863         fprintf (headerfile, "} %s;\n", name);
 864         break;
 865     }
 866     case TGeneralizedTime:
 867         space(level);
 868         fprintf (headerfile, "time_t %s;\n", name);
 869         break;
 870     case TGeneralString:
 871         space(level);
 872         fprintf (headerfile, "heim_general_string %s;\n", name);
 873         break;
 874     case TTeletexString:
 875         space(level);
 876         fprintf (headerfile, "heim_general_string %s;\n", name);
 877         break;
 878     case TTag:
 879         define_type (level, name, basename, t->subtype, typedefp, preservep);
 880         break;
 881     case TChoice: {
 882         int first = 1;
 883         Member *m;
 884
 885         getnewbasename(&newbasename, typedefp, basename, name);
 886
 887         space(level);
 888         fprintf (headerfile, "struct %s {\n", newbasename);
 889         if (preservep) {
 890             space(level + 1);
 891             fprintf(headerfile, "heim_octet_string _save;\n");
 892         }
 893         space(level + 1);
 894         fprintf (headerfile, "enum %s_enum {\n", newbasename);
 895         m = have_ellipsis(t);
 896         if (m) {
 897             space(level + 2);
 898             fprintf (headerfile, "%s = 0,\n", m->label);
 899             first = 0;
 900         }
 901         ASN1_TAILQ_FOREACH(m, t->members, members) {
 902             space(level + 2);
 903             if (m->ellipsis)
 904                 fprintf (headerfile, "/* ... */\n");
 905             else
 906                 fprintf (headerfile, "%s%s%s\n", m->label,
 907                          first ? " = 1" : "",
 908                          last_member_p(m));
 909             first = 0;
 910         }
 911         space(level + 1);
 912         fprintf (headerfile, "} element;\n");
 913         space(level + 1);
 914         fprintf (headerfile, "union {\n");
 915         ASN1_TAILQ_FOREACH(m, t->members, members) {
 916             if (m->ellipsis) {
 917                 space(level + 2);
 918                 fprintf(headerfile, "heim_octet_string asn1_ellipsis;\n");
 919             } else if (m->optional) {
 920                 char *n = NULL;
 921
 922                 if (asprintf (&n, "*%s", m->gen_name) < 0 || n == NULL)
 923                     errx(1, "malloc");
 924                 define_type (level + 2, n, newbasename, m->type, FALSE, FALSE);
 925                 free (n);
 926             } else
 927                 define_type (level + 2, m->gen_name, newbasename, m->type, FALSE, FALSE);
 928         }
 929         space(level + 1);
 930         fprintf (headerfile, "} u;\n");
 931         space(level);
 932         fprintf (headerfile, "} %s;\n", name);
 933         break;
 934     }
 935     case TUTCTime:
 936         space(level);
 937         fprintf (headerfile, "time_t %s;\n", name);
 938         break;
 939     case TUTF8String:
 940         space(level);
 941         fprintf (headerfile, "heim_utf8_string %s;\n", name);
 942         break;
 943     case TPrintableString:
 944         space(level);
 945         fprintf (headerfile, "heim_printable_string %s;\n", name);
 946         break;
 947     case TIA5String:
 948         space(level);
 949         fprintf (headerfile, "heim_ia5_string %s;\n", name);
 950         break;
 951     case TBMPString:
 952         space(level);
 953         fprintf (headerfile, "heim_bmp_string %s;\n", name);
 954         break;
 955     case TUniversalString:
 956         space(level);
 957         fprintf (headerfile, "heim_universal_string %s;\n", name);
 958         break;
 959     case TVisibleString:
 960         space(level);
 961         fprintf (headerfile, "heim_visible_string %s;\n", name);
 962         break;
 963     case TOID :
 964         space(level);
 965         fprintf (headerfile, "heim_oid %s;\n", name);
 966         break;
 967     case TNull:
 968         space(level);
 969         fprintf (headerfile, "int %s;\n", name);
 970         break;
 971     default:
 972         abort ();
 973     }
 974     if (newbasename)
 975         free(newbasename);
 976 }
 977
 978 static void
 979 generate_type_header (const Symbol *s)
 980 {
 981     int preservep = preserve_type(s->name) ? TRUE : FALSE;
 982
 983     fprintf (headerfile, "/*\n");
 984     fprintf (headerfile, "%s ::= ", s->name);
 985     define_asn1 (0, s->type);
 986     fprintf (headerfile, "\n*/\n\n");
 987
 988     fprintf (headerfile, "typedef ");
 989     define_type (0, s->gen_name, s->gen_name, s->type, TRUE, preservep);
 990
 991     fprintf (headerfile, "\n");
 992 }
 993
 994 void
 995 generate_type (const Symbol *s)
 996 {
 997     FILE *h;
 998     const char * exp;
 999
1000     if (!one_code_file)
1001         generate_header_of_codefile(s->gen_name);
1002
1003     generate_type_header (s);
1004
1005     if (template_flag)
1006         generate_template(s);
1007
1008     if (template_flag == 0 || is_template_compat(s) == 0) {
1009         generate_type_encode (s);
1010         generate_type_decode (s);
1011         generate_type_free (s);
1012         generate_type_length (s);
1013         generate_type_copy (s);
1014     }
1015     generate_type_seq (s);
1016     generate_glue (s->type, s->gen_name);
1017
1018     /* generate prototypes */
1019
1020     if (is_export(s->name)) {
1021         h = headerfile;
1022         exp = "ASN1EXP ";
1023     } else {
1024         h = privheaderfile;
1025         exp = "";
1026     }
1027
1028     fprintf (h,
1029              "%sint    ASN1CALL "
1030              "decode_%s(const unsigned char *, size_t, %s *, size_t *);\n",
1031              exp,
1032              s->gen_name, s->gen_name);
1033     fprintf (h,
1034              "%sint    ASN1CALL "
1035              "encode_%s(unsigned char *, size_t, const %s *, size_t *);\n",
1036              exp,
1037              s->gen_name, s->gen_name);
1038     fprintf (h,
1039              "%ssize_t ASN1CALL length_%s(const %s *);\n",
1040              exp,
1041              s->gen_name, s->gen_name);
1042     fprintf (h,
1043              "%sint    ASN1CALL copy_%s  (const %s *, %s *);\n",
1044              exp,
1045              s->gen_name, s->gen_name, s->gen_name);
1046     fprintf (h,
1047              "%svoid   ASN1CALL free_%s  (%s *);\n",
1048              exp,
1049              s->gen_name, s->gen_name);
1050
1051     fprintf(h, "\n\n");
1052
1053     if (!one_code_file) {
1054         fprintf(codefile, "\n\n");
1055         close_codefile();
1056         }
1057 }