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