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