s4:heimdal New files and supporting logic for heimdal update
[sfrench/samba-autobuild/.git] / source4 / heimdal / lib / asn1 / gen_template.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 static const char *symbol_name(const char *, const Type *);
39 static void generate_template_type(const char *, const char **, const char *, const char *, const char *,
40                                    Type *, int, int, int);
41
42 static const char *
43 ttype_symbol(const char *basename, const Type *t)
44 {
45     return t->symbol->gen_name;
46 }
47
48 static const char *
49 integer_symbol(const char *basename, const Type *t)
50 {
51     if (t->members)
52         return "int"; /* XXX enum foo */
53     else if (t->range == NULL)
54         return "heim_integer";
55     else if (t->range->min == INT_MIN && t->range->max == INT_MAX)
56         return "int";
57     else if (t->range->min == 0 && t->range->max == UINT_MAX)
58         return "unsigned";
59     else if (t->range->min == 0 && t->range->max == INT_MAX)
60         return "unsigned";
61     else
62         abort();
63 }
64
65 static const char *
66 boolean_symbol(const char *basename, const Type *t)
67 {
68     return "int";
69 }
70
71
72 static const char *
73 octetstring_symbol(const char *basename, const Type *t)
74 {
75     return "heim_octet_string";
76 }
77
78 static const char *
79 sequence_symbol(const char *basename, const Type *t)
80 {
81     return basename;
82 }
83
84 static const char *
85 time_symbol(const char *basename, const Type *t)
86 {
87     return "time_t";
88 }
89
90 static const char *
91 tag_symbol(const char *basename, const Type *t)
92 {
93     return symbol_name(basename, t->subtype);
94 }
95
96 static const char *
97 generalstring_symbol(const char *basename, const Type *t)
98 {
99     return "heim_general_string";
100 }
101
102 static const char *
103 printablestring_symbol(const char *basename, const Type *t)
104 {
105     return "heim_printable_string";
106 }
107
108 static const char *
109 ia5string_symbol(const char *basename, const Type *t)
110 {
111     return "heim_ia5_string";
112 }
113
114 static const char *
115 visiblestring_symbol(const char *basename, const Type *t)
116 {
117     return "heim_visible_string";
118 }
119
120 static const char *
121 utf8string_symbol(const char *basename, const Type *t)
122 {
123     return "heim_utf8_string";
124 }
125
126 static const char *
127 bmpstring_symbol(const char *basename, const Type *t)
128 {
129     return "heim_bmp_string";
130 }
131
132 static const char *
133 universalstring_symbol(const char *basename, const Type *t)
134 {
135     return "heim_universal_string";
136 }
137
138 static const char *
139 oid_symbol(const char *basename, const Type *t)
140 {
141     return "heim_oid";
142 }
143
144 static const char *
145 bitstring_symbol(const char *basename, const Type *t)
146 {
147     if (t->members)
148         return basename;
149     return "heim_bit_string";
150 }
151
152
153
154 struct {
155     enum typetype type;
156     const char *(*symbol_name)(const char *, const Type *);
157     int is_struct;
158 } types[] =  {
159     { TBMPString, bmpstring_symbol, 0 },
160     { TBitString, bitstring_symbol, 0 },
161     { TBoolean, boolean_symbol, 0 },
162     { TGeneralString, generalstring_symbol, 0 },
163     { TGeneralizedTime, time_symbol, 0 },
164     { TIA5String, ia5string_symbol, 0 },
165     { TInteger, integer_symbol, 0 },
166     { TOID, oid_symbol, 0 },
167     { TOctetString, octetstring_symbol, 0 },
168     { TPrintableString, printablestring_symbol, 0 },
169     { TSequence, sequence_symbol, 1 },
170     { TSequenceOf, tag_symbol, 1 },
171     { TSetOf, tag_symbol, 1 },
172     { TTag, tag_symbol, 1 },
173     { TType, ttype_symbol, 1 },
174     { TUTCTime, time_symbol, 0 },
175     { TUniversalString, universalstring_symbol, 0 },
176     { TVisibleString,  visiblestring_symbol, 0 },
177     { TUTF8String, utf8string_symbol, 0 },
178     { TChoice, sequence_symbol, 1 },
179     { TNull, integer_symbol, 1 }
180 };
181
182 static FILE *
183 get_code_file(void)
184 {
185     if (!one_code_file)
186         return templatefile;
187     return codefile;
188 }
189
190
191 static int
192 is_supported_type_p(const Type *t)
193 {
194     size_t i;
195
196     for (i = 0; i < sizeof(types)/sizeof(types[0]); i++)
197         if (t->type == types[i].type)
198             return 1;
199     return 0;
200 }
201
202 int
203 is_template_compat (const Symbol *s)
204 {
205     return is_supported_type_p(s->type);
206 }
207
208 static const char *
209 symbol_name(const char *basename, const Type *t)
210 {
211     size_t i;
212
213     for (i = 0; i < sizeof(types)/sizeof(types[0]); i++)
214         if (t->type == types[i].type)
215             return (types[i].symbol_name)(basename, t);
216     printf("unknown der type: %d\n", t->type);
217     exit(1);
218 }
219
220
221 static char *
222 partial_offset(const char *basetype, const char *name, int need_offset)
223 {
224     char *str;
225     if (name == NULL || need_offset == 0)
226         return strdup("0");
227     asprintf(&str, "offsetof(struct %s, %s)", basetype, name);
228     return str;
229 }
230
231 struct template {
232     char *line;
233     char *tt;
234     char *offset;
235     char *ptr;
236     ASN1_TAILQ_ENTRY(template) members;
237 };
238
239 ASN1_TAILQ_HEAD(templatehead, template);
240
241 struct tlist {
242     char *name;
243     char *header;
244     struct templatehead template;
245     ASN1_TAILQ_ENTRY(tlist) tmembers;
246 };
247
248 ASN1_TAILQ_HEAD(tlisthead, tlist);
249
250 static void tlist_header(struct tlist *, const char *, ...) __attribute__((__format__(__printf__, 2, 3)));
251 static struct template *
252     add_line(struct templatehead *, const char *, ...) __attribute__((__format__(__printf__, 2, 3)));
253 static int tlist_cmp(const struct tlist *, const struct tlist *);
254
255 static void add_line_pointer(struct templatehead *, const char *, const char *, const char *, ...)
256     __attribute__((__format__(__printf__, 4, 5)));
257
258
259 static struct tlisthead tlistmaster = ASN1_TAILQ_HEAD_INITIALIZER(tlistmaster);
260 static unsigned long numdups = 0;
261
262 static struct tlist *
263 tlist_new(const char *name)
264 {
265     struct tlist *tl = calloc(1, sizeof(*tl));
266     tl->name = strdup(name);
267     ASN1_TAILQ_INIT(&tl->template);
268     return tl;
269 }
270
271 static void
272 tlist_header(struct tlist *t, const char *fmt, ...)
273 {
274     va_list ap;
275     va_start(ap, fmt);
276     vasprintf(&t->header, fmt, ap);
277     va_end(ap);
278 }
279
280 static unsigned long
281 tlist_count(struct tlist *tl)
282 {
283     unsigned int count = 0;
284     struct template *q;
285
286     ASN1_TAILQ_FOREACH(q, &tl->template, members) {
287         count++;
288     }
289     return count;
290 }
291
292 static void
293 tlist_add(struct tlist *tl)
294 {
295     ASN1_TAILQ_INSERT_TAIL(&tlistmaster, tl, tmembers);
296 }
297
298 static void
299 tlist_print(struct tlist *tl)
300 {
301     struct template *q;
302     unsigned int i = 1;
303     FILE *f = get_code_file();
304
305     fprintf(f, "static const struct asn1_template asn1_%s[] = {\n", tl->name);
306     fprintf(f, "/* 0 */ %s,\n", tl->header);
307     ASN1_TAILQ_FOREACH(q, &tl->template, members) {
308         int last = (ASN1_TAILQ_LAST(&tl->template, templatehead) == q);
309         fprintf(f, "/* %lu */ %s%s\n", (unsigned long)i++, q->line, last ? "" : ",");
310     }
311     fprintf(f, "};\n");
312 }
313
314 static struct tlist *
315 tlist_find_by_name(const char *name)
316 {
317     struct tlist *ql;
318     ASN1_TAILQ_FOREACH(ql, &tlistmaster, tmembers) {
319         if (strcmp(ql->name, name) == 0)
320             return ql;
321     }
322     return NULL;
323 }
324
325 static int
326 tlist_cmp_name(const char *tname, const char *qname)
327 {
328     struct tlist *tl = tlist_find_by_name(tname);
329     struct tlist *ql = tlist_find_by_name(qname);
330     return tlist_cmp(tl, ql);
331 }
332
333 static int
334 tlist_cmp(const struct tlist *tl, const struct tlist *ql)
335 {
336     int ret;
337     struct template *t, *q;
338
339     ret = strcmp(tl->header, ql->header);
340     if (ret) return ret;
341         
342     q = ASN1_TAILQ_FIRST(&ql->template);
343     ASN1_TAILQ_FOREACH(t, &tl->template, members) {
344         if (q == NULL) return 1;
345
346         if (t->ptr == NULL || q->ptr == NULL) {
347             ret = strcmp(t->line, q->line);
348             if (ret) return ret;
349         } else {
350             ret = strcmp(t->tt, q->tt);
351             if (ret) return ret;
352             
353             ret = strcmp(t->offset, q->offset);
354             if (ret) return ret;
355
356             if ((ret = strcmp(t->ptr, q->ptr)) != 0 ||
357                 (ret = tlist_cmp_name(t->ptr, q->ptr)) != 0)
358                 return ret;
359         }
360         q = ASN1_TAILQ_NEXT(q, members);
361     }
362     if (q != NULL) return -1;
363     return 0;
364 }
365
366
367 static const char *
368 tlist_find_dup(const struct tlist *tl)
369 {
370     struct tlist *ql;
371
372     ASN1_TAILQ_FOREACH(ql, &tlistmaster, tmembers) {
373         if (tlist_cmp(ql, tl) == 0) {
374             numdups++;
375             return ql->name;
376         }
377     }
378     return NULL;
379 }
380
381
382 /*
383  *
384  */
385
386 static struct template *
387 add_line(struct templatehead *t, const char *fmt, ...)
388 {
389     struct template *q = calloc(1, sizeof(*q));
390     va_list ap;
391     va_start(ap, fmt);
392     vasprintf(&q->line, fmt, ap);
393     va_end(ap);
394     ASN1_TAILQ_INSERT_TAIL(t, q, members);
395     return q;
396 }
397
398 static void
399 add_line_pointer(struct templatehead *t,
400                  const char *ptr,
401                  const char *offset,
402                  const char *ttfmt,
403                  ...)
404 {
405     struct template *q;
406     va_list ap;
407     char *tt;
408
409     va_start(ap, ttfmt);
410     vasprintf(&tt, ttfmt, ap);
411     va_end(ap);
412
413     q = add_line(t, "{ %s, %s, asn1_%s }", tt, offset, ptr);
414     q->tt = tt;
415     q->offset = strdup(offset);
416     q->ptr = strdup(ptr);
417 }
418
419 static int
420 use_extern(const Symbol *s)
421 {
422     if (s->type == NULL)
423         return 1;
424     return 0;
425 }
426
427 static int
428 is_struct(Type *t, int isstruct)
429 {
430     size_t i;
431
432     if (t->type == TType)
433         return 0;
434     if (t->type == TSequence || t->type == TSet || t->type == TChoice)
435         return 1;
436     if (t->type == TTag)
437         return is_struct(t->subtype, isstruct);
438
439     for (i = 0; i < sizeof(types)/sizeof(types[0]); i++) {
440         if (t->type == types[i].type) {
441             if (types[i].is_struct == 0)
442                 return 0;
443             else
444                 break;
445         }
446     }
447
448     return isstruct;
449 }
450
451 static const Type *
452 compact_tag(const Type *t)
453 {
454     while (t->type == TTag)
455         t = t->subtype;
456     return t;
457 }
458
459 static void
460 template_members(struct templatehead *temp, const char *basetype, const char *name, const Type *t, int optional, int isstruct, int need_offset)
461 {
462     char *poffset = NULL;
463
464     if (optional && t->type != TTag && t->type != TType)
465         errx(1, "%s...%s is optional and not a (TTag or TType)", basetype, name);
466
467     poffset = partial_offset(basetype, name, need_offset);
468
469     switch (t->type) {
470     case TType:
471         if (use_extern(t->symbol)) {
472             add_line(temp, "{ A1_OP_TYPE_EXTERN %s, %s, &asn1_extern_%s}",
473                      optional ? "|A1_FLAG_OPTIONAL" : "",
474                      poffset, t->symbol->gen_name);
475         } else {
476             add_line_pointer(temp, t->symbol->gen_name, poffset, 
477                              "A1_OP_TYPE %s", optional ? "|A1_FLAG_OPTIONAL" : "");
478         }
479         break;
480     case TInteger: {
481         char *itype;
482
483         if (t->members)
484             itype = "IMEMBER";
485         else if (t->range == NULL)
486             itype = "HEIM_INTEGER";
487         else if (t->range->min == INT_MIN && t->range->max == INT_MAX)
488             itype = "INTEGER";
489         else if (t->range->min == 0 && t->range->max == UINT_MAX)
490             itype = "UNSIGNED";
491         else if (t->range->min == 0 && t->range->max == INT_MAX)
492             itype = "UNSIGNED";
493         else
494             errx(1, "%s: unsupported range %d -> %d",
495                  name, t->range->min, t->range->max);
496            
497         add_line(temp, "{ A1_PARSE_T(A1T_%s), %s, NULL }", itype, poffset);
498         break;
499     }
500     case TGeneralString:
501         add_line(temp, "{ A1_PARSE_T(A1T_GENERAL_STRING), %s, NULL }", poffset);
502         break;
503     case TTeletexString:
504         add_line(temp, "{ A1_PARSE_T(A1T_TELETEX_STRING), %s, NULL }", poffset);
505         break;
506     case TPrintableString:
507         add_line(temp, "{ A1_PARSE_T(A1T_PRINTABLE_STRING), %s, NULL }", poffset);
508         break;
509     case TOctetString:
510         add_line(temp, "{ A1_PARSE_T(A1T_OCTET_STRING), %s, NULL }", poffset);
511         break;
512     case TIA5String:
513         add_line(temp, "{ A1_PARSE_T(A1T_IA5_STRING), %s, NULL }", poffset);
514         break;
515     case TBMPString:
516         add_line(temp, "{ A1_PARSE_T(A1T_BMP_STRING), %s, NULL }", poffset);
517         break;
518     case TUniversalString:
519         add_line(temp, "{ A1_PARSE_T(A1T_UNIVERSAL_STRING), %s, NULL }", poffset);
520         break;
521     case TVisibleString:
522         add_line(temp, "{ A1_PARSE_T(A1T_VISIBLE_STRING), %s, NULL }", poffset);
523         break;
524     case TUTF8String:
525         add_line(temp, "{ A1_PARSE_T(A1T_UTF8_STRING), %s, NULL }", poffset);
526         break;
527     case TGeneralizedTime:
528         add_line(temp, "{ A1_PARSE_T(A1T_GENERALIZED_TIME), %s, NULL }", poffset);
529         break;
530     case TUTCTime:
531         add_line(temp, "{ A1_PARSE_T(A1T_UTC_TIME), %s, NULL }", poffset);
532         break;
533     case TBoolean:
534         add_line(temp, "{ A1_PARSE_T(A1T_BOOLEAN), %s, NULL }", poffset);
535         break;
536     case TOID:
537         add_line(temp, "{ A1_PARSE_T(A1T_OID), %s, NULL }", poffset);
538         break;
539     case TNull:
540         break;
541     case TBitString: {
542         struct templatehead template = ASN1_TAILQ_HEAD_INITIALIZER(template);
543         struct template *q;
544         Member *m;
545         size_t count = 0, i;
546         char *bname;
547         FILE *f = get_code_file();
548
549         if (ASN1_TAILQ_EMPTY(t->members)) {
550             add_line(temp, "{ A1_PARSE_T(A1T_HEIM_BIT_STRING), %s, NULL }", poffset);
551             break;
552         }
553
554         asprintf(&bname, "bmember_%s_%lu", name ? name : "", (unsigned long)t);
555         output_name(bname);
556
557         ASN1_TAILQ_FOREACH(m, t->members, members) {
558             add_line(&template, "{ 0, %d, 0 } /* %s */", m->val, m->gen_name);
559         }
560
561         ASN1_TAILQ_FOREACH(q, &template, members) {
562             count++;
563         }
564
565         fprintf(f, "static const struct asn1_template asn1_%s_%s[] = {\n", basetype, bname);
566         fprintf(f, "/* 0 */ { 0%s, sizeof(%s), ((void *)%lu) },\n",
567                 rfc1510_bitstring ? "|A1_HBF_RFC1510" : "",
568                 basetype, (unsigned long)count);
569         i = 1;
570         ASN1_TAILQ_FOREACH(q, &template, members) {
571             int last = (ASN1_TAILQ_LAST(&template, templatehead) == q);
572             fprintf(f, "/* %lu */ %s%s\n", (unsigned long)i++, q->line, last ? "" : ",");
573         }
574         fprintf(f, "};\n");
575
576         add_line(temp, "{ A1_OP_BMEMBER, %s, asn1_%s_%s }", poffset, basetype, bname);
577
578         free(bname);
579
580         break;
581     }
582     case TSequence: {
583         Member *m;
584
585         ASN1_TAILQ_FOREACH(m, t->members, members) {
586             char *newbasename;
587
588             if (m->ellipsis)
589                 continue;
590
591             if (name)
592                 asprintf(&newbasename, "%s_%s", basetype, name);
593             else
594                 newbasename = strdup(basetype);
595
596             template_members(temp, newbasename, m->gen_name, m->type, m->optional, isstruct, 1);
597
598             free(newbasename);
599         }
600
601         break;
602     }
603     case TTag: {
604         char *tname, *elname;
605         const char *sename, *dupname;
606         int subtype_is_struct = is_struct(t->subtype, isstruct);
607
608         if (subtype_is_struct)
609             sename = basetype;
610         else
611             sename = symbol_name(basetype, t->subtype);
612
613         asprintf(&tname, "tag_%s_%lu", name ? name : "", (unsigned long)t);
614         output_name(tname);
615
616         asprintf(&elname, "%s_%s", basetype, tname);
617
618         generate_template_type(elname, &dupname, NULL, sename, name,
619                                t->subtype, 0, subtype_is_struct, 0);
620
621         add_line_pointer(temp, dupname, poffset,
622                          "A1_TAG_T(%s,%s,%s)%s",
623                          classname(t->tag.tagclass),
624                          is_primitive_type(t->subtype->type)  ? "PRIM" : "CONS",
625                          valuename(t->tag.tagclass, t->tag.tagvalue),
626                          optional ? "|A1_FLAG_OPTIONAL" : "");
627
628         free(tname);
629         free(elname);
630
631         break;
632     }
633     case TSetOf:
634     case TSequenceOf: {
635         const char *type, *tname, *dupname;
636         char *sename, *elname;
637         int subtype_is_struct = is_struct(t->subtype, 0);
638
639         if (name && subtype_is_struct) {
640             tname = "seofTstruct";
641             asprintf(&sename, "%s_%s_val",
642                      basetype, name);
643         } else if (subtype_is_struct) {
644             tname = "seofTstruct";
645             asprintf(&sename, "%s_val", symbol_name(basetype, t->subtype));
646         } else {
647             if (name)
648                 tname = name;
649             else
650                 tname = "seofTstruct";
651             sename = strdup(symbol_name(basetype, t->subtype));
652         }
653
654         if (t->type == TSetOf) type = "A1_OP_SETOF";
655         else if (t->type == TSequenceOf) type = "A1_OP_SEQOF";
656         else abort();
657
658         asprintf(&elname, "%s_%s_%lu", basetype, tname, (unsigned long)t);
659
660         generate_template_type(elname, &dupname, NULL, sename, NULL, t->subtype,
661                                0, subtype_is_struct, need_offset);
662
663         add_line(temp, "{ %s, %s, asn1_%s }", type, poffset, dupname);
664         free(sename);
665         break;
666     }
667     case TChoice: {
668         struct templatehead template = ASN1_TAILQ_HEAD_INITIALIZER(template);
669         struct template *q;
670         size_t count = 0, i;
671         char *tname;
672         FILE *f = get_code_file();
673         Member *m;
674         int ellipsis = 0;
675         char *e;
676
677         asprintf(&tname, "asn1_choice_%s_%s%x",
678                  basetype, name ? name : "", (unsigned int)(uintptr_t)t);
679
680         ASN1_TAILQ_FOREACH(m, t->members, members) {
681             const char *dupname;
682             char *elname;
683             char *newbasename;
684             int subtype_is_struct;
685
686             if (m->ellipsis) {
687                 ellipsis = 1;
688                 continue;
689             }
690
691             subtype_is_struct = is_struct(m->type, 0);
692
693             asprintf(&elname, "%s_choice_%s", basetype, m->gen_name);
694
695             if (subtype_is_struct)
696                 asprintf(&newbasename, "%s_%s", basetype, m->gen_name);
697             else
698                 newbasename = strdup(basetype);
699
700             generate_template_type(elname, &dupname, NULL,
701                                    symbol_name(newbasename, m->type),
702                                    NULL, m->type, 0, subtype_is_struct, 1);
703
704             add_line(&template, "{ %s, offsetof(%s%s, u.%s), asn1_%s }",
705                      m->label, isstruct ? "struct " : "",
706                      basetype, m->gen_name,
707                      dupname);
708
709             free(elname);
710             free(newbasename);
711         }
712
713         if (ellipsis) {
714             asprintf(&e, "offsetof(%s%s, u.asn1_ellipsis)", isstruct ? "struct " : "", basetype);
715         } else
716             e = NULL;
717
718         ASN1_TAILQ_FOREACH(q, &template, members) {
719             count++;
720         }
721
722         fprintf(f, "static const struct asn1_template %s[] = {\n", tname);
723         fprintf(f, "/* 0 */ { %s, offsetof(%s%s, element), ((void *)%lu) },\n",
724                 e ? e : "0", isstruct ? "struct " : "", basetype, (unsigned long)count);
725         i = 1;
726         ASN1_TAILQ_FOREACH(q, &template, members) {
727             int last = (ASN1_TAILQ_LAST(&template, templatehead) == q);
728             fprintf(f, "/* %lu */ %s%s\n", (unsigned long)i++, q->line, last ? "" : ",");
729         }
730         fprintf(f, "};\n");
731
732         add_line(temp, "{ A1_OP_CHOICE, %s, %s }", poffset, tname);
733
734         free(e);
735         free(tname);
736         break;
737     }
738     default:
739         abort ();
740     }
741     if (poffset)
742         free(poffset);
743 }
744
745 static void
746 gen_extern_stubs(FILE *f, const char *name)
747 {
748     fprintf(f,
749             "static const struct asn1_type_func asn1_extern_%s = {\n"
750             "\t(asn1_type_encode)encode_%s,\n"
751             "\t(asn1_type_decode)decode_%s,\n"
752             "\t(asn1_type_length)length_%s,\n"
753             "\t(asn1_type_copy)copy_%s,\n"
754             "\t(asn1_type_release)free_%s,\n"
755             "\tsizeof(%s)\n"
756             "};\n",
757             name, name, name, name,
758             name, name, name);
759 }
760
761 void
762 gen_template_import(const Symbol *s)
763 {
764     FILE *f = get_code_file();
765
766     if (template_flag == 0)
767         return;
768
769     gen_extern_stubs(f, s->gen_name);
770 }
771
772 static void
773 generate_template_type(const char *varname,
774                        const char **dupname,
775                        const char *symname,
776                        const char *basetype,
777                        const char *name,
778                        Type *type,
779                        int optional, int isstruct, int need_offset)
780 {
781     struct tlist *tl;
782     const char *dup;
783     int have_ellipsis = 0;
784
785     tl = tlist_new(varname);
786
787     template_members(&tl->template, basetype, name, type, optional, isstruct, need_offset);
788
789     /* if its a sequence or set type, check if there is a ellipsis */
790     if (type->type == TSequence || type->type == TSet) {
791         Member *m;
792         ASN1_TAILQ_FOREACH(m, type->members, members) {
793             if (m->ellipsis)
794                 have_ellipsis = 1;
795         }
796     }
797
798     if (ASN1_TAILQ_EMPTY(&tl->template) && compact_tag(type)->type != TNull)
799         errx(1, "Tag %s...%s with no content ?", basetype, name ? name : "");
800
801     tlist_header(tl, "{ 0%s%s, sizeof(%s%s), ((void *)%lu) }",
802                  (symname && preserve_type(symname)) ? "|A1_HF_PRESERVE" : "",
803                  have_ellipsis ? "|A1_HF_ELLIPSIS" : "",
804                  isstruct ? "struct " : "", basetype, tlist_count(tl));
805
806     dup = tlist_find_dup(tl);
807     if (dup) {
808         if (strcmp(dup, tl->name) == 0)
809             errx(1, "found dup of ourself");
810         *dupname = dup;
811     } else {
812         *dupname = tl->name;
813         tlist_print(tl);
814         tlist_add(tl);
815     }
816 }
817
818
819 void
820 generate_template(const Symbol *s)
821 {
822     FILE *f = get_code_file();
823     const char *dupname;
824
825     if (use_extern(s)) {
826         gen_extern_stubs(f, s->gen_name);
827         return;
828     }
829
830     generate_template_type(s->gen_name, &dupname, s->name, s->gen_name, NULL, s->type, 0, 0, 1);
831
832     fprintf(f,
833             "\n"
834             "int\n"
835             "decode_%s(const unsigned char *p, size_t len, %s *data, size_t *size)\n"
836             "{\n"
837             "    return _asn1_decode_top(asn1_%s, 0|%s, p, len, data, size);\n"
838             "}\n"
839             "\n",
840             s->gen_name,
841             s->gen_name,
842             dupname,
843             support_ber ? "A1_PF_ALLOW_BER" : "0");
844
845     fprintf(f,
846             "\n"
847             "int\n"
848             "encode_%s(unsigned char *p, size_t len, const %s *data, size_t *size)\n"
849             "{\n"
850             "    return _asn1_encode(asn1_%s, p, len, data, size);\n"
851             "}\n"
852             "\n",
853             s->gen_name,
854             s->gen_name,
855             dupname);
856
857     fprintf(f,
858             "\n"
859             "size_t\n"
860             "length_%s(const %s *data)\n"
861             "{\n"
862             "    return _asn1_length(asn1_%s, data);\n"
863             "}\n"
864             "\n",
865             s->gen_name,
866             s->gen_name,
867             dupname);
868
869
870     fprintf(f,
871             "\n"
872             "void\n"
873             "free_%s(%s *data)\n"
874             "{\n"
875             "    _asn1_free(asn1_%s, data);\n"
876             "}\n"
877             "\n",
878             s->gen_name,
879             s->gen_name,
880             dupname);
881
882     fprintf(f,
883             "\n"
884             "int\n"
885             "copy_%s(const %s *from, %s *to)\n"
886             "{\n"
887             "    return _asn1_copy_top(asn1_%s, from, to);\n"
888             "}\n"
889             "\n",
890             s->gen_name,
891             s->gen_name,
892             s->gen_name,
893             dupname);
894 }