lib/asn1/gen_decode.c

   1 /*
   2  * Copyright (c) 1997 - 2006 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include "gen_locl.h"
  35 #include "lex.h"
  36
  37 RCSID("$Id$");
  38
  39 static void
  40 decode_primitive (const char *typename, const char *name, const char *forwstr)
  41 {
  42 #if 0
  43     fprintf (codefile,
  44              "e = decode_%s(p, len, %s, &l);\n"
  45              "%s;\n",
  46              typename,
  47              name,
  48              forwstr);
  49 #else
  50     fprintf (codefile,
  51              "e = der_get_%s(p, len, %s, &l);\n"
  52              "if(e) %s;\np += l; len -= l; ret += l;\n",
  53              typename,
  54              name,
  55              forwstr);
  56 #endif
  57 }
  58
  59 static int
  60 is_primitive_type(int type)
  61 {
  62     switch(type) {
  63     case TInteger:
  64     case TBoolean:
  65     case TOctetString:
  66     case TBitString:
  67     case TEnumerated:
  68     case TGeneralizedTime:
  69     case TGeneralString:
  70     case TOID:
  71     case TUTCTime:
  72     case TUTF8String:
  73     case TPrintableString:
  74     case TIA5String:
  75     case TBMPString:
  76     case TUniversalString:
  77     case TVisibleString:
  78     case TNull:
  79         return 1;
  80     default:
  81         return 0;
  82     }
  83 }
  84
  85 static void
  86 find_tag (const Type *t,
  87           Der_class *cl, Der_type *ty, unsigned *tag)
  88 {
  89     switch (t->type) {
  90     case TBitString:
  91         *cl  = ASN1_C_UNIV;
  92         *ty  = PRIM;
  93         *tag = UT_BitString;
  94         break;
  95     case TBoolean:
  96         *cl  = ASN1_C_UNIV;
  97         *ty  = PRIM;
  98         *tag = UT_Boolean;
  99         break;
 100     case TChoice:
 101         errx(1, "Cannot have recursive CHOICE");
 102     case TEnumerated:
 103         *cl  = ASN1_C_UNIV;
 104         *ty  = PRIM;
 105         *tag = UT_Enumerated;
 106         break;
 107     case TGeneralString:
 108         *cl  = ASN1_C_UNIV;
 109         *ty  = PRIM;
 110         *tag = UT_GeneralString;
 111         break;
 112     case TGeneralizedTime:
 113         *cl  = ASN1_C_UNIV;
 114         *ty  = PRIM;
 115         *tag = UT_GeneralizedTime;
 116         break;
 117     case TIA5String:
 118         *cl  = ASN1_C_UNIV;
 119         *ty  = PRIM;
 120         *tag = UT_IA5String;
 121         break;
 122     case TInteger:
 123         *cl  = ASN1_C_UNIV;
 124         *ty  = PRIM;
 125         *tag = UT_Integer;
 126         break;
 127     case TNull:
 128         *cl  = ASN1_C_UNIV;
 129         *ty  = PRIM;
 130         *tag = UT_Null;
 131         break;
 132     case TOID:
 133         *cl  = ASN1_C_UNIV;
 134         *ty  = PRIM;
 135         *tag = UT_OID;
 136         break;
 137     case TOctetString:
 138         *cl  = ASN1_C_UNIV;
 139         *ty  = PRIM;
 140         *tag = UT_OctetString;
 141         break;
 142     case TPrintableString:
 143         *cl  = ASN1_C_UNIV;
 144         *ty  = PRIM;
 145         *tag = UT_PrintableString;
 146         break;
 147     case TSequence:
 148     case TSequenceOf:
 149         *cl  = ASN1_C_UNIV;
 150         *ty  = CONS;
 151         *tag = UT_Sequence;
 152         break;
 153     case TSet:
 154     case TSetOf:
 155         *cl  = ASN1_C_UNIV;
 156         *ty  = CONS;
 157         *tag = UT_Set;
 158         break;
 159     case TTag:
 160         *cl  = t->tag.tagclass;
 161         *ty  = is_primitive_type(t->subtype->type) ? PRIM : CONS;
 162         *tag = t->tag.tagvalue;
 163         break;
 164     case TType:
 165         if ((t->symbol->stype == Stype && t->symbol->type == NULL)
 166             || t->symbol->stype == SUndefined) {
 167             error_message("%s is imported or still undefined, "
 168                           " can't generate tag checking data in CHOICE "
 169                           "without this information",
 170                           t->symbol->name);
 171             exit(1);
 172         }
 173         find_tag(t->symbol->type, cl, ty, tag);
 174         return;
 175     case TUTCTime:
 176         *cl  = ASN1_C_UNIV;
 177         *ty  = PRIM;
 178         *tag = UT_UTCTime;
 179         break;
 180     case TUTF8String:
 181         *cl  = ASN1_C_UNIV;
 182         *ty  = PRIM;
 183         *tag = UT_UTF8String;
 184         break;
 185     case TBMPString:
 186         *cl  = ASN1_C_UNIV;
 187         *ty  = PRIM;
 188         *tag = UT_BMPString;
 189         break;
 190     case TUniversalString:
 191         *cl  = ASN1_C_UNIV;
 192         *ty  = PRIM;
 193         *tag = UT_UniversalString;
 194         break;
 195     case TVisibleString:
 196         *cl  = ASN1_C_UNIV;
 197         *ty  = PRIM;
 198         *tag = UT_VisibleString;
 199         break;
 200     default:
 201         abort();
 202     }
 203 }
 204
 205 static void
 206 range_check(const char *name,
 207             const char *length,
 208             const char *forwstr,
 209             struct range *r)
 210 {
 211     if (r->min == r->max + 2 || r->min < r->max)
 212         fprintf (codefile,
 213                  "if ((%s)->%s > %d) {\n"
 214                  "e = ASN1_MAX_CONSTRAINT; %s;\n"
 215                  "}\n",
 216                  name, length, r->max, forwstr);
 217     if (r->min - 1 == r->max || r->min < r->max)
 218         fprintf (codefile,
 219                  "if ((%s)->%s < %d) {\n"
 220                  "e = ASN1_MIN_CONSTRAINT; %s;\n"
 221                  "}\n",
 222                  name, length, r->min, forwstr);
 223     if (r->max == r->min)
 224         fprintf (codefile,
 225                  "if ((%s)->%s != %d) {\n"
 226                  "e = ASN1_EXACT_CONSTRAINT; %s;\n"
 227                  "}\n",
 228                  name, length, r->min, forwstr);
 229 }
 230
 231 static int
 232 decode_type (const char *name, const Type *t, int optional,
 233              const char *forwstr, const char *tmpstr, const char *dertype)
 234 {
 235     switch (t->type) {
 236     case TType: {
 237         if (optional)
 238             fprintf(codefile,
 239                     "%s = calloc(1, sizeof(*%s));\n"
 240                     "if (%s == NULL) %s;\n",
 241                     name, name, name, forwstr);
 242         fprintf (codefile,
 243                  "e = decode_%s(p, len, %s, &l);\n",
 244                  t->symbol->gen_name, name);
 245         if (optional) {
 246             fprintf (codefile,
 247                      "if(e) {\n"
 248                      "free(%s);\n"
 249                      "%s = NULL;\n"
 250                      "} else {\n"
 251                      "p += l; len -= l; ret += l;\n"
 252                      "}\n",
 253                      name, name);
 254         } else {
 255             fprintf (codefile,
 256                      "if(e) %s;\n",
 257                      forwstr);
 258             fprintf (codefile,
 259                      "p += l; len -= l; ret += l;\n");
 260         }
 261         break;
 262     }
 263     case TInteger:
 264         if(t->members) {
 265             fprintf(codefile,
 266                     "{\n"
 267                     "int enumint;\n");
 268             decode_primitive ("integer", "&enumint", forwstr);
 269             fprintf(codefile,
 270                     "*%s = enumint;\n"
 271                     "}\n",
 272                     name);
 273         } else if (t->range == NULL) {
 274             decode_primitive ("heim_integer", name, forwstr);
 275         } else if (t->range->min == INT_MIN && t->range->max == INT_MAX) {
 276             decode_primitive ("integer", name, forwstr);
 277         } else if (t->range->min == 0 && t->range->max == UINT_MAX) {
 278             decode_primitive ("unsigned", name, forwstr);
 279         } else if (t->range->min == 0 && t->range->max == INT_MAX) {
 280             decode_primitive ("unsigned", name, forwstr);
 281         } else
 282             errx(1, "%s: unsupported range %d -> %d",
 283                  name, t->range->min, t->range->max);
 284         break;
 285     case TBoolean:
 286       decode_primitive ("boolean", name, forwstr);
 287       break;
 288     case TEnumerated:
 289         decode_primitive ("enumerated", name, forwstr);
 290         break;
 291     case TOctetString:
 292         if (dertype) {
 293             fprintf(codefile,
 294                     "if (%s == CONS) {\n",
 295                     dertype);
 296             decode_primitive("octet_string_ber", name, forwstr);
 297             fprintf(codefile,
 298                     "} else {\n");
 299         }
 300         decode_primitive ("octet_string", name, forwstr);
 301         if (dertype)
 302             fprintf(codefile, "}\n");
 303         if (t->range)
 304             range_check(name, "length", forwstr, t->range);
 305         break;
 306     case TBitString: {
 307         Member *m;
 308         int pos = 0;
 309
 310         if (ASN1_TAILQ_EMPTY(t->members)) {
 311             decode_primitive ("bit_string", name, forwstr);
 312             break;
 313         }
 314         fprintf(codefile,
 315                 "if (len < 1) return ASN1_OVERRUN;\n"
 316                 "p++; len--; ret++;\n");
 317         fprintf(codefile,
 318                 "do {\n"
 319                 "if (len < 1) break;\n");
 320         ASN1_TAILQ_FOREACH(m, t->members, members) {
 321             while (m->val / 8 > pos / 8) {
 322                 fprintf (codefile,
 323                          "p++; len--; ret++;\n"
 324                          "if (len < 1) break;\n");
 325                 pos += 8;
 326             }
 327             fprintf (codefile,
 328                      "(%s)->%s = (*p >> %d) & 1;\n",
 329                      name, m->gen_name, 7 - m->val % 8);
 330         }
 331         fprintf(codefile,
 332                 "} while(0);\n");
 333         fprintf (codefile,
 334                  "p += len; ret += len;\n");
 335         break;
 336     }
 337     case TSequence: {
 338         Member *m;
 339
 340         if (t->members == NULL)
 341             break;
 342
 343         ASN1_TAILQ_FOREACH(m, t->members, members) {
 344             char *s;
 345
 346             if (m->ellipsis)
 347                 continue;
 348
 349             asprintf (&s, "%s(%s)->%s", m->optional ? "" : "&",
 350                       name, m->gen_name);
 351             if (s == NULL)
 352                 errx(1, "malloc");
 353             decode_type (s, m->type, m->optional, forwstr, m->gen_name, NULL);
 354             free (s);
 355         }
 356
 357         break;
 358     }
 359     case TSet: {
 360         Member *m;
 361         unsigned int memno;
 362
 363         if(t->members == NULL)
 364             break;
 365
 366         fprintf(codefile, "{\n");
 367         fprintf(codefile, "unsigned int members = 0;\n");
 368         fprintf(codefile, "while(len > 0) {\n");
 369         fprintf(codefile,
 370                 "Der_class class;\n"
 371                 "Der_type type;\n"
 372                 "int tag;\n"
 373                 "e = der_get_tag (p, len, &class, &type, &tag, NULL);\n"
 374                 "if(e) %s;\n", forwstr);
 375         fprintf(codefile, "switch (MAKE_TAG(class, type, tag)) {\n");
 376         memno = 0;
 377         ASN1_TAILQ_FOREACH(m, t->members, members) {
 378             char *s;
 379
 380             assert(m->type->type == TTag);
 381
 382             fprintf(codefile, "case MAKE_TAG(%s, %s, %s):\n",
 383                     classname(m->type->tag.tagclass),
 384                     is_primitive_type(m->type->subtype->type) ? "PRIM" : "CONS",
 385                     valuename(m->type->tag.tagclass, m->type->tag.tagvalue));
 386
 387             asprintf (&s, "%s(%s)->%s", m->optional ? "" : "&", name, m->gen_name);
 388             if (s == NULL)
 389                 errx(1, "malloc");
 390             if(m->optional)
 391                 fprintf(codefile,
 392                         "%s = calloc(1, sizeof(*%s));\n"
 393                         "if (%s == NULL) { e = ENOMEM; %s; }\n",
 394                         s, s, s, forwstr);
 395             decode_type (s, m->type, 0, forwstr, m->gen_name, NULL);
 396             free (s);
 397
 398             fprintf(codefile, "members |= (1 << %d);\n", memno);
 399             memno++;
 400             fprintf(codefile, "break;\n");
 401         }
 402         fprintf(codefile,
 403                 "default:\n"
 404                 "return ASN1_MISPLACED_FIELD;\n"
 405                 "break;\n");
 406         fprintf(codefile, "}\n");
 407         fprintf(codefile, "}\n");
 408         memno = 0;
 409         ASN1_TAILQ_FOREACH(m, t->members, members) {
 410             char *s;
 411
 412             asprintf (&s, "%s->%s", name, m->gen_name);
 413             if (s == NULL)
 414                 errx(1, "malloc");
 415             fprintf(codefile, "if((members & (1 << %d)) == 0)\n", memno);
 416             if(m->optional)
 417                 fprintf(codefile, "%s = NULL;\n", s);
 418             else if(m->defval)
 419                 gen_assign_defval(s, m->defval);
 420             else
 421                 fprintf(codefile, "return ASN1_MISSING_FIELD;\n");
 422             free(s);
 423             memno++;
 424         }
 425         fprintf(codefile, "}\n");
 426         break;
 427     }
 428     case TSetOf:
 429     case TSequenceOf: {
 430         char *n;
 431         char *sname;
 432
 433         fprintf (codefile,
 434                  "{\n"
 435                  "size_t %s_origlen = len;\n"
 436                  "size_t %s_oldret = ret;\n"
 437                  "size_t %s_olen = 0;\n"
 438                  "void *%s_tmp;\n"
 439                  "ret = 0;\n"
 440                  "(%s)->len = 0;\n"
 441                  "(%s)->val = NULL;\n",
 442                  tmpstr,
 443                  tmpstr,
 444                  tmpstr,
 445                  tmpstr,
 446                  name,
 447                  name);
 448
 449         fprintf (codefile,
 450                  "while(ret < %s_origlen) {\n"
 451                  "size_t %s_nlen = %s_olen + sizeof(*((%s)->val));\n"
 452                  "if (%s_olen > %s_nlen) { e = ASN1_OVERFLOW; %s; }\n"
 453                  "%s_olen = %s_nlen;\n"
 454                  "%s_tmp = realloc((%s)->val, %s_olen);\n"
 455                  "if (%s_tmp == NULL) { e = ENOMEM; %s; }\n"
 456                  "(%s)->val = %s_tmp;\n",
 457                  tmpstr,
 458                  tmpstr, tmpstr, name,
 459                  tmpstr, tmpstr, forwstr,
 460                  tmpstr, tmpstr,
 461                  tmpstr, name, tmpstr,
 462                  tmpstr, forwstr,
 463                  name, tmpstr);
 464
 465         asprintf (&n, "&(%s)->val[(%s)->len]", name, name);
 466         if (n == NULL)
 467             errx(1, "malloc");
 468         asprintf (&sname, "%s_s_of", tmpstr);
 469         if (sname == NULL)
 470             errx(1, "malloc");
 471         decode_type (n, t->subtype, 0, forwstr, sname, NULL);
 472         fprintf (codefile,
 473                  "(%s)->len++;\n"
 474                  "len = %s_origlen - ret;\n"
 475                  "}\n"
 476                  "ret += %s_oldret;\n"
 477                  "}\n",
 478                  name,
 479                  tmpstr, tmpstr);
 480         if (t->range)
 481             range_check(name, "len", forwstr, t->range);
 482         free (n);
 483         free (sname);
 484         break;
 485     }
 486     case TGeneralizedTime:
 487         decode_primitive ("generalized_time", name, forwstr);
 488         break;
 489     case TGeneralString:
 490         decode_primitive ("general_string", name, forwstr);
 491         break;
 492     case TTag:{
 493         char *tname, *typestring;
 494         char *ide = NULL;
 495
 496         asprintf(&typestring, "%s_type", tmpstr);
 497
 498         fprintf(codefile,
 499                 "{\n"
 500                 "size_t %s_datalen, %s_oldlen;\n"
 501                 "Der_type %s;\n",
 502                 tmpstr, tmpstr, typestring);
 503         if(support_ber)
 504             fprintf(codefile,
 505                     "int is_indefinite;\n");
 506
 507         fprintf(codefile, "e = der_match_tag_and_length(p, len, %s, &%s, %s, "
 508                 "&%s_datalen, &l);\n",
 509                 classname(t->tag.tagclass),
 510                 typestring,
 511                 valuename(t->tag.tagclass, t->tag.tagvalue),
 512                 tmpstr);
 513
 514         /* XXX hardcode for now */
 515         if (support_ber && t->subtype->type == TOctetString) {
 516             ide = typestring;
 517         } else {
 518             fprintf(codefile,
 519                     "if (e == 0 && %s != %s) { e = ASN1_BAD_ID; }\n",
 520                     typestring,
 521                     is_primitive_type(t->subtype->type) ? "PRIM" : "CONS");
 522         }
 523
 524         if(optional) {
 525             fprintf(codefile,
 526                     "if(e) {\n"
 527                     "%s = NULL;\n"
 528                     "} else {\n"
 529                      "%s = calloc(1, sizeof(*%s));\n"
 530                      "if (%s == NULL) { e = ENOMEM; %s; }\n",
 531                      name, name, name, name, forwstr);
 532         } else {
 533             fprintf(codefile, "if(e) %s;\n", forwstr);
 534         }
 535         fprintf (codefile,
 536                  "p += l; len -= l; ret += l;\n"
 537                  "%s_oldlen = len;\n",
 538                  tmpstr);
 539         if(support_ber)
 540             fprintf (codefile,
 541                      "if((is_indefinite = _heim_fix_dce(%s_datalen, &len)) < 0)\n"
 542                      "{ e = ASN1_BAD_FORMAT; %s; }\n"
 543                      "if (is_indefinite) { if (len < 2) { e = ASN1_OVERRUN; %s; } len -= 2; }",
 544                      tmpstr, forwstr, forwstr);
 545         else
 546             fprintf(codefile,
 547                     "if (%s_datalen > len) { e = ASN1_OVERRUN; %s; }\n"
 548                     "len = %s_datalen;\n", tmpstr, forwstr, tmpstr);
 549         asprintf (&tname, "%s_Tag", tmpstr);
 550         if (tname == NULL)
 551             errx(1, "malloc");
 552         decode_type (name, t->subtype, 0, forwstr, tname, ide);
 553         if(support_ber)
 554             fprintf(codefile,
 555                     "if(is_indefinite){\n"
 556                     "len += 2;\n"
 557                     "e = der_match_tag_and_length(p, len, "
 558                     "(Der_class)0, &%s, UT_EndOfContent, "
 559                     "&%s_datalen, &l);\n"
 560                     "if(e) %s;\n"
 561                     "p += l; len -= l; ret += l;\n"
 562                     "if (%s != (Der_type)0) { e = ASN1_BAD_ID; %s; }\n"
 563                     "} else \n",
 564                     typestring,
 565                     tmpstr,
 566                     forwstr,
 567                     typestring, forwstr);
 568         fprintf(codefile,
 569                 "len = %s_oldlen - %s_datalen;\n",
 570                 tmpstr, tmpstr);
 571         if(optional)
 572             fprintf(codefile,
 573                     "}\n");
 574         fprintf(codefile,
 575                 "}\n");
 576         free(tname);
 577         free(typestring);
 578         break;
 579     }
 580     case TChoice: {
 581         Member *m, *have_ellipsis = NULL;
 582         const char *els = "";
 583
 584         if (t->members == NULL)
 585             break;
 586
 587         ASN1_TAILQ_FOREACH(m, t->members, members) {
 588             const Type *tt = m->type;
 589             char *s;
 590             Der_class cl;
 591             Der_type  ty;
 592             unsigned  tag;
 593
 594             if (m->ellipsis) {
 595                 have_ellipsis = m;
 596                 continue;
 597             }
 598
 599             find_tag(tt, &cl, &ty, &tag);
 600
 601             fprintf(codefile,
 602                     "%sif (der_match_tag(p, len, %s, %s, %s, NULL) == 0) {\n",
 603                     els,
 604                     classname(cl),
 605                     ty ? "CONS" : "PRIM",
 606                     valuename(cl, tag));
 607             asprintf (&s, "%s(%s)->u.%s", m->optional ? "" : "&",
 608                       name, m->gen_name);
 609             if (s == NULL)
 610                 errx(1, "malloc");
 611             decode_type (s, m->type, m->optional, forwstr, m->gen_name, NULL);
 612             fprintf(codefile,
 613                     "(%s)->element = %s;\n",
 614                     name, m->label);
 615             free(s);
 616             fprintf(codefile,
 617                     "}\n");
 618             els = "else ";
 619         }
 620         if (have_ellipsis) {
 621             fprintf(codefile,
 622                     "else {\n"
 623                     "(%s)->u.%s.data = calloc(1, len);\n"
 624                     "if ((%s)->u.%s.data == NULL) {\n"
 625                     "e = ENOMEM; %s;\n"
 626                     "}\n"
 627                     "(%s)->u.%s.length = len;\n"
 628                     "memcpy((%s)->u.%s.data, p, len);\n"
 629                     "(%s)->element = %s;\n"
 630                     "p += len;\n"
 631                     "ret += len;\n"
 632                     "len -= len;\n"
 633                     "}\n",
 634                     name, have_ellipsis->gen_name,
 635                     name, have_ellipsis->gen_name,
 636                     forwstr,
 637                     name, have_ellipsis->gen_name,
 638                     name, have_ellipsis->gen_name,
 639                     name, have_ellipsis->label);
 640         } else {
 641             fprintf(codefile,
 642                     "else {\n"
 643                     "e = ASN1_PARSE_ERROR;\n"
 644                     "%s;\n"
 645                     "}\n",
 646                     forwstr);
 647         }
 648         break;
 649     }
 650     case TUTCTime:
 651         decode_primitive ("utctime", name, forwstr);
 652         break;
 653     case TUTF8String:
 654         decode_primitive ("utf8string", name, forwstr);
 655         break;
 656     case TPrintableString:
 657         decode_primitive ("printable_string", name, forwstr);
 658         break;
 659     case TIA5String:
 660         decode_primitive ("ia5_string", name, forwstr);
 661         break;
 662     case TBMPString:
 663         decode_primitive ("bmp_string", name, forwstr);
 664         break;
 665     case TUniversalString:
 666         decode_primitive ("universal_string", name, forwstr);
 667         break;
 668     case TVisibleString:
 669         decode_primitive ("visible_string", name, forwstr);
 670         break;
 671     case TNull:
 672         fprintf (codefile, "/* NULL */\n");
 673         break;
 674     case TOID:
 675         decode_primitive ("oid", name, forwstr);
 676         break;
 677     default :
 678         abort ();
 679     }
 680     return 0;
 681 }
 682
 683 void
 684 generate_type_decode (const Symbol *s)
 685 {
 686     int preserve = preserve_type(s->name) ? TRUE : FALSE;
 687
 688     fprintf (headerfile,
 689              "int    "
 690              "decode_%s(const unsigned char *, size_t, %s *, size_t *);\n",
 691              s->gen_name, s->gen_name);
 692
 693     fprintf (codefile, "int\n"
 694              "decode_%s(const unsigned char *p,"
 695              " size_t len, %s *data, size_t *size)\n"
 696              "{\n",
 697              s->gen_name, s->gen_name);
 698
 699     switch (s->type->type) {
 700     case TInteger:
 701     case TBoolean:
 702     case TOctetString:
 703     case TOID:
 704     case TGeneralizedTime:
 705     case TGeneralString:
 706     case TUTF8String:
 707     case TPrintableString:
 708     case TIA5String:
 709     case TBMPString:
 710     case TUniversalString:
 711     case TVisibleString:
 712     case TUTCTime:
 713     case TNull:
 714     case TEnumerated:
 715     case TBitString:
 716     case TSequence:
 717     case TSequenceOf:
 718     case TSet:
 719     case TSetOf:
 720     case TTag:
 721     case TType:
 722     case TChoice:
 723         fprintf (codefile,
 724                  "size_t ret = 0;\n"
 725                  "size_t l;\n"
 726                  "int e;\n");
 727         if (preserve)
 728             fprintf (codefile, "const unsigned char *begin = p;\n");
 729
 730         fprintf (codefile, "\n");
 731         fprintf (codefile, "memset(data, 0, sizeof(*data));\n"); /* hack to avoid `unused variable' */
 732
 733         decode_type ("data", s->type, 0, "goto fail", "Top", NULL);
 734         if (preserve)
 735             fprintf (codefile,
 736                      "data->_save.data = calloc(1, ret);\n"
 737                      "if (data->_save.data == NULL) { \n"
 738                      "e = ENOMEM; goto fail; \n"
 739                      "}\n"
 740                      "data->_save.length = ret;\n"
 741                      "memcpy(data->_save.data, begin, ret);\n");
 742         fprintf (codefile,
 743                  "if(size) *size = ret;\n"
 744                  "return 0;\n");
 745         fprintf (codefile,
 746                  "fail:\n"
 747                  "free_%s(data);\n"
 748                  "return e;\n",
 749                  s->gen_name);
 750         break;
 751     default:
 752         abort ();
 753     }
 754     fprintf (codefile, "}\n\n");
 755 }