HCoop / hcoop / debian / openafs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Import Upstream version 1.8.5
[hcoop/debian/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 }
openafs packaging