1 /* Generated from ./krb5.asn1 */
13 encode_krb5int32(unsigned char *p
, size_t len
, const krb5int32
* data
, size_t * size
)
20 e
= der_put_integer(p
, len
, data
, &l
);
27 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, PRIM
, UT_Integer
, &l
);
39 decode_krb5int32(const unsigned char *p
, size_t len
, krb5int32
* data
, size_t * size
)
45 memset(data
, 0, sizeof(*data
));
47 size_t Top_datalen
, Top_oldlen
;
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
) {
59 if (Top_datalen
> len
) {
64 e
= der_get_integer(p
, len
, data
, &l
);
70 len
= Top_oldlen
- Top_datalen
;
81 free_krb5int32(krb5int32
* data
)
86 length_krb5int32(const krb5int32
* data
)
89 ret
+= der_length_integer(data
);
90 ret
+= 1 + der_length_len(ret
);
95 copy_krb5int32(const krb5int32
* from
, krb5int32
* to
)
97 memset(to
, 0, sizeof(*to
));
104 /* Generated from ./krb5.asn1 */
113 #include <asn1_err.h>
116 encode_Ticket(unsigned char *p
, size_t len
, const Ticket
* data
, size_t * size
)
125 size_t Top_tag_tag_oldret
= ret
;
127 e
= encode_EncryptedData(p
, len
, &(data
)->enc_part
, &l
);
134 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 3, &l
);
141 ret
+= Top_tag_tag_oldret
;
145 size_t Top_tag_tag_oldret
= ret
;
147 e
= encode_PrincipalName(p
, len
, &(data
)->sname
, &l
);
154 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 2, &l
);
161 ret
+= Top_tag_tag_oldret
;
165 size_t Top_tag_tag_oldret
= ret
;
167 e
= encode_Realm(p
, len
, &(data
)->realm
, &l
);
174 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 1, &l
);
181 ret
+= Top_tag_tag_oldret
;
185 size_t Top_tag_tag_oldret
= ret
;
187 e
= encode_krb5int32(p
, len
, &(data
)->tkt_vno
, &l
);
194 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 0, &l
);
201 ret
+= Top_tag_tag_oldret
;
203 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, CONS
, UT_Sequence
, &l
);
210 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_APPL
, CONS
, 1, &l
);
222 decode_Ticket(const unsigned char *p
, size_t len
, Ticket
* data
, size_t * size
)
228 memset(data
, 0, sizeof(*data
));
230 size_t Top_datalen
, Top_oldlen
;
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
) {
242 if (Top_datalen
> len
) {
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
) {
259 Top_Tag_oldlen
= len
;
260 if (Top_Tag_datalen
> len
) {
264 len
= Top_Tag_datalen
;
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
) {
277 tkt_vno_oldlen
= len
;
278 if (tkt_vno_datalen
> len
) {
282 len
= tkt_vno_datalen
;
283 e
= decode_krb5int32(p
, len
, &(data
)->tkt_vno
, &l
);
289 len
= tkt_vno_oldlen
- tkt_vno_datalen
;
292 size_t realm_datalen
, realm_oldlen
;
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
) {
304 if (realm_datalen
> len
) {
309 e
= decode_Realm(p
, len
, &(data
)->realm
, &l
);
315 len
= realm_oldlen
- realm_datalen
;
318 size_t sname_datalen
, sname_oldlen
;
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
) {
330 if (sname_datalen
> len
) {
335 e
= decode_PrincipalName(p
, len
, &(data
)->sname
, &l
);
341 len
= sname_oldlen
- sname_datalen
;
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
) {
355 enc_part_oldlen
= len
;
356 if (enc_part_datalen
> len
) {
360 len
= enc_part_datalen
;
361 e
= decode_EncryptedData(p
, len
, &(data
)->enc_part
, &l
);
367 len
= enc_part_oldlen
- enc_part_datalen
;
369 len
= Top_Tag_oldlen
- Top_Tag_datalen
;
371 len
= Top_oldlen
- Top_datalen
;
382 free_Ticket(Ticket
* data
)
384 free_krb5int32(&(data
)->tkt_vno
);
385 free_Realm(&(data
)->realm
);
386 free_PrincipalName(&(data
)->sname
);
387 free_EncryptedData(&(data
)->enc_part
);
391 length_Ticket(const Ticket
* data
)
395 size_t Top_tag_tag_oldret
= ret
;
397 ret
+= length_krb5int32(&(data
)->tkt_vno
);
398 ret
+= 1 + der_length_len(ret
);
399 ret
+= Top_tag_tag_oldret
;
402 size_t Top_tag_tag_oldret
= ret
;
404 ret
+= length_Realm(&(data
)->realm
);
405 ret
+= 1 + der_length_len(ret
);
406 ret
+= Top_tag_tag_oldret
;
409 size_t Top_tag_tag_oldret
= ret
;
411 ret
+= length_PrincipalName(&(data
)->sname
);
412 ret
+= 1 + der_length_len(ret
);
413 ret
+= Top_tag_tag_oldret
;
416 size_t Top_tag_tag_oldret
= ret
;
418 ret
+= length_EncryptedData(&(data
)->enc_part
);
419 ret
+= 1 + der_length_len(ret
);
420 ret
+= Top_tag_tag_oldret
;
422 ret
+= 1 + der_length_len(ret
);
423 ret
+= 1 + der_length_len(ret
);
428 copy_Ticket(const Ticket
* from
, Ticket
* to
)
430 memset(to
, 0, sizeof(*to
));
431 if (copy_krb5int32(&(from
)->tkt_vno
, &(to
)->tkt_vno
))
433 if (copy_Realm(&(from
)->realm
, &(to
)->realm
))
435 if (copy_PrincipalName(&(from
)->sname
, &(to
)->sname
))
437 if (copy_EncryptedData(&(from
)->enc_part
, &(to
)->enc_part
))
447 /* Generated from ./krb5.asn1 */
456 #include <asn1_err.h>
459 encode_AuthorizationDataElement(unsigned char *p
, size_t len
, const AuthorizationDataElement
* data
, size_t * size
)
468 size_t Top_tag_oldret
= ret
;
470 e
= der_put_octet_string(p
, len
, &(data
)->ad_data
, &l
);
477 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, PRIM
, UT_OctetString
, &l
);
484 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 1, &l
);
491 ret
+= Top_tag_oldret
;
495 size_t Top_tag_oldret
= ret
;
497 e
= encode_krb5int32(p
, len
, &(data
)->ad_type
, &l
);
504 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 0, &l
);
511 ret
+= Top_tag_oldret
;
513 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, CONS
, UT_Sequence
, &l
);
525 decode_AuthorizationDataElement(const unsigned char *p
, size_t len
, AuthorizationDataElement
* data
, size_t * size
)
531 memset(data
, 0, sizeof(*data
));
533 size_t Top_datalen
, Top_oldlen
;
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
) {
545 if (Top_datalen
> len
) {
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
) {
562 ad_type_oldlen
= len
;
563 if (ad_type_datalen
> len
) {
567 len
= ad_type_datalen
;
568 e
= decode_krb5int32(p
, len
, &(data
)->ad_type
, &l
);
574 len
= ad_type_oldlen
- ad_type_datalen
;
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
) {
588 ad_data_oldlen
= len
;
589 if (ad_data_datalen
> len
) {
593 len
= ad_data_datalen
;
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
) {
606 ad_data_Tag_oldlen
= len
;
607 if (ad_data_Tag_datalen
> len
) {
611 len
= ad_data_Tag_datalen
;
612 e
= der_get_octet_string(p
, len
, &(data
)->ad_data
, &l
);
618 len
= ad_data_Tag_oldlen
- ad_data_Tag_datalen
;
620 len
= ad_data_oldlen
- ad_data_datalen
;
622 len
= Top_oldlen
- Top_datalen
;
628 free_AuthorizationDataElement(data
);
633 free_AuthorizationDataElement(AuthorizationDataElement
* data
)
635 free_krb5int32(&(data
)->ad_type
);
636 der_free_octet_string(&(data
)->ad_data
);
640 length_AuthorizationDataElement(const AuthorizationDataElement
* data
)
644 size_t Top_tag_oldret
= ret
;
646 ret
+= length_krb5int32(&(data
)->ad_type
);
647 ret
+= 1 + der_length_len(ret
);
648 ret
+= Top_tag_oldret
;
651 size_t Top_tag_oldret
= ret
;
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
;
658 ret
+= 1 + der_length_len(ret
);
663 copy_AuthorizationDataElement(const AuthorizationDataElement
* from
, AuthorizationDataElement
* to
)
665 memset(to
, 0, sizeof(*to
));
666 if (copy_krb5int32(&(from
)->ad_type
, &(to
)->ad_type
))
668 if (der_copy_octet_string(&(from
)->ad_data
, &(to
)->ad_data
))
672 free_AuthorizationDataElement(to
);
678 /* Generated from ./krb5.asn1 */
687 #include <asn1_err.h>
690 encode_EncryptedData(unsigned char *p
, size_t len
, const EncryptedData
* data
, size_t * size
)
699 size_t Top_tag_oldret
= ret
;
701 e
= der_put_octet_string(p
, len
, &(data
)->cipher
, &l
);
708 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, PRIM
, UT_OctetString
, &l
);
715 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 2, &l
);
722 ret
+= Top_tag_oldret
;
726 size_t Top_tag_oldret
= ret
;
728 e
= encode_krb5int32(p
, len
, (data
)->kvno
, &l
);
735 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 1, &l
);
742 ret
+= Top_tag_oldret
;
746 size_t Top_tag_oldret
= ret
;
748 e
= encode_ENCTYPE(p
, len
, &(data
)->etype
, &l
);
755 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 0, &l
);
762 ret
+= Top_tag_oldret
;
764 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, CONS
, UT_Sequence
, &l
);
776 decode_EncryptedData(const unsigned char *p
, size_t len
, EncryptedData
* data
, size_t * size
)
782 memset(data
, 0, sizeof(*data
));
784 size_t Top_datalen
, Top_oldlen
;
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
) {
796 if (Top_datalen
> len
) {
802 size_t etype_datalen
, etype_oldlen
;
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
) {
814 if (etype_datalen
> len
) {
819 e
= decode_ENCTYPE(p
, len
, &(data
)->etype
, &l
);
825 len
= etype_oldlen
- etype_datalen
;
828 size_t kvno_datalen
, kvno_oldlen
;
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
) {
837 (data
)->kvno
= calloc(1, sizeof(*(data
)->kvno
));
838 if ((data
)->kvno
== NULL
) {
846 if (kvno_datalen
> len
) {
851 e
= decode_krb5int32(p
, len
, (data
)->kvno
, &l
);
857 len
= kvno_oldlen
- kvno_datalen
;
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
) {
873 if (cipher_datalen
> len
) {
877 len
= cipher_datalen
;
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
) {
890 cipher_Tag_oldlen
= len
;
891 if (cipher_Tag_datalen
> len
) {
895 len
= cipher_Tag_datalen
;
896 e
= der_get_octet_string(p
, len
, &(data
)->cipher
, &l
);
902 len
= cipher_Tag_oldlen
- cipher_Tag_datalen
;
904 len
= cipher_oldlen
- cipher_datalen
;
906 len
= Top_oldlen
- Top_datalen
;
912 free_EncryptedData(data
);
917 free_EncryptedData(EncryptedData
* data
)
919 free_ENCTYPE(&(data
)->etype
);
921 free_krb5int32((data
)->kvno
);
925 der_free_octet_string(&(data
)->cipher
);
929 length_EncryptedData(const EncryptedData
* data
)
933 size_t Top_tag_oldret
= ret
;
935 ret
+= length_ENCTYPE(&(data
)->etype
);
936 ret
+= 1 + der_length_len(ret
);
937 ret
+= Top_tag_oldret
;
940 size_t Top_tag_oldret
= ret
;
942 ret
+= length_krb5int32((data
)->kvno
);
943 ret
+= 1 + der_length_len(ret
);
944 ret
+= Top_tag_oldret
;
946 size_t Top_tag_oldret
= ret
;
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
;
953 ret
+= 1 + der_length_len(ret
);
958 copy_EncryptedData(const EncryptedData
* from
, EncryptedData
* to
)
960 memset(to
, 0, sizeof(*to
));
961 if (copy_ENCTYPE(&(from
)->etype
, &(to
)->etype
))
964 (to
)->kvno
= malloc(sizeof(*(to
)->kvno
));
965 if ((to
)->kvno
== NULL
)
967 if (copy_krb5int32((from
)->kvno
, (to
)->kvno
))
971 if (der_copy_octet_string(&(from
)->cipher
, &(to
)->cipher
))
975 free_EncryptedData(to
);
981 /* Generated from ./krb5.asn1 */
990 #include <asn1_err.h>
993 encode_PrincipalName(unsigned char *p
, size_t len
, const PrincipalName
* data
, size_t * size
)
1002 size_t Top_tag_oldret
= ret
;
1004 for (i
= (&(data
)->name_string
)->len
- 1; i
>= 0; --i
) {
1005 size_t name_string_tag_tag_for_oldret
= ret
;
1007 e
= der_put_general_string(p
, len
, &(&(data
)->name_string
)->val
[i
], &l
);
1014 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, PRIM
, UT_GeneralString
, &l
);
1021 ret
+= name_string_tag_tag_for_oldret
;
1023 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, CONS
, UT_Sequence
, &l
);
1030 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 1, &l
);
1037 ret
+= Top_tag_oldret
;
1041 size_t Top_tag_oldret
= ret
;
1043 e
= encode_NAME_TYPE(p
, len
, &(data
)->name_type
, &l
);
1050 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 0, &l
);
1057 ret
+= Top_tag_oldret
;
1059 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, CONS
, UT_Sequence
, &l
);
1071 decode_PrincipalName(const unsigned char *p
, size_t len
, PrincipalName
* data
, size_t * size
)
1077 memset(data
, 0, sizeof(*data
));
1079 size_t Top_datalen
, Top_oldlen
;
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
) {
1091 if (Top_datalen
> len
) {
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
) {
1108 name_type_oldlen
= len
;
1109 if (name_type_datalen
> len
) {
1113 len
= name_type_datalen
;
1114 e
= decode_NAME_TYPE(p
, len
, &(data
)->name_type
, &l
);
1120 len
= name_type_oldlen
- name_type_datalen
;
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
) {
1134 name_string_oldlen
= len
;
1135 if (name_string_datalen
> len
) {
1139 len
= name_string_datalen
;
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
) {
1152 name_string_Tag_oldlen
= len
;
1153 if (name_string_Tag_datalen
> len
) {
1157 len
= name_string_Tag_datalen
;
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
;
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
) {
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
) {
1178 (&(data
)->name_string
)->val
= name_string_Tag_Tag_tmp
;
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
) {
1191 name_string_Tag_Tag_s_of_oldlen
= len
;
1192 if (name_string_Tag_Tag_s_of_datalen
> len
) {
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
);
1203 len
= name_string_Tag_Tag_s_of_oldlen
- name_string_Tag_Tag_s_of_datalen
;
1205 (&(data
)->name_string
)->len
++;
1206 len
= name_string_Tag_Tag_origlen
- ret
;
1208 ret
+= name_string_Tag_Tag_oldret
;
1210 len
= name_string_Tag_oldlen
- name_string_Tag_datalen
;
1212 len
= name_string_oldlen
- name_string_datalen
;
1214 len
= Top_oldlen
- Top_datalen
;
1220 free_PrincipalName(data
);
1225 free_PrincipalName(PrincipalName
* data
)
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
--;
1232 free((&(data
)->name_string
)->val
);
1233 (&(data
)->name_string
)->val
= NULL
;
1237 length_PrincipalName(const PrincipalName
* data
)
1241 size_t Top_tag_oldret
= ret
;
1243 ret
+= length_NAME_TYPE(&(data
)->name_type
);
1244 ret
+= 1 + der_length_len(ret
);
1245 ret
+= Top_tag_oldret
;
1248 size_t Top_tag_oldret
= ret
;
1251 int name_string_tag_tag_oldret
= ret
;
1254 for (i
= (&(data
)->name_string
)->len
- 1; i
>= 0; --i
) {
1255 int name_string_tag_tag_for_oldret
= ret
;
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
;
1261 ret
+= name_string_tag_tag_oldret
;
1263 ret
+= 1 + der_length_len(ret
);
1264 ret
+= 1 + der_length_len(ret
);
1265 ret
+= Top_tag_oldret
;
1267 ret
+= 1 + der_length_len(ret
);
1272 copy_PrincipalName(const PrincipalName
* from
, PrincipalName
* to
)
1274 memset(to
, 0, sizeof(*to
));
1275 if (copy_NAME_TYPE(&(from
)->name_type
, &(to
)->name_type
))
1277 if (((&(to
)->name_string
)->val
= malloc((&(from
)->name_string
)->len
* sizeof(*(&(to
)->name_string
)->val
))) == NULL
&& (&(from
)->name_string
)->len
!= 0)
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
]))
1285 free_PrincipalName(to
);
1291 /* Generated from ./krb5.asn1 */
1300 #include <asn1_err.h>
1303 encode_HostAddresses(unsigned char *p
, size_t len
, const HostAddresses
* data
, size_t * size
)
1310 for (i
= (data
)->len
- 1; i
>= 0; --i
) {
1311 size_t Top_tag_for_oldret
= ret
;
1313 e
= encode_HostAddress(p
, len
, &(data
)->val
[i
], &l
);
1320 ret
+= Top_tag_for_oldret
;
1322 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, CONS
, UT_Sequence
, &l
);
1334 decode_HostAddresses(const unsigned char *p
, size_t len
, HostAddresses
* data
, size_t * size
)
1340 memset(data
, 0, sizeof(*data
));
1342 size_t Top_datalen
, Top_oldlen
;
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
) {
1354 if (Top_datalen
> len
) {
1360 size_t Top_Tag_origlen
= len
;
1361 size_t Top_Tag_oldret
= ret
;
1362 size_t Top_Tag_olen
= 0;
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
) {
1373 Top_Tag_olen
= Top_Tag_nlen
;
1374 Top_Tag_tmp
= realloc((data
)->val
, Top_Tag_olen
);
1375 if (Top_Tag_tmp
== NULL
) {
1379 (data
)->val
= Top_Tag_tmp
;
1380 e
= decode_HostAddress(p
, len
, &(data
)->val
[(data
)->len
], &l
);
1387 len
= Top_Tag_origlen
- ret
;
1389 ret
+= Top_Tag_oldret
;
1391 len
= Top_oldlen
- Top_datalen
;
1397 free_HostAddresses(data
);
1402 free_HostAddresses(HostAddresses
* data
)
1404 while ((data
)->len
) {
1405 free_HostAddress(&(data
)->val
[(data
)->len
- 1]);
1413 length_HostAddresses(const HostAddresses
* data
)
1417 int Top_tag_oldret
= ret
;
1420 for (i
= (data
)->len
- 1; i
>= 0; --i
) {
1421 int Top_tag_for_oldret
= ret
;
1423 ret
+= length_HostAddress(&(data
)->val
[i
]);
1424 ret
+= Top_tag_for_oldret
;
1426 ret
+= Top_tag_oldret
;
1428 ret
+= 1 + der_length_len(ret
);
1433 copy_HostAddresses(const HostAddresses
* from
, HostAddresses
* to
)
1435 memset(to
, 0, sizeof(*to
));
1436 if (((to
)->val
= malloc((from
)->len
* sizeof(*(to
)->val
))) == NULL
&& (from
)->len
!= 0)
1438 for ((to
)->len
= 0; (to
)->len
< (from
)->len
; (to
)->len
++) {
1439 if (copy_HostAddress(&(from
)->val
[(to
)->len
], &(to
)->val
[(to
)->len
]))
1444 free_HostAddresses(to
);
1450 /* Generated from ./krb5.asn1 */
1459 #include <asn1_err.h>
1462 encode_HostAddress(unsigned char *p
, size_t len
, const HostAddress
* data
, size_t * size
)
1466 int i AFS_UNUSED
, e
;
1471 size_t Top_tag_oldret
= ret
;
1473 e
= der_put_octet_string(p
, len
, &(data
)->address
, &l
);
1480 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, PRIM
, UT_OctetString
, &l
);
1487 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 1, &l
);
1494 ret
+= Top_tag_oldret
;
1498 size_t Top_tag_oldret
= ret
;
1500 e
= encode_krb5int32(p
, len
, &(data
)->addr_type
, &l
);
1507 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 0, &l
);
1514 ret
+= Top_tag_oldret
;
1516 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, CONS
, UT_Sequence
, &l
);
1528 decode_HostAddress(const unsigned char *p
, size_t len
, HostAddress
* data
, size_t * size
)
1534 memset(data
, 0, sizeof(*data
));
1536 size_t Top_datalen
, Top_oldlen
;
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
) {
1548 if (Top_datalen
> len
) {
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
) {
1565 addr_type_oldlen
= len
;
1566 if (addr_type_datalen
> len
) {
1570 len
= addr_type_datalen
;
1571 e
= decode_krb5int32(p
, len
, &(data
)->addr_type
, &l
);
1577 len
= addr_type_oldlen
- addr_type_datalen
;
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
) {
1591 address_oldlen
= len
;
1592 if (address_datalen
> len
) {
1596 len
= address_datalen
;
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
) {
1609 address_Tag_oldlen
= len
;
1610 if (address_Tag_datalen
> len
) {
1614 len
= address_Tag_datalen
;
1615 e
= der_get_octet_string(p
, len
, &(data
)->address
, &l
);
1621 len
= address_Tag_oldlen
- address_Tag_datalen
;
1623 len
= address_oldlen
- address_datalen
;
1625 len
= Top_oldlen
- Top_datalen
;
1631 free_HostAddress(data
);
1636 free_HostAddress(HostAddress
* data
)
1638 free_krb5int32(&(data
)->addr_type
);
1639 der_free_octet_string(&(data
)->address
);
1643 length_HostAddress(const HostAddress
* data
)
1647 size_t Top_tag_oldret
= ret
;
1649 ret
+= length_krb5int32(&(data
)->addr_type
);
1650 ret
+= 1 + der_length_len(ret
);
1651 ret
+= Top_tag_oldret
;
1654 size_t Top_tag_oldret
= ret
;
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
;
1661 ret
+= 1 + der_length_len(ret
);
1666 copy_HostAddress(const HostAddress
* from
, HostAddress
* to
)
1668 memset(to
, 0, sizeof(*to
));
1669 if (copy_krb5int32(&(from
)->addr_type
, &(to
)->addr_type
))
1671 if (der_copy_octet_string(&(from
)->address
, &(to
)->address
))
1675 free_HostAddress(to
);
1681 /* Generated from ./krb5.asn1 */
1690 #include <asn1_err.h>
1693 encode_AuthorizationData(unsigned char *p
, size_t len
, const AuthorizationData
* data
, size_t * size
)
1700 for (i
= (data
)->len
- 1; i
>= 0; --i
) {
1701 size_t Top_tag_for_oldret
= ret
;
1703 e
= encode_AuthorizationDataElement(p
, len
, &(data
)->val
[i
], &l
);
1710 ret
+= Top_tag_for_oldret
;
1712 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, CONS
, UT_Sequence
, &l
);
1724 decode_AuthorizationData(const unsigned char *p
, size_t len
, AuthorizationData
* data
, size_t * size
)
1730 memset(data
, 0, sizeof(*data
));
1732 size_t Top_datalen
, Top_oldlen
;
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
) {
1744 if (Top_datalen
> len
) {
1750 size_t Top_Tag_origlen
= len
;
1751 size_t Top_Tag_oldret
= ret
;
1752 size_t Top_Tag_olen
= 0;
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
) {
1763 Top_Tag_olen
= Top_Tag_nlen
;
1764 Top_Tag_tmp
= realloc((data
)->val
, Top_Tag_olen
);
1765 if (Top_Tag_tmp
== NULL
) {
1769 (data
)->val
= Top_Tag_tmp
;
1770 e
= decode_AuthorizationDataElement(p
, len
, &(data
)->val
[(data
)->len
], &l
);
1777 len
= Top_Tag_origlen
- ret
;
1779 ret
+= Top_Tag_oldret
;
1781 len
= Top_oldlen
- Top_datalen
;
1787 free_AuthorizationData(data
);
1792 free_AuthorizationData(AuthorizationData
* data
)
1794 while ((data
)->len
) {
1795 free_AuthorizationDataElement(&(data
)->val
[(data
)->len
- 1]);
1803 length_AuthorizationData(const AuthorizationData
* data
)
1807 int Top_tag_oldret
= ret
;
1810 for (i
= (data
)->len
- 1; i
>= 0; --i
) {
1811 int Top_tag_for_oldret
= ret
;
1813 ret
+= length_AuthorizationDataElement(&(data
)->val
[i
]);
1814 ret
+= Top_tag_for_oldret
;
1816 ret
+= Top_tag_oldret
;
1818 ret
+= 1 + der_length_len(ret
);
1823 copy_AuthorizationData(const AuthorizationData
* from
, AuthorizationData
* to
)
1825 memset(to
, 0, sizeof(*to
));
1826 if (((to
)->val
= malloc((from
)->len
* sizeof(*(to
)->val
))) == NULL
&& (from
)->len
!= 0)
1828 for ((to
)->len
= 0; (to
)->len
< (from
)->len
; (to
)->len
++) {
1829 if (copy_AuthorizationDataElement(&(from
)->val
[(to
)->len
], &(to
)->val
[(to
)->len
]))
1834 free_AuthorizationData(to
);
1839 add_AuthorizationData(AuthorizationData
* data
, const AuthorizationDataElement
* element
)
1844 ptr
= realloc(data
->val
,
1845 (data
->len
+ 1) * sizeof(data
->val
[0]));
1850 ret
= copy_AuthorizationDataElement(element
, &data
->val
[data
->len
]);
1858 remove_AuthorizationData(AuthorizationData
* data
, unsigned int element
)
1862 if (data
->len
== 0 || element
>= data
->len
)
1863 return ASN1_OVERRUN
;
1864 free_AuthorizationDataElement(&data
->val
[element
]);
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)
1877 /* Generated from ./krb5.asn1 */
1886 #include <asn1_err.h>
1889 encode_EncTicketPart(unsigned char *p
, size_t len
, const EncTicketPart
* data
, size_t * size
)
1893 int i AFS_UNUSED
, e
;
1896 /* authorization-data */
1897 if ((data
)->authorization_data
) {
1898 size_t Top_tag_tag_oldret
= ret
;
1900 e
= encode_AuthorizationData(p
, len
, (data
)->authorization_data
, &l
);
1907 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 10, &l
);
1914 ret
+= Top_tag_tag_oldret
;
1917 if ((data
)->caddr
) {
1918 size_t Top_tag_tag_oldret
= ret
;
1920 e
= encode_HostAddresses(p
, len
, (data
)->caddr
, &l
);
1927 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 9, &l
);
1934 ret
+= Top_tag_tag_oldret
;
1937 if ((data
)->renew_till
) {
1938 size_t Top_tag_tag_oldret
= ret
;
1940 e
= encode_KerberosTime(p
, len
, (data
)->renew_till
, &l
);
1947 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 8, &l
);
1954 ret
+= Top_tag_tag_oldret
;
1958 size_t Top_tag_tag_oldret
= ret
;
1960 e
= encode_KerberosTime(p
, len
, &(data
)->endtime
, &l
);
1967 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 7, &l
);
1974 ret
+= Top_tag_tag_oldret
;
1977 if ((data
)->starttime
) {
1978 size_t Top_tag_tag_oldret
= ret
;
1980 e
= encode_KerberosTime(p
, len
, (data
)->starttime
, &l
);
1987 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 6, &l
);
1994 ret
+= Top_tag_tag_oldret
;
1998 size_t Top_tag_tag_oldret
= ret
;
2000 e
= encode_KerberosTime(p
, len
, &(data
)->authtime
, &l
);
2007 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 5, &l
);
2014 ret
+= Top_tag_tag_oldret
;
2018 size_t Top_tag_tag_oldret
= ret
;
2020 e
= encode_TransitedEncoding(p
, len
, &(data
)->transited
, &l
);
2027 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 4, &l
);
2034 ret
+= Top_tag_tag_oldret
;
2038 size_t Top_tag_tag_oldret
= ret
;
2040 e
= encode_PrincipalName(p
, len
, &(data
)->cname
, &l
);
2047 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 3, &l
);
2054 ret
+= Top_tag_tag_oldret
;
2058 size_t Top_tag_tag_oldret
= ret
;
2060 e
= encode_Realm(p
, len
, &(data
)->crealm
, &l
);
2067 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 2, &l
);
2074 ret
+= Top_tag_tag_oldret
;
2078 size_t Top_tag_tag_oldret
= ret
;
2080 e
= encode_EncryptionKey(p
, len
, &(data
)->key
, &l
);
2087 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 1, &l
);
2094 ret
+= Top_tag_tag_oldret
;
2098 size_t Top_tag_tag_oldret
= ret
;
2100 e
= encode_TicketFlags(p
, len
, &(data
)->flags
, &l
);
2107 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 0, &l
);
2114 ret
+= Top_tag_tag_oldret
;
2116 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, CONS
, UT_Sequence
, &l
);
2123 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_APPL
, CONS
, 3, &l
);
2135 decode_EncTicketPart(const unsigned char *p
, size_t len
, EncTicketPart
* data
, size_t * size
)
2141 memset(data
, 0, sizeof(*data
));
2143 size_t Top_datalen
, Top_oldlen
;
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
) {
2155 if (Top_datalen
> len
) {
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
) {
2172 Top_Tag_oldlen
= len
;
2173 if (Top_Tag_datalen
> len
) {
2177 len
= Top_Tag_datalen
;
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
) {
2191 if (flags_datalen
> len
) {
2195 len
= flags_datalen
;
2196 e
= decode_TicketFlags(p
, len
, &(data
)->flags
, &l
);
2202 len
= flags_oldlen
- flags_datalen
;
2205 size_t key_datalen
, key_oldlen
;
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
) {
2217 if (key_datalen
> len
) {
2222 e
= decode_EncryptionKey(p
, len
, &(data
)->key
, &l
);
2228 len
= key_oldlen
- key_datalen
;
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
) {
2242 crealm_oldlen
= len
;
2243 if (crealm_datalen
> len
) {
2247 len
= crealm_datalen
;
2248 e
= decode_Realm(p
, len
, &(data
)->crealm
, &l
);
2254 len
= crealm_oldlen
- crealm_datalen
;
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
) {
2269 if (cname_datalen
> len
) {
2273 len
= cname_datalen
;
2274 e
= decode_PrincipalName(p
, len
, &(data
)->cname
, &l
);
2280 len
= cname_oldlen
- cname_datalen
;
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
) {
2294 transited_oldlen
= len
;
2295 if (transited_datalen
> len
) {
2299 len
= transited_datalen
;
2300 e
= decode_TransitedEncoding(p
, len
, &(data
)->transited
, &l
);
2306 len
= transited_oldlen
- transited_datalen
;
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
) {
2320 authtime_oldlen
= len
;
2321 if (authtime_datalen
> len
) {
2325 len
= authtime_datalen
;
2326 e
= decode_KerberosTime(p
, len
, &(data
)->authtime
, &l
);
2332 len
= authtime_oldlen
- authtime_datalen
;
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
) {
2342 (data
)->starttime
= NULL
;
2344 (data
)->starttime
= calloc(1, sizeof(*(data
)->starttime
));
2345 if ((data
)->starttime
== NULL
) {
2352 starttime_oldlen
= len
;
2353 if (starttime_datalen
> len
) {
2357 len
= starttime_datalen
;
2358 e
= decode_KerberosTime(p
, len
, (data
)->starttime
, &l
);
2364 len
= starttime_oldlen
- starttime_datalen
;
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
) {
2379 endtime_oldlen
= len
;
2380 if (endtime_datalen
> len
) {
2384 len
= endtime_datalen
;
2385 e
= decode_KerberosTime(p
, len
, &(data
)->endtime
, &l
);
2391 len
= endtime_oldlen
- endtime_datalen
;
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
) {
2401 (data
)->renew_till
= NULL
;
2403 (data
)->renew_till
= calloc(1, sizeof(*(data
)->renew_till
));
2404 if ((data
)->renew_till
== NULL
) {
2411 renew_till_oldlen
= len
;
2412 if (renew_till_datalen
> len
) {
2416 len
= renew_till_datalen
;
2417 e
= decode_KerberosTime(p
, len
, (data
)->renew_till
, &l
);
2423 len
= renew_till_oldlen
- renew_till_datalen
;
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
) {
2434 (data
)->caddr
= NULL
;
2436 (data
)->caddr
= calloc(1, sizeof(*(data
)->caddr
));
2437 if ((data
)->caddr
== NULL
) {
2445 if (caddr_datalen
> len
) {
2449 len
= caddr_datalen
;
2450 e
= decode_HostAddresses(p
, len
, (data
)->caddr
, &l
);
2456 len
= caddr_oldlen
- caddr_datalen
;
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
) {
2467 (data
)->authorization_data
= NULL
;
2469 (data
)->authorization_data
= calloc(1, sizeof(*(data
)->authorization_data
));
2470 if ((data
)->authorization_data
== NULL
) {
2477 authorization_data_oldlen
= len
;
2478 if (authorization_data_datalen
> len
) {
2482 len
= authorization_data_datalen
;
2483 e
= decode_AuthorizationData(p
, len
, (data
)->authorization_data
, &l
);
2489 len
= authorization_data_oldlen
- authorization_data_datalen
;
2492 len
= Top_Tag_oldlen
- Top_Tag_datalen
;
2494 len
= Top_oldlen
- Top_datalen
;
2500 free_EncTicketPart(data
);
2505 free_EncTicketPart(EncTicketPart
* data
)
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
;
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
;
2524 if ((data
)->caddr
) {
2525 free_HostAddresses((data
)->caddr
);
2526 free((data
)->caddr
);
2527 (data
)->caddr
= NULL
;
2529 if ((data
)->authorization_data
) {
2530 free_AuthorizationData((data
)->authorization_data
);
2531 free((data
)->authorization_data
);
2532 (data
)->authorization_data
= NULL
;
2537 length_EncTicketPart(const EncTicketPart
* data
)
2541 size_t Top_tag_tag_oldret
= ret
;
2543 ret
+= length_TicketFlags(&(data
)->flags
);
2544 ret
+= 1 + der_length_len(ret
);
2545 ret
+= Top_tag_tag_oldret
;
2548 size_t Top_tag_tag_oldret
= ret
;
2550 ret
+= length_EncryptionKey(&(data
)->key
);
2551 ret
+= 1 + der_length_len(ret
);
2552 ret
+= Top_tag_tag_oldret
;
2555 size_t Top_tag_tag_oldret
= ret
;
2557 ret
+= length_Realm(&(data
)->crealm
);
2558 ret
+= 1 + der_length_len(ret
);
2559 ret
+= Top_tag_tag_oldret
;
2562 size_t Top_tag_tag_oldret
= ret
;
2564 ret
+= length_PrincipalName(&(data
)->cname
);
2565 ret
+= 1 + der_length_len(ret
);
2566 ret
+= Top_tag_tag_oldret
;
2569 size_t Top_tag_tag_oldret
= ret
;
2571 ret
+= length_TransitedEncoding(&(data
)->transited
);
2572 ret
+= 1 + der_length_len(ret
);
2573 ret
+= Top_tag_tag_oldret
;
2576 size_t Top_tag_tag_oldret
= ret
;
2578 ret
+= length_KerberosTime(&(data
)->authtime
);
2579 ret
+= 1 + der_length_len(ret
);
2580 ret
+= Top_tag_tag_oldret
;
2582 if ((data
)->starttime
) {
2583 size_t Top_tag_tag_oldret
= ret
;
2585 ret
+= length_KerberosTime((data
)->starttime
);
2586 ret
+= 1 + der_length_len(ret
);
2587 ret
+= Top_tag_tag_oldret
;
2589 size_t Top_tag_tag_oldret
= ret
;
2591 ret
+= length_KerberosTime(&(data
)->endtime
);
2592 ret
+= 1 + der_length_len(ret
);
2593 ret
+= Top_tag_tag_oldret
;
2595 if ((data
)->renew_till
) {
2596 size_t Top_tag_tag_oldret
= ret
;
2598 ret
+= length_KerberosTime((data
)->renew_till
);
2599 ret
+= 1 + der_length_len(ret
);
2600 ret
+= Top_tag_tag_oldret
;
2602 if ((data
)->caddr
) {
2603 size_t Top_tag_tag_oldret
= ret
;
2605 ret
+= length_HostAddresses((data
)->caddr
);
2606 ret
+= 1 + der_length_len(ret
);
2607 ret
+= Top_tag_tag_oldret
;
2609 if ((data
)->authorization_data
) {
2610 size_t Top_tag_tag_oldret
= ret
;
2612 ret
+= length_AuthorizationData((data
)->authorization_data
);
2613 ret
+= 1 + der_length_len(ret
);
2614 ret
+= Top_tag_tag_oldret
;
2616 ret
+= 1 + der_length_len(ret
);
2617 ret
+= 1 + der_length_len(ret
);
2622 copy_EncTicketPart(const EncTicketPart
* from
, EncTicketPart
* to
)
2624 memset(to
, 0, sizeof(*to
));
2625 if (copy_TicketFlags(&(from
)->flags
, &(to
)->flags
))
2627 if (copy_EncryptionKey(&(from
)->key
, &(to
)->key
))
2629 if (copy_Realm(&(from
)->crealm
, &(to
)->crealm
))
2631 if (copy_PrincipalName(&(from
)->cname
, &(to
)->cname
))
2633 if (copy_TransitedEncoding(&(from
)->transited
, &(to
)->transited
))
2635 if (copy_KerberosTime(&(from
)->authtime
, &(to
)->authtime
))
2637 if ((from
)->starttime
) {
2638 (to
)->starttime
= malloc(sizeof(*(to
)->starttime
));
2639 if ((to
)->starttime
== NULL
)
2641 if (copy_KerberosTime((from
)->starttime
, (to
)->starttime
))
2644 (to
)->starttime
= NULL
;
2645 if (copy_KerberosTime(&(from
)->endtime
, &(to
)->endtime
))
2647 if ((from
)->renew_till
) {
2648 (to
)->renew_till
= malloc(sizeof(*(to
)->renew_till
));
2649 if ((to
)->renew_till
== NULL
)
2651 if (copy_KerberosTime((from
)->renew_till
, (to
)->renew_till
))
2654 (to
)->renew_till
= NULL
;
2655 if ((from
)->caddr
) {
2656 (to
)->caddr
= malloc(sizeof(*(to
)->caddr
));
2657 if ((to
)->caddr
== NULL
)
2659 if (copy_HostAddresses((from
)->caddr
, (to
)->caddr
))
2663 if ((from
)->authorization_data
) {
2664 (to
)->authorization_data
= malloc(sizeof(*(to
)->authorization_data
));
2665 if ((to
)->authorization_data
== NULL
)
2667 if (copy_AuthorizationData((from
)->authorization_data
, (to
)->authorization_data
))
2670 (to
)->authorization_data
= NULL
;
2673 free_EncTicketPart(to
);
2679 /* Generated from ./krb5.asn1 */
2688 #include <asn1_err.h>
2691 encode_KerberosTime(unsigned char *p
, size_t len
, const KerberosTime
* data
, size_t * size
)
2695 int i AFS_UNUSED
, e
;
2698 e
= der_put_generalized_time(p
, len
, data
, &l
);
2705 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, PRIM
, UT_GeneralizedTime
, &l
);
2717 decode_KerberosTime(const unsigned char *p
, size_t len
, KerberosTime
* data
, size_t * size
)
2723 memset(data
, 0, sizeof(*data
));
2725 size_t Top_datalen
, Top_oldlen
;
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
) {
2737 if (Top_datalen
> len
) {
2742 e
= der_get_generalized_time(p
, len
, data
, &l
);
2748 len
= Top_oldlen
- Top_datalen
;
2754 free_KerberosTime(data
);
2759 free_KerberosTime(KerberosTime
* data
)
2764 length_KerberosTime(const KerberosTime
* data
)
2767 ret
+= der_length_generalized_time(data
);
2768 ret
+= 1 + der_length_len(ret
);
2773 copy_KerberosTime(const KerberosTime
* from
, KerberosTime
* to
)
2775 memset(to
, 0, sizeof(*to
));
2782 /* Generated from ./krb5.asn1 */
2791 #include <asn1_err.h>
2794 encode_TransitedEncoding(unsigned char *p
, size_t len
, const TransitedEncoding
* data
, size_t * size
)
2798 int i AFS_UNUSED
, e
;
2803 size_t Top_tag_oldret
= ret
;
2805 e
= der_put_octet_string(p
, len
, &(data
)->contents
, &l
);
2812 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, PRIM
, UT_OctetString
, &l
);
2819 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 1, &l
);
2826 ret
+= Top_tag_oldret
;
2830 size_t Top_tag_oldret
= ret
;
2832 e
= encode_krb5int32(p
, len
, &(data
)->tr_type
, &l
);
2839 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 0, &l
);
2846 ret
+= Top_tag_oldret
;
2848 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, CONS
, UT_Sequence
, &l
);
2860 decode_TransitedEncoding(const unsigned char *p
, size_t len
, TransitedEncoding
* data
, size_t * size
)
2866 memset(data
, 0, sizeof(*data
));
2868 size_t Top_datalen
, Top_oldlen
;
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
) {
2880 if (Top_datalen
> len
) {
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
) {
2897 tr_type_oldlen
= len
;
2898 if (tr_type_datalen
> len
) {
2902 len
= tr_type_datalen
;
2903 e
= decode_krb5int32(p
, len
, &(data
)->tr_type
, &l
);
2909 len
= tr_type_oldlen
- tr_type_datalen
;
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
) {
2923 contents_oldlen
= len
;
2924 if (contents_datalen
> len
) {
2928 len
= contents_datalen
;
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
) {
2941 contents_Tag_oldlen
= len
;
2942 if (contents_Tag_datalen
> len
) {
2946 len
= contents_Tag_datalen
;
2947 e
= der_get_octet_string(p
, len
, &(data
)->contents
, &l
);
2953 len
= contents_Tag_oldlen
- contents_Tag_datalen
;
2955 len
= contents_oldlen
- contents_datalen
;
2957 len
= Top_oldlen
- Top_datalen
;
2963 free_TransitedEncoding(data
);
2968 free_TransitedEncoding(TransitedEncoding
* data
)
2970 free_krb5int32(&(data
)->tr_type
);
2971 der_free_octet_string(&(data
)->contents
);
2975 length_TransitedEncoding(const TransitedEncoding
* data
)
2979 size_t Top_tag_oldret
= ret
;
2981 ret
+= length_krb5int32(&(data
)->tr_type
);
2982 ret
+= 1 + der_length_len(ret
);
2983 ret
+= Top_tag_oldret
;
2986 size_t Top_tag_oldret
= ret
;
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
;
2993 ret
+= 1 + der_length_len(ret
);
2998 copy_TransitedEncoding(const TransitedEncoding
* from
, TransitedEncoding
* to
)
3000 memset(to
, 0, sizeof(*to
));
3001 if (copy_krb5int32(&(from
)->tr_type
, &(to
)->tr_type
))
3003 if (der_copy_octet_string(&(from
)->contents
, &(to
)->contents
))
3007 free_TransitedEncoding(to
);
3013 /* Generated from ./krb5.asn1 */
3022 #include <asn1_err.h>
3025 encode_EncryptionKey(unsigned char *p
, size_t len
, const EncryptionKey
* data
, size_t * size
)
3029 int i AFS_UNUSED
, e
;
3034 size_t Top_tag_oldret
= ret
;
3036 e
= der_put_octet_string(p
, len
, &(data
)->keyvalue
, &l
);
3043 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, PRIM
, UT_OctetString
, &l
);
3050 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 1, &l
);
3057 ret
+= Top_tag_oldret
;
3061 size_t Top_tag_oldret
= ret
;
3063 e
= encode_krb5int32(p
, len
, &(data
)->keytype
, &l
);
3070 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_CONTEXT
, CONS
, 0, &l
);
3077 ret
+= Top_tag_oldret
;
3079 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, CONS
, UT_Sequence
, &l
);
3091 decode_EncryptionKey(const unsigned char *p
, size_t len
, EncryptionKey
* data
, size_t * size
)
3097 memset(data
, 0, sizeof(*data
));
3099 size_t Top_datalen
, Top_oldlen
;
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
) {
3111 if (Top_datalen
> len
) {
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
) {
3128 keytype_oldlen
= len
;
3129 if (keytype_datalen
> len
) {
3133 len
= keytype_datalen
;
3134 e
= decode_krb5int32(p
, len
, &(data
)->keytype
, &l
);
3140 len
= keytype_oldlen
- keytype_datalen
;
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
) {
3154 keyvalue_oldlen
= len
;
3155 if (keyvalue_datalen
> len
) {
3159 len
= keyvalue_datalen
;
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
) {
3172 keyvalue_Tag_oldlen
= len
;
3173 if (keyvalue_Tag_datalen
> len
) {
3177 len
= keyvalue_Tag_datalen
;
3178 e
= der_get_octet_string(p
, len
, &(data
)->keyvalue
, &l
);
3184 len
= keyvalue_Tag_oldlen
- keyvalue_Tag_datalen
;
3186 len
= keyvalue_oldlen
- keyvalue_datalen
;
3188 len
= Top_oldlen
- Top_datalen
;
3194 free_EncryptionKey(data
);
3199 free_EncryptionKey(EncryptionKey
* data
)
3201 free_krb5int32(&(data
)->keytype
);
3202 der_free_octet_string(&(data
)->keyvalue
);
3206 length_EncryptionKey(const EncryptionKey
* data
)
3210 size_t Top_tag_oldret
= ret
;
3212 ret
+= length_krb5int32(&(data
)->keytype
);
3213 ret
+= 1 + der_length_len(ret
);
3214 ret
+= Top_tag_oldret
;
3217 size_t Top_tag_oldret
= ret
;
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
;
3224 ret
+= 1 + der_length_len(ret
);
3229 copy_EncryptionKey(const EncryptionKey
* from
, EncryptionKey
* to
)
3231 memset(to
, 0, sizeof(*to
));
3232 if (copy_krb5int32(&(from
)->keytype
, &(to
)->keytype
))
3234 if (der_copy_octet_string(&(from
)->keyvalue
, &(to
)->keyvalue
))
3238 free_EncryptionKey(to
);
3244 /* Generated from ./krb5.asn1 */
3253 #include <asn1_err.h>
3256 encode_TicketFlags(unsigned char *p
, size_t len
, const TicketFlags
* data
, size_t * size
)
3260 int i AFS_UNUSED
, e
;
3264 unsigned char c
= 0;
3266 return ASN1_OVERFLOW
;
3272 return ASN1_OVERFLOW
;
3277 if ((data
)->anonymous
) {
3280 if ((data
)->ok_as_delegate
) {
3283 if ((data
)->transited_policy_checked
) {
3286 if ((data
)->hw_authent
) {
3289 if ((data
)->pre_authent
) {
3292 if ((data
)->initial
) {
3295 if ((data
)->renewable
) {
3299 return ASN1_OVERFLOW
;
3304 if ((data
)->invalid
) {
3307 if ((data
)->postdated
) {
3310 if ((data
)->may_postdate
) {
3313 if ((data
)->proxy
) {
3316 if ((data
)->proxiable
) {
3319 if ((data
)->forwarded
) {
3322 if ((data
)->forwardable
) {
3325 if ((data
)->reserved
) {
3329 return ASN1_OVERFLOW
;
3334 return ASN1_OVERFLOW
;
3340 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, PRIM
, UT_BitString
, &l
);
3352 decode_TicketFlags(const unsigned char *p
, size_t len
, TicketFlags
* data
, size_t * size
)
3358 memset(data
, 0, sizeof(*data
));
3360 size_t Top_datalen
, Top_oldlen
;
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
) {
3372 if (Top_datalen
> len
) {
3378 return ASN1_OVERRUN
;
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;
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;
3408 len
= Top_oldlen
- Top_datalen
;
3414 free_TicketFlags(data
);
3419 free_TicketFlags(TicketFlags
* data
)
3424 length_TicketFlags(const TicketFlags
* data
)
3428 ret
+= 1 + der_length_len(ret
);
3433 copy_TicketFlags(const TicketFlags
* from
, TicketFlags
* to
)
3435 memset(to
, 0, sizeof(*to
));
3441 TicketFlags2int(TicketFlags f
)
3468 if (f
.transited_policy_checked
)
3470 if (f
.ok_as_delegate
)
3478 int2TicketFlags(unsigned n
)
3482 memset(&flags
, 0, sizeof(flags
));
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;
3506 /* Generated from ./krb5.asn1 */
3515 #include <asn1_err.h>
3518 encode_Realm(unsigned char *p
, size_t len
, const Realm
* data
, size_t * size
)
3522 int i AFS_UNUSED
, e
;
3525 e
= der_put_general_string(p
, len
, data
, &l
);
3532 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, PRIM
, UT_GeneralString
, &l
);
3544 decode_Realm(const unsigned char *p
, size_t len
, Realm
* data
, size_t * size
)
3550 memset(data
, 0, sizeof(*data
));
3552 size_t Top_datalen
, Top_oldlen
;
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
) {
3564 if (Top_datalen
> len
) {
3569 e
= der_get_general_string(p
, len
, data
, &l
);
3575 len
= Top_oldlen
- Top_datalen
;
3586 free_Realm(Realm
* data
)
3588 der_free_general_string(data
);
3592 length_Realm(const Realm
* data
)
3595 ret
+= der_length_general_string(data
);
3596 ret
+= 1 + der_length_len(ret
);
3601 copy_Realm(const Realm
* from
, Realm
* to
)
3603 memset(to
, 0, sizeof(*to
));
3604 if (der_copy_general_string(from
, to
))
3614 /* Generated from ./krb5.asn1 */
3623 #include <asn1_err.h>
3626 encode_ENCTYPE(unsigned char *p
, size_t len
, const ENCTYPE
* data
, size_t * size
)
3630 int i AFS_UNUSED
, e
;
3634 int enumint
= (int) *data
;
3635 e
= der_put_integer(p
, len
, &enumint
, &l
);
3644 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, PRIM
, UT_Integer
, &l
);
3656 decode_ENCTYPE(const unsigned char *p
, size_t len
, ENCTYPE
* data
, size_t * size
)
3662 memset(data
, 0, sizeof(*data
));
3664 size_t Top_datalen
, Top_oldlen
;
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
) {
3676 if (Top_datalen
> len
) {
3683 e
= der_get_integer(p
, len
, &enumint
, &l
);
3691 len
= Top_oldlen
- Top_datalen
;
3702 free_ENCTYPE(ENCTYPE
* data
)
3707 length_ENCTYPE(const ENCTYPE
* data
)
3711 int enumint
= *data
;
3712 ret
+= der_length_integer(&enumint
);
3714 ret
+= 1 + der_length_len(ret
);
3719 copy_ENCTYPE(const ENCTYPE
* from
, ENCTYPE
* to
)
3721 memset(to
, 0, sizeof(*to
));
3728 /* Generated from ./krb5.asn1 */
3737 #include <asn1_err.h>
3740 encode_NAME_TYPE(unsigned char *p
, size_t len
, const NAME_TYPE
* data
, size_t * size
)
3744 int i AFS_UNUSED
, e
;
3748 int enumint
= (int) *data
;
3749 e
= der_put_integer(p
, len
, &enumint
, &l
);
3758 e
= der_put_length_and_tag(p
, len
, ret
, ASN1_C_UNIV
, PRIM
, UT_Integer
, &l
);
3770 decode_NAME_TYPE(const unsigned char *p
, size_t len
, NAME_TYPE
* data
, size_t * size
)
3776 memset(data
, 0, sizeof(*data
));
3778 size_t Top_datalen
, Top_oldlen
;
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
) {
3790 if (Top_datalen
> len
) {
3797 e
= der_get_integer(p
, len
, &enumint
, &l
);
3805 len
= Top_oldlen
- Top_datalen
;
3811 free_NAME_TYPE(data
);
3816 free_NAME_TYPE(NAME_TYPE
* data
)
3821 length_NAME_TYPE(const NAME_TYPE
* data
)
3825 int enumint
= *data
;
3826 ret
+= der_length_integer(&enumint
);
3828 ret
+= 1 + der_length_len(ret
);
3833 copy_NAME_TYPE(const NAME_TYPE
* from
, NAME_TYPE
* to
)
3835 memset(to
, 0, sizeof(*to
));