602dcdcdadb8a5e968a7ffb64d7687cf4557953a
[openafs.git] / src / rxkad / v5gen.h
1 /* Generated from /home/lha/src/cvs/heimdal/lib/asn1/k5.asn1 */
2 /* Do not edit */
3
4 #ifndef __krb5_asn1_h__
5 #define __krb5_asn1_h__
6
7 #include <stddef.h>
8 #include <time.h>
9
10 #ifndef __asn1_common_definitions__
11 #define __asn1_common_definitions__
12
13 typedef struct octet_string {
14     size_t length;
15     void *data;
16 } octet_string;
17
18 typedef char *general_string;
19
20 typedef struct oid {
21     size_t length;
22     unsigned *components;
23 } oid;
24
25 #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R)                  \
26   do {                                                         \
27     (BL) = length_##T((S));                                    \
28     (B) = malloc((BL));                                        \
29     if((B) == NULL) {                                          \
30       (R) = ENOMEM;                                            \
31     } else {                                                   \
32       (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
33                        (S), (L));                              \
34       if((R) != 0) {                                           \
35         free((B));                                             \
36         (B) = NULL;                                            \
37       }                                                        \
38     }                                                          \
39   } while (0)
40
41 #endif
42
43 /*
44 NAME-TYPE ::= INTEGER
45 */
46
47 typedef enum NAME_TYPE {
48     KRB5_NT_UNKNOWN = 0,
49     KRB5_NT_PRINCIPAL = 1,
50     KRB5_NT_SRV_INST = 2,
51     KRB5_NT_SRV_HST = 3,
52     KRB5_NT_SRV_XHST = 4,
53     KRB5_NT_UID = 5,
54     KRB5_NT_X500_PRINCIPAL = 6
55 } NAME_TYPE;
56
57 int encode_NAME_TYPE(unsigned char *, size_t, const NAME_TYPE *, size_t *);
58 int decode_NAME_TYPE(const unsigned char *, size_t, NAME_TYPE *, size_t *);
59 void free_NAME_TYPE(NAME_TYPE *);
60 size_t length_NAME_TYPE(const NAME_TYPE *);
61 int copy_NAME_TYPE(const NAME_TYPE *, NAME_TYPE *);
62
63
64 /*
65 MESSAGE-TYPE ::= INTEGER
66 */
67
68 typedef enum MESSAGE_TYPE {
69     krb_as_req = 10,
70     krb_as_rep = 11,
71     krb_tgs_req = 12,
72     krb_tgs_rep = 13,
73     krb_ap_req = 14,
74     krb_ap_rep = 15,
75     krb_safe = 20,
76     krb_priv = 21,
77     krb_cred = 22,
78     krb_error = 30
79 } MESSAGE_TYPE;
80
81 int encode_MESSAGE_TYPE(unsigned char *, size_t, const MESSAGE_TYPE *,
82                         size_t *);
83 int decode_MESSAGE_TYPE(const unsigned char *, size_t, MESSAGE_TYPE *,
84                         size_t *);
85 void free_MESSAGE_TYPE(MESSAGE_TYPE *);
86 size_t length_MESSAGE_TYPE(const MESSAGE_TYPE *);
87 int copy_MESSAGE_TYPE(const MESSAGE_TYPE *, MESSAGE_TYPE *);
88
89
90 /*
91 PADATA-TYPE ::= INTEGER
92 */
93
94 typedef enum PADATA_TYPE {
95     KRB5_PADATA_NONE = 0,
96     KRB5_PADATA_TGS_REQ = 1,
97     KRB5_PADATA_AP_REQ = 1,
98     KRB5_PADATA_ENC_TIMESTAMP = 2,
99     KRB5_PADATA_PW_SALT = 3,
100     KRB5_PADATA_ENC_UNIX_TIME = 5,
101     KRB5_PADATA_SANDIA_SECUREID = 6,
102     KRB5_PADATA_SESAME = 7,
103     KRB5_PADATA_OSF_DCE = 8,
104     KRB5_PADATA_CYBERSAFE_SECUREID = 9,
105     KRB5_PADATA_AFS3_SALT = 10,
106     KRB5_PADATA_ETYPE_INFO = 11,
107     KRB5_PADATA_SAM_CHALLENGE = 12,
108     KRB5_PADATA_SAM_RESPONSE = 13,
109     KRB5_PADATA_PK_AS_REQ = 14,
110     KRB5_PADATA_PK_AS_REP = 15,
111     KRB5_PADATA_PK_AS_SIGN = 16,
112     KRB5_PADATA_PK_KEY_REQ = 17,
113     KRB5_PADATA_PK_KEY_REP = 18,
114     KRB5_PADATA_USE_SPECIFIED_KVNO = 20,
115     KRB5_PADATA_SAM_REDIRECT = 21,
116     KRB5_PADATA_GET_FROM_TYPED_DATA = 22,
117     KRB5_PADATA_SAM_ETYPE_INFO = 23
118 } PADATA_TYPE;
119
120 int encode_PADATA_TYPE(unsigned char *, size_t, const PADATA_TYPE *,
121                        size_t *);
122 int decode_PADATA_TYPE(const unsigned char *, size_t, PADATA_TYPE *,
123                        size_t *);
124 void free_PADATA_TYPE(PADATA_TYPE *);
125 size_t length_PADATA_TYPE(const PADATA_TYPE *);
126 int copy_PADATA_TYPE(const PADATA_TYPE *, PADATA_TYPE *);
127
128
129 /*
130 CKSUMTYPE ::= INTEGER
131 */
132
133 typedef enum CKSUMTYPE {
134     CKSUMTYPE_NONE = 0,
135     CKSUMTYPE_CRC32 = 1,
136     CKSUMTYPE_RSA_MD4 = 2,
137     CKSUMTYPE_RSA_MD4_DES = 3,
138     CKSUMTYPE_DES_MAC = 4,
139     CKSUMTYPE_DES_MAC_K = 5,
140     CKSUMTYPE_RSA_MD4_DES_K = 6,
141     CKSUMTYPE_RSA_MD5 = 7,
142     CKSUMTYPE_RSA_MD5_DES = 8,
143     CKSUMTYPE_RSA_MD5_DES3 = 9,
144     CKSUMTYPE_HMAC_SHA1_DES3 = 12,
145     CKSUMTYPE_SHA1 = 1000,
146     CKSUMTYPE_GSSAPI = 32771,
147     CKSUMTYPE_HMAC_MD5 = -138,
148     CKSUMTYPE_HMAC_MD5_ENC = -1138
149 } CKSUMTYPE;
150
151 int encode_CKSUMTYPE(unsigned char *, size_t, const CKSUMTYPE *, size_t *);
152 int decode_CKSUMTYPE(const unsigned char *, size_t, CKSUMTYPE *, size_t *);
153 void free_CKSUMTYPE(CKSUMTYPE *);
154 size_t length_CKSUMTYPE(const CKSUMTYPE *);
155 int copy_CKSUMTYPE(const CKSUMTYPE *, CKSUMTYPE *);
156
157
158 /*
159 ENCTYPE ::= INTEGER
160 */
161
162 typedef enum ENCTYPE {
163     ETYPE_NULL = 0,
164     ETYPE_DES_CBC_CRC = 1,
165     ETYPE_DES_CBC_MD4 = 2,
166     ETYPE_DES_CBC_MD5 = 3,
167     ETYPE_DES3_CBC_MD5 = 5,
168     ETYPE_OLD_DES3_CBC_SHA1 = 7,
169     ETYPE_SIGN_DSA_GENERATE = 8,
170     ETYPE_ENCRYPT_RSA_PRIV = 9,
171     ETYPE_ENCRYPT_RSA_PUB = 10,
172     ETYPE_DES3_CBC_SHA1 = 16,
173     ETYPE_ARCFOUR_HMAC_MD5 = 23,
174     ETYPE_ARCFOUR_HMAC_MD5_56 = 24,
175     ETYPE_ENCTYPE_PK_CROSS = 48,
176     ETYPE_DES_CBC_NONE = -4096,
177     ETYPE_DES3_CBC_NONE = -4097,
178     ETYPE_DES_CFB64_NONE = -4098,
179     ETYPE_DES_PCBC_NONE = -4099
180 } ENCTYPE;
181
182 int encode_ENCTYPE(unsigned char *, size_t, const ENCTYPE *, size_t *);
183 int decode_ENCTYPE(const unsigned char *, size_t, ENCTYPE *, size_t *);
184 void free_ENCTYPE(ENCTYPE *);
185 size_t length_ENCTYPE(const ENCTYPE *);
186 int copy_ENCTYPE(const ENCTYPE *, ENCTYPE *);
187
188
189 /*
190 UNSIGNED ::= UNSIGNED INTEGER
191 */
192
193 typedef unsigned int UNSIGNED;
194
195 int encode_UNSIGNED(unsigned char *, size_t, const UNSIGNED *, size_t *);
196 int decode_UNSIGNED(const unsigned char *, size_t, UNSIGNED *, size_t *);
197 void free_UNSIGNED(UNSIGNED *);
198 size_t length_UNSIGNED(const UNSIGNED *);
199 int copy_UNSIGNED(const UNSIGNED *, UNSIGNED *);
200
201
202 /*
203 Realm ::= GeneralString
204 */
205
206 typedef general_string Realm;
207
208 int encode_Realm(unsigned char *, size_t, const Realm *, size_t *);
209 int decode_Realm(const unsigned char *, size_t, Realm *, size_t *);
210 void free_Realm(Realm *);
211 size_t length_Realm(const Realm *);
212 int copy_Realm(const Realm *, Realm *);
213
214
215 /*
216 PrincipalName ::= SEQUENCE {
217   name-type[0]    NAME-TYPE,
218   name-string[1]  SEQUENCE OF GeneralString
219 }
220 */
221
222 typedef struct PrincipalName {
223     NAME_TYPE name_type;
224     struct {
225         unsigned int len;
226         general_string *val;
227     } name_string;
228 } PrincipalName;
229
230 int encode_PrincipalName(unsigned char *, size_t, const PrincipalName *,
231                          size_t *);
232 int decode_PrincipalName(const unsigned char *, size_t, PrincipalName *,
233                          size_t *);
234 void free_PrincipalName(PrincipalName *);
235 size_t length_PrincipalName(const PrincipalName *);
236 int copy_PrincipalName(const PrincipalName *, PrincipalName *);
237
238
239 /*
240 Principal ::= SEQUENCE {
241   name[0]         PrincipalName,
242   realm[1]        Realm
243 }
244 */
245
246 typedef struct Principal {
247     PrincipalName name;
248     Realm realm;
249 } Principal;
250
251 int encode_Principal(unsigned char *, size_t, const Principal *, size_t *);
252 int decode_Principal(const unsigned char *, size_t, Principal *, size_t *);
253 void free_Principal(Principal *);
254 size_t length_Principal(const Principal *);
255 int copy_Principal(const Principal *, Principal *);
256
257
258 /*
259 HostAddress ::= SEQUENCE {
260   addr-type[0]    INTEGER,
261   address[1]      OCTET STRING
262 }
263 */
264
265 typedef struct HostAddress {
266     int addr_type;
267     octet_string address;
268 } HostAddress;
269
270 int encode_HostAddress(unsigned char *, size_t, const HostAddress *,
271                        size_t *);
272 int decode_HostAddress(const unsigned char *, size_t, HostAddress *,
273                        size_t *);
274 void free_HostAddress(HostAddress *);
275 size_t length_HostAddress(const HostAddress *);
276 int copy_HostAddress(const HostAddress *, HostAddress *);
277
278
279 /*
280 HostAddresses ::= SEQUENCE OF HostAddress
281 */
282
283 typedef struct HostAddresses {
284     unsigned int len;
285     HostAddress *val;
286 } HostAddresses;
287
288 int encode_HostAddresses(unsigned char *, size_t, const HostAddresses *,
289                          size_t *);
290 int decode_HostAddresses(const unsigned char *, size_t, HostAddresses *,
291                          size_t *);
292 void free_HostAddresses(HostAddresses *);
293 size_t length_HostAddresses(const HostAddresses *);
294 int copy_HostAddresses(const HostAddresses *, HostAddresses *);
295
296
297 /*
298 KerberosTime ::= GeneralizedTime
299 */
300
301 typedef time_t KerberosTime;
302
303 int encode_KerberosTime(unsigned char *, size_t, const KerberosTime *,
304                         size_t *);
305 int decode_KerberosTime(const unsigned char *, size_t, KerberosTime *,
306                         size_t *);
307 void free_KerberosTime(KerberosTime *);
308 size_t length_KerberosTime(const KerberosTime *);
309 int copy_KerberosTime(const KerberosTime *, KerberosTime *);
310
311
312 /*
313 AuthorizationData ::= SEQUENCE OF SEQUENCE {
314   ad-type[0]      INTEGER,
315   ad-data[1]      OCTET STRING
316 }
317 */
318
319 typedef struct AuthorizationData {
320     unsigned int len;
321     struct {
322         int ad_type;
323         octet_string ad_data;
324     } *val;
325 } AuthorizationData;
326
327 int encode_AuthorizationData(unsigned char *, size_t,
328                              const AuthorizationData *, size_t *);
329 int decode_AuthorizationData(const unsigned char *, size_t,
330                              AuthorizationData *, size_t *);
331 void free_AuthorizationData(AuthorizationData *);
332 size_t length_AuthorizationData(const AuthorizationData *);
333 int copy_AuthorizationData(const AuthorizationData *, AuthorizationData *);
334
335
336 /*
337 APOptions ::= BIT STRING {
338   reserved(0),
339   use-session-key(1),
340   mutual-required(2)
341 }
342 */
343
344 typedef struct APOptions {
345     unsigned int reserved:1;
346     unsigned int use_session_key:1;
347     unsigned int mutual_required:1;
348 } APOptions;
349
350
351 int encode_APOptions(unsigned char *, size_t, const APOptions *, size_t *);
352 int decode_APOptions(const unsigned char *, size_t, APOptions *, size_t *);
353 void free_APOptions(APOptions *);
354 size_t length_APOptions(const APOptions *);
355 int copy_APOptions(const APOptions *, APOptions *);
356 unsigned APOptions2int(APOptions);
357 APOptions int2APOptions(unsigned);
358
359 /*
360 TicketFlags ::= BIT STRING {
361   reserved(0),
362   forwardable(1),
363   forwarded(2),
364   proxiable(3),
365   proxy(4),
366   may-postdate(5),
367   postdated(6),
368   invalid(7),
369   renewable(8),
370   initial(9),
371   pre-authent(10),
372   hw-authent(11),
373   transited-policy-checked(12),
374   ok-as-delegate(13),
375   anonymous(14)
376 }
377 */
378
379 typedef struct TicketFlags {
380     unsigned int reserved:1;
381     unsigned int forwardable:1;
382     unsigned int forwarded:1;
383     unsigned int proxiable:1;
384     unsigned int proxy:1;
385     unsigned int may_postdate:1;
386     unsigned int postdated:1;
387     unsigned int invalid:1;
388     unsigned int renewable:1;
389     unsigned int initial:1;
390     unsigned int pre_authent:1;
391     unsigned int hw_authent:1;
392     unsigned int transited_policy_checked:1;
393     unsigned int ok_as_delegate:1;
394     unsigned int anonymous:1;
395 } TicketFlags;
396
397
398 int encode_TicketFlags(unsigned char *, size_t, const TicketFlags *,
399                        size_t *);
400 int decode_TicketFlags(const unsigned char *, size_t, TicketFlags *,
401                        size_t *);
402 void free_TicketFlags(TicketFlags *);
403 size_t length_TicketFlags(const TicketFlags *);
404 int copy_TicketFlags(const TicketFlags *, TicketFlags *);
405 unsigned TicketFlags2int(TicketFlags);
406 TicketFlags int2TicketFlags(unsigned);
407
408 /*
409 KDCOptions ::= BIT STRING {
410   reserved(0),
411   forwardable(1),
412   forwarded(2),
413   proxiable(3),
414   proxy(4),
415   allow-postdate(5),
416   postdated(6),
417   unused7(7),
418   renewable(8),
419   unused9(9),
420   unused10(10),
421   unused11(11),
422   request-anonymous(14),
423   canonicalize(15),
424   disable-transited-check(26),
425   renewable-ok(27),
426   enc-tkt-in-skey(28),
427   renew(30),
428   validate(31)
429 }
430 */
431
432 typedef struct KDCOptions {
433     unsigned int reserved:1;
434     unsigned int forwardable:1;
435     unsigned int forwarded:1;
436     unsigned int proxiable:1;
437     unsigned int proxy:1;
438     unsigned int allow_postdate:1;
439     unsigned int postdated:1;
440     unsigned int unused7:1;
441     unsigned int renewable:1;
442     unsigned int unused9:1;
443     unsigned int unused10:1;
444     unsigned int unused11:1;
445     unsigned int request_anonymous:1;
446     unsigned int canonicalize:1;
447     unsigned int disable_transited_check:1;
448     unsigned int renewable_ok:1;
449     unsigned int enc_tkt_in_skey:1;
450     unsigned int renew:1;
451     unsigned int validate:1;
452 } KDCOptions;
453
454
455 int encode_KDCOptions(unsigned char *, size_t, const KDCOptions *, size_t *);
456 int decode_KDCOptions(const unsigned char *, size_t, KDCOptions *, size_t *);
457 void free_KDCOptions(KDCOptions *);
458 size_t length_KDCOptions(const KDCOptions *);
459 int copy_KDCOptions(const KDCOptions *, KDCOptions *);
460 unsigned KDCOptions2int(KDCOptions);
461 KDCOptions int2KDCOptions(unsigned);
462
463 /*
464 LR-TYPE ::= INTEGER
465 */
466
467 typedef enum LR_TYPE {
468     LR_NONE = 0,
469     LR_INITIAL_TGT = 1,
470     LR_INITIAL = 2,
471     LR_ISSUE_USE_TGT = 3,
472     LR_RENEWAL = 4,
473     LR_REQUEST = 5,
474     LR_PW_EXPTIME = 6,
475     LR_ACCT_EXPTIME = 7
476 } LR_TYPE;
477
478 int encode_LR_TYPE(unsigned char *, size_t, const LR_TYPE *, size_t *);
479 int decode_LR_TYPE(const unsigned char *, size_t, LR_TYPE *, size_t *);
480 void free_LR_TYPE(LR_TYPE *);
481 size_t length_LR_TYPE(const LR_TYPE *);
482 int copy_LR_TYPE(const LR_TYPE *, LR_TYPE *);
483
484
485 /*
486 LastReq ::= SEQUENCE OF SEQUENCE {
487   lr-type[0]      LR-TYPE,
488   lr-value[1]     KerberosTime
489 }
490 */
491
492 typedef struct LastReq {
493     unsigned int len;
494     struct {
495         LR_TYPE lr_type;
496         KerberosTime lr_value;
497     } *val;
498 } LastReq;
499
500 int encode_LastReq(unsigned char *, size_t, const LastReq *, size_t *);
501 int decode_LastReq(const unsigned char *, size_t, LastReq *, size_t *);
502 void free_LastReq(LastReq *);
503 size_t length_LastReq(const LastReq *);
504 int copy_LastReq(const LastReq *, LastReq *);
505
506
507 /*
508 EncryptedData ::= SEQUENCE {
509   etype[0]        ENCTYPE,
510   kvno[1]         INTEGER OPTIONAL,
511   cipher[2]       OCTET STRING
512 }
513 */
514
515 typedef struct EncryptedData {
516     ENCTYPE etype;
517     int *kvno;
518     octet_string cipher;
519 } EncryptedData;
520
521 int encode_EncryptedData(unsigned char *, size_t, const EncryptedData *,
522                          size_t *);
523 int decode_EncryptedData(const unsigned char *, size_t, EncryptedData *,
524                          size_t *);
525 void free_EncryptedData(EncryptedData *);
526 size_t length_EncryptedData(const EncryptedData *);
527 int copy_EncryptedData(const EncryptedData *, EncryptedData *);
528
529
530 /*
531 EncryptionKey ::= SEQUENCE {
532   keytype[0]      INTEGER,
533   keyvalue[1]     OCTET STRING
534 }
535 */
536
537 typedef struct EncryptionKey {
538     int keytype;
539     octet_string keyvalue;
540 } EncryptionKey;
541
542 int encode_EncryptionKey(unsigned char *, size_t, const EncryptionKey *,
543                          size_t *);
544 int decode_EncryptionKey(const unsigned char *, size_t, EncryptionKey *,
545                          size_t *);
546 void free_EncryptionKey(EncryptionKey *);
547 size_t length_EncryptionKey(const EncryptionKey *);
548 int copy_EncryptionKey(const EncryptionKey *, EncryptionKey *);
549
550
551 /*
552 TransitedEncoding ::= SEQUENCE {
553   tr-type[0]      INTEGER,
554   contents[1]     OCTET STRING
555 }
556 */
557
558 typedef struct TransitedEncoding {
559     int tr_type;
560     octet_string contents;
561 } TransitedEncoding;
562
563 int encode_TransitedEncoding(unsigned char *, size_t,
564                              const TransitedEncoding *, size_t *);
565 int decode_TransitedEncoding(const unsigned char *, size_t,
566                              TransitedEncoding *, size_t *);
567 void free_TransitedEncoding(TransitedEncoding *);
568 size_t length_TransitedEncoding(const TransitedEncoding *);
569 int copy_TransitedEncoding(const TransitedEncoding *, TransitedEncoding *);
570
571
572 /*
573 Ticket ::= [APPLICATION 1] SEQUENCE {
574   tkt-vno[0]      INTEGER,
575   realm[1]        Realm,
576   sname[2]        PrincipalName,
577   enc-part[3]     EncryptedData
578 }
579 */
580
581 typedef struct {
582     int tkt_vno;
583     Realm realm;
584     PrincipalName sname;
585     EncryptedData enc_part;
586 } Ticket;
587
588 int encode_Ticket(unsigned char *, size_t, const Ticket *, size_t *);
589 int decode_Ticket(const unsigned char *, size_t, Ticket *, size_t *);
590 void free_Ticket(Ticket *);
591 size_t length_Ticket(const Ticket *);
592 int copy_Ticket(const Ticket *, Ticket *);
593
594
595 /*
596 EncTicketPart ::= [APPLICATION 3] SEQUENCE {
597   flags[0]                TicketFlags,
598   key[1]                  EncryptionKey,
599   crealm[2]               Realm,
600   cname[3]                PrincipalName,
601   transited[4]            TransitedEncoding,
602   authtime[5]             KerberosTime,
603   starttime[6]            KerberosTime OPTIONAL,
604   endtime[7]              KerberosTime,
605   renew-till[8]           KerberosTime OPTIONAL,
606   caddr[9]                HostAddresses OPTIONAL,
607   authorization-data[10]  AuthorizationData OPTIONAL
608 }
609 */
610
611 typedef struct {
612     TicketFlags flags;
613     EncryptionKey key;
614     Realm crealm;
615     PrincipalName cname;
616     TransitedEncoding transited;
617     KerberosTime authtime;
618     KerberosTime *starttime;
619     KerberosTime endtime;
620     KerberosTime *renew_till;
621     HostAddresses *caddr;
622     AuthorizationData *authorization_data;
623 } EncTicketPart;
624
625 int encode_EncTicketPart(unsigned char *, size_t, const EncTicketPart *,
626                          size_t *);
627 int decode_EncTicketPart(const unsigned char *, size_t, EncTicketPart *,
628                          size_t *);
629 void free_EncTicketPart(EncTicketPart *);
630 size_t length_EncTicketPart(const EncTicketPart *);
631 int copy_EncTicketPart(const EncTicketPart *, EncTicketPart *);
632
633
634 /*
635 Checksum ::= SEQUENCE {
636   cksumtype[0]    CKSUMTYPE,
637   checksum[1]     OCTET STRING
638 }
639 */
640
641 typedef struct Checksum {
642     CKSUMTYPE cksumtype;
643     octet_string checksum;
644 } Checksum;
645
646 int encode_Checksum(unsigned char *, size_t, const Checksum *, size_t *);
647 int decode_Checksum(const unsigned char *, size_t, Checksum *, size_t *);
648 void free_Checksum(Checksum *);
649 size_t length_Checksum(const Checksum *);
650 int copy_Checksum(const Checksum *, Checksum *);
651
652
653 /*
654 Authenticator ::= [APPLICATION 2] SEQUENCE {
655   authenticator-vno[0]   INTEGER,
656   crealm[1]              Realm,
657   cname[2]               PrincipalName,
658   cksum[3]               Checksum OPTIONAL,
659   cusec[4]               INTEGER,
660   ctime[5]               KerberosTime,
661   subkey[6]              EncryptionKey OPTIONAL,
662   seq-number[7]          UNSIGNED OPTIONAL,
663   authorization-data[8]  AuthorizationData OPTIONAL
664 }
665 */
666
667 typedef struct {
668     int authenticator_vno;
669     Realm crealm;
670     PrincipalName cname;
671     Checksum *cksum;
672     int cusec;
673     KerberosTime ctime;
674     EncryptionKey *subkey;
675     UNSIGNED *seq_number;
676     AuthorizationData *authorization_data;
677 } Authenticator;
678
679 int encode_Authenticator(unsigned char *, size_t, const Authenticator *,
680                          size_t *);
681 int decode_Authenticator(const unsigned char *, size_t, Authenticator *,
682                          size_t *);
683 void free_Authenticator(Authenticator *);
684 size_t length_Authenticator(const Authenticator *);
685 int copy_Authenticator(const Authenticator *, Authenticator *);
686
687
688 /*
689 PA-DATA ::= SEQUENCE {
690   padata-type[1]   PADATA-TYPE,
691   padata-value[2]  OCTET STRING
692 }
693 */
694
695 typedef struct PA_DATA {
696     PADATA_TYPE padata_type;
697     octet_string padata_value;
698 } PA_DATA;
699
700 int encode_PA_DATA(unsigned char *, size_t, const PA_DATA *, size_t *);
701 int decode_PA_DATA(const unsigned char *, size_t, PA_DATA *, size_t *);
702 void free_PA_DATA(PA_DATA *);
703 size_t length_PA_DATA(const PA_DATA *);
704 int copy_PA_DATA(const PA_DATA *, PA_DATA *);
705
706
707 /*
708 ETYPE-INFO-ENTRY ::= SEQUENCE {
709   etype[0]        ENCTYPE,
710   salt[1]         OCTET STRING OPTIONAL,
711   salttype[2]     INTEGER OPTIONAL
712 }
713 */
714
715 typedef struct ETYPE_INFO_ENTRY {
716     ENCTYPE etype;
717     octet_string *salt;
718     int *salttype;
719 } ETYPE_INFO_ENTRY;
720
721 int encode_ETYPE_INFO_ENTRY(unsigned char *, size_t, const ETYPE_INFO_ENTRY *,
722                             size_t *);
723 int decode_ETYPE_INFO_ENTRY(const unsigned char *, size_t, ETYPE_INFO_ENTRY *,
724                             size_t *);
725 void free_ETYPE_INFO_ENTRY(ETYPE_INFO_ENTRY *);
726 size_t length_ETYPE_INFO_ENTRY(const ETYPE_INFO_ENTRY *);
727 int copy_ETYPE_INFO_ENTRY(const ETYPE_INFO_ENTRY *, ETYPE_INFO_ENTRY *);
728
729
730 /*
731 ETYPE-INFO ::= SEQUENCE OF ETYPE-INFO-ENTRY
732 */
733
734 typedef struct ETYPE_INFO {
735     unsigned int len;
736     ETYPE_INFO_ENTRY *val;
737 } ETYPE_INFO;
738
739 int encode_ETYPE_INFO(unsigned char *, size_t, const ETYPE_INFO *, size_t *);
740 int decode_ETYPE_INFO(const unsigned char *, size_t, ETYPE_INFO *, size_t *);
741 void free_ETYPE_INFO(ETYPE_INFO *);
742 size_t length_ETYPE_INFO(const ETYPE_INFO *);
743 int copy_ETYPE_INFO(const ETYPE_INFO *, ETYPE_INFO *);
744
745
746 /*
747 METHOD-DATA ::= SEQUENCE OF PA-DATA
748 */
749
750 typedef struct METHOD_DATA {
751     unsigned int len;
752     PA_DATA *val;
753 } METHOD_DATA;
754
755 int encode_METHOD_DATA(unsigned char *, size_t, const METHOD_DATA *,
756                        size_t *);
757 int decode_METHOD_DATA(const unsigned char *, size_t, METHOD_DATA *,
758                        size_t *);
759 void free_METHOD_DATA(METHOD_DATA *);
760 size_t length_METHOD_DATA(const METHOD_DATA *);
761 int copy_METHOD_DATA(const METHOD_DATA *, METHOD_DATA *);
762
763
764 /*
765 KDC-REQ-BODY ::= SEQUENCE {
766   kdc-options[0]              KDCOptions,
767   cname[1]                    PrincipalName OPTIONAL,
768   realm[2]                    Realm,
769   sname[3]                    PrincipalName OPTIONAL,
770   from[4]                     KerberosTime OPTIONAL,
771   till[5]                     KerberosTime OPTIONAL,
772   rtime[6]                    KerberosTime OPTIONAL,
773   nonce[7]                    INTEGER,
774   etype[8]                    SEQUENCE OF ENCTYPE,
775   addresses[9]                HostAddresses OPTIONAL,
776   enc-authorization-data[10]  EncryptedData OPTIONAL,
777   additional-tickets[11]      SEQUENCE OF Ticket OPTIONAL
778 }
779 */
780
781 typedef struct KDC_REQ_BODY {
782     KDCOptions kdc_options;
783     PrincipalName *cname;
784     Realm realm;
785     PrincipalName *sname;
786     KerberosTime *from;
787     KerberosTime *till;
788     KerberosTime *rtime;
789     int nonce;
790     struct {
791         unsigned int len;
792         ENCTYPE *val;
793     } etype;
794     HostAddresses *addresses;
795     EncryptedData *enc_authorization_data;
796     struct {
797         unsigned int len;
798         Ticket *val;
799     } *additional_tickets;
800 } KDC_REQ_BODY;
801
802 int encode_KDC_REQ_BODY(unsigned char *, size_t, const KDC_REQ_BODY *,
803                         size_t *);
804 int decode_KDC_REQ_BODY(const unsigned char *, size_t, KDC_REQ_BODY *,
805                         size_t *);
806 void free_KDC_REQ_BODY(KDC_REQ_BODY *);
807 size_t length_KDC_REQ_BODY(const KDC_REQ_BODY *);
808 int copy_KDC_REQ_BODY(const KDC_REQ_BODY *, KDC_REQ_BODY *);
809
810
811 /*
812 KDC-REQ ::= SEQUENCE {
813   pvno[1]         INTEGER,
814   msg-type[2]     MESSAGE-TYPE,
815   padata[3]       METHOD-DATA OPTIONAL,
816   req-body[4]     KDC-REQ-BODY
817 }
818 */
819
820 typedef struct KDC_REQ {
821     int pvno;
822     MESSAGE_TYPE msg_type;
823     METHOD_DATA *padata;
824     KDC_REQ_BODY req_body;
825 } KDC_REQ;
826
827 int encode_KDC_REQ(unsigned char *, size_t, const KDC_REQ *, size_t *);
828 int decode_KDC_REQ(const unsigned char *, size_t, KDC_REQ *, size_t *);
829 void free_KDC_REQ(KDC_REQ *);
830 size_t length_KDC_REQ(const KDC_REQ *);
831 int copy_KDC_REQ(const KDC_REQ *, KDC_REQ *);
832
833
834 /*
835 AS-REQ ::= [APPLICATION 10] KDC-REQ
836 */
837
838 typedef KDC_REQ AS_REQ;
839
840 int encode_AS_REQ(unsigned char *, size_t, const AS_REQ *, size_t *);
841 int decode_AS_REQ(const unsigned char *, size_t, AS_REQ *, size_t *);
842 void free_AS_REQ(AS_REQ *);
843 size_t length_AS_REQ(const AS_REQ *);
844 int copy_AS_REQ(const AS_REQ *, AS_REQ *);
845
846
847 /*
848 TGS-REQ ::= [APPLICATION 12] KDC-REQ
849 */
850
851 typedef KDC_REQ TGS_REQ;
852
853 int encode_TGS_REQ(unsigned char *, size_t, const TGS_REQ *, size_t *);
854 int decode_TGS_REQ(const unsigned char *, size_t, TGS_REQ *, size_t *);
855 void free_TGS_REQ(TGS_REQ *);
856 size_t length_TGS_REQ(const TGS_REQ *);
857 int copy_TGS_REQ(const TGS_REQ *, TGS_REQ *);
858
859
860 /*
861 PA-ENC-TS-ENC ::= SEQUENCE {
862   patimestamp[0]  KerberosTime,
863   pausec[1]       INTEGER OPTIONAL
864 }
865 */
866
867 typedef struct PA_ENC_TS_ENC {
868     KerberosTime patimestamp;
869     int *pausec;
870 } PA_ENC_TS_ENC;
871
872 int encode_PA_ENC_TS_ENC(unsigned char *, size_t, const PA_ENC_TS_ENC *,
873                          size_t *);
874 int decode_PA_ENC_TS_ENC(const unsigned char *, size_t, PA_ENC_TS_ENC *,
875                          size_t *);
876 void free_PA_ENC_TS_ENC(PA_ENC_TS_ENC *);
877 size_t length_PA_ENC_TS_ENC(const PA_ENC_TS_ENC *);
878 int copy_PA_ENC_TS_ENC(const PA_ENC_TS_ENC *, PA_ENC_TS_ENC *);
879
880
881 /*
882 KDC-REP ::= SEQUENCE {
883   pvno[0]         INTEGER,
884   msg-type[1]     MESSAGE-TYPE,
885   padata[2]       METHOD-DATA OPTIONAL,
886   crealm[3]       Realm,
887   cname[4]        PrincipalName,
888   ticket[5]       Ticket,
889   enc-part[6]     EncryptedData
890 }
891 */
892
893 typedef struct KDC_REP {
894     int pvno;
895     MESSAGE_TYPE msg_type;
896     METHOD_DATA *padata;
897     Realm crealm;
898     PrincipalName cname;
899     Ticket ticket;
900     EncryptedData enc_part;
901 } KDC_REP;
902
903 int encode_KDC_REP(unsigned char *, size_t, const KDC_REP *, size_t *);
904 int decode_KDC_REP(const unsigned char *, size_t, KDC_REP *, size_t *);
905 void free_KDC_REP(KDC_REP *);
906 size_t length_KDC_REP(const KDC_REP *);
907 int copy_KDC_REP(const KDC_REP *, KDC_REP *);
908
909
910 /*
911 AS-REP ::= [APPLICATION 11] KDC-REP
912 */
913
914 typedef KDC_REP AS_REP;
915
916 int encode_AS_REP(unsigned char *, size_t, const AS_REP *, size_t *);
917 int decode_AS_REP(const unsigned char *, size_t, AS_REP *, size_t *);
918 void free_AS_REP(AS_REP *);
919 size_t length_AS_REP(const AS_REP *);
920 int copy_AS_REP(const AS_REP *, AS_REP *);
921
922
923 /*
924 TGS-REP ::= [APPLICATION 13] KDC-REP
925 */
926
927 typedef KDC_REP TGS_REP;
928
929 int encode_TGS_REP(unsigned char *, size_t, const TGS_REP *, size_t *);
930 int decode_TGS_REP(const unsigned char *, size_t, TGS_REP *, size_t *);
931 void free_TGS_REP(TGS_REP *);
932 size_t length_TGS_REP(const TGS_REP *);
933 int copy_TGS_REP(const TGS_REP *, TGS_REP *);
934
935
936 /*
937 EncKDCRepPart ::= SEQUENCE {
938   key[0]             EncryptionKey,
939   last-req[1]        LastReq,
940   nonce[2]           INTEGER,
941   key-expiration[3]  KerberosTime OPTIONAL,
942   flags[4]           TicketFlags,
943   authtime[5]        KerberosTime,
944   starttime[6]       KerberosTime OPTIONAL,
945   endtime[7]         KerberosTime,
946   renew-till[8]      KerberosTime OPTIONAL,
947   srealm[9]          Realm,
948   sname[10]          PrincipalName,
949   caddr[11]          HostAddresses OPTIONAL
950 }
951 */
952
953 typedef struct EncKDCRepPart {
954     EncryptionKey key;
955     LastReq last_req;
956     int nonce;
957     KerberosTime *key_expiration;
958     TicketFlags flags;
959     KerberosTime authtime;
960     KerberosTime *starttime;
961     KerberosTime endtime;
962     KerberosTime *renew_till;
963     Realm srealm;
964     PrincipalName sname;
965     HostAddresses *caddr;
966 } EncKDCRepPart;
967
968 int encode_EncKDCRepPart(unsigned char *, size_t, const EncKDCRepPart *,
969                          size_t *);
970 int decode_EncKDCRepPart(const unsigned char *, size_t, EncKDCRepPart *,
971                          size_t *);
972 void free_EncKDCRepPart(EncKDCRepPart *);
973 size_t length_EncKDCRepPart(const EncKDCRepPart *);
974 int copy_EncKDCRepPart(const EncKDCRepPart *, EncKDCRepPart *);
975
976
977 /*
978 EncASRepPart ::= [APPLICATION 25] EncKDCRepPart
979 */
980
981 typedef EncKDCRepPart EncASRepPart;
982
983 int encode_EncASRepPart(unsigned char *, size_t, const EncASRepPart *,
984                         size_t *);
985 int decode_EncASRepPart(const unsigned char *, size_t, EncASRepPart *,
986                         size_t *);
987 void free_EncASRepPart(EncASRepPart *);
988 size_t length_EncASRepPart(const EncASRepPart *);
989 int copy_EncASRepPart(const EncASRepPart *, EncASRepPart *);
990
991
992 /*
993 EncTGSRepPart ::= [APPLICATION 26] EncKDCRepPart
994 */
995
996 typedef EncKDCRepPart EncTGSRepPart;
997
998 int encode_EncTGSRepPart(unsigned char *, size_t, const EncTGSRepPart *,
999                          size_t *);
1000 int decode_EncTGSRepPart(const unsigned char *, size_t, EncTGSRepPart *,
1001                          size_t *);
1002 void free_EncTGSRepPart(EncTGSRepPart *);
1003 size_t length_EncTGSRepPart(const EncTGSRepPart *);
1004 int copy_EncTGSRepPart(const EncTGSRepPart *, EncTGSRepPart *);
1005
1006
1007 /*
1008 AP-REQ ::= [APPLICATION 14] SEQUENCE {
1009   pvno[0]           INTEGER,
1010   msg-type[1]       MESSAGE-TYPE,
1011   ap-options[2]     APOptions,
1012   ticket[3]         Ticket,
1013   authenticator[4]  EncryptedData
1014 }
1015 */
1016
1017 typedef struct {
1018     int pvno;
1019     MESSAGE_TYPE msg_type;
1020     APOptions ap_options;
1021     Ticket ticket;
1022     EncryptedData authenticator;
1023 } AP_REQ;
1024
1025 int encode_AP_REQ(unsigned char *, size_t, const AP_REQ *, size_t *);
1026 int decode_AP_REQ(const unsigned char *, size_t, AP_REQ *, size_t *);
1027 void free_AP_REQ(AP_REQ *);
1028 size_t length_AP_REQ(const AP_REQ *);
1029 int copy_AP_REQ(const AP_REQ *, AP_REQ *);
1030
1031
1032 /*
1033 AP-REP ::= [APPLICATION 15] SEQUENCE {
1034   pvno[0]         INTEGER,
1035   msg-type[1]     MESSAGE-TYPE,
1036   enc-part[2]     EncryptedData
1037 }
1038 */
1039
1040 typedef struct {
1041     int pvno;
1042     MESSAGE_TYPE msg_type;
1043     EncryptedData enc_part;
1044 } AP_REP;
1045
1046 int encode_AP_REP(unsigned char *, size_t, const AP_REP *, size_t *);
1047 int decode_AP_REP(const unsigned char *, size_t, AP_REP *, size_t *);
1048 void free_AP_REP(AP_REP *);
1049 size_t length_AP_REP(const AP_REP *);
1050 int copy_AP_REP(const AP_REP *, AP_REP *);
1051
1052
1053 /*
1054 EncAPRepPart ::= [APPLICATION 27] SEQUENCE {
1055   ctime[0]        KerberosTime,
1056   cusec[1]        INTEGER,
1057   subkey[2]       EncryptionKey OPTIONAL,
1058   seq-number[3]   UNSIGNED OPTIONAL
1059 }
1060 */
1061
1062 typedef struct {
1063     KerberosTime ctime;
1064     int cusec;
1065     EncryptionKey *subkey;
1066     UNSIGNED *seq_number;
1067 } EncAPRepPart;
1068
1069 int encode_EncAPRepPart(unsigned char *, size_t, const EncAPRepPart *,
1070                         size_t *);
1071 int decode_EncAPRepPart(const unsigned char *, size_t, EncAPRepPart *,
1072                         size_t *);
1073 void free_EncAPRepPart(EncAPRepPart *);
1074 size_t length_EncAPRepPart(const EncAPRepPart *);
1075 int copy_EncAPRepPart(const EncAPRepPart *, EncAPRepPart *);
1076
1077
1078 /*
1079 KRB-SAFE-BODY ::= SEQUENCE {
1080   user-data[0]    OCTET STRING,
1081   timestamp[1]    KerberosTime OPTIONAL,
1082   usec[2]         INTEGER OPTIONAL,
1083   seq-number[3]   UNSIGNED OPTIONAL,
1084   s-address[4]    HostAddress OPTIONAL,
1085   r-address[5]    HostAddress OPTIONAL
1086 }
1087 */
1088
1089 typedef struct KRB_SAFE_BODY {
1090     octet_string user_data;
1091     KerberosTime *timestamp;
1092     int *usec;
1093     UNSIGNED *seq_number;
1094     HostAddress *s_address;
1095     HostAddress *r_address;
1096 } KRB_SAFE_BODY;
1097
1098 int encode_KRB_SAFE_BODY(unsigned char *, size_t, const KRB_SAFE_BODY *,
1099                          size_t *);
1100 int decode_KRB_SAFE_BODY(const unsigned char *, size_t, KRB_SAFE_BODY *,
1101                          size_t *);
1102 void free_KRB_SAFE_BODY(KRB_SAFE_BODY *);
1103 size_t length_KRB_SAFE_BODY(const KRB_SAFE_BODY *);
1104 int copy_KRB_SAFE_BODY(const KRB_SAFE_BODY *, KRB_SAFE_BODY *);
1105
1106
1107 /*
1108 KRB-SAFE ::= [APPLICATION 20] SEQUENCE {
1109   pvno[0]         INTEGER,
1110   msg-type[1]     MESSAGE-TYPE,
1111   safe-body[2]    KRB-SAFE-BODY,
1112   cksum[3]        Checksum
1113 }
1114 */
1115
1116 typedef struct {
1117     int pvno;
1118     MESSAGE_TYPE msg_type;
1119     KRB_SAFE_BODY safe_body;
1120     Checksum cksum;
1121 } KRB_SAFE;
1122
1123 int encode_KRB_SAFE(unsigned char *, size_t, const KRB_SAFE *, size_t *);
1124 int decode_KRB_SAFE(const unsigned char *, size_t, KRB_SAFE *, size_t *);
1125 void free_KRB_SAFE(KRB_SAFE *);
1126 size_t length_KRB_SAFE(const KRB_SAFE *);
1127 int copy_KRB_SAFE(const KRB_SAFE *, KRB_SAFE *);
1128
1129
1130 /*
1131 KRB-PRIV ::= [APPLICATION 21] SEQUENCE {
1132   pvno[0]         INTEGER,
1133   msg-type[1]     MESSAGE-TYPE,
1134   enc-part[3]     EncryptedData
1135 }
1136 */
1137
1138 typedef struct {
1139     int pvno;
1140     MESSAGE_TYPE msg_type;
1141     EncryptedData enc_part;
1142 } KRB_PRIV;
1143
1144 int encode_KRB_PRIV(unsigned char *, size_t, const KRB_PRIV *, size_t *);
1145 int decode_KRB_PRIV(const unsigned char *, size_t, KRB_PRIV *, size_t *);
1146 void free_KRB_PRIV(KRB_PRIV *);
1147 size_t length_KRB_PRIV(const KRB_PRIV *);
1148 int copy_KRB_PRIV(const KRB_PRIV *, KRB_PRIV *);
1149
1150
1151 /*
1152 EncKrbPrivPart ::= [APPLICATION 28] SEQUENCE {
1153   user-data[0]    OCTET STRING,
1154   timestamp[1]    KerberosTime OPTIONAL,
1155   usec[2]         INTEGER OPTIONAL,
1156   seq-number[3]   UNSIGNED OPTIONAL,
1157   s-address[4]    HostAddress OPTIONAL,
1158   r-address[5]    HostAddress OPTIONAL
1159 }
1160 */
1161
1162 typedef struct {
1163     octet_string user_data;
1164     KerberosTime *timestamp;
1165     int *usec;
1166     UNSIGNED *seq_number;
1167     HostAddress *s_address;
1168     HostAddress *r_address;
1169 } EncKrbPrivPart;
1170
1171 int encode_EncKrbPrivPart(unsigned char *, size_t, const EncKrbPrivPart *,
1172                           size_t *);
1173 int decode_EncKrbPrivPart(const unsigned char *, size_t, EncKrbPrivPart *,
1174                           size_t *);
1175 void free_EncKrbPrivPart(EncKrbPrivPart *);
1176 size_t length_EncKrbPrivPart(const EncKrbPrivPart *);
1177 int copy_EncKrbPrivPart(const EncKrbPrivPart *, EncKrbPrivPart *);
1178
1179
1180 /*
1181 KRB-CRED ::= [APPLICATION 22] SEQUENCE {
1182   pvno[0]         INTEGER,
1183   msg-type[1]     MESSAGE-TYPE,
1184   tickets[2]      SEQUENCE OF Ticket,
1185   enc-part[3]     EncryptedData
1186 }
1187 */
1188
1189 typedef struct {
1190     int pvno;
1191     MESSAGE_TYPE msg_type;
1192     struct {
1193         unsigned int len;
1194         Ticket *val;
1195     } tickets;
1196     EncryptedData enc_part;
1197 } KRB_CRED;
1198
1199 int encode_KRB_CRED(unsigned char *, size_t, const KRB_CRED *, size_t *);
1200 int decode_KRB_CRED(const unsigned char *, size_t, KRB_CRED *, size_t *);
1201 void free_KRB_CRED(KRB_CRED *);
1202 size_t length_KRB_CRED(const KRB_CRED *);
1203 int copy_KRB_CRED(const KRB_CRED *, KRB_CRED *);
1204
1205
1206 /*
1207 KrbCredInfo ::= SEQUENCE {
1208   key[0]          EncryptionKey,
1209   prealm[1]       Realm OPTIONAL,
1210   pname[2]        PrincipalName OPTIONAL,
1211   flags[3]        TicketFlags OPTIONAL,
1212   authtime[4]     KerberosTime OPTIONAL,
1213   starttime[5]    KerberosTime OPTIONAL,
1214   endtime[6]      KerberosTime OPTIONAL,
1215   renew-till[7]   KerberosTime OPTIONAL,
1216   srealm[8]       Realm OPTIONAL,
1217   sname[9]        PrincipalName OPTIONAL,
1218   caddr[10]       HostAddresses OPTIONAL
1219 }
1220 */
1221
1222 typedef struct KrbCredInfo {
1223     EncryptionKey key;
1224     Realm *prealm;
1225     PrincipalName *pname;
1226     TicketFlags *flags;
1227     KerberosTime *authtime;
1228     KerberosTime *starttime;
1229     KerberosTime *endtime;
1230     KerberosTime *renew_till;
1231     Realm *srealm;
1232     PrincipalName *sname;
1233     HostAddresses *caddr;
1234 } KrbCredInfo;
1235
1236 int encode_KrbCredInfo(unsigned char *, size_t, const KrbCredInfo *,
1237                        size_t *);
1238 int decode_KrbCredInfo(const unsigned char *, size_t, KrbCredInfo *,
1239                        size_t *);
1240 void free_KrbCredInfo(KrbCredInfo *);
1241 size_t length_KrbCredInfo(const KrbCredInfo *);
1242 int copy_KrbCredInfo(const KrbCredInfo *, KrbCredInfo *);
1243
1244
1245 /*
1246 EncKrbCredPart ::= [APPLICATION 29] SEQUENCE {
1247   ticket-info[0]  SEQUENCE OF KrbCredInfo,
1248   nonce[1]        INTEGER OPTIONAL,
1249   timestamp[2]    KerberosTime OPTIONAL,
1250   usec[3]         INTEGER OPTIONAL,
1251   s-address[4]    HostAddress OPTIONAL,
1252   r-address[5]    HostAddress OPTIONAL
1253 }
1254 */
1255
1256 typedef struct {
1257     struct {
1258         unsigned int len;
1259         KrbCredInfo *val;
1260     } ticket_info;
1261     int *nonce;
1262     KerberosTime *timestamp;
1263     int *usec;
1264     HostAddress *s_address;
1265     HostAddress *r_address;
1266 } EncKrbCredPart;
1267
1268 int encode_EncKrbCredPart(unsigned char *, size_t, const EncKrbCredPart *,
1269                           size_t *);
1270 int decode_EncKrbCredPart(const unsigned char *, size_t, EncKrbCredPart *,
1271                           size_t *);
1272 void free_EncKrbCredPart(EncKrbCredPart *);
1273 size_t length_EncKrbCredPart(const EncKrbCredPart *);
1274 int copy_EncKrbCredPart(const EncKrbCredPart *, EncKrbCredPart *);
1275
1276
1277 /*
1278 KRB-ERROR ::= [APPLICATION 30] SEQUENCE {
1279   pvno[0]         INTEGER,
1280   msg-type[1]     MESSAGE-TYPE,
1281   ctime[2]        KerberosTime OPTIONAL,
1282   cusec[3]        INTEGER OPTIONAL,
1283   stime[4]        KerberosTime,
1284   susec[5]        INTEGER,
1285   error-code[6]   INTEGER,
1286   crealm[7]       Realm OPTIONAL,
1287   cname[8]        PrincipalName OPTIONAL,
1288   realm[9]        Realm,
1289   sname[10]       PrincipalName,
1290   e-text[11]      GeneralString OPTIONAL,
1291   e-data[12]      OCTET STRING OPTIONAL
1292 }
1293 */
1294
1295 typedef struct {
1296     int pvno;
1297     MESSAGE_TYPE msg_type;
1298     KerberosTime *ctime;
1299     int *cusec;
1300     KerberosTime stime;
1301     int susec;
1302     int error_code;
1303     Realm *crealm;
1304     PrincipalName *cname;
1305     Realm realm;
1306     PrincipalName sname;
1307     general_string *e_text;
1308     octet_string *e_data;
1309 } KRB_ERROR;
1310
1311 int encode_KRB_ERROR(unsigned char *, size_t, const KRB_ERROR *, size_t *);
1312 int decode_KRB_ERROR(const unsigned char *, size_t, KRB_ERROR *, size_t *);
1313 void free_KRB_ERROR(KRB_ERROR *);
1314 size_t length_KRB_ERROR(const KRB_ERROR *);
1315 int copy_KRB_ERROR(const KRB_ERROR *, KRB_ERROR *);
1316
1317
1318 enum { pvno = 5 };
1319
1320 enum { DOMAIN_X500_COMPRESS = 1 };
1321
1322 #endif /* __krb5_asn1_h__ */