← Back to branch summary

~ubuntu-branches/ubuntu/vivid/samba/vivid

« back to all changes in this revision

Viewing changes to source4/heimdal/lib/asn1/gen.c

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2011-12-21 13:18:04 UTC
  • mfrom: (0.39.21 sid)
  • Revision ID: package-import@ubuntu.com-20111221131804-xtlr39wx6njehxxr
Tags: 2:3.6.1-3ubuntu1
* Merge from Debian testing.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/patches/error-trans.fix-276472:
    - Add the translation of Unix Error code -ENOTSUP to NT Error Code
    - NT_STATUS_NOT_SUPPORTED to prevent the Permission denied error.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access.
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/control:
    - Don't build against or suggest ctdb.
    - Add dependency on samba-common-bin to samba.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
  + Add apport hook:
    - Created debian/source_samba.py.
    - debian/rules, debian/samba.dirs, debian/samba-common-bin.files: install
  + Switch to upstart:
    - Add debian/samba.{nmbd,smbd}.upstart.
  + debian/samba.logrotate, debian/samba-common.dhcp, debian/samba.if-up:
    - Make them upstart compatible
  + debian/samba.postinst: 
    - Avoid scary pdbedit warnings on first import.
  + debian/samba-common.postinst: Add more informative error message for
    the case where smb.conf was manually deleted
  + debian/patches/fix-debuglevel-name-conflict.patch: don't use 'debug_level'
    as a global variable name in an NSS module 
  + Dropped:
    - debian/patches/error-trans.fix-276472
    - debian/patches/fix-debuglevel-name-conflict.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
source4/heimdal/lib/asn1/gen.c
3
3
 * (Royal Institute of Technology, Stockholm, Sweden).
4
4
 * All rights reserved.
5
5
 *
 
6
 * Portions Copyright (c) 2009 Apple Inc. All rights reserved.
 
7
 *
6
8
 * Redistribution and use in source and binary forms, with or without
7
9
 * modification, are permitted provided that the following conditions
8
10
 * are met:
35
37
 
36
38
RCSID("$Id$");
37
39
 
38
 
FILE *headerfile, *codefile, *logfile;
 
40
FILE *privheaderfile, *headerfile, *codefile, *logfile, *templatefile;
39
41
 
40
42
#define STEM "asn1"
41
43
 
42
44
static const char *orig_filename;
43
 
static char *header;
 
45
static char *privheader, *header, *template;
44
46
static const char *headerbase = STEM;
45
47
 
46
48
/*
66
68
    fprintf (headerfile, "#include <%s_asn1.h>\n", module);
67
69
}
68
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
 
69
110
const char *
70
111
get_filename (void)
71
112
{
75
116
void
76
117
init_generate (const char *filename, const char *base)
77
118
{
78
 
    char *fn;
 
119
    char *fn = NULL;
79
120
 
80
121
    orig_filename = filename;
81
122
    if (base != NULL) {
85
126
    }
86
127
 
87
128
    /* public header file */
88
 
    asprintf(&header, "%s.h", headerbase);
89
 
    if (header == NULL)
 
129
    if (asprintf(&header, "%s.h", headerbase) < 0 || header == NULL)
90
130
        errx(1, "malloc");
91
 
    asprintf(&fn, "%s.hx", headerbase);
92
 
    if (fn == NULL)
 
131
    if (asprintf(&fn, "%s.hx", headerbase) < 0 || fn == NULL)
93
132
        errx(1, "malloc");
94
133
    headerfile = fopen (fn, "w");
95
134
    if (headerfile == NULL)
96
135
        err (1, "open %s", fn);
97
136
    free(fn);
98
 
 
 
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");
99
153
    fprintf (headerfile,
100
154
             "/* Generated from %s */\n"
101
155
             "/* Do not edit */\n\n",
127
181
             "typedef char *heim_utf8_string;\n\n"
128
182
             );
129
183
    fprintf (headerfile,
130
 
             "typedef char *heim_printable_string;\n\n"
 
184
             "typedef struct heim_octet_string heim_printable_string;\n\n"
131
185
             );
132
186
    fprintf (headerfile,
133
 
             "typedef char *heim_ia5_string;\n\n"
 
187
             "typedef struct heim_octet_string heim_ia5_string;\n\n"
134
188
             );
135
189
    fprintf (headerfile,
136
190
             "typedef struct heim_bmp_string {\n"
174
228
          "    }                                                          \\\n"
175
229
          "  } while (0)\n\n",
176
230
          headerfile);
 
231
    fputs("#ifdef _WIN32\n"
 
232
          "#ifndef ASN1_LIB\n"
 
233
          "#define ASN1EXP  __declspec(dllimport)\n"
 
234
          "#else\n"
 
235
          "#define ASN1EXP\n"
 
236
          "#endif\n"
 
237
          "#define ASN1CALL __stdcall\n"
 
238
          "#else\n"
 
239
          "#define ASN1EXP\n"
 
240
          "#define ASN1CALL\n"
 
241
          "#endif\n",
 
242
          headerfile);
177
243
    fprintf (headerfile, "struct units;\n\n");
178
244
    fprintf (headerfile, "#endif\n\n");
179
 
    asprintf(&fn, "%s_files", base);
180
 
    if (fn == NULL)
 
245
    if (asprintf(&fn, "%s_files", base) < 0 || fn == NULL)
181
246
        errx(1, "malloc");
182
247
    logfile = fopen(fn, "w");
183
248
    if (logfile == NULL)
184
249
        err (1, "open %s", fn);
 
250
 
 
251
    /* if one code file, write into the one codefile */
 
252
    if (one_code_file)
 
253
        return;
 
254
 
 
255
    templatefile = fopen (template, "w");
 
256
    if (templatefile == NULL)
 
257
        err (1, "open %s", template);
 
258
 
 
259
    fprintf (templatefile,
 
260
             "/* Generated from %s */\n"
 
261
             "/* Do not edit */\n\n"
 
262
             "#include <stdio.h>\n"
 
263
             "#include <stdlib.h>\n"
 
264
             "#include <time.h>\n"
 
265
             "#include <string.h>\n"
 
266
             "#include <errno.h>\n"
 
267
             "#include <limits.h>\n"
 
268
             "#include <krb5-types.h>\n",
 
269
             filename);
 
270
 
 
271
    fprintf (templatefile,
 
272
             "#include <%s>\n"
 
273
             "#include <%s>\n"
 
274
             "#include <der.h>\n"
 
275
             "#include <der-private.h>\n"
 
276
             "#include <asn1-template.h>\n",
 
277
             header, privheader);
 
278
 
 
279
 
185
280
}
186
281
 
187
282
void
189
284
{
190
285
    fprintf (headerfile, "#endif /* __%s_h__ */\n", headerbase);
191
286
 
192
 
    fclose (headerfile);
193
 
    fprintf (logfile, "\n");
194
 
    fclose (logfile);
 
287
    if (headerfile)
 
288
        fclose (headerfile);
 
289
    if (privheaderfile)
 
290
        fclose (privheaderfile);
 
291
    if (templatefile)
 
292
        fclose (templatefile);
 
293
    if (logfile)
 
294
        fprintf (logfile, "\n");
 
295
        fclose (logfile);
195
296
}
196
297
 
197
298
void
239
340
void
240
341
generate_header_of_codefile(const char *name)
241
342
{
242
 
    char *filename;
 
343
    char *filename = NULL;
243
344
 
244
345
    if (codefile != NULL)
245
346
        abort();
246
347
 
247
 
    asprintf (&filename, "%s_%s.x", STEM, name);
248
 
    if (filename == NULL)
 
348
    if (asprintf (&filename, "%s_%s.x", STEM, name) < 0 || filename == NULL)
249
349
        errx(1, "malloc");
250
350
    codefile = fopen (filename, "w");
251
351
    if (codefile == NULL)
252
352
        err (1, "fopen %s", filename);
253
353
    fprintf(logfile, "%s ", filename);
254
354
    free(filename);
 
355
    filename = NULL;
255
356
    fprintf (codefile,
256
357
             "/* Generated from %s */\n"
257
358
             "/* Do not edit */\n\n"
 
359
             "#define  ASN1_LIB\n\n"
258
360
             "#include <stdio.h>\n"
259
361
             "#include <stdlib.h>\n"
260
362
             "#include <time.h>\n"
265
367
             orig_filename);
266
368
 
267
369
    fprintf (codefile,
268
 
             "#include <%s.h>\n",
269
 
             headerbase);
 
370
             "#include <%s>\n"
 
371
             "#include <%s>\n",
 
372
             header, privheader);
270
373
    fprintf (codefile,
271
374
             "#include <asn1_err.h>\n"
272
375
             "#include <der.h>\n"
 
376
             "#include <der-private.h>\n"
 
377
             "#include <asn1-template.h>\n"
273
378
             "#include <parse_units.h>\n\n");
274
379
 
275
380
}
302
407
    case objectidentifiervalue: {
303
408
        struct objid *o, **list;
304
409
        unsigned int i, len;
 
410
        char *gen_upper;
305
411
 
306
412
        if (!one_code_file)
307
413
            generate_header_of_codefile(s->gen_name);
327
433
                    o->label ? o->label : "label-less", o->value);
328
434
        }
329
435
 
330
 
        fprintf (headerfile, "} */\n");
331
 
        fprintf (headerfile, "const heim_oid *oid_%s(void);\n",
332
 
                 s->gen_name);
333
 
        fprintf (headerfile,
334
 
                 "extern const heim_oid asn1_oid_%s;\n\n",
335
 
                 s->gen_name);
336
 
 
337
 
 
338
436
        fprintf (codefile, "static unsigned oid_%s_variable_num[%d] =  {",
339
437
                 s->gen_name, len);
340
438
        for (i = len ; i > 0; i--) {
346
444
                 "{ %d, oid_%s_variable_num };\n\n",
347
445
                 s->gen_name, len, s->gen_name);
348
446
 
349
 
        fprintf (codefile, "const heim_oid *oid_%s(void)\n"
350
 
                 "{\n"
351
 
                 "return &asn1_oid_%s;\n"
352
 
                 "}\n\n",
353
 
                 s->gen_name, s->gen_name);
354
 
 
355
447
        free(list);
356
448
 
 
449
        /* header file */
 
450
 
 
451
        gen_upper = strdup(s->gen_name);
 
452
        len = strlen(gen_upper);
 
453
        for (i = 0; i < len; i++)
 
454
            gen_upper[i] = toupper((int)s->gen_name[i]);
 
455
 
 
456
        fprintf (headerfile, "} */\n");
 
457
        fprintf (headerfile,
 
458
                 "extern ASN1EXP const heim_oid asn1_oid_%s;\n"
 
459
                 "#define ASN1_OID_%s (&asn1_oid_%s)\n\n",
 
460
                 s->gen_name,
 
461
                 gen_upper,
 
462
                 s->gen_name);
 
463
 
 
464
        free(gen_upper);
 
465
 
357
466
        if (!one_code_file)
358
467
            close_codefile();
359
468
 
364
473
    }
365
474
}
366
475
 
 
476
int
 
477
is_primitive_type(int type)
 
478
{
 
479
    switch(type) {
 
480
    case TInteger:
 
481
    case TBoolean:
 
482
    case TOctetString:
 
483
    case TBitString:
 
484
    case TEnumerated:
 
485
    case TGeneralizedTime:
 
486
    case TGeneralString:
 
487
    case TTeletexString:
 
488
    case TOID:
 
489
    case TUTCTime:
 
490
    case TUTF8String:
 
491
    case TPrintableString:
 
492
    case TIA5String:
 
493
    case TBMPString:
 
494
    case TUniversalString:
 
495
    case TVisibleString:
 
496
    case TNull:
 
497
        return 1;
 
498
    default:
 
499
        return 0;
 
500
    }
 
501
}
 
502
 
367
503
static void
368
504
space(int level)
369
505
{
494
630
    case TGeneralString:
495
631
        fprintf (headerfile, "GeneralString");
496
632
        break;
 
633
    case TTeletexString:
 
634
        fprintf (headerfile, "TeletexString");
 
635
        break;
497
636
    case TTag: {
498
637
        const char *classnames[] = { "UNIVERSAL ", "APPLICATION ",
499
638
                                     "" /* CONTEXT */, "PRIVATE " };
547
686
}
548
687
 
549
688
static void
550
 
define_type (int level, const char *name, Type *t, int typedefp, int preservep)
551
 
{
 
689
getnewbasename(char **newbasename, int typedefp, const char *basename, const char *name)
 
690
{
 
691
    if (typedefp)
 
692
        *newbasename = strdup(name);
 
693
    else {
 
694
        if (name[0] == '*')
 
695
            name++;
 
696
        if (asprintf(newbasename, "%s_%s", basename, name) < 0)
 
697
            errx(1, "malloc");
 
698
    }
 
699
    if (*newbasename == NULL)
 
700
        err(1, "malloc");
 
701
}
 
702
 
 
703
static void
 
704
define_type (int level, const char *name, const char *basename, Type *t, int typedefp, int preservep)
 
705
{
 
706
    char *newbasename = NULL;
 
707
 
552
708
    switch (t->type) {
553
709
    case TType:
554
710
        space(level);
599
755
        if(ASN1_TAILQ_EMPTY(t->members))
600
756
            fprintf (headerfile, "heim_bit_string %s;\n", name);
601
757
        else {
602
 
            fprintf (headerfile, "struct %s {\n", typedefp ? name : "");
 
758
            int pos = 0;
 
759
            getnewbasename(&newbasename, typedefp, basename, name);
 
760
 
 
761
            fprintf (headerfile, "struct %s {\n", newbasename);
603
762
            ASN1_TAILQ_FOREACH(m, t->members, members) {
604
 
                char *n;
 
763
                char *n = NULL;
605
764
        
606
 
                asprintf (&n, "%s:1", m->gen_name);
607
 
                if (n == NULL)
 
765
                /* pad unused */
 
766
                while (pos < m->val) {
 
767
                    if (asprintf (&n, "_unused%d:1", pos) < 0 || n == NULL)
 
768
                        errx(1, "malloc");
 
769
                    define_type (level + 1, n, newbasename, &i, FALSE, FALSE);
 
770
                    free(n);
 
771
                    pos++;
 
772
                }
 
773
 
 
774
                n = NULL;
 
775
                if (asprintf (&n, "%s:1", m->gen_name) < 0 || n == NULL)
608
776
                    errx(1, "malloc");
609
 
                define_type (level + 1, n, &i, FALSE, FALSE);
 
777
                define_type (level + 1, n, newbasename, &i, FALSE, FALSE);
610
778
                free (n);
611
 
            }
 
779
                n = NULL;
 
780
                pos++;
 
781
            }
 
782
            /* pad to 32 elements */
 
783
            while (pos < 32) {
 
784
                char *n = NULL;
 
785
                if (asprintf (&n, "_unused%d:1", pos) < 0 || n == NULL)
 
786
                    errx(1, "malloc");
 
787
                define_type (level + 1, n, newbasename, &i, FALSE, FALSE);
 
788
                free(n);
 
789
                pos++;
 
790
            }
 
791
 
612
792
            space(level);
613
793
            fprintf (headerfile, "} %s;\n\n", name);
614
794
        }
635
815
    case TSequence: {
636
816
        Member *m;
637
817
 
 
818
        getnewbasename(&newbasename, typedefp, basename, name);
 
819
 
638
820
        space(level);
639
 
        fprintf (headerfile, "struct %s {\n", typedefp ? name : "");
 
821
        fprintf (headerfile, "struct %s {\n", newbasename);
640
822
        if (t->type == TSequence && preservep) {
641
823
            space(level + 1);
642
824
            fprintf(headerfile, "heim_octet_string _save;\n");
645
827
            if (m->ellipsis) {
646
828
                ;
647
829
            } else if (m->optional) {
648
 
                char *n;
 
830
                char *n = NULL;
649
831
 
650
 
                asprintf (&n, "*%s", m->gen_name);
651
 
                if (n == NULL)
 
832
                if (asprintf (&n, "*%s", m->gen_name) < 0 || n == NULL)
652
833
                    errx(1, "malloc");
653
 
                define_type (level + 1, n, m->type, FALSE, FALSE);
 
834
                define_type (level + 1, n, newbasename, m->type, FALSE, FALSE);
654
835
                free (n);
655
836
            } else
656
 
                define_type (level + 1, m->gen_name, m->type, FALSE, FALSE);
 
837
                define_type (level + 1, m->gen_name, newbasename, m->type, FALSE, FALSE);
657
838
        }
658
839
        space(level);
659
840
        fprintf (headerfile, "} %s;\n", name);
664
845
        Type i;
665
846
        struct range range = { 0, INT_MAX };
666
847
 
 
848
        getnewbasename(&newbasename, typedefp, basename, name);
 
849
 
667
850
        i.type = TInteger;
668
851
        i.range = &range;
669
852
        i.members = NULL;
670
853
        i.constraint = NULL;
671
854
 
672
855
        space(level);
673
 
        fprintf (headerfile, "struct %s {\n", typedefp ? name : "");
674
 
        define_type (level + 1, "len", &i, FALSE, FALSE);
675
 
        define_type (level + 1, "*val", t->subtype, FALSE, FALSE);
 
856
        fprintf (headerfile, "struct %s {\n", newbasename);
 
857
        define_type (level + 1, "len", newbasename, &i, FALSE, FALSE);
 
858
        define_type (level + 1, "*val", newbasename, t->subtype, FALSE, FALSE);
676
859
        space(level);
677
860
        fprintf (headerfile, "} %s;\n", name);
678
861
        break;
685
868
        space(level);
686
869
        fprintf (headerfile, "heim_general_string %s;\n", name);
687
870
        break;
 
871
    case TTeletexString:
 
872
        space(level);
 
873
        fprintf (headerfile, "heim_general_string %s;\n", name);
 
874
        break;
688
875
    case TTag:
689
 
        define_type (level, name, t->subtype, typedefp, preservep);
 
876
        define_type (level, name, basename, t->subtype, typedefp, preservep);
690
877
        break;
691
878
    case TChoice: {
692
879
        int first = 1;
693
880
        Member *m;
694
881
 
 
882
        getnewbasename(&newbasename, typedefp, basename, name);
 
883
 
695
884
        space(level);
696
 
        fprintf (headerfile, "struct %s {\n", typedefp ? name : "");
 
885
        fprintf (headerfile, "struct %s {\n", newbasename);
697
886
        if (preservep) {
698
887
            space(level + 1);
699
888
            fprintf(headerfile, "heim_octet_string _save;\n");
725
914
                space(level + 2);
726
915
                fprintf(headerfile, "heim_octet_string asn1_ellipsis;\n");
727
916
            } else if (m->optional) {
728
 
                char *n;
 
917
                char *n = NULL;
729
918
 
730
 
                asprintf (&n, "*%s", m->gen_name);
731
 
                if (n == NULL)
 
919
                if (asprintf (&n, "*%s", m->gen_name) < 0 || n == NULL)
732
920
                    errx(1, "malloc");
733
 
                define_type (level + 2, n, m->type, FALSE, FALSE);
 
921
                define_type (level + 2, n, newbasename, m->type, FALSE, FALSE);
734
922
                free (n);
735
923
            } else
736
 
                define_type (level + 2, m->gen_name, m->type, FALSE, FALSE);
 
924
                define_type (level + 2, m->gen_name, newbasename, m->type, FALSE, FALSE);
737
925
        }
738
926
        space(level + 1);
739
927
        fprintf (headerfile, "} u;\n");
780
968
    default:
781
969
        abort ();
782
970
    }
 
971
    if (newbasename)
 
972
        free(newbasename);
783
973
}
784
974
 
785
975
static void
793
983
    fprintf (headerfile, "\n*/\n\n");
794
984
 
795
985
    fprintf (headerfile, "typedef ");
796
 
    define_type (0, s->gen_name, s->type, TRUE, preservep);
 
986
    define_type (0, s->gen_name, s->gen_name, s->type, TRUE, preservep);
797
987
 
798
988
    fprintf (headerfile, "\n");
799
989
}
800
990
 
801
 
 
802
991
void
803
992
generate_type (const Symbol *s)
804
993
{
 
994
    FILE *h;
 
995
    const char * exp;
 
996
 
805
997
    if (!one_code_file)
806
998
        generate_header_of_codefile(s->gen_name);
807
999
 
808
1000
    generate_type_header (s);
809
 
    generate_type_encode (s);
810
 
    generate_type_decode (s);
811
 
    generate_type_free (s);
812
 
    generate_type_length (s);
813
 
    generate_type_copy (s);
 
1001
 
 
1002
    if (template_flag)
 
1003
        generate_template(s);
 
1004
 
 
1005
    if (template_flag == 0 || is_template_compat(s) == 0) {
 
1006
        generate_type_encode (s);
 
1007
        generate_type_decode (s);
 
1008
        generate_type_free (s);
 
1009
        generate_type_length (s);
 
1010
        generate_type_copy (s);
 
1011
    }
814
1012
    generate_type_seq (s);
815
1013
    generate_glue (s->type, s->gen_name);
816
 
    fprintf(headerfile, "\n\n");
 
1014
 
 
1015
    /* generate prototypes */
 
1016
 
 
1017
    if (is_export(s->name)) {
 
1018
        h = headerfile;
 
1019
        exp = "ASN1EXP ";
 
1020
    } else {
 
1021
        h = privheaderfile;
 
1022
        exp = "";
 
1023
    }
 
1024
   
 
1025
    fprintf (h,
 
1026
             "%sint    ASN1CALL "
 
1027
             "decode_%s(const unsigned char *, size_t, %s *, size_t *);\n",
 
1028
             exp,
 
1029
             s->gen_name, s->gen_name);
 
1030
    fprintf (h,
 
1031
             "%sint    ASN1CALL "
 
1032
             "encode_%s(unsigned char *, size_t, const %s *, size_t *);\n",
 
1033
             exp,
 
1034
             s->gen_name, s->gen_name);
 
1035
    fprintf (h,
 
1036
             "%ssize_t ASN1CALL length_%s(const %s *);\n",
 
1037
             exp,
 
1038
             s->gen_name, s->gen_name);
 
1039
    fprintf (h,
 
1040
             "%sint    ASN1CALL copy_%s  (const %s *, %s *);\n",
 
1041
             exp,
 
1042
             s->gen_name, s->gen_name, s->gen_name);
 
1043
    fprintf (h,
 
1044
             "%svoid   ASN1CALL free_%s  (%s *);\n",
 
1045
             exp,
 
1046
             s->gen_name, s->gen_name);
 
1047
   
 
1048
    fprintf(h, "\n\n");
817
1049
 
818
1050
    if (!one_code_file) {
819
1051
        fprintf(codefile, "\n\n");