Debian Codegraph @

lib/asn1/gen.c

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