#ifndef __asn1_common_definitions__
#define __asn1_common_definitions__
+#ifndef __HEIM_BASE_DATA__
+#define __HEIM_BASE_DATA__ 1
+struct heim_base_data {
+ size_t length;
+ void *data;
+};
+typedef struct heim_base_data heim_octet_string;
+#endif
+
typedef struct heim_integer {
size_t length;
void *data;
int negative;
} heim_integer;
-typedef struct heim_octet_string {
- size_t length;
- void *data;
-} heim_octet_string;
-
typedef char *heim_general_string;
typedef char *heim_utf8_string;
-typedef char *heim_printable_string;
+typedef struct heim_base_data heim_printable_string;
-typedef char *heim_ia5_string;
+typedef struct heim_base_data heim_ia5_string;
typedef struct heim_bmp_string {
size_t length;
void *data;
} heim_bit_string;
-typedef struct heim_octet_string heim_any;
-typedef struct heim_octet_string heim_any_set;
+typedef struct heim_base_data heim_any;
+typedef struct heim_base_data heim_any_set;
#define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \
do { \
} \
} while (0)
+#ifdef _WIN32
+#ifndef ASN1_LIB
+#define ASN1EXP __declspec(dllimport)
+#else
+#define ASN1EXP
+#endif
+#define ASN1CALL __stdcall
+#else
+#define ASN1EXP
+#define ASN1CALL
+#endif
#endif
KRB5_NT_SMTP_NAME(7),
KRB5_NT_ENTERPRISE_PRINCIPAL(10),
KRB5_NT_WELLKNOWN(11),
+ KRB5_NT_SRV_HST_DOMAIN(12),
KRB5_NT_ENT_PRINCIPAL_AND_ID(-130),
KRB5_NT_MS_PRINCIPAL(-128),
KRB5_NT_MS_PRINCIPAL_AND_ID(-129),
- KRB5_NT_NTLM(-1200)
+ KRB5_NT_NTLM(-1200),
+ KRB5_NT_X509_GENERAL_NAME(-1201),
+ KRB5_NT_GSS_HOSTBASED_SERVICE(-1202),
+ KRB5_NT_CACHE_UUID(-1203),
+ KRB5_NT_SRV_HST_NEEDS_CANON(-195894762)
}
*/
KRB5_NT_SMTP_NAME = 7,
KRB5_NT_ENTERPRISE_PRINCIPAL = 10,
KRB5_NT_WELLKNOWN = 11,
+ KRB5_NT_SRV_HST_DOMAIN = 12,
KRB5_NT_ENT_PRINCIPAL_AND_ID = -130,
KRB5_NT_MS_PRINCIPAL = -128,
KRB5_NT_MS_PRINCIPAL_AND_ID = -129,
- KRB5_NT_NTLM = -1200
+ KRB5_NT_NTLM = -1200,
+ KRB5_NT_X509_GENERAL_NAME = -1201,
+ KRB5_NT_GSS_HOSTBASED_SERVICE = -1202,
+ KRB5_NT_CACHE_UUID = -1203,
+ KRB5_NT_SRV_HST_NEEDS_CANON = -195894762
} NAME_TYPE;
-int decode_NAME_TYPE(const unsigned char *, size_t, NAME_TYPE *, size_t *);
-int encode_NAME_TYPE(unsigned char *, size_t, const NAME_TYPE *, size_t *);
-size_t length_NAME_TYPE(const NAME_TYPE *);
-int copy_NAME_TYPE (const NAME_TYPE *, NAME_TYPE *);
-void free_NAME_TYPE (NAME_TYPE *);
+ASN1EXP int ASN1CALL decode_NAME_TYPE(const unsigned char *, size_t, NAME_TYPE *, size_t *);
+ASN1EXP int ASN1CALL encode_NAME_TYPE(unsigned char *, size_t, const NAME_TYPE *, size_t *);
+ASN1EXP size_t ASN1CALL length_NAME_TYPE(const NAME_TYPE *);
+ASN1EXP int ASN1CALL copy_NAME_TYPE (const NAME_TYPE *, NAME_TYPE *);
+ASN1EXP void ASN1CALL free_NAME_TYPE (NAME_TYPE *);
/*
krb_error = 30
} MESSAGE_TYPE;
-int decode_MESSAGE_TYPE(const unsigned char *, size_t, MESSAGE_TYPE *, size_t *);
-int encode_MESSAGE_TYPE(unsigned char *, size_t, const MESSAGE_TYPE *, size_t *);
-size_t length_MESSAGE_TYPE(const MESSAGE_TYPE *);
-int copy_MESSAGE_TYPE (const MESSAGE_TYPE *, MESSAGE_TYPE *);
-void free_MESSAGE_TYPE (MESSAGE_TYPE *);
-
-
/*
PADATA-TYPE ::= INTEGER {
KRB5_PADATA_NONE(0),
KRB5_PADATA_SAM_CHALLENGE2(30),
KRB5_PADATA_SAM_RESPONSE2(31),
KRB5_PA_EXTRA_TGT(41),
+ KRB5_PADATA_FX_FAST_ARMOR(71),
KRB5_PADATA_TD_KRB_PRINCIPAL(102),
KRB5_PADATA_PK_TD_TRUSTED_CERTIFIERS(104),
KRB5_PADATA_PK_TD_CERTIFICATE_INDEX(105),
KRB5_PADATA_FOR_CHECK_DUPS(131),
KRB5_PADATA_AS_CHECKSUM(132),
KRB5_PADATA_PK_AS_09_BINDING(132),
- KRB5_PADATA_CLIENT_CANONICALIZED(133),
KRB5_PADATA_FX_COOKIE(133),
KRB5_PADATA_AUTHENTICATION_SET(134),
KRB5_PADATA_AUTH_SET_SELECTED(135),
KRB5_PADATA_EPAK_AS_REP(146),
KRB5_PADATA_PKINIT_KX(147),
KRB5_PADATA_PKU2U_NAME(148),
+ KRB5_PADATA_REQ_ENC_PA_REP(149),
KRB5_PADATA_SUPPORTED_ETYPES(165)
}
*/
KRB5_PADATA_SAM_CHALLENGE2 = 30,
KRB5_PADATA_SAM_RESPONSE2 = 31,
KRB5_PA_EXTRA_TGT = 41,
+ KRB5_PADATA_FX_FAST_ARMOR = 71,
KRB5_PADATA_TD_KRB_PRINCIPAL = 102,
KRB5_PADATA_PK_TD_TRUSTED_CERTIFIERS = 104,
KRB5_PADATA_PK_TD_CERTIFICATE_INDEX = 105,
KRB5_PADATA_FOR_CHECK_DUPS = 131,
KRB5_PADATA_AS_CHECKSUM = 132,
KRB5_PADATA_PK_AS_09_BINDING = 132,
- KRB5_PADATA_CLIENT_CANONICALIZED = 133,
KRB5_PADATA_FX_COOKIE = 133,
KRB5_PADATA_AUTHENTICATION_SET = 134,
KRB5_PADATA_AUTH_SET_SELECTED = 135,
KRB5_PADATA_EPAK_AS_REP = 146,
KRB5_PADATA_PKINIT_KX = 147,
KRB5_PADATA_PKU2U_NAME = 148,
+ KRB5_PADATA_REQ_ENC_PA_REP = 149,
KRB5_PADATA_SUPPORTED_ETYPES = 165
} PADATA_TYPE;
-int decode_PADATA_TYPE(const unsigned char *, size_t, PADATA_TYPE *, size_t *);
-int encode_PADATA_TYPE(unsigned char *, size_t, const PADATA_TYPE *, size_t *);
-size_t length_PADATA_TYPE(const PADATA_TYPE *);
-int copy_PADATA_TYPE (const PADATA_TYPE *, PADATA_TYPE *);
-void free_PADATA_TYPE (PADATA_TYPE *);
+ASN1EXP int ASN1CALL decode_PADATA_TYPE(const unsigned char *, size_t, PADATA_TYPE *, size_t *);
+ASN1EXP int ASN1CALL encode_PADATA_TYPE(unsigned char *, size_t, const PADATA_TYPE *, size_t *);
+ASN1EXP size_t ASN1CALL length_PADATA_TYPE(const PADATA_TYPE *);
+ASN1EXP int ASN1CALL copy_PADATA_TYPE (const PADATA_TYPE *, PADATA_TYPE *);
+ASN1EXP void ASN1CALL free_PADATA_TYPE (PADATA_TYPE *);
/*
KRB5_AUTHDATA_SIGNTICKET = 512
} AUTHDATA_TYPE;
-int decode_AUTHDATA_TYPE(const unsigned char *, size_t, AUTHDATA_TYPE *, size_t *);
-int encode_AUTHDATA_TYPE(unsigned char *, size_t, const AUTHDATA_TYPE *, size_t *);
-size_t length_AUTHDATA_TYPE(const AUTHDATA_TYPE *);
-int copy_AUTHDATA_TYPE (const AUTHDATA_TYPE *, AUTHDATA_TYPE *);
-void free_AUTHDATA_TYPE (AUTHDATA_TYPE *);
+ASN1EXP int ASN1CALL decode_AUTHDATA_TYPE(const unsigned char *, size_t, AUTHDATA_TYPE *, size_t *);
+ASN1EXP int ASN1CALL encode_AUTHDATA_TYPE(unsigned char *, size_t, const AUTHDATA_TYPE *, size_t *);
+ASN1EXP size_t ASN1CALL length_AUTHDATA_TYPE(const AUTHDATA_TYPE *);
+ASN1EXP int ASN1CALL copy_AUTHDATA_TYPE (const AUTHDATA_TYPE *, AUTHDATA_TYPE *);
+ASN1EXP void ASN1CALL free_AUTHDATA_TYPE (AUTHDATA_TYPE *);
/*
CKSUMTYPE_SHA1(14),
CKSUMTYPE_HMAC_SHA1_96_AES_128(15),
CKSUMTYPE_HMAC_SHA1_96_AES_256(16),
+ CKSUMTYPE_HMAC_SHA256_128_AES128(19),
+ CKSUMTYPE_HMAC_SHA384_192_AES256(20),
CKSUMTYPE_GSSAPI(32771),
CKSUMTYPE_HMAC_MD5(-138),
CKSUMTYPE_HMAC_MD5_ENC(-1138)
CKSUMTYPE_SHA1 = 14,
CKSUMTYPE_HMAC_SHA1_96_AES_128 = 15,
CKSUMTYPE_HMAC_SHA1_96_AES_256 = 16,
+ CKSUMTYPE_HMAC_SHA256_128_AES128 = 19,
+ CKSUMTYPE_HMAC_SHA384_192_AES256 = 20,
CKSUMTYPE_GSSAPI = 32771,
CKSUMTYPE_HMAC_MD5 = -138,
CKSUMTYPE_HMAC_MD5_ENC = -1138
} CKSUMTYPE;
-int decode_CKSUMTYPE(const unsigned char *, size_t, CKSUMTYPE *, size_t *);
-int encode_CKSUMTYPE(unsigned char *, size_t, const CKSUMTYPE *, size_t *);
-size_t length_CKSUMTYPE(const CKSUMTYPE *);
-int copy_CKSUMTYPE (const CKSUMTYPE *, CKSUMTYPE *);
-void free_CKSUMTYPE (CKSUMTYPE *);
+ASN1EXP int ASN1CALL decode_CKSUMTYPE(const unsigned char *, size_t, CKSUMTYPE *, size_t *);
+ASN1EXP int ASN1CALL encode_CKSUMTYPE(unsigned char *, size_t, const CKSUMTYPE *, size_t *);
+ASN1EXP size_t ASN1CALL length_CKSUMTYPE(const CKSUMTYPE *);
+ASN1EXP int ASN1CALL copy_CKSUMTYPE (const CKSUMTYPE *, CKSUMTYPE *);
+ASN1EXP void ASN1CALL free_CKSUMTYPE (CKSUMTYPE *);
/*
ENCTYPE ::= INTEGER {
- ETYPE_NULL(0),
- ETYPE_DES_CBC_CRC(1),
- ETYPE_DES_CBC_MD4(2),
- ETYPE_DES_CBC_MD5(3),
- ETYPE_DES3_CBC_MD5(5),
- ETYPE_OLD_DES3_CBC_SHA1(7),
- ETYPE_SIGN_DSA_GENERATE(8),
- ETYPE_ENCRYPT_RSA_PRIV(9),
- ETYPE_ENCRYPT_RSA_PUB(10),
- ETYPE_DES3_CBC_SHA1(16),
- ETYPE_AES128_CTS_HMAC_SHA1_96(17),
- ETYPE_AES256_CTS_HMAC_SHA1_96(18),
- ETYPE_ARCFOUR_HMAC_MD5(23),
- ETYPE_ARCFOUR_HMAC_MD5_56(24),
- ETYPE_ENCTYPE_PK_CROSS(48),
- ETYPE_ARCFOUR_MD4(-128),
- ETYPE_ARCFOUR_HMAC_OLD(-133),
- ETYPE_ARCFOUR_HMAC_OLD_EXP(-135),
- ETYPE_DES_CBC_NONE(-4096),
- ETYPE_DES3_CBC_NONE(-4097),
- ETYPE_DES_CFB64_NONE(-4098),
- ETYPE_DES_PCBC_NONE(-4099),
- ETYPE_DIGEST_MD5_NONE(-4100),
- ETYPE_CRAM_MD5_NONE(-4101)
+ KRB5_ENCTYPE_NULL(0),
+ KRB5_ENCTYPE_DES_CBC_CRC(1),
+ KRB5_ENCTYPE_DES_CBC_MD4(2),
+ KRB5_ENCTYPE_DES_CBC_MD5(3),
+ KRB5_ENCTYPE_DES3_CBC_MD5(5),
+ KRB5_ENCTYPE_OLD_DES3_CBC_SHA1(7),
+ KRB5_ENCTYPE_SIGN_DSA_GENERATE(8),
+ KRB5_ENCTYPE_ENCRYPT_RSA_PRIV(9),
+ KRB5_ENCTYPE_ENCRYPT_RSA_PUB(10),
+ KRB5_ENCTYPE_DES3_CBC_SHA1(16),
+ KRB5_ENCTYPE_AES128_CTS_HMAC_SHA1_96(17),
+ KRB5_ENCTYPE_AES256_CTS_HMAC_SHA1_96(18),
+ KRB5_ENCTYPE_AES128_CTS_HMAC_SHA256_128(19),
+ KRB5_ENCTYPE_AES256_CTS_HMAC_SHA384_192(20),
+ KRB5_ENCTYPE_ARCFOUR_HMAC_MD5(23),
+ KRB5_ENCTYPE_ARCFOUR_HMAC_MD5_56(24),
+ KRB5_ENCTYPE_ENCTYPE_PK_CROSS(48),
+ KRB5_ENCTYPE_ARCFOUR_MD4(-128),
+ KRB5_ENCTYPE_ARCFOUR_HMAC_OLD(-133),
+ KRB5_ENCTYPE_ARCFOUR_HMAC_OLD_EXP(-135),
+ KRB5_ENCTYPE_DES_CBC_NONE(-4096),
+ KRB5_ENCTYPE_DES3_CBC_NONE(-4097),
+ KRB5_ENCTYPE_DES_CFB64_NONE(-4098),
+ KRB5_ENCTYPE_DES_PCBC_NONE(-4099),
+ KRB5_ENCTYPE_DIGEST_MD5_NONE(-4100),
+ KRB5_ENCTYPE_CRAM_MD5_NONE(-4101)
}
*/
typedef enum ENCTYPE {
- ETYPE_NULL = 0,
- ETYPE_DES_CBC_CRC = 1,
- ETYPE_DES_CBC_MD4 = 2,
- ETYPE_DES_CBC_MD5 = 3,
- ETYPE_DES3_CBC_MD5 = 5,
- ETYPE_OLD_DES3_CBC_SHA1 = 7,
- ETYPE_SIGN_DSA_GENERATE = 8,
- ETYPE_ENCRYPT_RSA_PRIV = 9,
- ETYPE_ENCRYPT_RSA_PUB = 10,
- ETYPE_DES3_CBC_SHA1 = 16,
- ETYPE_AES128_CTS_HMAC_SHA1_96 = 17,
- ETYPE_AES256_CTS_HMAC_SHA1_96 = 18,
- ETYPE_ARCFOUR_HMAC_MD5 = 23,
- ETYPE_ARCFOUR_HMAC_MD5_56 = 24,
- ETYPE_ENCTYPE_PK_CROSS = 48,
- ETYPE_ARCFOUR_MD4 = -128,
- ETYPE_ARCFOUR_HMAC_OLD = -133,
- ETYPE_ARCFOUR_HMAC_OLD_EXP = -135,
- ETYPE_DES_CBC_NONE = -4096,
- ETYPE_DES3_CBC_NONE = -4097,
- ETYPE_DES_CFB64_NONE = -4098,
- ETYPE_DES_PCBC_NONE = -4099,
- ETYPE_DIGEST_MD5_NONE = -4100,
- ETYPE_CRAM_MD5_NONE = -4101
+ KRB5_ENCTYPE_NULL = 0,
+ KRB5_ENCTYPE_DES_CBC_CRC = 1,
+ KRB5_ENCTYPE_DES_CBC_MD4 = 2,
+ KRB5_ENCTYPE_DES_CBC_MD5 = 3,
+ KRB5_ENCTYPE_DES3_CBC_MD5 = 5,
+ KRB5_ENCTYPE_OLD_DES3_CBC_SHA1 = 7,
+ KRB5_ENCTYPE_SIGN_DSA_GENERATE = 8,
+ KRB5_ENCTYPE_ENCRYPT_RSA_PRIV = 9,
+ KRB5_ENCTYPE_ENCRYPT_RSA_PUB = 10,
+ KRB5_ENCTYPE_DES3_CBC_SHA1 = 16,
+ KRB5_ENCTYPE_AES128_CTS_HMAC_SHA1_96 = 17,
+ KRB5_ENCTYPE_AES256_CTS_HMAC_SHA1_96 = 18,
+ KRB5_ENCTYPE_AES128_CTS_HMAC_SHA256_128 = 19,
+ KRB5_ENCTYPE_AES256_CTS_HMAC_SHA384_192 = 20,
+ KRB5_ENCTYPE_ARCFOUR_HMAC_MD5 = 23,
+ KRB5_ENCTYPE_ARCFOUR_HMAC_MD5_56 = 24,
+ KRB5_ENCTYPE_ENCTYPE_PK_CROSS = 48,
+ KRB5_ENCTYPE_ARCFOUR_MD4 = -128,
+ KRB5_ENCTYPE_ARCFOUR_HMAC_OLD = -133,
+ KRB5_ENCTYPE_ARCFOUR_HMAC_OLD_EXP = -135,
+ KRB5_ENCTYPE_DES_CBC_NONE = -4096,
+ KRB5_ENCTYPE_DES3_CBC_NONE = -4097,
+ KRB5_ENCTYPE_DES_CFB64_NONE = -4098,
+ KRB5_ENCTYPE_DES_PCBC_NONE = -4099,
+ KRB5_ENCTYPE_DIGEST_MD5_NONE = -4100,
+ KRB5_ENCTYPE_CRAM_MD5_NONE = -4101
} ENCTYPE;
-int decode_ENCTYPE(const unsigned char *, size_t, ENCTYPE *, size_t *);
-int encode_ENCTYPE(unsigned char *, size_t, const ENCTYPE *, size_t *);
-size_t length_ENCTYPE(const ENCTYPE *);
-int copy_ENCTYPE (const ENCTYPE *, ENCTYPE *);
-void free_ENCTYPE (ENCTYPE *);
+ASN1EXP int ASN1CALL decode_ENCTYPE(const unsigned char *, size_t, ENCTYPE *, size_t *);
+ASN1EXP int ASN1CALL encode_ENCTYPE(unsigned char *, size_t, const ENCTYPE *, size_t *);
+ASN1EXP size_t ASN1CALL length_ENCTYPE(const ENCTYPE *);
+ASN1EXP int ASN1CALL copy_ENCTYPE (const ENCTYPE *, ENCTYPE *);
+ASN1EXP void ASN1CALL free_ENCTYPE (ENCTYPE *);
/*
-krb5uint32 ::= INTEGER (0..-1)
+krb5uint32 ::= INTEGER (0..4294967295)
*/
typedef unsigned int krb5uint32;
-int decode_krb5uint32(const unsigned char *, size_t, krb5uint32 *, size_t *);
-int encode_krb5uint32(unsigned char *, size_t, const krb5uint32 *, size_t *);
-size_t length_krb5uint32(const krb5uint32 *);
-int copy_krb5uint32 (const krb5uint32 *, krb5uint32 *);
-void free_krb5uint32 (krb5uint32 *);
-
-
/*
krb5int32 ::= INTEGER (-2147483648..2147483647)
*/
typedef int krb5int32;
-int decode_krb5int32(const unsigned char *, size_t, krb5int32 *, size_t *);
-int encode_krb5int32(unsigned char *, size_t, const krb5int32 *, size_t *);
-size_t length_krb5int32(const krb5int32 *);
-int copy_krb5int32 (const krb5int32 *, krb5int32 *);
-void free_krb5int32 (krb5int32 *);
-
-
/*
KerberosString ::= GeneralString
*/
typedef heim_general_string KerberosString;
-int decode_KerberosString(const unsigned char *, size_t, KerberosString *, size_t *);
-int encode_KerberosString(unsigned char *, size_t, const KerberosString *, size_t *);
-size_t length_KerberosString(const KerberosString *);
-int copy_KerberosString (const KerberosString *, KerberosString *);
-void free_KerberosString (KerberosString *);
+ASN1EXP int ASN1CALL decode_KerberosString(const unsigned char *, size_t, KerberosString *, size_t *);
+ASN1EXP int ASN1CALL encode_KerberosString(unsigned char *, size_t, const KerberosString *, size_t *);
+ASN1EXP size_t ASN1CALL length_KerberosString(const KerberosString *);
+ASN1EXP int ASN1CALL copy_KerberosString (const KerberosString *, KerberosString *);
+ASN1EXP void ASN1CALL free_KerberosString (KerberosString *);
/*
typedef heim_general_string Realm;
-int decode_Realm(const unsigned char *, size_t, Realm *, size_t *);
-int encode_Realm(unsigned char *, size_t, const Realm *, size_t *);
-size_t length_Realm(const Realm *);
-int copy_Realm (const Realm *, Realm *);
-void free_Realm (Realm *);
+ASN1EXP int ASN1CALL decode_Realm(const unsigned char *, size_t, Realm *, size_t *);
+ASN1EXP int ASN1CALL encode_Realm(unsigned char *, size_t, const Realm *, size_t *);
+ASN1EXP size_t ASN1CALL length_Realm(const Realm *);
+ASN1EXP int ASN1CALL copy_Realm (const Realm *, Realm *);
+ASN1EXP void ASN1CALL free_Realm (Realm *);
/*
} name_string;
} PrincipalName;
-int decode_PrincipalName(const unsigned char *, size_t, PrincipalName *, size_t *);
-int encode_PrincipalName(unsigned char *, size_t, const PrincipalName *, size_t *);
-size_t length_PrincipalName(const PrincipalName *);
-int copy_PrincipalName (const PrincipalName *, PrincipalName *);
-void free_PrincipalName (PrincipalName *);
+ASN1EXP int ASN1CALL decode_PrincipalName(const unsigned char *, size_t, PrincipalName *, size_t *);
+ASN1EXP int ASN1CALL encode_PrincipalName(unsigned char *, size_t, const PrincipalName *, size_t *);
+ASN1EXP size_t ASN1CALL length_PrincipalName(const PrincipalName *);
+ASN1EXP int ASN1CALL copy_PrincipalName (const PrincipalName *, PrincipalName *);
+ASN1EXP void ASN1CALL free_PrincipalName (PrincipalName *);
/*
Realm realm;
} Principal;
-int decode_Principal(const unsigned char *, size_t, Principal *, size_t *);
-int encode_Principal(unsigned char *, size_t, const Principal *, size_t *);
-size_t length_Principal(const Principal *);
-int copy_Principal (const Principal *, Principal *);
-void free_Principal (Principal *);
+ASN1EXP int ASN1CALL decode_Principal(const unsigned char *, size_t, Principal *, size_t *);
+ASN1EXP int ASN1CALL encode_Principal(unsigned char *, size_t, const Principal *, size_t *);
+ASN1EXP size_t ASN1CALL length_Principal(const Principal *);
+ASN1EXP int ASN1CALL copy_Principal (const Principal *, Principal *);
+ASN1EXP void ASN1CALL free_Principal (Principal *);
/*
Principal *val;
} Principals;
-int add_Principals (Principals *, const Principal *);
-int remove_Principals (Principals *, unsigned int);
-int decode_Principals(const unsigned char *, size_t, Principals *, size_t *);
-int encode_Principals(unsigned char *, size_t, const Principals *, size_t *);
-size_t length_Principals(const Principals *);
-int copy_Principals (const Principals *, Principals *);
-void free_Principals (Principals *);
+ASN1EXP int ASN1CALL add_Principals (Principals *, const Principal *);
+ASN1EXP int ASN1CALL remove_Principals (Principals *, unsigned int);
+ASN1EXP int ASN1CALL decode_Principals(const unsigned char *, size_t, Principals *, size_t *);
+ASN1EXP int ASN1CALL encode_Principals(unsigned char *, size_t, const Principals *, size_t *);
+ASN1EXP size_t ASN1CALL length_Principals(const Principals *);
+ASN1EXP int ASN1CALL copy_Principals (const Principals *, Principals *);
+ASN1EXP void ASN1CALL free_Principals (Principals *);
/*
heim_octet_string address;
} HostAddress;
-int decode_HostAddress(const unsigned char *, size_t, HostAddress *, size_t *);
-int encode_HostAddress(unsigned char *, size_t, const HostAddress *, size_t *);
-size_t length_HostAddress(const HostAddress *);
-int copy_HostAddress (const HostAddress *, HostAddress *);
-void free_HostAddress (HostAddress *);
+ASN1EXP int ASN1CALL decode_HostAddress(const unsigned char *, size_t, HostAddress *, size_t *);
+ASN1EXP int ASN1CALL encode_HostAddress(unsigned char *, size_t, const HostAddress *, size_t *);
+ASN1EXP size_t ASN1CALL length_HostAddress(const HostAddress *);
+ASN1EXP int ASN1CALL copy_HostAddress (const HostAddress *, HostAddress *);
+ASN1EXP void ASN1CALL free_HostAddress (HostAddress *);
/*
HostAddress *val;
} HostAddresses;
-int decode_HostAddresses(const unsigned char *, size_t, HostAddresses *, size_t *);
-int encode_HostAddresses(unsigned char *, size_t, const HostAddresses *, size_t *);
-size_t length_HostAddresses(const HostAddresses *);
-int copy_HostAddresses (const HostAddresses *, HostAddresses *);
-void free_HostAddresses (HostAddresses *);
+ASN1EXP int ASN1CALL decode_HostAddresses(const unsigned char *, size_t, HostAddresses *, size_t *);
+ASN1EXP int ASN1CALL encode_HostAddresses(unsigned char *, size_t, const HostAddresses *, size_t *);
+ASN1EXP size_t ASN1CALL length_HostAddresses(const HostAddresses *);
+ASN1EXP int ASN1CALL copy_HostAddresses (const HostAddresses *, HostAddresses *);
+ASN1EXP void ASN1CALL free_HostAddresses (HostAddresses *);
/*
typedef time_t KerberosTime;
-int decode_KerberosTime(const unsigned char *, size_t, KerberosTime *, size_t *);
-int encode_KerberosTime(unsigned char *, size_t, const KerberosTime *, size_t *);
-size_t length_KerberosTime(const KerberosTime *);
-int copy_KerberosTime (const KerberosTime *, KerberosTime *);
-void free_KerberosTime (KerberosTime *);
+ASN1EXP int ASN1CALL decode_KerberosTime(const unsigned char *, size_t, KerberosTime *, size_t *);
+ASN1EXP int ASN1CALL encode_KerberosTime(unsigned char *, size_t, const KerberosTime *, size_t *);
+ASN1EXP size_t ASN1CALL length_KerberosTime(const KerberosTime *);
+ASN1EXP int ASN1CALL copy_KerberosTime (const KerberosTime *, KerberosTime *);
+ASN1EXP void ASN1CALL free_KerberosTime (KerberosTime *);
/*
heim_octet_string ad_data;
} AuthorizationDataElement;
-int decode_AuthorizationDataElement(const unsigned char *, size_t, AuthorizationDataElement *, size_t *);
-int encode_AuthorizationDataElement(unsigned char *, size_t, const AuthorizationDataElement *, size_t *);
-size_t length_AuthorizationDataElement(const AuthorizationDataElement *);
-int copy_AuthorizationDataElement (const AuthorizationDataElement *, AuthorizationDataElement *);
-void free_AuthorizationDataElement (AuthorizationDataElement *);
+ASN1EXP int ASN1CALL decode_AuthorizationDataElement(const unsigned char *, size_t, AuthorizationDataElement *, size_t *);
+ASN1EXP int ASN1CALL encode_AuthorizationDataElement(unsigned char *, size_t, const AuthorizationDataElement *, size_t *);
+ASN1EXP size_t ASN1CALL length_AuthorizationDataElement(const AuthorizationDataElement *);
+ASN1EXP int ASN1CALL copy_AuthorizationDataElement (const AuthorizationDataElement *, AuthorizationDataElement *);
+ASN1EXP void ASN1CALL free_AuthorizationDataElement (AuthorizationDataElement *);
/*
AuthorizationDataElement *val;
} AuthorizationData;
-int add_AuthorizationData (AuthorizationData *, const AuthorizationDataElement *);
-int remove_AuthorizationData (AuthorizationData *, unsigned int);
-int decode_AuthorizationData(const unsigned char *, size_t, AuthorizationData *, size_t *);
-int encode_AuthorizationData(unsigned char *, size_t, const AuthorizationData *, size_t *);
-size_t length_AuthorizationData(const AuthorizationData *);
-int copy_AuthorizationData (const AuthorizationData *, AuthorizationData *);
-void free_AuthorizationData (AuthorizationData *);
+ASN1EXP int ASN1CALL add_AuthorizationData (AuthorizationData *, const AuthorizationDataElement *);
+ASN1EXP int ASN1CALL remove_AuthorizationData (AuthorizationData *, unsigned int);
+ASN1EXP int ASN1CALL decode_AuthorizationData(const unsigned char *, size_t, AuthorizationData *, size_t *);
+ASN1EXP int ASN1CALL encode_AuthorizationData(unsigned char *, size_t, const AuthorizationData *, size_t *);
+ASN1EXP size_t ASN1CALL length_AuthorizationData(const AuthorizationData *);
+ASN1EXP int ASN1CALL copy_AuthorizationData (const AuthorizationData *, AuthorizationData *);
+ASN1EXP void ASN1CALL free_AuthorizationData (AuthorizationData *);
/*
unsigned APOptions2int(APOptions);
APOptions int2APOptions(unsigned);
-int decode_APOptions(const unsigned char *, size_t, APOptions *, size_t *);
-int encode_APOptions(unsigned char *, size_t, const APOptions *, size_t *);
-size_t length_APOptions(const APOptions *);
-int copy_APOptions (const APOptions *, APOptions *);
-void free_APOptions (APOptions *);
-
-
/*
TicketFlags ::= BIT STRING {
reserved(0),
hw-authent(11),
transited-policy-checked(12),
ok-as-delegate(13),
- anonymous(14)
+ enc-pa-rep(15),
+ anonymous(16)
}
*/
unsigned int hw_authent:1;
unsigned int transited_policy_checked:1;
unsigned int ok_as_delegate:1;
+ unsigned int _unused14:1;
+ unsigned int enc_pa_rep:1;
unsigned int anonymous:1;
- unsigned int _unused15:1;
- unsigned int _unused16:1;
unsigned int _unused17:1;
unsigned int _unused18:1;
unsigned int _unused19:1;
unsigned TicketFlags2int(TicketFlags);
TicketFlags int2TicketFlags(unsigned);
-int decode_TicketFlags(const unsigned char *, size_t, TicketFlags *, size_t *);
-int encode_TicketFlags(unsigned char *, size_t, const TicketFlags *, size_t *);
-size_t length_TicketFlags(const TicketFlags *);
-int copy_TicketFlags (const TicketFlags *, TicketFlags *);
-void free_TicketFlags (TicketFlags *);
+ASN1EXP int ASN1CALL decode_TicketFlags(const unsigned char *, size_t, TicketFlags *, size_t *);
+ASN1EXP int ASN1CALL encode_TicketFlags(unsigned char *, size_t, const TicketFlags *, size_t *);
+ASN1EXP size_t ASN1CALL length_TicketFlags(const TicketFlags *);
+ASN1EXP int ASN1CALL copy_TicketFlags (const TicketFlags *, TicketFlags *);
+ASN1EXP void ASN1CALL free_TicketFlags (TicketFlags *);
/*
allow-postdate(5),
postdated(6),
renewable(8),
- request-anonymous(14),
+ cname-in-addl-tkt(14),
canonicalize(15),
- constrained-delegation(16),
+ request-anonymous(16),
disable-transited-check(26),
renewable-ok(27),
enc-tkt-in-skey(28),
unsigned int _unused11:1;
unsigned int _unused12:1;
unsigned int _unused13:1;
- unsigned int request_anonymous:1;
+ unsigned int cname_in_addl_tkt:1;
unsigned int canonicalize:1;
- unsigned int constrained_delegation:1;
+ unsigned int request_anonymous:1;
unsigned int _unused17:1;
unsigned int _unused18:1;
unsigned int _unused19:1;
unsigned KDCOptions2int(KDCOptions);
KDCOptions int2KDCOptions(unsigned);
-int decode_KDCOptions(const unsigned char *, size_t, KDCOptions *, size_t *);
-int encode_KDCOptions(unsigned char *, size_t, const KDCOptions *, size_t *);
-size_t length_KDCOptions(const KDCOptions *);
-int copy_KDCOptions (const KDCOptions *, KDCOptions *);
-void free_KDCOptions (KDCOptions *);
+ASN1EXP int ASN1CALL decode_KDCOptions(const unsigned char *, size_t, KDCOptions *, size_t *);
+ASN1EXP int ASN1CALL encode_KDCOptions(unsigned char *, size_t, const KDCOptions *, size_t *);
+ASN1EXP size_t ASN1CALL length_KDCOptions(const KDCOptions *);
+ASN1EXP int ASN1CALL copy_KDCOptions (const KDCOptions *, KDCOptions *);
+ASN1EXP void ASN1CALL free_KDCOptions (KDCOptions *);
/*
LR_ACCT_EXPTIME = 7
} LR_TYPE;
-int decode_LR_TYPE(const unsigned char *, size_t, LR_TYPE *, size_t *);
-int encode_LR_TYPE(unsigned char *, size_t, const LR_TYPE *, size_t *);
-size_t length_LR_TYPE(const LR_TYPE *);
-int copy_LR_TYPE (const LR_TYPE *, LR_TYPE *);
-void free_LR_TYPE (LR_TYPE *);
+ASN1EXP int ASN1CALL decode_LR_TYPE(const unsigned char *, size_t, LR_TYPE *, size_t *);
+ASN1EXP int ASN1CALL encode_LR_TYPE(unsigned char *, size_t, const LR_TYPE *, size_t *);
+ASN1EXP size_t ASN1CALL length_LR_TYPE(const LR_TYPE *);
+ASN1EXP int ASN1CALL copy_LR_TYPE (const LR_TYPE *, LR_TYPE *);
+ASN1EXP void ASN1CALL free_LR_TYPE (LR_TYPE *);
/*
} *val;
} LastReq;
-int decode_LastReq(const unsigned char *, size_t, LastReq *, size_t *);
-int encode_LastReq(unsigned char *, size_t, const LastReq *, size_t *);
-size_t length_LastReq(const LastReq *);
-int copy_LastReq (const LastReq *, LastReq *);
-void free_LastReq (LastReq *);
+ASN1EXP int ASN1CALL decode_LastReq(const unsigned char *, size_t, LastReq *, size_t *);
+ASN1EXP int ASN1CALL encode_LastReq(unsigned char *, size_t, const LastReq *, size_t *);
+ASN1EXP size_t ASN1CALL length_LastReq(const LastReq *);
+ASN1EXP int ASN1CALL copy_LastReq (const LastReq *, LastReq *);
+ASN1EXP void ASN1CALL free_LastReq (LastReq *);
/*
heim_octet_string cipher;
} EncryptedData;
-int decode_EncryptedData(const unsigned char *, size_t, EncryptedData *, size_t *);
-int encode_EncryptedData(unsigned char *, size_t, const EncryptedData *, size_t *);
-size_t length_EncryptedData(const EncryptedData *);
-int copy_EncryptedData (const EncryptedData *, EncryptedData *);
-void free_EncryptedData (EncryptedData *);
+ASN1EXP int ASN1CALL decode_EncryptedData(const unsigned char *, size_t, EncryptedData *, size_t *);
+ASN1EXP int ASN1CALL encode_EncryptedData(unsigned char *, size_t, const EncryptedData *, size_t *);
+ASN1EXP size_t ASN1CALL length_EncryptedData(const EncryptedData *);
+ASN1EXP int ASN1CALL copy_EncryptedData (const EncryptedData *, EncryptedData *);
+ASN1EXP void ASN1CALL free_EncryptedData (EncryptedData *);
/*
heim_octet_string keyvalue;
} EncryptionKey;
-int decode_EncryptionKey(const unsigned char *, size_t, EncryptionKey *, size_t *);
-int encode_EncryptionKey(unsigned char *, size_t, const EncryptionKey *, size_t *);
-size_t length_EncryptionKey(const EncryptionKey *);
-int copy_EncryptionKey (const EncryptionKey *, EncryptionKey *);
-void free_EncryptionKey (EncryptionKey *);
+ASN1EXP int ASN1CALL decode_EncryptionKey(const unsigned char *, size_t, EncryptionKey *, size_t *);
+ASN1EXP int ASN1CALL encode_EncryptionKey(unsigned char *, size_t, const EncryptionKey *, size_t *);
+ASN1EXP size_t ASN1CALL length_EncryptionKey(const EncryptionKey *);
+ASN1EXP int ASN1CALL copy_EncryptionKey (const EncryptionKey *, EncryptionKey *);
+ASN1EXP void ASN1CALL free_EncryptionKey (EncryptionKey *);
/*
heim_octet_string contents;
} TransitedEncoding;
-int decode_TransitedEncoding(const unsigned char *, size_t, TransitedEncoding *, size_t *);
-int encode_TransitedEncoding(unsigned char *, size_t, const TransitedEncoding *, size_t *);
-size_t length_TransitedEncoding(const TransitedEncoding *);
-int copy_TransitedEncoding (const TransitedEncoding *, TransitedEncoding *);
-void free_TransitedEncoding (TransitedEncoding *);
+ASN1EXP int ASN1CALL decode_TransitedEncoding(const unsigned char *, size_t, TransitedEncoding *, size_t *);
+ASN1EXP int ASN1CALL encode_TransitedEncoding(unsigned char *, size_t, const TransitedEncoding *, size_t *);
+ASN1EXP size_t ASN1CALL length_TransitedEncoding(const TransitedEncoding *);
+ASN1EXP int ASN1CALL copy_TransitedEncoding (const TransitedEncoding *, TransitedEncoding *);
+ASN1EXP void ASN1CALL free_TransitedEncoding (TransitedEncoding *);
/*
EncryptedData enc_part;
} Ticket;
-int decode_Ticket(const unsigned char *, size_t, Ticket *, size_t *);
-int encode_Ticket(unsigned char *, size_t, const Ticket *, size_t *);
-size_t length_Ticket(const Ticket *);
-int copy_Ticket (const Ticket *, Ticket *);
-void free_Ticket (Ticket *);
+ASN1EXP int ASN1CALL decode_Ticket(const unsigned char *, size_t, Ticket *, size_t *);
+ASN1EXP int ASN1CALL encode_Ticket(unsigned char *, size_t, const Ticket *, size_t *);
+ASN1EXP size_t ASN1CALL length_Ticket(const Ticket *);
+ASN1EXP int ASN1CALL copy_Ticket (const Ticket *, Ticket *);
+ASN1EXP void ASN1CALL free_Ticket (Ticket *);
/*
AuthorizationData *authorization_data;
} EncTicketPart;
-int decode_EncTicketPart(const unsigned char *, size_t, EncTicketPart *, size_t *);
-int encode_EncTicketPart(unsigned char *, size_t, const EncTicketPart *, size_t *);
-size_t length_EncTicketPart(const EncTicketPart *);
-int copy_EncTicketPart (const EncTicketPart *, EncTicketPart *);
-void free_EncTicketPart (EncTicketPart *);
+ASN1EXP int ASN1CALL decode_EncTicketPart(const unsigned char *, size_t, EncTicketPart *, size_t *);
+ASN1EXP int ASN1CALL encode_EncTicketPart(unsigned char *, size_t, const EncTicketPart *, size_t *);
+ASN1EXP size_t ASN1CALL length_EncTicketPart(const EncTicketPart *);
+ASN1EXP int ASN1CALL copy_EncTicketPart (const EncTicketPart *, EncTicketPart *);
+ASN1EXP void ASN1CALL free_EncTicketPart (EncTicketPart *);
/*
heim_octet_string checksum;
} Checksum;
-int decode_Checksum(const unsigned char *, size_t, Checksum *, size_t *);
-int encode_Checksum(unsigned char *, size_t, const Checksum *, size_t *);
-size_t length_Checksum(const Checksum *);
-int copy_Checksum (const Checksum *, Checksum *);
-void free_Checksum (Checksum *);
+ASN1EXP int ASN1CALL decode_Checksum(const unsigned char *, size_t, Checksum *, size_t *);
+ASN1EXP int ASN1CALL encode_Checksum(unsigned char *, size_t, const Checksum *, size_t *);
+ASN1EXP size_t ASN1CALL length_Checksum(const Checksum *);
+ASN1EXP int ASN1CALL copy_Checksum (const Checksum *, Checksum *);
+ASN1EXP void ASN1CALL free_Checksum (Checksum *);
/*
AuthorizationData *authorization_data;
} Authenticator;
-int decode_Authenticator(const unsigned char *, size_t, Authenticator *, size_t *);
-int encode_Authenticator(unsigned char *, size_t, const Authenticator *, size_t *);
-size_t length_Authenticator(const Authenticator *);
-int copy_Authenticator (const Authenticator *, Authenticator *);
-void free_Authenticator (Authenticator *);
+ASN1EXP int ASN1CALL decode_Authenticator(const unsigned char *, size_t, Authenticator *, size_t *);
+ASN1EXP int ASN1CALL encode_Authenticator(unsigned char *, size_t, const Authenticator *, size_t *);
+ASN1EXP size_t ASN1CALL length_Authenticator(const Authenticator *);
+ASN1EXP int ASN1CALL copy_Authenticator (const Authenticator *, Authenticator *);
+ASN1EXP void ASN1CALL free_Authenticator (Authenticator *);
/*
heim_octet_string padata_value;
} PA_DATA;
-int decode_PA_DATA(const unsigned char *, size_t, PA_DATA *, size_t *);
-int encode_PA_DATA(unsigned char *, size_t, const PA_DATA *, size_t *);
-size_t length_PA_DATA(const PA_DATA *);
-int copy_PA_DATA (const PA_DATA *, PA_DATA *);
-void free_PA_DATA (PA_DATA *);
+ASN1EXP int ASN1CALL decode_PA_DATA(const unsigned char *, size_t, PA_DATA *, size_t *);
+ASN1EXP int ASN1CALL encode_PA_DATA(unsigned char *, size_t, const PA_DATA *, size_t *);
+ASN1EXP size_t ASN1CALL length_PA_DATA(const PA_DATA *);
+ASN1EXP int ASN1CALL copy_PA_DATA (const PA_DATA *, PA_DATA *);
+ASN1EXP void ASN1CALL free_PA_DATA (PA_DATA *);
/*
krb5int32 *salttype;
} ETYPE_INFO_ENTRY;
-int decode_ETYPE_INFO_ENTRY(const unsigned char *, size_t, ETYPE_INFO_ENTRY *, size_t *);
-int encode_ETYPE_INFO_ENTRY(unsigned char *, size_t, const ETYPE_INFO_ENTRY *, size_t *);
-size_t length_ETYPE_INFO_ENTRY(const ETYPE_INFO_ENTRY *);
-int copy_ETYPE_INFO_ENTRY (const ETYPE_INFO_ENTRY *, ETYPE_INFO_ENTRY *);
-void free_ETYPE_INFO_ENTRY (ETYPE_INFO_ENTRY *);
+ASN1EXP int ASN1CALL decode_ETYPE_INFO_ENTRY(const unsigned char *, size_t, ETYPE_INFO_ENTRY *, size_t *);
+ASN1EXP int ASN1CALL encode_ETYPE_INFO_ENTRY(unsigned char *, size_t, const ETYPE_INFO_ENTRY *, size_t *);
+ASN1EXP size_t ASN1CALL length_ETYPE_INFO_ENTRY(const ETYPE_INFO_ENTRY *);
+ASN1EXP int ASN1CALL copy_ETYPE_INFO_ENTRY (const ETYPE_INFO_ENTRY *, ETYPE_INFO_ENTRY *);
+ASN1EXP void ASN1CALL free_ETYPE_INFO_ENTRY (ETYPE_INFO_ENTRY *);
/*
ETYPE_INFO_ENTRY *val;
} ETYPE_INFO;
-int add_ETYPE_INFO (ETYPE_INFO *, const ETYPE_INFO_ENTRY *);
-int remove_ETYPE_INFO (ETYPE_INFO *, unsigned int);
-int decode_ETYPE_INFO(const unsigned char *, size_t, ETYPE_INFO *, size_t *);
-int encode_ETYPE_INFO(unsigned char *, size_t, const ETYPE_INFO *, size_t *);
-size_t length_ETYPE_INFO(const ETYPE_INFO *);
-int copy_ETYPE_INFO (const ETYPE_INFO *, ETYPE_INFO *);
-void free_ETYPE_INFO (ETYPE_INFO *);
+ASN1EXP int ASN1CALL add_ETYPE_INFO (ETYPE_INFO *, const ETYPE_INFO_ENTRY *);
+ASN1EXP int ASN1CALL remove_ETYPE_INFO (ETYPE_INFO *, unsigned int);
+ASN1EXP int ASN1CALL decode_ETYPE_INFO(const unsigned char *, size_t, ETYPE_INFO *, size_t *);
+ASN1EXP int ASN1CALL encode_ETYPE_INFO(unsigned char *, size_t, const ETYPE_INFO *, size_t *);
+ASN1EXP size_t ASN1CALL length_ETYPE_INFO(const ETYPE_INFO *);
+ASN1EXP int ASN1CALL copy_ETYPE_INFO (const ETYPE_INFO *, ETYPE_INFO *);
+ASN1EXP void ASN1CALL free_ETYPE_INFO (ETYPE_INFO *);
/*
heim_octet_string *s2kparams;
} ETYPE_INFO2_ENTRY;
-int decode_ETYPE_INFO2_ENTRY(const unsigned char *, size_t, ETYPE_INFO2_ENTRY *, size_t *);
-int encode_ETYPE_INFO2_ENTRY(unsigned char *, size_t, const ETYPE_INFO2_ENTRY *, size_t *);
-size_t length_ETYPE_INFO2_ENTRY(const ETYPE_INFO2_ENTRY *);
-int copy_ETYPE_INFO2_ENTRY (const ETYPE_INFO2_ENTRY *, ETYPE_INFO2_ENTRY *);
-void free_ETYPE_INFO2_ENTRY (ETYPE_INFO2_ENTRY *);
+ASN1EXP int ASN1CALL decode_ETYPE_INFO2_ENTRY(const unsigned char *, size_t, ETYPE_INFO2_ENTRY *, size_t *);
+ASN1EXP int ASN1CALL encode_ETYPE_INFO2_ENTRY(unsigned char *, size_t, const ETYPE_INFO2_ENTRY *, size_t *);
+ASN1EXP size_t ASN1CALL length_ETYPE_INFO2_ENTRY(const ETYPE_INFO2_ENTRY *);
+ASN1EXP int ASN1CALL copy_ETYPE_INFO2_ENTRY (const ETYPE_INFO2_ENTRY *, ETYPE_INFO2_ENTRY *);
+ASN1EXP void ASN1CALL free_ETYPE_INFO2_ENTRY (ETYPE_INFO2_ENTRY *);
/*
ETYPE_INFO2_ENTRY *val;
} ETYPE_INFO2;
-int add_ETYPE_INFO2 (ETYPE_INFO2 *, const ETYPE_INFO2_ENTRY *);
-int remove_ETYPE_INFO2 (ETYPE_INFO2 *, unsigned int);
-int decode_ETYPE_INFO2(const unsigned char *, size_t, ETYPE_INFO2 *, size_t *);
-int encode_ETYPE_INFO2(unsigned char *, size_t, const ETYPE_INFO2 *, size_t *);
-size_t length_ETYPE_INFO2(const ETYPE_INFO2 *);
-int copy_ETYPE_INFO2 (const ETYPE_INFO2 *, ETYPE_INFO2 *);
-void free_ETYPE_INFO2 (ETYPE_INFO2 *);
+ASN1EXP int ASN1CALL add_ETYPE_INFO2 (ETYPE_INFO2 *, const ETYPE_INFO2_ENTRY *);
+ASN1EXP int ASN1CALL remove_ETYPE_INFO2 (ETYPE_INFO2 *, unsigned int);
+ASN1EXP int ASN1CALL decode_ETYPE_INFO2(const unsigned char *, size_t, ETYPE_INFO2 *, size_t *);
+ASN1EXP int ASN1CALL encode_ETYPE_INFO2(unsigned char *, size_t, const ETYPE_INFO2 *, size_t *);
+ASN1EXP size_t ASN1CALL length_ETYPE_INFO2(const ETYPE_INFO2 *);
+ASN1EXP int ASN1CALL copy_ETYPE_INFO2 (const ETYPE_INFO2 *, ETYPE_INFO2 *);
+ASN1EXP void ASN1CALL free_ETYPE_INFO2 (ETYPE_INFO2 *);
/*
PA_DATA *val;
} METHOD_DATA;
-int add_METHOD_DATA (METHOD_DATA *, const PA_DATA *);
-int remove_METHOD_DATA (METHOD_DATA *, unsigned int);
-int decode_METHOD_DATA(const unsigned char *, size_t, METHOD_DATA *, size_t *);
-int encode_METHOD_DATA(unsigned char *, size_t, const METHOD_DATA *, size_t *);
-size_t length_METHOD_DATA(const METHOD_DATA *);
-int copy_METHOD_DATA (const METHOD_DATA *, METHOD_DATA *);
-void free_METHOD_DATA (METHOD_DATA *);
+ASN1EXP int ASN1CALL add_METHOD_DATA (METHOD_DATA *, const PA_DATA *);
+ASN1EXP int ASN1CALL remove_METHOD_DATA (METHOD_DATA *, unsigned int);
+ASN1EXP int ASN1CALL decode_METHOD_DATA(const unsigned char *, size_t, METHOD_DATA *, size_t *);
+ASN1EXP int ASN1CALL encode_METHOD_DATA(unsigned char *, size_t, const METHOD_DATA *, size_t *);
+ASN1EXP size_t ASN1CALL length_METHOD_DATA(const METHOD_DATA *);
+ASN1EXP int ASN1CALL copy_METHOD_DATA (const METHOD_DATA *, METHOD_DATA *);
+ASN1EXP void ASN1CALL free_METHOD_DATA (METHOD_DATA *);
/*
heim_octet_string *data_value;
} TypedData;
-int decode_TypedData(const unsigned char *, size_t, TypedData *, size_t *);
-int encode_TypedData(unsigned char *, size_t, const TypedData *, size_t *);
-size_t length_TypedData(const TypedData *);
-int copy_TypedData (const TypedData *, TypedData *);
-void free_TypedData (TypedData *);
+ASN1EXP int ASN1CALL decode_TypedData(const unsigned char *, size_t, TypedData *, size_t *);
+ASN1EXP int ASN1CALL encode_TypedData(unsigned char *, size_t, const TypedData *, size_t *);
+ASN1EXP size_t ASN1CALL length_TypedData(const TypedData *);
+ASN1EXP int ASN1CALL copy_TypedData (const TypedData *, TypedData *);
+ASN1EXP void ASN1CALL free_TypedData (TypedData *);
/*
TypedData *val;
} TYPED_DATA;
-int decode_TYPED_DATA(const unsigned char *, size_t, TYPED_DATA *, size_t *);
-int encode_TYPED_DATA(unsigned char *, size_t, const TYPED_DATA *, size_t *);
-size_t length_TYPED_DATA(const TYPED_DATA *);
-int copy_TYPED_DATA (const TYPED_DATA *, TYPED_DATA *);
-void free_TYPED_DATA (TYPED_DATA *);
-
-
/*
KDC-REQ-BODY ::= SEQUENCE {
kdc-options [0] KDCOptions,
} *additional_tickets;
} KDC_REQ_BODY;
-int decode_KDC_REQ_BODY(const unsigned char *, size_t, KDC_REQ_BODY *, size_t *);
-int encode_KDC_REQ_BODY(unsigned char *, size_t, const KDC_REQ_BODY *, size_t *);
-size_t length_KDC_REQ_BODY(const KDC_REQ_BODY *);
-int copy_KDC_REQ_BODY (const KDC_REQ_BODY *, KDC_REQ_BODY *);
-void free_KDC_REQ_BODY (KDC_REQ_BODY *);
+ASN1EXP int ASN1CALL decode_KDC_REQ_BODY(const unsigned char *, size_t, KDC_REQ_BODY *, size_t *);
+ASN1EXP int ASN1CALL encode_KDC_REQ_BODY(unsigned char *, size_t, const KDC_REQ_BODY *, size_t *);
+ASN1EXP size_t ASN1CALL length_KDC_REQ_BODY(const KDC_REQ_BODY *);
+ASN1EXP int ASN1CALL copy_KDC_REQ_BODY (const KDC_REQ_BODY *, KDC_REQ_BODY *);
+ASN1EXP void ASN1CALL free_KDC_REQ_BODY (KDC_REQ_BODY *);
/*
KDC_REQ_BODY req_body;
} KDC_REQ;
-int decode_KDC_REQ(const unsigned char *, size_t, KDC_REQ *, size_t *);
-int encode_KDC_REQ(unsigned char *, size_t, const KDC_REQ *, size_t *);
-size_t length_KDC_REQ(const KDC_REQ *);
-int copy_KDC_REQ (const KDC_REQ *, KDC_REQ *);
-void free_KDC_REQ (KDC_REQ *);
-
-
/*
AS-REQ ::= [APPLICATION 10] KDC-REQ
*/
typedef KDC_REQ AS_REQ;
-int decode_AS_REQ(const unsigned char *, size_t, AS_REQ *, size_t *);
-int encode_AS_REQ(unsigned char *, size_t, const AS_REQ *, size_t *);
-size_t length_AS_REQ(const AS_REQ *);
-int copy_AS_REQ (const AS_REQ *, AS_REQ *);
-void free_AS_REQ (AS_REQ *);
+ASN1EXP int ASN1CALL decode_AS_REQ(const unsigned char *, size_t, AS_REQ *, size_t *);
+ASN1EXP int ASN1CALL encode_AS_REQ(unsigned char *, size_t, const AS_REQ *, size_t *);
+ASN1EXP size_t ASN1CALL length_AS_REQ(const AS_REQ *);
+ASN1EXP int ASN1CALL copy_AS_REQ (const AS_REQ *, AS_REQ *);
+ASN1EXP void ASN1CALL free_AS_REQ (AS_REQ *);
/*
typedef KDC_REQ TGS_REQ;
-int decode_TGS_REQ(const unsigned char *, size_t, TGS_REQ *, size_t *);
-int encode_TGS_REQ(unsigned char *, size_t, const TGS_REQ *, size_t *);
-size_t length_TGS_REQ(const TGS_REQ *);
-int copy_TGS_REQ (const TGS_REQ *, TGS_REQ *);
-void free_TGS_REQ (TGS_REQ *);
+ASN1EXP int ASN1CALL decode_TGS_REQ(const unsigned char *, size_t, TGS_REQ *, size_t *);
+ASN1EXP int ASN1CALL encode_TGS_REQ(unsigned char *, size_t, const TGS_REQ *, size_t *);
+ASN1EXP size_t ASN1CALL length_TGS_REQ(const TGS_REQ *);
+ASN1EXP int ASN1CALL copy_TGS_REQ (const TGS_REQ *, TGS_REQ *);
+ASN1EXP void ASN1CALL free_TGS_REQ (TGS_REQ *);
/*
krb5int32 *pausec;
} PA_ENC_TS_ENC;
-int decode_PA_ENC_TS_ENC(const unsigned char *, size_t, PA_ENC_TS_ENC *, size_t *);
-int encode_PA_ENC_TS_ENC(unsigned char *, size_t, const PA_ENC_TS_ENC *, size_t *);
-size_t length_PA_ENC_TS_ENC(const PA_ENC_TS_ENC *);
-int copy_PA_ENC_TS_ENC (const PA_ENC_TS_ENC *, PA_ENC_TS_ENC *);
-void free_PA_ENC_TS_ENC (PA_ENC_TS_ENC *);
+ASN1EXP int ASN1CALL decode_PA_ENC_TS_ENC(const unsigned char *, size_t, PA_ENC_TS_ENC *, size_t *);
+ASN1EXP int ASN1CALL encode_PA_ENC_TS_ENC(unsigned char *, size_t, const PA_ENC_TS_ENC *, size_t *);
+ASN1EXP size_t ASN1CALL length_PA_ENC_TS_ENC(const PA_ENC_TS_ENC *);
+ASN1EXP int ASN1CALL copy_PA_ENC_TS_ENC (const PA_ENC_TS_ENC *, PA_ENC_TS_ENC *);
+ASN1EXP void ASN1CALL free_PA_ENC_TS_ENC (PA_ENC_TS_ENC *);
/*
int include_pac;
} PA_PAC_REQUEST;
-int decode_PA_PAC_REQUEST(const unsigned char *, size_t, PA_PAC_REQUEST *, size_t *);
-int encode_PA_PAC_REQUEST(unsigned char *, size_t, const PA_PAC_REQUEST *, size_t *);
-size_t length_PA_PAC_REQUEST(const PA_PAC_REQUEST *);
-int copy_PA_PAC_REQUEST (const PA_PAC_REQUEST *, PA_PAC_REQUEST *);
-void free_PA_PAC_REQUEST (PA_PAC_REQUEST *);
+ASN1EXP int ASN1CALL decode_PA_PAC_REQUEST(const unsigned char *, size_t, PA_PAC_REQUEST *, size_t *);
+ASN1EXP int ASN1CALL encode_PA_PAC_REQUEST(unsigned char *, size_t, const PA_PAC_REQUEST *, size_t *);
+ASN1EXP size_t ASN1CALL length_PA_PAC_REQUEST(const PA_PAC_REQUEST *);
+ASN1EXP int ASN1CALL copy_PA_PAC_REQUEST (const PA_PAC_REQUEST *, PA_PAC_REQUEST *);
+ASN1EXP void ASN1CALL free_PA_PAC_REQUEST (PA_PAC_REQUEST *);
/*
typedef heim_general_string PROV_SRV_LOCATION;
-int decode_PROV_SRV_LOCATION(const unsigned char *, size_t, PROV_SRV_LOCATION *, size_t *);
-int encode_PROV_SRV_LOCATION(unsigned char *, size_t, const PROV_SRV_LOCATION *, size_t *);
-size_t length_PROV_SRV_LOCATION(const PROV_SRV_LOCATION *);
-int copy_PROV_SRV_LOCATION (const PROV_SRV_LOCATION *, PROV_SRV_LOCATION *);
-void free_PROV_SRV_LOCATION (PROV_SRV_LOCATION *);
-
-
/*
KDC-REP ::= SEQUENCE {
pvno [0] krb5int32,
EncryptedData enc_part;
} KDC_REP;
-int decode_KDC_REP(const unsigned char *, size_t, KDC_REP *, size_t *);
-int encode_KDC_REP(unsigned char *, size_t, const KDC_REP *, size_t *);
-size_t length_KDC_REP(const KDC_REP *);
-int copy_KDC_REP (const KDC_REP *, KDC_REP *);
-void free_KDC_REP (KDC_REP *);
+ASN1EXP int ASN1CALL decode_KDC_REP(const unsigned char *, size_t, KDC_REP *, size_t *);
+ASN1EXP int ASN1CALL encode_KDC_REP(unsigned char *, size_t, const KDC_REP *, size_t *);
+ASN1EXP size_t ASN1CALL length_KDC_REP(const KDC_REP *);
+ASN1EXP int ASN1CALL copy_KDC_REP (const KDC_REP *, KDC_REP *);
+ASN1EXP void ASN1CALL free_KDC_REP (KDC_REP *);
/*
typedef KDC_REP AS_REP;
-int decode_AS_REP(const unsigned char *, size_t, AS_REP *, size_t *);
-int encode_AS_REP(unsigned char *, size_t, const AS_REP *, size_t *);
-size_t length_AS_REP(const AS_REP *);
-int copy_AS_REP (const AS_REP *, AS_REP *);
-void free_AS_REP (AS_REP *);
+ASN1EXP int ASN1CALL decode_AS_REP(const unsigned char *, size_t, AS_REP *, size_t *);
+ASN1EXP int ASN1CALL encode_AS_REP(unsigned char *, size_t, const AS_REP *, size_t *);
+ASN1EXP size_t ASN1CALL length_AS_REP(const AS_REP *);
+ASN1EXP int ASN1CALL copy_AS_REP (const AS_REP *, AS_REP *);
+ASN1EXP void ASN1CALL free_AS_REP (AS_REP *);
/*
typedef KDC_REP TGS_REP;
-int decode_TGS_REP(const unsigned char *, size_t, TGS_REP *, size_t *);
-int encode_TGS_REP(unsigned char *, size_t, const TGS_REP *, size_t *);
-size_t length_TGS_REP(const TGS_REP *);
-int copy_TGS_REP (const TGS_REP *, TGS_REP *);
-void free_TGS_REP (TGS_REP *);
+ASN1EXP int ASN1CALL decode_TGS_REP(const unsigned char *, size_t, TGS_REP *, size_t *);
+ASN1EXP int ASN1CALL encode_TGS_REP(unsigned char *, size_t, const TGS_REP *, size_t *);
+ASN1EXP size_t ASN1CALL length_TGS_REP(const TGS_REP *);
+ASN1EXP int ASN1CALL copy_TGS_REP (const TGS_REP *, TGS_REP *);
+ASN1EXP void ASN1CALL free_TGS_REP (TGS_REP *);
/*
METHOD_DATA *encrypted_pa_data;
} EncKDCRepPart;
-int decode_EncKDCRepPart(const unsigned char *, size_t, EncKDCRepPart *, size_t *);
-int encode_EncKDCRepPart(unsigned char *, size_t, const EncKDCRepPart *, size_t *);
-size_t length_EncKDCRepPart(const EncKDCRepPart *);
-int copy_EncKDCRepPart (const EncKDCRepPart *, EncKDCRepPart *);
-void free_EncKDCRepPart (EncKDCRepPart *);
+ASN1EXP int ASN1CALL decode_EncKDCRepPart(const unsigned char *, size_t, EncKDCRepPart *, size_t *);
+ASN1EXP int ASN1CALL encode_EncKDCRepPart(unsigned char *, size_t, const EncKDCRepPart *, size_t *);
+ASN1EXP size_t ASN1CALL length_EncKDCRepPart(const EncKDCRepPart *);
+ASN1EXP int ASN1CALL copy_EncKDCRepPart (const EncKDCRepPart *, EncKDCRepPart *);
+ASN1EXP void ASN1CALL free_EncKDCRepPart (EncKDCRepPart *);
/*
typedef EncKDCRepPart EncASRepPart;
-int decode_EncASRepPart(const unsigned char *, size_t, EncASRepPart *, size_t *);
-int encode_EncASRepPart(unsigned char *, size_t, const EncASRepPart *, size_t *);
-size_t length_EncASRepPart(const EncASRepPart *);
-int copy_EncASRepPart (const EncASRepPart *, EncASRepPart *);
-void free_EncASRepPart (EncASRepPart *);
+ASN1EXP int ASN1CALL decode_EncASRepPart(const unsigned char *, size_t, EncASRepPart *, size_t *);
+ASN1EXP int ASN1CALL encode_EncASRepPart(unsigned char *, size_t, const EncASRepPart *, size_t *);
+ASN1EXP size_t ASN1CALL length_EncASRepPart(const EncASRepPart *);
+ASN1EXP int ASN1CALL copy_EncASRepPart (const EncASRepPart *, EncASRepPart *);
+ASN1EXP void ASN1CALL free_EncASRepPart (EncASRepPart *);
/*
typedef EncKDCRepPart EncTGSRepPart;
-int decode_EncTGSRepPart(const unsigned char *, size_t, EncTGSRepPart *, size_t *);
-int encode_EncTGSRepPart(unsigned char *, size_t, const EncTGSRepPart *, size_t *);
-size_t length_EncTGSRepPart(const EncTGSRepPart *);
-int copy_EncTGSRepPart (const EncTGSRepPart *, EncTGSRepPart *);
-void free_EncTGSRepPart (EncTGSRepPart *);
+ASN1EXP int ASN1CALL decode_EncTGSRepPart(const unsigned char *, size_t, EncTGSRepPart *, size_t *);
+ASN1EXP int ASN1CALL encode_EncTGSRepPart(unsigned char *, size_t, const EncTGSRepPart *, size_t *);
+ASN1EXP size_t ASN1CALL length_EncTGSRepPart(const EncTGSRepPart *);
+ASN1EXP int ASN1CALL copy_EncTGSRepPart (const EncTGSRepPart *, EncTGSRepPart *);
+ASN1EXP void ASN1CALL free_EncTGSRepPart (EncTGSRepPart *);
/*
EncryptedData authenticator;
} AP_REQ;
-int decode_AP_REQ(const unsigned char *, size_t, AP_REQ *, size_t *);
-int encode_AP_REQ(unsigned char *, size_t, const AP_REQ *, size_t *);
-size_t length_AP_REQ(const AP_REQ *);
-int copy_AP_REQ (const AP_REQ *, AP_REQ *);
-void free_AP_REQ (AP_REQ *);
+ASN1EXP int ASN1CALL decode_AP_REQ(const unsigned char *, size_t, AP_REQ *, size_t *);
+ASN1EXP int ASN1CALL encode_AP_REQ(unsigned char *, size_t, const AP_REQ *, size_t *);
+ASN1EXP size_t ASN1CALL length_AP_REQ(const AP_REQ *);
+ASN1EXP int ASN1CALL copy_AP_REQ (const AP_REQ *, AP_REQ *);
+ASN1EXP void ASN1CALL free_AP_REQ (AP_REQ *);
/*
EncryptedData enc_part;
} AP_REP;
-int decode_AP_REP(const unsigned char *, size_t, AP_REP *, size_t *);
-int encode_AP_REP(unsigned char *, size_t, const AP_REP *, size_t *);
-size_t length_AP_REP(const AP_REP *);
-int copy_AP_REP (const AP_REP *, AP_REP *);
-void free_AP_REP (AP_REP *);
+ASN1EXP int ASN1CALL decode_AP_REP(const unsigned char *, size_t, AP_REP *, size_t *);
+ASN1EXP int ASN1CALL encode_AP_REP(unsigned char *, size_t, const AP_REP *, size_t *);
+ASN1EXP size_t ASN1CALL length_AP_REP(const AP_REP *);
+ASN1EXP int ASN1CALL copy_AP_REP (const AP_REP *, AP_REP *);
+ASN1EXP void ASN1CALL free_AP_REP (AP_REP *);
/*
krb5uint32 *seq_number;
} EncAPRepPart;
-int decode_EncAPRepPart(const unsigned char *, size_t, EncAPRepPart *, size_t *);
-int encode_EncAPRepPart(unsigned char *, size_t, const EncAPRepPart *, size_t *);
-size_t length_EncAPRepPart(const EncAPRepPart *);
-int copy_EncAPRepPart (const EncAPRepPart *, EncAPRepPart *);
-void free_EncAPRepPart (EncAPRepPart *);
+ASN1EXP int ASN1CALL decode_EncAPRepPart(const unsigned char *, size_t, EncAPRepPart *, size_t *);
+ASN1EXP int ASN1CALL encode_EncAPRepPart(unsigned char *, size_t, const EncAPRepPart *, size_t *);
+ASN1EXP size_t ASN1CALL length_EncAPRepPart(const EncAPRepPart *);
+ASN1EXP int ASN1CALL copy_EncAPRepPart (const EncAPRepPart *, EncAPRepPart *);
+ASN1EXP void ASN1CALL free_EncAPRepPart (EncAPRepPart *);
/*
HostAddress *r_address;
} KRB_SAFE_BODY;
-int decode_KRB_SAFE_BODY(const unsigned char *, size_t, KRB_SAFE_BODY *, size_t *);
-int encode_KRB_SAFE_BODY(unsigned char *, size_t, const KRB_SAFE_BODY *, size_t *);
-size_t length_KRB_SAFE_BODY(const KRB_SAFE_BODY *);
-int copy_KRB_SAFE_BODY (const KRB_SAFE_BODY *, KRB_SAFE_BODY *);
-void free_KRB_SAFE_BODY (KRB_SAFE_BODY *);
+ASN1EXP int ASN1CALL decode_KRB_SAFE_BODY(const unsigned char *, size_t, KRB_SAFE_BODY *, size_t *);
+ASN1EXP int ASN1CALL encode_KRB_SAFE_BODY(unsigned char *, size_t, const KRB_SAFE_BODY *, size_t *);
+ASN1EXP size_t ASN1CALL length_KRB_SAFE_BODY(const KRB_SAFE_BODY *);
+ASN1EXP int ASN1CALL copy_KRB_SAFE_BODY (const KRB_SAFE_BODY *, KRB_SAFE_BODY *);
+ASN1EXP void ASN1CALL free_KRB_SAFE_BODY (KRB_SAFE_BODY *);
/*
Checksum cksum;
} KRB_SAFE;
-int decode_KRB_SAFE(const unsigned char *, size_t, KRB_SAFE *, size_t *);
-int encode_KRB_SAFE(unsigned char *, size_t, const KRB_SAFE *, size_t *);
-size_t length_KRB_SAFE(const KRB_SAFE *);
-int copy_KRB_SAFE (const KRB_SAFE *, KRB_SAFE *);
-void free_KRB_SAFE (KRB_SAFE *);
+ASN1EXP int ASN1CALL decode_KRB_SAFE(const unsigned char *, size_t, KRB_SAFE *, size_t *);
+ASN1EXP int ASN1CALL encode_KRB_SAFE(unsigned char *, size_t, const KRB_SAFE *, size_t *);
+ASN1EXP size_t ASN1CALL length_KRB_SAFE(const KRB_SAFE *);
+ASN1EXP int ASN1CALL copy_KRB_SAFE (const KRB_SAFE *, KRB_SAFE *);
+ASN1EXP void ASN1CALL free_KRB_SAFE (KRB_SAFE *);
/*
EncryptedData enc_part;
} KRB_PRIV;
-int decode_KRB_PRIV(const unsigned char *, size_t, KRB_PRIV *, size_t *);
-int encode_KRB_PRIV(unsigned char *, size_t, const KRB_PRIV *, size_t *);
-size_t length_KRB_PRIV(const KRB_PRIV *);
-int copy_KRB_PRIV (const KRB_PRIV *, KRB_PRIV *);
-void free_KRB_PRIV (KRB_PRIV *);
+ASN1EXP int ASN1CALL decode_KRB_PRIV(const unsigned char *, size_t, KRB_PRIV *, size_t *);
+ASN1EXP int ASN1CALL encode_KRB_PRIV(unsigned char *, size_t, const KRB_PRIV *, size_t *);
+ASN1EXP size_t ASN1CALL length_KRB_PRIV(const KRB_PRIV *);
+ASN1EXP int ASN1CALL copy_KRB_PRIV (const KRB_PRIV *, KRB_PRIV *);
+ASN1EXP void ASN1CALL free_KRB_PRIV (KRB_PRIV *);
/*
HostAddress *r_address;
} EncKrbPrivPart;
-int decode_EncKrbPrivPart(const unsigned char *, size_t, EncKrbPrivPart *, size_t *);
-int encode_EncKrbPrivPart(unsigned char *, size_t, const EncKrbPrivPart *, size_t *);
-size_t length_EncKrbPrivPart(const EncKrbPrivPart *);
-int copy_EncKrbPrivPart (const EncKrbPrivPart *, EncKrbPrivPart *);
-void free_EncKrbPrivPart (EncKrbPrivPart *);
+ASN1EXP int ASN1CALL decode_EncKrbPrivPart(const unsigned char *, size_t, EncKrbPrivPart *, size_t *);
+ASN1EXP int ASN1CALL encode_EncKrbPrivPart(unsigned char *, size_t, const EncKrbPrivPart *, size_t *);
+ASN1EXP size_t ASN1CALL length_EncKrbPrivPart(const EncKrbPrivPart *);
+ASN1EXP int ASN1CALL copy_EncKrbPrivPart (const EncKrbPrivPart *, EncKrbPrivPart *);
+ASN1EXP void ASN1CALL free_EncKrbPrivPart (EncKrbPrivPart *);
/*
EncryptedData enc_part;
} KRB_CRED;
-int decode_KRB_CRED(const unsigned char *, size_t, KRB_CRED *, size_t *);
-int encode_KRB_CRED(unsigned char *, size_t, const KRB_CRED *, size_t *);
-size_t length_KRB_CRED(const KRB_CRED *);
-int copy_KRB_CRED (const KRB_CRED *, KRB_CRED *);
-void free_KRB_CRED (KRB_CRED *);
+ASN1EXP int ASN1CALL decode_KRB_CRED(const unsigned char *, size_t, KRB_CRED *, size_t *);
+ASN1EXP int ASN1CALL encode_KRB_CRED(unsigned char *, size_t, const KRB_CRED *, size_t *);
+ASN1EXP size_t ASN1CALL length_KRB_CRED(const KRB_CRED *);
+ASN1EXP int ASN1CALL copy_KRB_CRED (const KRB_CRED *, KRB_CRED *);
+ASN1EXP void ASN1CALL free_KRB_CRED (KRB_CRED *);
/*
HostAddresses *caddr;
} KrbCredInfo;
-int decode_KrbCredInfo(const unsigned char *, size_t, KrbCredInfo *, size_t *);
-int encode_KrbCredInfo(unsigned char *, size_t, const KrbCredInfo *, size_t *);
-size_t length_KrbCredInfo(const KrbCredInfo *);
-int copy_KrbCredInfo (const KrbCredInfo *, KrbCredInfo *);
-void free_KrbCredInfo (KrbCredInfo *);
+ASN1EXP int ASN1CALL decode_KrbCredInfo(const unsigned char *, size_t, KrbCredInfo *, size_t *);
+ASN1EXP int ASN1CALL encode_KrbCredInfo(unsigned char *, size_t, const KrbCredInfo *, size_t *);
+ASN1EXP size_t ASN1CALL length_KrbCredInfo(const KrbCredInfo *);
+ASN1EXP int ASN1CALL copy_KrbCredInfo (const KrbCredInfo *, KrbCredInfo *);
+ASN1EXP void ASN1CALL free_KrbCredInfo (KrbCredInfo *);
/*
HostAddress *r_address;
} EncKrbCredPart;
-int decode_EncKrbCredPart(const unsigned char *, size_t, EncKrbCredPart *, size_t *);
-int encode_EncKrbCredPart(unsigned char *, size_t, const EncKrbCredPart *, size_t *);
-size_t length_EncKrbCredPart(const EncKrbCredPart *);
-int copy_EncKrbCredPart (const EncKrbCredPart *, EncKrbCredPart *);
-void free_EncKrbCredPart (EncKrbCredPart *);
+ASN1EXP int ASN1CALL decode_EncKrbCredPart(const unsigned char *, size_t, EncKrbCredPart *, size_t *);
+ASN1EXP int ASN1CALL encode_EncKrbCredPart(unsigned char *, size_t, const EncKrbCredPart *, size_t *);
+ASN1EXP size_t ASN1CALL length_EncKrbCredPart(const EncKrbCredPart *);
+ASN1EXP int ASN1CALL copy_EncKrbCredPart (const EncKrbCredPart *, EncKrbCredPart *);
+ASN1EXP void ASN1CALL free_EncKrbCredPart (EncKrbCredPart *);
/*
heim_octet_string *e_data;
} KRB_ERROR;
-int decode_KRB_ERROR(const unsigned char *, size_t, KRB_ERROR *, size_t *);
-int encode_KRB_ERROR(unsigned char *, size_t, const KRB_ERROR *, size_t *);
-size_t length_KRB_ERROR(const KRB_ERROR *);
-int copy_KRB_ERROR (const KRB_ERROR *, KRB_ERROR *);
-void free_KRB_ERROR (KRB_ERROR *);
+ASN1EXP int ASN1CALL decode_KRB_ERROR(const unsigned char *, size_t, KRB_ERROR *, size_t *);
+ASN1EXP int ASN1CALL encode_KRB_ERROR(unsigned char *, size_t, const KRB_ERROR *, size_t *);
+ASN1EXP size_t ASN1CALL length_KRB_ERROR(const KRB_ERROR *);
+ASN1EXP int ASN1CALL copy_KRB_ERROR (const KRB_ERROR *, KRB_ERROR *);
+ASN1EXP void ASN1CALL free_KRB_ERROR (KRB_ERROR *);
/*
Realm *targrealm;
} ChangePasswdDataMS;
-int decode_ChangePasswdDataMS(const unsigned char *, size_t, ChangePasswdDataMS *, size_t *);
-int encode_ChangePasswdDataMS(unsigned char *, size_t, const ChangePasswdDataMS *, size_t *);
-size_t length_ChangePasswdDataMS(const ChangePasswdDataMS *);
-int copy_ChangePasswdDataMS (const ChangePasswdDataMS *, ChangePasswdDataMS *);
-void free_ChangePasswdDataMS (ChangePasswdDataMS *);
+ASN1EXP int ASN1CALL decode_ChangePasswdDataMS(const unsigned char *, size_t, ChangePasswdDataMS *, size_t *);
+ASN1EXP int ASN1CALL encode_ChangePasswdDataMS(unsigned char *, size_t, const ChangePasswdDataMS *, size_t *);
+ASN1EXP size_t ASN1CALL length_ChangePasswdDataMS(const ChangePasswdDataMS *);
+ASN1EXP int ASN1CALL copy_ChangePasswdDataMS (const ChangePasswdDataMS *, ChangePasswdDataMS *);
+ASN1EXP void ASN1CALL free_ChangePasswdDataMS (ChangePasswdDataMS *);
/*
-EtypeList ::= SEQUENCE OF krb5int32
+EtypeList ::= SEQUENCE OF ENCTYPE
*/
typedef struct EtypeList {
unsigned int len;
- krb5int32 *val;
+ ENCTYPE *val;
} EtypeList;
-int decode_EtypeList(const unsigned char *, size_t, EtypeList *, size_t *);
-int encode_EtypeList(unsigned char *, size_t, const EtypeList *, size_t *);
-size_t length_EtypeList(const EtypeList *);
-int copy_EtypeList (const EtypeList *, EtypeList *);
-void free_EtypeList (EtypeList *);
+ASN1EXP int ASN1CALL decode_EtypeList(const unsigned char *, size_t, EtypeList *, size_t *);
+ASN1EXP int ASN1CALL encode_EtypeList(unsigned char *, size_t, const EtypeList *, size_t *);
+ASN1EXP size_t ASN1CALL length_EtypeList(const EtypeList *);
+ASN1EXP int ASN1CALL copy_EtypeList (const EtypeList *, EtypeList *);
+ASN1EXP void ASN1CALL free_EtypeList (EtypeList *);
enum { krb5_pvno = 5 };
typedef AuthorizationData AD_IF_RELEVANT;
-int decode_AD_IF_RELEVANT(const unsigned char *, size_t, AD_IF_RELEVANT *, size_t *);
-int encode_AD_IF_RELEVANT(unsigned char *, size_t, const AD_IF_RELEVANT *, size_t *);
-size_t length_AD_IF_RELEVANT(const AD_IF_RELEVANT *);
-int copy_AD_IF_RELEVANT (const AD_IF_RELEVANT *, AD_IF_RELEVANT *);
-void free_AD_IF_RELEVANT (AD_IF_RELEVANT *);
+ASN1EXP int ASN1CALL decode_AD_IF_RELEVANT(const unsigned char *, size_t, AD_IF_RELEVANT *, size_t *);
+ASN1EXP int ASN1CALL encode_AD_IF_RELEVANT(unsigned char *, size_t, const AD_IF_RELEVANT *, size_t *);
+ASN1EXP size_t ASN1CALL length_AD_IF_RELEVANT(const AD_IF_RELEVANT *);
+ASN1EXP int ASN1CALL copy_AD_IF_RELEVANT (const AD_IF_RELEVANT *, AD_IF_RELEVANT *);
+ASN1EXP void ASN1CALL free_AD_IF_RELEVANT (AD_IF_RELEVANT *);
/*
AuthorizationData elements;
} AD_KDCIssued;
-int decode_AD_KDCIssued(const unsigned char *, size_t, AD_KDCIssued *, size_t *);
-int encode_AD_KDCIssued(unsigned char *, size_t, const AD_KDCIssued *, size_t *);
-size_t length_AD_KDCIssued(const AD_KDCIssued *);
-int copy_AD_KDCIssued (const AD_KDCIssued *, AD_KDCIssued *);
-void free_AD_KDCIssued (AD_KDCIssued *);
+ASN1EXP int ASN1CALL decode_AD_KDCIssued(const unsigned char *, size_t, AD_KDCIssued *, size_t *);
+ASN1EXP int ASN1CALL encode_AD_KDCIssued(unsigned char *, size_t, const AD_KDCIssued *, size_t *);
+ASN1EXP size_t ASN1CALL length_AD_KDCIssued(const AD_KDCIssued *);
+ASN1EXP int ASN1CALL copy_AD_KDCIssued (const AD_KDCIssued *, AD_KDCIssued *);
+ASN1EXP void ASN1CALL free_AD_KDCIssued (AD_KDCIssued *);
/*
AuthorizationData elements;
} AD_AND_OR;
-int decode_AD_AND_OR(const unsigned char *, size_t, AD_AND_OR *, size_t *);
-int encode_AD_AND_OR(unsigned char *, size_t, const AD_AND_OR *, size_t *);
-size_t length_AD_AND_OR(const AD_AND_OR *);
-int copy_AD_AND_OR (const AD_AND_OR *, AD_AND_OR *);
-void free_AD_AND_OR (AD_AND_OR *);
+ASN1EXP int ASN1CALL decode_AD_AND_OR(const unsigned char *, size_t, AD_AND_OR *, size_t *);
+ASN1EXP int ASN1CALL encode_AD_AND_OR(unsigned char *, size_t, const AD_AND_OR *, size_t *);
+ASN1EXP size_t ASN1CALL length_AD_AND_OR(const AD_AND_OR *);
+ASN1EXP int ASN1CALL copy_AD_AND_OR (const AD_AND_OR *, AD_AND_OR *);
+ASN1EXP void ASN1CALL free_AD_AND_OR (AD_AND_OR *);
/*
typedef AuthorizationData AD_MANDATORY_FOR_KDC;
-int decode_AD_MANDATORY_FOR_KDC(const unsigned char *, size_t, AD_MANDATORY_FOR_KDC *, size_t *);
-int encode_AD_MANDATORY_FOR_KDC(unsigned char *, size_t, const AD_MANDATORY_FOR_KDC *, size_t *);
-size_t length_AD_MANDATORY_FOR_KDC(const AD_MANDATORY_FOR_KDC *);
-int copy_AD_MANDATORY_FOR_KDC (const AD_MANDATORY_FOR_KDC *, AD_MANDATORY_FOR_KDC *);
-void free_AD_MANDATORY_FOR_KDC (AD_MANDATORY_FOR_KDC *);
-
-
/*
PA-SAM-TYPE ::= INTEGER {
PA_SAM_TYPE_ENIGMA(1),
PA_SAM_TYPE_CRYPTOCARD = 6
} PA_SAM_TYPE;
-int decode_PA_SAM_TYPE(const unsigned char *, size_t, PA_SAM_TYPE *, size_t *);
-int encode_PA_SAM_TYPE(unsigned char *, size_t, const PA_SAM_TYPE *, size_t *);
-size_t length_PA_SAM_TYPE(const PA_SAM_TYPE *);
-int copy_PA_SAM_TYPE (const PA_SAM_TYPE *, PA_SAM_TYPE *);
-void free_PA_SAM_TYPE (PA_SAM_TYPE *);
-
-
/*
PA-SAM-REDIRECT ::= HostAddresses
*/
typedef HostAddresses PA_SAM_REDIRECT;
-int decode_PA_SAM_REDIRECT(const unsigned char *, size_t, PA_SAM_REDIRECT *, size_t *);
-int encode_PA_SAM_REDIRECT(unsigned char *, size_t, const PA_SAM_REDIRECT *, size_t *);
-size_t length_PA_SAM_REDIRECT(const PA_SAM_REDIRECT *);
-int copy_PA_SAM_REDIRECT (const PA_SAM_REDIRECT *, PA_SAM_REDIRECT *);
-void free_PA_SAM_REDIRECT (PA_SAM_REDIRECT *);
-
-
/*
SAMFlags ::= BIT STRING {
use-sad-as-key(0),
unsigned SAMFlags2int(SAMFlags);
SAMFlags int2SAMFlags(unsigned);
-int decode_SAMFlags(const unsigned char *, size_t, SAMFlags *, size_t *);
-int encode_SAMFlags(unsigned char *, size_t, const SAMFlags *, size_t *);
-size_t length_SAMFlags(const SAMFlags *);
-int copy_SAMFlags (const SAMFlags *, SAMFlags *);
-void free_SAMFlags (SAMFlags *);
-
-
/*
PA-SAM-CHALLENGE-2-BODY ::= SEQUENCE {
sam-type [0] krb5int32,
krb5int32 sam_etype;
} PA_SAM_CHALLENGE_2_BODY;
-int decode_PA_SAM_CHALLENGE_2_BODY(const unsigned char *, size_t, PA_SAM_CHALLENGE_2_BODY *, size_t *);
-int encode_PA_SAM_CHALLENGE_2_BODY(unsigned char *, size_t, const PA_SAM_CHALLENGE_2_BODY *, size_t *);
-size_t length_PA_SAM_CHALLENGE_2_BODY(const PA_SAM_CHALLENGE_2_BODY *);
-int copy_PA_SAM_CHALLENGE_2_BODY (const PA_SAM_CHALLENGE_2_BODY *, PA_SAM_CHALLENGE_2_BODY *);
-void free_PA_SAM_CHALLENGE_2_BODY (PA_SAM_CHALLENGE_2_BODY *);
-
-
/*
PA-SAM-CHALLENGE-2 ::= SEQUENCE {
sam-body [0] PA-SAM-CHALLENGE-2-BODY,
} sam_cksum;
} PA_SAM_CHALLENGE_2;
-int decode_PA_SAM_CHALLENGE_2(const unsigned char *, size_t, PA_SAM_CHALLENGE_2 *, size_t *);
-int encode_PA_SAM_CHALLENGE_2(unsigned char *, size_t, const PA_SAM_CHALLENGE_2 *, size_t *);
-size_t length_PA_SAM_CHALLENGE_2(const PA_SAM_CHALLENGE_2 *);
-int copy_PA_SAM_CHALLENGE_2 (const PA_SAM_CHALLENGE_2 *, PA_SAM_CHALLENGE_2 *);
-void free_PA_SAM_CHALLENGE_2 (PA_SAM_CHALLENGE_2 *);
-
-
/*
PA-SAM-RESPONSE-2 ::= SEQUENCE {
sam-type [0] krb5int32,
krb5int32 sam_nonce;
} PA_SAM_RESPONSE_2;
-int decode_PA_SAM_RESPONSE_2(const unsigned char *, size_t, PA_SAM_RESPONSE_2 *, size_t *);
-int encode_PA_SAM_RESPONSE_2(unsigned char *, size_t, const PA_SAM_RESPONSE_2 *, size_t *);
-size_t length_PA_SAM_RESPONSE_2(const PA_SAM_RESPONSE_2 *);
-int copy_PA_SAM_RESPONSE_2 (const PA_SAM_RESPONSE_2 *, PA_SAM_RESPONSE_2 *);
-void free_PA_SAM_RESPONSE_2 (PA_SAM_RESPONSE_2 *);
-
-
/*
PA-ENC-SAM-RESPONSE-ENC ::= SEQUENCE {
sam-nonce [0] krb5int32,
heim_general_string *sam_sad;
} PA_ENC_SAM_RESPONSE_ENC;
-int decode_PA_ENC_SAM_RESPONSE_ENC(const unsigned char *, size_t, PA_ENC_SAM_RESPONSE_ENC *, size_t *);
-int encode_PA_ENC_SAM_RESPONSE_ENC(unsigned char *, size_t, const PA_ENC_SAM_RESPONSE_ENC *, size_t *);
-size_t length_PA_ENC_SAM_RESPONSE_ENC(const PA_ENC_SAM_RESPONSE_ENC *);
-int copy_PA_ENC_SAM_RESPONSE_ENC (const PA_ENC_SAM_RESPONSE_ENC *, PA_ENC_SAM_RESPONSE_ENC *);
-void free_PA_ENC_SAM_RESPONSE_ENC (PA_ENC_SAM_RESPONSE_ENC *);
-
-
/*
PA-S4U2Self ::= SEQUENCE {
name [0] PrincipalName,
heim_general_string auth;
} PA_S4U2Self;
-int decode_PA_S4U2Self(const unsigned char *, size_t, PA_S4U2Self *, size_t *);
-int encode_PA_S4U2Self(unsigned char *, size_t, const PA_S4U2Self *, size_t *);
-size_t length_PA_S4U2Self(const PA_S4U2Self *);
-int copy_PA_S4U2Self (const PA_S4U2Self *, PA_S4U2Self *);
-void free_PA_S4U2Self (PA_S4U2Self *);
+ASN1EXP int ASN1CALL decode_PA_S4U2Self(const unsigned char *, size_t, PA_S4U2Self *, size_t *);
+ASN1EXP int ASN1CALL encode_PA_S4U2Self(unsigned char *, size_t, const PA_S4U2Self *, size_t *);
+ASN1EXP size_t ASN1CALL length_PA_S4U2Self(const PA_S4U2Self *);
+ASN1EXP int ASN1CALL copy_PA_S4U2Self (const PA_S4U2Self *, PA_S4U2Self *);
+ASN1EXP void ASN1CALL free_PA_S4U2Self (PA_S4U2Self *);
/*
METHOD_DATA *method_data;
} KRB5SignedPathData;
-int decode_KRB5SignedPathData(const unsigned char *, size_t, KRB5SignedPathData *, size_t *);
-int encode_KRB5SignedPathData(unsigned char *, size_t, const KRB5SignedPathData *, size_t *);
-size_t length_KRB5SignedPathData(const KRB5SignedPathData *);
-int copy_KRB5SignedPathData (const KRB5SignedPathData *, KRB5SignedPathData *);
-void free_KRB5SignedPathData (KRB5SignedPathData *);
+ASN1EXP int ASN1CALL decode_KRB5SignedPathData(const unsigned char *, size_t, KRB5SignedPathData *, size_t *);
+ASN1EXP int ASN1CALL encode_KRB5SignedPathData(unsigned char *, size_t, const KRB5SignedPathData *, size_t *);
+ASN1EXP size_t ASN1CALL length_KRB5SignedPathData(const KRB5SignedPathData *);
+ASN1EXP int ASN1CALL copy_KRB5SignedPathData (const KRB5SignedPathData *, KRB5SignedPathData *);
+ASN1EXP void ASN1CALL free_KRB5SignedPathData (KRB5SignedPathData *);
/*
METHOD_DATA *method_data;
} KRB5SignedPath;
-int decode_KRB5SignedPath(const unsigned char *, size_t, KRB5SignedPath *, size_t *);
-int encode_KRB5SignedPath(unsigned char *, size_t, const KRB5SignedPath *, size_t *);
-size_t length_KRB5SignedPath(const KRB5SignedPath *);
-int copy_KRB5SignedPath (const KRB5SignedPath *, KRB5SignedPath *);
-void free_KRB5SignedPath (KRB5SignedPath *);
-
-
-/*
-PA-ClientCanonicalizedNames ::= SEQUENCE {
- requested-name [0] PrincipalName,
- mapped-name [1] PrincipalName,
-}
-*/
-
-typedef struct PA_ClientCanonicalizedNames {
- PrincipalName requested_name;
- PrincipalName mapped_name;
-} PA_ClientCanonicalizedNames;
-
-int decode_PA_ClientCanonicalizedNames(const unsigned char *, size_t, PA_ClientCanonicalizedNames *, size_t *);
-int encode_PA_ClientCanonicalizedNames(unsigned char *, size_t, const PA_ClientCanonicalizedNames *, size_t *);
-size_t length_PA_ClientCanonicalizedNames(const PA_ClientCanonicalizedNames *);
-int copy_PA_ClientCanonicalizedNames (const PA_ClientCanonicalizedNames *, PA_ClientCanonicalizedNames *);
-void free_PA_ClientCanonicalizedNames (PA_ClientCanonicalizedNames *);
-
-
-/*
-PA-ClientCanonicalized ::= SEQUENCE {
- names [0] PA-ClientCanonicalizedNames,
- canon-checksum [1] Checksum,
-}
-*/
-
-typedef struct PA_ClientCanonicalized {
- PA_ClientCanonicalizedNames names;
- Checksum canon_checksum;
-} PA_ClientCanonicalized;
-
-int decode_PA_ClientCanonicalized(const unsigned char *, size_t, PA_ClientCanonicalized *, size_t *);
-int encode_PA_ClientCanonicalized(unsigned char *, size_t, const PA_ClientCanonicalized *, size_t *);
-size_t length_PA_ClientCanonicalized(const PA_ClientCanonicalized *);
-int copy_PA_ClientCanonicalized (const PA_ClientCanonicalized *, PA_ClientCanonicalized *);
-void free_PA_ClientCanonicalized (PA_ClientCanonicalized *);
+ASN1EXP int ASN1CALL decode_KRB5SignedPath(const unsigned char *, size_t, KRB5SignedPath *, size_t *);
+ASN1EXP int ASN1CALL encode_KRB5SignedPath(unsigned char *, size_t, const KRB5SignedPath *, size_t *);
+ASN1EXP size_t ASN1CALL length_KRB5SignedPath(const KRB5SignedPath *);
+ASN1EXP int ASN1CALL copy_KRB5SignedPath (const KRB5SignedPath *, KRB5SignedPath *);
+ASN1EXP void ASN1CALL free_KRB5SignedPath (KRB5SignedPath *);
/*
Checksum checksum;
} AD_LoginAlias;
-int decode_AD_LoginAlias(const unsigned char *, size_t, AD_LoginAlias *, size_t *);
-int encode_AD_LoginAlias(unsigned char *, size_t, const AD_LoginAlias *, size_t *);
-size_t length_AD_LoginAlias(const AD_LoginAlias *);
-int copy_AD_LoginAlias (const AD_LoginAlias *, AD_LoginAlias *);
-void free_AD_LoginAlias (AD_LoginAlias *);
+ASN1EXP int ASN1CALL decode_AD_LoginAlias(const unsigned char *, size_t, AD_LoginAlias *, size_t *);
+ASN1EXP int ASN1CALL encode_AD_LoginAlias(unsigned char *, size_t, const AD_LoginAlias *, size_t *);
+ASN1EXP size_t ASN1CALL length_AD_LoginAlias(const AD_LoginAlias *);
+ASN1EXP int ASN1CALL copy_AD_LoginAlias (const AD_LoginAlias *, AD_LoginAlias *);
+ASN1EXP void ASN1CALL free_AD_LoginAlias (AD_LoginAlias *);
/*
Realm referred_realm;
} PA_SvrReferralData;
-int decode_PA_SvrReferralData(const unsigned char *, size_t, PA_SvrReferralData *, size_t *);
-int encode_PA_SvrReferralData(unsigned char *, size_t, const PA_SvrReferralData *, size_t *);
-size_t length_PA_SvrReferralData(const PA_SvrReferralData *);
-int copy_PA_SvrReferralData (const PA_SvrReferralData *, PA_SvrReferralData *);
-void free_PA_SvrReferralData (PA_SvrReferralData *);
+ASN1EXP int ASN1CALL decode_PA_SvrReferralData(const unsigned char *, size_t, PA_SvrReferralData *, size_t *);
+ASN1EXP int ASN1CALL encode_PA_SvrReferralData(unsigned char *, size_t, const PA_SvrReferralData *, size_t *);
+ASN1EXP size_t ASN1CALL length_PA_SvrReferralData(const PA_SvrReferralData *);
+ASN1EXP int ASN1CALL copy_PA_SvrReferralData (const PA_SvrReferralData *, PA_SvrReferralData *);
+ASN1EXP void ASN1CALL free_PA_SvrReferralData (PA_SvrReferralData *);
/*
typedef EncryptedData PA_SERVER_REFERRAL_DATA;
-int decode_PA_SERVER_REFERRAL_DATA(const unsigned char *, size_t, PA_SERVER_REFERRAL_DATA *, size_t *);
-int encode_PA_SERVER_REFERRAL_DATA(unsigned char *, size_t, const PA_SERVER_REFERRAL_DATA *, size_t *);
-size_t length_PA_SERVER_REFERRAL_DATA(const PA_SERVER_REFERRAL_DATA *);
-int copy_PA_SERVER_REFERRAL_DATA (const PA_SERVER_REFERRAL_DATA *, PA_SERVER_REFERRAL_DATA *);
-void free_PA_SERVER_REFERRAL_DATA (PA_SERVER_REFERRAL_DATA *);
+ASN1EXP int ASN1CALL decode_PA_SERVER_REFERRAL_DATA(const unsigned char *, size_t, PA_SERVER_REFERRAL_DATA *, size_t *);
+ASN1EXP int ASN1CALL encode_PA_SERVER_REFERRAL_DATA(unsigned char *, size_t, const PA_SERVER_REFERRAL_DATA *, size_t *);
+ASN1EXP size_t ASN1CALL length_PA_SERVER_REFERRAL_DATA(const PA_SERVER_REFERRAL_DATA *);
+ASN1EXP int ASN1CALL copy_PA_SERVER_REFERRAL_DATA (const PA_SERVER_REFERRAL_DATA *, PA_SERVER_REFERRAL_DATA *);
+ASN1EXP void ASN1CALL free_PA_SERVER_REFERRAL_DATA (PA_SERVER_REFERRAL_DATA *);
/*
KerberosTime *referral_valid_until;
} PA_ServerReferralData;
-int decode_PA_ServerReferralData(const unsigned char *, size_t, PA_ServerReferralData *, size_t *);
-int encode_PA_ServerReferralData(unsigned char *, size_t, const PA_ServerReferralData *, size_t *);
-size_t length_PA_ServerReferralData(const PA_ServerReferralData *);
-int copy_PA_ServerReferralData (const PA_ServerReferralData *, PA_ServerReferralData *);
-void free_PA_ServerReferralData (PA_ServerReferralData *);
+ASN1EXP int ASN1CALL decode_PA_ServerReferralData(const unsigned char *, size_t, PA_ServerReferralData *, size_t *);
+ASN1EXP int ASN1CALL encode_PA_ServerReferralData(unsigned char *, size_t, const PA_ServerReferralData *, size_t *);
+ASN1EXP size_t ASN1CALL length_PA_ServerReferralData(const PA_ServerReferralData *);
+ASN1EXP int ASN1CALL copy_PA_ServerReferralData (const PA_ServerReferralData *, PA_ServerReferralData *);
+ASN1EXP void ASN1CALL free_PA_ServerReferralData (PA_ServerReferralData *);
/*
FastOptions ::= BIT STRING {
reserved(0),
hide-client-names(1),
- kdc-follow--referrals(16)
+ kdc-follow-referrals(16)
}
*/
unsigned int _unused13:1;
unsigned int _unused14:1;
unsigned int _unused15:1;
- unsigned int kdc_follow__referrals:1;
+ unsigned int kdc_follow_referrals:1;
unsigned int _unused17:1;
unsigned int _unused18:1;
unsigned int _unused19:1;
unsigned FastOptions2int(FastOptions);
FastOptions int2FastOptions(unsigned);
-int decode_FastOptions(const unsigned char *, size_t, FastOptions *, size_t *);
-int encode_FastOptions(unsigned char *, size_t, const FastOptions *, size_t *);
-size_t length_FastOptions(const FastOptions *);
-int copy_FastOptions (const FastOptions *, FastOptions *);
-void free_FastOptions (FastOptions *);
-
-
/*
KrbFastReq ::= SEQUENCE {
fast-options [0] FastOptions,
- padata [1] SEQUENCE OF PA-DATA,
+ padata [1] METHOD-DATA,
req-body [2] KDC-REQ-BODY,
...,
}
typedef struct KrbFastReq {
FastOptions fast_options;
- struct KrbFastReq_padata {
- unsigned int len;
- PA_DATA *val;
- } padata;
+ METHOD_DATA padata;
KDC_REQ_BODY req_body;
} KrbFastReq;
-int decode_KrbFastReq(const unsigned char *, size_t, KrbFastReq *, size_t *);
-int encode_KrbFastReq(unsigned char *, size_t, const KrbFastReq *, size_t *);
-size_t length_KrbFastReq(const KrbFastReq *);
-int copy_KrbFastReq (const KrbFastReq *, KrbFastReq *);
-void free_KrbFastReq (KrbFastReq *);
+ASN1EXP int ASN1CALL decode_KrbFastReq(const unsigned char *, size_t, KrbFastReq *, size_t *);
+ASN1EXP int ASN1CALL encode_KrbFastReq(unsigned char *, size_t, const KrbFastReq *, size_t *);
+ASN1EXP size_t ASN1CALL length_KrbFastReq(const KrbFastReq *);
+ASN1EXP int ASN1CALL copy_KrbFastReq (const KrbFastReq *, KrbFastReq *);
+ASN1EXP void ASN1CALL free_KrbFastReq (KrbFastReq *);
/*
heim_octet_string armor_value;
} KrbFastArmor;
-int decode_KrbFastArmor(const unsigned char *, size_t, KrbFastArmor *, size_t *);
-int encode_KrbFastArmor(unsigned char *, size_t, const KrbFastArmor *, size_t *);
-size_t length_KrbFastArmor(const KrbFastArmor *);
-int copy_KrbFastArmor (const KrbFastArmor *, KrbFastArmor *);
-void free_KrbFastArmor (KrbFastArmor *);
+ASN1EXP int ASN1CALL decode_KrbFastArmor(const unsigned char *, size_t, KrbFastArmor *, size_t *);
+ASN1EXP int ASN1CALL encode_KrbFastArmor(unsigned char *, size_t, const KrbFastArmor *, size_t *);
+ASN1EXP size_t ASN1CALL length_KrbFastArmor(const KrbFastArmor *);
+ASN1EXP int ASN1CALL copy_KrbFastArmor (const KrbFastArmor *, KrbFastArmor *);
+ASN1EXP void ASN1CALL free_KrbFastArmor (KrbFastArmor *);
/*
EncryptedData enc_fast_req;
} KrbFastArmoredReq;
-int decode_KrbFastArmoredReq(const unsigned char *, size_t, KrbFastArmoredReq *, size_t *);
-int encode_KrbFastArmoredReq(unsigned char *, size_t, const KrbFastArmoredReq *, size_t *);
-size_t length_KrbFastArmoredReq(const KrbFastArmoredReq *);
-int copy_KrbFastArmoredReq (const KrbFastArmoredReq *, KrbFastArmoredReq *);
-void free_KrbFastArmoredReq (KrbFastArmoredReq *);
-
-
/*
PA-FX-FAST-REQUEST ::= CHOICE {
armored-data [0] KrbFastArmoredReq,
*/
typedef struct PA_FX_FAST_REQUEST {
- enum {
+ enum PA_FX_FAST_REQUEST_enum {
choice_PA_FX_FAST_REQUEST_asn1_ellipsis = 0,
choice_PA_FX_FAST_REQUEST_armored_data
/* ... */
} u;
} PA_FX_FAST_REQUEST;
-int decode_PA_FX_FAST_REQUEST(const unsigned char *, size_t, PA_FX_FAST_REQUEST *, size_t *);
-int encode_PA_FX_FAST_REQUEST(unsigned char *, size_t, const PA_FX_FAST_REQUEST *, size_t *);
-size_t length_PA_FX_FAST_REQUEST(const PA_FX_FAST_REQUEST *);
-int copy_PA_FX_FAST_REQUEST (const PA_FX_FAST_REQUEST *, PA_FX_FAST_REQUEST *);
-void free_PA_FX_FAST_REQUEST (PA_FX_FAST_REQUEST *);
+ASN1EXP int ASN1CALL decode_PA_FX_FAST_REQUEST(const unsigned char *, size_t, PA_FX_FAST_REQUEST *, size_t *);
+ASN1EXP int ASN1CALL encode_PA_FX_FAST_REQUEST(unsigned char *, size_t, const PA_FX_FAST_REQUEST *, size_t *);
+ASN1EXP size_t ASN1CALL length_PA_FX_FAST_REQUEST(const PA_FX_FAST_REQUEST *);
+ASN1EXP int ASN1CALL copy_PA_FX_FAST_REQUEST (const PA_FX_FAST_REQUEST *, PA_FX_FAST_REQUEST *);
+ASN1EXP void ASN1CALL free_PA_FX_FAST_REQUEST (PA_FX_FAST_REQUEST *);
/*
usec [1] krb5int32,
crealm [2] Realm,
cname [3] PrincipalName,
- checksum [4] Checksum,
- ticket-checksum [5] Checksum,
+ ticket-checksum [4] Checksum,
...,
}
*/
krb5int32 usec;
Realm crealm;
PrincipalName cname;
- Checksum checksum;
Checksum ticket_checksum;
} KrbFastFinished;
-int decode_KrbFastFinished(const unsigned char *, size_t, KrbFastFinished *, size_t *);
-int encode_KrbFastFinished(unsigned char *, size_t, const KrbFastFinished *, size_t *);
-size_t length_KrbFastFinished(const KrbFastFinished *);
-int copy_KrbFastFinished (const KrbFastFinished *, KrbFastFinished *);
-void free_KrbFastFinished (KrbFastFinished *);
+ASN1EXP int ASN1CALL decode_KrbFastFinished(const unsigned char *, size_t, KrbFastFinished *, size_t *);
+ASN1EXP int ASN1CALL encode_KrbFastFinished(unsigned char *, size_t, const KrbFastFinished *, size_t *);
+ASN1EXP size_t ASN1CALL length_KrbFastFinished(const KrbFastFinished *);
+ASN1EXP int ASN1CALL copy_KrbFastFinished (const KrbFastFinished *, KrbFastFinished *);
+ASN1EXP void ASN1CALL free_KrbFastFinished (KrbFastFinished *);
/*
KrbFastResponse ::= SEQUENCE {
- padata [0] SEQUENCE OF PA-DATA,
- rep-key [1] EncryptionKey OPTIONAL,
- finished [2] KrbFastFinished OPTIONAL,
+ padata [0] METHOD-DATA,
+ strengthen-key [1] EncryptionKey OPTIONAL,
+ finished [2] KrbFastFinished OPTIONAL,
+ nonce [3] krb5uint32,
...,
}
*/
typedef struct KrbFastResponse {
- struct KrbFastResponse_padata {
- unsigned int len;
- PA_DATA *val;
- } padata;
- EncryptionKey *rep_key;
+ METHOD_DATA padata;
+ EncryptionKey *strengthen_key;
KrbFastFinished *finished;
+ krb5uint32 nonce;
} KrbFastResponse;
-int decode_KrbFastResponse(const unsigned char *, size_t, KrbFastResponse *, size_t *);
-int encode_KrbFastResponse(unsigned char *, size_t, const KrbFastResponse *, size_t *);
-size_t length_KrbFastResponse(const KrbFastResponse *);
-int copy_KrbFastResponse (const KrbFastResponse *, KrbFastResponse *);
-void free_KrbFastResponse (KrbFastResponse *);
+ASN1EXP int ASN1CALL decode_KrbFastResponse(const unsigned char *, size_t, KrbFastResponse *, size_t *);
+ASN1EXP int ASN1CALL encode_KrbFastResponse(unsigned char *, size_t, const KrbFastResponse *, size_t *);
+ASN1EXP size_t ASN1CALL length_KrbFastResponse(const KrbFastResponse *);
+ASN1EXP int ASN1CALL copy_KrbFastResponse (const KrbFastResponse *, KrbFastResponse *);
+ASN1EXP void ASN1CALL free_KrbFastResponse (KrbFastResponse *);
/*
EncryptedData enc_fast_rep;
} KrbFastArmoredRep;
-int decode_KrbFastArmoredRep(const unsigned char *, size_t, KrbFastArmoredRep *, size_t *);
-int encode_KrbFastArmoredRep(unsigned char *, size_t, const KrbFastArmoredRep *, size_t *);
-size_t length_KrbFastArmoredRep(const KrbFastArmoredRep *);
-int copy_KrbFastArmoredRep (const KrbFastArmoredRep *, KrbFastArmoredRep *);
-void free_KrbFastArmoredRep (KrbFastArmoredRep *);
-
-
/*
PA-FX-FAST-REPLY ::= CHOICE {
armored-data [0] KrbFastArmoredRep,
*/
typedef struct PA_FX_FAST_REPLY {
- enum {
+ enum PA_FX_FAST_REPLY_enum {
choice_PA_FX_FAST_REPLY_asn1_ellipsis = 0,
choice_PA_FX_FAST_REPLY_armored_data
/* ... */
} u;
} PA_FX_FAST_REPLY;
-int decode_PA_FX_FAST_REPLY(const unsigned char *, size_t, PA_FX_FAST_REPLY *, size_t *);
-int encode_PA_FX_FAST_REPLY(unsigned char *, size_t, const PA_FX_FAST_REPLY *, size_t *);
-size_t length_PA_FX_FAST_REPLY(const PA_FX_FAST_REPLY *);
-int copy_PA_FX_FAST_REPLY (const PA_FX_FAST_REPLY *, PA_FX_FAST_REPLY *);
-void free_PA_FX_FAST_REPLY (PA_FX_FAST_REPLY *);
+ASN1EXP int ASN1CALL decode_PA_FX_FAST_REPLY(const unsigned char *, size_t, PA_FX_FAST_REPLY *, size_t *);
+ASN1EXP int ASN1CALL encode_PA_FX_FAST_REPLY(unsigned char *, size_t, const PA_FX_FAST_REPLY *, size_t *);
+ASN1EXP size_t ASN1CALL length_PA_FX_FAST_REPLY(const PA_FX_FAST_REPLY *);
+ASN1EXP int ASN1CALL copy_PA_FX_FAST_REPLY (const PA_FX_FAST_REPLY *, PA_FX_FAST_REPLY *);
+ASN1EXP void ASN1CALL free_PA_FX_FAST_REPLY (PA_FX_FAST_REPLY *);
+
+
+/*
+KDCFastFlags ::= BIT STRING {
+ use_reply_key(0),
+ reply_key_used(1),
+ reply_key_replaced(2),
+ kdc_verfied(3)
+}
+*/
+
+typedef struct KDCFastFlags {
+ unsigned int use_reply_key:1;
+ unsigned int reply_key_used:1;
+ unsigned int reply_key_replaced:1;
+ unsigned int kdc_verfied:1;
+ unsigned int _unused4:1;
+ unsigned int _unused5:1;
+ unsigned int _unused6:1;
+ unsigned int _unused7:1;
+ unsigned int _unused8:1;
+ unsigned int _unused9:1;
+ unsigned int _unused10:1;
+ unsigned int _unused11:1;
+ unsigned int _unused12:1;
+ unsigned int _unused13:1;
+ unsigned int _unused14:1;
+ unsigned int _unused15:1;
+ unsigned int _unused16:1;
+ unsigned int _unused17:1;
+ unsigned int _unused18:1;
+ unsigned int _unused19:1;
+ unsigned int _unused20:1;
+ unsigned int _unused21:1;
+ unsigned int _unused22:1;
+ unsigned int _unused23:1;
+ unsigned int _unused24:1;
+ unsigned int _unused25:1;
+ unsigned int _unused26:1;
+ unsigned int _unused27:1;
+ unsigned int _unused28:1;
+ unsigned int _unused29:1;
+ unsigned int _unused30:1;
+ unsigned int _unused31:1;
+} KDCFastFlags;
+
+
+unsigned KDCFastFlags2int(KDCFastFlags);
+KDCFastFlags int2KDCFastFlags(unsigned);
+/*
+KDCFastState ::= SEQUENCE {
+ flags [0] KDCFastFlags,
+ expiration [1] GeneralizedTime,
+ fast-state [2] METHOD-DATA,
+ expected-pa-types [3] SEQUENCE OF PADATA-TYPE OPTIONAL,
+}
+*/
+
+typedef struct KDCFastState {
+ KDCFastFlags flags;
+ time_t expiration;
+ METHOD_DATA fast_state;
+ struct KDCFastState_expected_pa_types {
+ unsigned int len;
+ PADATA_TYPE *val;
+ } *expected_pa_types;
+} KDCFastState;
+
+ASN1EXP int ASN1CALL decode_KDCFastState(const unsigned char *, size_t, KDCFastState *, size_t *);
+ASN1EXP int ASN1CALL encode_KDCFastState(unsigned char *, size_t, const KDCFastState *, size_t *);
+ASN1EXP size_t ASN1CALL length_KDCFastState(const KDCFastState *);
+ASN1EXP int ASN1CALL copy_KDCFastState (const KDCFastState *, KDCFastState *);
+ASN1EXP void ASN1CALL free_KDCFastState (KDCFastState *);
+
+
+/*
+KDCFastCookie ::= SEQUENCE {
+ version [0] UTF8String,
+ cookie [1] EncryptedData,
+}
+*/
+
+typedef struct KDCFastCookie {
+ heim_utf8_string version;
+ EncryptedData cookie;
+} KDCFastCookie;
+
+ASN1EXP int ASN1CALL decode_KDCFastCookie(const unsigned char *, size_t, KDCFastCookie *, size_t *);
+ASN1EXP int ASN1CALL encode_KDCFastCookie(unsigned char *, size_t, const KDCFastCookie *, size_t *);
+ASN1EXP size_t ASN1CALL length_KDCFastCookie(const KDCFastCookie *);
+ASN1EXP int ASN1CALL copy_KDCFastCookie (const KDCFastCookie *, KDCFastCookie *);
+ASN1EXP void ASN1CALL free_KDCFastCookie (KDCFastCookie *);
+
+
+/*
+KDC-PROXY-MESSAGE ::= SEQUENCE {
+ kerb-message [0] OCTET STRING,
+ target-domain [1] Realm OPTIONAL,
+ dclocator-hint [2] INTEGER OPTIONAL,
+}
+*/
+
+typedef struct KDC_PROXY_MESSAGE {
+ heim_octet_string kerb_message;
+ Realm *target_domain;
+ heim_integer *dclocator_hint;
+} KDC_PROXY_MESSAGE;
+
+ASN1EXP int ASN1CALL decode_KDC_PROXY_MESSAGE(const unsigned char *, size_t, KDC_PROXY_MESSAGE *, size_t *);
+ASN1EXP int ASN1CALL encode_KDC_PROXY_MESSAGE(unsigned char *, size_t, const KDC_PROXY_MESSAGE *, size_t *);
+ASN1EXP size_t ASN1CALL length_KDC_PROXY_MESSAGE(const KDC_PROXY_MESSAGE *);
+ASN1EXP int ASN1CALL copy_KDC_PROXY_MESSAGE (const KDC_PROXY_MESSAGE *, KDC_PROXY_MESSAGE *);
+ASN1EXP void ASN1CALL free_KDC_PROXY_MESSAGE (KDC_PROXY_MESSAGE *);
+
+
+/*
+KERB-TIMES ::= SEQUENCE {
+ authtime [0] KerberosTime,
+ starttime [1] KerberosTime,
+ endtime [2] KerberosTime,
+ renew_till [3] KerberosTime,
+}
+*/
+
+typedef struct KERB_TIMES {
+ KerberosTime authtime;
+ KerberosTime starttime;
+ KerberosTime endtime;
+ KerberosTime renew_till;
+} KERB_TIMES;
+
+ASN1EXP int ASN1CALL decode_KERB_TIMES(const unsigned char *, size_t, KERB_TIMES *, size_t *);
+ASN1EXP int ASN1CALL encode_KERB_TIMES(unsigned char *, size_t, const KERB_TIMES *, size_t *);
+ASN1EXP size_t ASN1CALL length_KERB_TIMES(const KERB_TIMES *);
+ASN1EXP int ASN1CALL copy_KERB_TIMES (const KERB_TIMES *, KERB_TIMES *);
+ASN1EXP void ASN1CALL free_KERB_TIMES (KERB_TIMES *);
+
+
+/*
+KERB-CRED ::= SEQUENCE {
+ client [0] Principal,
+ server [1] Principal,
+ keyblock [2] EncryptionKey,
+ times [3] KERB-TIMES,
+ ticket [4] OCTET STRING,
+ authdata [5] OCTET STRING,
+ addresses [6] HostAddresses,
+ flags [7] TicketFlags,
+}
+*/
+
+typedef struct KERB_CRED {
+ Principal client;
+ Principal server;
+ EncryptionKey keyblock;
+ KERB_TIMES times;
+ heim_octet_string ticket;
+ heim_octet_string authdata;
+ HostAddresses addresses;
+ TicketFlags flags;
+} KERB_CRED;
+
+ASN1EXP int ASN1CALL decode_KERB_CRED(const unsigned char *, size_t, KERB_CRED *, size_t *);
+ASN1EXP int ASN1CALL encode_KERB_CRED(unsigned char *, size_t, const KERB_CRED *, size_t *);
+ASN1EXP size_t ASN1CALL length_KERB_CRED(const KERB_CRED *);
+ASN1EXP int ASN1CALL copy_KERB_CRED (const KERB_CRED *, KERB_CRED *);
+ASN1EXP void ASN1CALL free_KERB_CRED (KERB_CRED *);
+
+
+/*
+KERB-TGS-REQ-IN ::= SEQUENCE {
+ cache [0] OCTET STRING,
+ addrs [1] HostAddresses,
+ flags [2] krb5uint32,
+ imp [3] Principal OPTIONAL,
+ ticket [4] OCTET STRING OPTIONAL,
+ in_cred [5] KERB-CRED,
+ krbtgt [6] KERB-CRED,
+ padata [7] METHOD-DATA,
+}
+*/
+
+typedef struct KERB_TGS_REQ_IN {
+ heim_octet_string cache;
+ HostAddresses addrs;
+ krb5uint32 flags;
+ Principal *imp;
+ heim_octet_string *ticket;
+ KERB_CRED in_cred;
+ KERB_CRED krbtgt;
+ METHOD_DATA padata;
+} KERB_TGS_REQ_IN;
+
+ASN1EXP int ASN1CALL decode_KERB_TGS_REQ_IN(const unsigned char *, size_t, KERB_TGS_REQ_IN *, size_t *);
+ASN1EXP int ASN1CALL encode_KERB_TGS_REQ_IN(unsigned char *, size_t, const KERB_TGS_REQ_IN *, size_t *);
+ASN1EXP size_t ASN1CALL length_KERB_TGS_REQ_IN(const KERB_TGS_REQ_IN *);
+ASN1EXP int ASN1CALL copy_KERB_TGS_REQ_IN (const KERB_TGS_REQ_IN *, KERB_TGS_REQ_IN *);
+ASN1EXP void ASN1CALL free_KERB_TGS_REQ_IN (KERB_TGS_REQ_IN *);
+
+
+/*
+KERB-TGS-REQ-OUT ::= SEQUENCE {
+ subkey [0] EncryptionKey OPTIONAL,
+ t [1] TGS-REQ,
+}
+*/
+
+typedef struct KERB_TGS_REQ_OUT {
+ EncryptionKey *subkey;
+ TGS_REQ t;
+} KERB_TGS_REQ_OUT;
+
+ASN1EXP int ASN1CALL decode_KERB_TGS_REQ_OUT(const unsigned char *, size_t, KERB_TGS_REQ_OUT *, size_t *);
+ASN1EXP int ASN1CALL encode_KERB_TGS_REQ_OUT(unsigned char *, size_t, const KERB_TGS_REQ_OUT *, size_t *);
+ASN1EXP size_t ASN1CALL length_KERB_TGS_REQ_OUT(const KERB_TGS_REQ_OUT *);
+ASN1EXP int ASN1CALL copy_KERB_TGS_REQ_OUT (const KERB_TGS_REQ_OUT *, KERB_TGS_REQ_OUT *);
+ASN1EXP void ASN1CALL free_KERB_TGS_REQ_OUT (KERB_TGS_REQ_OUT *);
+
+
+/*
+KERB-TGS-REP-IN ::= SEQUENCE {
+ cache [0] OCTET STRING,
+ subkey [1] EncryptionKey OPTIONAL,
+ in_cred [2] KERB-CRED,
+ t [3] TGS-REP,
+}
+*/
+
+typedef struct KERB_TGS_REP_IN {
+ heim_octet_string cache;
+ EncryptionKey *subkey;
+ KERB_CRED in_cred;
+ TGS_REP t;
+} KERB_TGS_REP_IN;
+
+/*
+KERB-TGS-REP-OUT ::= SEQUENCE {
+ cache [0] OCTET STRING,
+ cred [1] KERB-CRED,
+ subkey [2] EncryptionKey,
+}
+*/
+
+typedef struct KERB_TGS_REP_OUT {
+ heim_octet_string cache;
+ KERB_CRED cred;
+ EncryptionKey subkey;
+} KERB_TGS_REP_OUT;
+
+/*
+KERB-ARMOR-SERVICE-REPLY ::= SEQUENCE {
+ armor [0] KrbFastArmor,
+ armor-key [1] EncryptionKey,
+}
+*/
+
+typedef struct KERB_ARMOR_SERVICE_REPLY {
+ KrbFastArmor armor;
+ EncryptionKey armor_key;
+} KERB_ARMOR_SERVICE_REPLY;
+
+ASN1EXP int ASN1CALL decode_KERB_ARMOR_SERVICE_REPLY(const unsigned char *, size_t, KERB_ARMOR_SERVICE_REPLY *, size_t *);
+ASN1EXP int ASN1CALL encode_KERB_ARMOR_SERVICE_REPLY(unsigned char *, size_t, const KERB_ARMOR_SERVICE_REPLY *, size_t *);
+ASN1EXP size_t ASN1CALL length_KERB_ARMOR_SERVICE_REPLY(const KERB_ARMOR_SERVICE_REPLY *);
+ASN1EXP int ASN1CALL copy_KERB_ARMOR_SERVICE_REPLY (const KERB_ARMOR_SERVICE_REPLY *, KERB_ARMOR_SERVICE_REPLY *);
+ASN1EXP void ASN1CALL free_KERB_ARMOR_SERVICE_REPLY (KERB_ARMOR_SERVICE_REPLY *);
#endif /* __krb5_asn1_h__ */
git://git.openafs.org / openafs.git / blobdiff