rxkad: Update ticket5 from heimdal
[openafs.git] / src / rxkad / v5gen.c
1 #define HEIMDAL_UNUSED_ATTRIBUTE AFS_UNUSED
2 int ASN1CALL decode_MESSAGE_TYPE(const unsigned char *, size_t,
3                                  MESSAGE_TYPE *, size_t *);
4 int ASN1CALL encode_MESSAGE_TYPE(unsigned char *, size_t,
5                                  const MESSAGE_TYPE *, size_t *);
6 size_t ASN1CALL length_MESSAGE_TYPE(const MESSAGE_TYPE *);
7 int ASN1CALL copy_MESSAGE_TYPE(const MESSAGE_TYPE *, MESSAGE_TYPE *);
8 void ASN1CALL free_MESSAGE_TYPE(MESSAGE_TYPE *);
9
10
11 int ASN1CALL decode_krb5uint32(const unsigned char *, size_t, krb5uint32 *,
12                                size_t *);
13 int ASN1CALL encode_krb5uint32(unsigned char *, size_t, const krb5uint32 *,
14                                size_t *);
15 size_t ASN1CALL length_krb5uint32(const krb5uint32 *);
16 int ASN1CALL copy_krb5uint32(const krb5uint32 *, krb5uint32 *);
17 void ASN1CALL free_krb5uint32(krb5uint32 *);
18
19
20 int ASN1CALL decode_krb5int32(const unsigned char *, size_t, krb5int32 *,
21                               size_t *);
22 int ASN1CALL encode_krb5int32(unsigned char *, size_t, const krb5int32 *,
23                               size_t *);
24 size_t ASN1CALL length_krb5int32(const krb5int32 *);
25 int ASN1CALL copy_krb5int32(const krb5int32 *, krb5int32 *);
26 void ASN1CALL free_krb5int32(krb5int32 *);
27
28
29 int ASN1CALL decode_APOptions(const unsigned char *, size_t, APOptions *,
30                               size_t *);
31 int ASN1CALL encode_APOptions(unsigned char *, size_t, const APOptions *,
32                               size_t *);
33 size_t ASN1CALL length_APOptions(const APOptions *);
34 int ASN1CALL copy_APOptions(const APOptions *, APOptions *);
35 void ASN1CALL free_APOptions(APOptions *);
36
37
38 int ASN1CALL decode_TYPED_DATA(const unsigned char *, size_t, TYPED_DATA *,
39                                size_t *);
40 int ASN1CALL encode_TYPED_DATA(unsigned char *, size_t, const TYPED_DATA *,
41                                size_t *);
42 size_t ASN1CALL length_TYPED_DATA(const TYPED_DATA *);
43 int ASN1CALL copy_TYPED_DATA(const TYPED_DATA *, TYPED_DATA *);
44 void ASN1CALL free_TYPED_DATA(TYPED_DATA *);
45
46
47 int ASN1CALL decode_KDC_REQ(const unsigned char *, size_t, KDC_REQ *,
48                             size_t *);
49 int ASN1CALL encode_KDC_REQ(unsigned char *, size_t, const KDC_REQ *,
50                             size_t *);
51 size_t ASN1CALL length_KDC_REQ(const KDC_REQ *);
52 int ASN1CALL copy_KDC_REQ(const KDC_REQ *, KDC_REQ *);
53 void ASN1CALL free_KDC_REQ(KDC_REQ *);
54
55
56 int ASN1CALL decode_PROV_SRV_LOCATION(const unsigned char *, size_t,
57                                       PROV_SRV_LOCATION *, size_t *);
58 int ASN1CALL encode_PROV_SRV_LOCATION(unsigned char *, size_t,
59                                       const PROV_SRV_LOCATION *, size_t *);
60 size_t ASN1CALL length_PROV_SRV_LOCATION(const PROV_SRV_LOCATION *);
61 int ASN1CALL copy_PROV_SRV_LOCATION(const PROV_SRV_LOCATION *,
62                                     PROV_SRV_LOCATION *);
63 void ASN1CALL free_PROV_SRV_LOCATION(PROV_SRV_LOCATION *);
64
65
66 int ASN1CALL decode_AD_MANDATORY_FOR_KDC(const unsigned char *, size_t,
67                                          AD_MANDATORY_FOR_KDC *, size_t *);
68 int ASN1CALL encode_AD_MANDATORY_FOR_KDC(unsigned char *, size_t,
69                                          const AD_MANDATORY_FOR_KDC *,
70                                          size_t *);
71 size_t ASN1CALL length_AD_MANDATORY_FOR_KDC(const AD_MANDATORY_FOR_KDC *);
72 int ASN1CALL copy_AD_MANDATORY_FOR_KDC(const AD_MANDATORY_FOR_KDC *,
73                                        AD_MANDATORY_FOR_KDC *);
74 void ASN1CALL free_AD_MANDATORY_FOR_KDC(AD_MANDATORY_FOR_KDC *);
75
76
77 int ASN1CALL decode_PA_SAM_TYPE(const unsigned char *, size_t, PA_SAM_TYPE *,
78                                 size_t *);
79 int ASN1CALL encode_PA_SAM_TYPE(unsigned char *, size_t, const PA_SAM_TYPE *,
80                                 size_t *);
81 size_t ASN1CALL length_PA_SAM_TYPE(const PA_SAM_TYPE *);
82 int ASN1CALL copy_PA_SAM_TYPE(const PA_SAM_TYPE *, PA_SAM_TYPE *);
83 void ASN1CALL free_PA_SAM_TYPE(PA_SAM_TYPE *);
84
85
86 int ASN1CALL decode_PA_SAM_REDIRECT(const unsigned char *, size_t,
87                                     PA_SAM_REDIRECT *, size_t *);
88 int ASN1CALL encode_PA_SAM_REDIRECT(unsigned char *, size_t,
89                                     const PA_SAM_REDIRECT *, size_t *);
90 size_t ASN1CALL length_PA_SAM_REDIRECT(const PA_SAM_REDIRECT *);
91 int ASN1CALL copy_PA_SAM_REDIRECT(const PA_SAM_REDIRECT *, PA_SAM_REDIRECT *);
92 void ASN1CALL free_PA_SAM_REDIRECT(PA_SAM_REDIRECT *);
93
94
95 int ASN1CALL decode_SAMFlags(const unsigned char *, size_t, SAMFlags *,
96                              size_t *);
97 int ASN1CALL encode_SAMFlags(unsigned char *, size_t, const SAMFlags *,
98                              size_t *);
99 size_t ASN1CALL length_SAMFlags(const SAMFlags *);
100 int ASN1CALL copy_SAMFlags(const SAMFlags *, SAMFlags *);
101 void ASN1CALL free_SAMFlags(SAMFlags *);
102
103
104 int ASN1CALL decode_PA_SAM_CHALLENGE_2_BODY(const unsigned char *, size_t,
105                                             PA_SAM_CHALLENGE_2_BODY *,
106                                             size_t *);
107 int ASN1CALL encode_PA_SAM_CHALLENGE_2_BODY(unsigned char *, size_t,
108                                             const PA_SAM_CHALLENGE_2_BODY *,
109                                             size_t *);
110 size_t ASN1CALL length_PA_SAM_CHALLENGE_2_BODY(const PA_SAM_CHALLENGE_2_BODY
111                                                *);
112 int ASN1CALL copy_PA_SAM_CHALLENGE_2_BODY(const PA_SAM_CHALLENGE_2_BODY *,
113                                           PA_SAM_CHALLENGE_2_BODY *);
114 void ASN1CALL free_PA_SAM_CHALLENGE_2_BODY(PA_SAM_CHALLENGE_2_BODY *);
115
116
117 int ASN1CALL decode_PA_SAM_CHALLENGE_2(const unsigned char *, size_t,
118                                        PA_SAM_CHALLENGE_2 *, size_t *);
119 int ASN1CALL encode_PA_SAM_CHALLENGE_2(unsigned char *, size_t,
120                                        const PA_SAM_CHALLENGE_2 *, size_t *);
121 size_t ASN1CALL length_PA_SAM_CHALLENGE_2(const PA_SAM_CHALLENGE_2 *);
122 int ASN1CALL copy_PA_SAM_CHALLENGE_2(const PA_SAM_CHALLENGE_2 *,
123                                      PA_SAM_CHALLENGE_2 *);
124 void ASN1CALL free_PA_SAM_CHALLENGE_2(PA_SAM_CHALLENGE_2 *);
125
126
127 int ASN1CALL decode_PA_SAM_RESPONSE_2(const unsigned char *, size_t,
128                                       PA_SAM_RESPONSE_2 *, size_t *);
129 int ASN1CALL encode_PA_SAM_RESPONSE_2(unsigned char *, size_t,
130                                       const PA_SAM_RESPONSE_2 *, size_t *);
131 size_t ASN1CALL length_PA_SAM_RESPONSE_2(const PA_SAM_RESPONSE_2 *);
132 int ASN1CALL copy_PA_SAM_RESPONSE_2(const PA_SAM_RESPONSE_2 *,
133                                     PA_SAM_RESPONSE_2 *);
134 void ASN1CALL free_PA_SAM_RESPONSE_2(PA_SAM_RESPONSE_2 *);
135
136
137 int ASN1CALL decode_PA_ENC_SAM_RESPONSE_ENC(const unsigned char *, size_t,
138                                             PA_ENC_SAM_RESPONSE_ENC *,
139                                             size_t *);
140 int ASN1CALL encode_PA_ENC_SAM_RESPONSE_ENC(unsigned char *, size_t,
141                                             const PA_ENC_SAM_RESPONSE_ENC *,
142                                             size_t *);
143 size_t ASN1CALL length_PA_ENC_SAM_RESPONSE_ENC(const PA_ENC_SAM_RESPONSE_ENC
144                                                *);
145 int ASN1CALL copy_PA_ENC_SAM_RESPONSE_ENC(const PA_ENC_SAM_RESPONSE_ENC *,
146                                           PA_ENC_SAM_RESPONSE_ENC *);
147 void ASN1CALL free_PA_ENC_SAM_RESPONSE_ENC(PA_ENC_SAM_RESPONSE_ENC *);
148
149
150 int ASN1CALL decode_FastOptions(const unsigned char *, size_t, FastOptions *,
151                                 size_t *);
152 int ASN1CALL encode_FastOptions(unsigned char *, size_t, const FastOptions *,
153                                 size_t *);
154 size_t ASN1CALL length_FastOptions(const FastOptions *);
155 int ASN1CALL copy_FastOptions(const FastOptions *, FastOptions *);
156 void ASN1CALL free_FastOptions(FastOptions *);
157
158
159 int ASN1CALL decode_KrbFastArmoredReq(const unsigned char *, size_t,
160                                       KrbFastArmoredReq *, size_t *);
161 int ASN1CALL encode_KrbFastArmoredReq(unsigned char *, size_t,
162                                       const KrbFastArmoredReq *, size_t *);
163 size_t ASN1CALL length_KrbFastArmoredReq(const KrbFastArmoredReq *);
164 int ASN1CALL copy_KrbFastArmoredReq(const KrbFastArmoredReq *,
165                                     KrbFastArmoredReq *);
166 void ASN1CALL free_KrbFastArmoredReq(KrbFastArmoredReq *);
167
168
169 int ASN1CALL decode_KrbFastArmoredRep(const unsigned char *, size_t,
170                                       KrbFastArmoredRep *, size_t *);
171 int ASN1CALL encode_KrbFastArmoredRep(unsigned char *, size_t,
172                                       const KrbFastArmoredRep *, size_t *);
173 size_t ASN1CALL length_KrbFastArmoredRep(const KrbFastArmoredRep *);
174 int ASN1CALL copy_KrbFastArmoredRep(const KrbFastArmoredRep *,
175                                     KrbFastArmoredRep *);
176 void ASN1CALL free_KrbFastArmoredRep(KrbFastArmoredRep *);
177
178
179 int ASN1CALL decode_KDCFastFlags(const unsigned char *, size_t,
180                                  KDCFastFlags *, size_t *);
181 int ASN1CALL encode_KDCFastFlags(unsigned char *, size_t,
182                                  const KDCFastFlags *, size_t *);
183 size_t ASN1CALL length_KDCFastFlags(const KDCFastFlags *);
184 int ASN1CALL copy_KDCFastFlags(const KDCFastFlags *, KDCFastFlags *);
185 void ASN1CALL free_KDCFastFlags(KDCFastFlags *);
186
187
188 int ASN1CALL decode_KERB_TGS_REP_IN(const unsigned char *, size_t,
189                                     KERB_TGS_REP_IN *, size_t *);
190 int ASN1CALL encode_KERB_TGS_REP_IN(unsigned char *, size_t,
191                                     const KERB_TGS_REP_IN *, size_t *);
192 size_t ASN1CALL length_KERB_TGS_REP_IN(const KERB_TGS_REP_IN *);
193 int ASN1CALL copy_KERB_TGS_REP_IN(const KERB_TGS_REP_IN *, KERB_TGS_REP_IN *);
194 void ASN1CALL free_KERB_TGS_REP_IN(KERB_TGS_REP_IN *);
195
196
197 int ASN1CALL decode_KERB_TGS_REP_OUT(const unsigned char *, size_t,
198                                      KERB_TGS_REP_OUT *, size_t *);
199 int ASN1CALL encode_KERB_TGS_REP_OUT(unsigned char *, size_t,
200                                      const KERB_TGS_REP_OUT *, size_t *);
201 size_t ASN1CALL length_KERB_TGS_REP_OUT(const KERB_TGS_REP_OUT *);
202 int ASN1CALL copy_KERB_TGS_REP_OUT(const KERB_TGS_REP_OUT *,
203                                    KERB_TGS_REP_OUT *);
204 void ASN1CALL free_KERB_TGS_REP_OUT(KERB_TGS_REP_OUT *);
205
206
207 /* Generated from ./krb5.asn1 */
208 /* Do not edit */
209
210 #define  ASN1_LIB
211
212 #include <stdio.h>
213 #include <stdlib.h>
214 #include <time.h>
215 #include <string.h>
216 #include <errno.h>
217 #include <limits.h>
218 #include <asn1_err.h>
219
220
221 int ASN1CALL
222 encode_NAME_TYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
223                  size_t len HEIMDAL_UNUSED_ATTRIBUTE, const NAME_TYPE * data,
224                  size_t * size)
225 {
226     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
227     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
228     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
229
230     {
231         int enumint = (int) *data;
232         e = der_put_integer(p, len, &enumint, &l);
233         if (e)
234             return e;
235         p -= l;
236         len -= l;
237         ret += l;
238
239     }
240     ;
241     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer,
242                                &l);
243     if (e)
244         return e;
245     p -= l;
246     len -= l;
247     ret += l;
248
249     *size = ret;
250     return 0;
251 }
252
253 int ASN1CALL
254 decode_NAME_TYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
255                  size_t len HEIMDAL_UNUSED_ATTRIBUTE, NAME_TYPE * data,
256                  size_t * size)
257 {
258     size_t ret = 0;
259     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
260     int e HEIMDAL_UNUSED_ATTRIBUTE;
261
262     memset(data, 0, sizeof(*data));
263     {
264         size_t Top_datalen, Top_oldlen;
265         Der_type Top_type;
266         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
267                                      UT_Integer, &Top_datalen, &l);
268         if (e == 0 && Top_type != PRIM) {
269             e = ASN1_BAD_ID;
270         }
271         if (e)
272             goto fail;
273         p += l;
274         len -= l;
275         ret += l;
276         Top_oldlen = len;
277         if (Top_datalen > len) {
278             e = ASN1_OVERRUN;
279             goto fail;
280         }
281         len = Top_datalen;
282         {
283             int enumint;
284             e = der_get_integer(p, len, &enumint, &l);
285             if (e)
286                 goto fail;
287             p += l;
288             len -= l;
289             ret += l;
290             *data = enumint;
291         }
292         len = Top_oldlen - Top_datalen;
293     }
294     if (size)
295         *size = ret;
296     return 0;
297   fail:
298     free_NAME_TYPE(data);
299     return e;
300 }
301
302 void ASN1CALL
303 free_NAME_TYPE(NAME_TYPE * data)
304 {
305 }
306
307 size_t ASN1CALL
308 length_NAME_TYPE(const NAME_TYPE * data)
309 {
310     size_t ret = 0;
311     {
312         int enumint = *data;
313         ret += der_length_integer(&enumint);
314     }
315     ret += 1 + der_length_len(ret);
316     return ret;
317 }
318
319 int ASN1CALL
320 copy_NAME_TYPE(const NAME_TYPE * from, NAME_TYPE * to)
321 {
322     memset(to, 0, sizeof(*to));
323     *(to) = *(from);
324     return 0;
325 }
326
327 int ASN1CALL
328 encode_MESSAGE_TYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
329                     size_t len HEIMDAL_UNUSED_ATTRIBUTE,
330                     const MESSAGE_TYPE * data, size_t * size)
331 {
332     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
333     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
334     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
335
336     {
337         int enumint = (int) *data;
338         e = der_put_integer(p, len, &enumint, &l);
339         if (e)
340             return e;
341         p -= l;
342         len -= l;
343         ret += l;
344
345     }
346     ;
347     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer,
348                                &l);
349     if (e)
350         return e;
351     p -= l;
352     len -= l;
353     ret += l;
354
355     *size = ret;
356     return 0;
357 }
358
359 int ASN1CALL
360 decode_MESSAGE_TYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
361                     size_t len HEIMDAL_UNUSED_ATTRIBUTE, MESSAGE_TYPE * data,
362                     size_t * size)
363 {
364     size_t ret = 0;
365     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
366     int e HEIMDAL_UNUSED_ATTRIBUTE;
367
368     memset(data, 0, sizeof(*data));
369     {
370         size_t Top_datalen, Top_oldlen;
371         Der_type Top_type;
372         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
373                                      UT_Integer, &Top_datalen, &l);
374         if (e == 0 && Top_type != PRIM) {
375             e = ASN1_BAD_ID;
376         }
377         if (e)
378             goto fail;
379         p += l;
380         len -= l;
381         ret += l;
382         Top_oldlen = len;
383         if (Top_datalen > len) {
384             e = ASN1_OVERRUN;
385             goto fail;
386         }
387         len = Top_datalen;
388         {
389             int enumint;
390             e = der_get_integer(p, len, &enumint, &l);
391             if (e)
392                 goto fail;
393             p += l;
394             len -= l;
395             ret += l;
396             *data = enumint;
397         }
398         len = Top_oldlen - Top_datalen;
399     }
400     if (size)
401         *size = ret;
402     return 0;
403   fail:
404     free_MESSAGE_TYPE(data);
405     return e;
406 }
407
408 void ASN1CALL
409 free_MESSAGE_TYPE(MESSAGE_TYPE * data)
410 {
411 }
412
413 size_t ASN1CALL
414 length_MESSAGE_TYPE(const MESSAGE_TYPE * data)
415 {
416     size_t ret = 0;
417     {
418         int enumint = *data;
419         ret += der_length_integer(&enumint);
420     }
421     ret += 1 + der_length_len(ret);
422     return ret;
423 }
424
425 int ASN1CALL
426 copy_MESSAGE_TYPE(const MESSAGE_TYPE * from, MESSAGE_TYPE * to)
427 {
428     memset(to, 0, sizeof(*to));
429     *(to) = *(from);
430     return 0;
431 }
432
433 int ASN1CALL
434 encode_PADATA_TYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
435                    size_t len HEIMDAL_UNUSED_ATTRIBUTE,
436                    const PADATA_TYPE * data, size_t * size)
437 {
438     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
439     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
440     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
441
442     {
443         int enumint = (int) *data;
444         e = der_put_integer(p, len, &enumint, &l);
445         if (e)
446             return e;
447         p -= l;
448         len -= l;
449         ret += l;
450
451     }
452     ;
453     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer,
454                                &l);
455     if (e)
456         return e;
457     p -= l;
458     len -= l;
459     ret += l;
460
461     *size = ret;
462     return 0;
463 }
464
465 int ASN1CALL
466 decode_PADATA_TYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
467                    size_t len HEIMDAL_UNUSED_ATTRIBUTE, PADATA_TYPE * data,
468                    size_t * size)
469 {
470     size_t ret = 0;
471     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
472     int e HEIMDAL_UNUSED_ATTRIBUTE;
473
474     memset(data, 0, sizeof(*data));
475     {
476         size_t Top_datalen, Top_oldlen;
477         Der_type Top_type;
478         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
479                                      UT_Integer, &Top_datalen, &l);
480         if (e == 0 && Top_type != PRIM) {
481             e = ASN1_BAD_ID;
482         }
483         if (e)
484             goto fail;
485         p += l;
486         len -= l;
487         ret += l;
488         Top_oldlen = len;
489         if (Top_datalen > len) {
490             e = ASN1_OVERRUN;
491             goto fail;
492         }
493         len = Top_datalen;
494         {
495             int enumint;
496             e = der_get_integer(p, len, &enumint, &l);
497             if (e)
498                 goto fail;
499             p += l;
500             len -= l;
501             ret += l;
502             *data = enumint;
503         }
504         len = Top_oldlen - Top_datalen;
505     }
506     if (size)
507         *size = ret;
508     return 0;
509   fail:
510     free_PADATA_TYPE(data);
511     return e;
512 }
513
514 void ASN1CALL
515 free_PADATA_TYPE(PADATA_TYPE * data)
516 {
517 }
518
519 size_t ASN1CALL
520 length_PADATA_TYPE(const PADATA_TYPE * data)
521 {
522     size_t ret = 0;
523     {
524         int enumint = *data;
525         ret += der_length_integer(&enumint);
526     }
527     ret += 1 + der_length_len(ret);
528     return ret;
529 }
530
531 int ASN1CALL
532 copy_PADATA_TYPE(const PADATA_TYPE * from, PADATA_TYPE * to)
533 {
534     memset(to, 0, sizeof(*to));
535     *(to) = *(from);
536     return 0;
537 }
538
539 int ASN1CALL
540 encode_AUTHDATA_TYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
541                      size_t len HEIMDAL_UNUSED_ATTRIBUTE,
542                      const AUTHDATA_TYPE * data, size_t * size)
543 {
544     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
545     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
546     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
547
548     {
549         int enumint = (int) *data;
550         e = der_put_integer(p, len, &enumint, &l);
551         if (e)
552             return e;
553         p -= l;
554         len -= l;
555         ret += l;
556
557     }
558     ;
559     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer,
560                                &l);
561     if (e)
562         return e;
563     p -= l;
564     len -= l;
565     ret += l;
566
567     *size = ret;
568     return 0;
569 }
570
571 int ASN1CALL
572 decode_AUTHDATA_TYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
573                      size_t len HEIMDAL_UNUSED_ATTRIBUTE,
574                      AUTHDATA_TYPE * data, size_t * size)
575 {
576     size_t ret = 0;
577     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
578     int e HEIMDAL_UNUSED_ATTRIBUTE;
579
580     memset(data, 0, sizeof(*data));
581     {
582         size_t Top_datalen, Top_oldlen;
583         Der_type Top_type;
584         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
585                                      UT_Integer, &Top_datalen, &l);
586         if (e == 0 && Top_type != PRIM) {
587             e = ASN1_BAD_ID;
588         }
589         if (e)
590             goto fail;
591         p += l;
592         len -= l;
593         ret += l;
594         Top_oldlen = len;
595         if (Top_datalen > len) {
596             e = ASN1_OVERRUN;
597             goto fail;
598         }
599         len = Top_datalen;
600         {
601             int enumint;
602             e = der_get_integer(p, len, &enumint, &l);
603             if (e)
604                 goto fail;
605             p += l;
606             len -= l;
607             ret += l;
608             *data = enumint;
609         }
610         len = Top_oldlen - Top_datalen;
611     }
612     if (size)
613         *size = ret;
614     return 0;
615   fail:
616     free_AUTHDATA_TYPE(data);
617     return e;
618 }
619
620 void ASN1CALL
621 free_AUTHDATA_TYPE(AUTHDATA_TYPE * data)
622 {
623 }
624
625 size_t ASN1CALL
626 length_AUTHDATA_TYPE(const AUTHDATA_TYPE * data)
627 {
628     size_t ret = 0;
629     {
630         int enumint = *data;
631         ret += der_length_integer(&enumint);
632     }
633     ret += 1 + der_length_len(ret);
634     return ret;
635 }
636
637 int ASN1CALL
638 copy_AUTHDATA_TYPE(const AUTHDATA_TYPE * from, AUTHDATA_TYPE * to)
639 {
640     memset(to, 0, sizeof(*to));
641     *(to) = *(from);
642     return 0;
643 }
644
645 int ASN1CALL
646 encode_CKSUMTYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
647                  size_t len HEIMDAL_UNUSED_ATTRIBUTE, const CKSUMTYPE * data,
648                  size_t * size)
649 {
650     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
651     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
652     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
653
654     {
655         int enumint = (int) *data;
656         e = der_put_integer(p, len, &enumint, &l);
657         if (e)
658             return e;
659         p -= l;
660         len -= l;
661         ret += l;
662
663     }
664     ;
665     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer,
666                                &l);
667     if (e)
668         return e;
669     p -= l;
670     len -= l;
671     ret += l;
672
673     *size = ret;
674     return 0;
675 }
676
677 int ASN1CALL
678 decode_CKSUMTYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
679                  size_t len HEIMDAL_UNUSED_ATTRIBUTE, CKSUMTYPE * data,
680                  size_t * size)
681 {
682     size_t ret = 0;
683     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
684     int e HEIMDAL_UNUSED_ATTRIBUTE;
685
686     memset(data, 0, sizeof(*data));
687     {
688         size_t Top_datalen, Top_oldlen;
689         Der_type Top_type;
690         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
691                                      UT_Integer, &Top_datalen, &l);
692         if (e == 0 && Top_type != PRIM) {
693             e = ASN1_BAD_ID;
694         }
695         if (e)
696             goto fail;
697         p += l;
698         len -= l;
699         ret += l;
700         Top_oldlen = len;
701         if (Top_datalen > len) {
702             e = ASN1_OVERRUN;
703             goto fail;
704         }
705         len = Top_datalen;
706         {
707             int enumint;
708             e = der_get_integer(p, len, &enumint, &l);
709             if (e)
710                 goto fail;
711             p += l;
712             len -= l;
713             ret += l;
714             *data = enumint;
715         }
716         len = Top_oldlen - Top_datalen;
717     }
718     if (size)
719         *size = ret;
720     return 0;
721   fail:
722     free_CKSUMTYPE(data);
723     return e;
724 }
725
726 void ASN1CALL
727 free_CKSUMTYPE(CKSUMTYPE * data)
728 {
729 }
730
731 size_t ASN1CALL
732 length_CKSUMTYPE(const CKSUMTYPE * data)
733 {
734     size_t ret = 0;
735     {
736         int enumint = *data;
737         ret += der_length_integer(&enumint);
738     }
739     ret += 1 + der_length_len(ret);
740     return ret;
741 }
742
743 int ASN1CALL
744 copy_CKSUMTYPE(const CKSUMTYPE * from, CKSUMTYPE * to)
745 {
746     memset(to, 0, sizeof(*to));
747     *(to) = *(from);
748     return 0;
749 }
750
751 int ASN1CALL
752 encode_ENCTYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
753                size_t len HEIMDAL_UNUSED_ATTRIBUTE, const ENCTYPE * data,
754                size_t * size)
755 {
756     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
757     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
758     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
759
760     {
761         int enumint = (int) *data;
762         e = der_put_integer(p, len, &enumint, &l);
763         if (e)
764             return e;
765         p -= l;
766         len -= l;
767         ret += l;
768
769     }
770     ;
771     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer,
772                                &l);
773     if (e)
774         return e;
775     p -= l;
776     len -= l;
777     ret += l;
778
779     *size = ret;
780     return 0;
781 }
782
783 int ASN1CALL
784 decode_ENCTYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
785                size_t len HEIMDAL_UNUSED_ATTRIBUTE, ENCTYPE * data,
786                size_t * size)
787 {
788     size_t ret = 0;
789     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
790     int e HEIMDAL_UNUSED_ATTRIBUTE;
791
792     memset(data, 0, sizeof(*data));
793     {
794         size_t Top_datalen, Top_oldlen;
795         Der_type Top_type;
796         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
797                                      UT_Integer, &Top_datalen, &l);
798         if (e == 0 && Top_type != PRIM) {
799             e = ASN1_BAD_ID;
800         }
801         if (e)
802             goto fail;
803         p += l;
804         len -= l;
805         ret += l;
806         Top_oldlen = len;
807         if (Top_datalen > len) {
808             e = ASN1_OVERRUN;
809             goto fail;
810         }
811         len = Top_datalen;
812         {
813             int enumint;
814             e = der_get_integer(p, len, &enumint, &l);
815             if (e)
816                 goto fail;
817             p += l;
818             len -= l;
819             ret += l;
820             *data = enumint;
821         }
822         len = Top_oldlen - Top_datalen;
823     }
824     if (size)
825         *size = ret;
826     return 0;
827   fail:
828     free_ENCTYPE(data);
829     return e;
830 }
831
832 void ASN1CALL
833 free_ENCTYPE(ENCTYPE * data)
834 {
835 }
836
837 size_t ASN1CALL
838 length_ENCTYPE(const ENCTYPE * data)
839 {
840     size_t ret = 0;
841     {
842         int enumint = *data;
843         ret += der_length_integer(&enumint);
844     }
845     ret += 1 + der_length_len(ret);
846     return ret;
847 }
848
849 int ASN1CALL
850 copy_ENCTYPE(const ENCTYPE * from, ENCTYPE * to)
851 {
852     memset(to, 0, sizeof(*to));
853     *(to) = *(from);
854     return 0;
855 }
856
857 int ASN1CALL
858 encode_krb5uint32(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
859                   size_t len HEIMDAL_UNUSED_ATTRIBUTE,
860                   const krb5uint32 * data, size_t * size)
861 {
862     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
863     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
864     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
865
866     e = der_put_unsigned(p, len, data, &l);
867     if (e)
868         return e;
869     p -= l;
870     len -= l;
871     ret += l;
872
873     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer,
874                                &l);
875     if (e)
876         return e;
877     p -= l;
878     len -= l;
879     ret += l;
880
881     *size = ret;
882     return 0;
883 }
884
885 int ASN1CALL
886 decode_krb5uint32(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
887                   size_t len HEIMDAL_UNUSED_ATTRIBUTE, krb5uint32 * data,
888                   size_t * size)
889 {
890     size_t ret = 0;
891     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
892     int e HEIMDAL_UNUSED_ATTRIBUTE;
893
894     memset(data, 0, sizeof(*data));
895     {
896         size_t Top_datalen, Top_oldlen;
897         Der_type Top_type;
898         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
899                                      UT_Integer, &Top_datalen, &l);
900         if (e == 0 && Top_type != PRIM) {
901             e = ASN1_BAD_ID;
902         }
903         if (e)
904             goto fail;
905         p += l;
906         len -= l;
907         ret += l;
908         Top_oldlen = len;
909         if (Top_datalen > len) {
910             e = ASN1_OVERRUN;
911             goto fail;
912         }
913         len = Top_datalen;
914         e = der_get_unsigned(p, len, data, &l);
915         if (e)
916             goto fail;
917         p += l;
918         len -= l;
919         ret += l;
920         len = Top_oldlen - Top_datalen;
921     }
922     if (size)
923         *size = ret;
924     return 0;
925   fail:
926     free_krb5uint32(data);
927     return e;
928 }
929
930 void ASN1CALL
931 free_krb5uint32(krb5uint32 * data)
932 {
933 }
934
935 size_t ASN1CALL
936 length_krb5uint32(const krb5uint32 * data)
937 {
938     size_t ret = 0;
939     ret += der_length_unsigned(data);
940     ret += 1 + der_length_len(ret);
941     return ret;
942 }
943
944 int ASN1CALL
945 copy_krb5uint32(const krb5uint32 * from, krb5uint32 * to)
946 {
947     memset(to, 0, sizeof(*to));
948     *(to) = *(from);
949     return 0;
950 }
951
952 int ASN1CALL
953 encode_krb5int32(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
954                  size_t len HEIMDAL_UNUSED_ATTRIBUTE, const krb5int32 * data,
955                  size_t * size)
956 {
957     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
958     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
959     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
960
961     e = der_put_integer(p, len, data, &l);
962     if (e)
963         return e;
964     p -= l;
965     len -= l;
966     ret += l;
967
968     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer,
969                                &l);
970     if (e)
971         return e;
972     p -= l;
973     len -= l;
974     ret += l;
975
976     *size = ret;
977     return 0;
978 }
979
980 int ASN1CALL
981 decode_krb5int32(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
982                  size_t len HEIMDAL_UNUSED_ATTRIBUTE, krb5int32 * data,
983                  size_t * size)
984 {
985     size_t ret = 0;
986     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
987     int e HEIMDAL_UNUSED_ATTRIBUTE;
988
989     memset(data, 0, sizeof(*data));
990     {
991         size_t Top_datalen, Top_oldlen;
992         Der_type Top_type;
993         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
994                                      UT_Integer, &Top_datalen, &l);
995         if (e == 0 && Top_type != PRIM) {
996             e = ASN1_BAD_ID;
997         }
998         if (e)
999             goto fail;
1000         p += l;
1001         len -= l;
1002         ret += l;
1003         Top_oldlen = len;
1004         if (Top_datalen > len) {
1005             e = ASN1_OVERRUN;
1006             goto fail;
1007         }
1008         len = Top_datalen;
1009         e = der_get_integer(p, len, data, &l);
1010         if (e)
1011             goto fail;
1012         p += l;
1013         len -= l;
1014         ret += l;
1015         len = Top_oldlen - Top_datalen;
1016     }
1017     if (size)
1018         *size = ret;
1019     return 0;
1020   fail:
1021     free_krb5int32(data);
1022     return e;
1023 }
1024
1025 void ASN1CALL
1026 free_krb5int32(krb5int32 * data)
1027 {
1028 }
1029
1030 size_t ASN1CALL
1031 length_krb5int32(const krb5int32 * data)
1032 {
1033     size_t ret = 0;
1034     ret += der_length_integer(data);
1035     ret += 1 + der_length_len(ret);
1036     return ret;
1037 }
1038
1039 int ASN1CALL
1040 copy_krb5int32(const krb5int32 * from, krb5int32 * to)
1041 {
1042     memset(to, 0, sizeof(*to));
1043     *(to) = *(from);
1044     return 0;
1045 }
1046
1047 int ASN1CALL
1048 encode_KerberosString(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
1049                       size_t len HEIMDAL_UNUSED_ATTRIBUTE,
1050                       const KerberosString * data, size_t * size)
1051 {
1052     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1053     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1054     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1055
1056     e = der_put_general_string(p, len, data, &l);
1057     if (e)
1058         return e;
1059     p -= l;
1060     len -= l;
1061     ret += l;
1062
1063     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM,
1064                                UT_GeneralString, &l);
1065     if (e)
1066         return e;
1067     p -= l;
1068     len -= l;
1069     ret += l;
1070
1071     *size = ret;
1072     return 0;
1073 }
1074
1075 int ASN1CALL
1076 decode_KerberosString(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
1077                       size_t len HEIMDAL_UNUSED_ATTRIBUTE,
1078                       KerberosString * data, size_t * size)
1079 {
1080     size_t ret = 0;
1081     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1082     int e HEIMDAL_UNUSED_ATTRIBUTE;
1083
1084     memset(data, 0, sizeof(*data));
1085     {
1086         size_t Top_datalen, Top_oldlen;
1087         Der_type Top_type;
1088         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
1089                                      UT_GeneralString, &Top_datalen, &l);
1090         if (e == 0 && Top_type != PRIM) {
1091             e = ASN1_BAD_ID;
1092         }
1093         if (e)
1094             goto fail;
1095         p += l;
1096         len -= l;
1097         ret += l;
1098         Top_oldlen = len;
1099         if (Top_datalen > len) {
1100             e = ASN1_OVERRUN;
1101             goto fail;
1102         }
1103         len = Top_datalen;
1104         e = der_get_general_string(p, len, data, &l);
1105         if (e)
1106             goto fail;
1107         p += l;
1108         len -= l;
1109         ret += l;
1110         len = Top_oldlen - Top_datalen;
1111     }
1112     if (size)
1113         *size = ret;
1114     return 0;
1115   fail:
1116     free_KerberosString(data);
1117     return e;
1118 }
1119
1120 void ASN1CALL
1121 free_KerberosString(KerberosString * data)
1122 {
1123     der_free_general_string(data);
1124 }
1125
1126 size_t ASN1CALL
1127 length_KerberosString(const KerberosString * data)
1128 {
1129     size_t ret = 0;
1130     ret += der_length_general_string(data);
1131     ret += 1 + der_length_len(ret);
1132     return ret;
1133 }
1134
1135 int ASN1CALL
1136 copy_KerberosString(const KerberosString * from, KerberosString * to)
1137 {
1138     memset(to, 0, sizeof(*to));
1139     if (der_copy_general_string(from, to))
1140         goto fail;
1141     return 0;
1142   fail:
1143     free_KerberosString(to);
1144     return ENOMEM;
1145 }
1146
1147 int ASN1CALL
1148 encode_Realm(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
1149              size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Realm * data,
1150              size_t * size)
1151 {
1152     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1153     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1154     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1155
1156     e = der_put_general_string(p, len, data, &l);
1157     if (e)
1158         return e;
1159     p -= l;
1160     len -= l;
1161     ret += l;
1162
1163     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM,
1164                                UT_GeneralString, &l);
1165     if (e)
1166         return e;
1167     p -= l;
1168     len -= l;
1169     ret += l;
1170
1171     *size = ret;
1172     return 0;
1173 }
1174
1175 int ASN1CALL
1176 decode_Realm(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
1177              size_t len HEIMDAL_UNUSED_ATTRIBUTE, Realm * data, size_t * size)
1178 {
1179     size_t ret = 0;
1180     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1181     int e HEIMDAL_UNUSED_ATTRIBUTE;
1182
1183     memset(data, 0, sizeof(*data));
1184     {
1185         size_t Top_datalen, Top_oldlen;
1186         Der_type Top_type;
1187         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
1188                                      UT_GeneralString, &Top_datalen, &l);
1189         if (e == 0 && Top_type != PRIM) {
1190             e = ASN1_BAD_ID;
1191         }
1192         if (e)
1193             goto fail;
1194         p += l;
1195         len -= l;
1196         ret += l;
1197         Top_oldlen = len;
1198         if (Top_datalen > len) {
1199             e = ASN1_OVERRUN;
1200             goto fail;
1201         }
1202         len = Top_datalen;
1203         e = der_get_general_string(p, len, data, &l);
1204         if (e)
1205             goto fail;
1206         p += l;
1207         len -= l;
1208         ret += l;
1209         len = Top_oldlen - Top_datalen;
1210     }
1211     if (size)
1212         *size = ret;
1213     return 0;
1214   fail:
1215     free_Realm(data);
1216     return e;
1217 }
1218
1219 void ASN1CALL
1220 free_Realm(Realm * data)
1221 {
1222     der_free_general_string(data);
1223 }
1224
1225 size_t ASN1CALL
1226 length_Realm(const Realm * data)
1227 {
1228     size_t ret = 0;
1229     ret += der_length_general_string(data);
1230     ret += 1 + der_length_len(ret);
1231     return ret;
1232 }
1233
1234 int ASN1CALL
1235 copy_Realm(const Realm * from, Realm * to)
1236 {
1237     memset(to, 0, sizeof(*to));
1238     if (der_copy_general_string(from, to))
1239         goto fail;
1240     return 0;
1241   fail:
1242     free_Realm(to);
1243     return ENOMEM;
1244 }
1245
1246 int ASN1CALL
1247 encode_PrincipalName(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
1248                      size_t len HEIMDAL_UNUSED_ATTRIBUTE,
1249                      const PrincipalName * data, size_t * size)
1250 {
1251     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1252     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1253     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1254
1255 /* name-string */
1256     {
1257         size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1258         ret = 0;
1259         for (i = (int) (&(data)->name_string)->len - 1; i >= 0; --i) {
1260             size_t name_string_tag_tag_for_oldret = ret;
1261             ret = 0;
1262             e = der_put_general_string(p, len,
1263                                        &(&(data)->name_string)->val[i], &l);
1264             if (e)
1265                 return e;
1266             p -= l;
1267             len -= l;
1268             ret += l;
1269
1270             e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM,
1271                                        UT_GeneralString, &l);
1272             if (e)
1273                 return e;
1274             p -= l;
1275             len -= l;
1276             ret += l;
1277
1278             ret += name_string_tag_tag_for_oldret;
1279         }
1280         e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS,
1281                                    UT_Sequence, &l);
1282         if (e)
1283             return e;
1284         p -= l;
1285         len -= l;
1286         ret += l;
1287
1288         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
1289         if (e)
1290             return e;
1291         p -= l;
1292         len -= l;
1293         ret += l;
1294
1295         ret += Top_tag_oldret;
1296     }
1297 /* name-type */
1298     {
1299         size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1300         ret = 0;
1301         e = encode_NAME_TYPE(p, len, &(data)->name_type, &l);
1302         if (e)
1303             return e;
1304         p -= l;
1305         len -= l;
1306         ret += l;
1307
1308         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1309         if (e)
1310             return e;
1311         p -= l;
1312         len -= l;
1313         ret += l;
1314
1315         ret += Top_tag_oldret;
1316     }
1317     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence,
1318                                &l);
1319     if (e)
1320         return e;
1321     p -= l;
1322     len -= l;
1323     ret += l;
1324
1325     *size = ret;
1326     return 0;
1327 }
1328
1329 int ASN1CALL
1330 decode_PrincipalName(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
1331                      size_t len HEIMDAL_UNUSED_ATTRIBUTE,
1332                      PrincipalName * data, size_t * size)
1333 {
1334     size_t ret = 0;
1335     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1336     int e HEIMDAL_UNUSED_ATTRIBUTE;
1337
1338     memset(data, 0, sizeof(*data));
1339     {
1340         size_t Top_datalen, Top_oldlen;
1341         Der_type Top_type;
1342         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
1343                                      UT_Sequence, &Top_datalen, &l);
1344         if (e == 0 && Top_type != CONS) {
1345             e = ASN1_BAD_ID;
1346         }
1347         if (e)
1348             goto fail;
1349         p += l;
1350         len -= l;
1351         ret += l;
1352         Top_oldlen = len;
1353         if (Top_datalen > len) {
1354             e = ASN1_OVERRUN;
1355             goto fail;
1356         }
1357         len = Top_datalen;
1358         {
1359             size_t name_type_datalen, name_type_oldlen;
1360             Der_type name_type_type;
1361             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT,
1362                                          &name_type_type, 0,
1363                                          &name_type_datalen, &l);
1364             if (e == 0 && name_type_type != CONS) {
1365                 e = ASN1_BAD_ID;
1366             }
1367             if (e)
1368                 goto fail;
1369             p += l;
1370             len -= l;
1371             ret += l;
1372             name_type_oldlen = len;
1373             if (name_type_datalen > len) {
1374                 e = ASN1_OVERRUN;
1375                 goto fail;
1376             }
1377             len = name_type_datalen;
1378             e = decode_NAME_TYPE(p, len, &(data)->name_type, &l);
1379             if (e)
1380                 goto fail;
1381             p += l;
1382             len -= l;
1383             ret += l;
1384             len = name_type_oldlen - name_type_datalen;
1385         }
1386         {
1387             size_t name_string_datalen, name_string_oldlen;
1388             Der_type name_string_type;
1389             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT,
1390                                          &name_string_type, 1,
1391                                          &name_string_datalen, &l);
1392             if (e == 0 && name_string_type != CONS) {
1393                 e = ASN1_BAD_ID;
1394             }
1395             if (e)
1396                 goto fail;
1397             p += l;
1398             len -= l;
1399             ret += l;
1400             name_string_oldlen = len;
1401             if (name_string_datalen > len) {
1402                 e = ASN1_OVERRUN;
1403                 goto fail;
1404             }
1405             len = name_string_datalen;
1406             {
1407                 size_t name_string_Tag_datalen, name_string_Tag_oldlen;
1408                 Der_type name_string_Tag_type;
1409                 e = der_match_tag_and_length(p, len, ASN1_C_UNIV,
1410                                              &name_string_Tag_type,
1411                                              UT_Sequence,
1412                                              &name_string_Tag_datalen, &l);
1413                 if (e == 0 && name_string_Tag_type != CONS) {
1414                     e = ASN1_BAD_ID;
1415                 }
1416                 if (e)
1417                     goto fail;
1418                 p += l;
1419                 len -= l;
1420                 ret += l;
1421                 name_string_Tag_oldlen = len;
1422                 if (name_string_Tag_datalen > len) {
1423                     e = ASN1_OVERRUN;
1424                     goto fail;
1425                 }
1426                 len = name_string_Tag_datalen;
1427                 {
1428                     size_t name_string_Tag_Tag_origlen = len;
1429                     size_t name_string_Tag_Tag_oldret = ret;
1430                     size_t name_string_Tag_Tag_olen = 0;
1431                     void *name_string_Tag_Tag_tmp;
1432                     ret = 0;
1433                     (&(data)->name_string)->len = 0;
1434                     (&(data)->name_string)->val = NULL;
1435                     while (ret < name_string_Tag_Tag_origlen) {
1436                         size_t name_string_Tag_Tag_nlen =
1437                             name_string_Tag_Tag_olen +
1438                             sizeof(*((&(data)->name_string)->val));
1439                         if (name_string_Tag_Tag_olen >
1440                             name_string_Tag_Tag_nlen) {
1441                             e = ASN1_OVERFLOW;
1442                             goto fail;
1443                         }
1444                         name_string_Tag_Tag_olen = name_string_Tag_Tag_nlen;
1445                         name_string_Tag_Tag_tmp =
1446                             realloc((&(data)->name_string)->val,
1447                                     name_string_Tag_Tag_olen);
1448                         if (name_string_Tag_Tag_tmp == NULL) {
1449                             e = ENOMEM;
1450                             goto fail;
1451                         }
1452                         (&(data)->name_string)->val = name_string_Tag_Tag_tmp;
1453                         {
1454                             size_t name_string_Tag_Tag_s_of_datalen,
1455                                 name_string_Tag_Tag_s_of_oldlen;
1456                             Der_type name_string_Tag_Tag_s_of_type;
1457                             e = der_match_tag_and_length(p, len, ASN1_C_UNIV,
1458                                                          &name_string_Tag_Tag_s_of_type,
1459                                                          UT_GeneralString,
1460                                                          &name_string_Tag_Tag_s_of_datalen,
1461                                                          &l);
1462                             if (e == 0
1463                                 && name_string_Tag_Tag_s_of_type != PRIM) {
1464                                 e = ASN1_BAD_ID;
1465                             }
1466                             if (e)
1467                                 goto fail;
1468                             p += l;
1469                             len -= l;
1470                             ret += l;
1471                             name_string_Tag_Tag_s_of_oldlen = len;
1472                             if (name_string_Tag_Tag_s_of_datalen > len) {
1473                                 e = ASN1_OVERRUN;
1474                                 goto fail;
1475                             }
1476                             len = name_string_Tag_Tag_s_of_datalen;
1477                             e = der_get_general_string(p, len,
1478                                                        &(&(data)->
1479                                                          name_string)->
1480                                                        val[(&(data)->
1481                                                             name_string)->
1482                                                            len], &l);
1483                             if (e)
1484                                 goto fail;
1485                             p += l;
1486                             len -= l;
1487                             ret += l;
1488                             len =
1489                                 name_string_Tag_Tag_s_of_oldlen -
1490                                 name_string_Tag_Tag_s_of_datalen;
1491                         }
1492                         (&(data)->name_string)->len++;
1493                         len = name_string_Tag_Tag_origlen - ret;
1494                     }
1495                     ret += name_string_Tag_Tag_oldret;
1496                 }
1497                 len = name_string_Tag_oldlen - name_string_Tag_datalen;
1498             }
1499             len = name_string_oldlen - name_string_datalen;
1500         }
1501         len = Top_oldlen - Top_datalen;
1502     }
1503     if (size)
1504         *size = ret;
1505     return 0;
1506   fail:
1507     free_PrincipalName(data);
1508     return e;
1509 }
1510
1511 void ASN1CALL
1512 free_PrincipalName(PrincipalName * data)
1513 {
1514     free_NAME_TYPE(&(data)->name_type);
1515     while ((&(data)->name_string)->len) {
1516         der_free_general_string(&(&(data)->name_string)->
1517                                 val[(&(data)->name_string)->len - 1]);
1518         (&(data)->name_string)->len--;
1519     }
1520     free((&(data)->name_string)->val);
1521     (&(data)->name_string)->val = NULL;
1522 }
1523
1524 size_t ASN1CALL
1525 length_PrincipalName(const PrincipalName * data)
1526 {
1527     size_t ret = 0;
1528     {
1529         size_t Top_tag_oldret = ret;
1530         ret = 0;
1531         ret += length_NAME_TYPE(&(data)->name_type);
1532         ret += 1 + der_length_len(ret);
1533         ret += Top_tag_oldret;
1534     }
1535     {
1536         size_t Top_tag_oldret = ret;
1537         ret = 0;
1538         {
1539             size_t name_string_tag_tag_oldret = ret;
1540             unsigned int n_name_string_tag_tag;
1541             ret = 0;
1542             for (n_name_string_tag_tag = (&(data)->name_string)->len;
1543                  n_name_string_tag_tag > 0; --n_name_string_tag_tag) {
1544                 size_t name_string_tag_tag_for_oldret = ret;
1545                 ret = 0;
1546                 ret +=
1547                     der_length_general_string(&(&(data)->name_string)->
1548                                               val[n_name_string_tag_tag - 1]);
1549                 ret += 1 + der_length_len(ret);
1550                 ret += name_string_tag_tag_for_oldret;
1551             }
1552             ret += name_string_tag_tag_oldret;
1553         }
1554         ret += 1 + der_length_len(ret);
1555         ret += 1 + der_length_len(ret);
1556         ret += Top_tag_oldret;
1557     }
1558     ret += 1 + der_length_len(ret);
1559     return ret;
1560 }
1561
1562 int ASN1CALL
1563 copy_PrincipalName(const PrincipalName * from, PrincipalName * to)
1564 {
1565     memset(to, 0, sizeof(*to));
1566     if (copy_NAME_TYPE(&(from)->name_type, &(to)->name_type))
1567         goto fail;
1568     if (((&(to)->name_string)->val =
1569          malloc((&(from)->name_string)->len *
1570                 sizeof(*(&(to)->name_string)->val))) == NULL
1571         && (&(from)->name_string)->len != 0)
1572         goto fail;
1573     for ((&(to)->name_string)->len = 0;
1574          (&(to)->name_string)->len < (&(from)->name_string)->len;
1575          (&(to)->name_string)->len++) {
1576         if (der_copy_general_string
1577             (&(&(from)->name_string)->val[(&(to)->name_string)->len],
1578              &(&(to)->name_string)->val[(&(to)->name_string)->len]))
1579             goto fail;
1580     }
1581     return 0;
1582   fail:
1583     free_PrincipalName(to);
1584     return ENOMEM;
1585 }
1586
1587 int ASN1CALL
1588 encode_Principal(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
1589                  size_t len HEIMDAL_UNUSED_ATTRIBUTE, const Principal * data,
1590                  size_t * size)
1591 {
1592     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1593     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1594     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1595
1596 /* realm */
1597     {
1598         size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1599         ret = 0;
1600         e = encode_Realm(p, len, &(data)->realm, &l);
1601         if (e)
1602             return e;
1603         p -= l;
1604         len -= l;
1605         ret += l;
1606
1607         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
1608         if (e)
1609             return e;
1610         p -= l;
1611         len -= l;
1612         ret += l;
1613
1614         ret += Top_tag_oldret;
1615     }
1616 /* name */
1617     {
1618         size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1619         ret = 0;
1620         e = encode_PrincipalName(p, len, &(data)->name, &l);
1621         if (e)
1622             return e;
1623         p -= l;
1624         len -= l;
1625         ret += l;
1626
1627         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
1628         if (e)
1629             return e;
1630         p -= l;
1631         len -= l;
1632         ret += l;
1633
1634         ret += Top_tag_oldret;
1635     }
1636     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence,
1637                                &l);
1638     if (e)
1639         return e;
1640     p -= l;
1641     len -= l;
1642     ret += l;
1643
1644     *size = ret;
1645     return 0;
1646 }
1647
1648 int ASN1CALL
1649 decode_Principal(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
1650                  size_t len HEIMDAL_UNUSED_ATTRIBUTE, Principal * data,
1651                  size_t * size)
1652 {
1653     size_t ret = 0;
1654     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1655     int e HEIMDAL_UNUSED_ATTRIBUTE;
1656
1657     memset(data, 0, sizeof(*data));
1658     {
1659         size_t Top_datalen, Top_oldlen;
1660         Der_type Top_type;
1661         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
1662                                      UT_Sequence, &Top_datalen, &l);
1663         if (e == 0 && Top_type != CONS) {
1664             e = ASN1_BAD_ID;
1665         }
1666         if (e)
1667             goto fail;
1668         p += l;
1669         len -= l;
1670         ret += l;
1671         Top_oldlen = len;
1672         if (Top_datalen > len) {
1673             e = ASN1_OVERRUN;
1674             goto fail;
1675         }
1676         len = Top_datalen;
1677         {
1678             size_t name_datalen, name_oldlen;
1679             Der_type name_type;
1680             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &name_type,
1681                                          0, &name_datalen, &l);
1682             if (e == 0 && name_type != CONS) {
1683                 e = ASN1_BAD_ID;
1684             }
1685             if (e)
1686                 goto fail;
1687             p += l;
1688             len -= l;
1689             ret += l;
1690             name_oldlen = len;
1691             if (name_datalen > len) {
1692                 e = ASN1_OVERRUN;
1693                 goto fail;
1694             }
1695             len = name_datalen;
1696             e = decode_PrincipalName(p, len, &(data)->name, &l);
1697             if (e)
1698                 goto fail;
1699             p += l;
1700             len -= l;
1701             ret += l;
1702             len = name_oldlen - name_datalen;
1703         }
1704         {
1705             size_t realm_datalen, realm_oldlen;
1706             Der_type realm_type;
1707             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT, &realm_type,
1708                                          1, &realm_datalen, &l);
1709             if (e == 0 && realm_type != CONS) {
1710                 e = ASN1_BAD_ID;
1711             }
1712             if (e)
1713                 goto fail;
1714             p += l;
1715             len -= l;
1716             ret += l;
1717             realm_oldlen = len;
1718             if (realm_datalen > len) {
1719                 e = ASN1_OVERRUN;
1720                 goto fail;
1721             }
1722             len = realm_datalen;
1723             e = decode_Realm(p, len, &(data)->realm, &l);
1724             if (e)
1725                 goto fail;
1726             p += l;
1727             len -= l;
1728             ret += l;
1729             len = realm_oldlen - realm_datalen;
1730         }
1731         len = Top_oldlen - Top_datalen;
1732     }
1733     if (size)
1734         *size = ret;
1735     return 0;
1736   fail:
1737     free_Principal(data);
1738     return e;
1739 }
1740
1741 void ASN1CALL
1742 free_Principal(Principal * data)
1743 {
1744     free_PrincipalName(&(data)->name);
1745     free_Realm(&(data)->realm);
1746 }
1747
1748 size_t ASN1CALL
1749 length_Principal(const Principal * data)
1750 {
1751     size_t ret = 0;
1752     {
1753         size_t Top_tag_oldret = ret;
1754         ret = 0;
1755         ret += length_PrincipalName(&(data)->name);
1756         ret += 1 + der_length_len(ret);
1757         ret += Top_tag_oldret;
1758     }
1759     {
1760         size_t Top_tag_oldret = ret;
1761         ret = 0;
1762         ret += length_Realm(&(data)->realm);
1763         ret += 1 + der_length_len(ret);
1764         ret += Top_tag_oldret;
1765     }
1766     ret += 1 + der_length_len(ret);
1767     return ret;
1768 }
1769
1770 int ASN1CALL
1771 copy_Principal(const Principal * from, Principal * to)
1772 {
1773     memset(to, 0, sizeof(*to));
1774     if (copy_PrincipalName(&(from)->name, &(to)->name))
1775         goto fail;
1776     if (copy_Realm(&(from)->realm, &(to)->realm))
1777         goto fail;
1778     return 0;
1779   fail:
1780     free_Principal(to);
1781     return ENOMEM;
1782 }
1783
1784 int ASN1CALL
1785 encode_Principals(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
1786                   size_t len HEIMDAL_UNUSED_ATTRIBUTE,
1787                   const Principals * data, size_t * size)
1788 {
1789     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1790     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1791     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1792
1793     for (i = (int) (data)->len - 1; i >= 0; --i) {
1794         size_t Top_tag_for_oldret = ret;
1795         ret = 0;
1796         e = encode_Principal(p, len, &(data)->val[i], &l);
1797         if (e)
1798             return e;
1799         p -= l;
1800         len -= l;
1801         ret += l;
1802
1803         ret += Top_tag_for_oldret;
1804     }
1805     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence,
1806                                &l);
1807     if (e)
1808         return e;
1809     p -= l;
1810     len -= l;
1811     ret += l;
1812
1813     *size = ret;
1814     return 0;
1815 }
1816
1817 int ASN1CALL
1818 decode_Principals(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
1819                   size_t len HEIMDAL_UNUSED_ATTRIBUTE, Principals * data,
1820                   size_t * size)
1821 {
1822     size_t ret = 0;
1823     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1824     int e HEIMDAL_UNUSED_ATTRIBUTE;
1825
1826     memset(data, 0, sizeof(*data));
1827     {
1828         size_t Top_datalen, Top_oldlen;
1829         Der_type Top_type;
1830         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
1831                                      UT_Sequence, &Top_datalen, &l);
1832         if (e == 0 && Top_type != CONS) {
1833             e = ASN1_BAD_ID;
1834         }
1835         if (e)
1836             goto fail;
1837         p += l;
1838         len -= l;
1839         ret += l;
1840         Top_oldlen = len;
1841         if (Top_datalen > len) {
1842             e = ASN1_OVERRUN;
1843             goto fail;
1844         }
1845         len = Top_datalen;
1846         {
1847             size_t Top_Tag_origlen = len;
1848             size_t Top_Tag_oldret = ret;
1849             size_t Top_Tag_olen = 0;
1850             void *Top_Tag_tmp;
1851             ret = 0;
1852             (data)->len = 0;
1853             (data)->val = NULL;
1854             while (ret < Top_Tag_origlen) {
1855                 size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
1856                 if (Top_Tag_olen > Top_Tag_nlen) {
1857                     e = ASN1_OVERFLOW;
1858                     goto fail;
1859                 }
1860                 Top_Tag_olen = Top_Tag_nlen;
1861                 Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
1862                 if (Top_Tag_tmp == NULL) {
1863                     e = ENOMEM;
1864                     goto fail;
1865                 }
1866                 (data)->val = Top_Tag_tmp;
1867                 e = decode_Principal(p, len, &(data)->val[(data)->len], &l);
1868                 if (e)
1869                     goto fail;
1870                 p += l;
1871                 len -= l;
1872                 ret += l;
1873                 (data)->len++;
1874                 len = Top_Tag_origlen - ret;
1875             }
1876             ret += Top_Tag_oldret;
1877         }
1878         len = Top_oldlen - Top_datalen;
1879     }
1880     if (size)
1881         *size = ret;
1882     return 0;
1883   fail:
1884     free_Principals(data);
1885     return e;
1886 }
1887
1888 void ASN1CALL
1889 free_Principals(Principals * data)
1890 {
1891     while ((data)->len) {
1892         free_Principal(&(data)->val[(data)->len - 1]);
1893         (data)->len--;
1894     }
1895     free((data)->val);
1896     (data)->val = NULL;
1897 }
1898
1899 size_t ASN1CALL
1900 length_Principals(const Principals * data)
1901 {
1902     size_t ret = 0;
1903     {
1904         size_t Top_tag_oldret = ret;
1905         unsigned int n_Top_tag;
1906         ret = 0;
1907         for (n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag) {
1908             size_t Top_tag_for_oldret = ret;
1909             ret = 0;
1910             ret += length_Principal(&(data)->val[n_Top_tag - 1]);
1911             ret += Top_tag_for_oldret;
1912         }
1913         ret += Top_tag_oldret;
1914     }
1915     ret += 1 + der_length_len(ret);
1916     return ret;
1917 }
1918
1919 int ASN1CALL
1920 copy_Principals(const Principals * from, Principals * to)
1921 {
1922     memset(to, 0, sizeof(*to));
1923     if (((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL
1924         && (from)->len != 0)
1925         goto fail;
1926     for ((to)->len = 0; (to)->len < (from)->len; (to)->len++) {
1927         if (copy_Principal(&(from)->val[(to)->len], &(to)->val[(to)->len]))
1928             goto fail;
1929     }
1930     return 0;
1931   fail:
1932     free_Principals(to);
1933     return ENOMEM;
1934 }
1935
1936 int ASN1CALL
1937 add_Principals(Principals * data, const Principal * element)
1938 {
1939     int ret;
1940     void *ptr;
1941
1942     ptr = realloc(data->val, (data->len + 1) * sizeof(data->val[0]));
1943     if (ptr == NULL)
1944         return ENOMEM;
1945     data->val = ptr;
1946
1947     ret = copy_Principal(element, &data->val[data->len]);
1948     if (ret)
1949         return ret;
1950     data->len++;
1951     return 0;
1952 }
1953
1954 int ASN1CALL
1955 remove_Principals(Principals * data, unsigned int element)
1956 {
1957     void *ptr;
1958
1959     if (data->len == 0 || element >= data->len)
1960         return ASN1_OVERRUN;
1961     free_Principal(&data->val[element]);
1962     data->len--;
1963     if (element < data->len)
1964         memmove(&data->val[element], &data->val[element + 1],
1965                 sizeof(data->val[0]) * (data->len - element));
1966     ptr = realloc(data->val, data->len * sizeof(data->val[0]));
1967     if (ptr != NULL || data->len == 0)
1968         data->val = ptr;
1969     return 0;
1970 }
1971
1972 int ASN1CALL
1973 encode_HostAddress(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
1974                    size_t len HEIMDAL_UNUSED_ATTRIBUTE,
1975                    const HostAddress * data, size_t * size)
1976 {
1977     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
1978     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
1979     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
1980
1981 /* address */
1982     {
1983         size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
1984         ret = 0;
1985         e = der_put_octet_string(p, len, &(data)->address, &l);
1986         if (e)
1987             return e;
1988         p -= l;
1989         len -= l;
1990         ret += l;
1991
1992         e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM,
1993                                    UT_OctetString, &l);
1994         if (e)
1995             return e;
1996         p -= l;
1997         len -= l;
1998         ret += l;
1999
2000         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
2001         if (e)
2002             return e;
2003         p -= l;
2004         len -= l;
2005         ret += l;
2006
2007         ret += Top_tag_oldret;
2008     }
2009 /* addr-type */
2010     {
2011         size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2012         ret = 0;
2013         e = encode_krb5int32(p, len, &(data)->addr_type, &l);
2014         if (e)
2015             return e;
2016         p -= l;
2017         len -= l;
2018         ret += l;
2019
2020         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
2021         if (e)
2022             return e;
2023         p -= l;
2024         len -= l;
2025         ret += l;
2026
2027         ret += Top_tag_oldret;
2028     }
2029     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence,
2030                                &l);
2031     if (e)
2032         return e;
2033     p -= l;
2034     len -= l;
2035     ret += l;
2036
2037     *size = ret;
2038     return 0;
2039 }
2040
2041 int ASN1CALL
2042 decode_HostAddress(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
2043                    size_t len HEIMDAL_UNUSED_ATTRIBUTE, HostAddress * data,
2044                    size_t * size)
2045 {
2046     size_t ret = 0;
2047     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2048     int e HEIMDAL_UNUSED_ATTRIBUTE;
2049
2050     memset(data, 0, sizeof(*data));
2051     {
2052         size_t Top_datalen, Top_oldlen;
2053         Der_type Top_type;
2054         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
2055                                      UT_Sequence, &Top_datalen, &l);
2056         if (e == 0 && Top_type != CONS) {
2057             e = ASN1_BAD_ID;
2058         }
2059         if (e)
2060             goto fail;
2061         p += l;
2062         len -= l;
2063         ret += l;
2064         Top_oldlen = len;
2065         if (Top_datalen > len) {
2066             e = ASN1_OVERRUN;
2067             goto fail;
2068         }
2069         len = Top_datalen;
2070         {
2071             size_t addr_type_datalen, addr_type_oldlen;
2072             Der_type addr_type_type;
2073             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT,
2074                                          &addr_type_type, 0,
2075                                          &addr_type_datalen, &l);
2076             if (e == 0 && addr_type_type != CONS) {
2077                 e = ASN1_BAD_ID;
2078             }
2079             if (e)
2080                 goto fail;
2081             p += l;
2082             len -= l;
2083             ret += l;
2084             addr_type_oldlen = len;
2085             if (addr_type_datalen > len) {
2086                 e = ASN1_OVERRUN;
2087                 goto fail;
2088             }
2089             len = addr_type_datalen;
2090             e = decode_krb5int32(p, len, &(data)->addr_type, &l);
2091             if (e)
2092                 goto fail;
2093             p += l;
2094             len -= l;
2095             ret += l;
2096             len = addr_type_oldlen - addr_type_datalen;
2097         }
2098         {
2099             size_t address_datalen, address_oldlen;
2100             Der_type address_type;
2101             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT,
2102                                          &address_type, 1, &address_datalen,
2103                                          &l);
2104             if (e == 0 && address_type != CONS) {
2105                 e = ASN1_BAD_ID;
2106             }
2107             if (e)
2108                 goto fail;
2109             p += l;
2110             len -= l;
2111             ret += l;
2112             address_oldlen = len;
2113             if (address_datalen > len) {
2114                 e = ASN1_OVERRUN;
2115                 goto fail;
2116             }
2117             len = address_datalen;
2118             {
2119                 size_t address_Tag_datalen, address_Tag_oldlen;
2120                 Der_type address_Tag_type;
2121                 e = der_match_tag_and_length(p, len, ASN1_C_UNIV,
2122                                              &address_Tag_type,
2123                                              UT_OctetString,
2124                                              &address_Tag_datalen, &l);
2125                 if (e == 0 && address_Tag_type != PRIM) {
2126                     e = ASN1_BAD_ID;
2127                 }
2128                 if (e)
2129                     goto fail;
2130                 p += l;
2131                 len -= l;
2132                 ret += l;
2133                 address_Tag_oldlen = len;
2134                 if (address_Tag_datalen > len) {
2135                     e = ASN1_OVERRUN;
2136                     goto fail;
2137                 }
2138                 len = address_Tag_datalen;
2139                 e = der_get_octet_string(p, len, &(data)->address, &l);
2140                 if (e)
2141                     goto fail;
2142                 p += l;
2143                 len -= l;
2144                 ret += l;
2145                 len = address_Tag_oldlen - address_Tag_datalen;
2146             }
2147             len = address_oldlen - address_datalen;
2148         }
2149         len = Top_oldlen - Top_datalen;
2150     }
2151     if (size)
2152         *size = ret;
2153     return 0;
2154   fail:
2155     free_HostAddress(data);
2156     return e;
2157 }
2158
2159 void ASN1CALL
2160 free_HostAddress(HostAddress * data)
2161 {
2162     free_krb5int32(&(data)->addr_type);
2163     der_free_octet_string(&(data)->address);
2164 }
2165
2166 size_t ASN1CALL
2167 length_HostAddress(const HostAddress * data)
2168 {
2169     size_t ret = 0;
2170     {
2171         size_t Top_tag_oldret = ret;
2172         ret = 0;
2173         ret += length_krb5int32(&(data)->addr_type);
2174         ret += 1 + der_length_len(ret);
2175         ret += Top_tag_oldret;
2176     }
2177     {
2178         size_t Top_tag_oldret = ret;
2179         ret = 0;
2180         ret += der_length_octet_string(&(data)->address);
2181         ret += 1 + der_length_len(ret);
2182         ret += 1 + der_length_len(ret);
2183         ret += Top_tag_oldret;
2184     }
2185     ret += 1 + der_length_len(ret);
2186     return ret;
2187 }
2188
2189 int ASN1CALL
2190 copy_HostAddress(const HostAddress * from, HostAddress * to)
2191 {
2192     memset(to, 0, sizeof(*to));
2193     if (copy_krb5int32(&(from)->addr_type, &(to)->addr_type))
2194         goto fail;
2195     if (der_copy_octet_string(&(from)->address, &(to)->address))
2196         goto fail;
2197     return 0;
2198   fail:
2199     free_HostAddress(to);
2200     return ENOMEM;
2201 }
2202
2203 int ASN1CALL
2204 encode_HostAddresses(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
2205                      size_t len HEIMDAL_UNUSED_ATTRIBUTE,
2206                      const HostAddresses * data, size_t * size)
2207 {
2208     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2209     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2210     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2211
2212     for (i = (int) (data)->len - 1; i >= 0; --i) {
2213         size_t Top_tag_for_oldret = ret;
2214         ret = 0;
2215         e = encode_HostAddress(p, len, &(data)->val[i], &l);
2216         if (e)
2217             return e;
2218         p -= l;
2219         len -= l;
2220         ret += l;
2221
2222         ret += Top_tag_for_oldret;
2223     }
2224     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence,
2225                                &l);
2226     if (e)
2227         return e;
2228     p -= l;
2229     len -= l;
2230     ret += l;
2231
2232     *size = ret;
2233     return 0;
2234 }
2235
2236 int ASN1CALL
2237 decode_HostAddresses(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
2238                      size_t len HEIMDAL_UNUSED_ATTRIBUTE,
2239                      HostAddresses * data, size_t * size)
2240 {
2241     size_t ret = 0;
2242     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2243     int e HEIMDAL_UNUSED_ATTRIBUTE;
2244
2245     memset(data, 0, sizeof(*data));
2246     {
2247         size_t Top_datalen, Top_oldlen;
2248         Der_type Top_type;
2249         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
2250                                      UT_Sequence, &Top_datalen, &l);
2251         if (e == 0 && Top_type != CONS) {
2252             e = ASN1_BAD_ID;
2253         }
2254         if (e)
2255             goto fail;
2256         p += l;
2257         len -= l;
2258         ret += l;
2259         Top_oldlen = len;
2260         if (Top_datalen > len) {
2261             e = ASN1_OVERRUN;
2262             goto fail;
2263         }
2264         len = Top_datalen;
2265         {
2266             size_t Top_Tag_origlen = len;
2267             size_t Top_Tag_oldret = ret;
2268             size_t Top_Tag_olen = 0;
2269             void *Top_Tag_tmp;
2270             ret = 0;
2271             (data)->len = 0;
2272             (data)->val = NULL;
2273             while (ret < Top_Tag_origlen) {
2274                 size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
2275                 if (Top_Tag_olen > Top_Tag_nlen) {
2276                     e = ASN1_OVERFLOW;
2277                     goto fail;
2278                 }
2279                 Top_Tag_olen = Top_Tag_nlen;
2280                 Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
2281                 if (Top_Tag_tmp == NULL) {
2282                     e = ENOMEM;
2283                     goto fail;
2284                 }
2285                 (data)->val = Top_Tag_tmp;
2286                 e = decode_HostAddress(p, len, &(data)->val[(data)->len], &l);
2287                 if (e)
2288                     goto fail;
2289                 p += l;
2290                 len -= l;
2291                 ret += l;
2292                 (data)->len++;
2293                 len = Top_Tag_origlen - ret;
2294             }
2295             ret += Top_Tag_oldret;
2296         }
2297         len = Top_oldlen - Top_datalen;
2298     }
2299     if (size)
2300         *size = ret;
2301     return 0;
2302   fail:
2303     free_HostAddresses(data);
2304     return e;
2305 }
2306
2307 void ASN1CALL
2308 free_HostAddresses(HostAddresses * data)
2309 {
2310     while ((data)->len) {
2311         free_HostAddress(&(data)->val[(data)->len - 1]);
2312         (data)->len--;
2313     }
2314     free((data)->val);
2315     (data)->val = NULL;
2316 }
2317
2318 size_t ASN1CALL
2319 length_HostAddresses(const HostAddresses * data)
2320 {
2321     size_t ret = 0;
2322     {
2323         size_t Top_tag_oldret = ret;
2324         unsigned int n_Top_tag;
2325         ret = 0;
2326         for (n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag) {
2327             size_t Top_tag_for_oldret = ret;
2328             ret = 0;
2329             ret += length_HostAddress(&(data)->val[n_Top_tag - 1]);
2330             ret += Top_tag_for_oldret;
2331         }
2332         ret += Top_tag_oldret;
2333     }
2334     ret += 1 + der_length_len(ret);
2335     return ret;
2336 }
2337
2338 int ASN1CALL
2339 copy_HostAddresses(const HostAddresses * from, HostAddresses * to)
2340 {
2341     memset(to, 0, sizeof(*to));
2342     if (((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL
2343         && (from)->len != 0)
2344         goto fail;
2345     for ((to)->len = 0; (to)->len < (from)->len; (to)->len++) {
2346         if (copy_HostAddress(&(from)->val[(to)->len], &(to)->val[(to)->len]))
2347             goto fail;
2348     }
2349     return 0;
2350   fail:
2351     free_HostAddresses(to);
2352     return ENOMEM;
2353 }
2354
2355 int ASN1CALL
2356 encode_KerberosTime(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
2357                     size_t len HEIMDAL_UNUSED_ATTRIBUTE,
2358                     const KerberosTime * data, size_t * size)
2359 {
2360     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2361     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2362     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2363
2364     e = der_put_generalized_time(p, len, data, &l);
2365     if (e)
2366         return e;
2367     p -= l;
2368     len -= l;
2369     ret += l;
2370
2371     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM,
2372                                UT_GeneralizedTime, &l);
2373     if (e)
2374         return e;
2375     p -= l;
2376     len -= l;
2377     ret += l;
2378
2379     *size = ret;
2380     return 0;
2381 }
2382
2383 int ASN1CALL
2384 decode_KerberosTime(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
2385                     size_t len HEIMDAL_UNUSED_ATTRIBUTE, KerberosTime * data,
2386                     size_t * size)
2387 {
2388     size_t ret = 0;
2389     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2390     int e HEIMDAL_UNUSED_ATTRIBUTE;
2391
2392     memset(data, 0, sizeof(*data));
2393     {
2394         size_t Top_datalen, Top_oldlen;
2395         Der_type Top_type;
2396         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
2397                                      UT_GeneralizedTime, &Top_datalen, &l);
2398         if (e == 0 && Top_type != PRIM) {
2399             e = ASN1_BAD_ID;
2400         }
2401         if (e)
2402             goto fail;
2403         p += l;
2404         len -= l;
2405         ret += l;
2406         Top_oldlen = len;
2407         if (Top_datalen > len) {
2408             e = ASN1_OVERRUN;
2409             goto fail;
2410         }
2411         len = Top_datalen;
2412         e = der_get_generalized_time(p, len, data, &l);
2413         if (e)
2414             goto fail;
2415         p += l;
2416         len -= l;
2417         ret += l;
2418         len = Top_oldlen - Top_datalen;
2419     }
2420     if (size)
2421         *size = ret;
2422     return 0;
2423   fail:
2424     free_KerberosTime(data);
2425     return e;
2426 }
2427
2428 void ASN1CALL
2429 free_KerberosTime(KerberosTime * data)
2430 {
2431 }
2432
2433 size_t ASN1CALL
2434 length_KerberosTime(const KerberosTime * data)
2435 {
2436     size_t ret = 0;
2437     ret += der_length_generalized_time(data);
2438     ret += 1 + der_length_len(ret);
2439     return ret;
2440 }
2441
2442 int ASN1CALL
2443 copy_KerberosTime(const KerberosTime * from, KerberosTime * to)
2444 {
2445     memset(to, 0, sizeof(*to));
2446     *(to) = *(from);
2447     return 0;
2448 }
2449
2450 int ASN1CALL
2451 encode_AuthorizationDataElement(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
2452                                 size_t len HEIMDAL_UNUSED_ATTRIBUTE,
2453                                 const AuthorizationDataElement * data,
2454                                 size_t * size)
2455 {
2456     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2457     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2458     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2459
2460 /* ad-data */
2461     {
2462         size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2463         ret = 0;
2464         e = der_put_octet_string(p, len, &(data)->ad_data, &l);
2465         if (e)
2466             return e;
2467         p -= l;
2468         len -= l;
2469         ret += l;
2470
2471         e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM,
2472                                    UT_OctetString, &l);
2473         if (e)
2474             return e;
2475         p -= l;
2476         len -= l;
2477         ret += l;
2478
2479         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1, &l);
2480         if (e)
2481             return e;
2482         p -= l;
2483         len -= l;
2484         ret += l;
2485
2486         ret += Top_tag_oldret;
2487     }
2488 /* ad-type */
2489     {
2490         size_t Top_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
2491         ret = 0;
2492         e = encode_krb5int32(p, len, &(data)->ad_type, &l);
2493         if (e)
2494             return e;
2495         p -= l;
2496         len -= l;
2497         ret += l;
2498
2499         e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 0, &l);
2500         if (e)
2501             return e;
2502         p -= l;
2503         len -= l;
2504         ret += l;
2505
2506         ret += Top_tag_oldret;
2507     }
2508     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence,
2509                                &l);
2510     if (e)
2511         return e;
2512     p -= l;
2513     len -= l;
2514     ret += l;
2515
2516     *size = ret;
2517     return 0;
2518 }
2519
2520 int ASN1CALL
2521 decode_AuthorizationDataElement(const unsigned char *p
2522                                 HEIMDAL_UNUSED_ATTRIBUTE,
2523                                 size_t len HEIMDAL_UNUSED_ATTRIBUTE,
2524                                 AuthorizationDataElement * data,
2525                                 size_t * size)
2526 {
2527     size_t ret = 0;
2528     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2529     int e HEIMDAL_UNUSED_ATTRIBUTE;
2530
2531     memset(data, 0, sizeof(*data));
2532     {
2533         size_t Top_datalen, Top_oldlen;
2534         Der_type Top_type;
2535         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
2536                                      UT_Sequence, &Top_datalen, &l);
2537         if (e == 0 && Top_type != CONS) {
2538             e = ASN1_BAD_ID;
2539         }
2540         if (e)
2541             goto fail;
2542         p += l;
2543         len -= l;
2544         ret += l;
2545         Top_oldlen = len;
2546         if (Top_datalen > len) {
2547             e = ASN1_OVERRUN;
2548             goto fail;
2549         }
2550         len = Top_datalen;
2551         {
2552             size_t ad_type_datalen, ad_type_oldlen;
2553             Der_type ad_type_type;
2554             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT,
2555                                          &ad_type_type, 0, &ad_type_datalen,
2556                                          &l);
2557             if (e == 0 && ad_type_type != CONS) {
2558                 e = ASN1_BAD_ID;
2559             }
2560             if (e)
2561                 goto fail;
2562             p += l;
2563             len -= l;
2564             ret += l;
2565             ad_type_oldlen = len;
2566             if (ad_type_datalen > len) {
2567                 e = ASN1_OVERRUN;
2568                 goto fail;
2569             }
2570             len = ad_type_datalen;
2571             e = decode_krb5int32(p, len, &(data)->ad_type, &l);
2572             if (e)
2573                 goto fail;
2574             p += l;
2575             len -= l;
2576             ret += l;
2577             len = ad_type_oldlen - ad_type_datalen;
2578         }
2579         {
2580             size_t ad_data_datalen, ad_data_oldlen;
2581             Der_type ad_data_type;
2582             e = der_match_tag_and_length(p, len, ASN1_C_CONTEXT,
2583                                          &ad_data_type, 1, &ad_data_datalen,
2584                                          &l);
2585             if (e == 0 && ad_data_type != CONS) {
2586                 e = ASN1_BAD_ID;
2587             }
2588             if (e)
2589                 goto fail;
2590             p += l;
2591             len -= l;
2592             ret += l;
2593             ad_data_oldlen = len;
2594             if (ad_data_datalen > len) {
2595                 e = ASN1_OVERRUN;
2596                 goto fail;
2597             }
2598             len = ad_data_datalen;
2599             {
2600                 size_t ad_data_Tag_datalen, ad_data_Tag_oldlen;
2601                 Der_type ad_data_Tag_type;
2602                 e = der_match_tag_and_length(p, len, ASN1_C_UNIV,
2603                                              &ad_data_Tag_type,
2604                                              UT_OctetString,
2605                                              &ad_data_Tag_datalen, &l);
2606                 if (e == 0 && ad_data_Tag_type != PRIM) {
2607                     e = ASN1_BAD_ID;
2608                 }
2609                 if (e)
2610                     goto fail;
2611                 p += l;
2612                 len -= l;
2613                 ret += l;
2614                 ad_data_Tag_oldlen = len;
2615                 if (ad_data_Tag_datalen > len) {
2616                     e = ASN1_OVERRUN;
2617                     goto fail;
2618                 }
2619                 len = ad_data_Tag_datalen;
2620                 e = der_get_octet_string(p, len, &(data)->ad_data, &l);
2621                 if (e)
2622                     goto fail;
2623                 p += l;
2624                 len -= l;
2625                 ret += l;
2626                 len = ad_data_Tag_oldlen - ad_data_Tag_datalen;
2627             }
2628             len = ad_data_oldlen - ad_data_datalen;
2629         }
2630         len = Top_oldlen - Top_datalen;
2631     }
2632     if (size)
2633         *size = ret;
2634     return 0;
2635   fail:
2636     free_AuthorizationDataElement(data);
2637     return e;
2638 }
2639
2640 void ASN1CALL
2641 free_AuthorizationDataElement(AuthorizationDataElement * data)
2642 {
2643     free_krb5int32(&(data)->ad_type);
2644     der_free_octet_string(&(data)->ad_data);
2645 }
2646
2647 size_t ASN1CALL
2648 length_AuthorizationDataElement(const AuthorizationDataElement * data)
2649 {
2650     size_t ret = 0;
2651     {
2652         size_t Top_tag_oldret = ret;
2653         ret = 0;
2654         ret += length_krb5int32(&(data)->ad_type);
2655         ret += 1 + der_length_len(ret);
2656         ret += Top_tag_oldret;
2657     }
2658     {
2659         size_t Top_tag_oldret = ret;
2660         ret = 0;
2661         ret += der_length_octet_string(&(data)->ad_data);
2662         ret += 1 + der_length_len(ret);
2663         ret += 1 + der_length_len(ret);
2664         ret += Top_tag_oldret;
2665     }
2666     ret += 1 + der_length_len(ret);
2667     return ret;
2668 }
2669
2670 int ASN1CALL
2671 copy_AuthorizationDataElement(const AuthorizationDataElement * from,
2672                               AuthorizationDataElement * to)
2673 {
2674     memset(to, 0, sizeof(*to));
2675     if (copy_krb5int32(&(from)->ad_type, &(to)->ad_type))
2676         goto fail;
2677     if (der_copy_octet_string(&(from)->ad_data, &(to)->ad_data))
2678         goto fail;
2679     return 0;
2680   fail:
2681     free_AuthorizationDataElement(to);
2682     return ENOMEM;
2683 }
2684
2685 int ASN1CALL
2686 encode_AuthorizationData(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
2687                          size_t len HEIMDAL_UNUSED_ATTRIBUTE,
2688                          const AuthorizationData * data, size_t * size)
2689 {
2690     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2691     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2692     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2693
2694     for (i = (int) (data)->len - 1; i >= 0; --i) {
2695         size_t Top_tag_for_oldret = ret;
2696         ret = 0;
2697         e = encode_AuthorizationDataElement(p, len, &(data)->val[i], &l);
2698         if (e)
2699             return e;
2700         p -= l;
2701         len -= l;
2702         ret += l;
2703
2704         ret += Top_tag_for_oldret;
2705     }
2706     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, CONS, UT_Sequence,
2707                                &l);
2708     if (e)
2709         return e;
2710     p -= l;
2711     len -= l;
2712     ret += l;
2713
2714     *size = ret;
2715     return 0;
2716 }
2717
2718 int ASN1CALL
2719 decode_AuthorizationData(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
2720                          size_t len HEIMDAL_UNUSED_ATTRIBUTE,
2721                          AuthorizationData * data, size_t * size)
2722 {
2723     size_t ret = 0;
2724     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2725     int e HEIMDAL_UNUSED_ATTRIBUTE;
2726
2727     memset(data, 0, sizeof(*data));
2728     {
2729         size_t Top_datalen, Top_oldlen;
2730         Der_type Top_type;
2731         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
2732                                      UT_Sequence, &Top_datalen, &l);
2733         if (e == 0 && Top_type != CONS) {
2734             e = ASN1_BAD_ID;
2735         }
2736         if (e)
2737             goto fail;
2738         p += l;
2739         len -= l;
2740         ret += l;
2741         Top_oldlen = len;
2742         if (Top_datalen > len) {
2743             e = ASN1_OVERRUN;
2744             goto fail;
2745         }
2746         len = Top_datalen;
2747         {
2748             size_t Top_Tag_origlen = len;
2749             size_t Top_Tag_oldret = ret;
2750             size_t Top_Tag_olen = 0;
2751             void *Top_Tag_tmp;
2752             ret = 0;
2753             (data)->len = 0;
2754             (data)->val = NULL;
2755             while (ret < Top_Tag_origlen) {
2756                 size_t Top_Tag_nlen = Top_Tag_olen + sizeof(*((data)->val));
2757                 if (Top_Tag_olen > Top_Tag_nlen) {
2758                     e = ASN1_OVERFLOW;
2759                     goto fail;
2760                 }
2761                 Top_Tag_olen = Top_Tag_nlen;
2762                 Top_Tag_tmp = realloc((data)->val, Top_Tag_olen);
2763                 if (Top_Tag_tmp == NULL) {
2764                     e = ENOMEM;
2765                     goto fail;
2766                 }
2767                 (data)->val = Top_Tag_tmp;
2768                 e = decode_AuthorizationDataElement(p, len,
2769                                                     &(data)->val[(data)->len],
2770                                                     &l);
2771                 if (e)
2772                     goto fail;
2773                 p += l;
2774                 len -= l;
2775                 ret += l;
2776                 (data)->len++;
2777                 len = Top_Tag_origlen - ret;
2778             }
2779             ret += Top_Tag_oldret;
2780         }
2781         len = Top_oldlen - Top_datalen;
2782     }
2783     if (size)
2784         *size = ret;
2785     return 0;
2786   fail:
2787     free_AuthorizationData(data);
2788     return e;
2789 }
2790
2791 void ASN1CALL
2792 free_AuthorizationData(AuthorizationData * data)
2793 {
2794     while ((data)->len) {
2795         free_AuthorizationDataElement(&(data)->val[(data)->len - 1]);
2796         (data)->len--;
2797     }
2798     free((data)->val);
2799     (data)->val = NULL;
2800 }
2801
2802 size_t ASN1CALL
2803 length_AuthorizationData(const AuthorizationData * data)
2804 {
2805     size_t ret = 0;
2806     {
2807         size_t Top_tag_oldret = ret;
2808         unsigned int n_Top_tag;
2809         ret = 0;
2810         for (n_Top_tag = (data)->len; n_Top_tag > 0; --n_Top_tag) {
2811             size_t Top_tag_for_oldret = ret;
2812             ret = 0;
2813             ret +=
2814                 length_AuthorizationDataElement(&(data)->val[n_Top_tag - 1]);
2815             ret += Top_tag_for_oldret;
2816         }
2817         ret += Top_tag_oldret;
2818     }
2819     ret += 1 + der_length_len(ret);
2820     return ret;
2821 }
2822
2823 int ASN1CALL
2824 copy_AuthorizationData(const AuthorizationData * from, AuthorizationData * to)
2825 {
2826     memset(to, 0, sizeof(*to));
2827     if (((to)->val = malloc((from)->len * sizeof(*(to)->val))) == NULL
2828         && (from)->len != 0)
2829         goto fail;
2830     for ((to)->len = 0; (to)->len < (from)->len; (to)->len++) {
2831         if (copy_AuthorizationDataElement
2832             (&(from)->val[(to)->len], &(to)->val[(to)->len]))
2833             goto fail;
2834     }
2835     return 0;
2836   fail:
2837     free_AuthorizationData(to);
2838     return ENOMEM;
2839 }
2840
2841 int ASN1CALL
2842 add_AuthorizationData(AuthorizationData * data,
2843                       const AuthorizationDataElement * element)
2844 {
2845     int ret;
2846     void *ptr;
2847
2848     ptr = realloc(data->val, (data->len + 1) * sizeof(data->val[0]));
2849     if (ptr == NULL)
2850         return ENOMEM;
2851     data->val = ptr;
2852
2853     ret = copy_AuthorizationDataElement(element, &data->val[data->len]);
2854     if (ret)
2855         return ret;
2856     data->len++;
2857     return 0;
2858 }
2859
2860 int ASN1CALL
2861 remove_AuthorizationData(AuthorizationData * data, unsigned int element)
2862 {
2863     void *ptr;
2864
2865     if (data->len == 0 || element >= data->len)
2866         return ASN1_OVERRUN;
2867     free_AuthorizationDataElement(&data->val[element]);
2868     data->len--;
2869     if (element < data->len)
2870         memmove(&data->val[element], &data->val[element + 1],
2871                 sizeof(data->val[0]) * (data->len - element));
2872     ptr = realloc(data->val, data->len * sizeof(data->val[0]));
2873     if (ptr != NULL || data->len == 0)
2874         data->val = ptr;
2875     return 0;
2876 }
2877
2878 int ASN1CALL
2879 encode_APOptions(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
2880                  size_t len HEIMDAL_UNUSED_ATTRIBUTE, const APOptions * data,
2881                  size_t * size)
2882 {
2883     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
2884     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2885     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
2886
2887     {
2888         unsigned char c = 0;
2889         if (len < 1)
2890             return ASN1_OVERFLOW;
2891         *p-- = c;
2892         len--;
2893         ret++;
2894         c = 0;
2895         if (len < 1)
2896             return ASN1_OVERFLOW;
2897         *p-- = c;
2898         len--;
2899         ret++;
2900         c = 0;
2901         if (len < 1)
2902             return ASN1_OVERFLOW;
2903         *p-- = c;
2904         len--;
2905         ret++;
2906         c = 0;
2907         if ((data)->mutual_required) {
2908             c |= 1 << 5;
2909         }
2910         if ((data)->use_session_key) {
2911             c |= 1 << 6;
2912         }
2913         if ((data)->reserved) {
2914             c |= 1 << 7;
2915         }
2916         if (len < 1)
2917             return ASN1_OVERFLOW;
2918         *p-- = c;
2919         len--;
2920         ret++;
2921         if (len < 1)
2922             return ASN1_OVERFLOW;
2923         *p-- = 0;
2924         len -= 1;
2925         ret += 1;
2926     }
2927
2928     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString,
2929                                &l);
2930     if (e)
2931         return e;
2932     p -= l;
2933     len -= l;
2934     ret += l;
2935
2936     *size = ret;
2937     return 0;
2938 }
2939
2940 int ASN1CALL
2941 decode_APOptions(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
2942                  size_t len HEIMDAL_UNUSED_ATTRIBUTE, APOptions * data,
2943                  size_t * size)
2944 {
2945     size_t ret = 0;
2946     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
2947     int e HEIMDAL_UNUSED_ATTRIBUTE;
2948
2949     memset(data, 0, sizeof(*data));
2950     {
2951         size_t Top_datalen, Top_oldlen;
2952         Der_type Top_type;
2953         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
2954                                      UT_BitString, &Top_datalen, &l);
2955         if (e == 0 && Top_type != PRIM) {
2956             e = ASN1_BAD_ID;
2957         }
2958         if (e)
2959             goto fail;
2960         p += l;
2961         len -= l;
2962         ret += l;
2963         Top_oldlen = len;
2964         if (Top_datalen > len) {
2965             e = ASN1_OVERRUN;
2966             goto fail;
2967         }
2968         len = Top_datalen;
2969         if (len < 1)
2970             return ASN1_OVERRUN;
2971         p++;
2972         len--;
2973         ret++;
2974         do {
2975             if (len < 1)
2976                 break;
2977             (data)->reserved = (*p >> 7) & 1;
2978             (data)->use_session_key = (*p >> 6) & 1;
2979             (data)->mutual_required = (*p >> 5) & 1;
2980         } while (0);
2981         p += len;
2982         ret += len;
2983         len = Top_oldlen - Top_datalen;
2984     }
2985     if (size)
2986         *size = ret;
2987     return 0;
2988   fail:
2989     free_APOptions(data);
2990     return e;
2991 }
2992
2993 void ASN1CALL
2994 free_APOptions(APOptions * data)
2995 {
2996 }
2997
2998 size_t ASN1CALL
2999 length_APOptions(const APOptions * data)
3000 {
3001     size_t ret = 0;
3002     ret += 5;
3003     ret += 1 + der_length_len(ret);
3004     return ret;
3005 }
3006
3007 int ASN1CALL
3008 copy_APOptions(const APOptions * from, APOptions * to)
3009 {
3010     memset(to, 0, sizeof(*to));
3011     *(to) = *(from);
3012     return 0;
3013 }
3014
3015 unsigned
3016 APOptions2int(APOptions f)
3017 {
3018     unsigned r = 0;
3019     if (f.reserved)
3020         r |= (1U << 0);
3021     if (f.use_session_key)
3022         r |= (1U << 1);
3023     if (f.mutual_required)
3024         r |= (1U << 2);
3025     return r;
3026 }
3027
3028 APOptions
3029 int2APOptions(unsigned n)
3030 {
3031     APOptions flags;
3032
3033     memset(&flags, 0, sizeof(flags));
3034
3035     flags.reserved = (n >> 0) & 1;
3036     flags.use_session_key = (n >> 1) & 1;
3037     flags.mutual_required = (n >> 2) & 1;
3038     return flags;
3039 }
3040
3041
3042
3043 int ASN1CALL
3044 encode_TicketFlags(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
3045                    size_t len HEIMDAL_UNUSED_ATTRIBUTE,
3046                    const TicketFlags * data, size_t * size)
3047 {
3048     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3049     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3050     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3051
3052     {
3053         unsigned char c = 0;
3054         if (len < 1)
3055             return ASN1_OVERFLOW;
3056         *p-- = c;
3057         len--;
3058         ret++;
3059         c = 0;
3060         if ((data)->anonymous) {
3061             c |= 1 << 7;
3062         }
3063         if (len < 1)
3064             return ASN1_OVERFLOW;
3065         *p-- = c;
3066         len--;
3067         ret++;
3068         c = 0;
3069         if ((data)->enc_pa_rep) {
3070             c |= 1 << 0;
3071         }
3072         if ((data)->ok_as_delegate) {
3073             c |= 1 << 2;
3074         }
3075         if ((data)->transited_policy_checked) {
3076             c |= 1 << 3;
3077         }
3078         if ((data)->hw_authent) {
3079             c |= 1 << 4;
3080         }
3081         if ((data)->pre_authent) {
3082             c |= 1 << 5;
3083         }
3084         if ((data)->initial) {
3085             c |= 1 << 6;
3086         }
3087         if ((data)->renewable) {
3088             c |= 1 << 7;
3089         }
3090         if (len < 1)
3091             return ASN1_OVERFLOW;
3092         *p-- = c;
3093         len--;
3094         ret++;
3095         c = 0;
3096         if ((data)->invalid) {
3097             c |= 1 << 0;
3098         }
3099         if ((data)->postdated) {
3100             c |= 1 << 1;
3101         }
3102         if ((data)->may_postdate) {
3103             c |= 1 << 2;
3104         }
3105         if ((data)->proxy) {
3106             c |= 1 << 3;
3107         }
3108         if ((data)->proxiable) {
3109             c |= 1 << 4;
3110         }
3111         if ((data)->forwarded) {
3112             c |= 1 << 5;
3113         }
3114         if ((data)->forwardable) {
3115             c |= 1 << 6;
3116         }
3117         if ((data)->reserved) {
3118             c |= 1 << 7;
3119         }
3120         if (len < 1)
3121             return ASN1_OVERFLOW;
3122         *p-- = c;
3123         len--;
3124         ret++;
3125         if (len < 1)
3126             return ASN1_OVERFLOW;
3127         *p-- = 0;
3128         len -= 1;
3129         ret += 1;
3130     }
3131
3132     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString,
3133                                &l);
3134     if (e)
3135         return e;
3136     p -= l;
3137     len -= l;
3138     ret += l;
3139
3140     *size = ret;
3141     return 0;
3142 }
3143
3144 int ASN1CALL
3145 decode_TicketFlags(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
3146                    size_t len HEIMDAL_UNUSED_ATTRIBUTE, TicketFlags * data,
3147                    size_t * size)
3148 {
3149     size_t ret = 0;
3150     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3151     int e HEIMDAL_UNUSED_ATTRIBUTE;
3152
3153     memset(data, 0, sizeof(*data));
3154     {
3155         size_t Top_datalen, Top_oldlen;
3156         Der_type Top_type;
3157         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
3158                                      UT_BitString, &Top_datalen, &l);
3159         if (e == 0 && Top_type != PRIM) {
3160             e = ASN1_BAD_ID;
3161         }
3162         if (e)
3163             goto fail;
3164         p += l;
3165         len -= l;
3166         ret += l;
3167         Top_oldlen = len;
3168         if (Top_datalen > len) {
3169             e = ASN1_OVERRUN;
3170             goto fail;
3171         }
3172         len = Top_datalen;
3173         if (len < 1)
3174             return ASN1_OVERRUN;
3175         p++;
3176         len--;
3177         ret++;
3178         do {
3179             if (len < 1)
3180                 break;
3181             (data)->reserved = (*p >> 7) & 1;
3182             (data)->forwardable = (*p >> 6) & 1;
3183             (data)->forwarded = (*p >> 5) & 1;
3184             (data)->proxiable = (*p >> 4) & 1;
3185             (data)->proxy = (*p >> 3) & 1;
3186             (data)->may_postdate = (*p >> 2) & 1;
3187             (data)->postdated = (*p >> 1) & 1;
3188             (data)->invalid = (*p >> 0) & 1;
3189             p++;
3190             len--;
3191             ret++;
3192             if (len < 1)
3193                 break;
3194             (data)->renewable = (*p >> 7) & 1;
3195             (data)->initial = (*p >> 6) & 1;
3196             (data)->pre_authent = (*p >> 5) & 1;
3197             (data)->hw_authent = (*p >> 4) & 1;
3198             (data)->transited_policy_checked = (*p >> 3) & 1;
3199             (data)->ok_as_delegate = (*p >> 2) & 1;
3200             (data)->enc_pa_rep = (*p >> 0) & 1;
3201             p++;
3202             len--;
3203             ret++;
3204             if (len < 1)
3205                 break;
3206             (data)->anonymous = (*p >> 7) & 1;
3207         } while (0);
3208         p += len;
3209         ret += len;
3210         len = Top_oldlen - Top_datalen;
3211     }
3212     if (size)
3213         *size = ret;
3214     return 0;
3215   fail:
3216     free_TicketFlags(data);
3217     return e;
3218 }
3219
3220 void ASN1CALL
3221 free_TicketFlags(TicketFlags * data)
3222 {
3223 }
3224
3225 size_t ASN1CALL
3226 length_TicketFlags(const TicketFlags * data)
3227 {
3228     size_t ret = 0;
3229     ret += 5;
3230     ret += 1 + der_length_len(ret);
3231     return ret;
3232 }
3233
3234 int ASN1CALL
3235 copy_TicketFlags(const TicketFlags * from, TicketFlags * to)
3236 {
3237     memset(to, 0, sizeof(*to));
3238     *(to) = *(from);
3239     return 0;
3240 }
3241
3242 unsigned
3243 TicketFlags2int(TicketFlags f)
3244 {
3245     unsigned r = 0;
3246     if (f.reserved)
3247         r |= (1U << 0);
3248     if (f.forwardable)
3249         r |= (1U << 1);
3250     if (f.forwarded)
3251         r |= (1U << 2);
3252     if (f.proxiable)
3253         r |= (1U << 3);
3254     if (f.proxy)
3255         r |= (1U << 4);
3256     if (f.may_postdate)
3257         r |= (1U << 5);
3258     if (f.postdated)
3259         r |= (1U << 6);
3260     if (f.invalid)
3261         r |= (1U << 7);
3262     if (f.renewable)
3263         r |= (1U << 8);
3264     if (f.initial)
3265         r |= (1U << 9);
3266     if (f.pre_authent)
3267         r |= (1U << 10);
3268     if (f.hw_authent)
3269         r |= (1U << 11);
3270     if (f.transited_policy_checked)
3271         r |= (1U << 12);
3272     if (f.ok_as_delegate)
3273         r |= (1U << 13);
3274     if (f.enc_pa_rep)
3275         r |= (1U << 15);
3276     if (f.anonymous)
3277         r |= (1U << 16);
3278     return r;
3279 }
3280
3281 TicketFlags
3282 int2TicketFlags(unsigned n)
3283 {
3284     TicketFlags flags;
3285
3286     memset(&flags, 0, sizeof(flags));
3287
3288     flags.reserved = (n >> 0) & 1;
3289     flags.forwardable = (n >> 1) & 1;
3290     flags.forwarded = (n >> 2) & 1;
3291     flags.proxiable = (n >> 3) & 1;
3292     flags.proxy = (n >> 4) & 1;
3293     flags.may_postdate = (n >> 5) & 1;
3294     flags.postdated = (n >> 6) & 1;
3295     flags.invalid = (n >> 7) & 1;
3296     flags.renewable = (n >> 8) & 1;
3297     flags.initial = (n >> 9) & 1;
3298     flags.pre_authent = (n >> 10) & 1;
3299     flags.hw_authent = (n >> 11) & 1;
3300     flags.transited_policy_checked = (n >> 12) & 1;
3301     flags.ok_as_delegate = (n >> 13) & 1;
3302     flags.enc_pa_rep = (n >> 15) & 1;
3303     flags.anonymous = (n >> 16) & 1;
3304     return flags;
3305 }
3306
3307
3308
3309 int ASN1CALL
3310 encode_KDCOptions(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
3311                   size_t len HEIMDAL_UNUSED_ATTRIBUTE,
3312                   const KDCOptions * data, size_t * size)
3313 {
3314     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3315     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3316     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3317
3318     {
3319         unsigned char c = 0;
3320         if ((data)->validate) {
3321             c |= 1 << 0;
3322         }
3323         if ((data)->renew) {
3324             c |= 1 << 1;
3325         }
3326         if ((data)->enc_tkt_in_skey) {
3327             c |= 1 << 3;
3328         }
3329         if ((data)->renewable_ok) {
3330             c |= 1 << 4;
3331         }
3332         if ((data)->disable_transited_check) {
3333             c |= 1 << 5;
3334         }
3335         if (len < 1)
3336             return ASN1_OVERFLOW;
3337         *p-- = c;
3338         len--;
3339         ret++;
3340         c = 0;
3341         if ((data)->request_anonymous) {
3342             c |= 1 << 7;
3343         }
3344         if (len < 1)
3345             return ASN1_OVERFLOW;
3346         *p-- = c;
3347         len--;
3348         ret++;
3349         c = 0;
3350         if ((data)->canonicalize) {
3351             c |= 1 << 0;
3352         }
3353         if ((data)->cname_in_addl_tkt) {
3354             c |= 1 << 1;
3355         }
3356         if ((data)->renewable) {
3357             c |= 1 << 7;
3358         }
3359         if (len < 1)
3360             return ASN1_OVERFLOW;
3361         *p-- = c;
3362         len--;
3363         ret++;
3364         c = 0;
3365         if ((data)->postdated) {
3366             c |= 1 << 1;
3367         }
3368         if ((data)->allow_postdate) {
3369             c |= 1 << 2;
3370         }
3371         if ((data)->proxy) {
3372             c |= 1 << 3;
3373         }
3374         if ((data)->proxiable) {
3375             c |= 1 << 4;
3376         }
3377         if ((data)->forwarded) {
3378             c |= 1 << 5;
3379         }
3380         if ((data)->forwardable) {
3381             c |= 1 << 6;
3382         }
3383         if ((data)->reserved) {
3384             c |= 1 << 7;
3385         }
3386         if (len < 1)
3387             return ASN1_OVERFLOW;
3388         *p-- = c;
3389         len--;
3390         ret++;
3391         if (len < 1)
3392             return ASN1_OVERFLOW;
3393         *p-- = 0;
3394         len -= 1;
3395         ret += 1;
3396     }
3397
3398     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_BitString,
3399                                &l);
3400     if (e)
3401         return e;
3402     p -= l;
3403     len -= l;
3404     ret += l;
3405
3406     *size = ret;
3407     return 0;
3408 }
3409
3410 int ASN1CALL
3411 decode_KDCOptions(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
3412                   size_t len HEIMDAL_UNUSED_ATTRIBUTE, KDCOptions * data,
3413                   size_t * size)
3414 {
3415     size_t ret = 0;
3416     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3417     int e HEIMDAL_UNUSED_ATTRIBUTE;
3418
3419     memset(data, 0, sizeof(*data));
3420     {
3421         size_t Top_datalen, Top_oldlen;
3422         Der_type Top_type;
3423         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
3424                                      UT_BitString, &Top_datalen, &l);
3425         if (e == 0 && Top_type != PRIM) {
3426             e = ASN1_BAD_ID;
3427         }
3428         if (e)
3429             goto fail;
3430         p += l;
3431         len -= l;
3432         ret += l;
3433         Top_oldlen = len;
3434         if (Top_datalen > len) {
3435             e = ASN1_OVERRUN;
3436             goto fail;
3437         }
3438         len = Top_datalen;
3439         if (len < 1)
3440             return ASN1_OVERRUN;
3441         p++;
3442         len--;
3443         ret++;
3444         do {
3445             if (len < 1)
3446                 break;
3447             (data)->reserved = (*p >> 7) & 1;
3448             (data)->forwardable = (*p >> 6) & 1;
3449             (data)->forwarded = (*p >> 5) & 1;
3450             (data)->proxiable = (*p >> 4) & 1;
3451             (data)->proxy = (*p >> 3) & 1;
3452             (data)->allow_postdate = (*p >> 2) & 1;
3453             (data)->postdated = (*p >> 1) & 1;
3454             p++;
3455             len--;
3456             ret++;
3457             if (len < 1)
3458                 break;
3459             (data)->renewable = (*p >> 7) & 1;
3460             (data)->cname_in_addl_tkt = (*p >> 1) & 1;
3461             (data)->canonicalize = (*p >> 0) & 1;
3462             p++;
3463             len--;
3464             ret++;
3465             if (len < 1)
3466                 break;
3467             (data)->request_anonymous = (*p >> 7) & 1;
3468             p++;
3469             len--;
3470             ret++;
3471             if (len < 1)
3472                 break;
3473             (data)->disable_transited_check = (*p >> 5) & 1;
3474             (data)->renewable_ok = (*p >> 4) & 1;
3475             (data)->enc_tkt_in_skey = (*p >> 3) & 1;
3476             (data)->renew = (*p >> 1) & 1;
3477             (data)->validate = (*p >> 0) & 1;
3478         } while (0);
3479         p += len;
3480         ret += len;
3481         len = Top_oldlen - Top_datalen;
3482     }
3483     if (size)
3484         *size = ret;
3485     return 0;
3486   fail:
3487     free_KDCOptions(data);
3488     return e;
3489 }
3490
3491 void ASN1CALL
3492 free_KDCOptions(KDCOptions * data)
3493 {
3494 }
3495
3496 size_t ASN1CALL
3497 length_KDCOptions(const KDCOptions * data)
3498 {
3499     size_t ret = 0;
3500     ret += 5;
3501     ret += 1 + der_length_len(ret);
3502     return ret;
3503 }
3504
3505 int ASN1CALL
3506 copy_KDCOptions(const KDCOptions * from, KDCOptions * to)
3507 {
3508     memset(to, 0, sizeof(*to));
3509     *(to) = *(from);
3510     return 0;
3511 }
3512
3513 unsigned
3514 KDCOptions2int(KDCOptions f)
3515 {
3516     unsigned r = 0;
3517     if (f.reserved)
3518         r |= (1U << 0);
3519     if (f.forwardable)
3520         r |= (1U << 1);
3521     if (f.forwarded)
3522         r |= (1U << 2);
3523     if (f.proxiable)
3524         r |= (1U << 3);
3525     if (f.proxy)
3526         r |= (1U << 4);
3527     if (f.allow_postdate)
3528         r |= (1U << 5);
3529     if (f.postdated)
3530         r |= (1U << 6);
3531     if (f.renewable)
3532         r |= (1U << 8);
3533     if (f.cname_in_addl_tkt)
3534         r |= (1U << 14);
3535     if (f.canonicalize)
3536         r |= (1U << 15);
3537     if (f.request_anonymous)
3538         r |= (1U << 16);
3539     if (f.disable_transited_check)
3540         r |= (1U << 26);
3541     if (f.renewable_ok)
3542         r |= (1U << 27);
3543     if (f.enc_tkt_in_skey)
3544         r |= (1U << 28);
3545     if (f.renew)
3546         r |= (1U << 30);
3547     if (f.validate)
3548         r |= (1U << 31);
3549     return r;
3550 }
3551
3552 KDCOptions
3553 int2KDCOptions(unsigned n)
3554 {
3555     KDCOptions flags;
3556
3557     memset(&flags, 0, sizeof(flags));
3558
3559     flags.reserved = (n >> 0) & 1;
3560     flags.forwardable = (n >> 1) & 1;
3561     flags.forwarded = (n >> 2) & 1;
3562     flags.proxiable = (n >> 3) & 1;
3563     flags.proxy = (n >> 4) & 1;
3564     flags.allow_postdate = (n >> 5) & 1;
3565     flags.postdated = (n >> 6) & 1;
3566     flags.renewable = (n >> 8) & 1;
3567     flags.cname_in_addl_tkt = (n >> 14) & 1;
3568     flags.canonicalize = (n >> 15) & 1;
3569     flags.request_anonymous = (n >> 16) & 1;
3570     flags.disable_transited_check = (n >> 26) & 1;
3571     flags.renewable_ok = (n >> 27) & 1;
3572     flags.enc_tkt_in_skey = (n >> 28) & 1;
3573     flags.renew = (n >> 30) & 1;
3574     flags.validate = (n >> 31) & 1;
3575     return flags;
3576 }
3577
3578
3579
3580 int ASN1CALL
3581 encode_LR_TYPE(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
3582                size_t len HEIMDAL_UNUSED_ATTRIBUTE, const LR_TYPE * data,
3583                size_t * size)
3584 {
3585     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3586     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3587     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3588
3589     {
3590         int enumint = (int) *data;
3591         e = der_put_integer(p, len, &enumint, &l);
3592         if (e)
3593             return e;
3594         p -= l;
3595         len -= l;
3596         ret += l;
3597
3598     }
3599     ;
3600     e = der_put_length_and_tag(p, len, ret, ASN1_C_UNIV, PRIM, UT_Integer,
3601                                &l);
3602     if (e)
3603         return e;
3604     p -= l;
3605     len -= l;
3606     ret += l;
3607
3608     *size = ret;
3609     return 0;
3610 }
3611
3612 int ASN1CALL
3613 decode_LR_TYPE(const unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
3614                size_t len HEIMDAL_UNUSED_ATTRIBUTE, LR_TYPE * data,
3615                size_t * size)
3616 {
3617     size_t ret = 0;
3618     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3619     int e HEIMDAL_UNUSED_ATTRIBUTE;
3620
3621     memset(data, 0, sizeof(*data));
3622     {
3623         size_t Top_datalen, Top_oldlen;
3624         Der_type Top_type;
3625         e = der_match_tag_and_length(p, len, ASN1_C_UNIV, &Top_type,
3626                                      UT_Integer, &Top_datalen, &l);
3627         if (e == 0 && Top_type != PRIM) {
3628             e = ASN1_BAD_ID;
3629         }
3630         if (e)
3631             goto fail;
3632         p += l;
3633         len -= l;
3634         ret += l;
3635         Top_oldlen = len;
3636         if (Top_datalen > len) {
3637             e = ASN1_OVERRUN;
3638             goto fail;
3639         }
3640         len = Top_datalen;
3641         {
3642             int enumint;
3643             e = der_get_integer(p, len, &enumint, &l);
3644             if (e)
3645                 goto fail;
3646             p += l;
3647             len -= l;
3648             ret += l;
3649             *data = enumint;
3650         }
3651         len = Top_oldlen - Top_datalen;
3652     }
3653     if (size)
3654         *size = ret;
3655     return 0;
3656   fail:
3657     free_LR_TYPE(data);
3658     return e;
3659 }
3660
3661 void ASN1CALL
3662 free_LR_TYPE(LR_TYPE * data)
3663 {
3664 }
3665
3666 size_t ASN1CALL
3667 length_LR_TYPE(const LR_TYPE * data)
3668 {
3669     size_t ret = 0;
3670     {
3671         int enumint = *data;
3672         ret += der_length_integer(&enumint);
3673     }
3674     ret += 1 + der_length_len(ret);
3675     return ret;
3676 }
3677
3678 int ASN1CALL
3679 copy_LR_TYPE(const LR_TYPE * from, LR_TYPE * to)
3680 {
3681     memset(to, 0, sizeof(*to));
3682     *(to) = *(from);
3683     return 0;
3684 }
3685
3686 int ASN1CALL
3687 encode_LastReq(unsigned char *p HEIMDAL_UNUSED_ATTRIBUTE,
3688                size_t len HEIMDAL_UNUSED_ATTRIBUTE, const LastReq * data,
3689                size_t * size)
3690 {
3691     size_t ret HEIMDAL_UNUSED_ATTRIBUTE = 0;
3692     size_t l HEIMDAL_UNUSED_ATTRIBUTE;
3693     int i HEIMDAL_UNUSED_ATTRIBUTE, e HEIMDAL_UNUSED_ATTRIBUTE;
3694
3695     for (i = (int) (data)->len - 1; i >= 0; --i) {
3696         size_t Top_tag_for_oldret = ret;
3697         ret = 0;
3698 /* lr-value */
3699         {
3700             size_t Top_tag_S_Of_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3701             ret = 0;
3702             e = encode_KerberosTime(p, len, &(&(data)->val[i])->lr_value, &l);
3703             if (e)
3704                 return e;
3705             p -= l;
3706             len -= l;
3707             ret += l;
3708
3709             e = der_put_length_and_tag(p, len, ret, ASN1_C_CONTEXT, CONS, 1,
3710                                        &l);
3711             if (e)
3712                 return e;
3713             p -= l;
3714             len -= l;
3715             ret += l;
3716
3717             ret += Top_tag_S_Of_tag_oldret;
3718         }
3719 /* lr-type */
3720         {
3721             size_t Top_tag_S_Of_tag_oldret HEIMDAL_UNUSED_ATTRIBUTE = ret;
3722             ret = 0;
3723             e = encode_LR_TYPE(p, len, &(&(data)->val[i])->lr_type, &l);
3724             if (e)
3725                 return e;
3726             p -= l;
<