5ca4f9779bc3d1c68b3b41730b103ca39461b611
[openafs.git] / src / rxkad / v5gen.h
1 /* Generated from ./krb5.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 heim_integer {
14   size_t length;
15   void *data;
16   int negative;
17 } heim_integer;
18
19 typedef struct heim_octet_string {
20   size_t length;
21   void *data;
22 } heim_octet_string;
23
24 typedef char *heim_general_string;
25
26 typedef char *heim_utf8_string;
27
28 typedef char *heim_printable_string;
29
30 typedef char *heim_ia5_string;
31
32 typedef struct heim_bmp_string {
33   size_t length;
34   afs_uint16 *data;
35 } heim_bmp_string;
36
37 typedef struct heim_universal_string {
38   size_t length;
39   afs_uint32 *data;
40 } heim_universal_string;
41
42 typedef char *heim_visible_string;
43
44 typedef struct heim_oid {
45   size_t length;
46   unsigned *components;
47 } heim_oid;
48
49 typedef struct heim_bit_string {
50   size_t length;
51   void *data;
52 } heim_bit_string;
53
54 typedef struct heim_octet_string heim_any;
55 typedef struct heim_octet_string heim_any_set;
56
57 #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R)                  \
58   do {                                                         \
59     (BL) = length_##T((S));                                    \
60     (B) = malloc((BL));                                        \
61     if((B) == NULL) {                                          \
62       (R) = ENOMEM;                                            \
63     } else {                                                   \
64       (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
65                        (S), (L));                              \
66       if((R) != 0) {                                           \
67         free((B));                                             \
68         (B) = NULL;                                            \
69       }                                                        \
70     }                                                          \
71   } while (0)
72
73
74 #endif
75
76 /*
77 NAME-TYPE ::= INTEGER {
78   KRB5_NT_UNKNOWN(0),
79   KRB5_NT_PRINCIPAL(1),
80   KRB5_NT_SRV_INST(2),
81   KRB5_NT_SRV_HST(3),
82   KRB5_NT_SRV_XHST(4),
83   KRB5_NT_UID(5),
84   KRB5_NT_X500_PRINCIPAL(6),
85   KRB5_NT_SMTP_NAME(7),
86   KRB5_NT_ENTERPRISE_PRINCIPAL(10),
87   KRB5_NT_WELLKNOWN(11),
88   KRB5_NT_ENT_PRINCIPAL_AND_ID(-130),
89   KRB5_NT_MS_PRINCIPAL(-128),
90   KRB5_NT_MS_PRINCIPAL_AND_ID(-129),
91   KRB5_NT_NTLM(-1200)
92 }
93 */
94
95 typedef enum NAME_TYPE {
96   KRB5_NT_UNKNOWN = 0,
97   KRB5_NT_PRINCIPAL = 1,
98   KRB5_NT_SRV_INST = 2,
99   KRB5_NT_SRV_HST = 3,
100   KRB5_NT_SRV_XHST = 4,
101   KRB5_NT_UID = 5,
102   KRB5_NT_X500_PRINCIPAL = 6,
103   KRB5_NT_SMTP_NAME = 7,
104   KRB5_NT_ENTERPRISE_PRINCIPAL = 10,
105   KRB5_NT_WELLKNOWN = 11,
106   KRB5_NT_ENT_PRINCIPAL_AND_ID = -130,
107   KRB5_NT_MS_PRINCIPAL = -128,
108   KRB5_NT_MS_PRINCIPAL_AND_ID = -129,
109   KRB5_NT_NTLM = -1200
110 } NAME_TYPE;
111
112 int    decode_NAME_TYPE(const unsigned char *, size_t, NAME_TYPE *, size_t *);
113 int    encode_NAME_TYPE(unsigned char *, size_t, const NAME_TYPE *, size_t *);
114 size_t length_NAME_TYPE(const NAME_TYPE *);
115 int    copy_NAME_TYPE  (const NAME_TYPE *, NAME_TYPE *);
116 void   free_NAME_TYPE  (NAME_TYPE *);
117
118
119 /*
120 MESSAGE-TYPE ::= INTEGER {
121   krb_as_req(10),
122   krb_as_rep(11),
123   krb_tgs_req(12),
124   krb_tgs_rep(13),
125   krb_ap_req(14),
126   krb_ap_rep(15),
127   krb_safe(20),
128   krb_priv(21),
129   krb_cred(22),
130   krb_error(30)
131 }
132 */
133
134 typedef enum MESSAGE_TYPE {
135   krb_as_req = 10,
136   krb_as_rep = 11,
137   krb_tgs_req = 12,
138   krb_tgs_rep = 13,
139   krb_ap_req = 14,
140   krb_ap_rep = 15,
141   krb_safe = 20,
142   krb_priv = 21,
143   krb_cred = 22,
144   krb_error = 30
145 } MESSAGE_TYPE;
146
147 int    decode_MESSAGE_TYPE(const unsigned char *, size_t, MESSAGE_TYPE *, size_t *);
148 int    encode_MESSAGE_TYPE(unsigned char *, size_t, const MESSAGE_TYPE *, size_t *);
149 size_t length_MESSAGE_TYPE(const MESSAGE_TYPE *);
150 int    copy_MESSAGE_TYPE  (const MESSAGE_TYPE *, MESSAGE_TYPE *);
151 void   free_MESSAGE_TYPE  (MESSAGE_TYPE *);
152
153
154 /*
155 PADATA-TYPE ::= INTEGER {
156   KRB5_PADATA_NONE(0),
157   KRB5_PADATA_TGS_REQ(1),
158   KRB5_PADATA_AP_REQ(1),
159   KRB5_PADATA_ENC_TIMESTAMP(2),
160   KRB5_PADATA_PW_SALT(3),
161   KRB5_PADATA_ENC_UNIX_TIME(5),
162   KRB5_PADATA_SANDIA_SECUREID(6),
163   KRB5_PADATA_SESAME(7),
164   KRB5_PADATA_OSF_DCE(8),
165   KRB5_PADATA_CYBERSAFE_SECUREID(9),
166   KRB5_PADATA_AFS3_SALT(10),
167   KRB5_PADATA_ETYPE_INFO(11),
168   KRB5_PADATA_SAM_CHALLENGE(12),
169   KRB5_PADATA_SAM_RESPONSE(13),
170   KRB5_PADATA_PK_AS_REQ_19(14),
171   KRB5_PADATA_PK_AS_REP_19(15),
172   KRB5_PADATA_PK_AS_REQ_WIN(15),
173   KRB5_PADATA_PK_AS_REQ(16),
174   KRB5_PADATA_PK_AS_REP(17),
175   KRB5_PADATA_PA_PK_OCSP_RESPONSE(18),
176   KRB5_PADATA_ETYPE_INFO2(19),
177   KRB5_PADATA_USE_SPECIFIED_KVNO(20),
178   KRB5_PADATA_SVR_REFERRAL_INFO(20),
179   KRB5_PADATA_SAM_REDIRECT(21),
180   KRB5_PADATA_GET_FROM_TYPED_DATA(22),
181   KRB5_PADATA_SAM_ETYPE_INFO(23),
182   KRB5_PADATA_SERVER_REFERRAL(25),
183   KRB5_PADATA_ALT_PRINC(24),
184   KRB5_PADATA_SAM_CHALLENGE2(30),
185   KRB5_PADATA_SAM_RESPONSE2(31),
186   KRB5_PA_EXTRA_TGT(41),
187   KRB5_PADATA_TD_KRB_PRINCIPAL(102),
188   KRB5_PADATA_PK_TD_TRUSTED_CERTIFIERS(104),
189   KRB5_PADATA_PK_TD_CERTIFICATE_INDEX(105),
190   KRB5_PADATA_TD_APP_DEFINED_ERROR(106),
191   KRB5_PADATA_TD_REQ_NONCE(107),
192   KRB5_PADATA_TD_REQ_SEQ(108),
193   KRB5_PADATA_PA_PAC_REQUEST(128),
194   KRB5_PADATA_FOR_USER(129),
195   KRB5_PADATA_FOR_X509_USER(130),
196   KRB5_PADATA_FOR_CHECK_DUPS(131),
197   KRB5_PADATA_AS_CHECKSUM(132),
198   KRB5_PADATA_PK_AS_09_BINDING(132),
199   KRB5_PADATA_CLIENT_CANONICALIZED(133),
200   KRB5_PADATA_FX_COOKIE(133),
201   KRB5_PADATA_AUTHENTICATION_SET(134),
202   KRB5_PADATA_AUTH_SET_SELECTED(135),
203   KRB5_PADATA_FX_FAST(136),
204   KRB5_PADATA_FX_ERROR(137),
205   KRB5_PADATA_ENCRYPTED_CHALLENGE(138),
206   KRB5_PADATA_OTP_CHALLENGE(141),
207   KRB5_PADATA_OTP_REQUEST(142),
208   KBB5_PADATA_OTP_CONFIRM(143),
209   KRB5_PADATA_OTP_PIN_CHANGE(144),
210   KRB5_PADATA_EPAK_AS_REQ(145),
211   KRB5_PADATA_EPAK_AS_REP(146),
212   KRB5_PADATA_PKINIT_KX(147),
213   KRB5_PADATA_PKU2U_NAME(148),
214   KRB5_PADATA_SUPPORTED_ETYPES(165)
215 }
216 */
217
218 typedef enum PADATA_TYPE {
219   KRB5_PADATA_NONE = 0,
220   KRB5_PADATA_TGS_REQ = 1,
221   KRB5_PADATA_AP_REQ = 1,
222   KRB5_PADATA_ENC_TIMESTAMP = 2,
223   KRB5_PADATA_PW_SALT = 3,
224   KRB5_PADATA_ENC_UNIX_TIME = 5,
225   KRB5_PADATA_SANDIA_SECUREID = 6,
226   KRB5_PADATA_SESAME = 7,
227   KRB5_PADATA_OSF_DCE = 8,
228   KRB5_PADATA_CYBERSAFE_SECUREID = 9,
229   KRB5_PADATA_AFS3_SALT = 10,
230   KRB5_PADATA_ETYPE_INFO = 11,
231   KRB5_PADATA_SAM_CHALLENGE = 12,
232   KRB5_PADATA_SAM_RESPONSE = 13,
233   KRB5_PADATA_PK_AS_REQ_19 = 14,
234   KRB5_PADATA_PK_AS_REP_19 = 15,
235   KRB5_PADATA_PK_AS_REQ_WIN = 15,
236   KRB5_PADATA_PK_AS_REQ = 16,
237   KRB5_PADATA_PK_AS_REP = 17,
238   KRB5_PADATA_PA_PK_OCSP_RESPONSE = 18,
239   KRB5_PADATA_ETYPE_INFO2 = 19,
240   KRB5_PADATA_USE_SPECIFIED_KVNO = 20,
241   KRB5_PADATA_SVR_REFERRAL_INFO = 20,
242   KRB5_PADATA_SAM_REDIRECT = 21,
243   KRB5_PADATA_GET_FROM_TYPED_DATA = 22,
244   KRB5_PADATA_SAM_ETYPE_INFO = 23,
245   KRB5_PADATA_SERVER_REFERRAL = 25,
246   KRB5_PADATA_ALT_PRINC = 24,
247   KRB5_PADATA_SAM_CHALLENGE2 = 30,
248   KRB5_PADATA_SAM_RESPONSE2 = 31,
249   KRB5_PA_EXTRA_TGT = 41,
250   KRB5_PADATA_TD_KRB_PRINCIPAL = 102,
251   KRB5_PADATA_PK_TD_TRUSTED_CERTIFIERS = 104,
252   KRB5_PADATA_PK_TD_CERTIFICATE_INDEX = 105,
253   KRB5_PADATA_TD_APP_DEFINED_ERROR = 106,
254   KRB5_PADATA_TD_REQ_NONCE = 107,
255   KRB5_PADATA_TD_REQ_SEQ = 108,
256   KRB5_PADATA_PA_PAC_REQUEST = 128,
257   KRB5_PADATA_FOR_USER = 129,
258   KRB5_PADATA_FOR_X509_USER = 130,
259   KRB5_PADATA_FOR_CHECK_DUPS = 131,
260   KRB5_PADATA_AS_CHECKSUM = 132,
261   KRB5_PADATA_PK_AS_09_BINDING = 132,
262   KRB5_PADATA_CLIENT_CANONICALIZED = 133,
263   KRB5_PADATA_FX_COOKIE = 133,
264   KRB5_PADATA_AUTHENTICATION_SET = 134,
265   KRB5_PADATA_AUTH_SET_SELECTED = 135,
266   KRB5_PADATA_FX_FAST = 136,
267   KRB5_PADATA_FX_ERROR = 137,
268   KRB5_PADATA_ENCRYPTED_CHALLENGE = 138,
269   KRB5_PADATA_OTP_CHALLENGE = 141,
270   KRB5_PADATA_OTP_REQUEST = 142,
271   KBB5_PADATA_OTP_CONFIRM = 143,
272   KRB5_PADATA_OTP_PIN_CHANGE = 144,
273   KRB5_PADATA_EPAK_AS_REQ = 145,
274   KRB5_PADATA_EPAK_AS_REP = 146,
275   KRB5_PADATA_PKINIT_KX = 147,
276   KRB5_PADATA_PKU2U_NAME = 148,
277   KRB5_PADATA_SUPPORTED_ETYPES = 165
278 } PADATA_TYPE;
279
280 int    decode_PADATA_TYPE(const unsigned char *, size_t, PADATA_TYPE *, size_t *);
281 int    encode_PADATA_TYPE(unsigned char *, size_t, const PADATA_TYPE *, size_t *);
282 size_t length_PADATA_TYPE(const PADATA_TYPE *);
283 int    copy_PADATA_TYPE  (const PADATA_TYPE *, PADATA_TYPE *);
284 void   free_PADATA_TYPE  (PADATA_TYPE *);
285
286
287 /*
288 AUTHDATA-TYPE ::= INTEGER {
289   KRB5_AUTHDATA_IF_RELEVANT(1),
290   KRB5_AUTHDATA_INTENDED_FOR_SERVER(2),
291   KRB5_AUTHDATA_INTENDED_FOR_APPLICATION_CLASS(3),
292   KRB5_AUTHDATA_KDC_ISSUED(4),
293   KRB5_AUTHDATA_AND_OR(5),
294   KRB5_AUTHDATA_MANDATORY_TICKET_EXTENSIONS(6),
295   KRB5_AUTHDATA_IN_TICKET_EXTENSIONS(7),
296   KRB5_AUTHDATA_MANDATORY_FOR_KDC(8),
297   KRB5_AUTHDATA_INITIAL_VERIFIED_CAS(9),
298   KRB5_AUTHDATA_OSF_DCE(64),
299   KRB5_AUTHDATA_SESAME(65),
300   KRB5_AUTHDATA_OSF_DCE_PKI_CERTID(66),
301   KRB5_AUTHDATA_WIN2K_PAC(128),
302   KRB5_AUTHDATA_GSS_API_ETYPE_NEGOTIATION(129),
303   KRB5_AUTHDATA_SIGNTICKET_OLDER(-17),
304   KRB5_AUTHDATA_SIGNTICKET_OLD(142),
305   KRB5_AUTHDATA_SIGNTICKET(512)
306 }
307 */
308
309 typedef enum AUTHDATA_TYPE {
310   KRB5_AUTHDATA_IF_RELEVANT = 1,
311   KRB5_AUTHDATA_INTENDED_FOR_SERVER = 2,
312   KRB5_AUTHDATA_INTENDED_FOR_APPLICATION_CLASS = 3,
313   KRB5_AUTHDATA_KDC_ISSUED = 4,
314   KRB5_AUTHDATA_AND_OR = 5,
315   KRB5_AUTHDATA_MANDATORY_TICKET_EXTENSIONS = 6,
316   KRB5_AUTHDATA_IN_TICKET_EXTENSIONS = 7,
317   KRB5_AUTHDATA_MANDATORY_FOR_KDC = 8,
318   KRB5_AUTHDATA_INITIAL_VERIFIED_CAS = 9,
319   KRB5_AUTHDATA_OSF_DCE = 64,
320   KRB5_AUTHDATA_SESAME = 65,
321   KRB5_AUTHDATA_OSF_DCE_PKI_CERTID = 66,
322   KRB5_AUTHDATA_WIN2K_PAC = 128,
323   KRB5_AUTHDATA_GSS_API_ETYPE_NEGOTIATION = 129,
324   KRB5_AUTHDATA_SIGNTICKET_OLDER = -17,
325   KRB5_AUTHDATA_SIGNTICKET_OLD = 142,
326   KRB5_AUTHDATA_SIGNTICKET = 512
327 } AUTHDATA_TYPE;
328
329 int    decode_AUTHDATA_TYPE(const unsigned char *, size_t, AUTHDATA_TYPE *, size_t *);
330 int    encode_AUTHDATA_TYPE(unsigned char *, size_t, const AUTHDATA_TYPE *, size_t *);
331 size_t length_AUTHDATA_TYPE(const AUTHDATA_TYPE *);
332 int    copy_AUTHDATA_TYPE  (const AUTHDATA_TYPE *, AUTHDATA_TYPE *);
333 void   free_AUTHDATA_TYPE  (AUTHDATA_TYPE *);
334
335
336 /*
337 CKSUMTYPE ::= INTEGER {
338   CKSUMTYPE_NONE(0),
339   CKSUMTYPE_CRC32(1),
340   CKSUMTYPE_RSA_MD4(2),
341   CKSUMTYPE_RSA_MD4_DES(3),
342   CKSUMTYPE_DES_MAC(4),
343   CKSUMTYPE_DES_MAC_K(5),
344   CKSUMTYPE_RSA_MD4_DES_K(6),
345   CKSUMTYPE_RSA_MD5(7),
346   CKSUMTYPE_RSA_MD5_DES(8),
347   CKSUMTYPE_RSA_MD5_DES3(9),
348   CKSUMTYPE_SHA1_OTHER(10),
349   CKSUMTYPE_HMAC_SHA1_DES3(12),
350   CKSUMTYPE_SHA1(14),
351   CKSUMTYPE_HMAC_SHA1_96_AES_128(15),
352   CKSUMTYPE_HMAC_SHA1_96_AES_256(16),
353   CKSUMTYPE_GSSAPI(32771),
354   CKSUMTYPE_HMAC_MD5(-138),
355   CKSUMTYPE_HMAC_MD5_ENC(-1138)
356 }
357 */
358
359 typedef enum CKSUMTYPE {
360   CKSUMTYPE_NONE = 0,
361   CKSUMTYPE_CRC32 = 1,
362   CKSUMTYPE_RSA_MD4 = 2,
363   CKSUMTYPE_RSA_MD4_DES = 3,
364   CKSUMTYPE_DES_MAC = 4,
365   CKSUMTYPE_DES_MAC_K = 5,
366   CKSUMTYPE_RSA_MD4_DES_K = 6,
367   CKSUMTYPE_RSA_MD5 = 7,
368   CKSUMTYPE_RSA_MD5_DES = 8,
369   CKSUMTYPE_RSA_MD5_DES3 = 9,
370   CKSUMTYPE_SHA1_OTHER = 10,
371   CKSUMTYPE_HMAC_SHA1_DES3 = 12,
372   CKSUMTYPE_SHA1 = 14,
373   CKSUMTYPE_HMAC_SHA1_96_AES_128 = 15,
374   CKSUMTYPE_HMAC_SHA1_96_AES_256 = 16,
375   CKSUMTYPE_GSSAPI = 32771,
376   CKSUMTYPE_HMAC_MD5 = -138,
377   CKSUMTYPE_HMAC_MD5_ENC = -1138
378 } CKSUMTYPE;
379
380 int    decode_CKSUMTYPE(const unsigned char *, size_t, CKSUMTYPE *, size_t *);
381 int    encode_CKSUMTYPE(unsigned char *, size_t, const CKSUMTYPE *, size_t *);
382 size_t length_CKSUMTYPE(const CKSUMTYPE *);
383 int    copy_CKSUMTYPE  (const CKSUMTYPE *, CKSUMTYPE *);
384 void   free_CKSUMTYPE  (CKSUMTYPE *);
385
386
387 /*
388 ENCTYPE ::= INTEGER {
389   ETYPE_NULL(0),
390   ETYPE_DES_CBC_CRC(1),
391   ETYPE_DES_CBC_MD4(2),
392   ETYPE_DES_CBC_MD5(3),
393   ETYPE_DES3_CBC_MD5(5),
394   ETYPE_OLD_DES3_CBC_SHA1(7),
395   ETYPE_SIGN_DSA_GENERATE(8),
396   ETYPE_ENCRYPT_RSA_PRIV(9),
397   ETYPE_ENCRYPT_RSA_PUB(10),
398   ETYPE_DES3_CBC_SHA1(16),
399   ETYPE_AES128_CTS_HMAC_SHA1_96(17),
400   ETYPE_AES256_CTS_HMAC_SHA1_96(18),
401   ETYPE_ARCFOUR_HMAC_MD5(23),
402   ETYPE_ARCFOUR_HMAC_MD5_56(24),
403   ETYPE_ENCTYPE_PK_CROSS(48),
404   ETYPE_ARCFOUR_MD4(-128),
405   ETYPE_ARCFOUR_HMAC_OLD(-133),
406   ETYPE_ARCFOUR_HMAC_OLD_EXP(-135),
407   ETYPE_DES_CBC_NONE(-4096),
408   ETYPE_DES3_CBC_NONE(-4097),
409   ETYPE_DES_CFB64_NONE(-4098),
410   ETYPE_DES_PCBC_NONE(-4099),
411   ETYPE_DIGEST_MD5_NONE(-4100),
412   ETYPE_CRAM_MD5_NONE(-4101)
413 }
414 */
415
416 typedef enum ENCTYPE {
417   ETYPE_NULL = 0,
418   ETYPE_DES_CBC_CRC = 1,
419   ETYPE_DES_CBC_MD4 = 2,
420   ETYPE_DES_CBC_MD5 = 3,
421   ETYPE_DES3_CBC_MD5 = 5,
422   ETYPE_OLD_DES3_CBC_SHA1 = 7,
423   ETYPE_SIGN_DSA_GENERATE = 8,
424   ETYPE_ENCRYPT_RSA_PRIV = 9,
425   ETYPE_ENCRYPT_RSA_PUB = 10,
426   ETYPE_DES3_CBC_SHA1 = 16,
427   ETYPE_AES128_CTS_HMAC_SHA1_96 = 17,
428   ETYPE_AES256_CTS_HMAC_SHA1_96 = 18,
429   ETYPE_ARCFOUR_HMAC_MD5 = 23,
430   ETYPE_ARCFOUR_HMAC_MD5_56 = 24,
431   ETYPE_ENCTYPE_PK_CROSS = 48,
432   ETYPE_ARCFOUR_MD4 = -128,
433   ETYPE_ARCFOUR_HMAC_OLD = -133,
434   ETYPE_ARCFOUR_HMAC_OLD_EXP = -135,
435   ETYPE_DES_CBC_NONE = -4096,
436   ETYPE_DES3_CBC_NONE = -4097,
437   ETYPE_DES_CFB64_NONE = -4098,
438   ETYPE_DES_PCBC_NONE = -4099,
439   ETYPE_DIGEST_MD5_NONE = -4100,
440   ETYPE_CRAM_MD5_NONE = -4101
441 } ENCTYPE;
442
443 int    decode_ENCTYPE(const unsigned char *, size_t, ENCTYPE *, size_t *);
444 int    encode_ENCTYPE(unsigned char *, size_t, const ENCTYPE *, size_t *);
445 size_t length_ENCTYPE(const ENCTYPE *);
446 int    copy_ENCTYPE  (const ENCTYPE *, ENCTYPE *);
447 void   free_ENCTYPE  (ENCTYPE *);
448
449
450 /*
451 krb5uint32 ::= INTEGER (0..-1)
452 */
453
454 typedef unsigned int krb5uint32;
455
456 int    decode_krb5uint32(const unsigned char *, size_t, krb5uint32 *, size_t *);
457 int    encode_krb5uint32(unsigned char *, size_t, const krb5uint32 *, size_t *);
458 size_t length_krb5uint32(const krb5uint32 *);
459 int    copy_krb5uint32  (const krb5uint32 *, krb5uint32 *);
460 void   free_krb5uint32  (krb5uint32 *);
461
462
463 /*
464 krb5int32 ::= INTEGER (-2147483648..2147483647)
465 */
466
467 typedef int krb5int32;
468
469 int    decode_krb5int32(const unsigned char *, size_t, krb5int32 *, size_t *);
470 int    encode_krb5int32(unsigned char *, size_t, const krb5int32 *, size_t *);
471 size_t length_krb5int32(const krb5int32 *);
472 int    copy_krb5int32  (const krb5int32 *, krb5int32 *);
473 void   free_krb5int32  (krb5int32 *);
474
475
476 /*
477 KerberosString ::= GeneralString
478 */
479
480 typedef heim_general_string KerberosString;
481
482 int    decode_KerberosString(const unsigned char *, size_t, KerberosString *, size_t *);
483 int    encode_KerberosString(unsigned char *, size_t, const KerberosString *, size_t *);
484 size_t length_KerberosString(const KerberosString *);
485 int    copy_KerberosString  (const KerberosString *, KerberosString *);
486 void   free_KerberosString  (KerberosString *);
487
488
489 /*
490 Realm ::= GeneralString
491 */
492
493 typedef heim_general_string Realm;
494
495 int    decode_Realm(const unsigned char *, size_t, Realm *, size_t *);
496 int    encode_Realm(unsigned char *, size_t, const Realm *, size_t *);
497 size_t length_Realm(const Realm *);
498 int    copy_Realm  (const Realm *, Realm *);
499 void   free_Realm  (Realm *);
500
501
502 /*
503 PrincipalName ::= SEQUENCE {
504   name-type       [0] NAME-TYPE,
505   name-string     [1] SEQUENCE OF GeneralString,
506 }
507 */
508
509 typedef struct PrincipalName {
510   NAME_TYPE name_type;
511   struct PrincipalName_name_string {
512     unsigned int len;
513     heim_general_string *val;
514   } name_string;
515 } PrincipalName;
516
517 int    decode_PrincipalName(const unsigned char *, size_t, PrincipalName *, size_t *);
518 int    encode_PrincipalName(unsigned char *, size_t, const PrincipalName *, size_t *);
519 size_t length_PrincipalName(const PrincipalName *);
520 int    copy_PrincipalName  (const PrincipalName *, PrincipalName *);
521 void   free_PrincipalName  (PrincipalName *);
522
523
524 /*
525 Principal ::= SEQUENCE {
526   name            [0] PrincipalName,
527   realm           [1] Realm,
528 }
529 */
530
531 typedef struct Principal {
532   PrincipalName name;
533   Realm realm;
534 } Principal;
535
536 int    decode_Principal(const unsigned char *, size_t, Principal *, size_t *);
537 int    encode_Principal(unsigned char *, size_t, const Principal *, size_t *);
538 size_t length_Principal(const Principal *);
539 int    copy_Principal  (const Principal *, Principal *);
540 void   free_Principal  (Principal *);
541
542
543 /*
544 Principals ::= SEQUENCE OF Principal
545 */
546
547 typedef struct Principals {
548   unsigned int len;
549   Principal *val;
550 } Principals;
551
552 int   add_Principals  (Principals *, const Principal *);
553 int   remove_Principals  (Principals *, unsigned int);
554 int    decode_Principals(const unsigned char *, size_t, Principals *, size_t *);
555 int    encode_Principals(unsigned char *, size_t, const Principals *, size_t *);
556 size_t length_Principals(const Principals *);
557 int    copy_Principals  (const Principals *, Principals *);
558 void   free_Principals  (Principals *);
559
560
561 /*
562 HostAddress ::= SEQUENCE {
563   addr-type       [0] krb5int32,
564   address         [1] OCTET STRING,
565 }
566 */
567
568 typedef struct HostAddress {
569   krb5int32 addr_type;
570   heim_octet_string address;
571 } HostAddress;
572
573 int    decode_HostAddress(const unsigned char *, size_t, HostAddress *, size_t *);
574 int    encode_HostAddress(unsigned char *, size_t, const HostAddress *, size_t *);
575 size_t length_HostAddress(const HostAddress *);
576 int    copy_HostAddress  (const HostAddress *, HostAddress *);
577 void   free_HostAddress  (HostAddress *);
578
579
580 /*
581 HostAddresses ::= SEQUENCE OF HostAddress
582 */
583
584 typedef struct HostAddresses {
585   unsigned int len;
586   HostAddress *val;
587 } HostAddresses;
588
589 int    decode_HostAddresses(const unsigned char *, size_t, HostAddresses *, size_t *);
590 int    encode_HostAddresses(unsigned char *, size_t, const HostAddresses *, size_t *);
591 size_t length_HostAddresses(const HostAddresses *);
592 int    copy_HostAddresses  (const HostAddresses *, HostAddresses *);
593 void   free_HostAddresses  (HostAddresses *);
594
595
596 /*
597 KerberosTime ::= GeneralizedTime
598 */
599
600 typedef time_t KerberosTime;
601
602 int    decode_KerberosTime(const unsigned char *, size_t, KerberosTime *, size_t *);
603 int    encode_KerberosTime(unsigned char *, size_t, const KerberosTime *, size_t *);
604 size_t length_KerberosTime(const KerberosTime *);
605 int    copy_KerberosTime  (const KerberosTime *, KerberosTime *);
606 void   free_KerberosTime  (KerberosTime *);
607
608
609 /*
610 AuthorizationDataElement ::= SEQUENCE {
611   ad-type         [0] krb5int32,
612   ad-data         [1] OCTET STRING,
613 }
614 */
615
616 typedef struct AuthorizationDataElement {
617   krb5int32 ad_type;
618   heim_octet_string ad_data;
619 } AuthorizationDataElement;
620
621 int    decode_AuthorizationDataElement(const unsigned char *, size_t, AuthorizationDataElement *, size_t *);
622 int    encode_AuthorizationDataElement(unsigned char *, size_t, const AuthorizationDataElement *, size_t *);
623 size_t length_AuthorizationDataElement(const AuthorizationDataElement *);
624 int    copy_AuthorizationDataElement  (const AuthorizationDataElement *, AuthorizationDataElement *);
625 void   free_AuthorizationDataElement  (AuthorizationDataElement *);
626
627
628 /*
629 AuthorizationData ::= SEQUENCE OF AuthorizationDataElement
630 */
631
632 typedef struct AuthorizationData {
633   unsigned int len;
634   AuthorizationDataElement *val;
635 } AuthorizationData;
636
637 int   add_AuthorizationData  (AuthorizationData *, const AuthorizationDataElement *);
638 int   remove_AuthorizationData  (AuthorizationData *, unsigned int);
639 int    decode_AuthorizationData(const unsigned char *, size_t, AuthorizationData *, size_t *);
640 int    encode_AuthorizationData(unsigned char *, size_t, const AuthorizationData *, size_t *);
641 size_t length_AuthorizationData(const AuthorizationData *);
642 int    copy_AuthorizationData  (const AuthorizationData *, AuthorizationData *);
643 void   free_AuthorizationData  (AuthorizationData *);
644
645
646 /*
647 APOptions ::= BIT STRING {
648   reserved(0),
649   use-session-key(1),
650   mutual-required(2)
651 }
652 */
653
654 typedef struct APOptions {
655   unsigned int reserved:1;
656   unsigned int use_session_key:1;
657   unsigned int mutual_required:1;
658   unsigned int _unused3:1;
659   unsigned int _unused4:1;
660   unsigned int _unused5:1;
661   unsigned int _unused6:1;
662   unsigned int _unused7:1;
663   unsigned int _unused8:1;
664   unsigned int _unused9:1;
665   unsigned int _unused10:1;
666   unsigned int _unused11:1;
667   unsigned int _unused12:1;
668   unsigned int _unused13:1;
669   unsigned int _unused14:1;
670   unsigned int _unused15:1;
671   unsigned int _unused16:1;
672   unsigned int _unused17:1;
673   unsigned int _unused18:1;
674   unsigned int _unused19:1;
675   unsigned int _unused20:1;
676   unsigned int _unused21:1;
677   unsigned int _unused22:1;
678   unsigned int _unused23:1;
679   unsigned int _unused24:1;
680   unsigned int _unused25:1;
681   unsigned int _unused26:1;
682   unsigned int _unused27:1;
683   unsigned int _unused28:1;
684   unsigned int _unused29:1;
685   unsigned int _unused30:1;
686   unsigned int _unused31:1;
687 } APOptions;
688
689
690 unsigned APOptions2int(APOptions);
691 APOptions int2APOptions(unsigned);
692 int    decode_APOptions(const unsigned char *, size_t, APOptions *, size_t *);
693 int    encode_APOptions(unsigned char *, size_t, const APOptions *, size_t *);
694 size_t length_APOptions(const APOptions *);
695 int    copy_APOptions  (const APOptions *, APOptions *);
696 void   free_APOptions  (APOptions *);
697
698
699 /*
700 TicketFlags ::= BIT STRING {
701   reserved(0),
702   forwardable(1),
703   forwarded(2),
704   proxiable(3),
705   proxy(4),
706   may-postdate(5),
707   postdated(6),
708   invalid(7),
709   renewable(8),
710   initial(9),
711   pre-authent(10),
712   hw-authent(11),
713   transited-policy-checked(12),
714   ok-as-delegate(13),
715   anonymous(14)
716 }
717 */
718
719 typedef struct TicketFlags {
720   unsigned int reserved:1;
721   unsigned int forwardable:1;
722   unsigned int forwarded:1;
723   unsigned int proxiable:1;
724   unsigned int proxy:1;
725   unsigned int may_postdate:1;
726   unsigned int postdated:1;
727   unsigned int invalid:1;
728   unsigned int renewable:1;
729   unsigned int initial:1;
730   unsigned int pre_authent:1;
731   unsigned int hw_authent:1;
732   unsigned int transited_policy_checked:1;
733   unsigned int ok_as_delegate:1;
734   unsigned int anonymous:1;
735   unsigned int _unused15:1;
736   unsigned int _unused16:1;
737   unsigned int _unused17:1;
738   unsigned int _unused18:1;
739   unsigned int _unused19:1;
740   unsigned int _unused20:1;
741   unsigned int _unused21:1;
742   unsigned int _unused22:1;
743   unsigned int _unused23:1;
744   unsigned int _unused24:1;
745   unsigned int _unused25:1;
746   unsigned int _unused26:1;
747   unsigned int _unused27:1;
748   unsigned int _unused28:1;
749   unsigned int _unused29:1;
750   unsigned int _unused30:1;
751   unsigned int _unused31:1;
752 } TicketFlags;
753
754
755 unsigned TicketFlags2int(TicketFlags);
756 TicketFlags int2TicketFlags(unsigned);
757 int    decode_TicketFlags(const unsigned char *, size_t, TicketFlags *, size_t *);
758 int    encode_TicketFlags(unsigned char *, size_t, const TicketFlags *, size_t *);
759 size_t length_TicketFlags(const TicketFlags *);
760 int    copy_TicketFlags  (const TicketFlags *, TicketFlags *);
761 void   free_TicketFlags  (TicketFlags *);
762
763
764 /*
765 KDCOptions ::= BIT STRING {
766   reserved(0),
767   forwardable(1),
768   forwarded(2),
769   proxiable(3),
770   proxy(4),
771   allow-postdate(5),
772   postdated(6),
773   renewable(8),
774   request-anonymous(14),
775   canonicalize(15),
776   constrained-delegation(16),
777   disable-transited-check(26),
778   renewable-ok(27),
779   enc-tkt-in-skey(28),
780   renew(30),
781   validate(31)
782 }
783 */
784
785 typedef struct KDCOptions {
786   unsigned int reserved:1;
787   unsigned int forwardable:1;
788   unsigned int forwarded:1;
789   unsigned int proxiable:1;
790   unsigned int proxy:1;
791   unsigned int allow_postdate:1;
792   unsigned int postdated:1;
793   unsigned int _unused7:1;
794   unsigned int renewable:1;
795   unsigned int _unused9:1;
796   unsigned int _unused10:1;
797   unsigned int _unused11:1;
798   unsigned int _unused12:1;
799   unsigned int _unused13:1;
800   unsigned int request_anonymous:1;
801   unsigned int canonicalize:1;
802   unsigned int constrained_delegation:1;
803   unsigned int _unused17:1;
804   unsigned int _unused18:1;
805   unsigned int _unused19:1;
806   unsigned int _unused20:1;
807   unsigned int _unused21:1;
808   unsigned int _unused22:1;
809   unsigned int _unused23:1;
810   unsigned int _unused24:1;
811   unsigned int _unused25:1;
812   unsigned int disable_transited_check:1;
813   unsigned int renewable_ok:1;
814   unsigned int enc_tkt_in_skey:1;
815   unsigned int _unused29:1;
816   unsigned int renew:1;
817   unsigned int validate:1;
818 } KDCOptions;
819
820
821 unsigned KDCOptions2int(KDCOptions);
822 KDCOptions int2KDCOptions(unsigned);
823 int    decode_KDCOptions(const unsigned char *, size_t, KDCOptions *, size_t *);
824 int    encode_KDCOptions(unsigned char *, size_t, const KDCOptions *, size_t *);
825 size_t length_KDCOptions(const KDCOptions *);
826 int    copy_KDCOptions  (const KDCOptions *, KDCOptions *);
827 void   free_KDCOptions  (KDCOptions *);
828
829
830 /*
831 LR-TYPE ::= INTEGER {
832   LR_NONE(0),
833   LR_INITIAL_TGT(1),
834   LR_INITIAL(2),
835   LR_ISSUE_USE_TGT(3),
836   LR_RENEWAL(4),
837   LR_REQUEST(5),
838   LR_PW_EXPTIME(6),
839   LR_ACCT_EXPTIME(7)
840 }
841 */
842
843 typedef enum LR_TYPE {
844   LR_NONE = 0,
845   LR_INITIAL_TGT = 1,
846   LR_INITIAL = 2,
847   LR_ISSUE_USE_TGT = 3,
848   LR_RENEWAL = 4,
849   LR_REQUEST = 5,
850   LR_PW_EXPTIME = 6,
851   LR_ACCT_EXPTIME = 7
852 } LR_TYPE;
853
854 int    decode_LR_TYPE(const unsigned char *, size_t, LR_TYPE *, size_t *);
855 int    encode_LR_TYPE(unsigned char *, size_t, const LR_TYPE *, size_t *);
856 size_t length_LR_TYPE(const LR_TYPE *);
857 int    copy_LR_TYPE  (const LR_TYPE *, LR_TYPE *);
858 void   free_LR_TYPE  (LR_TYPE *);
859
860
861 /*
862 LastReq ::= SEQUENCE OF SEQUENCE {
863   lr-type         [0] LR-TYPE,
864   lr-value        [1] KerberosTime,
865 }
866 */
867
868 typedef struct LastReq {
869   unsigned int len;
870   struct LastReq_val {
871     LR_TYPE lr_type;
872     KerberosTime lr_value;
873   } *val;
874 } LastReq;
875
876 int    decode_LastReq(const unsigned char *, size_t, LastReq *, size_t *);
877 int    encode_LastReq(unsigned char *, size_t, const LastReq *, size_t *);
878 size_t length_LastReq(const LastReq *);
879 int    copy_LastReq  (const LastReq *, LastReq *);
880 void   free_LastReq  (LastReq *);
881
882
883 /*
884 EncryptedData ::= SEQUENCE {
885   etype           [0] ENCTYPE,
886   kvno            [1] krb5int32 OPTIONAL,
887   cipher          [2] OCTET STRING,
888 }
889 */
890
891 typedef struct EncryptedData {
892   ENCTYPE etype;
893   krb5int32 *kvno;
894   heim_octet_string cipher;
895 } EncryptedData;
896
897 int    decode_EncryptedData(const unsigned char *, size_t, EncryptedData *, size_t *);
898 int    encode_EncryptedData(unsigned char *, size_t, const EncryptedData *, size_t *);
899 size_t length_EncryptedData(const EncryptedData *);
900 int    copy_EncryptedData  (const EncryptedData *, EncryptedData *);
901 void   free_EncryptedData  (EncryptedData *);
902
903
904 /*
905 EncryptionKey ::= SEQUENCE {
906   keytype         [0] krb5int32,
907   keyvalue        [1] OCTET STRING,
908 }
909 */
910
911 typedef struct EncryptionKey {
912   krb5int32 keytype;
913   heim_octet_string keyvalue;
914 } EncryptionKey;
915
916 int    decode_EncryptionKey(const unsigned char *, size_t, EncryptionKey *, size_t *);
917 int    encode_EncryptionKey(unsigned char *, size_t, const EncryptionKey *, size_t *);
918 size_t length_EncryptionKey(const EncryptionKey *);
919 int    copy_EncryptionKey  (const EncryptionKey *, EncryptionKey *);
920 void   free_EncryptionKey  (EncryptionKey *);
921
922
923 /*
924 TransitedEncoding ::= SEQUENCE {
925   tr-type         [0] krb5int32,
926   contents        [1] OCTET STRING,
927 }
928 */
929
930 typedef struct TransitedEncoding {
931   krb5int32 tr_type;
932   heim_octet_string contents;
933 } TransitedEncoding;
934
935 int    decode_TransitedEncoding(const unsigned char *, size_t, TransitedEncoding *, size_t *);
936 int    encode_TransitedEncoding(unsigned char *, size_t, const TransitedEncoding *, size_t *);
937 size_t length_TransitedEncoding(const TransitedEncoding *);
938 int    copy_TransitedEncoding  (const TransitedEncoding *, TransitedEncoding *);
939 void   free_TransitedEncoding  (TransitedEncoding *);
940
941
942 /*
943 Ticket ::= [APPLICATION 1] SEQUENCE {
944   tkt-vno         [0] krb5int32,
945   realm           [1] Realm,
946   sname           [2] PrincipalName,
947   enc-part        [3] EncryptedData,
948 }
949 */
950
951 typedef struct Ticket {
952   krb5int32 tkt_vno;
953   Realm realm;
954   PrincipalName sname;
955   EncryptedData enc_part;
956 } Ticket;
957
958 int    decode_Ticket(const unsigned char *, size_t, Ticket *, size_t *);
959 int    encode_Ticket(unsigned char *, size_t, const Ticket *, size_t *);
960 size_t length_Ticket(const Ticket *);
961 int    copy_Ticket  (const Ticket *, Ticket *);
962 void   free_Ticket  (Ticket *);
963
964
965 /*
966 EncTicketPart ::= [APPLICATION 3] SEQUENCE {
967   flags                [0] TicketFlags,
968   key                  [1] EncryptionKey,
969   crealm               [2] Realm,
970   cname                [3] PrincipalName,
971   transited            [4] TransitedEncoding,
972   authtime             [5] KerberosTime,
973   starttime            [6] KerberosTime OPTIONAL,
974   endtime              [7] KerberosTime,
975   renew-till           [8] KerberosTime OPTIONAL,
976   caddr                [9] HostAddresses OPTIONAL,
977   authorization-data   [10] AuthorizationData OPTIONAL,
978 }
979 */
980
981 typedef struct EncTicketPart {
982   TicketFlags flags;
983   EncryptionKey key;
984   Realm crealm;
985   PrincipalName cname;
986   TransitedEncoding transited;
987   KerberosTime authtime;
988   KerberosTime *starttime;
989   KerberosTime endtime;
990   KerberosTime *renew_till;
991   HostAddresses *caddr;
992   AuthorizationData *authorization_data;
993 } EncTicketPart;
994
995 int    decode_EncTicketPart(const unsigned char *, size_t, EncTicketPart *, size_t *);
996 int    encode_EncTicketPart(unsigned char *, size_t, const EncTicketPart *, size_t *);
997 size_t length_EncTicketPart(const EncTicketPart *);
998 int    copy_EncTicketPart  (const EncTicketPart *, EncTicketPart *);
999 void   free_EncTicketPart  (EncTicketPart *);
1000
1001
1002 /*
1003 Checksum ::= SEQUENCE {
1004   cksumtype       [0] CKSUMTYPE,
1005   checksum        [1] OCTET STRING,
1006 }
1007 */
1008
1009 typedef struct Checksum {
1010   CKSUMTYPE cksumtype;
1011   heim_octet_string checksum;
1012 } Checksum;
1013
1014 int    decode_Checksum(const unsigned char *, size_t, Checksum *, size_t *);
1015 int    encode_Checksum(unsigned char *, size_t, const Checksum *, size_t *);
1016 size_t length_Checksum(const Checksum *);
1017 int    copy_Checksum  (const Checksum *, Checksum *);
1018 void   free_Checksum  (Checksum *);
1019
1020
1021 /*
1022 Authenticator ::= [APPLICATION 2] SEQUENCE {
1023   authenticator-vno    [0] krb5int32,
1024   crealm               [1] Realm,
1025   cname                [2] PrincipalName,
1026   cksum                [3] Checksum OPTIONAL,
1027   cusec                [4] krb5int32,
1028   ctime                [5] KerberosTime,
1029   subkey               [6] EncryptionKey OPTIONAL,
1030   seq-number           [7] krb5uint32 OPTIONAL,
1031   authorization-data   [8] AuthorizationData OPTIONAL,
1032 }
1033 */
1034
1035 typedef struct Authenticator {
1036   krb5int32 authenticator_vno;
1037   Realm crealm;
1038   PrincipalName cname;
1039   Checksum *cksum;
1040   krb5int32 cusec;
1041   KerberosTime ctime;
1042   EncryptionKey *subkey;
1043   krb5uint32 *seq_number;
1044   AuthorizationData *authorization_data;
1045 } Authenticator;
1046
1047 int    decode_Authenticator(const unsigned char *, size_t, Authenticator *, size_t *);
1048 int    encode_Authenticator(unsigned char *, size_t, const Authenticator *, size_t *);
1049 size_t length_Authenticator(const Authenticator *);
1050 int    copy_Authenticator  (const Authenticator *, Authenticator *);
1051 void   free_Authenticator  (Authenticator *);
1052
1053
1054 /*
1055 PA-DATA ::= SEQUENCE {
1056   padata-type     [1] PADATA-TYPE,
1057   padata-value    [2] OCTET STRING,
1058 }
1059 */
1060
1061 typedef struct PA_DATA {
1062   PADATA_TYPE padata_type;
1063   heim_octet_string padata_value;
1064 } PA_DATA;
1065
1066 int    decode_PA_DATA(const unsigned char *, size_t, PA_DATA *, size_t *);
1067 int    encode_PA_DATA(unsigned char *, size_t, const PA_DATA *, size_t *);
1068 size_t length_PA_DATA(const PA_DATA *);
1069 int    copy_PA_DATA  (const PA_DATA *, PA_DATA *);
1070 void   free_PA_DATA  (PA_DATA *);
1071
1072
1073 /*
1074 ETYPE-INFO-ENTRY ::= SEQUENCE {
1075   etype           [0] ENCTYPE,
1076   salt            [1] OCTET STRING OPTIONAL,
1077   salttype        [2] krb5int32 OPTIONAL,
1078 }
1079 */
1080
1081 typedef struct ETYPE_INFO_ENTRY {
1082   ENCTYPE etype;
1083   heim_octet_string *salt;
1084   krb5int32 *salttype;
1085 } ETYPE_INFO_ENTRY;
1086
1087 int    decode_ETYPE_INFO_ENTRY(const unsigned char *, size_t, ETYPE_INFO_ENTRY *, size_t *);
1088 int    encode_ETYPE_INFO_ENTRY(unsigned char *, size_t, const ETYPE_INFO_ENTRY *, size_t *);
1089 size_t length_ETYPE_INFO_ENTRY(const ETYPE_INFO_ENTRY *);
1090 int    copy_ETYPE_INFO_ENTRY  (const ETYPE_INFO_ENTRY *, ETYPE_INFO_ENTRY *);
1091 void   free_ETYPE_INFO_ENTRY  (ETYPE_INFO_ENTRY *);
1092
1093
1094 /*
1095 ETYPE-INFO ::= SEQUENCE OF ETYPE-INFO-ENTRY
1096 */
1097
1098 typedef struct ETYPE_INFO {
1099   unsigned int len;
1100   ETYPE_INFO_ENTRY *val;
1101 } ETYPE_INFO;
1102
1103 int   add_ETYPE_INFO  (ETYPE_INFO *, const ETYPE_INFO_ENTRY *);
1104 int   remove_ETYPE_INFO  (ETYPE_INFO *, unsigned int);
1105 int    decode_ETYPE_INFO(const unsigned char *, size_t, ETYPE_INFO *, size_t *);
1106 int    encode_ETYPE_INFO(unsigned char *, size_t, const ETYPE_INFO *, size_t *);
1107 size_t length_ETYPE_INFO(const ETYPE_INFO *);
1108 int    copy_ETYPE_INFO  (const ETYPE_INFO *, ETYPE_INFO *);
1109 void   free_ETYPE_INFO  (ETYPE_INFO *);
1110
1111
1112 /*
1113 ETYPE-INFO2-ENTRY ::= SEQUENCE {
1114   etype           [0] ENCTYPE,
1115   salt            [1] KerberosString OPTIONAL,
1116   s2kparams       [2] OCTET STRING OPTIONAL,
1117 }
1118 */
1119
1120 typedef struct ETYPE_INFO2_ENTRY {
1121   ENCTYPE etype;
1122   KerberosString *salt;
1123   heim_octet_string *s2kparams;
1124 } ETYPE_INFO2_ENTRY;
1125
1126 int    decode_ETYPE_INFO2_ENTRY(const unsigned char *, size_t, ETYPE_INFO2_ENTRY *, size_t *);
1127 int    encode_ETYPE_INFO2_ENTRY(unsigned char *, size_t, const ETYPE_INFO2_ENTRY *, size_t *);
1128 size_t length_ETYPE_INFO2_ENTRY(const ETYPE_INFO2_ENTRY *);
1129 int    copy_ETYPE_INFO2_ENTRY  (const ETYPE_INFO2_ENTRY *, ETYPE_INFO2_ENTRY *);
1130 void   free_ETYPE_INFO2_ENTRY  (ETYPE_INFO2_ENTRY *);
1131
1132
1133 /*
1134 ETYPE-INFO2 ::= SEQUENCE OF ETYPE-INFO2-ENTRY
1135 */
1136
1137 typedef struct ETYPE_INFO2 {
1138   unsigned int len;
1139   ETYPE_INFO2_ENTRY *val;
1140 } ETYPE_INFO2;
1141
1142 int   add_ETYPE_INFO2  (ETYPE_INFO2 *, const ETYPE_INFO2_ENTRY *);
1143 int   remove_ETYPE_INFO2  (ETYPE_INFO2 *, unsigned int);
1144 int    decode_ETYPE_INFO2(const unsigned char *, size_t, ETYPE_INFO2 *, size_t *);
1145 int    encode_ETYPE_INFO2(unsigned char *, size_t, const ETYPE_INFO2 *, size_t *);
1146 size_t length_ETYPE_INFO2(const ETYPE_INFO2 *);
1147 int    copy_ETYPE_INFO2  (const ETYPE_INFO2 *, ETYPE_INFO2 *);
1148 void   free_ETYPE_INFO2  (ETYPE_INFO2 *);
1149
1150
1151 /*
1152 METHOD-DATA ::= SEQUENCE OF PA-DATA
1153 */
1154
1155 typedef struct METHOD_DATA {
1156   unsigned int len;
1157   PA_DATA *val;
1158 } METHOD_DATA;
1159
1160 int   add_METHOD_DATA  (METHOD_DATA *, const PA_DATA *);
1161 int   remove_METHOD_DATA  (METHOD_DATA *, unsigned int);
1162 int    decode_METHOD_DATA(const unsigned char *, size_t, METHOD_DATA *, size_t *);
1163 int    encode_METHOD_DATA(unsigned char *, size_t, const METHOD_DATA *, size_t *);
1164 size_t length_METHOD_DATA(const METHOD_DATA *);
1165 int    copy_METHOD_DATA  (const METHOD_DATA *, METHOD_DATA *);
1166 void   free_METHOD_DATA  (METHOD_DATA *);
1167
1168
1169 /*
1170 TypedData ::= SEQUENCE {
1171   data-type       [0] krb5int32,
1172   data-value      [1] OCTET STRING OPTIONAL,
1173 }
1174 */
1175
1176 typedef struct TypedData {
1177   krb5int32 data_type;
1178   heim_octet_string *data_value;
1179 } TypedData;
1180
1181 int    decode_TypedData(const unsigned char *, size_t, TypedData *, size_t *);
1182 int    encode_TypedData(unsigned char *, size_t, const TypedData *, size_t *);
1183 size_t length_TypedData(const TypedData *);
1184 int    copy_TypedData  (const TypedData *, TypedData *);
1185 void   free_TypedData  (TypedData *);
1186
1187
1188 /*
1189 TYPED-DATA ::= SEQUENCE OF TypedData
1190 */
1191
1192 typedef struct TYPED_DATA {
1193   unsigned int len;
1194   TypedData *val;
1195 } TYPED_DATA;
1196
1197 int    decode_TYPED_DATA(const unsigned char *, size_t, TYPED_DATA *, size_t *);
1198 int    encode_TYPED_DATA(unsigned char *, size_t, const TYPED_DATA *, size_t *);
1199 size_t length_TYPED_DATA(const TYPED_DATA *);
1200 int    copy_TYPED_DATA  (const TYPED_DATA *, TYPED_DATA *);
1201 void   free_TYPED_DATA  (TYPED_DATA *);
1202
1203
1204 /*
1205 KDC-REQ-BODY ::= SEQUENCE {
1206   kdc-options              [0] KDCOptions,
1207   cname                    [1] PrincipalName OPTIONAL,
1208   realm                    [2] Realm,
1209   sname                    [3] PrincipalName OPTIONAL,
1210   from                     [4] KerberosTime OPTIONAL,
1211   till                     [5] KerberosTime OPTIONAL,
1212   rtime                    [6] KerberosTime OPTIONAL,
1213   nonce                    [7] krb5int32,
1214   etype                    [8] SEQUENCE OF ENCTYPE,
1215   addresses                [9] HostAddresses OPTIONAL,
1216   enc-authorization-data   [10] EncryptedData OPTIONAL,
1217   additional-tickets       [11] SEQUENCE OF Ticket OPTIONAL,
1218 }
1219 */
1220
1221 typedef struct KDC_REQ_BODY {
1222   KDCOptions kdc_options;
1223   PrincipalName *cname;
1224   Realm realm;
1225   PrincipalName *sname;
1226   KerberosTime *from;
1227   KerberosTime *till;
1228   KerberosTime *rtime;
1229   krb5int32 nonce;
1230   struct KDC_REQ_BODY_etype {
1231     unsigned int len;
1232     ENCTYPE *val;
1233   } etype;
1234   HostAddresses *addresses;
1235   EncryptedData *enc_authorization_data;
1236   struct KDC_REQ_BODY_additional_tickets {
1237     unsigned int len;
1238     Ticket *val;
1239   } *additional_tickets;
1240 } KDC_REQ_BODY;
1241
1242 int    decode_KDC_REQ_BODY(const unsigned char *, size_t, KDC_REQ_BODY *, size_t *);
1243 int    encode_KDC_REQ_BODY(unsigned char *, size_t, const KDC_REQ_BODY *, size_t *);
1244 size_t length_KDC_REQ_BODY(const KDC_REQ_BODY *);
1245 int    copy_KDC_REQ_BODY  (const KDC_REQ_BODY *, KDC_REQ_BODY *);
1246 void   free_KDC_REQ_BODY  (KDC_REQ_BODY *);
1247
1248
1249 /*
1250 KDC-REQ ::= SEQUENCE {
1251   pvno            [1] krb5int32,
1252   msg-type        [2] MESSAGE-TYPE,
1253   padata          [3] METHOD-DATA OPTIONAL,
1254   req-body        [4] KDC-REQ-BODY,
1255 }
1256 */
1257
1258 typedef struct KDC_REQ {
1259   krb5int32 pvno;
1260   MESSAGE_TYPE msg_type;
1261   METHOD_DATA *padata;
1262   KDC_REQ_BODY req_body;
1263 } KDC_REQ;
1264
1265 int    decode_KDC_REQ(const unsigned char *, size_t, KDC_REQ *, size_t *);
1266 int    encode_KDC_REQ(unsigned char *, size_t, const KDC_REQ *, size_t *);
1267 size_t length_KDC_REQ(const KDC_REQ *);
1268 int    copy_KDC_REQ  (const KDC_REQ *, KDC_REQ *);
1269 void   free_KDC_REQ  (KDC_REQ *);
1270
1271
1272 /*
1273 AS-REQ ::= [APPLICATION 10] KDC-REQ
1274 */
1275
1276 typedef KDC_REQ AS_REQ;
1277
1278 int    decode_AS_REQ(const unsigned char *, size_t, AS_REQ *, size_t *);
1279 int    encode_AS_REQ(unsigned char *, size_t, const AS_REQ *, size_t *);
1280 size_t length_AS_REQ(const AS_REQ *);
1281 int    copy_AS_REQ  (const AS_REQ *, AS_REQ *);
1282 void   free_AS_REQ  (AS_REQ *);
1283
1284
1285 /*
1286 TGS-REQ ::= [APPLICATION 12] KDC-REQ
1287 */
1288
1289 typedef KDC_REQ TGS_REQ;
1290
1291 int    decode_TGS_REQ(const unsigned char *, size_t, TGS_REQ *, size_t *);
1292 int    encode_TGS_REQ(unsigned char *, size_t, const TGS_REQ *, size_t *);
1293 size_t length_TGS_REQ(const TGS_REQ *);
1294 int    copy_TGS_REQ  (const TGS_REQ *, TGS_REQ *);
1295 void   free_TGS_REQ  (TGS_REQ *);
1296
1297
1298 /*
1299 PA-ENC-TS-ENC ::= SEQUENCE {
1300   patimestamp     [0] KerberosTime,
1301   pausec          [1] krb5int32 OPTIONAL,
1302 }
1303 */
1304
1305 typedef struct PA_ENC_TS_ENC {
1306   KerberosTime patimestamp;
1307   krb5int32 *pausec;
1308 } PA_ENC_TS_ENC;
1309
1310 int    decode_PA_ENC_TS_ENC(const unsigned char *, size_t, PA_ENC_TS_ENC *, size_t *);
1311 int    encode_PA_ENC_TS_ENC(unsigned char *, size_t, const PA_ENC_TS_ENC *, size_t *);
1312 size_t length_PA_ENC_TS_ENC(const PA_ENC_TS_ENC *);
1313 int    copy_PA_ENC_TS_ENC  (const PA_ENC_TS_ENC *, PA_ENC_TS_ENC *);
1314 void   free_PA_ENC_TS_ENC  (PA_ENC_TS_ENC *);
1315
1316
1317 /*
1318 PA-PAC-REQUEST ::= SEQUENCE {
1319   include-pac     [0] BOOLEAN,
1320 }
1321 */
1322
1323 typedef struct PA_PAC_REQUEST {
1324   int include_pac;
1325 } PA_PAC_REQUEST;
1326
1327 int    decode_PA_PAC_REQUEST(const unsigned char *, size_t, PA_PAC_REQUEST *, size_t *);
1328 int    encode_PA_PAC_REQUEST(unsigned char *, size_t, const PA_PAC_REQUEST *, size_t *);
1329 size_t length_PA_PAC_REQUEST(const PA_PAC_REQUEST *);
1330 int    copy_PA_PAC_REQUEST  (const PA_PAC_REQUEST *, PA_PAC_REQUEST *);
1331 void   free_PA_PAC_REQUEST  (PA_PAC_REQUEST *);
1332
1333
1334 /*
1335 PROV-SRV-LOCATION ::= GeneralString
1336 */
1337
1338 typedef heim_general_string PROV_SRV_LOCATION;
1339
1340 int    decode_PROV_SRV_LOCATION(const unsigned char *, size_t, PROV_SRV_LOCATION *, size_t *);
1341 int    encode_PROV_SRV_LOCATION(unsigned char *, size_t, const PROV_SRV_LOCATION *, size_t *);
1342 size_t length_PROV_SRV_LOCATION(const PROV_SRV_LOCATION *);
1343 int    copy_PROV_SRV_LOCATION  (const PROV_SRV_LOCATION *, PROV_SRV_LOCATION *);
1344 void   free_PROV_SRV_LOCATION  (PROV_SRV_LOCATION *);
1345
1346
1347 /*
1348 KDC-REP ::= SEQUENCE {
1349   pvno            [0] krb5int32,
1350   msg-type        [1] MESSAGE-TYPE,
1351   padata          [2] METHOD-DATA OPTIONAL,
1352   crealm          [3] Realm,
1353   cname           [4] PrincipalName,
1354   ticket          [5] Ticket,
1355   enc-part        [6] EncryptedData,
1356 }
1357 */
1358
1359 typedef struct KDC_REP {
1360   krb5int32 pvno;
1361   MESSAGE_TYPE msg_type;
1362   METHOD_DATA *padata;
1363   Realm crealm;
1364   PrincipalName cname;
1365   Ticket ticket;
1366   EncryptedData enc_part;
1367 } KDC_REP;
1368
1369 int    decode_KDC_REP(const unsigned char *, size_t, KDC_REP *, size_t *);
1370 int    encode_KDC_REP(unsigned char *, size_t, const KDC_REP *, size_t *);
1371 size_t length_KDC_REP(const KDC_REP *);
1372 int    copy_KDC_REP  (const KDC_REP *, KDC_REP *);
1373 void   free_KDC_REP  (KDC_REP *);
1374
1375
1376 /*
1377 AS-REP ::= [APPLICATION 11] KDC-REP
1378 */
1379
1380 typedef KDC_REP AS_REP;
1381
1382 int    decode_AS_REP(const unsigned char *, size_t, AS_REP *, size_t *);
1383 int    encode_AS_REP(unsigned char *, size_t, const AS_REP *, size_t *);
1384 size_t length_AS_REP(const AS_REP *);
1385 int    copy_AS_REP  (const AS_REP *, AS_REP *);
1386 void   free_AS_REP  (AS_REP *);
1387
1388
1389 /*
1390 TGS-REP ::= [APPLICATION 13] KDC-REP
1391 */
1392
1393 typedef KDC_REP TGS_REP;
1394
1395 int    decode_TGS_REP(const unsigned char *, size_t, TGS_REP *, size_t *);
1396 int    encode_TGS_REP(unsigned char *, size_t, const TGS_REP *, size_t *);
1397 size_t length_TGS_REP(const TGS_REP *);
1398 int    copy_TGS_REP  (const TGS_REP *, TGS_REP *);
1399 void   free_TGS_REP  (TGS_REP *);
1400
1401
1402 /*
1403 EncKDCRepPart ::= SEQUENCE {
1404   key                 [0] EncryptionKey,
1405   last-req            [1] LastReq,
1406   nonce               [2] krb5int32,
1407   key-expiration      [3] KerberosTime OPTIONAL,
1408   flags               [4] TicketFlags,
1409   authtime            [5] KerberosTime,
1410   starttime           [6] KerberosTime OPTIONAL,
1411   endtime             [7] KerberosTime,
1412   renew-till          [8] KerberosTime OPTIONAL,
1413   srealm              [9] Realm,
1414   sname               [10] PrincipalName,
1415   caddr               [11] HostAddresses OPTIONAL,
1416   encrypted-pa-data   [12] METHOD-DATA OPTIONAL,
1417 }
1418 */
1419
1420 typedef struct EncKDCRepPart {
1421   EncryptionKey key;
1422   LastReq last_req;
1423   krb5int32 nonce;
1424   KerberosTime *key_expiration;
1425   TicketFlags flags;
1426   KerberosTime authtime;
1427   KerberosTime *starttime;
1428   KerberosTime endtime;
1429   KerberosTime *renew_till;
1430   Realm srealm;
1431   PrincipalName sname;
1432   HostAddresses *caddr;
1433   METHOD_DATA *encrypted_pa_data;
1434 } EncKDCRepPart;
1435
1436 int    decode_EncKDCRepPart(const unsigned char *, size_t, EncKDCRepPart *, size_t *);
1437 int    encode_EncKDCRepPart(unsigned char *, size_t, const EncKDCRepPart *, size_t *);
1438 size_t length_EncKDCRepPart(const EncKDCRepPart *);
1439 int    copy_EncKDCRepPart  (const EncKDCRepPart *, EncKDCRepPart *);
1440 void   free_EncKDCRepPart  (EncKDCRepPart *);
1441
1442
1443 /*
1444 EncASRepPart ::= [APPLICATION 25] EncKDCRepPart
1445 */
1446
1447 typedef EncKDCRepPart EncASRepPart;
1448
1449 int    decode_EncASRepPart(const unsigned char *, size_t, EncASRepPart *, size_t *);
1450 int    encode_EncASRepPart(unsigned char *, size_t, const EncASRepPart *, size_t *);
1451 size_t length_EncASRepPart(const EncASRepPart *);
1452 int    copy_EncASRepPart  (const EncASRepPart *, EncASRepPart *);
1453 void   free_EncASRepPart  (EncASRepPart *);
1454
1455
1456 /*
1457 EncTGSRepPart ::= [APPLICATION 26] EncKDCRepPart
1458 */
1459
1460 typedef EncKDCRepPart EncTGSRepPart;
1461
1462 int    decode_EncTGSRepPart(const unsigned char *, size_t, EncTGSRepPart *, size_t *);
1463 int    encode_EncTGSRepPart(unsigned char *, size_t, const EncTGSRepPart *, size_t *);
1464 size_t length_EncTGSRepPart(const EncTGSRepPart *);
1465 int    copy_EncTGSRepPart  (const EncTGSRepPart *, EncTGSRepPart *);
1466 void   free_EncTGSRepPart  (EncTGSRepPart *);
1467
1468
1469 /*
1470 AP-REQ ::= [APPLICATION 14] SEQUENCE {
1471   pvno            [0] krb5int32,
1472   msg-type        [1] MESSAGE-TYPE,
1473   ap-options      [2] APOptions,
1474   ticket          [3] Ticket,
1475   authenticator   [4] EncryptedData,
1476 }
1477 */
1478
1479 typedef struct AP_REQ {
1480   krb5int32 pvno;
1481   MESSAGE_TYPE msg_type;
1482   APOptions ap_options;
1483   Ticket ticket;
1484   EncryptedData authenticator;
1485 } AP_REQ;
1486
1487 int    decode_AP_REQ(const unsigned char *, size_t, AP_REQ *, size_t *);
1488 int    encode_AP_REQ(unsigned char *, size_t, const AP_REQ *, size_t *);
1489 size_t length_AP_REQ(const AP_REQ *);
1490 int    copy_AP_REQ  (const AP_REQ *, AP_REQ *);
1491 void   free_AP_REQ  (AP_REQ *);
1492
1493
1494 /*
1495 AP-REP ::= [APPLICATION 15] SEQUENCE {
1496   pvno            [0] krb5int32,
1497   msg-type        [1] MESSAGE-TYPE,
1498   enc-part        [2] EncryptedData,
1499 }
1500 */
1501
1502 typedef struct AP_REP {
1503   krb5int32 pvno;
1504   MESSAGE_TYPE msg_type;
1505   EncryptedData enc_part;
1506 } AP_REP;
1507
1508 int    decode_AP_REP(const unsigned char *, size_t, AP_REP *, size_t *);
1509 int    encode_AP_REP(unsigned char *, size_t, const AP_REP *, size_t *);
1510 size_t length_AP_REP(const AP_REP *);
1511 int    copy_AP_REP  (const AP_REP *, AP_REP *);
1512 void   free_AP_REP  (AP_REP *);
1513
1514
1515 /*
1516 EncAPRepPart ::= [APPLICATION 27] SEQUENCE {
1517   ctime           [0] KerberosTime,
1518   cusec           [1] krb5int32,
1519   subkey          [2] EncryptionKey OPTIONAL,
1520   seq-number      [3] krb5uint32 OPTIONAL,
1521 }
1522 */
1523
1524 typedef struct EncAPRepPart {
1525   KerberosTime ctime;
1526   krb5int32 cusec;
1527   EncryptionKey *subkey;
1528   krb5uint32 *seq_number;
1529 } EncAPRepPart;
1530
1531 int    decode_EncAPRepPart(const unsigned char *, size_t, EncAPRepPart *, size_t *);
1532 int    encode_EncAPRepPart(unsigned char *, size_t, const EncAPRepPart *, size_t *);
1533 size_t length_EncAPRepPart(const EncAPRepPart *);
1534 int    copy_EncAPRepPart  (const EncAPRepPart *, EncAPRepPart *);
1535 void   free_EncAPRepPart  (EncAPRepPart *);
1536
1537
1538 /*
1539 KRB-SAFE-BODY ::= SEQUENCE {
1540   user-data       [0] OCTET STRING,
1541   timestamp       [1] KerberosTime OPTIONAL,
1542   usec            [2] krb5int32 OPTIONAL,
1543   seq-number      [3] krb5uint32 OPTIONAL,
1544   s-address       [4] HostAddress OPTIONAL,
1545   r-address       [5] HostAddress OPTIONAL,
1546 }
1547 */
1548
1549 typedef struct KRB_SAFE_BODY {
1550   heim_octet_string user_data;
1551   KerberosTime *timestamp;
1552   krb5int32 *usec;
1553   krb5uint32 *seq_number;
1554   HostAddress *s_address;
1555   HostAddress *r_address;
1556 } KRB_SAFE_BODY;
1557
1558 int    decode_KRB_SAFE_BODY(const unsigned char *, size_t, KRB_SAFE_BODY *, size_t *);
1559 int    encode_KRB_SAFE_BODY(unsigned char *, size_t, const KRB_SAFE_BODY *, size_t *);
1560 size_t length_KRB_SAFE_BODY(const KRB_SAFE_BODY *);
1561 int    copy_KRB_SAFE_BODY  (const KRB_SAFE_BODY *, KRB_SAFE_BODY *);
1562 void   free_KRB_SAFE_BODY  (KRB_SAFE_BODY *);
1563
1564
1565 /*
1566 KRB-SAFE ::= [APPLICATION 20] SEQUENCE {
1567   pvno            [0] krb5int32,
1568   msg-type        [1] MESSAGE-TYPE,
1569   safe-body       [2] KRB-SAFE-BODY,
1570   cksum           [3] Checksum,
1571 }
1572 */
1573
1574 typedef struct KRB_SAFE {
1575   krb5int32 pvno;
1576   MESSAGE_TYPE msg_type;
1577   KRB_SAFE_BODY safe_body;
1578   Checksum cksum;
1579 } KRB_SAFE;
1580
1581 int    decode_KRB_SAFE(const unsigned char *, size_t, KRB_SAFE *, size_t *);
1582 int    encode_KRB_SAFE(unsigned char *, size_t, const KRB_SAFE *, size_t *);
1583 size_t length_KRB_SAFE(const KRB_SAFE *);
1584 int    copy_KRB_SAFE  (const KRB_SAFE *, KRB_SAFE *);
1585 void   free_KRB_SAFE  (KRB_SAFE *);
1586
1587
1588 /*
1589 KRB-PRIV ::= [APPLICATION 21] SEQUENCE {
1590   pvno            [0] krb5int32,
1591   msg-type        [1] MESSAGE-TYPE,
1592   enc-part        [3] EncryptedData,
1593 }
1594 */
1595
1596 typedef struct KRB_PRIV {
1597   krb5int32 pvno;
1598   MESSAGE_TYPE msg_type;
1599   EncryptedData enc_part;
1600 } KRB_PRIV;
1601
1602 int    decode_KRB_PRIV(const unsigned char *, size_t, KRB_PRIV *, size_t *);
1603 int    encode_KRB_PRIV(unsigned char *, size_t, const KRB_PRIV *, size_t *);
1604 size_t length_KRB_PRIV(const KRB_PRIV *);
1605 int    copy_KRB_PRIV  (const KRB_PRIV *, KRB_PRIV *);
1606 void   free_KRB_PRIV  (KRB_PRIV *);
1607
1608
1609 /*
1610 EncKrbPrivPart ::= [APPLICATION 28] SEQUENCE {
1611   user-data       [0] OCTET STRING,
1612   timestamp       [1] KerberosTime OPTIONAL,
1613   usec            [2] krb5int32 OPTIONAL,
1614   seq-number      [3] krb5uint32 OPTIONAL,
1615   s-address       [4] HostAddress OPTIONAL,
1616   r-address       [5] HostAddress OPTIONAL,
1617 }
1618 */
1619
1620 typedef struct EncKrbPrivPart {
1621   heim_octet_string user_data;
1622   KerberosTime *timestamp;
1623   krb5int32 *usec;
1624   krb5uint32 *seq_number;
1625   HostAddress *s_address;
1626   HostAddress *r_address;
1627 } EncKrbPrivPart;
1628
1629 int    decode_EncKrbPrivPart(const unsigned char *, size_t, EncKrbPrivPart *, size_t *);
1630 int    encode_EncKrbPrivPart(unsigned char *, size_t, const EncKrbPrivPart *, size_t *);
1631 size_t length_EncKrbPrivPart(const EncKrbPrivPart *);
1632 int    copy_EncKrbPrivPart  (const EncKrbPrivPart *, EncKrbPrivPart *);
1633 void   free_EncKrbPrivPart  (EncKrbPrivPart *);
1634
1635
1636 /*
1637 KRB-CRED ::= [APPLICATION 22] SEQUENCE {
1638   pvno            [0] krb5int32,
1639   msg-type        [1] MESSAGE-TYPE,
1640   tickets         [2] SEQUENCE OF Ticket,
1641   enc-part        [3] EncryptedData,
1642 }
1643 */
1644
1645 typedef struct KRB_CRED {
1646   krb5int32 pvno;
1647   MESSAGE_TYPE msg_type;
1648   struct KRB_CRED_tickets {
1649     unsigned int len;
1650     Ticket *val;
1651   } tickets;
1652   EncryptedData enc_part;
1653 } KRB_CRED;
1654
1655 int    decode_KRB_CRED(const unsigned char *, size_t, KRB_CRED *, size_t *);
1656 int    encode_KRB_CRED(unsigned char *, size_t, const KRB_CRED *, size_t *);
1657 size_t length_KRB_CRED(const KRB_CRED *);
1658 int    copy_KRB_CRED  (const KRB_CRED *, KRB_CRED *);
1659 void   free_KRB_CRED  (KRB_CRED *);
1660
1661
1662 /*
1663 KrbCredInfo ::= SEQUENCE {
1664   key             [0] EncryptionKey,
1665   prealm          [1] Realm OPTIONAL,
1666   pname           [2] PrincipalName OPTIONAL,
1667   flags           [3] TicketFlags OPTIONAL,
1668   authtime        [4] KerberosTime OPTIONAL,
1669   starttime       [5] KerberosTime OPTIONAL,
1670   endtime         [6] KerberosTime OPTIONAL,
1671   renew-till      [7] KerberosTime OPTIONAL,
1672   srealm          [8] Realm OPTIONAL,
1673   sname           [9] PrincipalName OPTIONAL,
1674   caddr           [10] HostAddresses OPTIONAL,
1675 }
1676 */
1677
1678 typedef struct KrbCredInfo {
1679   EncryptionKey key;
1680   Realm *prealm;
1681   PrincipalName *pname;
1682   TicketFlags *flags;
1683   KerberosTime *authtime;
1684   KerberosTime *starttime;
1685   KerberosTime *endtime;
1686   KerberosTime *renew_till;
1687   Realm *srealm;
1688   PrincipalName *sname;
1689   HostAddresses *caddr;
1690 } KrbCredInfo;
1691
1692 int    decode_KrbCredInfo(const unsigned char *, size_t, KrbCredInfo *, size_t *);
1693 int    encode_KrbCredInfo(unsigned char *, size_t, const KrbCredInfo *, size_t *);
1694 size_t length_KrbCredInfo(const KrbCredInfo *);
1695 int    copy_KrbCredInfo  (const KrbCredInfo *, KrbCredInfo *);
1696 void   free_KrbCredInfo  (KrbCredInfo *);
1697
1698
1699 /*
1700 EncKrbCredPart ::= [APPLICATION 29] SEQUENCE {
1701   ticket-info     [0] SEQUENCE OF KrbCredInfo,
1702   nonce           [1] krb5int32 OPTIONAL,
1703   timestamp       [2] KerberosTime OPTIONAL,
1704   usec            [3] krb5int32 OPTIONAL,
1705   s-address       [4] HostAddress OPTIONAL,
1706   r-address       [5] HostAddress OPTIONAL,
1707 }
1708 */
1709
1710 typedef struct EncKrbCredPart {
1711   struct EncKrbCredPart_ticket_info {
1712     unsigned int len;
1713     KrbCredInfo *val;
1714   } ticket_info;
1715   krb5int32 *nonce;
1716   KerberosTime *timestamp;
1717   krb5int32 *usec;
1718   HostAddress *s_address;
1719   HostAddress *r_address;
1720 } EncKrbCredPart;
1721
1722 int    decode_EncKrbCredPart(const unsigned char *, size_t, EncKrbCredPart *, size_t *);
1723 int    encode_EncKrbCredPart(unsigned char *, size_t, const EncKrbCredPart *, size_t *);
1724 size_t length_EncKrbCredPart(const EncKrbCredPart *);
1725 int    copy_EncKrbCredPart  (const EncKrbCredPart *, EncKrbCredPart *);
1726 void   free_EncKrbCredPart  (EncKrbCredPart *);
1727
1728
1729 /*
1730 KRB-ERROR ::= [APPLICATION 30] SEQUENCE {
1731   pvno            [0] krb5int32,
1732   msg-type        [1] MESSAGE-TYPE,
1733   ctime           [2] KerberosTime OPTIONAL,
1734   cusec           [3] krb5int32 OPTIONAL,
1735   stime           [4] KerberosTime,
1736   susec           [5] krb5int32,
1737   error-code      [6] krb5int32,
1738   crealm          [7] Realm OPTIONAL,
1739   cname           [8] PrincipalName OPTIONAL,
1740   realm           [9] Realm,
1741   sname           [10] PrincipalName,
1742   e-text          [11] GeneralString OPTIONAL,
1743   e-data          [12] OCTET STRING OPTIONAL,
1744 }
1745 */
1746
1747 typedef struct KRB_ERROR {
1748   krb5int32 pvno;
1749   MESSAGE_TYPE msg_type;
1750   KerberosTime *ctime;
1751   krb5int32 *cusec;
1752   KerberosTime stime;
1753   krb5int32 susec;
1754   krb5int32 error_code;
1755   Realm *crealm;
1756   PrincipalName *cname;
1757   Realm realm;
1758   PrincipalName sname;
1759   heim_general_string *e_text;
1760   heim_octet_string *e_data;
1761 } KRB_ERROR;
1762
1763 int    decode_KRB_ERROR(const unsigned char *, size_t, KRB_ERROR *, size_t *);
1764 int    encode_KRB_ERROR(unsigned char *, size_t, const KRB_ERROR *, size_t *);
1765 size_t length_KRB_ERROR(const KRB_ERROR *);
1766 int    copy_KRB_ERROR  (const KRB_ERROR *, KRB_ERROR *);
1767 void   free_KRB_ERROR  (KRB_ERROR *);
1768
1769
1770 /*
1771 ChangePasswdDataMS ::= SEQUENCE {
1772   newpasswd       [0] OCTET STRING,
1773   targname        [1] PrincipalName OPTIONAL,
1774   targrealm       [2] Realm OPTIONAL,
1775 }
1776 */
1777
1778 typedef struct ChangePasswdDataMS {
1779   heim_octet_string newpasswd;
1780   PrincipalName *targname;
1781   Realm *targrealm;
1782 } ChangePasswdDataMS;
1783
1784 int    decode_ChangePasswdDataMS(const unsigned char *, size_t, ChangePasswdDataMS *, size_t *);
1785 int    encode_ChangePasswdDataMS(unsigned char *, size_t, const ChangePasswdDataMS *, size_t *);
1786 size_t length_ChangePasswdDataMS(const ChangePasswdDataMS *);
1787 int    copy_ChangePasswdDataMS  (const ChangePasswdDataMS *, ChangePasswdDataMS *);
1788 void   free_ChangePasswdDataMS  (ChangePasswdDataMS *);
1789
1790
1791 /*
1792 EtypeList ::= SEQUENCE OF krb5int32
1793 */
1794
1795 typedef struct EtypeList {
1796   unsigned int len;
1797   krb5int32 *val;
1798 } EtypeList;
1799
1800 int    decode_EtypeList(const unsigned char *, size_t, EtypeList *, size_t *);
1801 int    encode_EtypeList(unsigned char *, size_t, const EtypeList *, size_t *);
1802 size_t length_EtypeList(const EtypeList *);
1803 int    copy_EtypeList  (const EtypeList *, EtypeList *);
1804 void   free_EtypeList  (EtypeList *);
1805
1806
1807 enum { krb5_pvno = 5 };
1808
1809 enum { DOMAIN_X500_COMPRESS = 1 };
1810
1811 /*
1812 AD-IF-RELEVANT ::= AuthorizationData
1813 */
1814
1815 typedef AuthorizationData AD_IF_RELEVANT;
1816
1817 int    decode_AD_IF_RELEVANT(const unsigned char *, size_t, AD_IF_RELEVANT *, size_t *);
1818 int    encode_AD_IF_RELEVANT(unsigned char *, size_t, const AD_IF_RELEVANT *, size_t *);
1819 size_t length_AD_IF_RELEVANT(const AD_IF_RELEVANT *);
1820 int    copy_AD_IF_RELEVANT  (const AD_IF_RELEVANT *, AD_IF_RELEVANT *);
1821 void   free_AD_IF_RELEVANT  (AD_IF_RELEVANT *);
1822
1823
1824 /*
1825 AD-KDCIssued ::= SEQUENCE {
1826   ad-checksum     [0] Checksum,
1827   i-realm         [1] Realm OPTIONAL,
1828   i-sname         [2] PrincipalName OPTIONAL,
1829   elements        [3] AuthorizationData,
1830 }
1831 */
1832
1833 typedef struct AD_KDCIssued {
1834   Checksum ad_checksum;
1835   Realm *i_realm;
1836   PrincipalName *i_sname;
1837   AuthorizationData elements;
1838 } AD_KDCIssued;
1839
1840 int    decode_AD_KDCIssued(const unsigned char *, size_t, AD_KDCIssued *, size_t *);
1841 int    encode_AD_KDCIssued(unsigned char *, size_t, const AD_KDCIssued *, size_t *);
1842 size_t length_AD_KDCIssued(const AD_KDCIssued *);
1843 int    copy_AD_KDCIssued  (const AD_KDCIssued *, AD_KDCIssued *);
1844 void   free_AD_KDCIssued  (AD_KDCIssued *);
1845
1846
1847 /*
1848 AD-AND-OR ::= SEQUENCE {
1849   condition-count   [0] INTEGER,
1850   elements          [1] AuthorizationData,
1851 }
1852 */
1853
1854 typedef struct AD_AND_OR {
1855   heim_integer condition_count;
1856   AuthorizationData elements;
1857 } AD_AND_OR;
1858
1859 int    decode_AD_AND_OR(const unsigned char *, size_t, AD_AND_OR *, size_t *);
1860 int    encode_AD_AND_OR(unsigned char *, size_t, const AD_AND_OR *, size_t *);
1861 size_t length_AD_AND_OR(const AD_AND_OR *);
1862 int    copy_AD_AND_OR  (const AD_AND_OR *, AD_AND_OR *);
1863 void   free_AD_AND_OR  (AD_AND_OR *);
1864
1865
1866 /*
1867 AD-MANDATORY-FOR-KDC ::= AuthorizationData
1868 */
1869
1870 typedef AuthorizationData AD_MANDATORY_FOR_KDC;
1871
1872 int    decode_AD_MANDATORY_FOR_KDC(const unsigned char *, size_t, AD_MANDATORY_FOR_KDC *, size_t *);
1873 int    encode_AD_MANDATORY_FOR_KDC(unsigned char *, size_t, const AD_MANDATORY_FOR_KDC *, size_t *);
1874 size_t length_AD_MANDATORY_FOR_KDC(const AD_MANDATORY_FOR_KDC *);
1875 int    copy_AD_MANDATORY_FOR_KDC  (const AD_MANDATORY_FOR_KDC *, AD_MANDATORY_FOR_KDC *);
1876 void   free_AD_MANDATORY_FOR_KDC  (AD_MANDATORY_FOR_KDC *);
1877
1878
1879 /*
1880 PA-SAM-TYPE ::= INTEGER {
1881   PA_SAM_TYPE_ENIGMA(1),
1882   PA_SAM_TYPE_DIGI_PATH(2),
1883   PA_SAM_TYPE_SKEY_K0(3),
1884   PA_SAM_TYPE_SKEY(4),
1885   PA_SAM_TYPE_SECURID(5),
1886   PA_SAM_TYPE_CRYPTOCARD(6)
1887 }
1888 */
1889
1890 typedef enum PA_SAM_TYPE {
1891   PA_SAM_TYPE_ENIGMA = 1,
1892   PA_SAM_TYPE_DIGI_PATH = 2,
1893   PA_SAM_TYPE_SKEY_K0 = 3,
1894   PA_SAM_TYPE_SKEY = 4,
1895   PA_SAM_TYPE_SECURID = 5,
1896   PA_SAM_TYPE_CRYPTOCARD = 6
1897 } PA_SAM_TYPE;
1898
1899 int    decode_PA_SAM_TYPE(const unsigned char *, size_t, PA_SAM_TYPE *, size_t *);
1900 int    encode_PA_SAM_TYPE(unsigned char *, size_t, const PA_SAM_TYPE *, size_t *);
1901 size_t length_PA_SAM_TYPE(const PA_SAM_TYPE *);
1902 int    copy_PA_SAM_TYPE  (const PA_SAM_TYPE *, PA_SAM_TYPE *);
1903 void   free_PA_SAM_TYPE  (PA_SAM_TYPE *);
1904
1905
1906 /*
1907 PA-SAM-REDIRECT ::= HostAddresses
1908 */
1909
1910 typedef HostAddresses PA_SAM_REDIRECT;
1911
1912 int    decode_PA_SAM_REDIRECT(const unsigned char *, size_t, PA_SAM_REDIRECT *, size_t *);
1913 int    encode_PA_SAM_REDIRECT(unsigned char *, size_t, const PA_SAM_REDIRECT *, size_t *);
1914 size_t length_PA_SAM_REDIRECT(const PA_SAM_REDIRECT *);
1915 int    copy_PA_SAM_REDIRECT  (const PA_SAM_REDIRECT *, PA_SAM_REDIRECT *);
1916 void   free_PA_SAM_REDIRECT  (PA_SAM_REDIRECT *);
1917
1918
1919 /*
1920 SAMFlags ::= BIT STRING {
1921   use-sad-as-key(0),
1922   send-encrypted-sad(1),
1923   must-pk-encrypt-sad(2)
1924 }
1925 */
1926
1927 typedef struct SAMFlags {
1928   unsigned int use_sad_as_key:1;
1929   unsigned int send_encrypted_sad:1;
1930   unsigned int must_pk_encrypt_sad:1;
1931   unsigned int _unused3:1;
1932   unsigned int _unused4:1;
1933   unsigned int _unused5:1;
1934   unsigned int _unused6:1;
1935   unsigned int _unused7:1;
1936   unsigned int _unused8:1;
1937   unsigned int _unused9:1;
1938   unsigned int _unused10:1;
1939   unsigned int _unused11:1;
1940   unsigned int _unused12:1;
1941   unsigned int _unused13:1;
1942   unsigned int _unused14:1;
1943   unsigned int _unused15:1;
1944   unsigned int _unused16:1;
1945   unsigned int _unused17:1;
1946   unsigned int _unused18:1;
1947   unsigned int _unused19:1;
1948   unsigned int _unused20:1;
1949   unsigned int _unused21:1;
1950   unsigned int _unused22:1;
1951   unsigned int _unused23:1;
1952   unsigned int _unused24:1;
1953   unsigned int _unused25:1;
1954   unsigned int _unused26:1;
1955   unsigned int _unused27:1;
1956   unsigned int _unused28:1;
1957   unsigned int _unused29:1;
1958   unsigned int _unused30:1;
1959   unsigned int _unused31:1;
1960 } SAMFlags;
1961
1962
1963 unsigned SAMFlags2int(SAMFlags);
1964 SAMFlags int2SAMFlags(unsigned);
1965 int    decode_SAMFlags(const unsigned char *, size_t, SAMFlags *, size_t *);
1966 int    encode_SAMFlags(unsigned char *, size_t, const SAMFlags *, size_t *);
1967 size_t length_SAMFlags(const SAMFlags *);
1968 int    copy_SAMFlags  (const SAMFlags *, SAMFlags *);
1969 void   free_SAMFlags  (SAMFlags *);
1970
1971
1972 /*
1973 PA-SAM-CHALLENGE-2-BODY ::= SEQUENCE {
1974   sam-type              [0] krb5int32,
1975   sam-flags             [1] SAMFlags,
1976   sam-type-name         [2] GeneralString OPTIONAL,
1977   sam-track-id          [3] GeneralString OPTIONAL,
1978   sam-challenge-label   [4] GeneralString OPTIONAL,
1979   sam-challenge         [5] GeneralString OPTIONAL,
1980   sam-response-prompt   [6] GeneralString OPTIONAL,
1981   sam-pk-for-sad        [7] EncryptionKey OPTIONAL,
1982   sam-nonce             [8] krb5int32,
1983   sam-etype             [9] krb5int32,
1984   ...,
1985 }
1986 */
1987
1988 typedef struct PA_SAM_CHALLENGE_2_BODY {
1989   krb5int32 sam_type;
1990   SAMFlags sam_flags;
1991   heim_general_string *sam_type_name;
1992   heim_general_string *sam_track_id;
1993   heim_general_string *sam_challenge_label;
1994   heim_general_string *sam_challenge;
1995   heim_general_string *sam_response_prompt;
1996   EncryptionKey *sam_pk_for_sad;
1997   krb5int32 sam_nonce;
1998   krb5int32 sam_etype;
1999 } PA_SAM_CHALLENGE_2_BODY;
2000
2001 int    decode_PA_SAM_CHALLENGE_2_BODY(const unsigned char *, size_t, PA_SAM_CHALLENGE_2_BODY *, size_t *);
2002 int    encode_PA_SAM_CHALLENGE_2_BODY(unsigned char *, size_t, const PA_SAM_CHALLENGE_2_BODY *, size_t *);
2003 size_t length_PA_SAM_CHALLENGE_2_BODY(const PA_SAM_CHALLENGE_2_BODY *);
2004 int    copy_PA_SAM_CHALLENGE_2_BODY  (const PA_SAM_CHALLENGE_2_BODY *, PA_SAM_CHALLENGE_2_BODY *);
2005 void   free_PA_SAM_CHALLENGE_2_BODY  (PA_SAM_CHALLENGE_2_BODY *);
2006
2007
2008 /*
2009 PA-SAM-CHALLENGE-2 ::= SEQUENCE {
2010   sam-body        [0] PA-SAM-CHALLENGE-2-BODY,
2011   sam-cksum       [1] SEQUENCE OF Checksum,
2012   ...,
2013 }
2014 */
2015
2016 typedef struct PA_SAM_CHALLENGE_2 {
2017   PA_SAM_CHALLENGE_2_BODY sam_body;
2018   struct PA_SAM_CHALLENGE_2_sam_cksum {
2019     unsigned int len;
2020     Checksum *val;
2021   } sam_cksum;
2022 } PA_SAM_CHALLENGE_2;
2023
2024 int    decode_PA_SAM_CHALLENGE_2(const unsigned char *, size_t, PA_SAM_CHALLENGE_2 *, size_t *);
2025 int    encode_PA_SAM_CHALLENGE_2(unsigned char *, size_t, const PA_SAM_CHALLENGE_2 *, size_t *);
2026 size_t length_PA_SAM_CHALLENGE_2(const PA_SAM_CHALLENGE_2 *);
2027 int    copy_PA_SAM_CHALLENGE_2  (const PA_SAM_CHALLENGE_2 *, PA_SAM_CHALLENGE_2 *);
2028 void   free_PA_SAM_CHALLENGE_2  (PA_SAM_CHALLENGE_2 *);
2029
2030
2031 /*
2032 PA-SAM-RESPONSE-2 ::= SEQUENCE {
2033   sam-type               [0] krb5int32,
2034   sam-flags              [1] SAMFlags,
2035   sam-track-id           [2] GeneralString OPTIONAL,
2036   sam-enc-nonce-or-sad   [3] EncryptedData,
2037   sam-nonce              [4] krb5int32,
2038   ...,
2039 }
2040 */
2041
2042 typedef struct PA_SAM_RESPONSE_2 {
2043   krb5int32 sam_type;
2044   SAMFlags sam_flags;
2045   heim_general_string *sam_track_id;
2046   EncryptedData sam_enc_nonce_or_sad;
2047   krb5int32 sam_nonce;
2048 } PA_SAM_RESPONSE_2;
2049
2050 int    decode_PA_SAM_RESPONSE_2(const unsigned char *, size_t, PA_SAM_RESPONSE_2 *, size_t *);
2051 int    encode_PA_SAM_RESPONSE_2(unsigned char *, size_t, const PA_SAM_RESPONSE_2 *, size_t *);
2052 size_t length_PA_SAM_RESPONSE_2(const PA_SAM_RESPONSE_2 *);
2053 int    copy_PA_SAM_RESPONSE_2  (const PA_SAM_RESPONSE_2 *, PA_SAM_RESPONSE_2 *);
2054 void   free_PA_SAM_RESPONSE_2  (PA_SAM_RESPONSE_2 *);
2055
2056
2057 /*
2058 PA-ENC-SAM-RESPONSE-ENC ::= SEQUENCE {
2059   sam-nonce       [0] krb5int32,
2060   sam-sad         [1] GeneralString OPTIONAL,
2061   ...,
2062 }
2063 */
2064
2065 typedef struct PA_ENC_SAM_RESPONSE_ENC {
2066   krb5int32 sam_nonce;
2067   heim_general_string *sam_sad;
2068 } PA_ENC_SAM_RESPONSE_ENC;
2069
2070 int    decode_PA_ENC_SAM_RESPONSE_ENC(const unsigned char *, size_t, PA_ENC_SAM_RESPONSE_ENC *, size_t *);
2071 int    encode_PA_ENC_SAM_RESPONSE_ENC(unsigned char *, size_t, const PA_ENC_SAM_RESPONSE_ENC *, size_t *);
2072 size_t length_PA_ENC_SAM_RESPONSE_ENC(const PA_ENC_SAM_RESPONSE_ENC *);
2073 int    copy_PA_ENC_SAM_RESPONSE_ENC  (const PA_ENC_SAM_RESPONSE_ENC *, PA_ENC_SAM_RESPONSE_ENC *);
2074 void   free_PA_ENC_SAM_RESPONSE_ENC  (PA_ENC_SAM_RESPONSE_ENC *);
2075
2076
2077 /*
2078 PA-S4U2Self ::= SEQUENCE {
2079   name            [0] PrincipalName,
2080   realm           [1] Realm,
2081   cksum           [2] Checksum,
2082   auth            [3] GeneralString,
2083 }
2084 */
2085
2086 typedef struct PA_S4U2Self {
2087   PrincipalName name;
2088   Realm realm;
2089   Checksum cksum;
2090   heim_general_string auth;
2091 } PA_S4U2Self;
2092
2093 int    decode_PA_S4U2Self(const unsigned char *, size_t, PA_S4U2Self *, size_t *);
2094 int    encode_PA_S4U2Self(unsigned char *, size_t, const PA_S4U2Self *, size_t *);
2095 size_t length_PA_S4U2Self(const PA_S4U2Self *);
2096 int    copy_PA_S4U2Self  (const PA_S4U2Self *, PA_S4U2Self *);
2097 void   free_PA_S4U2Self  (PA_S4U2Self *);
2098
2099
2100 /*
2101 KRB5SignedPathData ::= SEQUENCE {
2102   client          [0] Principal OPTIONAL,
2103   authtime        [1] KerberosTime,
2104   delegated       [2] Principals OPTIONAL,
2105   method_data     [3] METHOD-DATA OPTIONAL,
2106 }
2107 */
2108
2109 typedef struct KRB5SignedPathData {
2110   Principal *client;
2111   KerberosTime authtime;
2112   Principals *delegated;
2113   METHOD_DATA *method_data;
2114 } KRB5SignedPathData;
2115
2116 int    decode_KRB5SignedPathData(const unsigned char *, size_t, KRB5SignedPathData *, size_t *);
2117 int    encode_KRB5SignedPathData(unsigned char *, size_t, const KRB5SignedPathData *, size_t *);
2118 size_t length_KRB5SignedPathData(const KRB5SignedPathData *);
2119 int    copy_KRB5SignedPathData  (const KRB5SignedPathData *, KRB5SignedPathData *);
2120 void   free_KRB5SignedPathData  (KRB5SignedPathData *);
2121
2122
2123 /*
2124 KRB5SignedPath ::= SEQUENCE {
2125   etype           [0] ENCTYPE,
2126   cksum           [1] Checksum,
2127   delegated       [2] Principals OPTIONAL,
2128   method_data     [3] METHOD-DATA OPTIONAL,
2129 }
2130 */
2131
2132 typedef struct KRB5SignedPath {
2133   ENCTYPE etype;
2134   Checksum cksum;
2135   Principals *delegated;
2136   METHOD_DATA *method_data;
2137 } KRB5SignedPath;
2138
2139 int    decode_KRB5SignedPath(const unsigned char *, size_t, KRB5SignedPath *, size_t *);
2140 int    encode_KRB5SignedPath(unsigned char *, size_t, const KRB5SignedPath *, size_t *);
2141 size_t length_KRB5SignedPath(const KRB5SignedPath *);
2142 int    copy_KRB5SignedPath  (const KRB5SignedPath *, KRB5SignedPath *);
2143 void   free_KRB5SignedPath  (KRB5SignedPath *);
2144
2145
2146 /*
2147 PA-ClientCanonicalizedNames ::= SEQUENCE {
2148   requested-name   [0] PrincipalName,
2149   mapped-name      [1] PrincipalName,
2150 }
2151 */
2152
2153 typedef struct PA_ClientCanonicalizedNames {
2154   PrincipalName requested_name;
2155   PrincipalName mapped_name;
2156 } PA_ClientCanonicalizedNames;
2157
2158 int    decode_PA_ClientCanonicalizedNames(const unsigned char *, size_t, PA_ClientCanonicalizedNames *, size_t *);
2159 int    encode_PA_ClientCanonicalizedNames(unsigned char *, size_t, const PA_ClientCanonicalizedNames *, size_t *);
2160 size_t length_PA_ClientCanonicalizedNames(const PA_ClientCanonicalizedNames *);
2161 int    copy_PA_ClientCanonicalizedNames  (const PA_ClientCanonicalizedNames *, PA_ClientCanonicalizedNames *);
2162 void   free_PA_ClientCanonicalizedNames  (PA_ClientCanonicalizedNames *);
2163
2164
2165 /*
2166 PA-ClientCanonicalized ::= SEQUENCE {
2167   names            [0] PA-ClientCanonicalizedNames,
2168   canon-checksum   [1] Checksum,
2169 }
2170 */
2171
2172 typedef struct PA_ClientCanonicalized {
2173   PA_ClientCanonicalizedNames names;
2174   Checksum canon_checksum;
2175 } PA_ClientCanonicalized;
2176
2177 int    decode_PA_ClientCanonicalized(const unsigned char *, size_t, PA_ClientCanonicalized *, size_t *);
2178 int    encode_PA_ClientCanonicalized(unsigned char *, size_t, const PA_ClientCanonicalized *, size_t *);
2179 size_t length_PA_ClientCanonicalized(const PA_ClientCanonicalized *);
2180 int    copy_PA_ClientCanonicalized  (const PA_ClientCanonicalized *, PA_ClientCanonicalized *);
2181 void   free_PA_ClientCanonicalized  (PA_ClientCanonicalized *);
2182
2183
2184 /*
2185 AD-LoginAlias ::= SEQUENCE {
2186   login-alias     [0] PrincipalName,
2187   checksum        [1] Checksum,
2188 }
2189 */
2190
2191 typedef struct AD_LoginAlias {
2192   PrincipalName login_alias;
2193   Checksum checksum;
2194 } AD_LoginAlias;
2195
2196 int    decode_AD_LoginAlias(const unsigned char *, size_t, AD_LoginAlias *, size_t *);
2197 int    encode_AD_LoginAlias(unsigned char *, size_t, const AD_LoginAlias *, size_t *);
2198 size_t length_AD_LoginAlias(const AD_LoginAlias *);
2199 int    copy_AD_LoginAlias  (const AD_LoginAlias *, AD_LoginAlias *);
2200 void   free_AD_LoginAlias  (AD_LoginAlias *);
2201
2202
2203 /*
2204 PA-SvrReferralData ::= SEQUENCE {
2205   referred-name    [1] PrincipalName OPTIONAL,
2206   referred-realm   [0] Realm,
2207 }
2208 */
2209
2210 typedef struct PA_SvrReferralData {
2211   PrincipalName *referred_name;
2212   Realm referred_realm;
2213 } PA_SvrReferralData;
2214
2215 int    decode_PA_SvrReferralData(const unsigned char *, size_t, PA_SvrReferralData *, size_t *);
2216 int    encode_PA_SvrReferralData(unsigned char *, size_t, const PA_SvrReferralData *, size_t *);
2217 size_t length_PA_SvrReferralData(const PA_SvrReferralData *);
2218 int    copy_PA_SvrReferralData  (const PA_SvrReferralData *, PA_SvrReferralData *);
2219 void   free_PA_SvrReferralData  (PA_SvrReferralData *);
2220
2221
2222 /*
2223 PA-SERVER-REFERRAL-DATA ::= EncryptedData
2224 */
2225
2226 typedef EncryptedData PA_SERVER_REFERRAL_DATA;
2227
2228 int    decode_PA_SERVER_REFERRAL_DATA(const unsigned char *, size_t, PA_SERVER_REFERRAL_DATA *, size_t *);
2229 int    encode_PA_SERVER_REFERRAL_DATA(unsigned char *, size_t, const PA_SERVER_REFERRAL_DATA *, size_t *);
2230 size_t length_PA_SERVER_REFERRAL_DATA(const PA_SERVER_REFERRAL_DATA *);
2231 int    copy_PA_SERVER_REFERRAL_DATA  (const PA_SERVER_REFERRAL_DATA *, PA_SERVER_REFERRAL_DATA *);
2232 void   free_PA_SERVER_REFERRAL_DATA  (PA_SERVER_REFERRAL_DATA *);
2233
2234
2235 /*
2236 PA-ServerReferralData ::= SEQUENCE {
2237   referred-realm             [0] Realm OPTIONAL,
2238   true-principal-name        [1] PrincipalName OPTIONAL,
2239   requested-principal-name   [2] PrincipalName OPTIONAL,
2240   referral-valid-until       [3] KerberosTime OPTIONAL,
2241   ...,
2242 }
2243 */
2244
2245 typedef struct PA_ServerReferralData {
2246   Realm *referred_realm;
2247   PrincipalName *true_principal_name;
2248   PrincipalName *requested_principal_name;
2249   KerberosTime *referral_valid_until;
2250 } PA_ServerReferralData;
2251
2252 int    decode_PA_ServerReferralData(const unsigned char *, size_t, PA_ServerReferralData *, size_t *);
2253 int    encode_PA_ServerReferralData(unsigned char *, size_t, const PA_ServerReferralData *, size_t *);
2254 size_t length_PA_ServerReferralData(const PA_ServerReferralData *);
2255 int    copy_PA_ServerReferralData  (const PA_ServerReferralData *, PA_ServerReferralData *);
2256 void   free_PA_ServerReferralData  (PA_ServerReferralData *);
2257
2258
2259 /*
2260 FastOptions ::= BIT STRING {
2261   reserved(0),
2262   hide-client-names(1),
2263   kdc-follow--referrals(16)
2264 }
2265 */
2266
2267 typedef struct FastOptions {
2268   unsigned int reserved:1;
2269   unsigned int hide_client_names:1;
2270   unsigned int _unused2:1;
2271   unsigned int _unused3:1;
2272   unsigned int _unused4:1;
2273   unsigned int _unused5:1;
2274   unsigned int _unused6:1;
2275   unsigned int _unused7:1;
2276   unsigned int _unused8:1;
2277   unsigned int _unused9:1;
2278   unsigned int _unused10:1;
2279   unsigned int _unused11:1;
2280   unsigned int _unused12:1;
2281   unsigned int _unused13:1;
2282   unsigned int _unused14:1;
2283   unsigned int _unused15:1;
2284   unsigned int kdc_follow__referrals:1;
2285   unsigned int _unused17:1;
2286   unsigned int _unused18:1;
2287   unsigned int _unused19:1;
2288   unsigned int _unused20:1;
2289   unsigned int _unused21:1;
2290   unsigned int _unused22:1;
2291   unsigned int _unused23:1;
2292   unsigned int _unused24:1;
2293   unsigned int _unused25:1;
2294   unsigned int _unused26:1;
2295   unsigned int _unused27:1;
2296   unsigned int _unused28:1;
2297   unsigned int _unused29:1;
2298   unsigned int _unused30:1;
2299   unsigned int _unused31:1;
2300 } FastOptions;
2301
2302
2303 unsigned FastOptions2int(FastOptions);
2304 FastOptions int2FastOptions(unsigned);
2305 int    decode_FastOptions(const unsigned char *, size_t, FastOptions *, size_t *);
2306 int    encode_FastOptions(unsigned char *, size_t, const FastOptions *, size_t *);
2307 size_t length_FastOptions(const FastOptions *);
2308 int    copy_FastOptions  (const FastOptions *, FastOptions *);
2309 void   free_FastOptions  (FastOptions *);
2310
2311
2312 /*
2313 KrbFastReq ::= SEQUENCE {
2314   fast-options    [0] FastOptions,
2315   padata          [1] SEQUENCE OF PA-DATA,
2316   req-body        [2] KDC-REQ-BODY,
2317   ...,
2318 }
2319 */
2320
2321 typedef struct KrbFastReq {
2322   FastOptions fast_options;
2323   struct KrbFastReq_padata {
2324     unsigned int len;
2325     PA_DATA *val;
2326   } padata;
2327   KDC_REQ_BODY req_body;
2328 } KrbFastReq;
2329
2330 int    decode_KrbFastReq(const unsigned char *, size_t, KrbFastReq *, size_t *);
2331 int    encode_KrbFastReq(unsigned char *, size_t, const KrbFastReq *, size_t *);
2332 size_t length_KrbFastReq(const KrbFastReq *);
2333 int    copy_KrbFastReq  (const KrbFastReq *, KrbFastReq *);
2334 void   free_KrbFastReq  (KrbFastReq *);
2335
2336
2337 /*
2338 KrbFastArmor ::= SEQUENCE {
2339   armor-type      [0] krb5int32,
2340   armor-value     [1] OCTET STRING,
2341   ...,
2342 }
2343 */
2344
2345 typedef struct KrbFastArmor {
2346   krb5int32 armor_type;
2347   heim_octet_string armor_value;
2348 } KrbFastArmor;
2349
2350 int    decode_KrbFastArmor(const unsigned char *, size_t, KrbFastArmor *, size_t *);
2351 int    encode_KrbFastArmor(unsigned char *, size_t, const KrbFastArmor *, size_t *);
2352 size_t length_KrbFastArmor(const KrbFastArmor *);
2353 int    copy_KrbFastArmor  (const KrbFastArmor *, KrbFastArmor *);
2354 void   free_KrbFastArmor  (KrbFastArmor *);
2355
2356
2357 /*
2358 KrbFastArmoredReq ::= SEQUENCE {
2359   armor           [0] KrbFastArmor OPTIONAL,
2360   req-checksum    [1] Checksum,
2361   enc-fast-req    [2] EncryptedData,
2362 }
2363 */
2364
2365 typedef struct KrbFastArmoredReq {
2366   KrbFastArmor *armor;
2367   Checksum req_checksum;
2368   EncryptedData enc_fast_req;
2369 } KrbFastArmoredReq;
2370
2371 int    decode_KrbFastArmoredReq(const unsigned char *, size_t, KrbFastArmoredReq *, size_t *);
2372 int    encode_KrbFastArmoredReq(unsigned char *, size_t, const KrbFastArmoredReq *, size_t *);
2373 size_t length_KrbFastArmoredReq(const KrbFastArmoredReq *);
2374 int    copy_KrbFastArmoredReq  (const KrbFastArmoredReq *, KrbFastArmoredReq *);
2375 void   free_KrbFastArmoredReq  (KrbFastArmoredReq *);
2376
2377
2378 /*
2379 PA-FX-FAST-REQUEST ::= CHOICE {
2380   armored-data    [0] KrbFastArmoredReq,
2381   ...,
2382 }
2383 */
2384
2385 typedef struct PA_FX_FAST_REQUEST {
2386   enum {
2387     choice_PA_FX_FAST_REQUEST_asn1_ellipsis = 0,
2388     choice_PA_FX_FAST_REQUEST_armored_data
2389     /* ... */
2390   } element;
2391   union {
2392     KrbFastArmoredReq armored_data;
2393     heim_octet_string asn1_ellipsis;
2394   } u;
2395 } PA_FX_FAST_REQUEST;
2396
2397 int    decode_PA_FX_FAST_REQUEST(const unsigned char *, size_t, PA_FX_FAST_REQUEST *, size_t *);
2398 int    encode_PA_FX_FAST_REQUEST(unsigned char *, size_t, const PA_FX_FAST_REQUEST *, size_t *);
2399 size_t length_PA_FX_FAST_REQUEST(const PA_FX_FAST_REQUEST *);
2400 int    copy_PA_FX_FAST_REQUEST  (const PA_FX_FAST_REQUEST *, PA_FX_FAST_REQUEST *);
2401 void   free_PA_FX_FAST_REQUEST  (PA_FX_FAST_REQUEST *);
2402
2403
2404 /*
2405 KrbFastFinished ::= SEQUENCE {
2406   timestamp         [0] KerberosTime,
2407   usec              [1] krb5int32,
2408   crealm            [2] Realm,
2409   cname             [3] PrincipalName,
2410   checksum          [4] Checksum,
2411   ticket-checksum   [5] Checksum,
2412   ...,
2413 }
2414 */
2415
2416 typedef struct KrbFastFinished {
2417   KerberosTime timestamp;
2418   krb5int32 usec;
2419   Realm crealm;
2420   PrincipalName cname;
2421   Checksum checksum;
2422   Checksum ticket_checksum;
2423 } KrbFastFinished;
2424
2425 int    decode_KrbFastFinished(const unsigned char *, size_t, KrbFastFinished *, size_t *);
2426 int    encode_KrbFastFinished(unsigned char *, size_t, const KrbFastFinished *, size_t *);
2427 size_t length_KrbFastFinished(const KrbFastFinished *);
2428 int    copy_KrbFastFinished  (const KrbFastFinished *, KrbFastFinished *);
2429 void   free_KrbFastFinished  (KrbFastFinished *);
2430
2431
2432 /*
2433 KrbFastResponse ::= SEQUENCE {
2434   padata          [0] SEQUENCE OF PA-DATA,
2435   rep-key         [1] EncryptionKey OPTIONAL,
2436   finished        [2] KrbFastFinished OPTIONAL,
2437   ...,
2438 }
2439 */
2440
2441 typedef struct KrbFastResponse {
2442   struct KrbFastResponse_padata {
2443     unsigned int len;
2444     PA_DATA *val;
2445   } padata;
2446   EncryptionKey *rep_key;
2447   KrbFastFinished *finished;
2448 } KrbFastResponse;
2449
2450 int    decode_KrbFastResponse(const unsigned char *, size_t, KrbFastResponse *, size_t *);
2451 int    encode_KrbFastResponse(unsigned char *, size_t, const KrbFastResponse *, size_t *);
2452 size_t length_KrbFastResponse(const KrbFastResponse *);
2453 int    copy_KrbFastResponse  (const KrbFastResponse *, KrbFastResponse *);
2454 void   free_KrbFastResponse  (KrbFastResponse *);
2455
2456
2457 /*
2458 KrbFastArmoredRep ::= SEQUENCE {
2459   enc-fast-rep    [0] EncryptedData,
2460   ...,
2461 }
2462 */
2463
2464 typedef struct KrbFastArmoredRep {
2465   EncryptedData enc_fast_rep;
2466 } KrbFastArmoredRep;
2467
2468 int    decode_KrbFastArmoredRep(const unsigned char *, size_t, KrbFastArmoredRep *, size_t *);
2469 int    encode_KrbFastArmoredRep(unsigned char *, size_t, const KrbFastArmoredRep *, size_t *);
2470 size_t length_KrbFastArmoredRep(const KrbFastArmoredRep *);
2471 int    copy_KrbFastArmoredRep  (const KrbFastArmoredRep *, KrbFastArmoredRep *);
2472 void   free_KrbFastArmoredRep  (KrbFastArmoredRep *);
2473
2474
2475 /*
2476 PA-FX-FAST-REPLY ::= CHOICE {
2477   armored-data    [0] KrbFastArmoredRep,
2478   ...,
2479 }
2480 */
2481
2482 typedef struct PA_FX_FAST_REPLY {
2483   enum {
2484     choice_PA_FX_FAST_REPLY_asn1_ellipsis = 0,
2485     choice_PA_FX_FAST_REPLY_armored_data
2486     /* ... */
2487   } element;
2488   union {
2489     KrbFastArmoredRep armored_data;
2490     heim_octet_string asn1_ellipsis;
2491   } u;
2492 } PA_FX_FAST_REPLY;
2493
2494 int    decode_PA_FX_FAST_REPLY(const unsigned char *, size_t, PA_FX_FAST_REPLY *, size_t *);
2495 int    encode_PA_FX_FAST_REPLY(unsigned char *, size_t, const PA_FX_FAST_REPLY *, size_t *);
2496 size_t length_PA_FX_FAST_REPLY(const PA_FX_FAST_REPLY *);
2497 int    copy_PA_FX_FAST_REPLY  (const PA_FX_FAST_REPLY *, PA_FX_FAST_REPLY *);
2498 void   free_PA_FX_FAST_REPLY  (PA_FX_FAST_REPLY *);
2499
2500
2501 #endif /* __krb5_asn1_h__ */