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