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__ */