asn1_err.h   asn1_err.h 
skipping to change at line 31 skipping to change at line 31
ASN1_BAD_ID = 1859794438, ASN1_BAD_ID = 1859794438,
ASN1_BAD_LENGTH = 1859794439, ASN1_BAD_LENGTH = 1859794439,
ASN1_BAD_FORMAT = 1859794440, ASN1_BAD_FORMAT = 1859794440,
ASN1_PARSE_ERROR = 1859794441, ASN1_PARSE_ERROR = 1859794441,
ASN1_EXTRA_DATA = 1859794442, ASN1_EXTRA_DATA = 1859794442,
ASN1_BAD_CHARACTER = 1859794443, ASN1_BAD_CHARACTER = 1859794443,
ASN1_MIN_CONSTRAINT = 1859794444, ASN1_MIN_CONSTRAINT = 1859794444,
ASN1_MAX_CONSTRAINT = 1859794445, ASN1_MAX_CONSTRAINT = 1859794445,
ASN1_EXACT_CONSTRAINT = 1859794446, ASN1_EXACT_CONSTRAINT = 1859794446,
ASN1_INDEF_OVERRUN = 1859794447, ASN1_INDEF_OVERRUN = 1859794447,
ASN1_INDEF_UNDERRUN = 1859794448 ASN1_INDEF_UNDERRUN = 1859794448,
ASN1_GOT_BER = 1859794449,
ASN1_INDEF_EXTRA_DATA = 1859794450
} asn1_error_number; } asn1_error_number;
#define ERROR_TABLE_BASE_asn1 1859794432 #define ERROR_TABLE_BASE_asn1 1859794432
#define COM_ERR_BINDDOMAIN_asn1 "heim_com_err1859794432" #define COM_ERR_BINDDOMAIN_asn1 "heim_com_err1859794432"
#endif /* __asn1_err_h__ */ #endif /* __asn1_err_h__ */
 End of changes. 1 change blocks. 
1 lines changed or deleted 3 lines changed or added


 base64.h   base64.h 
skipping to change at line 41 skipping to change at line 41
* SUCH DAMAGE. * SUCH DAMAGE.
*/ */
/* $Id$ */ /* $Id$ */
#ifndef _BASE64_H_ #ifndef _BASE64_H_
#define _BASE64_H_ #define _BASE64_H_
#ifndef ROKEN_LIB_FUNCTION #ifndef ROKEN_LIB_FUNCTION
#ifdef _WIN32 #ifdef _WIN32
#define ROKEN_LIB_FUNCTION _stdcall #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL __cdecl
#else #else
#define ROKEN_LIB_FUNCTION #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL
#endif #endif
#endif #endif
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
base64_encode(const void *, int, char **); base64_encode(const void *, int, char **);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
base64_decode(const char *, void *); base64_decode(const char *, void *);
#endif #endif
 End of changes. 4 change blocks. 
3 lines changed or deleted 5 lines changed or added


 cms_asn1.h   cms_asn1.h 
skipping to change at line 28 skipping to change at line 28
typedef struct heim_octet_string { typedef struct heim_octet_string {
size_t length; size_t length;
void *data; void *data;
} heim_octet_string; } heim_octet_string;
typedef char *heim_general_string; typedef char *heim_general_string;
typedef char *heim_utf8_string; typedef char *heim_utf8_string;
typedef char *heim_printable_string; typedef struct heim_octet_string heim_printable_string;
typedef char *heim_ia5_string; typedef struct heim_octet_string heim_ia5_string;
typedef struct heim_bmp_string { typedef struct heim_bmp_string {
size_t length; size_t length;
uint16_t *data; uint16_t *data;
} heim_bmp_string; } heim_bmp_string;
typedef struct heim_universal_string { typedef struct heim_universal_string {
size_t length; size_t length;
uint32_t *data; uint32_t *data;
} heim_universal_string; } heim_universal_string;
skipping to change at line 73 skipping to change at line 73
} else { \ } else { \
(R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
(S), (L)); \ (S), (L)); \
if((R) != 0) { \ if((R) != 0) { \
free((B)); \ free((B)); \
(B) = NULL; \ (B) = NULL; \
} \ } \
} \ } \
} while (0) } while (0)
#ifdef _WIN32
#ifndef ASN1_LIB
#define ASN1EXP __declspec(dllimport)
#else
#define ASN1EXP
#endif
#define ASN1CALL __stdcall
#else
#define ASN1EXP
#define ASN1CALL
#endif
struct units; struct units;
#endif #endif
#include <rfc2459_asn1.h> #include <rfc2459_asn1.h>
#include <heim_asn1.h> #include <heim_asn1.h>
/* OBJECT IDENTIFIER id-pkcs7 ::= { iso(1) member-body(2) us(840) rsadsi(11 3549) pkcs(1) pkcs7(7) } */ /* OBJECT IDENTIFIER id-pkcs7 ::= { iso(1) member-body(2) us(840) rsadsi(11 3549) pkcs(1) pkcs7(7) } */
const heim_oid *oid_id_pkcs7(void);
extern const heim_oid asn1_oid_id_pkcs7; extern const heim_oid asn1_oid_id_pkcs7;
#define ASN1_OID_ID_PKCS7 (&asn1_oid_id_pkcs7)
/* OBJECT IDENTIFIER id-pkcs7-data ::= { iso(1) member-body(2) us(840) rsad si(113549) pkcs(1) pkcs7(7) label-less(1) } */ /* OBJECT IDENTIFIER id-pkcs7-data ::= { iso(1) member-body(2) us(840) rsad si(113549) pkcs(1) pkcs7(7) label-less(1) } */
const heim_oid *oid_id_pkcs7_data(void);
extern const heim_oid asn1_oid_id_pkcs7_data; extern const heim_oid asn1_oid_id_pkcs7_data;
#define ASN1_OID_ID_PKCS7_DATA (&asn1_oid_id_pkcs7_data)
/* OBJECT IDENTIFIER id-pkcs7-signedData ::= { iso(1) member-body(2) us(840 ) rsadsi(113549) pkcs(1) pkcs7(7) label-less(2) } */ /* OBJECT IDENTIFIER id-pkcs7-signedData ::= { iso(1) member-body(2) us(840 ) rsadsi(113549) pkcs(1) pkcs7(7) label-less(2) } */
const heim_oid *oid_id_pkcs7_signedData(void);
extern const heim_oid asn1_oid_id_pkcs7_signedData; extern const heim_oid asn1_oid_id_pkcs7_signedData;
#define ASN1_OID_ID_PKCS7_SIGNEDDATA (&asn1_oid_id_pkcs7_signedData)
/* OBJECT IDENTIFIER id-pkcs7-envelopedData ::= { iso(1) member-body(2) us( 840) rsadsi(113549) pkcs(1) pkcs7(7) label-less(3) } */ /* OBJECT IDENTIFIER id-pkcs7-envelopedData ::= { iso(1) member-body(2) us( 840) rsadsi(113549) pkcs(1) pkcs7(7) label-less(3) } */
const heim_oid *oid_id_pkcs7_envelopedData(void);
extern const heim_oid asn1_oid_id_pkcs7_envelopedData; extern const heim_oid asn1_oid_id_pkcs7_envelopedData;
#define ASN1_OID_ID_PKCS7_ENVELOPEDDATA (&asn1_oid_id_pkcs7_envelopedData)
/* OBJECT IDENTIFIER id-pkcs7-signedAndEnvelopedData ::= { iso(1) member-bo dy(2) us(840) rsadsi(113549) pkcs(1) pkcs7(7) label-less(4) } */ /* OBJECT IDENTIFIER id-pkcs7-signedAndEnvelopedData ::= { iso(1) member-bo dy(2) us(840) rsadsi(113549) pkcs(1) pkcs7(7) label-less(4) } */
const heim_oid *oid_id_pkcs7_signedAndEnvelopedData(void);
extern const heim_oid asn1_oid_id_pkcs7_signedAndEnvelopedData; extern const heim_oid asn1_oid_id_pkcs7_signedAndEnvelopedData;
#define ASN1_OID_ID_PKCS7_SIGNEDANDENVELOPEDDATA (&asn1_oid_id_pkcs7_signed AndEnvelopedData)
/* OBJECT IDENTIFIER id-pkcs7-digestedData ::= { iso(1) member-body(2) us(8 40) rsadsi(113549) pkcs(1) pkcs7(7) label-less(5) } */ /* OBJECT IDENTIFIER id-pkcs7-digestedData ::= { iso(1) member-body(2) us(8 40) rsadsi(113549) pkcs(1) pkcs7(7) label-less(5) } */
const heim_oid *oid_id_pkcs7_digestedData(void);
extern const heim_oid asn1_oid_id_pkcs7_digestedData; extern const heim_oid asn1_oid_id_pkcs7_digestedData;
#define ASN1_OID_ID_PKCS7_DIGESTEDDATA (&asn1_oid_id_pkcs7_digestedData)
/* OBJECT IDENTIFIER id-pkcs7-encryptedData ::= { iso(1) member-body(2) us( 840) rsadsi(113549) pkcs(1) pkcs7(7) label-less(6) } */ /* OBJECT IDENTIFIER id-pkcs7-encryptedData ::= { iso(1) member-body(2) us( 840) rsadsi(113549) pkcs(1) pkcs7(7) label-less(6) } */
const heim_oid *oid_id_pkcs7_encryptedData(void);
extern const heim_oid asn1_oid_id_pkcs7_encryptedData; extern const heim_oid asn1_oid_id_pkcs7_encryptedData;
#define ASN1_OID_ID_PKCS7_ENCRYPTEDDATA (&asn1_oid_id_pkcs7_encryptedData)
/* /*
CMSVersion ::= INTEGER { CMSVersion ::= INTEGER {
CMSVersion_v0(0), CMSVersion_v0(0),
CMSVersion_v1(1), CMSVersion_v1(1),
CMSVersion_v2(2), CMSVersion_v2(2),
CMSVersion_v3(3), CMSVersion_v3(3),
CMSVersion_v4(4) CMSVersion_v4(4)
} }
*/ */
typedef enum CMSVersion { typedef enum CMSVersion {
CMSVersion_v0 = 0, CMSVersion_v0 = 0,
CMSVersion_v1 = 1, CMSVersion_v1 = 1,
CMSVersion_v2 = 2, CMSVersion_v2 = 2,
CMSVersion_v3 = 3, CMSVersion_v3 = 3,
CMSVersion_v4 = 4 CMSVersion_v4 = 4
} CMSVersion; } CMSVersion;
int encode_CMSVersion(unsigned char *, size_t, const CMSVersion *, size_ ASN1EXP int ASN1CALL decode_CMSVersion(const unsigned char *, size_t, CM
t *); SVersion *, size_t *);
int decode_CMSVersion(const unsigned char *, size_t, CMSVersion *, size_ ASN1EXP int ASN1CALL encode_CMSVersion(unsigned char *, size_t, const CM
t *); SVersion *, size_t *);
void free_CMSVersion (CMSVersion *); ASN1EXP size_t ASN1CALL length_CMSVersion(const CMSVersion *);
size_t length_CMSVersion(const CMSVersion *); ASN1EXP int ASN1CALL copy_CMSVersion (const CMSVersion *, CMSVersion *)
int copy_CMSVersion (const CMSVersion *, CMSVersion *); ;
ASN1EXP void ASN1CALL free_CMSVersion (CMSVersion *);
/* /*
DigestAlgorithmIdentifier ::= AlgorithmIdentifier DigestAlgorithmIdentifier ::= AlgorithmIdentifier
*/ */
typedef AlgorithmIdentifier DigestAlgorithmIdentifier; typedef AlgorithmIdentifier DigestAlgorithmIdentifier;
int encode_DigestAlgorithmIdentifier(unsigned char *, size_t, const Dige ASN1EXP int ASN1CALL decode_DigestAlgorithmIdentifier(const unsigned cha
stAlgorithmIdentifier *, size_t *); r *, size_t, DigestAlgorithmIdentifier *, size_t *);
int decode_DigestAlgorithmIdentifier(const unsigned char *, size_t, Dige ASN1EXP int ASN1CALL encode_DigestAlgorithmIdentifier(unsigned char *, s
stAlgorithmIdentifier *, size_t *); ize_t, const DigestAlgorithmIdentifier *, size_t *);
void free_DigestAlgorithmIdentifier (DigestAlgorithmIdentifier *); ASN1EXP size_t ASN1CALL length_DigestAlgorithmIdentifier(const DigestAlgori
size_t length_DigestAlgorithmIdentifier(const DigestAlgorithmIdentifier *); thmIdentifier *);
int copy_DigestAlgorithmIdentifier (const DigestAlgorithmIdentifier *, ASN1EXP int ASN1CALL copy_DigestAlgorithmIdentifier (const DigestAlgori
DigestAlgorithmIdentifier *); thmIdentifier *, DigestAlgorithmIdentifier *);
ASN1EXP void ASN1CALL free_DigestAlgorithmIdentifier (DigestAlgorithmIde
ntifier *);
/* /*
DigestAlgorithmIdentifiers ::= SET OF DigestAlgorithmIdentifier DigestAlgorithmIdentifiers ::= SET OF DigestAlgorithmIdentifier
*/ */
typedef struct DigestAlgorithmIdentifiers { typedef struct DigestAlgorithmIdentifiers {
unsigned int len; unsigned int len;
DigestAlgorithmIdentifier *val; DigestAlgorithmIdentifier *val;
} DigestAlgorithmIdentifiers; } DigestAlgorithmIdentifiers;
int encode_DigestAlgorithmIdentifiers(unsigned char *, size_t, const Dig ASN1EXP int ASN1CALL add_DigestAlgorithmIdentifiers (DigestAlgorithmIden
estAlgorithmIdentifiers *, size_t *); tifiers *, const DigestAlgorithmIdentifier *);
int decode_DigestAlgorithmIdentifiers(const unsigned char *, size_t, Dig ASN1EXP int ASN1CALL remove_DigestAlgorithmIdentifiers (DigestAlgorithmI
estAlgorithmIdentifiers *, size_t *); dentifiers *, unsigned int);
void free_DigestAlgorithmIdentifiers (DigestAlgorithmIdentifiers *); ASN1EXP int ASN1CALL decode_DigestAlgorithmIdentifiers(const unsigned ch
size_t length_DigestAlgorithmIdentifiers(const DigestAlgorithmIdentifiers * ar *, size_t, DigestAlgorithmIdentifiers *, size_t *);
); ASN1EXP int ASN1CALL encode_DigestAlgorithmIdentifiers(unsigned char *,
int copy_DigestAlgorithmIdentifiers (const DigestAlgorithmIdentifiers * size_t, const DigestAlgorithmIdentifiers *, size_t *);
, DigestAlgorithmIdentifiers *); ASN1EXP size_t ASN1CALL length_DigestAlgorithmIdentifiers(const DigestAlgor
ithmIdentifiers *);
ASN1EXP int ASN1CALL copy_DigestAlgorithmIdentifiers (const DigestAlgor
ithmIdentifiers *, DigestAlgorithmIdentifiers *);
ASN1EXP void ASN1CALL free_DigestAlgorithmIdentifiers (DigestAlgorithmId
entifiers *);
/* /*
SignatureAlgorithmIdentifier ::= AlgorithmIdentifier SignatureAlgorithmIdentifier ::= AlgorithmIdentifier
*/ */
typedef AlgorithmIdentifier SignatureAlgorithmIdentifier; typedef AlgorithmIdentifier SignatureAlgorithmIdentifier;
int encode_SignatureAlgorithmIdentifier(unsigned char *, size_t, const S ASN1EXP int ASN1CALL decode_SignatureAlgorithmIdentifier(const unsigned
ignatureAlgorithmIdentifier *, size_t *); char *, size_t, SignatureAlgorithmIdentifier *, size_t *);
int decode_SignatureAlgorithmIdentifier(const unsigned char *, size_t, S ASN1EXP int ASN1CALL encode_SignatureAlgorithmIdentifier(unsigned char *
ignatureAlgorithmIdentifier *, size_t *); , size_t, const SignatureAlgorithmIdentifier *, size_t *);
void free_SignatureAlgorithmIdentifier (SignatureAlgorithmIdentifier *); ASN1EXP size_t ASN1CALL length_SignatureAlgorithmIdentifier(const Signature
size_t length_SignatureAlgorithmIdentifier(const SignatureAlgorithmIdentifi AlgorithmIdentifier *);
er *); ASN1EXP int ASN1CALL copy_SignatureAlgorithmIdentifier (const Signature
int copy_SignatureAlgorithmIdentifier (const SignatureAlgorithmIdentifi AlgorithmIdentifier *, SignatureAlgorithmIdentifier *);
er *, SignatureAlgorithmIdentifier *); ASN1EXP void ASN1CALL free_SignatureAlgorithmIdentifier (SignatureAlgori
thmIdentifier *);
/* /*
ContentType ::= OBJECT IDENTIFIER ContentType ::= OBJECT IDENTIFIER
*/ */
typedef heim_oid ContentType; typedef heim_oid ContentType;
int encode_ContentType(unsigned char *, size_t, const ContentType *, siz ASN1EXP int ASN1CALL decode_ContentType(const unsigned char *, size_t, C
e_t *); ontentType *, size_t *);
int decode_ContentType(const unsigned char *, size_t, ContentType *, siz ASN1EXP int ASN1CALL encode_ContentType(unsigned char *, size_t, const C
e_t *); ontentType *, size_t *);
void free_ContentType (ContentType *); ASN1EXP size_t ASN1CALL length_ContentType(const ContentType *);
size_t length_ContentType(const ContentType *); ASN1EXP int ASN1CALL copy_ContentType (const ContentType *, ContentType
int copy_ContentType (const ContentType *, ContentType *); *);
ASN1EXP void ASN1CALL free_ContentType (ContentType *);
/* /*
MessageDigest ::= OCTET STRING MessageDigest ::= OCTET STRING
*/ */
typedef heim_octet_string MessageDigest; typedef heim_octet_string MessageDigest;
int encode_MessageDigest(unsigned char *, size_t, const MessageDigest *, ASN1EXP int ASN1CALL decode_MessageDigest(const unsigned char *, size_t,
size_t *); MessageDigest *, size_t *);
int decode_MessageDigest(const unsigned char *, size_t, MessageDigest *, ASN1EXP int ASN1CALL encode_MessageDigest(unsigned char *, size_t, const
size_t *); MessageDigest *, size_t *);
void free_MessageDigest (MessageDigest *); ASN1EXP size_t ASN1CALL length_MessageDigest(const MessageDigest *);
size_t length_MessageDigest(const MessageDigest *); ASN1EXP int ASN1CALL copy_MessageDigest (const MessageDigest *, Message
int copy_MessageDigest (const MessageDigest *, MessageDigest *); Digest *);
ASN1EXP void ASN1CALL free_MessageDigest (MessageDigest *);
/* /*
ContentInfo ::= SEQUENCE { ContentInfo ::= SEQUENCE {
contentType ContentType, contentType ContentType,
content [0] heim_any OPTIONAL, content [0] heim_any OPTIONAL,
} }
*/ */
typedef struct ContentInfo { typedef struct ContentInfo {
ContentType contentType; ContentType contentType;
heim_any *content; heim_any *content;
} ContentInfo; } ContentInfo;
int encode_ContentInfo(unsigned char *, size_t, const ContentInfo *, siz ASN1EXP int ASN1CALL decode_ContentInfo(const unsigned char *, size_t, C
e_t *); ontentInfo *, size_t *);
int decode_ContentInfo(const unsigned char *, size_t, ContentInfo *, siz ASN1EXP int ASN1CALL encode_ContentInfo(unsigned char *, size_t, const C
e_t *); ontentInfo *, size_t *);
void free_ContentInfo (ContentInfo *); ASN1EXP size_t ASN1CALL length_ContentInfo(const ContentInfo *);
size_t length_ContentInfo(const ContentInfo *); ASN1EXP int ASN1CALL copy_ContentInfo (const ContentInfo *, ContentInfo
int copy_ContentInfo (const ContentInfo *, ContentInfo *); *);
ASN1EXP void ASN1CALL free_ContentInfo (ContentInfo *);
/* /*
EncapsulatedContentInfo ::= SEQUENCE { EncapsulatedContentInfo ::= SEQUENCE {
eContentType ContentType, eContentType ContentType,
eContent [0] OCTET STRING OPTIONAL, eContent [0] OCTET STRING OPTIONAL,
} }
*/ */
typedef struct EncapsulatedContentInfo { typedef struct EncapsulatedContentInfo {
ContentType eContentType; ContentType eContentType;
heim_octet_string *eContent; heim_octet_string *eContent;
} EncapsulatedContentInfo; } EncapsulatedContentInfo;
int encode_EncapsulatedContentInfo(unsigned char *, size_t, const Encaps ASN1EXP int ASN1CALL decode_EncapsulatedContentInfo(const unsigned char
ulatedContentInfo *, size_t *); *, size_t, EncapsulatedContentInfo *, size_t *);
int decode_EncapsulatedContentInfo(const unsigned char *, size_t, Encaps ASN1EXP int ASN1CALL encode_EncapsulatedContentInfo(unsigned char *, siz
ulatedContentInfo *, size_t *); e_t, const EncapsulatedContentInfo *, size_t *);
void free_EncapsulatedContentInfo (EncapsulatedContentInfo *); ASN1EXP size_t ASN1CALL length_EncapsulatedContentInfo(const EncapsulatedCo
size_t length_EncapsulatedContentInfo(const EncapsulatedContentInfo *); ntentInfo *);
int copy_EncapsulatedContentInfo (const EncapsulatedContentInfo *, Enca ASN1EXP int ASN1CALL copy_EncapsulatedContentInfo (const EncapsulatedCo
psulatedContentInfo *); ntentInfo *, EncapsulatedContentInfo *);
ASN1EXP void ASN1CALL free_EncapsulatedContentInfo (EncapsulatedContentI
nfo *);
/* /*
CertificateSet ::= SET OF heim_any CertificateSet ::= SET OF heim_any
*/ */
typedef struct CertificateSet { typedef struct CertificateSet {
unsigned int len; unsigned int len;
heim_any *val; heim_any *val;
} CertificateSet; } CertificateSet;
int encode_CertificateSet(unsigned char *, size_t, const CertificateSet ASN1EXP int ASN1CALL decode_CertificateSet(const unsigned char *, size_t
*, size_t *); , CertificateSet *, size_t *);
int decode_CertificateSet(const unsigned char *, size_t, CertificateSet ASN1EXP int ASN1CALL encode_CertificateSet(unsigned char *, size_t, cons
*, size_t *); t CertificateSet *, size_t *);
void free_CertificateSet (CertificateSet *); ASN1EXP size_t ASN1CALL length_CertificateSet(const CertificateSet *);
size_t length_CertificateSet(const CertificateSet *); ASN1EXP int ASN1CALL copy_CertificateSet (const CertificateSet *, Certi
int copy_CertificateSet (const CertificateSet *, CertificateSet *); ficateSet *);
ASN1EXP void ASN1CALL free_CertificateSet (CertificateSet *);
/* /*
CertificateList ::= Certificate CertificateList ::= Certificate
*/ */
typedef Certificate CertificateList; typedef Certificate CertificateList;
int encode_CertificateList(unsigned char *, size_t, const CertificateLis ASN1EXP int ASN1CALL decode_CertificateList(const unsigned char *, size_
t *, size_t *); t, CertificateList *, size_t *);
int decode_CertificateList(const unsigned char *, size_t, CertificateLis ASN1EXP int ASN1CALL encode_CertificateList(unsigned char *, size_t, con
t *, size_t *); st CertificateList *, size_t *);
void free_CertificateList (CertificateList *); ASN1EXP size_t ASN1CALL length_CertificateList(const CertificateList *);
size_t length_CertificateList(const CertificateList *); ASN1EXP int ASN1CALL copy_CertificateList (const CertificateList *, Cer
int copy_CertificateList (const CertificateList *, CertificateList *); tificateList *);
ASN1EXP void ASN1CALL free_CertificateList (CertificateList *);
/* /*
CertificateRevocationLists ::= SET OF CertificateList CertificateRevocationLists ::= SET OF CertificateList
*/ */
typedef struct CertificateRevocationLists { typedef struct CertificateRevocationLists {
unsigned int len; unsigned int len;
CertificateList *val; CertificateList *val;
} CertificateRevocationLists; } CertificateRevocationLists;
int encode_CertificateRevocationLists(unsigned char *, size_t, const Cer ASN1EXP int ASN1CALL decode_CertificateRevocationLists(const unsigned ch
tificateRevocationLists *, size_t *); ar *, size_t, CertificateRevocationLists *, size_t *);
int decode_CertificateRevocationLists(const unsigned char *, size_t, Cer ASN1EXP int ASN1CALL encode_CertificateRevocationLists(unsigned char *,
tificateRevocationLists *, size_t *); size_t, const CertificateRevocationLists *, size_t *);
void free_CertificateRevocationLists (CertificateRevocationLists *); ASN1EXP size_t ASN1CALL length_CertificateRevocationLists(const Certificate
size_t length_CertificateRevocationLists(const CertificateRevocationLists * RevocationLists *);
); ASN1EXP int ASN1CALL copy_CertificateRevocationLists (const Certificate
int copy_CertificateRevocationLists (const CertificateRevocationLists * RevocationLists *, CertificateRevocationLists *);
, CertificateRevocationLists *); ASN1EXP void ASN1CALL free_CertificateRevocationLists (CertificateRevoca
tionLists *);
/* /*
IssuerAndSerialNumber ::= SEQUENCE { IssuerAndSerialNumber ::= SEQUENCE {
issuer Name, issuer Name,
serialNumber CertificateSerialNumber, serialNumber CertificateSerialNumber,
} }
*/ */
typedef struct IssuerAndSerialNumber { typedef struct IssuerAndSerialNumber {
Name issuer; Name issuer;
CertificateSerialNumber serialNumber; CertificateSerialNumber serialNumber;
} IssuerAndSerialNumber; } IssuerAndSerialNumber;
int encode_IssuerAndSerialNumber(unsigned char *, size_t, const IssuerAn ASN1EXP int ASN1CALL decode_IssuerAndSerialNumber(const unsigned char *,
dSerialNumber *, size_t *); size_t, IssuerAndSerialNumber *, size_t *);
int decode_IssuerAndSerialNumber(const unsigned char *, size_t, IssuerAn ASN1EXP int ASN1CALL encode_IssuerAndSerialNumber(unsigned char *, size_
dSerialNumber *, size_t *); t, const IssuerAndSerialNumber *, size_t *);
void free_IssuerAndSerialNumber (IssuerAndSerialNumber *); ASN1EXP size_t ASN1CALL length_IssuerAndSerialNumber(const IssuerAndSerialN
size_t length_IssuerAndSerialNumber(const IssuerAndSerialNumber *); umber *);
int copy_IssuerAndSerialNumber (const IssuerAndSerialNumber *, IssuerAn ASN1EXP int ASN1CALL copy_IssuerAndSerialNumber (const IssuerAndSerialN
dSerialNumber *); umber *, IssuerAndSerialNumber *);
ASN1EXP void ASN1CALL free_IssuerAndSerialNumber (IssuerAndSerialNumber
*);
/* /*
CMSIdentifier ::= CHOICE { CMSIdentifier ::= CHOICE {
issuerAndSerialNumber IssuerAndSerialNumber, issuerAndSerialNumber IssuerAndSerialNumber,
subjectKeyIdentifier [0] SubjectKeyIdentifier, subjectKeyIdentifier [0] SubjectKeyIdentifier,
} }
*/ */
typedef struct CMSIdentifier { typedef struct CMSIdentifier {
enum { enum {
choice_CMSIdentifier_issuerAndSerialNumber = 1, choice_CMSIdentifier_issuerAndSerialNumber = 1,
choice_CMSIdentifier_subjectKeyIdentifier choice_CMSIdentifier_subjectKeyIdentifier
} element; } element;
union { union {
IssuerAndSerialNumber issuerAndSerialNumber; IssuerAndSerialNumber issuerAndSerialNumber;
SubjectKeyIdentifier subjectKeyIdentifier; SubjectKeyIdentifier subjectKeyIdentifier;
} u; } u;
} CMSIdentifier; } CMSIdentifier;
int encode_CMSIdentifier(unsigned char *, size_t, const CMSIdentifier *, ASN1EXP int ASN1CALL decode_CMSIdentifier(const unsigned char *, size_t,
size_t *); CMSIdentifier *, size_t *);
int decode_CMSIdentifier(const unsigned char *, size_t, CMSIdentifier *, ASN1EXP int ASN1CALL encode_CMSIdentifier(unsigned char *, size_t, const
size_t *); CMSIdentifier *, size_t *);
void free_CMSIdentifier (CMSIdentifier *); ASN1EXP size_t ASN1CALL length_CMSIdentifier(const CMSIdentifier *);
size_t length_CMSIdentifier(const CMSIdentifier *); ASN1EXP int ASN1CALL copy_CMSIdentifier (const CMSIdentifier *, CMSIden
int copy_CMSIdentifier (const CMSIdentifier *, CMSIdentifier *); tifier *);
ASN1EXP void ASN1CALL free_CMSIdentifier (CMSIdentifier *);
/* /*
SignerIdentifier ::= CMSIdentifier SignerIdentifier ::= CMSIdentifier
*/ */
typedef CMSIdentifier SignerIdentifier; typedef CMSIdentifier SignerIdentifier;
int encode_SignerIdentifier(unsigned char *, size_t, const SignerIdentif ASN1EXP int ASN1CALL decode_SignerIdentifier(const unsigned char *, size
ier *, size_t *); _t, SignerIdentifier *, size_t *);
int decode_SignerIdentifier(const unsigned char *, size_t, SignerIdentif ASN1EXP int ASN1CALL encode_SignerIdentifier(unsigned char *, size_t, co
ier *, size_t *); nst SignerIdentifier *, size_t *);
void free_SignerIdentifier (SignerIdentifier *); ASN1EXP size_t ASN1CALL length_SignerIdentifier(const SignerIdentifier *);
size_t length_SignerIdentifier(const SignerIdentifier *); ASN1EXP int ASN1CALL copy_SignerIdentifier (const SignerIdentifier *, S
int copy_SignerIdentifier (const SignerIdentifier *, SignerIdentifier * ignerIdentifier *);
); ASN1EXP void ASN1CALL free_SignerIdentifier (SignerIdentifier *);
/* /*
RecipientIdentifier ::= CMSIdentifier RecipientIdentifier ::= CMSIdentifier
*/ */
typedef CMSIdentifier RecipientIdentifier; typedef CMSIdentifier RecipientIdentifier;
int encode_RecipientIdentifier(unsigned char *, size_t, const RecipientI ASN1EXP int ASN1CALL decode_RecipientIdentifier(const unsigned char *, s
dentifier *, size_t *); ize_t, RecipientIdentifier *, size_t *);
int decode_RecipientIdentifier(const unsigned char *, size_t, RecipientI ASN1EXP int ASN1CALL encode_RecipientIdentifier(unsigned char *, size_t,
dentifier *, size_t *); const RecipientIdentifier *, size_t *);
void free_RecipientIdentifier (RecipientIdentifier *); ASN1EXP size_t ASN1CALL length_RecipientIdentifier(const RecipientIdentifie
size_t length_RecipientIdentifier(const RecipientIdentifier *); r *);
int copy_RecipientIdentifier (const RecipientIdentifier *, RecipientIde ASN1EXP int ASN1CALL copy_RecipientIdentifier (const RecipientIdentifie
ntifier *); r *, RecipientIdentifier *);
ASN1EXP void ASN1CALL free_RecipientIdentifier (RecipientIdentifier *);
/* /*
CMSAttributes ::= SET OF Attribute CMSAttributes ::= SET OF Attribute
*/ */
typedef struct CMSAttributes { typedef struct CMSAttributes {
unsigned int len; unsigned int len;
Attribute *val; Attribute *val;
} CMSAttributes; } CMSAttributes;
int encode_CMSAttributes(unsigned char *, size_t, const CMSAttributes *, ASN1EXP int ASN1CALL decode_CMSAttributes(const unsigned char *, size_t,
size_t *); CMSAttributes *, size_t *);
int decode_CMSAttributes(const unsigned char *, size_t, CMSAttributes *, ASN1EXP int ASN1CALL encode_CMSAttributes(unsigned char *, size_t, const
size_t *); CMSAttributes *, size_t *);
void free_CMSAttributes (CMSAttributes *); ASN1EXP size_t ASN1CALL length_CMSAttributes(const CMSAttributes *);
size_t length_CMSAttributes(const CMSAttributes *); ASN1EXP int ASN1CALL copy_CMSAttributes (const CMSAttributes *, CMSAttr
int copy_CMSAttributes (const CMSAttributes *, CMSAttributes *); ibutes *);
ASN1EXP void ASN1CALL free_CMSAttributes (CMSAttributes *);
/* /*
SignatureValue ::= OCTET STRING SignatureValue ::= OCTET STRING
*/ */
typedef heim_octet_string SignatureValue; typedef heim_octet_string SignatureValue;
int encode_SignatureValue(unsigned char *, size_t, const SignatureValue ASN1EXP int ASN1CALL decode_SignatureValue(const unsigned char *, size_t
*, size_t *); , SignatureValue *, size_t *);
int decode_SignatureValue(const unsigned char *, size_t, SignatureValue ASN1EXP int ASN1CALL encode_SignatureValue(unsigned char *, size_t, cons
*, size_t *); t SignatureValue *, size_t *);
void free_SignatureValue (SignatureValue *); ASN1EXP size_t ASN1CALL length_SignatureValue(const SignatureValue *);
size_t length_SignatureValue(const SignatureValue *); ASN1EXP int ASN1CALL copy_SignatureValue (const SignatureValue *, Signa
int copy_SignatureValue (const SignatureValue *, SignatureValue *); tureValue *);
ASN1EXP void ASN1CALL free_SignatureValue (SignatureValue *);
/* /*
SignerInfo ::= SEQUENCE { SignerInfo ::= SEQUENCE {
version CMSVersion, version CMSVersion,
sid SignerIdentifier, sid SignerIdentifier,
digestAlgorithm DigestAlgorithmIdentifier, digestAlgorithm DigestAlgorithmIdentifier,
signedAttrs [0] IMPLICIT SET OF Attribute OPTIONAL, signedAttrs [0] IMPLICIT SET OF Attribute OPTIONAL,
signatureAlgorithm SignatureAlgorithmIdentifier, signatureAlgorithm SignatureAlgorithmIdentifier,
signature SignatureValue, signature SignatureValue,
unsignedAttrs [1] IMPLICIT SET OF Attribute OPTIONAL, unsignedAttrs [1] IMPLICIT SET OF Attribute OPTIONAL,
} }
*/ */
typedef struct SignerInfo { typedef struct SignerInfo {
CMSVersion version; CMSVersion version;
SignerIdentifier sid; SignerIdentifier sid;
DigestAlgorithmIdentifier digestAlgorithm; DigestAlgorithmIdentifier digestAlgorithm;
struct { struct SignerInfo_signedAttrs {
unsigned int len; unsigned int len;
Attribute *val; Attribute *val;
} *signedAttrs; } *signedAttrs;
SignatureAlgorithmIdentifier signatureAlgorithm; SignatureAlgorithmIdentifier signatureAlgorithm;
SignatureValue signature; SignatureValue signature;
struct { struct SignerInfo_unsignedAttrs {
unsigned int len; unsigned int len;
Attribute *val; Attribute *val;
} *unsignedAttrs; } *unsignedAttrs;
} SignerInfo; } SignerInfo;
int encode_SignerInfo(unsigned char *, size_t, const SignerInfo *, size_ ASN1EXP int ASN1CALL decode_SignerInfo(const unsigned char *, size_t, Si
t *); gnerInfo *, size_t *);
int decode_SignerInfo(const unsigned char *, size_t, SignerInfo *, size_ ASN1EXP int ASN1CALL encode_SignerInfo(unsigned char *, size_t, const Si
t *); gnerInfo *, size_t *);
void free_SignerInfo (SignerInfo *); ASN1EXP size_t ASN1CALL length_SignerInfo(const SignerInfo *);
size_t length_SignerInfo(const SignerInfo *); ASN1EXP int ASN1CALL copy_SignerInfo (const SignerInfo *, SignerInfo *)
int copy_SignerInfo (const SignerInfo *, SignerInfo *); ;
ASN1EXP void ASN1CALL free_SignerInfo (SignerInfo *);
/* /*
SignerInfos ::= SET OF SignerInfo SignerInfos ::= SET OF SignerInfo
*/ */
typedef struct SignerInfos { typedef struct SignerInfos {
unsigned int len; unsigned int len;
SignerInfo *val; SignerInfo *val;
} SignerInfos; } SignerInfos;
int encode_SignerInfos(unsigned char *, size_t, const SignerInfos *, siz ASN1EXP int ASN1CALL decode_SignerInfos(const unsigned char *, size_t, S
e_t *); ignerInfos *, size_t *);
int decode_SignerInfos(const unsigned char *, size_t, SignerInfos *, siz ASN1EXP int ASN1CALL encode_SignerInfos(unsigned char *, size_t, const S
e_t *); ignerInfos *, size_t *);
void free_SignerInfos (SignerInfos *); ASN1EXP size_t ASN1CALL length_SignerInfos(const SignerInfos *);
size_t length_SignerInfos(const SignerInfos *); ASN1EXP int ASN1CALL copy_SignerInfos (const SignerInfos *, SignerInfos
int copy_SignerInfos (const SignerInfos *, SignerInfos *); *);
ASN1EXP void ASN1CALL free_SignerInfos (SignerInfos *);
/* /*
SignedData ::= SEQUENCE { SignedData ::= SEQUENCE {
version CMSVersion, version CMSVersion,
digestAlgorithms DigestAlgorithmIdentifiers, digestAlgorithms DigestAlgorithmIdentifiers,
encapContentInfo EncapsulatedContentInfo, encapContentInfo EncapsulatedContentInfo,
certificates [0] IMPLICIT SET OF heim_any OPTIONAL, certificates [0] IMPLICIT SET OF heim_any OPTIONAL,
crls [1] IMPLICIT heim_any OPTIONAL, crls [1] IMPLICIT heim_any OPTIONAL,
signerInfos SignerInfos, signerInfos SignerInfos,
} }
*/ */
typedef struct SignedData { typedef struct SignedData {
CMSVersion version; CMSVersion version;
DigestAlgorithmIdentifiers digestAlgorithms; DigestAlgorithmIdentifiers digestAlgorithms;
EncapsulatedContentInfo encapContentInfo; EncapsulatedContentInfo encapContentInfo;
struct { struct SignedData_certificates {
unsigned int len; unsigned int len;
heim_any *val; heim_any *val;
} *certificates; } *certificates;
heim_any *crls; heim_any *crls;
SignerInfos signerInfos; SignerInfos signerInfos;
} SignedData; } SignedData;
int encode_SignedData(unsigned char *, size_t, const SignedData *, size_ ASN1EXP int ASN1CALL decode_SignedData(const unsigned char *, size_t, Si
t *); gnedData *, size_t *);
int decode_SignedData(const unsigned char *, size_t, SignedData *, size_ ASN1EXP int ASN1CALL encode_SignedData(unsigned char *, size_t, const Si
t *); gnedData *, size_t *);
void free_SignedData (SignedData *); ASN1EXP size_t ASN1CALL length_SignedData(const SignedData *);
size_t length_SignedData(const SignedData *); ASN1EXP int ASN1CALL copy_SignedData (const SignedData *, SignedData *)
int copy_SignedData (const SignedData *, SignedData *); ;
ASN1EXP void ASN1CALL free_SignedData (SignedData *);
/* /*
OriginatorInfo ::= SEQUENCE { OriginatorInfo ::= SEQUENCE {
certs [0] IMPLICIT SET OF heim_any OPTIONAL, certs [0] IMPLICIT SET OF heim_any OPTIONAL,
crls [1] IMPLICIT heim_any OPTIONAL, crls [1] IMPLICIT heim_any OPTIONAL,
} }
*/ */
typedef struct OriginatorInfo { typedef struct OriginatorInfo {
struct { struct OriginatorInfo_certs {
unsigned int len; unsigned int len;
heim_any *val; heim_any *val;
} *certs; } *certs;
heim_any *crls; heim_any *crls;
} OriginatorInfo; } OriginatorInfo;
int encode_OriginatorInfo(unsigned char *, size_t, const OriginatorInfo ASN1EXP int ASN1CALL decode_OriginatorInfo(const unsigned char *, size_t
*, size_t *); , OriginatorInfo *, size_t *);
int decode_OriginatorInfo(const unsigned char *, size_t, OriginatorInfo ASN1EXP int ASN1CALL encode_OriginatorInfo(unsigned char *, size_t, cons
*, size_t *); t OriginatorInfo *, size_t *);
void free_OriginatorInfo (OriginatorInfo *); ASN1EXP size_t ASN1CALL length_OriginatorInfo(const OriginatorInfo *);
size_t length_OriginatorInfo(const OriginatorInfo *); ASN1EXP int ASN1CALL copy_OriginatorInfo (const OriginatorInfo *, Origi
int copy_OriginatorInfo (const OriginatorInfo *, OriginatorInfo *); natorInfo *);
ASN1EXP void ASN1CALL free_OriginatorInfo (OriginatorInfo *);
/* /*
KeyEncryptionAlgorithmIdentifier ::= AlgorithmIdentifier KeyEncryptionAlgorithmIdentifier ::= AlgorithmIdentifier
*/ */
typedef AlgorithmIdentifier KeyEncryptionAlgorithmIdentifier; typedef AlgorithmIdentifier KeyEncryptionAlgorithmIdentifier;
int encode_KeyEncryptionAlgorithmIdentifier(unsigned char *, size_t, con ASN1EXP int ASN1CALL decode_KeyEncryptionAlgorithmIdentifier(const unsig
st KeyEncryptionAlgorithmIdentifier *, size_t *); ned char *, size_t, KeyEncryptionAlgorithmIdentifier *, size_t *);
int decode_KeyEncryptionAlgorithmIdentifier(const unsigned char *, size_ ASN1EXP int ASN1CALL encode_KeyEncryptionAlgorithmIdentifier(unsigned ch
t, KeyEncryptionAlgorithmIdentifier *, size_t *); ar *, size_t, const KeyEncryptionAlgorithmIdentifier *, size_t *);
void free_KeyEncryptionAlgorithmIdentifier (KeyEncryptionAlgorithmIdenti ASN1EXP size_t ASN1CALL length_KeyEncryptionAlgorithmIdentifier(const KeyEn
fier *); cryptionAlgorithmIdentifier *);
size_t length_KeyEncryptionAlgorithmIdentifier(const KeyEncryptionAlgorithm ASN1EXP int ASN1CALL copy_KeyEncryptionAlgorithmIdentifier (const KeyEn
Identifier *); cryptionAlgorithmIdentifier *, KeyEncryptionAlgorithmIdentifier *);
int copy_KeyEncryptionAlgorithmIdentifier (const KeyEncryptionAlgorithm ASN1EXP void ASN1CALL free_KeyEncryptionAlgorithmIdentifier (KeyEncrypti
Identifier *, KeyEncryptionAlgorithmIdentifier *); onAlgorithmIdentifier *);
/* /*
ContentEncryptionAlgorithmIdentifier ::= AlgorithmIdentifier ContentEncryptionAlgorithmIdentifier ::= AlgorithmIdentifier
*/ */
typedef AlgorithmIdentifier ContentEncryptionAlgorithmIdentifier; typedef AlgorithmIdentifier ContentEncryptionAlgorithmIdentifier;
int encode_ContentEncryptionAlgorithmIdentifier(unsigned char *, size_t, ASN1EXP int ASN1CALL decode_ContentEncryptionAlgorithmIdentifier(const u
const ContentEncryptionAlgorithmIdentifier *, size_t *); nsigned char *, size_t, ContentEncryptionAlgorithmIdentifier *, size_t *);
int decode_ContentEncryptionAlgorithmIdentifier(const unsigned char *, s ASN1EXP int ASN1CALL encode_ContentEncryptionAlgorithmIdentifier(unsigne
ize_t, ContentEncryptionAlgorithmIdentifier *, size_t *); d char *, size_t, const ContentEncryptionAlgorithmIdentifier *, size_t *);
void free_ContentEncryptionAlgorithmIdentifier (ContentEncryptionAlgorit ASN1EXP size_t ASN1CALL length_ContentEncryptionAlgorithmIdentifier(const C
hmIdentifier *); ontentEncryptionAlgorithmIdentifier *);
size_t length_ContentEncryptionAlgorithmIdentifier(const ContentEncryptionA ASN1EXP int ASN1CALL copy_ContentEncryptionAlgorithmIdentifier (const C
lgorithmIdentifier *); ontentEncryptionAlgorithmIdentifier *, ContentEncryptionAlgorithmIdentifier
int copy_ContentEncryptionAlgorithmIdentifier (const ContentEncryptionA *);
lgorithmIdentifier *, ContentEncryptionAlgorithmIdentifier *); ASN1EXP void ASN1CALL free_ContentEncryptionAlgorithmIdentifier (Content
EncryptionAlgorithmIdentifier *);
/* /*
EncryptedKey ::= OCTET STRING EncryptedKey ::= OCTET STRING
*/ */
typedef heim_octet_string EncryptedKey; typedef heim_octet_string EncryptedKey;
int encode_EncryptedKey(unsigned char *, size_t, const EncryptedKey *, s ASN1EXP int ASN1CALL decode_EncryptedKey(const unsigned char *, size_t,
ize_t *); EncryptedKey *, size_t *);
int decode_EncryptedKey(const unsigned char *, size_t, EncryptedKey *, s ASN1EXP int ASN1CALL encode_EncryptedKey(unsigned char *, size_t, const
ize_t *); EncryptedKey *, size_t *);
void free_EncryptedKey (EncryptedKey *); ASN1EXP size_t ASN1CALL length_EncryptedKey(const EncryptedKey *);
size_t length_EncryptedKey(const EncryptedKey *); ASN1EXP int ASN1CALL copy_EncryptedKey (const EncryptedKey *, Encrypted
int copy_EncryptedKey (const EncryptedKey *, EncryptedKey *); Key *);
ASN1EXP void ASN1CALL free_EncryptedKey (EncryptedKey *);
/* /*
KeyTransRecipientInfo ::= SEQUENCE { KeyTransRecipientInfo ::= SEQUENCE {
version CMSVersion, version CMSVersion,
rid RecipientIdentifier, rid RecipientIdentifier,
keyEncryptionAlgorithm KeyEncryptionAlgorithmIdentifier, keyEncryptionAlgorithm KeyEncryptionAlgorithmIdentifier,
encryptedKey EncryptedKey, encryptedKey EncryptedKey,
} }
*/ */
typedef struct KeyTransRecipientInfo { typedef struct KeyTransRecipientInfo {
CMSVersion version; CMSVersion version;
RecipientIdentifier rid; RecipientIdentifier rid;
KeyEncryptionAlgorithmIdentifier keyEncryptionAlgorithm; KeyEncryptionAlgorithmIdentifier keyEncryptionAlgorithm;
EncryptedKey encryptedKey; EncryptedKey encryptedKey;
} KeyTransRecipientInfo; } KeyTransRecipientInfo;
int encode_KeyTransRecipientInfo(unsigned char *, size_t, const KeyTrans ASN1EXP int ASN1CALL decode_KeyTransRecipientInfo(const unsigned char *,
RecipientInfo *, size_t *); size_t, KeyTransRecipientInfo *, size_t *);
int decode_KeyTransRecipientInfo(const unsigned char *, size_t, KeyTrans ASN1EXP int ASN1CALL encode_KeyTransRecipientInfo(unsigned char *, size_
RecipientInfo *, size_t *); t, const KeyTransRecipientInfo *, size_t *);
void free_KeyTransRecipientInfo (KeyTransRecipientInfo *); ASN1EXP size_t ASN1CALL length_KeyTransRecipientInfo(const KeyTransRecipien
size_t length_KeyTransRecipientInfo(const KeyTransRecipientInfo *); tInfo *);
int copy_KeyTransRecipientInfo (const KeyTransRecipientInfo *, KeyTrans ASN1EXP int ASN1CALL copy_KeyTransRecipientInfo (const KeyTransRecipien
RecipientInfo *); tInfo *, KeyTransRecipientInfo *);
ASN1EXP void ASN1CALL free_KeyTransRecipientInfo (KeyTransRecipientInfo
*);
/* /*
RecipientInfo ::= KeyTransRecipientInfo RecipientInfo ::= KeyTransRecipientInfo
*/ */
typedef KeyTransRecipientInfo RecipientInfo; typedef KeyTransRecipientInfo RecipientInfo;
int encode_RecipientInfo(unsigned char *, size_t, const RecipientInfo *, ASN1EXP int ASN1CALL decode_RecipientInfo(const unsigned char *, size_t,
size_t *); RecipientInfo *, size_t *);
int decode_RecipientInfo(const unsigned char *, size_t, RecipientInfo *, ASN1EXP int ASN1CALL encode_RecipientInfo(unsigned char *, size_t, const
size_t *); RecipientInfo *, size_t *);
void free_RecipientInfo (RecipientInfo *); ASN1EXP size_t ASN1CALL length_RecipientInfo(const RecipientInfo *);
size_t length_RecipientInfo(const RecipientInfo *); ASN1EXP int ASN1CALL copy_RecipientInfo (const RecipientInfo *, Recipie
int copy_RecipientInfo (const RecipientInfo *, RecipientInfo *); ntInfo *);
ASN1EXP void ASN1CALL free_RecipientInfo (RecipientInfo *);
/* /*
RecipientInfos ::= SET OF RecipientInfo RecipientInfos ::= SET OF RecipientInfo
*/ */
typedef struct RecipientInfos { typedef struct RecipientInfos {
unsigned int len; unsigned int len;
RecipientInfo *val; RecipientInfo *val;
} RecipientInfos; } RecipientInfos;
int encode_RecipientInfos(unsigned char *, size_t, const RecipientInfos ASN1EXP int ASN1CALL decode_RecipientInfos(const unsigned char *, size_t
*, size_t *); , RecipientInfos *, size_t *);
int decode_RecipientInfos(const unsigned char *, size_t, RecipientInfos ASN1EXP int ASN1CALL encode_RecipientInfos(unsigned char *, size_t, cons
*, size_t *); t RecipientInfos *, size_t *);
void free_RecipientInfos (RecipientInfos *); ASN1EXP size_t ASN1CALL length_RecipientInfos(const RecipientInfos *);
size_t length_RecipientInfos(const RecipientInfos *); ASN1EXP int ASN1CALL copy_RecipientInfos (const RecipientInfos *, Recip
int copy_RecipientInfos (const RecipientInfos *, RecipientInfos *); ientInfos *);
ASN1EXP void ASN1CALL free_RecipientInfos (RecipientInfos *);
/* /*
EncryptedContent ::= OCTET STRING EncryptedContent ::= OCTET STRING
*/ */
typedef heim_octet_string EncryptedContent; typedef heim_octet_string EncryptedContent;
int encode_EncryptedContent(unsigned char *, size_t, const EncryptedCont ASN1EXP int ASN1CALL decode_EncryptedContent(const unsigned char *, size
ent *, size_t *); _t, EncryptedContent *, size_t *);
int decode_EncryptedContent(const unsigned char *, size_t, EncryptedCont ASN1EXP int ASN1CALL encode_EncryptedContent(unsigned char *, size_t, co
ent *, size_t *); nst EncryptedContent *, size_t *);
void free_EncryptedContent (EncryptedContent *); ASN1EXP size_t ASN1CALL length_EncryptedContent(const EncryptedContent *);
size_t length_EncryptedContent(const EncryptedContent *); ASN1EXP int ASN1CALL copy_EncryptedContent (const EncryptedContent *, E
int copy_EncryptedContent (const EncryptedContent *, EncryptedContent * ncryptedContent *);
); ASN1EXP void ASN1CALL free_EncryptedContent (EncryptedContent *);
/* /*
EncryptedContentInfo ::= SEQUENCE { EncryptedContentInfo ::= SEQUENCE {
contentType ContentType, contentType ContentType,
contentEncryptionAlgorithm ContentEncryptionAlgorithmIdentifier, contentEncryptionAlgorithm ContentEncryptionAlgorithmIdentifier,
encryptedContent [0] IMPLICIT OCTET STRING OPTIONAL, encryptedContent [0] IMPLICIT OCTET STRING OPTIONAL,
} }
*/ */
typedef struct EncryptedContentInfo { typedef struct EncryptedContentInfo {
ContentType contentType; ContentType contentType;
ContentEncryptionAlgorithmIdentifier contentEncryptionAlgorithm; ContentEncryptionAlgorithmIdentifier contentEncryptionAlgorithm;
heim_octet_string *encryptedContent; heim_octet_string *encryptedContent;
} EncryptedContentInfo; } EncryptedContentInfo;
int encode_EncryptedContentInfo(unsigned char *, size_t, const Encrypted ASN1EXP int ASN1CALL decode_EncryptedContentInfo(const unsigned char *,
ContentInfo *, size_t *); size_t, EncryptedContentInfo *, size_t *);
int decode_EncryptedContentInfo(const unsigned char *, size_t, Encrypted ASN1EXP int ASN1CALL encode_EncryptedContentInfo(unsigned char *, size_t
ContentInfo *, size_t *); , const EncryptedContentInfo *, size_t *);
void free_EncryptedContentInfo (EncryptedContentInfo *); ASN1EXP size_t ASN1CALL length_EncryptedContentInfo(const EncryptedContentI
size_t length_EncryptedContentInfo(const EncryptedContentInfo *); nfo *);
int copy_EncryptedContentInfo (const EncryptedContentInfo *, EncryptedC ASN1EXP int ASN1CALL copy_EncryptedContentInfo (const EncryptedContentI
ontentInfo *); nfo *, EncryptedContentInfo *);
ASN1EXP void ASN1CALL free_EncryptedContentInfo (EncryptedContentInfo *)
;
/* /*
UnprotectedAttributes ::= SET OF Attribute UnprotectedAttributes ::= SET OF Attribute
*/ */
typedef struct UnprotectedAttributes { typedef struct UnprotectedAttributes {
unsigned int len; unsigned int len;
Attribute *val; Attribute *val;
} UnprotectedAttributes; } UnprotectedAttributes;
int encode_UnprotectedAttributes(unsigned char *, size_t, const Unprotec ASN1EXP int ASN1CALL decode_UnprotectedAttributes(const unsigned char *,
tedAttributes *, size_t *); size_t, UnprotectedAttributes *, size_t *);
int decode_UnprotectedAttributes(const unsigned char *, size_t, Unprotec ASN1EXP int ASN1CALL encode_UnprotectedAttributes(unsigned char *, size_
tedAttributes *, size_t *); t, const UnprotectedAttributes *, size_t *);
void free_UnprotectedAttributes (UnprotectedAttributes *); ASN1EXP size_t ASN1CALL length_UnprotectedAttributes(const UnprotectedAttri
size_t length_UnprotectedAttributes(const UnprotectedAttributes *); butes *);
int copy_UnprotectedAttributes (const UnprotectedAttributes *, Unprotec ASN1EXP int ASN1CALL copy_UnprotectedAttributes (const UnprotectedAttri
tedAttributes *); butes *, UnprotectedAttributes *);
ASN1EXP void ASN1CALL free_UnprotectedAttributes (UnprotectedAttributes
*);
/* /*
CMSEncryptedData ::= SEQUENCE { CMSEncryptedData ::= SEQUENCE {
version CMSVersion, version CMSVersion,
encryptedContentInfo EncryptedContentInfo, encryptedContentInfo EncryptedContentInfo,
unprotectedAttrs [1] IMPLICIT heim_any OPTIONAL, unprotectedAttrs [1] IMPLICIT heim_any OPTIONAL,
} }
*/ */
typedef struct CMSEncryptedData { typedef struct CMSEncryptedData {
CMSVersion version; CMSVersion version;
EncryptedContentInfo encryptedContentInfo; EncryptedContentInfo encryptedContentInfo;
heim_any *unprotectedAttrs; heim_any *unprotectedAttrs;
} CMSEncryptedData; } CMSEncryptedData;
int encode_CMSEncryptedData(unsigned char *, size_t, const CMSEncryptedD ASN1EXP int ASN1CALL decode_CMSEncryptedData(const unsigned char *, size
ata *, size_t *); _t, CMSEncryptedData *, size_t *);
int decode_CMSEncryptedData(const unsigned char *, size_t, CMSEncryptedD ASN1EXP int ASN1CALL encode_CMSEncryptedData(unsigned char *, size_t, co
ata *, size_t *); nst CMSEncryptedData *, size_t *);
void free_CMSEncryptedData (CMSEncryptedData *); ASN1EXP size_t ASN1CALL length_CMSEncryptedData(const CMSEncryptedData *);
size_t length_CMSEncryptedData(const CMSEncryptedData *); ASN1EXP int ASN1CALL copy_CMSEncryptedData (const CMSEncryptedData *, C
int copy_CMSEncryptedData (const CMSEncryptedData *, CMSEncryptedData * MSEncryptedData *);
); ASN1EXP void ASN1CALL free_CMSEncryptedData (CMSEncryptedData *);
/* /*
EnvelopedData ::= SEQUENCE { EnvelopedData ::= SEQUENCE {
version CMSVersion, version CMSVersion,
originatorInfo [0] IMPLICIT heim_any OPTIONAL, originatorInfo [0] IMPLICIT heim_any OPTIONAL,
recipientInfos RecipientInfos, recipientInfos RecipientInfos,
encryptedContentInfo EncryptedContentInfo, encryptedContentInfo EncryptedContentInfo,
unprotectedAttrs [1] IMPLICIT heim_any OPTIONAL, unprotectedAttrs [1] IMPLICIT heim_any OPTIONAL,
} }
*/ */
typedef struct EnvelopedData { typedef struct EnvelopedData {
CMSVersion version; CMSVersion version;
heim_any *originatorInfo; heim_any *originatorInfo;
RecipientInfos recipientInfos; RecipientInfos recipientInfos;
EncryptedContentInfo encryptedContentInfo; EncryptedContentInfo encryptedContentInfo;
heim_any *unprotectedAttrs; heim_any *unprotectedAttrs;
} EnvelopedData; } EnvelopedData;
int encode_EnvelopedData(unsigned char *, size_t, const EnvelopedData *, ASN1EXP int ASN1CALL decode_EnvelopedData(const unsigned char *, size_t,
size_t *); EnvelopedData *, size_t *);
int decode_EnvelopedData(const unsigned char *, size_t, EnvelopedData *, ASN1EXP int ASN1CALL encode_EnvelopedData(unsigned char *, size_t, const
size_t *); EnvelopedData *, size_t *);
void free_EnvelopedData (EnvelopedData *); ASN1EXP size_t ASN1CALL length_EnvelopedData(const EnvelopedData *);
size_t length_EnvelopedData(const EnvelopedData *); ASN1EXP int ASN1CALL copy_EnvelopedData (const EnvelopedData *, Envelop
int copy_EnvelopedData (const EnvelopedData *, EnvelopedData *); edData *);
ASN1EXP void ASN1CALL free_EnvelopedData (EnvelopedData *);
/* /*
CMSRC2CBCParameter ::= SEQUENCE { CMSRC2CBCParameter ::= SEQUENCE {
rc2ParameterVersion INTEGER (0..2147483647), rc2ParameterVersion INTEGER (0..2147483647),
iv OCTET STRING, iv OCTET STRING,
} }
*/ */
typedef struct CMSRC2CBCParameter { typedef struct CMSRC2CBCParameter {
unsigned int rc2ParameterVersion; unsigned int rc2ParameterVersion;
heim_octet_string iv; heim_octet_string iv;
} CMSRC2CBCParameter; } CMSRC2CBCParameter;
int encode_CMSRC2CBCParameter(unsigned char *, size_t, const CMSRC2CBCPa ASN1EXP int ASN1CALL decode_CMSRC2CBCParameter(const unsigned char *, si
rameter *, size_t *); ze_t, CMSRC2CBCParameter *, size_t *);
int decode_CMSRC2CBCParameter(const unsigned char *, size_t, CMSRC2CBCPa ASN1EXP int ASN1CALL encode_CMSRC2CBCParameter(unsigned char *, size_t,
rameter *, size_t *); const CMSRC2CBCParameter *, size_t *);
void free_CMSRC2CBCParameter (CMSRC2CBCParameter *); ASN1EXP size_t ASN1CALL length_CMSRC2CBCParameter(const CMSRC2CBCParameter
size_t length_CMSRC2CBCParameter(const CMSRC2CBCParameter *); *);
int copy_CMSRC2CBCParameter (const CMSRC2CBCParameter *, CMSRC2CBCParam ASN1EXP int ASN1CALL copy_CMSRC2CBCParameter (const CMSRC2CBCParameter
eter *); *, CMSRC2CBCParameter *);
ASN1EXP void ASN1CALL free_CMSRC2CBCParameter (CMSRC2CBCParameter *);
/* /*
CMSCBCParameter ::= OCTET STRING CMSCBCParameter ::= OCTET STRING
*/ */
typedef heim_octet_string CMSCBCParameter; typedef heim_octet_string CMSCBCParameter;
int encode_CMSCBCParameter(unsigned char *, size_t, const CMSCBCParamete ASN1EXP int ASN1CALL decode_CMSCBCParameter(const unsigned char *, size_
r *, size_t *); t, CMSCBCParameter *, size_t *);
int decode_CMSCBCParameter(const unsigned char *, size_t, CMSCBCParamete ASN1EXP int ASN1CALL encode_CMSCBCParameter(unsigned char *, size_t, con
r *, size_t *); st CMSCBCParameter *, size_t *);
void free_CMSCBCParameter (CMSCBCParameter *); ASN1EXP size_t ASN1CALL length_CMSCBCParameter(const CMSCBCParameter *);
size_t length_CMSCBCParameter(const CMSCBCParameter *); ASN1EXP int ASN1CALL copy_CMSCBCParameter (const CMSCBCParameter *, CMS
int copy_CMSCBCParameter (const CMSCBCParameter *, CMSCBCParameter *); CBCParameter *);
ASN1EXP void ASN1CALL free_CMSCBCParameter (CMSCBCParameter *);
#endif /* __cms_asn1_h__ */ #endif /* __cms_asn1_h__ */
 End of changes. 55 change blocks. 
274 lines changed or deleted 325 lines changed or added


 com_err.h   com_err.h 
skipping to change at line 48 skipping to change at line 48
#ifndef __COM_ERR_H__ #ifndef __COM_ERR_H__
#define __COM_ERR_H__ #define __COM_ERR_H__
#include <com_right.h> #include <com_right.h>
#include <stdarg.h> #include <stdarg.h>
#if !defined(__GNUC__) && !defined(__attribute__) #if !defined(__GNUC__) && !defined(__attribute__)
#define __attribute__(X) #define __attribute__(X)
#endif #endif
typedef void (*errf) (const char *, long, const char *, va_list); #ifndef KRB5_LIB
#ifndef KRB5_LIB_FUNCTION
#if defined(_WIN32)
#define KRB5_LIB_FUNCTION __declspec(dllimport)
#define KRB5_LIB_CALL __stdcall
#define KRB5_LIB_VARIABLE __declspec(dllimport)
#else
#define KRB5_LIB_FUNCTION
#define KRB5_LIB_CALL
#define KRB5_LIB_VARIABLE
#endif
#endif
#endif
#ifdef _WIN32
#define KRB5_CALLCONV __stdcall
#else
#define KRB5_CALLCONV
#endif
typedef void (KRB5_CALLCONV *errf) (const char *, long, const char *, va_li
st);
const char * error_message (long); KRB5_LIB_FUNCTION const char * KRB5_LIB_CALL
int init_error_table (const char**, long, int); error_message (long);
void com_err_va (const char *, long, const char *, va_list) KRB5_LIB_FUNCTION int KRB5_LIB_CALL
init_error_table (const char**, long, int);
KRB5_LIB_FUNCTION void KRB5_LIB_CALL
com_err_va (const char *, long, const char *, va_list)
__attribute__((format(printf, 3, 0))); __attribute__((format(printf, 3, 0)));
void com_err (const char *, long, const char *, ...) KRB5_LIB_FUNCTION void KRB5_LIB_CALL
com_err (const char *, long, const char *, ...)
__attribute__((format(printf, 3, 4))); __attribute__((format(printf, 3, 4)));
errf set_com_err_hook (errf); KRB5_LIB_FUNCTION errf KRB5_LIB_CALL
errf reset_com_err_hook (void); set_com_err_hook (errf);
KRB5_LIB_FUNCTION errf KRB5_LIB_CALL
reset_com_err_hook (void);
const char *error_table_name (int num); KRB5_LIB_FUNCTION const char * KRB5_LIB_CALL
error_table_name (int num);
void add_to_error_table (struct et_list *new_table); KRB5_LIB_FUNCTION void KRB5_LIB_CALL
add_to_error_table (struct et_list *new_table);
#endif /* __COM_ERR_H__ */ #endif /* __COM_ERR_H__ */
 End of changes. 7 change blocks. 
9 lines changed or deleted 40 lines changed or added


 der-protos.h   der-protos.h 
skipping to change at line 51 skipping to change at line 51
der_copy_bmp_string ( der_copy_bmp_string (
const heim_bmp_string */*from*/, const heim_bmp_string */*from*/,
heim_bmp_string */*to*/); heim_bmp_string */*to*/);
int int
der_copy_general_string ( der_copy_general_string (
const heim_general_string */*from*/, const heim_general_string */*from*/,
heim_general_string */*to*/); heim_general_string */*to*/);
int int
der_copy_generalized_time (
const time_t */*from*/,
time_t */*to*/);
int
der_copy_heim_integer ( der_copy_heim_integer (
const heim_integer */*from*/, const heim_integer */*from*/,
heim_integer */*to*/); heim_integer */*to*/);
int int
der_copy_ia5_string ( der_copy_ia5_string (
const heim_printable_string */*from*/, const heim_ia5_string */*from*/,
heim_printable_string */*to*/); heim_ia5_string */*to*/);
int
der_copy_integer (
const int */*from*/,
int */*to*/);
int int
der_copy_octet_string ( der_copy_octet_string (
const heim_octet_string */*from*/, const heim_octet_string */*from*/,
heim_octet_string */*to*/); heim_octet_string */*to*/);
int int
der_copy_oid ( der_copy_oid (
const heim_oid */*from*/, const heim_oid */*from*/,
heim_oid */*to*/); heim_oid */*to*/);
skipping to change at line 81 skipping to change at line 91
der_copy_printable_string ( der_copy_printable_string (
const heim_printable_string */*from*/, const heim_printable_string */*from*/,
heim_printable_string */*to*/); heim_printable_string */*to*/);
int int
der_copy_universal_string ( der_copy_universal_string (
const heim_universal_string */*from*/, const heim_universal_string */*from*/,
heim_universal_string */*to*/); heim_universal_string */*to*/);
int int
der_copy_unsigned (
const unsigned */*from*/,
unsigned */*to*/);
int
der_copy_utctime (
const time_t */*from*/,
time_t */*to*/);
int
der_copy_utf8string ( der_copy_utf8string (
const heim_utf8_string */*from*/, const heim_utf8_string */*from*/,
heim_utf8_string */*to*/); heim_utf8_string */*to*/);
int int
der_copy_visible_string ( der_copy_visible_string (
const heim_visible_string */*from*/, const heim_visible_string */*from*/,
heim_visible_string */*to*/); heim_visible_string */*to*/);
void void
der_free_bit_string (heim_bit_string */*k*/); der_free_bit_string (heim_bit_string */*k*/);
void void
der_free_bmp_string (heim_bmp_string */*k*/); der_free_bmp_string (heim_bmp_string */*k*/);
void void
der_free_general_string (heim_general_string */*str*/); der_free_general_string (heim_general_string */*str*/);
void void
der_free_generalized_time (time_t */*t*/);
void
der_free_heim_integer (heim_integer */*k*/); der_free_heim_integer (heim_integer */*k*/);
void void
der_free_ia5_string (heim_ia5_string */*str*/); der_free_ia5_string (heim_ia5_string */*str*/);
void void
der_free_integer (int */*i*/);
void
der_free_octet_string (heim_octet_string */*k*/); der_free_octet_string (heim_octet_string */*k*/);
void void
der_free_oid (heim_oid */*k*/); der_free_oid (heim_oid */*k*/);
void void
der_free_printable_string (heim_printable_string */*str*/); der_free_printable_string (heim_printable_string */*str*/);
void void
der_free_universal_string (heim_universal_string */*k*/); der_free_universal_string (heim_universal_string */*k*/);
void void
der_free_unsigned (unsigned */*u*/);
void
der_free_utctime (time_t */*t*/);
void
der_free_utf8string (heim_utf8_string */*str*/); der_free_utf8string (heim_utf8_string */*str*/);
void void
der_free_visible_string (heim_visible_string */*str*/); der_free_visible_string (heim_visible_string */*str*/);
int int
der_get_bit_string ( der_get_bit_string (
const unsigned char */*p*/, const unsigned char */*p*/,
size_t /*len*/, size_t /*len*/,
heim_bit_string */*data*/, heim_bit_string */*data*/,
skipping to change at line 306 skipping to change at line 338
int int
der_heim_oid_cmp ( der_heim_oid_cmp (
const heim_oid */*p*/, const heim_oid */*p*/,
const heim_oid */*q*/); const heim_oid */*q*/);
int int
der_heim_universal_string_cmp ( der_heim_universal_string_cmp (
const heim_universal_string */*p*/, const heim_universal_string */*p*/,
const heim_universal_string */*q*/); const heim_universal_string */*q*/);
int
der_ia5_string_cmp (
const heim_ia5_string */*p*/,
const heim_ia5_string */*q*/);
size_t size_t
der_length_bit_string (const heim_bit_string */*k*/); der_length_bit_string (const heim_bit_string */*k*/);
size_t size_t
der_length_bmp_string (const heim_bmp_string */*data*/); der_length_bmp_string (const heim_bmp_string */*data*/);
size_t size_t
der_length_boolean (const int */*k*/); der_length_boolean (const int */*k*/);
size_t size_t
skipping to change at line 346 skipping to change at line 383
size_t size_t
der_length_octet_string (const heim_octet_string */*k*/); der_length_octet_string (const heim_octet_string */*k*/);
size_t size_t
der_length_oid (const heim_oid */*k*/); der_length_oid (const heim_oid */*k*/);
size_t size_t
der_length_printable_string (const heim_printable_string */*data*/); der_length_printable_string (const heim_printable_string */*data*/);
size_t size_t
der_length_tag (unsigned int /*tag*/);
size_t
der_length_universal_string (const heim_universal_string */*data*/); der_length_universal_string (const heim_universal_string */*data*/);
size_t size_t
der_length_unsigned (const unsigned */*data*/); der_length_unsigned (const unsigned */*data*/);
size_t size_t
der_length_utctime (const time_t */*t*/); der_length_utctime (const time_t */*t*/);
size_t size_t
der_length_utf8string (const heim_utf8_string */*data*/); der_length_utf8string (const heim_utf8_string */*data*/);
skipping to change at line 411 skipping to change at line 451
const heim_oid */*oid*/, const heim_oid */*oid*/,
char /*delim*/, char /*delim*/,
char **/*str*/); char **/*str*/);
int int
der_print_hex_heim_integer ( der_print_hex_heim_integer (
const heim_integer */*data*/, const heim_integer */*data*/,
char **/*p*/); char **/*p*/);
int int
der_printable_string_cmp (
const heim_printable_string */*p*/,
const heim_printable_string */*q*/);
int
der_put_bit_string ( der_put_bit_string (
unsigned char */*p*/, unsigned char */*p*/,
size_t /*len*/, size_t /*len*/,
const heim_bit_string */*data*/, const heim_bit_string */*data*/,
size_t */*size*/); size_t */*size*/);
int int
der_put_bmp_string ( der_put_bmp_string (
unsigned char */*p*/, unsigned char */*p*/,
size_t /*len*/, size_t /*len*/,
 End of changes. 9 change blocks. 
2 lines changed or deleted 47 lines changed or added


 der.h   der.h 
skipping to change at line 97 skipping to change at line 97
time_t dt_sec; time_t dt_sec;
unsigned long dt_nsec; unsigned long dt_nsec;
} heim_der_time_t; } heim_der_time_t;
typedef struct heim_ber_time_t { typedef struct heim_ber_time_t {
time_t bt_sec; time_t bt_sec;
unsigned bt_nsec; unsigned bt_nsec;
int bt_zone; int bt_zone;
} heim_ber_time_t; } heim_ber_time_t;
struct asn1_template;
#include <der-protos.h> #include <der-protos.h>
int _heim_fix_dce(size_t reallen, size_t *len); int _heim_fix_dce(size_t reallen, size_t *len);
int _heim_der_set_sort(const void *, const void *); int _heim_der_set_sort(const void *, const void *);
int _heim_time2generalizedtime (time_t, heim_octet_string *, int); int _heim_time2generalizedtime (time_t, heim_octet_string *, int);
#endif /* __DER_H__ */ #endif /* __DER_H__ */
 End of changes. 1 change blocks. 
0 lines changed or deleted 2 lines changed or added


 digest_asn1.h   digest_asn1.h 
skipping to change at line 28 skipping to change at line 28
typedef struct heim_octet_string { typedef struct heim_octet_string {
size_t length; size_t length;
void *data; void *data;
} heim_octet_string; } heim_octet_string;
typedef char *heim_general_string; typedef char *heim_general_string;
typedef char *heim_utf8_string; typedef char *heim_utf8_string;
typedef char *heim_printable_string; typedef struct heim_octet_string heim_printable_string;
typedef char *heim_ia5_string; typedef struct heim_octet_string heim_ia5_string;
typedef struct heim_bmp_string { typedef struct heim_bmp_string {
size_t length; size_t length;
uint16_t *data; uint16_t *data;
} heim_bmp_string; } heim_bmp_string;
typedef struct heim_universal_string { typedef struct heim_universal_string {
size_t length; size_t length;
uint32_t *data; uint32_t *data;
} heim_universal_string; } heim_universal_string;
skipping to change at line 73 skipping to change at line 73
} else { \ } else { \
(R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
(S), (L)); \ (S), (L)); \
if((R) != 0) { \ if((R) != 0) { \
free((B)); \ free((B)); \
(B) = NULL; \ (B) = NULL; \
} \ } \
} \ } \
} while (0) } while (0)
#ifdef _WIN32
#ifndef ASN1_LIB
#define ASN1EXP __declspec(dllimport)
#else
#define ASN1EXP
#endif
#define ASN1CALL __stdcall
#else
#define ASN1EXP
#define ASN1CALL
#endif
struct units; struct units;
#endif #endif
#include <krb5_asn1.h> #include <krb5_asn1.h>
/* /*
DigestTypes ::= BIT STRING { DigestTypes ::= BIT STRING {
ntlm-v1(0), ntlm-v1(0),
ntlm-v1-session(1), ntlm-v1-session(1),
ntlm-v2(2), ntlm-v2(2),
skipping to change at line 96 skipping to change at line 107
} }
*/ */
typedef struct DigestTypes { typedef struct DigestTypes {
unsigned int ntlm_v1:1; unsigned int ntlm_v1:1;
unsigned int ntlm_v1_session:1; unsigned int ntlm_v1_session:1;
unsigned int ntlm_v2:1; unsigned int ntlm_v2:1;
unsigned int digest_md5:1; unsigned int digest_md5:1;
unsigned int chap_md5:1; unsigned int chap_md5:1;
unsigned int ms_chap_v2:1; unsigned int ms_chap_v2: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;
} DigestTypes; } DigestTypes;
int encode_DigestTypes(unsigned char *, size_t, const DigestTypes *, siz
e_t *);
int decode_DigestTypes(const unsigned char *, size_t, DigestTypes *, siz
e_t *);
void free_DigestTypes (DigestTypes *);
size_t length_DigestTypes(const DigestTypes *);
int copy_DigestTypes (const DigestTypes *, DigestTypes *);
unsigned DigestTypes2int(DigestTypes); unsigned DigestTypes2int(DigestTypes);
DigestTypes int2DigestTypes(unsigned); DigestTypes int2DigestTypes(unsigned);
const struct units * asn1_DigestTypes_units(void); const struct units * asn1_DigestTypes_units(void);
ASN1EXP int ASN1CALL decode_DigestTypes(const unsigned char *, size_t, D
igestTypes *, size_t *);
ASN1EXP int ASN1CALL encode_DigestTypes(unsigned char *, size_t, const D
igestTypes *, size_t *);
ASN1EXP size_t ASN1CALL length_DigestTypes(const DigestTypes *);
ASN1EXP int ASN1CALL copy_DigestTypes (const DigestTypes *, DigestTypes
*);
ASN1EXP void ASN1CALL free_DigestTypes (DigestTypes *);
/* /*
DigestInit ::= SEQUENCE { DigestInit ::= SEQUENCE {
type UTF8String, type UTF8String,
channel [0] SEQUENCE { channel [0] SEQUENCE {
cb-type UTF8String, cb-type UTF8String,
cb-binding UTF8String, cb-binding UTF8String,
} OPTIONAL, } OPTIONAL,
hostname [1] UTF8String OPTIONAL, hostname [1] UTF8String OPTIONAL,
} }
*/ */
typedef struct DigestInit { typedef struct DigestInit {
heim_utf8_string type; heim_utf8_string type;
struct { struct DigestInit_channel {
heim_utf8_string cb_type; heim_utf8_string cb_type;
heim_utf8_string cb_binding; heim_utf8_string cb_binding;
} *channel; } *channel;
heim_utf8_string *hostname; heim_utf8_string *hostname;
} DigestInit; } DigestInit;
int encode_DigestInit(unsigned char *, size_t, const DigestInit *, size_ ASN1EXP int ASN1CALL decode_DigestInit(const unsigned char *, size_t, Di
t *); gestInit *, size_t *);
int decode_DigestInit(const unsigned char *, size_t, DigestInit *, size_ ASN1EXP int ASN1CALL encode_DigestInit(unsigned char *, size_t, const Di
t *); gestInit *, size_t *);
void free_DigestInit (DigestInit *); ASN1EXP size_t ASN1CALL length_DigestInit(const DigestInit *);
size_t length_DigestInit(const DigestInit *); ASN1EXP int ASN1CALL copy_DigestInit (const DigestInit *, DigestInit *)
int copy_DigestInit (const DigestInit *, DigestInit *); ;
ASN1EXP void ASN1CALL free_DigestInit (DigestInit *);
/* /*
DigestInitReply ::= SEQUENCE { DigestInitReply ::= SEQUENCE {
nonce UTF8String, nonce UTF8String,
opaque UTF8String, opaque UTF8String,
identifier [0] UTF8String OPTIONAL, identifier [0] UTF8String OPTIONAL,
} }
*/ */
typedef struct DigestInitReply { typedef struct DigestInitReply {
heim_utf8_string nonce; heim_utf8_string nonce;
heim_utf8_string opaque; heim_utf8_string opaque;
heim_utf8_string *identifier; heim_utf8_string *identifier;
} DigestInitReply; } DigestInitReply;
int encode_DigestInitReply(unsigned char *, size_t, const DigestInitRepl ASN1EXP int ASN1CALL decode_DigestInitReply(const unsigned char *, size_
y *, size_t *); t, DigestInitReply *, size_t *);
int decode_DigestInitReply(const unsigned char *, size_t, DigestInitRepl ASN1EXP int ASN1CALL encode_DigestInitReply(unsigned char *, size_t, con
y *, size_t *); st DigestInitReply *, size_t *);
void free_DigestInitReply (DigestInitReply *); ASN1EXP size_t ASN1CALL length_DigestInitReply(const DigestInitReply *);
size_t length_DigestInitReply(const DigestInitReply *); ASN1EXP int ASN1CALL copy_DigestInitReply (const DigestInitReply *, Dig
int copy_DigestInitReply (const DigestInitReply *, DigestInitReply *); estInitReply *);
ASN1EXP void ASN1CALL free_DigestInitReply (DigestInitReply *);
/* /*
DigestRequest ::= SEQUENCE { DigestRequest ::= SEQUENCE {
type UTF8String, type UTF8String,
digest UTF8String, digest UTF8String,
username UTF8String, username UTF8String,
responseData UTF8String, responseData UTF8String,
authid [0] UTF8String OPTIONAL, authid [0] UTF8String OPTIONAL,
authentication-user [1] Principal OPTIONAL, authentication-user [1] Principal OPTIONAL,
realm [2] UTF8String OPTIONAL, realm [2] UTF8String OPTIONAL,
skipping to change at line 193 skipping to change at line 230
heim_utf8_string *uri; heim_utf8_string *uri;
heim_utf8_string serverNonce; heim_utf8_string serverNonce;
heim_utf8_string *clientNonce; heim_utf8_string *clientNonce;
heim_utf8_string *nonceCount; heim_utf8_string *nonceCount;
heim_utf8_string *qop; heim_utf8_string *qop;
heim_utf8_string *identifier; heim_utf8_string *identifier;
heim_utf8_string *hostname; heim_utf8_string *hostname;
heim_utf8_string opaque; heim_utf8_string opaque;
} DigestRequest; } DigestRequest;
int encode_DigestRequest(unsigned char *, size_t, const DigestRequest *, ASN1EXP int ASN1CALL decode_DigestRequest(const unsigned char *, size_t,
size_t *); DigestRequest *, size_t *);
int decode_DigestRequest(const unsigned char *, size_t, DigestRequest *, ASN1EXP int ASN1CALL encode_DigestRequest(unsigned char *, size_t, const
size_t *); DigestRequest *, size_t *);
void free_DigestRequest (DigestRequest *); ASN1EXP size_t ASN1CALL length_DigestRequest(const DigestRequest *);
size_t length_DigestRequest(const DigestRequest *); ASN1EXP int ASN1CALL copy_DigestRequest (const DigestRequest *, DigestR
int copy_DigestRequest (const DigestRequest *, DigestRequest *); equest *);
ASN1EXP void ASN1CALL free_DigestRequest (DigestRequest *);
/* /*
DigestError ::= SEQUENCE { DigestError ::= SEQUENCE {
reason UTF8String, reason UTF8String,
code INTEGER (-2147483648..2147483647), code INTEGER (-2147483648..2147483647),
} }
*/ */
typedef struct DigestError { typedef struct DigestError {
heim_utf8_string reason; heim_utf8_string reason;
int code; int code;
} DigestError; } DigestError;
int encode_DigestError(unsigned char *, size_t, const DigestError *, siz ASN1EXP int ASN1CALL decode_DigestError(const unsigned char *, size_t, D
e_t *); igestError *, size_t *);
int decode_DigestError(const unsigned char *, size_t, DigestError *, siz ASN1EXP int ASN1CALL encode_DigestError(unsigned char *, size_t, const D
e_t *); igestError *, size_t *);
void free_DigestError (DigestError *); ASN1EXP size_t ASN1CALL length_DigestError(const DigestError *);
size_t length_DigestError(const DigestError *); ASN1EXP int ASN1CALL copy_DigestError (const DigestError *, DigestError
int copy_DigestError (const DigestError *, DigestError *); *);
ASN1EXP void ASN1CALL free_DigestError (DigestError *);
/* /*
DigestResponse ::= SEQUENCE { DigestResponse ::= SEQUENCE {
success BOOLEAN, success BOOLEAN,
rsp [0] UTF8String OPTIONAL, rsp [0] UTF8String OPTIONAL,
tickets [1] SEQUENCE OF OCTET STRING OPTIONAL, tickets [1] SEQUENCE OF OCTET STRING OPTIONAL,
channel [2] SEQUENCE { channel [2] SEQUENCE {
cb-type UTF8String, cb-type UTF8String,
cb-binding UTF8String, cb-binding UTF8String,
} OPTIONAL, } OPTIONAL,
session-key [3] OCTET STRING OPTIONAL, session-key [3] OCTET STRING OPTIONAL,
} }
*/ */
typedef struct DigestResponse { typedef struct DigestResponse {
int success; int success;
heim_utf8_string *rsp; heim_utf8_string *rsp;
struct { struct DigestResponse_tickets {
unsigned int len; unsigned int len;
heim_octet_string *val; heim_octet_string *val;
} *tickets; } *tickets;
struct { struct DigestResponse_channel {
heim_utf8_string cb_type; heim_utf8_string cb_type;
heim_utf8_string cb_binding; heim_utf8_string cb_binding;
} *channel; } *channel;
heim_octet_string *session_key; heim_octet_string *session_key;
} DigestResponse; } DigestResponse;
int encode_DigestResponse(unsigned char *, size_t, const DigestResponse ASN1EXP int ASN1CALL decode_DigestResponse(const unsigned char *, size_t
*, size_t *); , DigestResponse *, size_t *);
int decode_DigestResponse(const unsigned char *, size_t, DigestResponse ASN1EXP int ASN1CALL encode_DigestResponse(unsigned char *, size_t, cons
*, size_t *); t DigestResponse *, size_t *);
void free_DigestResponse (DigestResponse *); ASN1EXP size_t ASN1CALL length_DigestResponse(const DigestResponse *);
size_t length_DigestResponse(const DigestResponse *); ASN1EXP int ASN1CALL copy_DigestResponse (const DigestResponse *, Diges
int copy_DigestResponse (const DigestResponse *, DigestResponse *); tResponse *);
ASN1EXP void ASN1CALL free_DigestResponse (DigestResponse *);
/* /*
NTLMInit ::= SEQUENCE { NTLMInit ::= SEQUENCE {
flags [0] INTEGER (0..2147483647), flags [0] INTEGER (0..2147483647),
hostname [1] UTF8String OPTIONAL, hostname [1] UTF8String OPTIONAL,
domain [1] UTF8String OPTIONAL, domain [1] UTF8String OPTIONAL,
} }
*/ */
typedef struct NTLMInit { typedef struct NTLMInit {
unsigned int flags; unsigned int flags;
heim_utf8_string *hostname; heim_utf8_string *hostname;
heim_utf8_string *domain; heim_utf8_string *domain;
} NTLMInit; } NTLMInit;
int encode_NTLMInit(unsigned char *, size_t, const NTLMInit *, size_t *) ASN1EXP int ASN1CALL decode_NTLMInit(const unsigned char *, size_t, NTLM
; Init *, size_t *);
int decode_NTLMInit(const unsigned char *, size_t, NTLMInit *, size_t *) ASN1EXP int ASN1CALL encode_NTLMInit(unsigned char *, size_t, const NTLM
; Init *, size_t *);
void free_NTLMInit (NTLMInit *); ASN1EXP size_t ASN1CALL length_NTLMInit(const NTLMInit *);
size_t length_NTLMInit(const NTLMInit *); ASN1EXP int ASN1CALL copy_NTLMInit (const NTLMInit *, NTLMInit *);
int copy_NTLMInit (const NTLMInit *, NTLMInit *); ASN1EXP void ASN1CALL free_NTLMInit (NTLMInit *);
/* /*
NTLMInitReply ::= SEQUENCE { NTLMInitReply ::= SEQUENCE {
flags [0] INTEGER (0..2147483647), flags [0] INTEGER (0..2147483647),
opaque [1] OCTET STRING, opaque [1] OCTET STRING,
targetname [2] UTF8String, targetname [2] UTF8String,
challange [3] OCTET STRING, challange [3] OCTET STRING,
targetinfo [4] OCTET STRING OPTIONAL, targetinfo [4] OCTET STRING OPTIONAL,
} }
*/ */
typedef struct NTLMInitReply { typedef struct NTLMInitReply {
unsigned int flags; unsigned int flags;
heim_octet_string opaque; heim_octet_string opaque;
heim_utf8_string targetname; heim_utf8_string targetname;
heim_octet_string challange; heim_octet_string challange;
heim_octet_string *targetinfo; heim_octet_string *targetinfo;
} NTLMInitReply; } NTLMInitReply;
int encode_NTLMInitReply(unsigned char *, size_t, const NTLMInitReply *, ASN1EXP int ASN1CALL decode_NTLMInitReply(const unsigned char *, size_t,
size_t *); NTLMInitReply *, size_t *);
int decode_NTLMInitReply(const unsigned char *, size_t, NTLMInitReply *, ASN1EXP int ASN1CALL encode_NTLMInitReply(unsigned char *, size_t, const
size_t *); NTLMInitReply *, size_t *);
void free_NTLMInitReply (NTLMInitReply *); ASN1EXP size_t ASN1CALL length_NTLMInitReply(const NTLMInitReply *);
size_t length_NTLMInitReply(const NTLMInitReply *); ASN1EXP int ASN1CALL copy_NTLMInitReply (const NTLMInitReply *, NTLMIni
int copy_NTLMInitReply (const NTLMInitReply *, NTLMInitReply *); tReply *);
ASN1EXP void ASN1CALL free_NTLMInitReply (NTLMInitReply *);
/* /*
NTLMRequest ::= SEQUENCE { NTLMRequest ::= SEQUENCE {
flags [0] INTEGER (0..2147483647), flags [0] INTEGER (0..2147483647),
opaque [1] OCTET STRING, opaque [1] OCTET STRING,
username [2] UTF8String, username [2] UTF8String,
targetname [3] UTF8String, targetname [3] UTF8String,
targetinfo [4] OCTET STRING OPTIONAL, targetinfo [4] OCTET STRING OPTIONAL,
lm [5] OCTET STRING, lm [5] OCTET STRING,
ntlm [6] OCTET STRING, ntlm [6] OCTET STRING,
skipping to change at line 318 skipping to change at line 355
unsigned int flags; unsigned int flags;
heim_octet_string opaque; heim_octet_string opaque;
heim_utf8_string username; heim_utf8_string username;
heim_utf8_string targetname; heim_utf8_string targetname;
heim_octet_string *targetinfo; heim_octet_string *targetinfo;
heim_octet_string lm; heim_octet_string lm;
heim_octet_string ntlm; heim_octet_string ntlm;
heim_octet_string *sessionkey; heim_octet_string *sessionkey;
} NTLMRequest; } NTLMRequest;
int encode_NTLMRequest(unsigned char *, size_t, const NTLMRequest *, siz ASN1EXP int ASN1CALL decode_NTLMRequest(const unsigned char *, size_t, N
e_t *); TLMRequest *, size_t *);
int decode_NTLMRequest(const unsigned char *, size_t, NTLMRequest *, siz ASN1EXP int ASN1CALL encode_NTLMRequest(unsigned char *, size_t, const N
e_t *); TLMRequest *, size_t *);
void free_NTLMRequest (NTLMRequest *); ASN1EXP size_t ASN1CALL length_NTLMRequest(const NTLMRequest *);
size_t length_NTLMRequest(const NTLMRequest *); ASN1EXP int ASN1CALL copy_NTLMRequest (const NTLMRequest *, NTLMRequest
int copy_NTLMRequest (const NTLMRequest *, NTLMRequest *); *);
ASN1EXP void ASN1CALL free_NTLMRequest (NTLMRequest *);
/* /*
NTLMResponse ::= SEQUENCE { NTLMResponse ::= SEQUENCE {
success [0] BOOLEAN, success [0] BOOLEAN,
flags [1] INTEGER (0..2147483647), flags [1] INTEGER (0..2147483647),
sessionkey [2] OCTET STRING OPTIONAL, sessionkey [2] OCTET STRING OPTIONAL,
tickets [3] SEQUENCE OF OCTET STRING OPTIONAL, tickets [3] SEQUENCE OF OCTET STRING OPTIONAL,
} }
*/ */
typedef struct NTLMResponse { typedef struct NTLMResponse {
int success; int success;
unsigned int flags; unsigned int flags;
heim_octet_string *sessionkey; heim_octet_string *sessionkey;
struct { struct NTLMResponse_tickets {
unsigned int len; unsigned int len;
heim_octet_string *val; heim_octet_string *val;
} *tickets; } *tickets;
} NTLMResponse; } NTLMResponse;
int encode_NTLMResponse(unsigned char *, size_t, const NTLMResponse *, s ASN1EXP int ASN1CALL decode_NTLMResponse(const unsigned char *, size_t,
ize_t *); NTLMResponse *, size_t *);
int decode_NTLMResponse(const unsigned char *, size_t, NTLMResponse *, s ASN1EXP int ASN1CALL encode_NTLMResponse(unsigned char *, size_t, const
ize_t *); NTLMResponse *, size_t *);
void free_NTLMResponse (NTLMResponse *); ASN1EXP size_t ASN1CALL length_NTLMResponse(const NTLMResponse *);
size_t length_NTLMResponse(const NTLMResponse *); ASN1EXP int ASN1CALL copy_NTLMResponse (const NTLMResponse *, NTLMRespo
int copy_NTLMResponse (const NTLMResponse *, NTLMResponse *); nse *);
ASN1EXP void ASN1CALL free_NTLMResponse (NTLMResponse *);
/*
NTLMRequest2 ::= SEQUENCE {
loginUserName [0] UTF8String,
loginDomainName [1] UTF8String,
flags [2] INTEGER (0..2147483647),
lmchallenge [3] OCTET STRING,
ntChallengeResponce [4] OCTET STRING,
lmChallengeResponce [5] OCTET STRING,
}
*/
typedef struct NTLMRequest2 {
heim_utf8_string loginUserName;
heim_utf8_string loginDomainName;
unsigned int flags;
heim_octet_string lmchallenge;
heim_octet_string ntChallengeResponce;
heim_octet_string lmChallengeResponce;
} NTLMRequest2;
ASN1EXP int ASN1CALL decode_NTLMRequest2(const unsigned char *, size_t,
NTLMRequest2 *, size_t *);
ASN1EXP int ASN1CALL encode_NTLMRequest2(unsigned char *, size_t, const
NTLMRequest2 *, size_t *);
ASN1EXP size_t ASN1CALL length_NTLMRequest2(const NTLMRequest2 *);
ASN1EXP int ASN1CALL copy_NTLMRequest2 (const NTLMRequest2 *, NTLMReque
st2 *);
ASN1EXP void ASN1CALL free_NTLMRequest2 (NTLMRequest2 *);
/*
NTLMReply ::= SEQUENCE {
success [0] BOOLEAN,
flags [1] INTEGER (0..2147483647),
sessionkey [2] OCTET STRING OPTIONAL,
}
*/
typedef struct NTLMReply {
int success;
unsigned int flags;
heim_octet_string *sessionkey;
} NTLMReply;
ASN1EXP int ASN1CALL decode_NTLMReply(const unsigned char *, size_t, NTL
MReply *, size_t *);
ASN1EXP int ASN1CALL encode_NTLMReply(unsigned char *, size_t, const NTL
MReply *, size_t *);
ASN1EXP size_t ASN1CALL length_NTLMReply(const NTLMReply *);
ASN1EXP int ASN1CALL copy_NTLMReply (const NTLMReply *, NTLMReply *);
ASN1EXP void ASN1CALL free_NTLMReply (NTLMReply *);
/* /*
DigestReqInner ::= CHOICE { DigestReqInner ::= CHOICE {
init [0] DigestInit, init [0] DigestInit,
digestRequest [1] DigestRequest, digestRequest [1] DigestRequest,
ntlmInit [2] NTLMInit, ntlmInit [2] NTLMInit,
ntlmRequest [3] NTLMRequest, ntlmRequest [3] NTLMRequest,
supportedMechs [4] NULL, supportedMechs [4] NULL,
} }
*/ */
skipping to change at line 376 skipping to change at line 459
} element; } element;
union { union {
DigestInit init; DigestInit init;
DigestRequest digestRequest; DigestRequest digestRequest;
NTLMInit ntlmInit; NTLMInit ntlmInit;
NTLMRequest ntlmRequest; NTLMRequest ntlmRequest;
int supportedMechs; int supportedMechs;
} u; } u;
} DigestReqInner; } DigestReqInner;
int encode_DigestReqInner(unsigned char *, size_t, const DigestReqInner ASN1EXP int ASN1CALL decode_DigestReqInner(const unsigned char *, size_t
*, size_t *); , DigestReqInner *, size_t *);
int decode_DigestReqInner(const unsigned char *, size_t, DigestReqInner ASN1EXP int ASN1CALL encode_DigestReqInner(unsigned char *, size_t, cons
*, size_t *); t DigestReqInner *, size_t *);
void free_DigestReqInner (DigestReqInner *); ASN1EXP size_t ASN1CALL length_DigestReqInner(const DigestReqInner *);
size_t length_DigestReqInner(const DigestReqInner *); ASN1EXP int ASN1CALL copy_DigestReqInner (const DigestReqInner *, Diges
int copy_DigestReqInner (const DigestReqInner *, DigestReqInner *); tReqInner *);
ASN1EXP void ASN1CALL free_DigestReqInner (DigestReqInner *);
/* /*
DigestREQ ::= [APPLICATION 128] SEQUENCE { DigestREQ ::= [APPLICATION 128] SEQUENCE {
apReq [0] OCTET STRING, apReq [0] OCTET STRING,
innerReq [1] EncryptedData, innerReq [1] EncryptedData,
} }
*/ */
typedef struct DigestREQ { typedef struct DigestREQ {
heim_octet_string apReq; heim_octet_string apReq;
EncryptedData innerReq; EncryptedData innerReq;
} DigestREQ; } DigestREQ;
int encode_DigestREQ(unsigned char *, size_t, const DigestREQ *, size_t ASN1EXP int ASN1CALL decode_DigestREQ(const unsigned char *, size_t, Dig
*); estREQ *, size_t *);
int decode_DigestREQ(const unsigned char *, size_t, DigestREQ *, size_t ASN1EXP int ASN1CALL encode_DigestREQ(unsigned char *, size_t, const Dig
*); estREQ *, size_t *);
void free_DigestREQ (DigestREQ *); ASN1EXP size_t ASN1CALL length_DigestREQ(const DigestREQ *);
size_t length_DigestREQ(const DigestREQ *); ASN1EXP int ASN1CALL copy_DigestREQ (const DigestREQ *, DigestREQ *);
int copy_DigestREQ (const DigestREQ *, DigestREQ *); ASN1EXP void ASN1CALL free_DigestREQ (DigestREQ *);
/* /*
DigestRepInner ::= CHOICE { DigestRepInner ::= CHOICE {
error [0] DigestError, error [0] DigestError,
initReply [1] DigestInitReply, initReply [1] DigestInitReply,
response [2] DigestResponse, response [2] DigestResponse,
ntlmInitReply [3] NTLMInitReply, ntlmInitReply [3] NTLMInitReply,
ntlmResponse [4] NTLMResponse, ntlmResponse [4] NTLMResponse,
supportedMechs [5] DigestTypes, supportedMechs [5] DigestTypes,
..., ...,
skipping to change at line 434 skipping to change at line 517
DigestError error; DigestError error;
DigestInitReply initReply; DigestInitReply initReply;
DigestResponse response; DigestResponse response;
NTLMInitReply ntlmInitReply; NTLMInitReply ntlmInitReply;
NTLMResponse ntlmResponse; NTLMResponse ntlmResponse;
DigestTypes supportedMechs; DigestTypes supportedMechs;
heim_octet_string asn1_ellipsis; heim_octet_string asn1_ellipsis;
} u; } u;
} DigestRepInner; } DigestRepInner;
int encode_DigestRepInner(unsigned char *, size_t, const DigestRepInner ASN1EXP int ASN1CALL decode_DigestRepInner(const unsigned char *, size_t
*, size_t *); , DigestRepInner *, size_t *);
int decode_DigestRepInner(const unsigned char *, size_t, DigestRepInner ASN1EXP int ASN1CALL encode_DigestRepInner(unsigned char *, size_t, cons
*, size_t *); t DigestRepInner *, size_t *);
void free_DigestRepInner (DigestRepInner *); ASN1EXP size_t ASN1CALL length_DigestRepInner(const DigestRepInner *);
size_t length_DigestRepInner(const DigestRepInner *); ASN1EXP int ASN1CALL copy_DigestRepInner (const DigestRepInner *, Diges
int copy_DigestRepInner (const DigestRepInner *, DigestRepInner *); tRepInner *);
ASN1EXP void ASN1CALL free_DigestRepInner (DigestRepInner *);
/* /*
DigestREP ::= [APPLICATION 129] SEQUENCE { DigestREP ::= [APPLICATION 129] SEQUENCE {
apRep [0] OCTET STRING, apRep [0] OCTET STRING,
innerRep [1] EncryptedData, innerRep [1] EncryptedData,
} }
*/ */
typedef struct DigestREP { typedef struct DigestREP {
heim_octet_string apRep; heim_octet_string apRep;
EncryptedData innerRep; EncryptedData innerRep;
} DigestREP; } DigestREP;
int encode_DigestREP(unsigned char *, size_t, const DigestREP *, size_t ASN1EXP int ASN1CALL decode_DigestREP(const unsigned char *, size_t, Dig
*); estREP *, size_t *);
int decode_DigestREP(const unsigned char *, size_t, DigestREP *, size_t ASN1EXP int ASN1CALL encode_DigestREP(unsigned char *, size_t, const Dig
*); estREP *, size_t *);
void free_DigestREP (DigestREP *); ASN1EXP size_t ASN1CALL length_DigestREP(const DigestREP *);
size_t length_DigestREP(const DigestREP *); ASN1EXP int ASN1CALL copy_DigestREP (const DigestREP *, DigestREP *);
int copy_DigestREP (const DigestREP *, DigestREP *); ASN1EXP void ASN1CALL free_DigestREP (DigestREP *);
#endif /* __digest_asn1_h__ */ #endif /* __digest_asn1_h__ */
 End of changes. 23 change blocks. 
104 lines changed or deleted 203 lines changed or added


 getarg.h   getarg.h 
skipping to change at line 43 skipping to change at line 43
/* $Id$ */ /* $Id$ */
#ifndef __GETARG_H__ #ifndef __GETARG_H__
#define __GETARG_H__ #define __GETARG_H__
#include <stddef.h> #include <stddef.h>
#ifndef ROKEN_LIB_FUNCTION #ifndef ROKEN_LIB_FUNCTION
#ifdef _WIN32 #ifdef _WIN32
#define ROKEN_LIB_FUNCTION _stdcall #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL __cdecl
#else #else
#define ROKEN_LIB_FUNCTION #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL
#endif #endif
#endif #endif
struct getargs{ struct getargs{
const char *long_name; const char *long_name;
char short_name; char short_name;
enum { arg_integer, enum { arg_integer,
arg_string, arg_string,
arg_flag, arg_flag,
arg_negative_flag, arg_negative_flag,
skipping to change at line 89 skipping to change at line 91
char **argv, char **argv,
int *goptind, int *goptind,
int *goptarg, int *goptarg,
void *data); void *data);
typedef struct getarg_collect_info { typedef struct getarg_collect_info {
getarg_collect_func func; getarg_collect_func func;
void *data; void *data;
} getarg_collect_info; } getarg_collect_info;
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
getarg(struct getargs *args, size_t num_args, getarg(struct getargs *args, size_t num_args,
int argc, char **argv, int *goptind); int argc, char **argv, int *goptind);
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
arg_printusage (struct getargs *args, arg_printusage (struct getargs *args,
size_t num_args, size_t num_args,
const char *progname, const char *progname,
const char *extra_string); const char *extra_string);
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
arg_printusage_i18n (struct getargs *args, arg_printusage_i18n (struct getargs *args,
size_t num_args, size_t num_args,
const char *usage, const char *usage,
const char *progname, const char *progname,
const char *extra_string, const char *extra_string,
char *(i18n)(const char *)); char *(*i18n)(const char *));
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
free_getarg_strings (getarg_strings *); free_getarg_strings (getarg_strings *);
#endif /* __GETARG_H__ */ #endif /* __GETARG_H__ */
 End of changes. 7 change blocks. 
6 lines changed or deleted 8 lines changed or added


 glob.h   glob.h 
skipping to change at line 40 skipping to change at line 40
* SUCH DAMAGE. * SUCH DAMAGE.
* *
* @(#)glob.h 8.1 (Berkeley) 6/2/93 * @(#)glob.h 8.1 (Berkeley) 6/2/93
*/ */
#ifndef _GLOB_H_ #ifndef _GLOB_H_
#define _GLOB_H_ #define _GLOB_H_
#ifndef ROKEN_LIB_FUNCTION #ifndef ROKEN_LIB_FUNCTION
#ifdef _WIN32 #ifdef _WIN32
#define ROKEN_LIB_FUNCTION _stdcall #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL _stdcall
#else #else
#define ROKEN_LIB_FUNCTION #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL
#endif #endif
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define glob_t rk_glob_t #define glob_t rk_glob_t
#define glob rk_glob #define glob rk_glob
#define globfree rk_globfree #define globfree rk_globfree
 End of changes. 2 change blocks. 
1 lines changed or deleted 3 lines changed or added


 gssapi_krb5.h   gssapi_krb5.h 
skipping to change at line 55 skipping to change at line 55
#endif #endif
#ifndef GSSKRB5_FUNCTION_DEPRECATED #ifndef GSSKRB5_FUNCTION_DEPRECATED
#define GSSKRB5_FUNCTION_DEPRECATED __attribute__((deprecated)) #define GSSKRB5_FUNCTION_DEPRECATED __attribute__((deprecated))
#endif #endif
/* /*
* This is for kerberos5 names. * This is for kerberos5 names.
*/ */
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_NT_PRINCIPAL_NAME; extern gss_OID_desc GSSAPI_LIB_VARIABLE __gss_krb5_nt_principal_name_oid_de
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_NT_USER_NAME; sc;
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_NT_MACHINE_UID_NAME; #define GSS_KRB5_NT_PRINCIPAL_NAME (&__gss_krb5_nt_principal_name_oid_desc)
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_NT_STRING_UID_NAME;
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_MECHANISM; #define GSS_KRB5_NT_USER_NAME (&__gss_c_nt_user_name_oid_desc)
#define GSS_KRB5_NT_MACHINE_UID_NAME (&__gss_c_nt_machine_uid_name_oid_desc
)
#define GSS_KRB5_NT_STRING_UID_NAME (&__gss_c_nt_string_uid_name_oid_desc)
extern gss_OID_desc GSSAPI_LIB_VARIABLE __gss_krb5_mechanism_oid_desc;
#define GSS_KRB5_MECHANISM (&__gss_krb5_mechanism_oid_desc)
/* for compatibility with MIT api */ /* for compatibility with MIT api */
#define gss_mech_krb5 GSS_KRB5_MECHANISM #define gss_mech_krb5 GSS_KRB5_MECHANISM
#define gss_krb5_nt_general_name GSS_KRB5_NT_PRINCIPAL_NAME #define gss_krb5_nt_general_name GSS_KRB5_NT_PRINCIPAL_NAME
/* Extensions set contexts options */ /* Extensions set contexts options */
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_COPY_CCACHE_X; extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_copy_ccache_x_oid_desc;
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_COMPAT_DES3_MIC_X; #define GSS_KRB5_COPY_CCACHE_X (&__gss_krb5_copy_ccache_x_oid_desc)
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_REGISTER_ACCEPTOR_IDENTITY_X;
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_SET_DNS_CANONICALIZE_X; extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_compat_des3_mic_x_oid_de
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_SEND_TO_KDC_X; sc;
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_SET_DEFAULT_REALM_X; #define GSS_KRB5_COMPAT_DES3_MIC_X (&__gss_krb5_compat_des3_mic_x_oid_desc)
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_CCACHE_NAME_X;
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_SET_TIME_OFFSET_X; extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_register_acceptor_identi
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_GET_TIME_OFFSET_X; ty_x_oid_desc;
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_PLUGIN_REGISTER_X; #define GSS_KRB5_REGISTER_ACCEPTOR_IDENTITY_X (&__gss_krb5_register_accepto
r_identity_x_oid_desc)
extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_set_dns_canonicalize_x_o
id_desc;
#define GSS_KRB5_SET_DNS_CANONICALIZE_X (&__gss_krb5_set_dns_canonicalize_x
_oid_desc)
extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_send_to_kdc_x_oid_desc;
#define GSS_KRB5_SEND_TO_KDC_X (&__gss_krb5_send_to_kdc_x_oid_desc)
extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_set_default_realm_x_oid_
desc;
#define GSS_KRB5_SET_DEFAULT_REALM_X (&__gss_krb5_set_default_realm_x_oid_d
esc)
extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_ccache_name_x_oid_desc;
#define GSS_KRB5_CCACHE_NAME_X (&__gss_krb5_ccache_name_x_oid_desc)
extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_set_time_offset_x_oid_de
sc;
#define GSS_KRB5_SET_TIME_OFFSET_X (&__gss_krb5_set_time_offset_x_oid_desc)
extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_get_time_offset_x_oid_de
sc;
#define GSS_KRB5_GET_TIME_OFFSET_X (&__gss_krb5_get_time_offset_x_oid_desc)
extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_plugin_register_x_oid_de
sc;
#define GSS_KRB5_PLUGIN_REGISTER_X (&__gss_krb5_plugin_register_x_oid_desc)
/* Extensions inquire context */ /* Extensions inquire context */
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_GET_TKT_FLAGS_X; extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_get_tkt_flags_x_oid_desc
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_EXTRACT_AUTHZ_DATA_FROM_SEC_CON ;
TEXT_X; #define GSS_KRB5_GET_TKT_FLAGS_X (&__gss_krb5_get_tkt_flags_x_oid_desc)
extern GSSAPI_LIB_VARIABLE gss_OID GSS_C_PEER_HAS_UPDATED_SPNEGO;
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_EXPORT_LUCID_CONTEXT_X; extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_extract_authz_data_from_
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_EXPORT_LUCID_CONTEXT_V1_X; sec_context_x_oid_desc;
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_GET_SUBKEY_X; #define GSS_KRB5_EXTRACT_AUTHZ_DATA_FROM_SEC_CONTEXT_X (&__gss_krb5_extract
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_GET_INITIATOR_SUBKEY_X; _authz_data_from_sec_context_x_oid_desc)
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_GET_ACCEPTOR_SUBKEY_X;
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_GET_AUTHTIME_X; extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_peer_has_updated_spnego_oid
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_GET_SERVICE_KEYBLOCK_X; _desc;
#define GSS_C_PEER_HAS_UPDATED_SPNEGO (&__gss_c_peer_has_updated_spnego_oid
_desc)
extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_export_lucid_context_x_o
id_desc;
#define GSS_KRB5_EXPORT_LUCID_CONTEXT_X (&__gss_krb5_export_lucid_context_x
_oid_desc)
extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_export_lucid_context_v1_
x_oid_desc;
#define GSS_KRB5_EXPORT_LUCID_CONTEXT_V1_X (&__gss_krb5_export_lucid_contex
t_v1_x_oid_desc)
extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_get_subkey_x_oid_desc;
#define GSS_KRB5_GET_SUBKEY_X (&__gss_krb5_get_subkey_x_oid_desc)
extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_get_initiator_subkey_x_o
id_desc;
#define GSS_KRB5_GET_INITIATOR_SUBKEY_X (&__gss_krb5_get_initiator_subkey_x
_oid_desc)
extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_get_acceptor_subkey_x_oi
d_desc;
#define GSS_KRB5_GET_ACCEPTOR_SUBKEY_X (&__gss_krb5_get_acceptor_subkey_x_o
id_desc)
extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_get_authtime_x_oid_desc;
#define GSS_KRB5_GET_AUTHTIME_X (&__gss_krb5_get_authtime_x_oid_desc)
extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_get_service_keyblock_x_o
id_desc;
#define GSS_KRB5_GET_SERVICE_KEYBLOCK_X (&__gss_krb5_get_service_keyblock_x
_oid_desc)
/* Extensions creds */ /* Extensions creds */
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_IMPORT_CRED_X;
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_SET_ALLOWABLE_ENCTYPES_X; extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_import_cred_x_oid_desc;
extern GSSAPI_LIB_VARIABLE gss_OID GSS_KRB5_CRED_NO_CI_FLAGS_X; #define GSS_KRB5_IMPORT_CRED_X (&__gss_krb5_import_cred_x_oid_desc)
extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_set_allowable_enctypes_x
_oid_desc;
#define GSS_KRB5_SET_ALLOWABLE_ENCTYPES_X (&__gss_krb5_set_allowable_enctyp
es_x_oid_desc)
extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_cred_no_ci_flags_x_oid_d
esc;
#define GSS_KRB5_CRED_NO_CI_FLAGS_X (&__gss_krb5_cred_no_ci_flags_x_oid_des
c)
/* /*
* kerberos mechanism specific functions * kerberos mechanism specific functions
*/ */
struct krb5_keytab_data; struct krb5_keytab_data;
struct krb5_ccache_data; struct krb5_ccache_data;
struct Principal; struct Principal;
OM_uint32 GSSAPI_LIB_FUNCTION GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL
gss_krb5_ccache_name(OM_uint32 * /*minor_status*/, gss_krb5_ccache_name(OM_uint32 * /*minor_status*/,
const char * /*name */, const char * /*name */,
const char ** /*out_name */); const char ** /*out_name */);
OM_uint32 GSSAPI_LIB_FUNCTION gsskrb5_register_acceptor_identity GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gsskrb5_register_acceptor_ide
(const char */*identity*/); ntity
(const char * /*identity*/);
OM_uint32 GSSAPI_LIB_FUNCTION krb5_gss_register_acceptor_identity GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL krb5_gss_register_acceptor_id
(const char */*identity*/); entity
(const char * /*identity*/);
OM_uint32 GSSAPI_LIB_FUNCTION gss_krb5_copy_ccache GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_krb5_copy_ccache
(OM_uint32 */*minor*/, (OM_uint32 * /*minor*/,
gss_cred_id_t /*cred*/, gss_cred_id_t /*cred*/,
struct krb5_ccache_data */*out*/); struct krb5_ccache_data * /*out*/);
OM_uint32 GSSAPI_LIB_FUNCTION GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL
gss_krb5_import_cred(OM_uint32 */*minor*/, gss_krb5_import_cred(OM_uint32 * /*minor*/,
struct krb5_ccache_data * /*in*/, struct krb5_ccache_data * /*in*/,
struct Principal * /*keytab_principal*/, struct Principal * /*keytab_principal*/,
struct krb5_keytab_data * /*keytab*/, struct krb5_keytab_data * /*keytab*/,
gss_cred_id_t */*out*/); gss_cred_id_t * /*out*/);
OM_uint32 GSSAPI_LIB_FUNCTION gss_krb5_get_tkt_flags GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_krb5_get_tkt_flags
(OM_uint32 */*minor*/, (OM_uint32 * /*minor*/,
gss_ctx_id_t /*context_handle*/, gss_ctx_id_t /*context_handle*/,
OM_uint32 */*tkt_flags*/); OM_uint32 * /*tkt_flags*/);
OM_uint32 GSSAPI_LIB_FUNCTION GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL
gsskrb5_extract_authz_data_from_sec_context gsskrb5_extract_authz_data_from_sec_context
(OM_uint32 * /*minor_status*/, (OM_uint32 * /*minor_status*/,
gss_ctx_id_t /*context_handle*/, gss_ctx_id_t /*context_handle*/,
int /*ad_type*/, int /*ad_type*/,
gss_buffer_t /*ad_data*/); gss_buffer_t /*ad_data*/);
OM_uint32 GSSAPI_LIB_FUNCTION GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL
gsskrb5_set_dns_canonicalize(int); gsskrb5_set_dns_canonicalize(int);
struct gsskrb5_send_to_kdc { struct gsskrb5_send_to_kdc {
void *func; void *func;
void *ptr; void *ptr;
}; };
OM_uint32 GSSAPI_LIB_FUNCTION GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL
gsskrb5_set_send_to_kdc(struct gsskrb5_send_to_kdc *) gsskrb5_set_send_to_kdc(struct gsskrb5_send_to_kdc *)
GSSKRB5_FUNCTION_DEPRECATED; GSSKRB5_FUNCTION_DEPRECATED;
OM_uint32 GSSAPI_LIB_FUNCTION GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL
gsskrb5_set_default_realm(const char *); gsskrb5_set_default_realm(const char *);
OM_uint32 GSSAPI_LIB_FUNCTION GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL
gsskrb5_extract_authtime_from_sec_context(OM_uint32 *, gss_ctx_id_t, time_t *); gsskrb5_extract_authtime_from_sec_context(OM_uint32 *, gss_ctx_id_t, time_t *);
struct EncryptionKey; struct EncryptionKey;
OM_uint32 GSSAPI_LIB_FUNCTION GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL
gsskrb5_extract_service_keyblock(OM_uint32 *minor_status, gsskrb5_extract_service_keyblock(OM_uint32 *minor_status,
gss_ctx_id_t context_handle, gss_ctx_id_t context_handle,
struct EncryptionKey **out); struct EncryptionKey **out);
OM_uint32 GSSAPI_LIB_FUNCTION GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL
gsskrb5_get_initiator_subkey(OM_uint32 *minor_status, gsskrb5_get_initiator_subkey(OM_uint32 *minor_status,
gss_ctx_id_t context_handle, gss_ctx_id_t context_handle,
struct EncryptionKey **out); struct EncryptionKey **out);
OM_uint32 GSSAPI_LIB_FUNCTION GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL
gsskrb5_get_subkey(OM_uint32 *minor_status, gsskrb5_get_subkey(OM_uint32 *minor_status,
gss_ctx_id_t context_handle, gss_ctx_id_t context_handle,
struct EncryptionKey **out); struct EncryptionKey **out);
OM_uint32 GSSAPI_LIB_FUNCTION GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL
gsskrb5_set_time_offset(int); gsskrb5_set_time_offset(int);
OM_uint32 GSSAPI_LIB_FUNCTION GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL
gsskrb5_get_time_offset(int *); gsskrb5_get_time_offset(int *);
struct gsskrb5_krb5_plugin { struct gsskrb5_krb5_plugin {
int type; int type;
char *name; char *name;
void *symbol; void *symbol;
}; };
OM_uint32 GSSAPI_LIB_FUNCTION GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL
gsskrb5_plugin_register(struct gsskrb5_krb5_plugin *); gsskrb5_plugin_register(struct gsskrb5_krb5_plugin *);
/* /*
* Lucid - NFSv4 interface to GSS-API KRB5 to expose key material to * Lucid - NFSv4 interface to GSS-API KRB5 to expose key material to
* do GSS content token handling in-kernel. * do GSS content token handling in-kernel.
*/ */
typedef struct gss_krb5_lucid_key { typedef struct gss_krb5_lucid_key {
OM_uint32 type; OM_uint32 type;
OM_uint32 length; OM_uint32 length;
skipping to change at line 227 skipping to change at line 276
} gss_krb5_lucid_context_v1_t; } gss_krb5_lucid_context_v1_t;
typedef struct gss_krb5_lucid_context_version { typedef struct gss_krb5_lucid_context_version {
OM_uint32 version; /* Structure version number */ OM_uint32 version; /* Structure version number */
} gss_krb5_lucid_context_version_t; } gss_krb5_lucid_context_version_t;
/* /*
* Function declarations * Function declarations
*/ */
OM_uint32 GSSAPI_LIB_FUNCTION GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL
gss_krb5_export_lucid_sec_context(OM_uint32 *minor_status, gss_krb5_export_lucid_sec_context(OM_uint32 *minor_status,
gss_ctx_id_t *context_handle, gss_ctx_id_t *context_handle,
OM_uint32 version, OM_uint32 version,
void **kctx); void **kctx);
OM_uint32 GSSAPI_LIB_FUNCTION GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL
gss_krb5_free_lucid_sec_context(OM_uint32 *minor_status, gss_krb5_free_lucid_sec_context(OM_uint32 *minor_status,
void *kctx); void *kctx);
OM_uint32 GSSAPI_LIB_FUNCTION GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL
gss_krb5_set_allowable_enctypes(OM_uint32 *minor_status, gss_krb5_set_allowable_enctypes(OM_uint32 *minor_status,
gss_cred_id_t cred, gss_cred_id_t cred,
OM_uint32 num_enctypes, OM_uint32 num_enctypes,
int32_t *enctypes); int32_t *enctypes);
GSSAPI_CPP_END GSSAPI_CPP_END
#endif /* GSSAPI_SPNEGO_H_ */ #endif /* GSSAPI_SPNEGO_H_ */
 End of changes. 28 change blocks. 
57 lines changed or deleted 138 lines changed or added


 gssapi_ntlm.h   gssapi_ntlm.h 
skipping to change at line 43 skipping to change at line 43
/* $Id$ */ /* $Id$ */
#ifndef GSSAPI_NTLM_H_ #ifndef GSSAPI_NTLM_H_
#define GSSAPI_NTLM_H_ #define GSSAPI_NTLM_H_
#include <gssapi.h> #include <gssapi.h>
GSSAPI_CPP_START GSSAPI_CPP_START
extern GSSAPI_LIB_VARIABLE gss_OID GSS_NTLM_MECHANISM; extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_ntlm_mechanism_oid_desc;
#define GSS_NTLM_MECHANISM (&__gss_ntlm_mechanism_oid_desc)
GSSAPI_CPP_END GSSAPI_CPP_END
#endif /* GSSAPI_NTLM_H_ */ #endif /* GSSAPI_NTLM_H_ */
 End of changes. 1 change blocks. 
1 lines changed or deleted 2 lines changed or added


 gssapi_spnego.h   gssapi_spnego.h 
skipping to change at line 49 skipping to change at line 49
#include <gssapi.h> #include <gssapi.h>
GSSAPI_CPP_START GSSAPI_CPP_START
/* /*
* RFC2478, SPNEGO: * RFC2478, SPNEGO:
* The security mechanism of the initial * The security mechanism of the initial
* negotiation token is identified by the Object Identifier * negotiation token is identified by the Object Identifier
* iso.org.dod.internet.security.mechanism.snego (1.3.6.1.5.5.2). * iso.org.dod.internet.security.mechanism.snego (1.3.6.1.5.5.2).
*/ */
extern GSSAPI_LIB_VARIABLE gss_OID GSS_SPNEGO_MECHANISM; extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_spnego_mechanism_oid_desc;
#define GSS_SPNEGO_MECHANISM (&__gss_spnego_mechanism_oid_desc)
#define gss_mech_spnego GSS_SPNEGO_MECHANISM #define gss_mech_spnego GSS_SPNEGO_MECHANISM
GSSAPI_CPP_END GSSAPI_CPP_END
#endif /* GSSAPI_SPNEGO_H_ */ #endif /* GSSAPI_SPNEGO_H_ */
 End of changes. 1 change blocks. 
1 lines changed or deleted 2 lines changed or added


 hdb-protos.h   hdb-protos.h 
skipping to change at line 246 skipping to change at line 246
krb5_context /*context*/, krb5_context /*context*/,
HDB */*db*/); HDB */*db*/);
int int
hdb_key2principal ( hdb_key2principal (
krb5_context /*context*/, krb5_context /*context*/,
krb5_data */*key*/, krb5_data */*key*/,
krb5_principal /*p*/); krb5_principal /*p*/);
krb5_error_code krb5_error_code
hdb_keytab_create (
krb5_context /*context*/,
HDB ** /*db*/,
const char */*arg*/);
krb5_error_code
hdb_ldap_create ( hdb_ldap_create (
krb5_context /*context*/, krb5_context /*context*/,
HDB ** /*db*/, HDB ** /*db*/,
const char */*arg*/); const char */*arg*/);
krb5_error_code krb5_error_code
hdb_ldapi_create ( hdb_ldapi_create (
krb5_context /*context*/, krb5_context /*context*/,
HDB ** /*db*/, HDB ** /*db*/,
const char */*arg*/); const char */*arg*/);
skipping to change at line 268 skipping to change at line 274
hdb_list_builtin ( hdb_list_builtin (
krb5_context /*context*/, krb5_context /*context*/,
char **/*list*/); char **/*list*/);
krb5_error_code krb5_error_code
hdb_lock ( hdb_lock (
int /*fd*/, int /*fd*/,
int /*operation*/); int /*operation*/);
krb5_error_code krb5_error_code
hdb_mdb_create (
krb5_context /*context*/,
HDB **/*db*/,
const char */*filename*/);
krb5_error_code
hdb_ndbm_create ( hdb_ndbm_create (
krb5_context /*context*/, krb5_context /*context*/,
HDB **/*db*/, HDB **/*db*/,
const char */*filename*/); const char */*filename*/);
krb5_error_code krb5_error_code
hdb_next_enctype2key ( hdb_next_enctype2key (
krb5_context /*context*/, krb5_context /*context*/,
const hdb_entry */*e*/, const hdb_entry */*e*/,
krb5_enctype /*enctype*/, krb5_enctype /*enctype*/,
 End of changes. 2 change blocks. 
0 lines changed or deleted 12 lines changed or added


 hdb.h   hdb.h 
skipping to change at line 198 skipping to change at line 198
/** /**
* Destroy the handle to the database. * Destroy the handle to the database.
* *
* Destroy the handle to the database, deallocate all memory and * Destroy the handle to the database, deallocate all memory and
* related resources. Does not remove any permanent data. Its the * related resources. Does not remove any permanent data. Its the
* logical reverse of hdb_create() function that is the entry * logical reverse of hdb_create() function that is the entry
* point for the module. * point for the module.
*/ */
krb5_error_code (*hdb_destroy)(krb5_context, struct HDB*); krb5_error_code (*hdb_destroy)(krb5_context, struct HDB*);
/** /**
* Get the list of realms this backend handles.
* This call is optional to support. The returned realms are used
* for announcing the realms over bonjour. Free returned array
* with krb5_free_host_realm().
*/
krb5_error_code (*hdb_get_realms)(krb5_context, struct HDB *, krb5_real
m **);
/**
* Change password. * Change password.
* *
* Will update keys for the entry when given password. The new * Will update keys for the entry when given password. The new
* keys must be written into the entry and and will then later be * keys must be written into the entry and and will then later be
* ->hdb_store() into the database. The backend will still perform * ->hdb_store() into the database. The backend will still perform
* all other operations, increasing the kvno, and update * all other operations, increasing the kvno, and update
* modification timestamp. * modification timestamp.
* *
* The backen need to call _kadm5_set_keys() and perform password * The backen need to call _kadm5_set_keys() and perform password
* quality checks. * quality checks.
 End of changes. 1 change blocks. 
0 lines changed or deleted 8 lines changed or added


 hdb_asn1.h   hdb_asn1.h 
skipping to change at line 28 skipping to change at line 28
typedef struct heim_octet_string { typedef struct heim_octet_string {
size_t length; size_t length;
void *data; void *data;
} heim_octet_string; } heim_octet_string;
typedef char *heim_general_string; typedef char *heim_general_string;
typedef char *heim_utf8_string; typedef char *heim_utf8_string;
typedef char *heim_printable_string; typedef struct heim_octet_string heim_printable_string;
typedef char *heim_ia5_string; typedef struct heim_octet_string heim_ia5_string;
typedef struct heim_bmp_string { typedef struct heim_bmp_string {
size_t length; size_t length;
uint16_t *data; uint16_t *data;
} heim_bmp_string; } heim_bmp_string;
typedef struct heim_universal_string { typedef struct heim_universal_string {
size_t length; size_t length;
uint32_t *data; uint32_t *data;
} heim_universal_string; } heim_universal_string;
skipping to change at line 73 skipping to change at line 73
} else { \ } else { \
(R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
(S), (L)); \ (S), (L)); \
if((R) != 0) { \ if((R) != 0) { \
free((B)); \ free((B)); \
(B) = NULL; \ (B) = NULL; \
} \ } \
} \ } \
} while (0) } while (0)
#ifdef _WIN32
#ifndef ASN1_LIB
#define ASN1EXP __declspec(dllimport)
#else
#define ASN1EXP
#endif
#define ASN1CALL __stdcall
#else
#define ASN1EXP
#define ASN1CALL
#endif
struct units; struct units;
#endif #endif
#include <krb5_asn1.h> #include <krb5_asn1.h>
enum { HDB_DB_FORMAT = 2 }; enum { HDB_DB_FORMAT = 2 };
enum { hdb_pw_salt = 3 }; enum { hdb_pw_salt = 3 };
enum { hdb_afs3_salt = 10 }; enum { hdb_afs3_salt = 10 };
skipping to change at line 98 skipping to change at line 109
opaque [2] OCTET STRING OPTIONAL, opaque [2] OCTET STRING OPTIONAL,
} }
*/ */
typedef struct Salt { typedef struct Salt {
unsigned int type; unsigned int type;
heim_octet_string salt; heim_octet_string salt;
heim_octet_string *opaque; heim_octet_string *opaque;
} Salt; } Salt;
int encode_Salt(unsigned char *, size_t, const Salt *, size_t *); ASN1EXP int ASN1CALL decode_Salt(const unsigned char *, size_t, Salt *,
int decode_Salt(const unsigned char *, size_t, Salt *, size_t *); size_t *);
void free_Salt (Salt *); ASN1EXP int ASN1CALL encode_Salt(unsigned char *, size_t, const Salt *,
size_t length_Salt(const Salt *); size_t *);
int copy_Salt (const Salt *, Salt *); ASN1EXP size_t ASN1CALL length_Salt(const Salt *);
ASN1EXP int ASN1CALL copy_Salt (const Salt *, Salt *);
ASN1EXP void ASN1CALL free_Salt (Salt *);
/* /*
Key ::= SEQUENCE { Key ::= SEQUENCE {
mkvno [0] INTEGER (0..2147483647) OPTIONAL, mkvno [0] INTEGER (0..2147483647) OPTIONAL,
key [1] EncryptionKey, key [1] EncryptionKey,
salt [2] Salt OPTIONAL, salt [2] Salt OPTIONAL,
} }
*/ */
typedef struct Key { typedef struct Key {
unsigned int *mkvno; unsigned int *mkvno;
EncryptionKey key; EncryptionKey key;
Salt *salt; Salt *salt;
} Key; } Key;
int encode_Key(unsigned char *, size_t, const Key *, size_t *); ASN1EXP int ASN1CALL decode_Key(const unsigned char *, size_t, Key *, si
int decode_Key(const unsigned char *, size_t, Key *, size_t *); ze_t *);
void free_Key (Key *); ASN1EXP int ASN1CALL encode_Key(unsigned char *, size_t, const Key *, si
size_t length_Key(const Key *); ze_t *);
int copy_Key (const Key *, Key *); ASN1EXP size_t ASN1CALL length_Key(const Key *);
ASN1EXP int ASN1CALL copy_Key (const Key *, Key *);
ASN1EXP void ASN1CALL free_Key (Key *);
/* /*
Event ::= SEQUENCE { Event ::= SEQUENCE {
time [0] KerberosTime, time [0] KerberosTime,
principal [1] Principal OPTIONAL, principal [1] Principal OPTIONAL,
} }
*/ */
typedef struct Event { typedef struct Event {
KerberosTime time; KerberosTime time;
Principal *principal; Principal *principal;
} Event; } Event;
int encode_Event(unsigned char *, size_t, const Event *, size_t *); ASN1EXP int ASN1CALL decode_Event(const unsigned char *, size_t, Event *
int decode_Event(const unsigned char *, size_t, Event *, size_t *); , size_t *);
void free_Event (Event *); ASN1EXP int ASN1CALL encode_Event(unsigned char *, size_t, const Event *
size_t length_Event(const Event *); , size_t *);
int copy_Event (const Event *, Event *); ASN1EXP size_t ASN1CALL length_Event(const Event *);
ASN1EXP int ASN1CALL copy_Event (const Event *, Event *);
ASN1EXP void ASN1CALL free_Event (Event *);
/* /*
HDBFlags ::= BIT STRING { HDBFlags ::= BIT STRING {
initial(0), initial(0),
forwardable(1), forwardable(1),
proxiable(2), proxiable(2),
renewable(3), renewable(3),
postdate(4), postdate(4),
server(5), server(5),
client(6), client(6),
skipping to change at line 184 skipping to change at line 195
unsigned int require_preauth:1; unsigned int require_preauth:1;
unsigned int change_pw:1; unsigned int change_pw:1;
unsigned int require_hwauth:1; unsigned int require_hwauth:1;
unsigned int ok_as_delegate:1; unsigned int ok_as_delegate:1;
unsigned int user_to_user:1; unsigned int user_to_user:1;
unsigned int immutable:1; unsigned int immutable:1;
unsigned int trusted_for_delegation:1; unsigned int trusted_for_delegation:1;
unsigned int allow_kerberos4:1; unsigned int allow_kerberos4:1;
unsigned int allow_digest:1; unsigned int allow_digest:1;
unsigned int locked_out:1; unsigned int locked_out: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;
} HDBFlags; } HDBFlags;
int encode_HDBFlags(unsigned char *, size_t, const HDBFlags *, size_t *)
;
int decode_HDBFlags(const unsigned char *, size_t, HDBFlags *, size_t *)
;
void free_HDBFlags (HDBFlags *);
size_t length_HDBFlags(const HDBFlags *);
int copy_HDBFlags (const HDBFlags *, HDBFlags *);
unsigned HDBFlags2int(HDBFlags); unsigned HDBFlags2int(HDBFlags);
HDBFlags int2HDBFlags(unsigned); HDBFlags int2HDBFlags(unsigned);
const struct units * asn1_HDBFlags_units(void); const struct units * asn1_HDBFlags_units(void);
ASN1EXP int ASN1CALL decode_HDBFlags(const unsigned char *, size_t, HDBF
lags *, size_t *);
ASN1EXP int ASN1CALL encode_HDBFlags(unsigned char *, size_t, const HDBF
lags *, size_t *);
ASN1EXP size_t ASN1CALL length_HDBFlags(const HDBFlags *);
ASN1EXP int ASN1CALL copy_HDBFlags (const HDBFlags *, HDBFlags *);
ASN1EXP void ASN1CALL free_HDBFlags (HDBFlags *);
/* /*
GENERATION ::= SEQUENCE { GENERATION ::= SEQUENCE {
time [0] KerberosTime, time [0] KerberosTime,
usec [1] INTEGER (0..2147483647), usec [1] INTEGER (0..2147483647),
gen [2] INTEGER (0..2147483647), gen [2] INTEGER (0..2147483647),
} }
*/ */
typedef struct GENERATION { typedef struct GENERATION {
KerberosTime time; KerberosTime time;
unsigned int usec; unsigned int usec;
unsigned int gen; unsigned int gen;
} GENERATION; } GENERATION;
int encode_GENERATION(unsigned char *, size_t, const GENERATION *, size_ ASN1EXP int ASN1CALL decode_GENERATION(const unsigned char *, size_t, GE
t *); NERATION *, size_t *);
int decode_GENERATION(const unsigned char *, size_t, GENERATION *, size_ ASN1EXP int ASN1CALL encode_GENERATION(unsigned char *, size_t, const GE
t *); NERATION *, size_t *);
void free_GENERATION (GENERATION *); ASN1EXP size_t ASN1CALL length_GENERATION(const GENERATION *);
size_t length_GENERATION(const GENERATION *); ASN1EXP int ASN1CALL copy_GENERATION (const GENERATION *, GENERATION *)
int copy_GENERATION (const GENERATION *, GENERATION *); ;
ASN1EXP void ASN1CALL free_GENERATION (GENERATION *);
/* /*
HDB-Ext-PKINIT-acl ::= SEQUENCE OF SEQUENCE { HDB-Ext-PKINIT-acl ::= SEQUENCE OF SEQUENCE {
subject [0] UTF8String, subject [0] UTF8String,
issuer [1] UTF8String OPTIONAL, issuer [1] UTF8String OPTIONAL,
anchor [2] UTF8String OPTIONAL, anchor [2] UTF8String OPTIONAL,
} }
*/ */
typedef struct HDB_Ext_PKINIT_acl { typedef struct HDB_Ext_PKINIT_acl {
unsigned int len; unsigned int len;
struct { struct HDB_Ext_PKINIT_acl_val {
heim_utf8_string subject; heim_utf8_string subject;
heim_utf8_string *issuer; heim_utf8_string *issuer;
heim_utf8_string *anchor; heim_utf8_string *anchor;
} *val; } *val;
} HDB_Ext_PKINIT_acl; } HDB_Ext_PKINIT_acl;
int encode_HDB_Ext_PKINIT_acl(unsigned char *, size_t, const HDB_Ext_PKI ASN1EXP int ASN1CALL decode_HDB_Ext_PKINIT_acl(const unsigned char *, si
NIT_acl *, size_t *); ze_t, HDB_Ext_PKINIT_acl *, size_t *);
int decode_HDB_Ext_PKINIT_acl(const unsigned char *, size_t, HDB_Ext_PKI ASN1EXP int ASN1CALL encode_HDB_Ext_PKINIT_acl(unsigned char *, size_t,
NIT_acl *, size_t *); const HDB_Ext_PKINIT_acl *, size_t *);
void free_HDB_Ext_PKINIT_acl (HDB_Ext_PKINIT_acl *); ASN1EXP size_t ASN1CALL length_HDB_Ext_PKINIT_acl(const HDB_Ext_PKINIT_acl
size_t length_HDB_Ext_PKINIT_acl(const HDB_Ext_PKINIT_acl *); *);
int copy_HDB_Ext_PKINIT_acl (const HDB_Ext_PKINIT_acl *, HDB_Ext_PKINIT ASN1EXP int ASN1CALL copy_HDB_Ext_PKINIT_acl (const HDB_Ext_PKINIT_acl
_acl *); *, HDB_Ext_PKINIT_acl *);
ASN1EXP void ASN1CALL free_HDB_Ext_PKINIT_acl (HDB_Ext_PKINIT_acl *);
/* /*
HDB-Ext-PKINIT-hash ::= SEQUENCE OF SEQUENCE { HDB-Ext-PKINIT-hash ::= SEQUENCE OF SEQUENCE {
digest-type [0] OBJECT IDENTIFIER, digest-type [0] OBJECT IDENTIFIER,
digest [1] OCTET STRING, digest [1] OCTET STRING,
} }
*/ */
typedef struct HDB_Ext_PKINIT_hash { typedef struct HDB_Ext_PKINIT_hash {
unsigned int len; unsigned int len;
struct { struct HDB_Ext_PKINIT_hash_val {
heim_oid digest_type; heim_oid digest_type;
heim_octet_string digest; heim_octet_string digest;
} *val; } *val;
} HDB_Ext_PKINIT_hash; } HDB_Ext_PKINIT_hash;
int encode_HDB_Ext_PKINIT_hash(unsigned char *, size_t, const HDB_Ext_PK ASN1EXP int ASN1CALL decode_HDB_Ext_PKINIT_hash(const unsigned char *, s
INIT_hash *, size_t *); ize_t, HDB_Ext_PKINIT_hash *, size_t *);
int decode_HDB_Ext_PKINIT_hash(const unsigned char *, size_t, HDB_Ext_PK ASN1EXP int ASN1CALL encode_HDB_Ext_PKINIT_hash(unsigned char *, size_t,
INIT_hash *, size_t *); const HDB_Ext_PKINIT_hash *, size_t *);
void free_HDB_Ext_PKINIT_hash (HDB_Ext_PKINIT_hash *); ASN1EXP size_t ASN1CALL length_HDB_Ext_PKINIT_hash(const HDB_Ext_PKINIT_has
size_t length_HDB_Ext_PKINIT_hash(const HDB_Ext_PKINIT_hash *); h *);
int copy_HDB_Ext_PKINIT_hash (const HDB_Ext_PKINIT_hash *, HDB_Ext_PKIN ASN1EXP int ASN1CALL copy_HDB_Ext_PKINIT_hash (const HDB_Ext_PKINIT_has
IT_hash *); h *, HDB_Ext_PKINIT_hash *);
ASN1EXP void ASN1CALL free_HDB_Ext_PKINIT_hash (HDB_Ext_PKINIT_hash *);
/* /*
HDB-Ext-PKINIT-cert ::= SEQUENCE OF SEQUENCE { HDB-Ext-PKINIT-cert ::= SEQUENCE OF SEQUENCE {
cert [0] OCTET STRING, cert [0] OCTET STRING,
} }
*/ */
typedef struct HDB_Ext_PKINIT_cert { typedef struct HDB_Ext_PKINIT_cert {
unsigned int len; unsigned int len;
struct { struct HDB_Ext_PKINIT_cert_val {
heim_octet_string cert; heim_octet_string cert;
} *val; } *val;
} HDB_Ext_PKINIT_cert; } HDB_Ext_PKINIT_cert;
int encode_HDB_Ext_PKINIT_cert(unsigned char *, size_t, const HDB_Ext_PK ASN1EXP int ASN1CALL decode_HDB_Ext_PKINIT_cert(const unsigned char *, s
INIT_cert *, size_t *); ize_t, HDB_Ext_PKINIT_cert *, size_t *);
int decode_HDB_Ext_PKINIT_cert(const unsigned char *, size_t, HDB_Ext_PK ASN1EXP int ASN1CALL encode_HDB_Ext_PKINIT_cert(unsigned char *, size_t,
INIT_cert *, size_t *); const HDB_Ext_PKINIT_cert *, size_t *);
void free_HDB_Ext_PKINIT_cert (HDB_Ext_PKINIT_cert *); ASN1EXP size_t ASN1CALL length_HDB_Ext_PKINIT_cert(const HDB_Ext_PKINIT_cer
size_t length_HDB_Ext_PKINIT_cert(const HDB_Ext_PKINIT_cert *); t *);
int copy_HDB_Ext_PKINIT_cert (const HDB_Ext_PKINIT_cert *, HDB_Ext_PKIN ASN1EXP int ASN1CALL copy_HDB_Ext_PKINIT_cert (const HDB_Ext_PKINIT_cer
IT_cert *); t *, HDB_Ext_PKINIT_cert *);
ASN1EXP void ASN1CALL free_HDB_Ext_PKINIT_cert (HDB_Ext_PKINIT_cert *);
/* /*
HDB-Ext-Constrained-delegation-acl ::= SEQUENCE OF Principal HDB-Ext-Constrained-delegation-acl ::= SEQUENCE OF Principal
*/ */
typedef struct HDB_Ext_Constrained_delegation_acl { typedef struct HDB_Ext_Constrained_delegation_acl {
unsigned int len; unsigned int len;
Principal *val; Principal *val;
} HDB_Ext_Constrained_delegation_acl; } HDB_Ext_Constrained_delegation_acl;
int encode_HDB_Ext_Constrained_delegation_acl(unsigned char *, size_t, c ASN1EXP int ASN1CALL decode_HDB_Ext_Constrained_delegation_acl(const uns
onst HDB_Ext_Constrained_delegation_acl *, size_t *); igned char *, size_t, HDB_Ext_Constrained_delegation_acl *, size_t *);
int decode_HDB_Ext_Constrained_delegation_acl(const unsigned char *, siz ASN1EXP int ASN1CALL encode_HDB_Ext_Constrained_delegation_acl(unsigned
e_t, HDB_Ext_Constrained_delegation_acl *, size_t *); char *, size_t, const HDB_Ext_Constrained_delegation_acl *, size_t *);
void free_HDB_Ext_Constrained_delegation_acl (HDB_Ext_Constrained_delega ASN1EXP size_t ASN1CALL length_HDB_Ext_Constrained_delegation_acl(const HDB
tion_acl *); _Ext_Constrained_delegation_acl *);
size_t length_HDB_Ext_Constrained_delegation_acl(const HDB_Ext_Constrained_ ASN1EXP int ASN1CALL copy_HDB_Ext_Constrained_delegation_acl (const HDB
delegation_acl *); _Ext_Constrained_delegation_acl *, HDB_Ext_Constrained_delegation_acl *);
int copy_HDB_Ext_Constrained_delegation_acl (const HDB_Ext_Constrained_ ASN1EXP void ASN1CALL free_HDB_Ext_Constrained_delegation_acl (HDB_Ext_C
delegation_acl *, HDB_Ext_Constrained_delegation_acl *); onstrained_delegation_acl *);
/* /*
HDB-Ext-Lan-Manager-OWF ::= OCTET STRING HDB-Ext-Lan-Manager-OWF ::= OCTET STRING
*/ */
typedef heim_octet_string HDB_Ext_Lan_Manager_OWF; typedef heim_octet_string HDB_Ext_Lan_Manager_OWF;
int encode_HDB_Ext_Lan_Manager_OWF(unsigned char *, size_t, const HDB_Ex ASN1EXP int ASN1CALL decode_HDB_Ext_Lan_Manager_OWF(const unsigned char
t_Lan_Manager_OWF *, size_t *); *, size_t, HDB_Ext_Lan_Manager_OWF *, size_t *);
int decode_HDB_Ext_Lan_Manager_OWF(const unsigned char *, size_t, HDB_Ex ASN1EXP int ASN1CALL encode_HDB_Ext_Lan_Manager_OWF(unsigned char *, siz
t_Lan_Manager_OWF *, size_t *); e_t, const HDB_Ext_Lan_Manager_OWF *, size_t *);
void free_HDB_Ext_Lan_Manager_OWF (HDB_Ext_Lan_Manager_OWF *); ASN1EXP size_t ASN1CALL length_HDB_Ext_Lan_Manager_OWF(const HDB_Ext_Lan_Ma
size_t length_HDB_Ext_Lan_Manager_OWF(const HDB_Ext_Lan_Manager_OWF *); nager_OWF *);
int copy_HDB_Ext_Lan_Manager_OWF (const HDB_Ext_Lan_Manager_OWF *, HDB_ ASN1EXP int ASN1CALL copy_HDB_Ext_Lan_Manager_OWF (const HDB_Ext_Lan_Ma
Ext_Lan_Manager_OWF *); nager_OWF *, HDB_Ext_Lan_Manager_OWF *);
ASN1EXP void ASN1CALL free_HDB_Ext_Lan_Manager_OWF (HDB_Ext_Lan_Manager_
OWF *);
/* /*
HDB-Ext-Password ::= SEQUENCE { HDB-Ext-Password ::= SEQUENCE {
mkvno [0] INTEGER (0..2147483647) OPTIONAL, mkvno [0] INTEGER (0..2147483647) OPTIONAL,
password OCTET STRING, password OCTET STRING,
} }
*/ */
typedef struct HDB_Ext_Password { typedef struct HDB_Ext_Password {
unsigned int *mkvno; unsigned int *mkvno;
heim_octet_string password; heim_octet_string password;
} HDB_Ext_Password; } HDB_Ext_Password;
int encode_HDB_Ext_Password(unsigned char *, size_t, const HDB_Ext_Passw ASN1EXP int ASN1CALL decode_HDB_Ext_Password(const unsigned char *, size
ord *, size_t *); _t, HDB_Ext_Password *, size_t *);
int decode_HDB_Ext_Password(const unsigned char *, size_t, HDB_Ext_Passw ASN1EXP int ASN1CALL encode_HDB_Ext_Password(unsigned char *, size_t, co
ord *, size_t *); nst HDB_Ext_Password *, size_t *);
void free_HDB_Ext_Password (HDB_Ext_Password *); ASN1EXP size_t ASN1CALL length_HDB_Ext_Password(const HDB_Ext_Password *);
size_t length_HDB_Ext_Password(const HDB_Ext_Password *); ASN1EXP int ASN1CALL copy_HDB_Ext_Password (const HDB_Ext_Password *, H
int copy_HDB_Ext_Password (const HDB_Ext_Password *, HDB_Ext_Password * DB_Ext_Password *);
); ASN1EXP void ASN1CALL free_HDB_Ext_Password (HDB_Ext_Password *);
/* /*
HDB-Ext-Aliases ::= SEQUENCE { HDB-Ext-Aliases ::= SEQUENCE {
case-insensitive [0] BOOLEAN, case-insensitive [0] BOOLEAN,
aliases [1] SEQUENCE OF Principal, aliases [1] SEQUENCE OF Principal,
} }
*/ */
typedef struct HDB_Ext_Aliases { typedef struct HDB_Ext_Aliases {
int case_insensitive; int case_insensitive;
struct { struct HDB_Ext_Aliases_aliases {
unsigned int len; unsigned int len;
Principal *val; Principal *val;
} aliases; } aliases;
} HDB_Ext_Aliases; } HDB_Ext_Aliases;
int encode_HDB_Ext_Aliases(unsigned char *, size_t, const HDB_Ext_Aliase ASN1EXP int ASN1CALL decode_HDB_Ext_Aliases(const unsigned char *, size_
s *, size_t *); t, HDB_Ext_Aliases *, size_t *);
int decode_HDB_Ext_Aliases(const unsigned char *, size_t, HDB_Ext_Aliase ASN1EXP int ASN1CALL encode_HDB_Ext_Aliases(unsigned char *, size_t, con
s *, size_t *); st HDB_Ext_Aliases *, size_t *);
void free_HDB_Ext_Aliases (HDB_Ext_Aliases *); ASN1EXP size_t ASN1CALL length_HDB_Ext_Aliases(const HDB_Ext_Aliases *);
size_t length_HDB_Ext_Aliases(const HDB_Ext_Aliases *); ASN1EXP int ASN1CALL copy_HDB_Ext_Aliases (const HDB_Ext_Aliases *, HDB
int copy_HDB_Ext_Aliases (const HDB_Ext_Aliases *, HDB_Ext_Aliases *); _Ext_Aliases *);
ASN1EXP void ASN1CALL free_HDB_Ext_Aliases (HDB_Ext_Aliases *);
/* /*
HDB-extension ::= SEQUENCE { HDB-extension ::= SEQUENCE {
mandatory [0] BOOLEAN, mandatory [0] BOOLEAN,
data [1] CHOICE { data [1] CHOICE {
pkinit-acl [0] HDB-Ext-PKINIT-acl, pkinit-acl [0] HDB-Ext-PKINIT-acl,
pkinit-cert-hash [1] HDB-Ext-PKINIT-hash, pkinit-cert-hash [1] HDB-Ext-PKINIT-hash,
allowed-to-delegate-to [2] HDB-Ext-Constrained-delegation-acl, allowed-to-delegate-to [2] HDB-Ext-Constrained-delegation-acl,
lm-owf [4] HDB-Ext-Lan-Manager-OWF, lm-owf [4] HDB-Ext-Lan-Manager-OWF,
password [5] HDB-Ext-Password, password [5] HDB-Ext-Password,
skipping to change at line 364 skipping to change at line 389
last-pw-change [7] KerberosTime, last-pw-change [7] KerberosTime,
pkinit-cert [8] HDB-Ext-PKINIT-cert, pkinit-cert [8] HDB-Ext-PKINIT-cert,
..., ...,
}, },
..., ...,
} }
*/ */
typedef struct HDB_extension { typedef struct HDB_extension {
int mandatory; int mandatory;
struct { struct HDB_extension_data {
enum { enum {
choice_HDB_extension_data_asn1_ellipsis = 0, choice_HDB_extension_data_asn1_ellipsis = 0,
choice_HDB_extension_data_pkinit_acl, choice_HDB_extension_data_pkinit_acl,
choice_HDB_extension_data_pkinit_cert_hash, choice_HDB_extension_data_pkinit_cert_hash,
choice_HDB_extension_data_allowed_to_delegate_to, choice_HDB_extension_data_allowed_to_delegate_to,
choice_HDB_extension_data_lm_owf, choice_HDB_extension_data_lm_owf,
choice_HDB_extension_data_password, choice_HDB_extension_data_password,
choice_HDB_extension_data_aliases, choice_HDB_extension_data_aliases,
choice_HDB_extension_data_last_pw_change, choice_HDB_extension_data_last_pw_change,
choice_HDB_extension_data_pkinit_cert choice_HDB_extension_data_pkinit_cert
skipping to change at line 391 skipping to change at line 416
HDB_Ext_Lan_Manager_OWF lm_owf; HDB_Ext_Lan_Manager_OWF lm_owf;
HDB_Ext_Password password; HDB_Ext_Password password;
HDB_Ext_Aliases aliases; HDB_Ext_Aliases aliases;
KerberosTime last_pw_change; KerberosTime last_pw_change;
HDB_Ext_PKINIT_cert pkinit_cert; HDB_Ext_PKINIT_cert pkinit_cert;
heim_octet_string asn1_ellipsis; heim_octet_string asn1_ellipsis;
} u; } u;
} data; } data;
} HDB_extension; } HDB_extension;
int encode_HDB_extension(unsigned char *, size_t, const HDB_extension *, ASN1EXP int ASN1CALL decode_HDB_extension(const unsigned char *, size_t,
size_t *); HDB_extension *, size_t *);
int decode_HDB_extension(const unsigned char *, size_t, HDB_extension *, ASN1EXP int ASN1CALL encode_HDB_extension(unsigned char *, size_t, const
size_t *); HDB_extension *, size_t *);
void free_HDB_extension (HDB_extension *); ASN1EXP size_t ASN1CALL length_HDB_extension(const HDB_extension *);
size_t length_HDB_extension(const HDB_extension *); ASN1EXP int ASN1CALL copy_HDB_extension (const HDB_extension *, HDB_ext
int copy_HDB_extension (const HDB_extension *, HDB_extension *); ension *);
ASN1EXP void ASN1CALL free_HDB_extension (HDB_extension *);
/* /*
HDB-extensions ::= SEQUENCE OF HDB-extension HDB-extensions ::= SEQUENCE OF HDB-extension
*/ */
typedef struct HDB_extensions { typedef struct HDB_extensions {
unsigned int len; unsigned int len;
HDB_extension *val; HDB_extension *val;
} HDB_extensions; } HDB_extensions;
int encode_HDB_extensions(unsigned char *, size_t, const HDB_extensions ASN1EXP int ASN1CALL decode_HDB_extensions(const unsigned char *, size_t
*, size_t *); , HDB_extensions *, size_t *);
int decode_HDB_extensions(const unsigned char *, size_t, HDB_extensions ASN1EXP int ASN1CALL encode_HDB_extensions(unsigned char *, size_t, cons
*, size_t *); t HDB_extensions *, size_t *);
void free_HDB_extensions (HDB_extensions *); ASN1EXP size_t ASN1CALL length_HDB_extensions(const HDB_extensions *);
size_t length_HDB_extensions(const HDB_extensions *); ASN1EXP int ASN1CALL copy_HDB_extensions (const HDB_extensions *, HDB_e
int copy_HDB_extensions (const HDB_extensions *, HDB_extensions *); xtensions *);
ASN1EXP void ASN1CALL free_HDB_extensions (HDB_extensions *);
/* /*
hdb_keyset ::= SEQUENCE { hdb_keyset ::= SEQUENCE {
kvno [1] INTEGER (0..2147483647), kvno [1] INTEGER (0..2147483647),
keys [0] SEQUENCE OF Key, keys [0] SEQUENCE OF Key,
} }
*/ */
typedef struct hdb_keyset { typedef struct hdb_keyset {
unsigned int kvno; unsigned int kvno;
struct { struct hdb_keyset_keys {
unsigned int len; unsigned int len;
Key *val; Key *val;
} keys; } keys;
} hdb_keyset; } hdb_keyset;
int encode_hdb_keyset(unsigned char *, size_t, const hdb_keyset *, size_ ASN1EXP int ASN1CALL decode_hdb_keyset(const unsigned char *, size_t, hd
t *); b_keyset *, size_t *);
int decode_hdb_keyset(const unsigned char *, size_t, hdb_keyset *, size_ ASN1EXP int ASN1CALL encode_hdb_keyset(unsigned char *, size_t, const hd
t *); b_keyset *, size_t *);
void free_hdb_keyset (hdb_keyset *); ASN1EXP size_t ASN1CALL length_hdb_keyset(const hdb_keyset *);
size_t length_hdb_keyset(const hdb_keyset *); ASN1EXP int ASN1CALL copy_hdb_keyset (const hdb_keyset *, hdb_keyset *)
int copy_hdb_keyset (const hdb_keyset *, hdb_keyset *); ;
ASN1EXP void ASN1CALL free_hdb_keyset (hdb_keyset *);
/* /*
hdb_entry ::= SEQUENCE { hdb_entry ::= SEQUENCE {
principal [0] Principal OPTIONAL, principal [0] Principal OPTIONAL,
kvno [1] INTEGER (0..2147483647), kvno [1] INTEGER (0..2147483647),
keys [2] SEQUENCE OF Key, keys [2] SEQUENCE OF Key,
created-by [3] Event, created-by [3] Event,
modified-by [4] Event OPTIONAL, modified-by [4] Event OPTIONAL,
valid-start [5] KerberosTime OPTIONAL, valid-start [5] KerberosTime OPTIONAL,
valid-end [6] KerberosTime OPTIONAL, valid-end [6] KerberosTime OPTIONAL,
skipping to change at line 455 skipping to change at line 480
flags [10] HDBFlags, flags [10] HDBFlags,
etypes [11] SEQUENCE OF INTEGER (0..2147483647) OPTIONAL, etypes [11] SEQUENCE OF INTEGER (0..2147483647) OPTIONAL,
generation [12] GENERATION OPTIONAL, generation [12] GENERATION OPTIONAL,
extensions [13] HDB-extensions OPTIONAL, extensions [13] HDB-extensions OPTIONAL,
} }
*/ */
typedef struct hdb_entry { typedef struct hdb_entry {
Principal *principal; Principal *principal;
unsigned int kvno; unsigned int kvno;
struct { struct hdb_entry_keys {
unsigned int len; unsigned int len;
Key *val; Key *val;
} keys; } keys;
Event created_by; Event created_by;
Event *modified_by; Event *modified_by;
KerberosTime *valid_start; KerberosTime *valid_start;
KerberosTime *valid_end; KerberosTime *valid_end;
KerberosTime *pw_end; KerberosTime *pw_end;
unsigned int *max_life; unsigned int *max_life;
unsigned int *max_renew; unsigned int *max_renew;
HDBFlags flags; HDBFlags flags;
struct { struct hdb_entry_etypes {
unsigned int len; unsigned int len;
unsigned int *val; unsigned int *val;
} *etypes; } *etypes;
GENERATION *generation; GENERATION *generation;
HDB_extensions *extensions; HDB_extensions *extensions;
} hdb_entry; } hdb_entry;
int encode_hdb_entry(unsigned char *, size_t, const hdb_entry *, size_t ASN1EXP int ASN1CALL decode_hdb_entry(const unsigned char *, size_t, hdb
*); _entry *, size_t *);
int decode_hdb_entry(const unsigned char *, size_t, hdb_entry *, size_t ASN1EXP int ASN1CALL encode_hdb_entry(unsigned char *, size_t, const hdb
*); _entry *, size_t *);
void free_hdb_entry (hdb_entry *); ASN1EXP size_t ASN1CALL length_hdb_entry(const hdb_entry *);
size_t length_hdb_entry(const hdb_entry *); ASN1EXP int ASN1CALL copy_hdb_entry (const hdb_entry *, hdb_entry *);
int copy_hdb_entry (const hdb_entry *, hdb_entry *); ASN1EXP void ASN1CALL free_hdb_entry (hdb_entry *);
/* /*
hdb_entry_alias ::= [APPLICATION 0] SEQUENCE { hdb_entry_alias ::= [APPLICATION 0] SEQUENCE {
principal [0] Principal OPTIONAL, principal [0] Principal OPTIONAL,
} }
*/ */
typedef struct hdb_entry_alias { typedef struct hdb_entry_alias {
Principal *principal; Principal *principal;
} hdb_entry_alias; } hdb_entry_alias;
int encode_hdb_entry_alias(unsigned char *, size_t, const hdb_entry_alia ASN1EXP int ASN1CALL decode_hdb_entry_alias(const unsigned char *, size_
s *, size_t *); t, hdb_entry_alias *, size_t *);
int decode_hdb_entry_alias(const unsigned char *, size_t, hdb_entry_alia ASN1EXP int ASN1CALL encode_hdb_entry_alias(unsigned char *, size_t, con
s *, size_t *); st hdb_entry_alias *, size_t *);
void free_hdb_entry_alias (hdb_entry_alias *); ASN1EXP size_t ASN1CALL length_hdb_entry_alias(const hdb_entry_alias *);
size_t length_hdb_entry_alias(const hdb_entry_alias *); ASN1EXP int ASN1CALL copy_hdb_entry_alias (const hdb_entry_alias *, hdb
int copy_hdb_entry_alias (const hdb_entry_alias *, hdb_entry_alias *); _entry_alias *);
ASN1EXP void ASN1CALL free_hdb_entry_alias (hdb_entry_alias *);
#endif /* __hdb_asn1_h__ */ #endif /* __hdb_asn1_h__ */
 End of changes. 30 change blocks. 
131 lines changed or deleted 173 lines changed or added


 hdb_err.h   hdb_err.h 
skipping to change at line 27 skipping to change at line 27
HDB_ERR_NOENTRY = 36150275, HDB_ERR_NOENTRY = 36150275,
HDB_ERR_DB_INUSE = 36150276, HDB_ERR_DB_INUSE = 36150276,
HDB_ERR_DB_CHANGED = 36150277, HDB_ERR_DB_CHANGED = 36150277,
HDB_ERR_RECURSIVELOCK = 36150278, HDB_ERR_RECURSIVELOCK = 36150278,
HDB_ERR_NOTLOCKED = 36150279, HDB_ERR_NOTLOCKED = 36150279,
HDB_ERR_BADLOCKMODE = 36150280, HDB_ERR_BADLOCKMODE = 36150280,
HDB_ERR_CANT_LOCK_DB = 36150281, HDB_ERR_CANT_LOCK_DB = 36150281,
HDB_ERR_EXISTS = 36150282, HDB_ERR_EXISTS = 36150282,
HDB_ERR_BADVERSION = 36150283, HDB_ERR_BADVERSION = 36150283,
HDB_ERR_NO_MKEY = 36150284, HDB_ERR_NO_MKEY = 36150284,
HDB_ERR_MANDATORY_OPTION = 36150285 HDB_ERR_MANDATORY_OPTION = 36150285,
HDB_ERR_NO_WRITE_SUPPORT = 36150286
} hdb_error_number; } hdb_error_number;
#define ERROR_TABLE_BASE_hdb 36150272 #define ERROR_TABLE_BASE_hdb 36150272
#define COM_ERR_BINDDOMAIN_hdb "heim_com_err36150272" #define COM_ERR_BINDDOMAIN_hdb "heim_com_err36150272"
#endif /* __hdb_err_h__ */ #endif /* __hdb_err_h__ */
 End of changes. 1 change blocks. 
1 lines changed or deleted 2 lines changed or added


 heimntlm.h   heimntlm.h 
skipping to change at line 49 skipping to change at line 49
/** /**
* Buffer for storing data in the NTLM library. When filled in by the * Buffer for storing data in the NTLM library. When filled in by the
* library it should be freed with heim_ntlm_free_buf(). * library it should be freed with heim_ntlm_free_buf().
*/ */
struct ntlm_buf { struct ntlm_buf {
size_t length; /**< length buffer data */ size_t length; /**< length buffer data */
void *data; /**< pointer to the data itself */ void *data; /**< pointer to the data itself */
}; };
#define NTLM_NEG_UNICODE 0x00000001 #define NTLM_NEG_UNICODE 0x00000001
#define NTLM_NEG_OEM 0x00000002
#define NTLM_NEG_TARGET 0x00000004 #define NTLM_NEG_TARGET 0x00000004
#define NTLM_MBZ9 0x00000008
#define NTLM_NEG_SIGN 0x00000010 #define NTLM_NEG_SIGN 0x00000010
#define NTLM_NEG_SEAL 0x00000020 #define NTLM_NEG_SEAL 0x00000020
#define NTLM_NEG_NTLM 0x00000200 #define NTLM_NEG_DATAGRAM 0x00000040
#define NTLM_NEG_LM_KEY 0x00000080
#define NTLM_SUPPLIED_DOMAIN 0x00001000 #define NTLM_MBZ8 0x00000100
#define NTLM_SUPPLIED_WORKSTAION 0x00002000 #define NTLM_NEG_NTLM 0x00000200
#define NTLM_NEG_NT_ONLY 0x00000400
#define NTLM_MBZ7 0x00000800 /* anon ? */
#define NTLM_OEM_SUPPLIED_DOMAIN 0x00001000
#define NTLM_OEM_SUPPLIED_WORKSTAION 0x00002000
#define NTLM_MBZ6 0x00004000 /* local call ? */
#define NTLM_NEG_ALWAYS_SIGN 0x00008000 #define NTLM_NEG_ALWAYS_SIGN 0x00008000
#define NTLM_NEG_NTLM2_SESSION 0x00080000
#define NTLM_TARGET_DOMAIN 0x00010000 #define NTLM_TARGET_DOMAIN 0x00010000
#define NTLM_TARGET_SERVER 0x00020000 #define NTLM_TARGET_SERVER 0x00020000
#define NTLM_TARGET_SHARE 0x00040000
#define NTLM_NEG_NTLM2_SESSION 0x00080000
#define NTLM_NEG_NTLM2 0x00080000
#define NTLM_NEG_IDENTIFY 0x00100000
#define NTLM_MBZ5 0x00200000
#define NTLM_NON_NT_SESSION_KEY 0x00400000
#define NTLM_NEG_TARGET_INFO 0x00800000
#define NTLM_MBZ4 0x01000000
#define NTLM_NEG_VERSION 0x02000000
#define NTLM_MBZ3 0x04000000
#define NTLM_MBZ2 0x08000000
#define NTLM_MBZ1 0x10000000
#define NTLM_ENC_128 0x20000000 #define NTLM_ENC_128 0x20000000
#define NTLM_NEG_KEYEX 0x40000000 #define NTLM_NEG_KEYEX 0x40000000
#define NTLM_NEGOTIATE_56 0x80000000
/** /**
* Struct for the NTLM target info, the strings is assumed to be in * Struct for the NTLM target info, the strings is assumed to be in
* UTF8. When filled in by the library it should be freed with * UTF8. When filled in by the library it should be freed with
* heim_ntlm_free_targetinfo(). * heim_ntlm_free_targetinfo().
*/ */
struct ntlm_targetinfo { struct ntlm_targetinfo {
char *servername; /**< */ char *servername; /**< */
char *domainname; /**< */ char *domainname; /**< */
char *dnsdomainname; /**< */ char *dnsdomainname; /**< */
 End of changes. 8 change blocks. 
4 lines changed or deleted 28 lines changed or added


 hex.h   hex.h 
skipping to change at line 41 skipping to change at line 41
* SUCH DAMAGE. * SUCH DAMAGE.
*/ */
/* $Id$ */ /* $Id$ */
#ifndef _rk_HEX_H_ #ifndef _rk_HEX_H_
#define _rk_HEX_H_ 1 #define _rk_HEX_H_ 1
#ifndef ROKEN_LIB_FUNCTION #ifndef ROKEN_LIB_FUNCTION
#ifdef _WIN32 #ifdef _WIN32
#define ROKEN_LIB_FUNCTION _stdcall #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL __cdecl
#else #else
#define ROKEN_LIB_FUNCTION #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL
#endif #endif
#endif #endif
#define hex_encode rk_hex_encode #define hex_encode rk_hex_encode
#define hex_decode rk_hex_decode #define hex_decode rk_hex_decode
ssize_t ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION ssize_t ROKEN_LIB_CALL
hex_encode(const void *, size_t, char **); hex_encode(const void *, size_t, char **);
ssize_t ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION ssize_t ROKEN_LIB_CALL
hex_decode(const char *, void *, size_t); hex_decode(const char *, void *, size_t);
#endif /* _rk_HEX_H_ */ #endif /* _rk_HEX_H_ */
 End of changes. 4 change blocks. 
3 lines changed or deleted 5 lines changed or added


 hx509-protos.h   hx509-protos.h 
skipping to change at line 12 skipping to change at line 12
#ifndef __hx509_protos_h__ #ifndef __hx509_protos_h__
#define __hx509_protos_h__ #define __hx509_protos_h__
#include <stdarg.h> #include <stdarg.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#ifndef HX509_LIB #ifndef HX509_LIB
#ifndef HX509_LIB_FUNCTION
#if defined(_WIN32) #if defined(_WIN32)
#define HX509_LIB_FUNCTION __stdcall __declspec(dllimport) #define HX509_LIB_FUNCTION __declspec(dllimport)
#define HX509_LIB_CALL __stdcall
#define HX509_LIB_VARIABLE __declspec(dllimport) #define HX509_LIB_VARIABLE __declspec(dllimport)
#else #else
#define HX509_LIB_FUNCTION #define HX509_LIB_FUNCTION
#define HX509_LIB_CALL
#define HX509_LIB_VARIABLE #define HX509_LIB_VARIABLE
#endif #endif
#endif #endif
#endif
void void
hx509_bitstring_print ( hx509_bitstring_print (
const heim_bit_string */*b*/, const heim_bit_string */*b*/,
hx509_vprint_func /*func*/, hx509_vprint_func /*func*/,
void */*ctx*/); void */*ctx*/);
int int
hx509_ca_sign ( hx509_ca_sign (
hx509_context /*context*/, hx509_context /*context*/,
hx509_ca_tbs /*tbs*/, hx509_ca_tbs /*tbs*/,
skipping to change at line 160 skipping to change at line 163
hx509_name /*subject*/); hx509_name /*subject*/);
int int
hx509_ca_tbs_set_template ( hx509_ca_tbs_set_template (
hx509_context /*context*/, hx509_context /*context*/,
hx509_ca_tbs /*tbs*/, hx509_ca_tbs /*tbs*/,
int /*flags*/, int /*flags*/,
hx509_cert /*cert*/); hx509_cert /*cert*/);
int int
hx509_ca_tbs_set_unique (
hx509_context /*context*/,
hx509_ca_tbs /*tbs*/,
const heim_bit_string */*subjectUniqueID*/,
const heim_bit_string */*issuerUniqueID*/);
int
hx509_ca_tbs_subject_expand ( hx509_ca_tbs_subject_expand (
hx509_context /*context*/, hx509_context /*context*/,
hx509_ca_tbs /*tbs*/, hx509_ca_tbs /*tbs*/,
hx509_env /*env*/); hx509_env /*env*/);
const struct units * const struct units *
hx509_ca_tbs_template_units (void); hx509_ca_tbs_template_units (void);
int int
hx509_cert_binary ( hx509_cert_binary (
skipping to change at line 227 skipping to change at line 237
hx509_name */*name*/); hx509_name */*name*/);
const char * const char *
hx509_cert_get_friendly_name (hx509_cert /*cert*/); hx509_cert_get_friendly_name (hx509_cert /*cert*/);
int int
hx509_cert_get_issuer ( hx509_cert_get_issuer (
hx509_cert /*p*/, hx509_cert /*p*/,
hx509_name */*name*/); hx509_name */*name*/);
int
hx509_cert_get_issuer_unique_id (
hx509_context /*context*/,
hx509_cert /*p*/,
heim_bit_string */*issuer*/);
time_t time_t
hx509_cert_get_notAfter (hx509_cert /*p*/); hx509_cert_get_notAfter (hx509_cert /*p*/);
time_t time_t
hx509_cert_get_notBefore (hx509_cert /*p*/); hx509_cert_get_notBefore (hx509_cert /*p*/);
int int
hx509_cert_get_serialnumber ( hx509_cert_get_serialnumber (
hx509_cert /*p*/, hx509_cert /*p*/,
heim_integer */*i*/); heim_integer */*i*/);
int int
hx509_cert_get_subject ( hx509_cert_get_subject (
hx509_cert /*p*/, hx509_cert /*p*/,
hx509_name */*name*/); hx509_name */*name*/);
int int
hx509_cert_get_subject_unique_id (
hx509_context /*context*/,
hx509_cert /*p*/,
heim_bit_string */*subject*/);
int
hx509_cert_have_private_key (hx509_cert /*p*/); hx509_cert_have_private_key (hx509_cert /*p*/);
int int
hx509_cert_init ( hx509_cert_init (
hx509_context /*context*/, hx509_context /*context*/,
const Certificate */*c*/, const Certificate */*c*/,
hx509_cert */*cert*/); hx509_cert */*cert*/);
int int
hx509_cert_init_data ( hx509_cert_init_data (
skipping to change at line 324 skipping to change at line 346
void */*ctx*/); void */*ctx*/);
int int
hx509_certs_init ( hx509_certs_init (
hx509_context /*context*/, hx509_context /*context*/,
const char */*name*/, const char */*name*/,
int /*flags*/, int /*flags*/,
hx509_lock /*lock*/, hx509_lock /*lock*/,
hx509_certs */*certs*/); hx509_certs */*certs*/);
#ifdef __BLOCKS__
int int
hx509_certs_iter ( hx509_certs_iter (
hx509_context /*context*/, hx509_context /*context*/,
hx509_certs /*certs*/, hx509_certs /*certs*/,
int (^func)(hx509_cert));
#endif /* __BLOCKS__ */
int
hx509_certs_iter_f (
hx509_context /*context*/,
hx509_certs /*certs*/,
int (*/*func*/)(hx509_context, void *, hx509_cert), int (*/*func*/)(hx509_context, void *, hx509_cert),
void */*ctx*/); void */*ctx*/);
int int
hx509_certs_merge ( hx509_certs_merge (
hx509_context /*context*/, hx509_context /*context*/,
hx509_certs /*to*/, hx509_certs /*to*/,
hx509_certs /*from*/); hx509_certs /*from*/);
int int
skipping to change at line 979 skipping to change at line 1009
const AlgorithmIdentifier * const AlgorithmIdentifier *
hx509_signature_ecPublicKey (void); hx509_signature_ecPublicKey (void);
const AlgorithmIdentifier * const AlgorithmIdentifier *
hx509_signature_ecdsa_with_sha1 (void); hx509_signature_ecdsa_with_sha1 (void);
const AlgorithmIdentifier * const AlgorithmIdentifier *
hx509_signature_ecdsa_with_sha256 (void); hx509_signature_ecdsa_with_sha256 (void);
const AlgorithmIdentifier * const AlgorithmIdentifier *
hx509_signature_md2 (void);
const AlgorithmIdentifier *
hx509_signature_md5 (void); hx509_signature_md5 (void);
const AlgorithmIdentifier * const AlgorithmIdentifier *
hx509_signature_rsa (void); hx509_signature_rsa (void);
const AlgorithmIdentifier * const AlgorithmIdentifier *
hx509_signature_rsa_pkcs1_x509 (void); hx509_signature_rsa_pkcs1_x509 (void);
const AlgorithmIdentifier * const AlgorithmIdentifier *
hx509_signature_rsa_with_md2 (void);
const AlgorithmIdentifier *
hx509_signature_rsa_with_md5 (void); hx509_signature_rsa_with_md5 (void);
const AlgorithmIdentifier * const AlgorithmIdentifier *
hx509_signature_rsa_with_sha1 (void); hx509_signature_rsa_with_sha1 (void);
const AlgorithmIdentifier * const AlgorithmIdentifier *
hx509_signature_rsa_with_sha256 (void); hx509_signature_rsa_with_sha256 (void);
const AlgorithmIdentifier * const AlgorithmIdentifier *
hx509_signature_rsa_with_sha384 (void); hx509_signature_rsa_with_sha384 (void);
 End of changes. 11 change blocks. 
8 lines changed or deleted 32 lines changed or added


 hx509.h   hx509.h 
skipping to change at line 160 skipping to change at line 160
#define HX509_CA_TEMPLATE_NOTBEFORE 4 #define HX509_CA_TEMPLATE_NOTBEFORE 4
#define HX509_CA_TEMPLATE_NOTAFTER 8 #define HX509_CA_TEMPLATE_NOTAFTER 8
#define HX509_CA_TEMPLATE_SPKI 16 #define HX509_CA_TEMPLATE_SPKI 16
#define HX509_CA_TEMPLATE_KU 32 #define HX509_CA_TEMPLATE_KU 32
#define HX509_CA_TEMPLATE_EKU 64 #define HX509_CA_TEMPLATE_EKU 64
/* flags hx509_cms_create_signed* */ /* flags hx509_cms_create_signed* */
#define HX509_CMS_SIGNATURE_DETACHED 0x01 #define HX509_CMS_SIGNATURE_DETACHED 0x01
#define HX509_CMS_SIGNATURE_ID_NAME 0x02 #define HX509_CMS_SIGNATURE_ID_NAME 0x02
#define HX509_CMS_SIGNATURE_NO_SIGNER 0x04 #define HX509_CMS_SIGNATURE_NO_SIGNER 0x04
#define HX509_CMS_SIGNATURE_LEAF_ONLY 0x08
#define HX509_CMS_SIGNATURE_NO_CERTS 0x10
/* hx509_verify_hostname nametype */ /* hx509_verify_hostname nametype */
typedef enum { typedef enum {
HX509_HN_HOSTNAME = 0, HX509_HN_HOSTNAME = 0,
HX509_HN_DNSSRV HX509_HN_DNSSRV
} hx509_hostname_type; } hx509_hostname_type;
#include <hx509-protos.h> #include <hx509-protos.h>
#include <hx509_err.h> #include <hx509_err.h>
 End of changes. 1 change blocks. 
0 lines changed or deleted 2 lines changed or added


 kadm5-private.h   kadm5-private.h 
skipping to change at line 357 skipping to change at line 357
kadm5_ret_t kadm5_ret_t
kadm5_log_set_version ( kadm5_log_set_version (
kadm5_server_context */*context*/, kadm5_server_context */*context*/,
uint32_t /*vno*/); uint32_t /*vno*/);
const char * const char *
kadm5_log_signal_socket (krb5_context /*context*/); kadm5_log_signal_socket (krb5_context /*context*/);
kadm5_ret_t kadm5_ret_t
kadm5_log_signal_socket_info (
krb5_context /*context*/,
int /*server_end*/,
struct addrinfo **/*ret_addrs*/);
kadm5_ret_t
kadm5_log_truncate (kadm5_server_context */*server_context*/); kadm5_log_truncate (kadm5_server_context */*server_context*/);
kadm5_ret_t kadm5_ret_t
kadm5_s_chpass_principal ( kadm5_s_chpass_principal (
void */*server_handle*/, void */*server_handle*/,
krb5_principal /*princ*/, krb5_principal /*princ*/,
const char */*password*/); const char */*password*/);
kadm5_ret_t kadm5_ret_t
kadm5_s_chpass_principal_cond ( kadm5_s_chpass_principal_cond (
 End of changes. 1 change blocks. 
0 lines changed or deleted 6 lines changed or added


 kdc-protos.h   kdc-protos.h 
skipping to change at line 48 skipping to change at line 48
kdc_log_msg_va ( kdc_log_msg_va (
krb5_context /*context*/, krb5_context /*context*/,
krb5_kdc_configuration */*config*/, krb5_kdc_configuration */*config*/,
int /*level*/, int /*level*/,
const char */*fmt*/, const char */*fmt*/,
va_list /*ap*/); va_list /*ap*/);
void void
kdc_openlog ( kdc_openlog (
krb5_context /*context*/, krb5_context /*context*/,
const char */*service*/,
krb5_kdc_configuration */*config*/); krb5_kdc_configuration */*config*/);
krb5_error_code krb5_error_code
krb5_kdc_get_config ( krb5_kdc_get_config (
krb5_context /*context*/, krb5_context /*context*/,
krb5_kdc_configuration **/*config*/); krb5_kdc_configuration **/*config*/);
krb5_error_code
krb5_kdc_pk_initialize (
krb5_context /*context*/,
krb5_kdc_configuration */*config*/,
const char */*user_id*/,
const char */*anchors*/,
char **/*pool*/,
char **/*revoke_list*/);
int int
krb5_kdc_process_krb5_request ( krb5_kdc_process_krb5_request (
krb5_context /*context*/, krb5_context /*context*/,
krb5_kdc_configuration */*config*/, krb5_kdc_configuration */*config*/,
unsigned char */*buf*/, unsigned char */*buf*/,
size_t /*len*/, size_t /*len*/,
krb5_data */*reply*/, krb5_data */*reply*/,
const char */*from*/, const char */*from*/,
struct sockaddr */*addr*/, struct sockaddr */*addr*/,
int /*datagram_reply*/); int /*datagram_reply*/);
 End of changes. 2 change blocks. 
0 lines changed or deleted 10 lines changed or added


 kdc.h   kdc.h 
skipping to change at line 77 skipping to change at line 77
krb5_boolean enable_v4; krb5_boolean enable_v4;
krb5_boolean enable_v4_cross_realm; krb5_boolean enable_v4_cross_realm;
krb5_boolean enable_v4_per_principal; krb5_boolean enable_v4_per_principal;
krb5_boolean enable_kaserver; krb5_boolean enable_kaserver;
krb5_boolean enable_524; krb5_boolean enable_524;
krb5_boolean enable_pkinit; krb5_boolean enable_pkinit;
krb5_boolean pkinit_princ_in_cert; krb5_boolean pkinit_princ_in_cert;
char *pkinit_kdc_ocsp_file; const char *pkinit_kdc_identity;
char *pkinit_kdc_friendly_name; const char *pkinit_kdc_anchors;
const char *pkinit_kdc_friendly_name;
const char *pkinit_kdc_ocsp_file;
char **pkinit_kdc_cert_pool;
char **pkinit_kdc_revoke;
int pkinit_dh_min_bits; int pkinit_dh_min_bits;
int pkinit_require_binding; int pkinit_require_binding;
int pkinit_allow_proxy_certs; int pkinit_allow_proxy_certs;
krb5_log_facility *logf; krb5_log_facility *logf;
int enable_digest; int enable_digest;
int digests_allowed; int digests_allowed;
size_t max_datagram_reply_length; size_t max_datagram_reply_length;
 End of changes. 1 change blocks. 
2 lines changed or deleted 6 lines changed or added


 krb5-private.h   krb5-private.h 
/* This is a generated file */ /* This is a generated file */
#ifndef __krb5_private_h__ #ifndef __krb5_private_h__
#define __krb5_private_h__ #define __krb5_private_h__
#include <stdarg.h> #include <stdarg.h>
#if !defined(__GNUC__) && !defined(__attribute__) #if !defined(__GNUC__) && !defined(__attribute__)
#define __attribute__(x) #define __attribute__(x)
#endif #endif
krb5_error_code KRB5_LIB_FUNCTION void
_heim_krb5_ipc_client_clear_target (void);
void
_heim_krb5_ipc_client_set_target_uid (uid_t /*uid*/);
KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_build_authenticator ( _krb5_build_authenticator (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_enctype /*enctype*/, krb5_enctype /*enctype*/,
krb5_creds */*cred*/, krb5_creds */*cred*/,
Checksum */*cksum*/, Checksum */*cksum*/,
krb5_data */*result*/, krb5_data */*result*/,
krb5_key_usage /*usage*/); krb5_key_usage /*usage*/);
krb5_error_code krb5_error_code
_krb5_cc_allocate ( _krb5_cc_allocate (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_cc_ops */*ops*/, const krb5_cc_ops */*ops*/,
krb5_ccache */*id*/); krb5_ccache */*id*/);
krb5_error_code KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_config_copy ( _krb5_config_copy (
krb5_context /*context*/, krb5_context /*context*/,
krb5_config_section */*c*/, krb5_config_section */*c*/,
krb5_config_section **/*head*/); krb5_config_section **/*head*/);
const void * KRB5_LIB_FUNCTION const void * KRB5_LIB_CALL
_krb5_config_get ( _krb5_config_get (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
int /*type*/, int /*type*/,
...); ...);
const void * KRB5_LIB_FUNCTION const void * KRB5_LIB_CALL
_krb5_config_get_next ( _krb5_config_get_next (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
const krb5_config_binding **/*pointer*/, const krb5_config_binding **/*pointer*/,
int /*type*/, int /*type*/,
...); ...);
const void * const void *
_krb5_config_vget ( _krb5_config_vget (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
int /*type*/, int /*type*/,
va_list /*args*/); va_list /*args*/);
const void * KRB5_LIB_FUNCTION const void * KRB5_LIB_CALL
_krb5_config_vget_next ( _krb5_config_vget_next (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
const krb5_config_binding **/*pointer*/, const krb5_config_binding **/*pointer*/,
int /*type*/, int /*type*/,
va_list /*args*/); va_list /*args*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_copy_send_to_kdc_func ( _krb5_copy_send_to_kdc_func (
krb5_context /*context*/, krb5_context /*context*/,
krb5_context /*to*/); krb5_context /*to*/);
void void
_krb5_crc_init_table (void); _krb5_crc_init_table (void);
uint32_t uint32_t
_krb5_crc_update ( _krb5_crc_update (
const char */*p*/, const char */*p*/,
skipping to change at line 106 skipping to change at line 112
_krb5_erase_file ( _krb5_erase_file (
krb5_context /*context*/, krb5_context /*context*/,
const char */*filename*/); const char */*filename*/);
krb5_error_code krb5_error_code
_krb5_expand_default_cc_name ( _krb5_expand_default_cc_name (
krb5_context /*context*/, krb5_context /*context*/,
const char */*str*/, const char */*str*/,
char **/*res*/); char **/*res*/);
KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_expand_path_tokens (
krb5_context /*context*/,
const char */*path_in*/,
char **/*ppath_out*/);
int int
_krb5_extract_ticket ( _krb5_extract_ticket (
krb5_context /*context*/, krb5_context /*context*/,
krb5_kdc_rep */*rep*/, krb5_kdc_rep */*rep*/,
krb5_creds */*creds*/, krb5_creds */*creds*/,
krb5_keyblock */*key*/, krb5_keyblock */*key*/,
krb5_const_pointer /*keyseed*/, krb5_const_pointer /*keyseed*/,
krb5_key_usage /*key_usage*/, krb5_key_usage /*key_usage*/,
krb5_addresses */*addrs*/, krb5_addresses */*addrs*/,
unsigned /*nonce*/, unsigned /*nonce*/,
skipping to change at line 142 skipping to change at line 154
krb5_principal /*impersonate_principal*/, krb5_principal /*impersonate_principal*/,
Ticket */*second_ticket*/, Ticket */*second_ticket*/,
krb5_creds **/*out_creds*/, krb5_creds **/*out_creds*/,
krb5_creds ***/*ret_tgts*/); krb5_creds ***/*ret_tgts*/);
krb5_error_code krb5_error_code
_krb5_get_default_principal_local ( _krb5_get_default_principal_local (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal */*princ*/); krb5_principal */*princ*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_get_host_realm_int ( _krb5_get_host_realm_int (
krb5_context /*context*/, krb5_context /*context*/,
const char */*host*/, const char */*host*/,
krb5_boolean /*use_dns*/, krb5_boolean /*use_dns*/,
krb5_realm **/*realms*/); krb5_realm **/*realms*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
_krb5_get_init_creds_opt_free_pkinit (krb5_get_init_creds_opt */*opt*/); _krb5_get_init_creds_opt_free_pkinit (krb5_get_init_creds_opt */*opt*/);
krb5_error_code KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_FUNCTION
_krb5_get_init_creds_opt_set_pkinit_user_certs ( _krb5_get_init_creds_opt_set_pkinit_user_certs (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_init_creds_opt */*opt*/, krb5_get_init_creds_opt */*opt*/,
struct hx509_certs_data */*certs*/); struct hx509_certs_data */*certs*/);
krb5_ssize_t KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_ssize_t KRB5_LIB_CALL
_krb5_get_int ( _krb5_get_int (
void */*buffer*/, void */*buffer*/,
unsigned long */*value*/, unsigned long */*value*/,
size_t /*size*/); size_t /*size*/);
krb5_error_code krb5_error_code
_krb5_get_krbtgt ( _krb5_get_krbtgt (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/, krb5_ccache /*id*/,
krb5_realm /*realm*/, krb5_realm /*realm*/,
krb5_creds **/*cred*/); krb5_creds **/*cred*/);
krb5_boolean krb5_boolean KRB5_LIB_FUNCTION
_krb5_homedir_access (krb5_context /*context*/); _krb5_have_debug (
krb5_error_code
_krb5_kcm_chmod (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/, int /*level*/);
uint16_t /*mode*/);
krb5_error_code krb5_boolean
_krb5_kcm_chown ( _krb5_homedir_access (krb5_context /*context*/);
krb5_context /*context*/,
krb5_ccache /*id*/,
uint32_t /*uid*/,
uint32_t /*gid*/);
krb5_error_code krb5_error_code
_krb5_kcm_get_initial_ticket ( _krb5_kcm_get_initial_ticket (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/, krb5_ccache /*id*/,
krb5_principal /*server*/, krb5_principal /*server*/,
krb5_keyblock */*key*/); krb5_keyblock */*key*/);
krb5_error_code krb5_error_code
_krb5_kcm_get_ticket ( _krb5_kcm_get_ticket (
skipping to change at line 210 skipping to change at line 214
krb5_principal /*server*/); krb5_principal /*server*/);
krb5_boolean krb5_boolean
_krb5_kcm_is_running (krb5_context /*context*/); _krb5_kcm_is_running (krb5_context /*context*/);
krb5_error_code krb5_error_code
_krb5_kcm_noop ( _krb5_kcm_noop (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/); krb5_ccache /*id*/);
krb5_error_code krb5_error_code KRB5_CALLCONV
_krb5_kdc_retry ( _krb5_kdc_retry (
krb5_context /*context*/, krb5_context /*context*/,
krb5_sendto_ctx /*ctx*/, krb5_sendto_ctx /*ctx*/,
void */*data*/, void */*data*/,
const krb5_data */*reply*/, const krb5_data */*reply*/,
int */*action*/); int */*action*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_krb_cr_err_reply ( _krb5_krb_cr_err_reply (
krb5_context /*context*/, krb5_context /*context*/,
const char */*name*/, const char */*name*/,
const char */*inst*/, const char */*inst*/,
const char */*realm*/, const char */*realm*/,
uint32_t /*time_ws*/, uint32_t /*time_ws*/,
uint32_t /*e*/, uint32_t /*e*/,
const char */*e_string*/, const char */*e_string*/,
krb5_data */*data*/); krb5_data */*data*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_krb_create_auth_reply ( _krb5_krb_create_auth_reply (
krb5_context /*context*/, krb5_context /*context*/,
const char */*pname*/, const char */*pname*/,
const char */*pinst*/, const char */*pinst*/,
const char */*prealm*/, const char */*prealm*/,
int32_t /*time_ws*/, int32_t /*time_ws*/,
int /*n*/, int /*n*/,
uint32_t /*x_date*/, uint32_t /*x_date*/,
unsigned char /*kvno*/, unsigned char /*kvno*/,
const krb5_data */*cipher*/, const krb5_data */*cipher*/,
krb5_data */*data*/); krb5_data */*data*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_krb_create_ciph ( _krb5_krb_create_ciph (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_keyblock */*session*/, const krb5_keyblock */*session*/,
const char */*service*/, const char */*service*/,
const char */*instance*/, const char */*instance*/,
const char */*realm*/, const char */*realm*/,
uint32_t /*life*/, uint32_t /*life*/,
unsigned char /*kvno*/, unsigned char /*kvno*/,
const krb5_data */*ticket*/, const krb5_data */*ticket*/,
uint32_t /*kdc_time*/, uint32_t /*kdc_time*/,
const krb5_keyblock */*key*/, const krb5_keyblock */*key*/,
krb5_data */*enc_data*/); krb5_data */*enc_data*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_krb_create_ticket ( _krb5_krb_create_ticket (
krb5_context /*context*/, krb5_context /*context*/,
unsigned char /*flags*/, unsigned char /*flags*/,
const char */*pname*/, const char */*pname*/,
const char */*pinstance*/, const char */*pinstance*/,
const char */*prealm*/, const char */*prealm*/,
int32_t /*paddress*/, int32_t /*paddress*/,
const krb5_keyblock */*session*/, const krb5_keyblock */*session*/,
int16_t /*life*/, int16_t /*life*/,
int32_t /*life_sec*/, int32_t /*life_sec*/,
const char */*sname*/, const char */*sname*/,
const char */*sinstance*/, const char */*sinstance*/,
const krb5_keyblock */*key*/, const krb5_keyblock */*key*/,
krb5_data */*enc_data*/); krb5_data */*enc_data*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_krb_decomp_ticket ( _krb5_krb_decomp_ticket (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_data */*enc_ticket*/, const krb5_data */*enc_ticket*/,
const krb5_keyblock */*key*/, const krb5_keyblock */*key*/,
const char */*local_realm*/, const char */*local_realm*/,
char **/*sname*/, char **/*sname*/,
char **/*sinstance*/, char **/*sinstance*/,
struct _krb5_krb_auth_data */*ad*/); struct _krb5_krb_auth_data */*ad*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_krb_dest_tkt ( _krb5_krb_dest_tkt (
krb5_context /*context*/, krb5_context /*context*/,
const char */*tkfile*/); const char */*tkfile*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
_krb5_krb_free_auth_data ( _krb5_krb_free_auth_data (
krb5_context /*context*/, krb5_context /*context*/,
struct _krb5_krb_auth_data */*ad*/); struct _krb5_krb_auth_data */*ad*/);
time_t KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION time_t KRB5_LIB_CALL
_krb5_krb_life_to_time ( _krb5_krb_life_to_time (
int /*start*/, int /*start*/,
int /*life_*/); int /*life_*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_krb_rd_req ( _krb5_krb_rd_req (
krb5_context /*context*/, krb5_context /*context*/,
krb5_data */*authent*/, krb5_data */*authent*/,
const char */*service*/, const char */*service*/,
const char */*instance*/, const char */*instance*/,
const char */*local_realm*/, const char */*local_realm*/,
int32_t /*from_addr*/, int32_t /*from_addr*/,
const krb5_keyblock */*key*/, const krb5_keyblock */*key*/,
struct _krb5_krb_auth_data */*ad*/); struct _krb5_krb_auth_data */*ad*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_krb_tf_setup ( _krb5_krb_tf_setup (
krb5_context /*context*/, krb5_context /*context*/,
struct credentials */*v4creds*/, struct credentials */*v4creds*/,
const char */*tkfile*/, const char */*tkfile*/,
int /*append*/); int /*append*/);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
_krb5_krb_time_to_life ( _krb5_krb_time_to_life (
time_t /*start*/, time_t /*start*/,
time_t /*end*/); time_t /*end*/);
krb5_error_code krb5_error_code
_krb5_krbhost_info_move ( _krb5_krbhost_info_move (
krb5_context /*context*/, krb5_context /*context*/,
krb5_krbhst_info */*from*/, krb5_krbhst_info */*from*/,
krb5_krbhst_info **/*to*/); krb5_krbhst_info **/*to*/);
skipping to change at line 349 skipping to change at line 353
_krb5_mk_req_internal ( _krb5_mk_req_internal (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context */*auth_context*/, krb5_auth_context */*auth_context*/,
const krb5_flags /*ap_req_options*/, const krb5_flags /*ap_req_options*/,
krb5_data */*in_data*/, krb5_data */*in_data*/,
krb5_creds */*in_creds*/, krb5_creds */*in_creds*/,
krb5_data */*outbuf*/, krb5_data */*outbuf*/,
krb5_key_usage /*checksum_usage*/, krb5_key_usage /*checksum_usage*/,
krb5_key_usage /*encrypt_usage*/); krb5_key_usage /*encrypt_usage*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_n_fold ( _krb5_n_fold (
const void */*str*/, const void */*str*/,
size_t /*len*/, size_t /*len*/,
void */*key*/, void */*key*/,
size_t /*size*/); size_t /*size*/);
krb5_error_code krb5_error_code
_krb5_pac_sign ( _krb5_pac_sign (
krb5_context /*context*/, krb5_context /*context*/,
krb5_pac /*p*/, krb5_pac /*p*/,
skipping to change at line 380 skipping to change at line 384
struct krb5_dh_moduli ***/*moduli*/); struct krb5_dh_moduli ***/*moduli*/);
krb5_error_code krb5_error_code
_krb5_parse_moduli_line ( _krb5_parse_moduli_line (
krb5_context /*context*/, krb5_context /*context*/,
const char */*file*/, const char */*file*/,
int /*lineno*/, int /*lineno*/,
char */*p*/, char */*p*/,
struct krb5_dh_moduli **/*m*/); struct krb5_dh_moduli **/*m*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
_krb5_pk_cert_free (struct krb5_pk_cert */*cert*/); _krb5_pk_cert_free (struct krb5_pk_cert */*cert*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_pk_enterprise_cert ( _krb5_pk_enterprise_cert (
krb5_context /*context*/, krb5_context /*context*/,
const char */*user_id*/, const char */*user_id*/,
krb5_const_realm /*realm*/, krb5_const_realm /*realm*/,
krb5_principal */*principal*/, krb5_principal */*principal*/,
struct hx509_certs_data **/*res*/); struct hx509_certs_data **/*res*/);
krb5_error_code krb5_error_code
_krb5_pk_kdf ( _krb5_pk_kdf (
krb5_context /*context*/, krb5_context /*context*/,
skipping to change at line 405 skipping to change at line 409
const void */*dhdata*/, const void */*dhdata*/,
size_t /*dhsize*/, size_t /*dhsize*/,
krb5_const_principal /*client*/, krb5_const_principal /*client*/,
krb5_const_principal /*server*/, krb5_const_principal /*server*/,
krb5_enctype /*enctype*/, krb5_enctype /*enctype*/,
const krb5_data */*as_req*/, const krb5_data */*as_req*/,
const krb5_data */*pk_as_rep*/, const krb5_data */*pk_as_rep*/,
const Ticket */*ticket*/, const Ticket */*ticket*/,
krb5_keyblock */*key*/); krb5_keyblock */*key*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_pk_load_id ( _krb5_pk_load_id (
krb5_context /*context*/, krb5_context /*context*/,
struct krb5_pk_identity **/*ret_id*/, struct krb5_pk_identity **/*ret_id*/,
const char */*user_id*/, const char */*user_id*/,
const char */*anchor_id*/, const char */*anchor_id*/,
char * const */*chain_list*/, char * const */*chain_list*/,
char * const */*revoke_list*/, char * const */*revoke_list*/,
krb5_prompter_fct /*prompter*/, krb5_prompter_fct /*prompter*/,
void */*prompter_data*/, void */*prompter_data*/,
char */*password*/); char */*password*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_pk_mk_ContentInfo ( _krb5_pk_mk_ContentInfo (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_data */*buf*/, const krb5_data */*buf*/,
const heim_oid */*oid*/, const heim_oid */*oid*/,
struct ContentInfo */*content_info*/); struct ContentInfo */*content_info*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_pk_mk_padata ( _krb5_pk_mk_padata (
krb5_context /*context*/, krb5_context /*context*/,
void */*c*/, void */*c*/,
int /*ic_flags*/,
int /*win2k*/,
const KDC_REQ_BODY */*req_body*/, const KDC_REQ_BODY */*req_body*/,
unsigned /*nonce*/, unsigned /*nonce*/,
METHOD_DATA */*md*/); METHOD_DATA */*md*/);
krb5_error_code krb5_error_code
_krb5_pk_octetstring2key ( _krb5_pk_octetstring2key (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*type*/, krb5_enctype /*type*/,
const void */*dhdata*/, const void */*dhdata*/,
size_t /*dhsize*/, size_t /*dhsize*/,
const heim_octet_string */*c_n*/, const heim_octet_string */*c_n*/,
const heim_octet_string */*k_n*/, const heim_octet_string */*k_n*/,
krb5_keyblock */*key*/); krb5_keyblock */*key*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_pk_rd_pa_reply ( _krb5_pk_rd_pa_reply (
krb5_context /*context*/, krb5_context /*context*/,
const char */*realm*/, const char */*realm*/,
void */*c*/, void */*c*/,
krb5_enctype /*etype*/, krb5_enctype /*etype*/,
const krb5_krbhst_info */*hi*/, const krb5_krbhst_info */*hi*/,
unsigned /*nonce*/, unsigned /*nonce*/,
const krb5_data */*req_buffer*/, const krb5_data */*req_buffer*/,
PA_DATA */*pa*/, PA_DATA */*pa*/,
krb5_keyblock **/*key*/); krb5_keyblock **/*key*/);
skipping to change at line 470 skipping to change at line 476
void void
_krb5_plugin_free (struct krb5_plugin */*list*/); _krb5_plugin_free (struct krb5_plugin */*list*/);
struct krb5_plugin * struct krb5_plugin *
_krb5_plugin_get_next (struct krb5_plugin */*p*/); _krb5_plugin_get_next (struct krb5_plugin */*p*/);
void * void *
_krb5_plugin_get_symbol (struct krb5_plugin */*p*/); _krb5_plugin_get_symbol (struct krb5_plugin */*p*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_principal2principalname ( _krb5_principal2principalname (
PrincipalName */*p*/, PrincipalName */*p*/,
const krb5_principal /*from*/); const krb5_principal /*from*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
_krb5_principal_compare_PrincipalName ( _krb5_principal_compare_PrincipalName (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*princ1*/, krb5_const_principal /*princ1*/,
PrincipalName */*princ2*/); PrincipalName */*princ2*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_principalname2krb5_principal ( _krb5_principalname2krb5_principal (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal */*principal*/, krb5_principal */*principal*/,
const PrincipalName /*from*/, const PrincipalName /*from*/,
const Realm /*realm*/); const Realm /*realm*/);
krb5_ssize_t KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_ssize_t KRB5_LIB_CALL
_krb5_put_int ( _krb5_put_int (
void */*buffer*/, void */*buffer*/,
unsigned long /*value*/, unsigned long /*value*/,
size_t /*size*/); size_t /*size*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_s4u2self_to_checksumdata ( _krb5_s4u2self_to_checksumdata (
krb5_context /*context*/, krb5_context /*context*/,
const PA_S4U2Self */*self*/, const PA_S4U2Self */*self*/,
krb5_data */*data*/); krb5_data */*data*/);
int int
_krb5_send_and_recv_tcp ( _krb5_send_and_recv_tcp (
int /*fd*/, krb5_socket_t /*fd*/,
time_t /*tmout*/, time_t /*tmout*/,
const krb5_data */*req*/, const krb5_data */*req*/,
krb5_data */*rep*/); krb5_data */*rep*/);
int int
_krb5_xlock ( _krb5_xlock (
krb5_context /*context*/, krb5_context /*context*/,
int /*fd*/, int /*fd*/,
krb5_boolean /*exclusive*/, krb5_boolean /*exclusive*/,
const char */*filename*/); const char */*filename*/);
 End of changes. 39 change blocks. 
47 lines changed or deleted 53 lines changed or added


 krb5-protos.h   krb5-protos.h 
skipping to change at line 16 skipping to change at line 16
#if !defined(__GNUC__) && !defined(__attribute__) #if !defined(__GNUC__) && !defined(__attribute__)
#define __attribute__(x) #define __attribute__(x)
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#ifndef KRB5_LIB #ifndef KRB5_LIB
#ifndef KRB5_LIB_FUNCTION
#if defined(_WIN32) #if defined(_WIN32)
#define KRB5_LIB_FUNCTION __stdcall __declspec(dllimport) #define KRB5_LIB_FUNCTION __declspec(dllimport)
#define KRB5_LIB_CALL __stdcall
#define KRB5_LIB_VARIABLE __declspec(dllimport) #define KRB5_LIB_VARIABLE __declspec(dllimport)
#else #else
#define KRB5_LIB_FUNCTION #define KRB5_LIB_FUNCTION
#define KRB5_LIB_CALL
#define KRB5_LIB_VARIABLE #define KRB5_LIB_VARIABLE
#endif #endif
#endif #endif
#endif
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb524_convert_creds_kdc ( krb524_convert_creds_kdc (
krb5_context /*context*/, krb5_context /*context*/,
krb5_creds */*in_cred*/, krb5_creds */*in_cred*/,
struct credentials */*v4creds*/); struct credentials */*v4creds*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb524_convert_creds_kdc_ccache ( krb524_convert_creds_kdc_ccache (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
krb5_creds */*in_cred*/, krb5_creds */*in_cred*/,
struct credentials */*v4creds*/); struct credentials */*v4creds*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_425_conv_principal ( krb5_425_conv_principal (
krb5_context /*context*/, krb5_context /*context*/,
const char */*name*/, const char */*name*/,
const char */*instance*/, const char */*instance*/,
const char */*realm*/, const char */*realm*/,
krb5_principal */*princ*/) krb5_principal */*princ*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_425_conv_principal_ext ( krb5_425_conv_principal_ext (
krb5_context /*context*/, krb5_context /*context*/,
const char */*name*/, const char */*name*/,
const char */*instance*/, const char */*instance*/,
const char */*realm*/, const char */*realm*/,
krb5_boolean (*/*func*/)(krb5_context, krb5_principal), krb5_boolean (*/*func*/)(krb5_context, krb5_principal),
krb5_boolean /*resolve*/, krb5_boolean /*resolve*/,
krb5_principal */*principal*/) krb5_principal */*principal*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_425_conv_principal_ext2 ( krb5_425_conv_principal_ext2 (
krb5_context /*context*/, krb5_context /*context*/,
const char */*name*/, const char */*name*/,
const char */*instance*/, const char */*instance*/,
const char */*realm*/, const char */*realm*/,
krb5_boolean (*/*func*/)(krb5_context, void *, krb5_principal), krb5_boolean (*/*func*/)(krb5_context, void *, krb5_principal),
void */*funcctx*/, void */*funcctx*/,
krb5_boolean /*resolve*/, krb5_boolean /*resolve*/,
krb5_principal */*princ*/); krb5_principal */*princ*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_524_conv_principal ( krb5_524_conv_principal (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_principal /*principal*/, const krb5_principal /*principal*/,
char */*name*/, char */*name*/,
char */*instance*/, char */*instance*/,
char */*realm*/); char */*realm*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_abort ( krb5_abort (
krb5_context /*context*/, krb5_context /*context*/,
krb5_error_code /*code*/, krb5_error_code /*code*/,
const char */*fmt*/, const char */*fmt*/,
...) ...)
__attribute__ ((noreturn, format (printf, 3, 4))); __attribute__ ((noreturn, format (printf, 3, 4)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_abortx ( krb5_abortx (
krb5_context /*context*/, krb5_context /*context*/,
const char */*fmt*/, const char */*fmt*/,
...) ...)
__attribute__ ((noreturn, format (printf, 2, 3))); __attribute__ ((noreturn, format (printf, 2, 3)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_acl_match_file ( krb5_acl_match_file (
krb5_context /*context*/, krb5_context /*context*/,
const char */*file*/, const char */*file*/,
const char */*format*/, const char */*format*/,
...); ...);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_acl_match_string ( krb5_acl_match_string (
krb5_context /*context*/, krb5_context /*context*/,
const char */*string*/, const char */*string*/,
const char */*format*/, const char */*format*/,
...); ...);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_add_et_list ( krb5_add_et_list (
krb5_context /*context*/, krb5_context /*context*/,
void (*/*func*/)(struct et_list **)); void (*/*func*/)(struct et_list **));
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_add_extra_addresses ( krb5_add_extra_addresses (
krb5_context /*context*/, krb5_context /*context*/,
krb5_addresses */*addresses*/); krb5_addresses */*addresses*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_add_ignore_addresses ( krb5_add_ignore_addresses (
krb5_context /*context*/, krb5_context /*context*/,
krb5_addresses */*addresses*/); krb5_addresses */*addresses*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_addlog_dest ( krb5_addlog_dest (
krb5_context /*context*/, krb5_context /*context*/,
krb5_log_facility */*f*/, krb5_log_facility */*f*/,
const char */*orig*/); const char */*orig*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_addlog_func ( krb5_addlog_func (
krb5_context /*context*/, krb5_context /*context*/,
krb5_log_facility */*fac*/, krb5_log_facility */*fac*/,
int /*min*/, int /*min*/,
int /*max*/, int /*max*/,
krb5_log_log_func_t /*log_func*/, krb5_log_log_func_t /*log_func*/,
krb5_log_close_func_t /*close_func*/, krb5_log_close_func_t /*close_func*/,
void */*data*/); void */*data*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_addr2sockaddr ( krb5_addr2sockaddr (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_address */*addr*/, const krb5_address */*addr*/,
struct sockaddr */*sa*/, struct sockaddr */*sa*/,
krb5_socklen_t */*sa_size*/, krb5_socklen_t */*sa_size*/,
int /*port*/); int /*port*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_address_compare ( krb5_address_compare (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_address */*addr1*/, const krb5_address */*addr1*/,
const krb5_address */*addr2*/); const krb5_address */*addr2*/);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
krb5_address_order ( krb5_address_order (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_address */*addr1*/, const krb5_address */*addr1*/,
const krb5_address */*addr2*/); const krb5_address */*addr2*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_address_prefixlen_boundary ( krb5_address_prefixlen_boundary (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_address */*inaddr*/, const krb5_address */*inaddr*/,
unsigned long /*prefixlen*/, unsigned long /*prefixlen*/,
krb5_address */*low*/, krb5_address */*low*/,
krb5_address */*high*/); krb5_address */*high*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_address_search ( krb5_address_search (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_address */*addr*/, const krb5_address */*addr*/,
const krb5_addresses */*addrlist*/); const krb5_addresses */*addrlist*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_allow_weak_crypto ( krb5_allow_weak_crypto (
krb5_context /*context*/, krb5_context /*context*/,
krb5_boolean /*enable*/); krb5_boolean /*enable*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_aname_to_localname ( krb5_aname_to_localname (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*aname*/, krb5_const_principal /*aname*/,
size_t /*lnsize*/, size_t /*lnsize*/,
char */*lname*/); char */*lname*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_anyaddr ( krb5_anyaddr (
krb5_context /*context*/, krb5_context /*context*/,
int /*af*/, int /*af*/,
struct sockaddr */*sa*/, struct sockaddr */*sa*/,
krb5_socklen_t */*sa_size*/, krb5_socklen_t */*sa_size*/,
int /*port*/); int /*port*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_appdefault_boolean ( krb5_appdefault_boolean (
krb5_context /*context*/, krb5_context /*context*/,
const char */*appname*/, const char */*appname*/,
krb5_const_realm /*realm*/, krb5_const_realm /*realm*/,
const char */*option*/, const char */*option*/,
krb5_boolean /*def_val*/, krb5_boolean /*def_val*/,
krb5_boolean */*ret_val*/); krb5_boolean */*ret_val*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_appdefault_string ( krb5_appdefault_string (
krb5_context /*context*/, krb5_context /*context*/,
const char */*appname*/, const char */*appname*/,
krb5_const_realm /*realm*/, krb5_const_realm /*realm*/,
const char */*option*/, const char */*option*/,
const char */*def_val*/, const char */*def_val*/,
char **/*ret_val*/); char **/*ret_val*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_appdefault_time ( krb5_appdefault_time (
krb5_context /*context*/, krb5_context /*context*/,
const char */*appname*/, const char */*appname*/,
krb5_const_realm /*realm*/, krb5_const_realm /*realm*/,
const char */*option*/, const char */*option*/,
time_t /*def_val*/, time_t /*def_val*/,
time_t */*ret_val*/); time_t */*ret_val*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_append_addresses ( krb5_append_addresses (
krb5_context /*context*/, krb5_context /*context*/,
krb5_addresses */*dest*/, krb5_addresses */*dest*/,
const krb5_addresses */*source*/); const krb5_addresses */*source*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_addflags ( krb5_auth_con_addflags (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
int32_t /*addflags*/, int32_t /*addflags*/,
int32_t */*flags*/); int32_t */*flags*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_free ( krb5_auth_con_free (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/); krb5_auth_context /*auth_context*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_genaddrs ( krb5_auth_con_genaddrs (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
int /*fd*/, krb5_socket_t /*fd*/,
int /*flags*/); int /*flags*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_generatelocalsubkey ( krb5_auth_con_generatelocalsubkey (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_keyblock */*key*/); krb5_keyblock */*key*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_getaddrs ( krb5_auth_con_getaddrs (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_address **/*local_addr*/, krb5_address **/*local_addr*/,
krb5_address **/*remote_addr*/); krb5_address **/*remote_addr*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_getauthenticator ( krb5_auth_con_getauthenticator (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_authenticator */*authenticator*/); krb5_authenticator */*authenticator*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_getcksumtype ( krb5_auth_con_getcksumtype (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_cksumtype */*cksumtype*/); krb5_cksumtype */*cksumtype*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_getflags ( krb5_auth_con_getflags (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
int32_t */*flags*/); int32_t */*flags*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_getkey ( krb5_auth_con_getkey (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_keyblock **/*keyblock*/); krb5_keyblock **/*keyblock*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_getkeytype ( krb5_auth_con_getkeytype (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_keytype */*keytype*/); krb5_keytype */*keytype*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_getlocalseqnumber ( krb5_auth_con_getlocalseqnumber (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
int32_t */*seqnumber*/); int32_t */*seqnumber*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_getlocalsubkey ( krb5_auth_con_getlocalsubkey (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_keyblock **/*keyblock*/); krb5_keyblock **/*keyblock*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_getrcache ( krb5_auth_con_getrcache (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_rcache */*rcache*/); krb5_rcache */*rcache*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_getremoteseqnumber (
krb5_context /*context*/,
krb5_auth_context /*auth_context*/,
int32_t */*seqnumber*/);
KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_getremotesubkey ( krb5_auth_con_getremotesubkey (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_keyblock **/*keyblock*/); krb5_keyblock **/*keyblock*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_init ( krb5_auth_con_init (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context */*auth_context*/); krb5_auth_context */*auth_context*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_removeflags ( krb5_auth_con_removeflags (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
int32_t /*removeflags*/, int32_t /*removeflags*/,
int32_t */*flags*/); int32_t */*flags*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_setaddrs ( krb5_auth_con_setaddrs (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_address */*local_addr*/, krb5_address */*local_addr*/,
krb5_address */*remote_addr*/); krb5_address */*remote_addr*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_setaddrs_from_fd ( krb5_auth_con_setaddrs_from_fd (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
void */*p_fd*/); void */*p_fd*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_setcksumtype ( krb5_auth_con_setcksumtype (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_cksumtype /*cksumtype*/); krb5_cksumtype /*cksumtype*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_setflags ( krb5_auth_con_setflags (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
int32_t /*flags*/); int32_t /*flags*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_setkey ( krb5_auth_con_setkey (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_keyblock */*keyblock*/); krb5_keyblock */*keyblock*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_setkeytype ( krb5_auth_con_setkeytype (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_keytype /*keytype*/); krb5_keytype /*keytype*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_setlocalseqnumber ( krb5_auth_con_setlocalseqnumber (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
int32_t /*seqnumber*/); int32_t /*seqnumber*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_setlocalsubkey ( krb5_auth_con_setlocalsubkey (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_keyblock */*keyblock*/); krb5_keyblock */*keyblock*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_setrcache ( krb5_auth_con_setrcache (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_rcache /*rcache*/); krb5_rcache /*rcache*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_setremoteseqnumber ( krb5_auth_con_setremoteseqnumber (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
int32_t /*seqnumber*/); int32_t /*seqnumber*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_setremotesubkey ( krb5_auth_con_setremotesubkey (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_keyblock */*keyblock*/); krb5_keyblock */*keyblock*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_con_setuserkey ( krb5_auth_con_setuserkey (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_keyblock */*keyblock*/); krb5_keyblock */*keyblock*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED krb5_error_code KRB5_LIB_FUNCTION
krb5_auth_getremoteseqnumber ( krb5_auth_getremoteseqnumber (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
int32_t */*seqnumber*/); int32_t */*seqnumber*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_build_ap_req ( krb5_build_ap_req (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*enctype*/, krb5_enctype /*enctype*/,
krb5_creds */*cred*/, krb5_creds */*cred*/,
krb5_flags /*ap_options*/, krb5_flags /*ap_options*/,
krb5_data /*authenticator*/, krb5_data /*authenticator*/,
krb5_data */*retdata*/); krb5_data */*retdata*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_build_principal ( krb5_build_principal (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal */*principal*/, krb5_principal */*principal*/,
int /*rlen*/, int /*rlen*/,
krb5_const_realm /*realm*/, krb5_const_realm /*realm*/,
...); ...);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_build_principal_ext ( krb5_build_principal_ext (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal */*principal*/, krb5_principal */*principal*/,
int /*rlen*/, int /*rlen*/,
krb5_const_realm /*realm*/, krb5_const_realm /*realm*/,
...); ...);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_build_principal_va ( krb5_build_principal_va (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal */*principal*/, krb5_principal */*principal*/,
int /*rlen*/, int /*rlen*/,
krb5_const_realm /*realm*/, krb5_const_realm /*realm*/,
va_list /*ap*/); va_list /*ap*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_build_principal_va_ext ( krb5_build_principal_va_ext (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal */*principal*/, krb5_principal */*principal*/,
int /*rlen*/, int /*rlen*/,
krb5_const_realm /*realm*/, krb5_const_realm /*realm*/,
va_list /*ap*/); va_list /*ap*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_c_block_size ( krb5_c_block_size (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*enctype*/, krb5_enctype /*enctype*/,
size_t */*blocksize*/); size_t */*blocksize*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_c_checksum_length ( krb5_c_checksum_length (
krb5_context /*context*/, krb5_context /*context*/,
krb5_cksumtype /*cksumtype*/, krb5_cksumtype /*cksumtype*/,
size_t */*length*/); size_t */*length*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_c_decrypt ( krb5_c_decrypt (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_keyblock /*key*/, const krb5_keyblock /*key*/,
krb5_keyusage /*usage*/, krb5_keyusage /*usage*/,
const krb5_data */*ivec*/, const krb5_data */*ivec*/,
krb5_enc_data */*input*/, krb5_enc_data */*input*/,
krb5_data */*output*/); krb5_data */*output*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_c_encrypt ( krb5_c_encrypt (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_keyblock */*key*/, const krb5_keyblock */*key*/,
krb5_keyusage /*usage*/, krb5_keyusage /*usage*/,
const krb5_data */*ivec*/, const krb5_data */*ivec*/,
const krb5_data */*input*/, const krb5_data */*input*/,
krb5_enc_data */*output*/); krb5_enc_data */*output*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_c_encrypt_length ( krb5_c_encrypt_length (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*enctype*/, krb5_enctype /*enctype*/,
size_t /*inputlen*/, size_t /*inputlen*/,
size_t */*length*/); size_t */*length*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_c_enctype_compare ( krb5_c_enctype_compare (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*e1*/, krb5_enctype /*e1*/,
krb5_enctype /*e2*/, krb5_enctype /*e2*/,
krb5_boolean */*similar*/) krb5_boolean */*similar*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_c_get_checksum ( krb5_c_get_checksum (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_checksum */*cksum*/, const krb5_checksum */*cksum*/,
krb5_cksumtype */*type*/, krb5_cksumtype */*type*/,
krb5_data **/*data*/); krb5_data **/*data*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_c_is_coll_proof_cksum (krb5_cksumtype /*ctype*/); krb5_c_is_coll_proof_cksum (krb5_cksumtype /*ctype*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_c_is_keyed_cksum (krb5_cksumtype /*ctype*/); krb5_c_is_keyed_cksum (krb5_cksumtype /*ctype*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_c_keylengths ( krb5_c_keylengths (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*enctype*/, krb5_enctype /*enctype*/,
size_t */*ilen*/, size_t */*ilen*/,
size_t */*keylen*/); size_t */*keylen*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_c_make_checksum ( krb5_c_make_checksum (
krb5_context /*context*/, krb5_context /*context*/,
krb5_cksumtype /*cksumtype*/, krb5_cksumtype /*cksumtype*/,
const krb5_keyblock */*key*/, const krb5_keyblock */*key*/,
krb5_keyusage /*usage*/, krb5_keyusage /*usage*/,
const krb5_data */*input*/, const krb5_data */*input*/,
krb5_checksum */*cksum*/); krb5_checksum */*cksum*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_c_make_random_key ( krb5_c_make_random_key (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*enctype*/, krb5_enctype /*enctype*/,
krb5_keyblock */*random_key*/); krb5_keyblock */*random_key*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_c_prf ( krb5_c_prf (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_keyblock */*key*/, const krb5_keyblock */*key*/,
const krb5_data */*input*/, const krb5_data */*input*/,
krb5_data */*output*/); krb5_data */*output*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_c_prf_length ( krb5_c_prf_length (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*type*/, krb5_enctype /*type*/,
size_t */*length*/); size_t */*length*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_c_set_checksum ( krb5_c_set_checksum (
krb5_context /*context*/, krb5_context /*context*/,
krb5_checksum */*cksum*/, krb5_checksum */*cksum*/,
krb5_cksumtype /*type*/, krb5_cksumtype /*type*/,
const krb5_data */*data*/); const krb5_data */*data*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_c_valid_cksumtype (krb5_cksumtype /*ctype*/); krb5_c_valid_cksumtype (krb5_cksumtype /*ctype*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_c_valid_enctype (krb5_enctype /*etype*/); krb5_c_valid_enctype (krb5_enctype /*etype*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_c_verify_checksum ( krb5_c_verify_checksum (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_keyblock */*key*/, const krb5_keyblock */*key*/,
krb5_keyusage /*usage*/, krb5_keyusage /*usage*/,
const krb5_data */*data*/, const krb5_data */*data*/,
const krb5_checksum */*cksum*/, const krb5_checksum */*cksum*/,
krb5_boolean */*valid*/); krb5_boolean */*valid*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_cache_end_seq_get ( krb5_cc_cache_end_seq_get (
krb5_context /*context*/, krb5_context /*context*/,
krb5_cc_cache_cursor /*cursor*/); krb5_cc_cache_cursor /*cursor*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_cache_get_first ( krb5_cc_cache_get_first (
krb5_context /*context*/, krb5_context /*context*/,
const char */*type*/, const char */*type*/,
krb5_cc_cache_cursor */*cursor*/); krb5_cc_cache_cursor */*cursor*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_cache_match ( krb5_cc_cache_match (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal /*client*/, krb5_principal /*client*/,
krb5_ccache */*id*/); krb5_ccache */*id*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_cache_next ( krb5_cc_cache_next (
krb5_context /*context*/, krb5_context /*context*/,
krb5_cc_cache_cursor /*cursor*/, krb5_cc_cache_cursor /*cursor*/,
krb5_ccache */*id*/); krb5_ccache */*id*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_cc_clear_mcred (krb5_creds */*mcred*/); krb5_cc_clear_mcred (krb5_creds */*mcred*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_close ( krb5_cc_close (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/); krb5_ccache /*id*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_copy_cache ( krb5_cc_copy_cache (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_ccache /*from*/, const krb5_ccache /*from*/,
krb5_ccache /*to*/); krb5_ccache /*to*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_copy_creds ( krb5_cc_copy_creds (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_ccache /*from*/, const krb5_ccache /*from*/,
krb5_ccache /*to*/); krb5_ccache /*to*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_copy_match_f ( krb5_cc_copy_match_f (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_ccache /*from*/, const krb5_ccache /*from*/,
krb5_ccache /*to*/, krb5_ccache /*to*/,
krb5_boolean (*/*match*/)(krb5_context, void *, const krb5_creds *), krb5_boolean (*/*match*/)(krb5_context, void *, const krb5_creds *),
void */*matchctx*/, void */*matchctx*/,
unsigned int */*matched*/); unsigned int */*matched*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_default ( krb5_cc_default (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache */*id*/); krb5_ccache */*id*/);
const char* KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL
krb5_cc_default_name (krb5_context /*context*/); krb5_cc_default_name (krb5_context /*context*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_destroy ( krb5_cc_destroy (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/); krb5_ccache /*id*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_end_seq_get ( krb5_cc_end_seq_get (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_ccache /*id*/, const krb5_ccache /*id*/,
krb5_cc_cursor */*cursor*/); krb5_cc_cursor */*cursor*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_gen_new ( krb5_cc_gen_new (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_cc_ops */*ops*/, const krb5_cc_ops */*ops*/,
krb5_ccache */*id*/) krb5_ccache */*id*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_get_config ( krb5_cc_get_config (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/, krb5_ccache /*id*/,
krb5_const_principal /*principal*/, krb5_const_principal /*principal*/,
const char */*name*/, const char */*name*/,
krb5_data */*data*/); krb5_data */*data*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_get_flags ( krb5_cc_get_flags (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/, krb5_ccache /*id*/,
krb5_flags */*flags*/); krb5_flags */*flags*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_get_friendly_name ( krb5_cc_get_friendly_name (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/, krb5_ccache /*id*/,
char **/*name*/); char **/*name*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_get_full_name ( krb5_cc_get_full_name (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/, krb5_ccache /*id*/,
char **/*str*/); char **/*str*/);
krb5_error_code KRB5_LIB_FUNCTION krb5_error_code
krb5_cc_get_kdc_offset (
krb5_context /*context*/,
krb5_ccache /*id*/,
krb5_deltat */*offset*/);
KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_get_lifetime ( krb5_cc_get_lifetime (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/, krb5_ccache /*id*/,
time_t */*t*/); time_t */*t*/);
const char* KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL
krb5_cc_get_name ( krb5_cc_get_name (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/); krb5_ccache /*id*/);
const krb5_cc_ops * const krb5_cc_ops *
krb5_cc_get_ops ( krb5_cc_get_ops (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/); krb5_ccache /*id*/);
const krb5_cc_ops * const krb5_cc_ops *
krb5_cc_get_prefix_ops ( krb5_cc_get_prefix_ops (
krb5_context /*context*/, krb5_context /*context*/,
const char */*prefix*/); const char */*prefix*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_get_principal ( krb5_cc_get_principal (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/, krb5_ccache /*id*/,
krb5_principal */*principal*/); krb5_principal */*principal*/);
const char* KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL
krb5_cc_get_type ( krb5_cc_get_type (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/); krb5_ccache /*id*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_get_version ( krb5_cc_get_version (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_ccache /*id*/); const krb5_ccache /*id*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_initialize ( krb5_cc_initialize (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/, krb5_ccache /*id*/,
krb5_principal /*primary_principal*/); krb5_principal /*primary_principal*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_last_change_time ( krb5_cc_last_change_time (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/, krb5_ccache /*id*/,
krb5_timestamp */*mtime*/); krb5_timestamp */*mtime*/);
krb5_error_code krb5_error_code
krb5_cc_move ( krb5_cc_move (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*from*/, krb5_ccache /*from*/,
krb5_ccache /*to*/); krb5_ccache /*to*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_new_unique ( krb5_cc_new_unique (
krb5_context /*context*/, krb5_context /*context*/,
const char */*type*/, const char */*type*/,
const char */*hint*/, const char */*hint*/,
krb5_ccache */*id*/); krb5_ccache */*id*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_next_cred ( krb5_cc_next_cred (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_ccache /*id*/, const krb5_ccache /*id*/,
krb5_cc_cursor */*cursor*/, krb5_cc_cursor */*cursor*/,
krb5_creds */*creds*/); krb5_creds */*creds*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_register ( krb5_cc_register (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_cc_ops */*ops*/, const krb5_cc_ops */*ops*/,
krb5_boolean /*override*/); krb5_boolean /*override*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_remove_cred ( krb5_cc_remove_cred (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/, krb5_ccache /*id*/,
krb5_flags /*which*/, krb5_flags /*which*/,
krb5_creds */*cred*/); krb5_creds */*cred*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_resolve ( krb5_cc_resolve (
krb5_context /*context*/, krb5_context /*context*/,
const char */*name*/, const char */*name*/,
krb5_ccache */*id*/); krb5_ccache */*id*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_retrieve_cred ( krb5_cc_retrieve_cred (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/, krb5_ccache /*id*/,
krb5_flags /*whichfields*/, krb5_flags /*whichfields*/,
const krb5_creds */*mcreds*/, const krb5_creds */*mcreds*/,
krb5_creds */*creds*/); krb5_creds */*creds*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_set_config ( krb5_cc_set_config (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/, krb5_ccache /*id*/,
krb5_const_principal /*principal*/, krb5_const_principal /*principal*/,
const char */*name*/, const char */*name*/,
krb5_data */*data*/); krb5_data */*data*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_set_default_name ( krb5_cc_set_default_name (
krb5_context /*context*/, krb5_context /*context*/,
const char */*name*/); const char */*name*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_set_flags ( krb5_cc_set_flags (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/, krb5_ccache /*id*/,
krb5_flags /*flags*/); krb5_flags /*flags*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_set_friendly_name ( krb5_cc_set_friendly_name (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/, krb5_ccache /*id*/,
const char */*name*/); const char */*name*/);
krb5_error_code KRB5_LIB_FUNCTION krb5_error_code
krb5_cc_set_kdc_offset (
krb5_context /*context*/,
krb5_ccache /*id*/,
krb5_deltat /*offset*/);
KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_start_seq_get ( krb5_cc_start_seq_get (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_ccache /*id*/, const krb5_ccache /*id*/,
krb5_cc_cursor */*cursor*/); krb5_cc_cursor */*cursor*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_store_cred ( krb5_cc_store_cred (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/, krb5_ccache /*id*/,
krb5_creds */*creds*/); krb5_creds */*creds*/);
krb5_error_code krb5_boolean KRB5_LIB_FUNCTION
krb5_cc_support_switch (
krb5_context /*context*/,
const char */*type*/);
krb5_error_code KRB5_LIB_FUNCTION
krb5_cc_switch ( krb5_cc_switch (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/); krb5_ccache /*id*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cccol_cursor_free ( krb5_cccol_cursor_free (
krb5_context /*context*/, krb5_context /*context*/,
krb5_cccol_cursor */*cursor*/); krb5_cccol_cursor */*cursor*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cccol_cursor_new ( krb5_cccol_cursor_new (
krb5_context /*context*/, krb5_context /*context*/,
krb5_cccol_cursor */*cursor*/); krb5_cccol_cursor */*cursor*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cccol_cursor_next ( krb5_cccol_cursor_next (
krb5_context /*context*/, krb5_context /*context*/,
krb5_cccol_cursor /*cursor*/, krb5_cccol_cursor /*cursor*/,
krb5_ccache */*cache*/); krb5_ccache */*cache*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cccol_last_change_time ( krb5_cccol_last_change_time (
krb5_context /*context*/, krb5_context /*context*/,
const char */*type*/, const char */*type*/,
krb5_timestamp */*mtime*/); krb5_timestamp */*mtime*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_change_password ( krb5_change_password (
krb5_context /*context*/, krb5_context /*context*/,
krb5_creds */*creds*/, krb5_creds */*creds*/,
const char */*newpw*/, const char */*newpw*/,
int */*result_code*/, int */*result_code*/,
krb5_data */*result_code_string*/, krb5_data */*result_code_string*/,
krb5_data */*result_string*/) krb5_data */*result_string*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_check_transited ( krb5_check_transited (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_realm /*client_realm*/, krb5_const_realm /*client_realm*/,
krb5_const_realm /*server_realm*/, krb5_const_realm /*server_realm*/,
krb5_realm */*realms*/, krb5_realm */*realms*/,
unsigned int /*num_realms*/, unsigned int /*num_realms*/,
int */*bad_realm*/); int */*bad_realm*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_check_transited_realms ( krb5_check_transited_realms (
krb5_context /*context*/, krb5_context /*context*/,
const char *const */*realms*/, const char *const */*realms*/,
unsigned int /*num_realms*/, unsigned int /*num_realms*/,
int */*bad_realm*/); int */*bad_realm*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_checksum_disable ( krb5_checksum_disable (
krb5_context /*context*/, krb5_context /*context*/,
krb5_cksumtype /*type*/); krb5_cksumtype /*type*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_checksum_free ( krb5_checksum_free (
krb5_context /*context*/, krb5_context /*context*/,
krb5_checksum */*cksum*/); krb5_checksum */*cksum*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_checksum_is_collision_proof ( krb5_checksum_is_collision_proof (
krb5_context /*context*/, krb5_context /*context*/,
krb5_cksumtype /*type*/); krb5_cksumtype /*type*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_checksum_is_keyed ( krb5_checksum_is_keyed (
krb5_context /*context*/, krb5_context /*context*/,
krb5_cksumtype /*type*/); krb5_cksumtype /*type*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_checksumsize ( krb5_checksumsize (
krb5_context /*context*/, krb5_context /*context*/,
krb5_cksumtype /*type*/, krb5_cksumtype /*type*/,
size_t */*size*/); size_t */*size*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cksumtype_to_enctype ( krb5_cksumtype_to_enctype (
krb5_context /*context*/, krb5_context /*context*/,
krb5_cksumtype /*ctype*/, krb5_cksumtype /*ctype*/,
krb5_enctype */*etype*/); krb5_enctype */*etype*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cksumtype_valid ( krb5_cksumtype_valid (
krb5_context /*context*/, krb5_context /*context*/,
krb5_cksumtype /*ctype*/); krb5_cksumtype /*ctype*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_clear_error_message (krb5_context /*context*/); krb5_clear_error_message (krb5_context /*context*/);
void KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_clear_error_string (krb5_context /*context*/) krb5_clear_error_string (krb5_context /*context*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_closelog ( krb5_closelog (
krb5_context /*context*/, krb5_context /*context*/,
krb5_log_facility */*fac*/); krb5_log_facility */*fac*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_compare_creds ( krb5_compare_creds (
krb5_context /*context*/, krb5_context /*context*/,
krb5_flags /*whichfields*/, krb5_flags /*whichfields*/,
const krb5_creds * /*mcreds*/, const krb5_creds * /*mcreds*/,
const krb5_creds * /*creds*/); const krb5_creds * /*creds*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_config_file_free ( krb5_config_file_free (
krb5_context /*context*/, krb5_context /*context*/,
krb5_config_section */*s*/); krb5_config_section */*s*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_config_free_strings (char **/*strings*/); krb5_config_free_strings (char **/*strings*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_config_get_bool ( krb5_config_get_bool (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
...); ...);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_config_get_bool_default ( krb5_config_get_bool_default (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
krb5_boolean /*def_value*/, krb5_boolean /*def_value*/,
...); ...);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
krb5_config_get_int ( krb5_config_get_int (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
...); ...);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
krb5_config_get_int_default ( krb5_config_get_int_default (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
int /*def_value*/, int /*def_value*/,
...); ...);
const krb5_config_binding * KRB5_LIB_FUNCTION const krb5_config_binding * KRB5_LIB_CALL
krb5_config_get_list ( krb5_config_get_list (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
...); ...);
const char* KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL
krb5_config_get_string ( krb5_config_get_string (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
...); ...);
const char* KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL
krb5_config_get_string_default ( krb5_config_get_string_default (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
const char */*def_value*/, const char */*def_value*/,
...); ...);
char** KRB5_LIB_FUNCTION char** KRB5_LIB_CALL
krb5_config_get_strings ( krb5_config_get_strings (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
...); ...);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
krb5_config_get_time ( krb5_config_get_time (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
...); ...);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
krb5_config_get_time_default ( krb5_config_get_time_default (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
int /*def_value*/, int /*def_value*/,
...); ...);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_config_parse_file ( krb5_config_parse_file (
krb5_context /*context*/, krb5_context /*context*/,
const char */*fname*/, const char */*fname*/,
krb5_config_section **/*res*/); krb5_config_section **/*res*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_config_parse_file_multi ( krb5_config_parse_file_multi (
krb5_context /*context*/, krb5_context /*context*/,
const char */*fname*/, const char */*fname*/,
krb5_config_section **/*res*/); krb5_config_section **/*res*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED krb5_error_code KRB5_LIB_FUNCTION
krb5_config_parse_string_multi ( krb5_config_parse_string_multi (
krb5_context /*context*/, krb5_context /*context*/,
const char */*string*/, const char */*string*/,
krb5_config_section **/*res*/) krb5_config_section **/*res*/);
KRB5_DEPRECATED;
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_config_vget_bool ( krb5_config_vget_bool (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
va_list /*args*/); va_list /*args*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_config_vget_bool_default ( krb5_config_vget_bool_default (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
krb5_boolean /*def_value*/, krb5_boolean /*def_value*/,
va_list /*args*/); va_list /*args*/);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
krb5_config_vget_int ( krb5_config_vget_int (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
va_list /*args*/); va_list /*args*/);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
krb5_config_vget_int_default ( krb5_config_vget_int_default (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
int /*def_value*/, int /*def_value*/,
va_list /*args*/); va_list /*args*/);
const krb5_config_binding * KRB5_LIB_FUNCTION const krb5_config_binding * KRB5_LIB_CALL
krb5_config_vget_list ( krb5_config_vget_list (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
va_list /*args*/); va_list /*args*/);
const char* KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL
krb5_config_vget_string ( krb5_config_vget_string (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
va_list /*args*/); va_list /*args*/);
const char* KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL
krb5_config_vget_string_default ( krb5_config_vget_string_default (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
const char */*def_value*/, const char */*def_value*/,
va_list /*args*/); va_list /*args*/);
char ** KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION char ** KRB5_LIB_CALL
krb5_config_vget_strings ( krb5_config_vget_strings (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
va_list /*args*/); va_list /*args*/);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
krb5_config_vget_time ( krb5_config_vget_time (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
va_list /*args*/); va_list /*args*/);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
krb5_config_vget_time_default ( krb5_config_vget_time_default (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_config_section */*c*/, const krb5_config_section */*c*/,
int /*def_value*/, int /*def_value*/,
va_list /*args*/); va_list /*args*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_copy_address ( krb5_copy_address (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_address */*inaddr*/, const krb5_address */*inaddr*/,
krb5_address */*outaddr*/); krb5_address */*outaddr*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_copy_addresses ( krb5_copy_addresses (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_addresses */*inaddr*/, const krb5_addresses */*inaddr*/,
krb5_addresses */*outaddr*/); krb5_addresses */*outaddr*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_copy_checksum ( krb5_copy_checksum (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_checksum */*old*/, const krb5_checksum */*old*/,
krb5_checksum **/*new*/); krb5_checksum **/*new*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_copy_context ( krb5_copy_context (
krb5_context /*context*/, krb5_context /*context*/,
krb5_context */*out*/); krb5_context */*out*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_copy_creds ( krb5_copy_creds (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_creds */*incred*/, const krb5_creds */*incred*/,
krb5_creds **/*outcred*/); krb5_creds **/*outcred*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_copy_creds_contents ( krb5_copy_creds_contents (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_creds */*incred*/, const krb5_creds */*incred*/,
krb5_creds */*c*/); krb5_creds */*c*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_copy_data ( krb5_copy_data (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_data */*indata*/, const krb5_data */*indata*/,
krb5_data **/*outdata*/); krb5_data **/*outdata*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_copy_host_realm ( krb5_copy_host_realm (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_realm */*from*/, const krb5_realm */*from*/,
krb5_realm **/*to*/); krb5_realm **/*to*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_copy_keyblock ( krb5_copy_keyblock (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_keyblock */*inblock*/, const krb5_keyblock */*inblock*/,
krb5_keyblock **/*to*/); krb5_keyblock **/*to*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_copy_keyblock_contents ( krb5_copy_keyblock_contents (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_keyblock */*inblock*/, const krb5_keyblock */*inblock*/,
krb5_keyblock */*to*/); krb5_keyblock */*to*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_copy_principal ( krb5_copy_principal (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*inprinc*/, krb5_const_principal /*inprinc*/,
krb5_principal */*outprinc*/); krb5_principal */*outprinc*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_copy_ticket ( krb5_copy_ticket (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_ticket */*from*/, const krb5_ticket */*from*/,
krb5_ticket **/*to*/); krb5_ticket **/*to*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_create_checksum ( krb5_create_checksum (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
krb5_key_usage /*usage*/, krb5_key_usage /*usage*/,
int /*type*/, int /*type*/,
void */*data*/, void */*data*/,
size_t /*len*/, size_t /*len*/,
Checksum */*result*/); Checksum */*result*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_create_checksum_iov ( krb5_create_checksum_iov (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
unsigned /*usage*/, unsigned /*usage*/,
krb5_crypto_iov */*data*/, krb5_crypto_iov */*data*/,
unsigned int /*num_data*/, unsigned int /*num_data*/,
krb5_cksumtype */*type*/); krb5_cksumtype */*type*/);
unsigned long unsigned long
krb5_creds_get_ticket_flags (krb5_creds */*creds*/); krb5_creds_get_ticket_flags (krb5_creds */*creds*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_crypto_destroy ( krb5_crypto_destroy (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/); krb5_crypto /*crypto*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_crypto_fx_cf2 ( krb5_crypto_fx_cf2 (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_crypto /*crypto1*/, const krb5_crypto /*crypto1*/,
const krb5_crypto /*crypto2*/, const krb5_crypto /*crypto2*/,
krb5_data */*pepper1*/, krb5_data */*pepper1*/,
krb5_data */*pepper2*/, krb5_data */*pepper2*/,
krb5_enctype /*enctype*/, krb5_enctype /*enctype*/,
krb5_keyblock */*res*/); krb5_keyblock */*res*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_crypto_get_checksum_type ( krb5_crypto_get_checksum_type (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
krb5_cksumtype */*type*/); krb5_cksumtype */*type*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_crypto_getblocksize ( krb5_crypto_getblocksize (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
size_t */*blocksize*/); size_t */*blocksize*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_crypto_getconfoundersize ( krb5_crypto_getconfoundersize (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
size_t */*confoundersize*/); size_t */*confoundersize*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_crypto_getenctype ( krb5_crypto_getenctype (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
krb5_enctype */*enctype*/); krb5_enctype */*enctype*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_crypto_getpadsize ( krb5_crypto_getpadsize (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
size_t */*padsize*/); size_t */*padsize*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_crypto_init ( krb5_crypto_init (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_keyblock */*key*/, const krb5_keyblock */*key*/,
krb5_enctype /*etype*/, krb5_enctype /*etype*/,
krb5_crypto */*crypto*/); krb5_crypto */*crypto*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_crypto_length ( krb5_crypto_length (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
int /*type*/, int /*type*/,
size_t */*len*/); size_t */*len*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_crypto_length_iov ( krb5_crypto_length_iov (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
krb5_crypto_iov */*data*/, krb5_crypto_iov */*data*/,
unsigned int /*num_data*/); unsigned int /*num_data*/);
size_t size_t
krb5_crypto_overhead ( krb5_crypto_overhead (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/); krb5_crypto /*crypto*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_crypto_prf ( krb5_crypto_prf (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_crypto /*crypto*/, const krb5_crypto /*crypto*/,
const krb5_data */*input*/, const krb5_data */*input*/,
krb5_data */*output*/); krb5_data */*output*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_crypto_prf_length ( krb5_crypto_prf_length (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*type*/, krb5_enctype /*type*/,
size_t */*length*/); size_t */*length*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_data_alloc ( krb5_data_alloc (
krb5_data */*p*/, krb5_data */*p*/,
int /*len*/); int /*len*/);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
krb5_data_cmp ( krb5_data_cmp (
const krb5_data */*data1*/, const krb5_data */*data1*/,
const krb5_data */*data2*/); const krb5_data */*data2*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_data_copy ( krb5_data_copy (
krb5_data */*p*/, krb5_data */*p*/,
const void */*data*/, const void */*data*/,
size_t /*len*/); size_t /*len*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_data_free (krb5_data */*p*/); krb5_data_free (krb5_data */*p*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_data_realloc ( krb5_data_realloc (
krb5_data */*p*/, krb5_data */*p*/,
int /*len*/); int /*len*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_data_zero (krb5_data */*p*/); krb5_data_zero (krb5_data */*p*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_decode_Authenticator ( krb5_decode_Authenticator (
krb5_context /*context*/, krb5_context /*context*/,
const void */*data*/, const void */*data*/,
size_t /*length*/, size_t /*length*/,
Authenticator */*t*/, Authenticator */*t*/,
size_t */*len*/) size_t */*len*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_decode_ETYPE_INFO ( krb5_decode_ETYPE_INFO (
krb5_context /*context*/, krb5_context /*context*/,
const void */*data*/, const void */*data*/,
size_t /*length*/, size_t /*length*/,
ETYPE_INFO */*t*/, ETYPE_INFO */*t*/,
size_t */*len*/) size_t */*len*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_decode_ETYPE_INFO2 ( krb5_decode_ETYPE_INFO2 (
krb5_context /*context*/, krb5_context /*context*/,
const void */*data*/, const void */*data*/,
size_t /*length*/, size_t /*length*/,
ETYPE_INFO2 */*t*/, ETYPE_INFO2 */*t*/,
size_t */*len*/) size_t */*len*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_decode_EncAPRepPart ( krb5_decode_EncAPRepPart (
krb5_context /*context*/, krb5_context /*context*/,
const void */*data*/, const void */*data*/,
size_t /*length*/, size_t /*length*/,
EncAPRepPart */*t*/, EncAPRepPart */*t*/,
size_t */*len*/) size_t */*len*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_decode_EncASRepPart ( krb5_decode_EncASRepPart (
krb5_context /*context*/, krb5_context /*context*/,
const void */*data*/, const void */*data*/,
size_t /*length*/, size_t /*length*/,
EncASRepPart */*t*/, EncASRepPart */*t*/,
size_t */*len*/) size_t */*len*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_decode_EncKrbCredPart ( krb5_decode_EncKrbCredPart (
krb5_context /*context*/, krb5_context /*context*/,
const void */*data*/, const void */*data*/,
size_t /*length*/, size_t /*length*/,
EncKrbCredPart */*t*/, EncKrbCredPart */*t*/,
size_t */*len*/) size_t */*len*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_decode_EncTGSRepPart ( krb5_decode_EncTGSRepPart (
krb5_context /*context*/, krb5_context /*context*/,
const void */*data*/, const void */*data*/,
size_t /*length*/, size_t /*length*/,
EncTGSRepPart */*t*/, EncTGSRepPart */*t*/,
size_t */*len*/) size_t */*len*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_decode_EncTicketPart ( krb5_decode_EncTicketPart (
krb5_context /*context*/, krb5_context /*context*/,
const void */*data*/, const void */*data*/,
size_t /*length*/, size_t /*length*/,
EncTicketPart */*t*/, EncTicketPart */*t*/,
size_t */*len*/) size_t */*len*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_decode_ap_req ( krb5_decode_ap_req (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_data */*inbuf*/, const krb5_data */*inbuf*/,
krb5_ap_req */*ap_req*/); krb5_ap_req */*ap_req*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_decrypt ( krb5_decrypt (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
unsigned /*usage*/, unsigned /*usage*/,
void */*data*/, void */*data*/,
size_t /*len*/, size_t /*len*/,
krb5_data */*result*/); krb5_data */*result*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_decrypt_EncryptedData ( krb5_decrypt_EncryptedData (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
unsigned /*usage*/, unsigned /*usage*/,
const EncryptedData */*e*/, const EncryptedData */*e*/,
krb5_data */*result*/); krb5_data */*result*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_decrypt_iov_ivec ( krb5_decrypt_iov_ivec (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
unsigned /*usage*/, unsigned /*usage*/,
krb5_crypto_iov */*data*/, krb5_crypto_iov */*data*/,
unsigned int /*num_data*/, unsigned int /*num_data*/,
void */*ivec*/); void */*ivec*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_decrypt_ivec ( krb5_decrypt_ivec (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
unsigned /*usage*/, unsigned /*usage*/,
void */*data*/, void */*data*/,
size_t /*len*/, size_t /*len*/,
krb5_data */*result*/, krb5_data */*result*/,
void */*ivec*/); void */*ivec*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_decrypt_ticket ( krb5_decrypt_ticket (
krb5_context /*context*/, krb5_context /*context*/,
Ticket */*ticket*/, Ticket */*ticket*/,
krb5_keyblock */*key*/, krb5_keyblock */*key*/,
EncTicketPart */*out*/, EncTicketPart */*out*/,
krb5_flags /*flags*/); krb5_flags /*flags*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_derive_key ( krb5_derive_key (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_keyblock */*key*/, const krb5_keyblock */*key*/,
krb5_enctype /*etype*/, krb5_enctype /*etype*/,
const void */*constant*/, const void */*constant*/,
size_t /*constant_len*/, size_t /*constant_len*/,
krb5_keyblock **/*derived_key*/); krb5_keyblock **/*derived_key*/);
krb5_error_code krb5_error_code
krb5_digest_alloc ( krb5_digest_alloc (
skipping to change at line 1569 skipping to change at line 1580
krb5_context /*context*/, krb5_context /*context*/,
krb5_digest /*digest*/, krb5_digest /*digest*/,
const char */*uri*/); const char */*uri*/);
krb5_error_code krb5_error_code
krb5_digest_set_username ( krb5_digest_set_username (
krb5_context /*context*/, krb5_context /*context*/,
krb5_digest /*digest*/, krb5_digest /*digest*/,
const char */*username*/); const char */*username*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_domain_x500_decode ( krb5_domain_x500_decode (
krb5_context /*context*/, krb5_context /*context*/,
krb5_data /*tr*/, krb5_data /*tr*/,
char ***/*realms*/, char ***/*realms*/,
unsigned int */*num_realms*/, unsigned int */*num_realms*/,
const char */*client_realm*/, const char */*client_realm*/,
const char */*server_realm*/); const char */*server_realm*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_domain_x500_encode ( krb5_domain_x500_encode (
char **/*realms*/, char **/*realms*/,
unsigned int /*num_realms*/, unsigned int /*num_realms*/,
krb5_data */*encoding*/); krb5_data */*encoding*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_eai_to_heim_errno ( krb5_eai_to_heim_errno (
int /*eai_errno*/, int /*eai_errno*/,
int /*system_error*/); int /*system_error*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_encode_Authenticator ( krb5_encode_Authenticator (
krb5_context /*context*/, krb5_context /*context*/,
void */*data*/, void */*data*/,
size_t /*length*/, size_t /*length*/,
Authenticator */*t*/, Authenticator */*t*/,
size_t */*len*/) size_t */*len*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_encode_ETYPE_INFO ( krb5_encode_ETYPE_INFO (
krb5_context /*context*/, krb5_context /*context*/,
void */*data*/, void */*data*/,
size_t /*length*/, size_t /*length*/,
ETYPE_INFO */*t*/, ETYPE_INFO */*t*/,
size_t */*len*/) size_t */*len*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_encode_ETYPE_INFO2 ( krb5_encode_ETYPE_INFO2 (
krb5_context /*context*/, krb5_context /*context*/,
void */*data*/, void */*data*/,
size_t /*length*/, size_t /*length*/,
ETYPE_INFO2 */*t*/, ETYPE_INFO2 */*t*/,
size_t */*len*/) size_t */*len*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_encode_EncAPRepPart ( krb5_encode_EncAPRepPart (
krb5_context /*context*/, krb5_context /*context*/,
void */*data*/, void */*data*/,
size_t /*length*/, size_t /*length*/,
EncAPRepPart */*t*/, EncAPRepPart */*t*/,
size_t */*len*/) size_t */*len*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_encode_EncASRepPart ( krb5_encode_EncASRepPart (
krb5_context /*context*/, krb5_context /*context*/,
void */*data*/, void */*data*/,
size_t /*length*/, size_t /*length*/,
EncASRepPart */*t*/, EncASRepPart */*t*/,
size_t */*len*/) size_t */*len*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_encode_EncKrbCredPart ( krb5_encode_EncKrbCredPart (
krb5_context /*context*/, krb5_context /*context*/,
void */*data*/, void */*data*/,
size_t /*length*/, size_t /*length*/,
EncKrbCredPart */*t*/, EncKrbCredPart */*t*/,
size_t */*len*/) size_t */*len*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_encode_EncTGSRepPart ( krb5_encode_EncTGSRepPart (
krb5_context /*context*/, krb5_context /*context*/,
void */*data*/, void */*data*/,
size_t /*length*/, size_t /*length*/,
EncTGSRepPart */*t*/, EncTGSRepPart */*t*/,
size_t */*len*/) size_t */*len*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_encode_EncTicketPart ( krb5_encode_EncTicketPart (
krb5_context /*context*/, krb5_context /*context*/,
void */*data*/, void */*data*/,
size_t /*length*/, size_t /*length*/,
EncTicketPart */*t*/, EncTicketPart */*t*/,
size_t */*len*/) size_t */*len*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_encrypt ( krb5_encrypt (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
unsigned /*usage*/, unsigned /*usage*/,
const void */*data*/, const void */*data*/,
size_t /*len*/, size_t /*len*/,
krb5_data */*result*/); krb5_data */*result*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_encrypt_EncryptedData ( krb5_encrypt_EncryptedData (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
unsigned /*usage*/, unsigned /*usage*/,
void */*data*/, void */*data*/,
size_t /*len*/, size_t /*len*/,
int /*kvno*/, int /*kvno*/,
EncryptedData */*result*/); EncryptedData */*result*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_encrypt_iov_ivec ( krb5_encrypt_iov_ivec (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
unsigned /*usage*/, unsigned /*usage*/,
krb5_crypto_iov */*data*/, krb5_crypto_iov */*data*/,
int /*num_data*/, int /*num_data*/,
void */*ivec*/); void */*ivec*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_encrypt_ivec ( krb5_encrypt_ivec (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
unsigned /*usage*/, unsigned /*usage*/,
const void */*data*/, const void */*data*/,
size_t /*len*/, size_t /*len*/,
krb5_data */*result*/, krb5_data */*result*/,
void */*ivec*/); void */*ivec*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_enctype_disable ( krb5_enctype_disable (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*enctype*/); krb5_enctype /*enctype*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_enctype_enable ( krb5_enctype_enable (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*enctype*/); krb5_enctype /*enctype*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_enctype_keybits ( krb5_enctype_keybits (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*type*/, krb5_enctype /*type*/,
size_t */*keybits*/); size_t */*keybits*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_enctype_keysize ( krb5_enctype_keysize (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*type*/, krb5_enctype /*type*/,
size_t */*keysize*/); size_t */*keysize*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_enctype_to_keytype ( krb5_enctype_to_keytype (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*etype*/, krb5_enctype /*etype*/,
krb5_keytype */*keytype*/); krb5_keytype */*keytype*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_enctype_to_string ( krb5_enctype_to_string (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*etype*/, krb5_enctype /*etype*/,
char **/*string*/); char **/*string*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_enctype_valid ( krb5_enctype_valid (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*etype*/); krb5_enctype /*etype*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_enctypes_compatible_keys ( krb5_enctypes_compatible_keys (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*etype1*/, krb5_enctype /*etype1*/,
krb5_enctype /*etype2*/) krb5_enctype /*etype2*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_err ( krb5_err (
krb5_context /*context*/, krb5_context /*context*/,
int /*eval*/, int /*eval*/,
krb5_error_code /*code*/, krb5_error_code /*code*/,
const char */*fmt*/, const char */*fmt*/,
...) ...)
__attribute__ ((noreturn, format (printf, 4, 5))); __attribute__ ((noreturn, format (printf, 4, 5)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_error_from_rd_error ( krb5_error_from_rd_error (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_error */*error*/, const krb5_error */*error*/,
const krb5_creds */*creds*/); const krb5_creds */*creds*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_errx ( krb5_errx (
krb5_context /*context*/, krb5_context /*context*/,
int /*eval*/, int /*eval*/,
const char */*fmt*/, const char */*fmt*/,
...) ...)
__attribute__ ((noreturn, format (printf, 3, 4))); __attribute__ ((noreturn, format (printf, 3, 4)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_expand_hostname ( krb5_expand_hostname (
krb5_context /*context*/, krb5_context /*context*/,
const char */*orig_hostname*/, const char */*orig_hostname*/,
char **/*new_hostname*/); char **/*new_hostname*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_expand_hostname_realms ( krb5_expand_hostname_realms (
krb5_context /*context*/, krb5_context /*context*/,
const char */*orig_hostname*/, const char */*orig_hostname*/,
char **/*new_hostname*/, char **/*new_hostname*/,
char ***/*realms*/); char ***/*realms*/);
PA_DATA * PA_DATA *
krb5_find_padata ( krb5_find_padata (
PA_DATA */*val*/, PA_DATA */*val*/,
unsigned /*len*/, unsigned /*len*/,
int /*type*/, int /*type*/,
int */*idx*/); int */*idx*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_format_time ( krb5_format_time (
krb5_context /*context*/, krb5_context /*context*/,
time_t /*t*/, time_t /*t*/,
char */*s*/, char */*s*/,
size_t /*len*/, size_t /*len*/,
krb5_boolean /*include_time*/); krb5_boolean /*include_time*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_free_address ( krb5_free_address (
krb5_context /*context*/, krb5_context /*context*/,
krb5_address */*address*/); krb5_address */*address*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_free_addresses ( krb5_free_addresses (
krb5_context /*context*/, krb5_context /*context*/,
krb5_addresses */*addresses*/); krb5_addresses */*addresses*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_ap_rep_enc_part ( krb5_free_ap_rep_enc_part (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ap_rep_enc_part */*val*/); krb5_ap_rep_enc_part */*val*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_authenticator ( krb5_free_authenticator (
krb5_context /*context*/, krb5_context /*context*/,
krb5_authenticator */*authenticator*/); krb5_authenticator */*authenticator*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_checksum ( krb5_free_checksum (
krb5_context /*context*/, krb5_context /*context*/,
krb5_checksum */*cksum*/); krb5_checksum */*cksum*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_checksum_contents ( krb5_free_checksum_contents (
krb5_context /*context*/, krb5_context /*context*/,
krb5_checksum */*cksum*/); krb5_checksum */*cksum*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_config_files (char **/*filenames*/); krb5_free_config_files (char **/*filenames*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_context (krb5_context /*context*/); krb5_free_context (krb5_context /*context*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_free_cred_contents ( krb5_free_cred_contents (
krb5_context /*context*/, krb5_context /*context*/,
krb5_creds */*c*/); krb5_creds */*c*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_free_creds ( krb5_free_creds (
krb5_context /*context*/, krb5_context /*context*/,
krb5_creds */*c*/); krb5_creds */*c*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_free_creds_contents ( krb5_free_creds_contents (
krb5_context /*context*/, krb5_context /*context*/,
krb5_creds */*c*/) krb5_creds */*c*/);
KRB5_DEPRECATED;
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_data ( krb5_free_data (
krb5_context /*context*/, krb5_context /*context*/,
krb5_data */*p*/); krb5_data */*p*/);
void KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_data_contents ( krb5_free_data_contents (
krb5_context /*context*/, krb5_context /*context*/,
krb5_data */*data*/) krb5_data */*data*/);
KRB5_DEPRECATED;
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_error ( krb5_free_error (
krb5_context /*context*/, krb5_context /*context*/,
krb5_error */*error*/); krb5_error */*error*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_error_contents ( krb5_free_error_contents (
krb5_context /*context*/, krb5_context /*context*/,
krb5_error */*error*/); krb5_error */*error*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_error_message ( krb5_free_error_message (
krb5_context /*context*/, krb5_context /*context*/,
const char */*msg*/); const char */*msg*/);
void KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_error_string ( krb5_free_error_string (
krb5_context /*context*/, krb5_context /*context*/,
char */*str*/) char */*str*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_free_host_realm ( krb5_free_host_realm (
krb5_context /*context*/, krb5_context /*context*/,
krb5_realm */*realmlist*/); krb5_realm */*realmlist*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_free_kdc_rep ( krb5_free_kdc_rep (
krb5_context /*context*/, krb5_context /*context*/,
krb5_kdc_rep */*rep*/); krb5_kdc_rep */*rep*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_keyblock ( krb5_free_keyblock (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keyblock */*keyblock*/); krb5_keyblock */*keyblock*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_keyblock_contents ( krb5_free_keyblock_contents (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keyblock */*keyblock*/); krb5_keyblock */*keyblock*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_free_krbhst ( krb5_free_krbhst (
krb5_context /*context*/, krb5_context /*context*/,
char **/*hostlist*/); char **/*hostlist*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_principal ( krb5_free_principal (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal /*p*/); krb5_principal /*p*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_free_salt ( krb5_free_salt (
krb5_context /*context*/, krb5_context /*context*/,
krb5_salt /*salt*/); krb5_salt /*salt*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_free_ticket ( krb5_free_ticket (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ticket */*ticket*/); krb5_ticket */*ticket*/);
void KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_unparsed_name ( krb5_free_unparsed_name (
krb5_context /*context*/, krb5_context /*context*/,
char */*str*/) char */*str*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_fwd_tgt_creds ( krb5_fwd_tgt_creds (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
const char */*hostname*/, const char */*hostname*/,
krb5_principal /*client*/, krb5_principal /*client*/,
krb5_principal /*server*/, krb5_principal /*server*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
int /*forwardable*/, int /*forwardable*/,
krb5_data */*out_data*/); krb5_data */*out_data*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_generate_random_block ( krb5_generate_random_block (
void */*buf*/, void */*buf*/,
size_t /*len*/); size_t /*len*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_generate_random_keyblock ( krb5_generate_random_keyblock (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*type*/, krb5_enctype /*type*/,
krb5_keyblock */*key*/); krb5_keyblock */*key*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_generate_seq_number ( krb5_generate_seq_number (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_keyblock */*key*/, const krb5_keyblock */*key*/,
uint32_t */*seqno*/); uint32_t */*seqno*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED krb5_error_code KRB5_LIB_FUNCTION
krb5_generate_subkey ( krb5_generate_subkey (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_keyblock */*key*/, const krb5_keyblock */*key*/,
krb5_keyblock **/*subkey*/) krb5_keyblock **/*subkey*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_generate_subkey_extended ( krb5_generate_subkey_extended (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_keyblock */*key*/, const krb5_keyblock */*key*/,
krb5_enctype /*etype*/, krb5_enctype /*etype*/,
krb5_keyblock **/*subkey*/); krb5_keyblock **/*subkey*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_all_client_addrs ( krb5_get_all_client_addrs (
krb5_context /*context*/, krb5_context /*context*/,
krb5_addresses */*res*/); krb5_addresses */*res*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_all_server_addrs ( krb5_get_all_server_addrs (
krb5_context /*context*/, krb5_context /*context*/,
krb5_addresses */*res*/); krb5_addresses */*res*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_cred_from_kdc ( krb5_get_cred_from_kdc (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
krb5_creds */*in_creds*/, krb5_creds */*in_creds*/,
krb5_creds **/*out_creds*/, krb5_creds **/*out_creds*/,
krb5_creds ***/*ret_tgts*/) krb5_creds ***/*ret_tgts*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_cred_from_kdc_opt ( krb5_get_cred_from_kdc_opt (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
krb5_creds */*in_creds*/, krb5_creds */*in_creds*/,
krb5_creds **/*out_creds*/, krb5_creds **/*out_creds*/,
krb5_creds ***/*ret_tgts*/, krb5_creds ***/*ret_tgts*/,
krb5_flags /*flags*/) krb5_flags /*flags*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_credentials ( krb5_get_credentials (
krb5_context /*context*/, krb5_context /*context*/,
krb5_flags /*options*/, krb5_flags /*options*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
krb5_creds */*in_creds*/, krb5_creds */*in_creds*/,
krb5_creds **/*out_creds*/); krb5_creds **/*out_creds*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_credentials_with_flags ( krb5_get_credentials_with_flags (
krb5_context /*context*/, krb5_context /*context*/,
krb5_flags /*options*/, krb5_flags /*options*/,
krb5_kdc_flags /*flags*/, krb5_kdc_flags /*flags*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
krb5_creds */*in_creds*/, krb5_creds */*in_creds*/,
krb5_creds **/*out_creds*/); krb5_creds **/*out_creds*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_creds ( krb5_get_creds (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_creds_opt /*opt*/, krb5_get_creds_opt /*opt*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
krb5_const_principal /*inprinc*/, krb5_const_principal /*inprinc*/,
krb5_creds **/*out_creds*/); krb5_creds **/*out_creds*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_get_creds_opt_add_options ( krb5_get_creds_opt_add_options (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_creds_opt /*opt*/, krb5_get_creds_opt /*opt*/,
krb5_flags /*options*/); krb5_flags /*options*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_creds_opt_alloc ( krb5_get_creds_opt_alloc (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_creds_opt */*opt*/); krb5_get_creds_opt */*opt*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_get_creds_opt_free ( krb5_get_creds_opt_free (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_creds_opt /*opt*/); krb5_get_creds_opt /*opt*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_get_creds_opt_set_enctype ( krb5_get_creds_opt_set_enctype (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_creds_opt /*opt*/, krb5_get_creds_opt /*opt*/,
krb5_enctype /*enctype*/); krb5_enctype /*enctype*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_creds_opt_set_impersonate ( krb5_get_creds_opt_set_impersonate (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_creds_opt /*opt*/, krb5_get_creds_opt /*opt*/,
krb5_const_principal /*self*/); krb5_const_principal /*self*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_get_creds_opt_set_options ( krb5_get_creds_opt_set_options (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_creds_opt /*opt*/, krb5_get_creds_opt /*opt*/,
krb5_flags /*options*/); krb5_flags /*options*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_creds_opt_set_ticket ( krb5_get_creds_opt_set_ticket (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_creds_opt /*opt*/, krb5_get_creds_opt /*opt*/,
const Ticket */*ticket*/); const Ticket */*ticket*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_default_config_files (char ***/*pfilenames*/); krb5_get_default_config_files (char ***/*pfilenames*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_default_in_tkt_etypes ( krb5_get_default_in_tkt_etypes (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype **/*etypes*/); krb5_enctype **/*etypes*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_default_principal ( krb5_get_default_principal (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal */*princ*/); krb5_principal */*princ*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_default_realm ( krb5_get_default_realm (
krb5_context /*context*/, krb5_context /*context*/,
krb5_realm */*realm*/); krb5_realm */*realm*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_default_realms ( krb5_get_default_realms (
krb5_context /*context*/, krb5_context /*context*/,
krb5_realm **/*realms*/); krb5_realm **/*realms*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_get_dns_canonicalize_hostname (krb5_context /*context*/); krb5_get_dns_canonicalize_hostname (krb5_context /*context*/);
const char* KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL
krb5_get_err_text ( krb5_get_err_text (
krb5_context /*context*/, krb5_context /*context*/,
krb5_error_code /*code*/) krb5_error_code /*code*/);
KRB5_DEPRECATED;
const char * KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION const char * KRB5_LIB_CALL
krb5_get_error_message ( krb5_get_error_message (
krb5_context /*context*/, krb5_context /*context*/,
krb5_error_code /*code*/); krb5_error_code /*code*/);
char * KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION char * KRB5_LIB_CALL
krb5_get_error_string (krb5_context /*context*/); krb5_get_error_string (krb5_context /*context*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_extra_addresses ( krb5_get_extra_addresses (
krb5_context /*context*/, krb5_context /*context*/,
krb5_addresses */*addresses*/); krb5_addresses */*addresses*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_fcache_version ( krb5_get_fcache_version (
krb5_context /*context*/, krb5_context /*context*/,
int */*version*/); int */*version*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_forwarded_creds ( krb5_get_forwarded_creds (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
krb5_flags /*flags*/, krb5_flags /*flags*/,
const char */*hostname*/, const char */*hostname*/,
krb5_creds */*in_creds*/, krb5_creds */*in_creds*/,
krb5_data */*out_data*/); krb5_data */*out_data*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_host_realm ( krb5_get_host_realm (
krb5_context /*context*/, krb5_context /*context*/,
const char */*targethost*/, const char */*targethost*/,
krb5_realm **/*realms*/); krb5_realm **/*realms*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_ignore_addresses ( krb5_get_ignore_addresses (
krb5_context /*context*/, krb5_context /*context*/,
krb5_addresses */*addresses*/); krb5_addresses */*addresses*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_in_cred ( krb5_get_in_cred (
krb5_context /*context*/, krb5_context /*context*/,
krb5_flags /*options*/, krb5_flags /*options*/,
const krb5_addresses */*addrs*/, const krb5_addresses */*addrs*/,
const krb5_enctype */*etypes*/, const krb5_enctype */*etypes*/,
const krb5_preauthtype */*ptypes*/, const krb5_preauthtype */*ptypes*/,
const krb5_preauthdata */*preauth*/, const krb5_preauthdata */*preauth*/,
krb5_key_proc /*key_proc*/, krb5_key_proc /*key_proc*/,
krb5_const_pointer /*keyseed*/, krb5_const_pointer /*keyseed*/,
krb5_decrypt_proc /*decrypt_proc*/, krb5_decrypt_proc /*decrypt_proc*/,
krb5_const_pointer /*decryptarg*/, krb5_const_pointer /*decryptarg*/,
krb5_creds */*creds*/, krb5_creds */*creds*/,
krb5_kdc_rep */*ret_as_reply*/) krb5_kdc_rep */*ret_as_reply*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_in_tkt ( krb5_get_in_tkt (
krb5_context /*context*/, krb5_context /*context*/,
krb5_flags /*options*/, krb5_flags /*options*/,
const krb5_addresses */*addrs*/, const krb5_addresses */*addrs*/,
const krb5_enctype */*etypes*/, const krb5_enctype */*etypes*/,
const krb5_preauthtype */*ptypes*/, const krb5_preauthtype */*ptypes*/,
krb5_key_proc /*key_proc*/, krb5_key_proc /*key_proc*/,
krb5_const_pointer /*keyseed*/, krb5_const_pointer /*keyseed*/,
krb5_decrypt_proc /*decrypt_proc*/, krb5_decrypt_proc /*decrypt_proc*/,
krb5_const_pointer /*decryptarg*/, krb5_const_pointer /*decryptarg*/,
krb5_creds */*creds*/, krb5_creds */*creds*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
krb5_kdc_rep */*ret_as_reply*/) krb5_kdc_rep */*ret_as_reply*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_in_tkt_with_keytab ( krb5_get_in_tkt_with_keytab (
krb5_context /*context*/, krb5_context /*context*/,
krb5_flags /*options*/, krb5_flags /*options*/,
krb5_addresses */*addrs*/, krb5_addresses */*addrs*/,
const krb5_enctype */*etypes*/, const krb5_enctype */*etypes*/,
const krb5_preauthtype */*pre_auth_types*/, const krb5_preauthtype */*pre_auth_types*/,
krb5_keytab /*keytab*/, krb5_keytab /*keytab*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
krb5_creds */*creds*/, krb5_creds */*creds*/,
krb5_kdc_rep */*ret_as_reply*/) krb5_kdc_rep */*ret_as_reply*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_in_tkt_with_password ( krb5_get_in_tkt_with_password (
krb5_context /*context*/, krb5_context /*context*/,
krb5_flags /*options*/, krb5_flags /*options*/,
krb5_addresses */*addrs*/, krb5_addresses */*addrs*/,
const krb5_enctype */*etypes*/, const krb5_enctype */*etypes*/,
const krb5_preauthtype */*pre_auth_types*/, const krb5_preauthtype */*pre_auth_types*/,
const char */*password*/, const char */*password*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
krb5_creds */*creds*/, krb5_creds */*creds*/,
krb5_kdc_rep */*ret_as_reply*/) krb5_kdc_rep */*ret_as_reply*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_in_tkt_with_skey ( krb5_get_in_tkt_with_skey (
krb5_context /*context*/, krb5_context /*context*/,
krb5_flags /*options*/, krb5_flags /*options*/,
krb5_addresses */*addrs*/, krb5_addresses */*addrs*/,
const krb5_enctype */*etypes*/, const krb5_enctype */*etypes*/,
const krb5_preauthtype */*pre_auth_types*/, const krb5_preauthtype */*pre_auth_types*/,
const krb5_keyblock */*key*/, const krb5_keyblock */*key*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
krb5_creds */*creds*/, krb5_creds */*creds*/,
krb5_kdc_rep */*ret_as_reply*/) krb5_kdc_rep */*ret_as_reply*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_init_creds_keyblock ( krb5_get_init_creds_keyblock (
krb5_context /*context*/, krb5_context /*context*/,
krb5_creds */*creds*/, krb5_creds */*creds*/,
krb5_principal /*client*/, krb5_principal /*client*/,
krb5_keyblock */*keyblock*/, krb5_keyblock */*keyblock*/,
krb5_deltat /*start_time*/, krb5_deltat /*start_time*/,
const char */*in_tkt_service*/, const char */*in_tkt_service*/,
krb5_get_init_creds_opt */*options*/); krb5_get_init_creds_opt */*options*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_init_creds_keytab ( krb5_get_init_creds_keytab (
krb5_context /*context*/, krb5_context /*context*/,
krb5_creds */*creds*/, krb5_creds */*creds*/,
krb5_principal /*client*/, krb5_principal /*client*/,
krb5_keytab /*keytab*/, krb5_keytab /*keytab*/,
krb5_deltat /*start_time*/, krb5_deltat /*start_time*/,
const char */*in_tkt_service*/, const char */*in_tkt_service*/,
krb5_get_init_creds_opt */*options*/); krb5_get_init_creds_opt */*options*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_init_creds_opt_alloc ( krb5_get_init_creds_opt_alloc (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_init_creds_opt **/*opt*/); krb5_get_init_creds_opt **/*opt*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_get_init_creds_opt_free ( krb5_get_init_creds_opt_free (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_init_creds_opt */*opt*/); krb5_get_init_creds_opt */*opt*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_init_creds_opt_get_error ( krb5_get_init_creds_opt_get_error (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_init_creds_opt */*opt*/, krb5_get_init_creds_opt */*opt*/,
KRB_ERROR **/*error*/) KRB_ERROR **/*error*/);
KRB5_DEPRECATED;
void KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_get_init_creds_opt_init (krb5_get_init_creds_opt */*opt*/) krb5_get_init_creds_opt_init (krb5_get_init_creds_opt */*opt*/);
KRB5_DEPRECATED;
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_get_init_creds_opt_set_address_list ( krb5_get_init_creds_opt_set_address_list (
krb5_get_init_creds_opt */*opt*/, krb5_get_init_creds_opt */*opt*/,
krb5_addresses */*addresses*/); krb5_addresses */*addresses*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_init_creds_opt_set_addressless ( krb5_get_init_creds_opt_set_addressless (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_init_creds_opt */*opt*/, krb5_get_init_creds_opt */*opt*/,
krb5_boolean /*addressless*/); krb5_boolean /*addressless*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_get_init_creds_opt_set_anonymous ( krb5_get_init_creds_opt_set_anonymous (
krb5_get_init_creds_opt */*opt*/, krb5_get_init_creds_opt */*opt*/,
int /*anonymous*/); int /*anonymous*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_init_creds_opt_set_canonicalize ( krb5_get_init_creds_opt_set_canonicalize (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_init_creds_opt */*opt*/, krb5_get_init_creds_opt */*opt*/,
krb5_boolean /*req*/); krb5_boolean /*req*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_get_init_creds_opt_set_default_flags ( krb5_get_init_creds_opt_set_default_flags (
krb5_context /*context*/, krb5_context /*context*/,
const char */*appname*/, const char */*appname*/,
krb5_const_realm /*realm*/, krb5_const_realm /*realm*/,
krb5_get_init_creds_opt */*opt*/); krb5_get_init_creds_opt */*opt*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_get_init_creds_opt_set_etype_list ( krb5_get_init_creds_opt_set_etype_list (
krb5_get_init_creds_opt */*opt*/, krb5_get_init_creds_opt */*opt*/,
krb5_enctype */*etype_list*/, krb5_enctype */*etype_list*/,
int /*etype_list_length*/); int /*etype_list_length*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_get_init_creds_opt_set_forwardable ( krb5_get_init_creds_opt_set_forwardable (
krb5_get_init_creds_opt */*opt*/, krb5_get_init_creds_opt */*opt*/,
int /*forwardable*/); int /*forwardable*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_init_creds_opt_set_pa_password ( krb5_get_init_creds_opt_set_pa_password (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_init_creds_opt */*opt*/, krb5_get_init_creds_opt */*opt*/,
const char */*password*/, const char */*password*/,
krb5_s2k_proc /*key_proc*/); krb5_s2k_proc /*key_proc*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_init_creds_opt_set_pac_request ( krb5_get_init_creds_opt_set_pac_request (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_init_creds_opt */*opt*/, krb5_get_init_creds_opt */*opt*/,
krb5_boolean /*req_pac*/); krb5_boolean /*req_pac*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_init_creds_opt_set_pkinit ( krb5_get_init_creds_opt_set_pkinit (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_init_creds_opt */*opt*/, krb5_get_init_creds_opt */*opt*/,
krb5_principal /*principal*/, krb5_principal /*principal*/,
const char */*user_id*/, const char */*user_id*/,
const char */*x509_anchors*/, const char */*x509_anchors*/,
char * const * /*pool*/, char * const * /*pool*/,
char * const * /*pki_revoke*/, char * const * /*pki_revoke*/,
int /*flags*/, int /*flags*/,
krb5_prompter_fct /*prompter*/, krb5_prompter_fct /*prompter*/,
void */*prompter_data*/, void */*prompter_data*/,
char */*password*/); char */*password*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_get_init_creds_opt_set_preauth_list ( krb5_get_init_creds_opt_set_preauth_list (
krb5_get_init_creds_opt */*opt*/, krb5_get_init_creds_opt */*opt*/,
krb5_preauthtype */*preauth_list*/, krb5_preauthtype */*preauth_list*/,
int /*preauth_list_length*/); int /*preauth_list_length*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_init_creds_opt_set_process_last_req ( krb5_get_init_creds_opt_set_process_last_req (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_init_creds_opt */*opt*/, krb5_get_init_creds_opt */*opt*/,
krb5_gic_process_last_req /*func*/, krb5_gic_process_last_req /*func*/,
void */*ctx*/); void */*ctx*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_get_init_creds_opt_set_proxiable ( krb5_get_init_creds_opt_set_proxiable (
krb5_get_init_creds_opt */*opt*/, krb5_get_init_creds_opt */*opt*/,
int /*proxiable*/); int /*proxiable*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_get_init_creds_opt_set_renew_life ( krb5_get_init_creds_opt_set_renew_life (
krb5_get_init_creds_opt */*opt*/, krb5_get_init_creds_opt */*opt*/,
krb5_deltat /*renew_life*/); krb5_deltat /*renew_life*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_get_init_creds_opt_set_salt ( krb5_get_init_creds_opt_set_salt (
krb5_get_init_creds_opt */*opt*/, krb5_get_init_creds_opt */*opt*/,
krb5_data */*salt*/); krb5_data */*salt*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_get_init_creds_opt_set_tkt_life ( krb5_get_init_creds_opt_set_tkt_life (
krb5_get_init_creds_opt */*opt*/, krb5_get_init_creds_opt */*opt*/,
krb5_deltat /*tkt_life*/); krb5_deltat /*tkt_life*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_init_creds_opt_set_win2k ( krb5_get_init_creds_opt_set_win2k (
krb5_context /*context*/, krb5_context /*context*/,
krb5_get_init_creds_opt */*opt*/, krb5_get_init_creds_opt */*opt*/,
krb5_boolean /*req*/); krb5_boolean /*req*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_init_creds_password ( krb5_get_init_creds_password (
krb5_context /*context*/, krb5_context /*context*/,
krb5_creds */*creds*/, krb5_creds */*creds*/,
krb5_principal /*client*/, krb5_principal /*client*/,
const char */*password*/, const char */*password*/,
krb5_prompter_fct /*prompter*/, krb5_prompter_fct /*prompter*/,
void */*data*/, void */*data*/,
krb5_deltat /*start_time*/, krb5_deltat /*start_time*/,
const char */*in_tkt_service*/, const char */*in_tkt_service*/,
krb5_get_init_creds_opt */*options*/); krb5_get_init_creds_opt */*options*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_kdc_cred ( krb5_get_kdc_cred (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*id*/, krb5_ccache /*id*/,
krb5_kdc_flags /*flags*/, krb5_kdc_flags /*flags*/,
krb5_addresses */*addresses*/, krb5_addresses */*addresses*/,
Ticket */*second_ticket*/, Ticket */*second_ticket*/,
krb5_creds */*in_creds*/, krb5_creds */*in_creds*/,
krb5_creds **out_creds ); krb5_creds **out_creds );
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_kdc_sec_offset ( krb5_get_kdc_sec_offset (
krb5_context /*context*/, krb5_context /*context*/,
int32_t */*sec*/, int32_t */*sec*/,
int32_t */*usec*/); int32_t */*usec*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_krb524hst ( krb5_get_krb524hst (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_realm */*realm*/, const krb5_realm */*realm*/,
char ***/*hostlist*/); char ***/*hostlist*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_krb_admin_hst ( krb5_get_krb_admin_hst (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_realm */*realm*/, const krb5_realm */*realm*/,
char ***/*hostlist*/); char ***/*hostlist*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_krb_changepw_hst ( krb5_get_krb_changepw_hst (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_realm */*realm*/, const krb5_realm */*realm*/,
char ***/*hostlist*/); char ***/*hostlist*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_krbhst ( krb5_get_krbhst (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_realm */*realm*/, const krb5_realm */*realm*/,
char ***/*hostlist*/); char ***/*hostlist*/);
time_t KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION time_t KRB5_LIB_CALL
krb5_get_max_time_skew (krb5_context /*context*/); krb5_get_max_time_skew (krb5_context /*context*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_permitted_enctypes (
krb5_context /*context*/,
krb5_enctype **/*etypes*/);
KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_pw_salt ( krb5_get_pw_salt (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*principal*/, krb5_const_principal /*principal*/,
krb5_salt */*salt*/); krb5_salt */*salt*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_renewed_creds ( krb5_get_renewed_creds (
krb5_context /*context*/, krb5_context /*context*/,
krb5_creds */*creds*/, krb5_creds */*creds*/,
krb5_const_principal /*client*/, krb5_const_principal /*client*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
const char */*in_tkt_service*/); const char */*in_tkt_service*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_server_rcache ( krb5_get_server_rcache (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_data */*piece*/, const krb5_data */*piece*/,
krb5_rcache */*id*/); krb5_rcache */*id*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_get_use_admin_kdc (krb5_context /*context*/); krb5_get_use_admin_kdc (krb5_context /*context*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_validated_creds ( krb5_get_validated_creds (
krb5_context /*context*/, krb5_context /*context*/,
krb5_creds */*creds*/, krb5_creds */*creds*/,
krb5_principal /*client*/, krb5_principal /*client*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
char */*service*/); char */*service*/);
krb5_log_facility * KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_log_facility * KRB5_LIB_CALL
krb5_get_warn_dest (krb5_context /*context*/); krb5_get_warn_dest (krb5_context /*context*/);
size_t size_t
krb5_get_wrapped_length ( krb5_get_wrapped_length (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
size_t /*data_len*/); size_t /*data_len*/);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
krb5_getportbyname ( krb5_getportbyname (
krb5_context /*context*/, krb5_context /*context*/,
const char */*service*/, const char */*service*/,
const char */*proto*/, const char */*proto*/,
int /*default_port*/); int /*default_port*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_h_addr2addr ( krb5_h_addr2addr (
krb5_context /*context*/, krb5_context /*context*/,
int /*af*/, int /*af*/,
const char */*haddr*/, const char */*haddr*/,
krb5_address */*addr*/); krb5_address */*addr*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_h_addr2sockaddr ( krb5_h_addr2sockaddr (
krb5_context /*context*/, krb5_context /*context*/,
int /*af*/, int /*af*/,
const char */*addr*/, const char */*addr*/,
struct sockaddr */*sa*/, struct sockaddr */*sa*/,
krb5_socklen_t */*sa_size*/, krb5_socklen_t */*sa_size*/,
int /*port*/); int /*port*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_h_errno_to_heim_errno (int /*eai_errno*/); krb5_h_errno_to_heim_errno (int /*eai_errno*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_have_error_string (krb5_context /*context*/); krb5_have_error_string (krb5_context /*context*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_hmac ( krb5_hmac (
krb5_context /*context*/, krb5_context /*context*/,
krb5_cksumtype /*cktype*/, krb5_cksumtype /*cktype*/,
const void */*data*/, const void */*data*/,
size_t /*len*/, size_t /*len*/,
unsigned /*usage*/, unsigned /*usage*/,
krb5_keyblock */*key*/, krb5_keyblock */*key*/,
Checksum */*result*/); Checksum */*result*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_init_context (krb5_context */*context*/); krb5_init_context (krb5_context */*context*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_init_creds_free ( krb5_init_creds_free (
krb5_context /*context*/, krb5_context /*context*/,
krb5_init_creds_context /*ctx*/); krb5_init_creds_context /*ctx*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_init_creds_get ( krb5_init_creds_get (
krb5_context /*context*/, krb5_context /*context*/,
krb5_init_creds_context /*ctx*/); krb5_init_creds_context /*ctx*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_init_creds_get_creds ( krb5_init_creds_get_creds (
krb5_context /*context*/, krb5_context /*context*/,
krb5_init_creds_context /*ctx*/, krb5_init_creds_context /*ctx*/,
krb5_creds */*cred*/); krb5_creds */*cred*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_init_creds_get_error ( krb5_init_creds_get_error (
krb5_context /*context*/, krb5_context /*context*/,
krb5_init_creds_context /*ctx*/, krb5_init_creds_context /*ctx*/,
KRB_ERROR */*error*/); KRB_ERROR */*error*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_init_creds_init ( krb5_init_creds_init (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal /*client*/, krb5_principal /*client*/,
krb5_prompter_fct /*prompter*/, krb5_prompter_fct /*prompter*/,
void */*prompter_data*/, void */*prompter_data*/,
krb5_deltat /*start_time*/, krb5_deltat /*start_time*/,
krb5_get_init_creds_opt */*options*/, krb5_get_init_creds_opt */*options*/,
krb5_init_creds_context */*rctx*/); krb5_init_creds_context */*rctx*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_init_creds_set_keyblock ( krb5_init_creds_set_keyblock (
krb5_context /*context*/, krb5_context /*context*/,
krb5_init_creds_context /*ctx*/, krb5_init_creds_context /*ctx*/,
krb5_keyblock */*keyblock*/); krb5_keyblock */*keyblock*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_init_creds_set_keytab ( krb5_init_creds_set_keytab (
krb5_context /*context*/, krb5_context /*context*/,
krb5_init_creds_context /*ctx*/, krb5_init_creds_context /*ctx*/,
krb5_keytab /*keytab*/); krb5_keytab /*keytab*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_init_creds_set_password ( krb5_init_creds_set_password (
krb5_context /*context*/, krb5_context /*context*/,
krb5_init_creds_context /*ctx*/, krb5_init_creds_context /*ctx*/,
const char */*password*/); const char */*password*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_init_creds_set_service ( krb5_init_creds_set_service (
krb5_context /*context*/, krb5_context /*context*/,
krb5_init_creds_context /*ctx*/, krb5_init_creds_context /*ctx*/,
const char */*service*/); const char */*service*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_init_creds_step ( krb5_init_creds_step (
krb5_context /*context*/, krb5_context /*context*/,
krb5_init_creds_context /*ctx*/, krb5_init_creds_context /*ctx*/,
krb5_data */*in*/, krb5_data */*in*/,
krb5_data */*out*/, krb5_data */*out*/,
krb5_krbhst_info */*hostinfo*/, krb5_krbhst_info */*hostinfo*/,
unsigned int */*flags*/); unsigned int */*flags*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_init_ets (krb5_context /*context*/); krb5_init_ets (krb5_context /*context*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_init_etype ( krb5_init_etype (
krb5_context /*context*/, krb5_context /*context*/,
unsigned */*len*/, unsigned */*len*/,
krb5_enctype **/*val*/, krb5_enctype **/*val*/,
const krb5_enctype */*etypes*/); const krb5_enctype */*etypes*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_initlog ( krb5_initlog (
krb5_context /*context*/, krb5_context /*context*/,
const char */*program*/, const char */*program*/,
krb5_log_facility **/*fac*/); krb5_log_facility **/*fac*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_is_config_principal ( krb5_is_config_principal (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*principal*/); krb5_const_principal /*principal*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_is_thread_safe (void); krb5_is_thread_safe (void);
const krb5_enctype * KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_FUNCTION
krb5_kcm_call (
krb5_context /*context*/,
krb5_storage */*request*/,
krb5_storage **/*response_p*/,
krb5_data */*response_data_p*/);
krb5_error_code
krb5_kcm_storage_request (
krb5_context /*context*/,
uint16_t /*opcode*/,
krb5_storage **/*storage_p*/);
KRB5_LIB_FUNCTION const krb5_enctype * KRB5_LIB_CALL
krb5_kerberos_enctypes (krb5_context /*context*/); krb5_kerberos_enctypes (krb5_context /*context*/);
krb5_enctype krb5_enctype
krb5_keyblock_get_enctype (const krb5_keyblock */*block*/); krb5_keyblock_get_enctype (const krb5_keyblock */*block*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_keyblock_init ( krb5_keyblock_init (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*type*/, krb5_enctype /*type*/,
const void */*data*/, const void */*data*/,
size_t /*size*/, size_t /*size*/,
krb5_keyblock */*key*/); krb5_keyblock */*key*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_keyblock_key_proc ( krb5_keyblock_key_proc (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keytype /*type*/, krb5_keytype /*type*/,
krb5_data */*salt*/, krb5_data */*salt*/,
krb5_const_pointer /*keyseed*/, krb5_const_pointer /*keyseed*/,
krb5_keyblock **/*key*/); krb5_keyblock **/*key*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_keyblock_zero (krb5_keyblock */*keyblock*/); krb5_keyblock_zero (krb5_keyblock */*keyblock*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_CALLCONV
krb5_keytab_key_proc ( krb5_keytab_key_proc (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*enctype*/, krb5_enctype /*enctype*/,
krb5_salt /*salt*/, krb5_salt /*salt*/,
krb5_const_pointer /*keyseed*/, krb5_const_pointer /*keyseed*/,
krb5_keyblock **/*key*/) krb5_keyblock **/*key*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_keytype_to_enctypes ( krb5_keytype_to_enctypes (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keytype /*keytype*/, krb5_keytype /*keytype*/,
unsigned */*len*/, unsigned */*len*/,
krb5_enctype **/*val*/) krb5_enctype **/*val*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_keytype_to_enctypes_default ( krb5_keytype_to_enctypes_default (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keytype /*keytype*/, krb5_keytype /*keytype*/,
unsigned */*len*/, unsigned */*len*/,
krb5_enctype **/*val*/) krb5_enctype **/*val*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_keytype_to_string ( krb5_keytype_to_string (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keytype /*keytype*/, krb5_keytype /*keytype*/,
char **/*string*/) char **/*string*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_krbhst_format_string ( krb5_krbhst_format_string (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_krbhst_info */*host*/, const krb5_krbhst_info */*host*/,
char */*hostname*/, char */*hostname*/,
size_t /*hostlen*/); size_t /*hostlen*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_krbhst_free ( krb5_krbhst_free (
krb5_context /*context*/, krb5_context /*context*/,
krb5_krbhst_handle /*handle*/); krb5_krbhst_handle /*handle*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_krbhst_get_addrinfo ( krb5_krbhst_get_addrinfo (
krb5_context /*context*/, krb5_context /*context*/,
krb5_krbhst_info */*host*/, krb5_krbhst_info */*host*/,
struct addrinfo **/*ai*/); struct addrinfo **/*ai*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_krbhst_init ( krb5_krbhst_init (
krb5_context /*context*/, krb5_context /*context*/,
const char */*realm*/, const char */*realm*/,
unsigned int /*type*/, unsigned int /*type*/,
krb5_krbhst_handle */*handle*/); krb5_krbhst_handle */*handle*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_krbhst_init_flags ( krb5_krbhst_init_flags (
krb5_context /*context*/, krb5_context /*context*/,
const char */*realm*/, const char */*realm*/,
unsigned int /*type*/, unsigned int /*type*/,
int /*flags*/, int /*flags*/,
krb5_krbhst_handle */*handle*/); krb5_krbhst_handle */*handle*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_krbhst_next ( krb5_krbhst_next (
krb5_context /*context*/, krb5_context /*context*/,
krb5_krbhst_handle /*handle*/, krb5_krbhst_handle /*handle*/,
krb5_krbhst_info **/*host*/); krb5_krbhst_info **/*host*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_krbhst_next_as_string ( krb5_krbhst_next_as_string (
krb5_context /*context*/, krb5_context /*context*/,
krb5_krbhst_handle /*handle*/, krb5_krbhst_handle /*handle*/,
char */*hostname*/, char */*hostname*/,
size_t /*hostlen*/); size_t /*hostlen*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_krbhst_reset ( krb5_krbhst_reset (
krb5_context /*context*/, krb5_context /*context*/,
krb5_krbhst_handle /*handle*/); krb5_krbhst_handle /*handle*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_add_entry ( krb5_kt_add_entry (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keytab /*id*/, krb5_keytab /*id*/,
krb5_keytab_entry */*entry*/); krb5_keytab_entry */*entry*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_close ( krb5_kt_close (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keytab /*id*/); krb5_keytab /*id*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_kt_compare ( krb5_kt_compare (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keytab_entry */*entry*/, krb5_keytab_entry */*entry*/,
krb5_const_principal /*principal*/, krb5_const_principal /*principal*/,
krb5_kvno /*vno*/, krb5_kvno /*vno*/,
krb5_enctype /*enctype*/); krb5_enctype /*enctype*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_copy_entry_contents ( krb5_kt_copy_entry_contents (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_keytab_entry */*in*/, const krb5_keytab_entry */*in*/,
krb5_keytab_entry */*out*/); krb5_keytab_entry */*out*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_default ( krb5_kt_default (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keytab */*id*/); krb5_keytab */*id*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_default_modify_name ( krb5_kt_default_modify_name (
krb5_context /*context*/, krb5_context /*context*/,
char */*name*/, char */*name*/,
size_t /*namesize*/); size_t /*namesize*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_default_name ( krb5_kt_default_name (
krb5_context /*context*/, krb5_context /*context*/,
char */*name*/, char */*name*/,
size_t /*namesize*/); size_t /*namesize*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_destroy ( krb5_kt_destroy (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keytab /*id*/); krb5_keytab /*id*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_end_seq_get ( krb5_kt_end_seq_get (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keytab /*id*/, krb5_keytab /*id*/,
krb5_kt_cursor */*cursor*/); krb5_kt_cursor */*cursor*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_free_entry ( krb5_kt_free_entry (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keytab_entry */*entry*/); krb5_keytab_entry */*entry*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_get_entry ( krb5_kt_get_entry (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keytab /*id*/, krb5_keytab /*id*/,
krb5_const_principal /*principal*/, krb5_const_principal /*principal*/,
krb5_kvno /*kvno*/, krb5_kvno /*kvno*/,
krb5_enctype /*enctype*/, krb5_enctype /*enctype*/,
krb5_keytab_entry */*entry*/); krb5_keytab_entry */*entry*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_get_full_name ( krb5_kt_get_full_name (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keytab /*keytab*/, krb5_keytab /*keytab*/,
char **/*str*/); char **/*str*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_get_name ( krb5_kt_get_name (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keytab /*keytab*/, krb5_keytab /*keytab*/,
char */*name*/, char */*name*/,
size_t /*namesize*/); size_t /*namesize*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_get_type ( krb5_kt_get_type (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keytab /*keytab*/, krb5_keytab /*keytab*/,
char */*prefix*/, char */*prefix*/,
size_t /*prefixsize*/); size_t /*prefixsize*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_next_entry ( krb5_kt_next_entry (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keytab /*id*/, krb5_keytab /*id*/,
krb5_keytab_entry */*entry*/, krb5_keytab_entry */*entry*/,
krb5_kt_cursor */*cursor*/); krb5_kt_cursor */*cursor*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_read_service_key ( krb5_kt_read_service_key (
krb5_context /*context*/, krb5_context /*context*/,
krb5_pointer /*keyprocarg*/, krb5_pointer /*keyprocarg*/,
krb5_principal /*principal*/, krb5_principal /*principal*/,
krb5_kvno /*vno*/, krb5_kvno /*vno*/,
krb5_enctype /*enctype*/, krb5_enctype /*enctype*/,
krb5_keyblock **/*key*/); krb5_keyblock **/*key*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_register ( krb5_kt_register (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_kt_ops */*ops*/); const krb5_kt_ops */*ops*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_remove_entry ( krb5_kt_remove_entry (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keytab /*id*/, krb5_keytab /*id*/,
krb5_keytab_entry */*entry*/); krb5_keytab_entry */*entry*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_resolve ( krb5_kt_resolve (
krb5_context /*context*/, krb5_context /*context*/,
const char */*name*/, const char */*name*/,
krb5_keytab */*id*/); krb5_keytab */*id*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_kt_start_seq_get ( krb5_kt_start_seq_get (
krb5_context /*context*/, krb5_context /*context*/,
krb5_keytab /*id*/, krb5_keytab /*id*/,
krb5_kt_cursor */*cursor*/); krb5_kt_cursor */*cursor*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_kuserok ( krb5_kuserok (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal /*principal*/, krb5_principal /*principal*/,
const char */*luser*/); const char */*luser*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_log ( krb5_log (
krb5_context /*context*/, krb5_context /*context*/,
krb5_log_facility */*fac*/, krb5_log_facility */*fac*/,
int /*level*/, int /*level*/,
const char */*fmt*/, const char */*fmt*/,
...) ...)
__attribute__((format (printf, 4, 5))); __attribute__((format (printf, 4, 5)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_log_msg ( krb5_log_msg (
krb5_context /*context*/, krb5_context /*context*/,
krb5_log_facility */*fac*/, krb5_log_facility */*fac*/,
int /*level*/, int /*level*/,
char **/*reply*/, char **/*reply*/,
const char */*fmt*/, const char */*fmt*/,
...) ...)
__attribute__((format (printf, 5, 6))); __attribute__((format (printf, 5, 6)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_make_addrport ( krb5_make_addrport (
krb5_context /*context*/, krb5_context /*context*/,
krb5_address **/*res*/, krb5_address **/*res*/,
const krb5_address */*addr*/, const krb5_address */*addr*/,
int16_t /*port*/); int16_t /*port*/);
krb5_error_code KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_FUNCTION
krb5_make_principal ( krb5_make_principal (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal */*principal*/, krb5_principal */*principal*/,
krb5_const_realm /*realm*/, krb5_const_realm /*realm*/,
...); ...);
size_t KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION size_t KRB5_LIB_CALL
krb5_max_sockaddr_size (void); krb5_max_sockaddr_size (void);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_mk_error ( krb5_mk_error (
krb5_context /*context*/, krb5_context /*context*/,
krb5_error_code /*error_code*/, krb5_error_code /*error_code*/,
const char */*e_text*/, const char */*e_text*/,
const krb5_data */*e_data*/, const krb5_data */*e_data*/,
const krb5_principal /*client*/, const krb5_principal /*client*/,
const krb5_principal /*server*/, const krb5_principal /*server*/,
time_t */*client_time*/, time_t */*client_time*/,
int */*client_usec*/, int */*client_usec*/,
krb5_data */*reply*/); krb5_data */*reply*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_mk_priv ( krb5_mk_priv (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
const krb5_data */*userdata*/, const krb5_data */*userdata*/,
krb5_data */*outbuf*/, krb5_data */*outbuf*/,
krb5_replay_data */*outdata*/); krb5_replay_data */*outdata*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_mk_rep ( krb5_mk_rep (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_data */*outbuf*/); krb5_data */*outbuf*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_mk_req ( krb5_mk_req (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context */*auth_context*/, krb5_auth_context */*auth_context*/,
const krb5_flags /*ap_req_options*/, const krb5_flags /*ap_req_options*/,
const char */*service*/, const char */*service*/,
const char */*hostname*/, const char */*hostname*/,
krb5_data */*in_data*/, krb5_data */*in_data*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
krb5_data */*outbuf*/); krb5_data */*outbuf*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_mk_req_exact ( krb5_mk_req_exact (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context */*auth_context*/, krb5_auth_context */*auth_context*/,
const krb5_flags /*ap_req_options*/, const krb5_flags /*ap_req_options*/,
const krb5_principal /*server*/, const krb5_principal /*server*/,
krb5_data */*in_data*/, krb5_data */*in_data*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
krb5_data */*outbuf*/); krb5_data */*outbuf*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_mk_req_extended ( krb5_mk_req_extended (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context */*auth_context*/, krb5_auth_context */*auth_context*/,
const krb5_flags /*ap_req_options*/, const krb5_flags /*ap_req_options*/,
krb5_data */*in_data*/, krb5_data */*in_data*/,
krb5_creds */*in_creds*/, krb5_creds */*in_creds*/,
krb5_data */*outbuf*/); krb5_data */*outbuf*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_mk_safe ( krb5_mk_safe (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
const krb5_data */*userdata*/, const krb5_data */*userdata*/,
krb5_data */*outbuf*/, krb5_data */*outbuf*/,
krb5_replay_data */*outdata*/); krb5_replay_data */*outdata*/);
krb5_ssize_t KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_ssize_t KRB5_LIB_CALL
krb5_net_read ( krb5_net_read (
krb5_context /*context*/, krb5_context /*context*/,
void */*p_fd*/, void */*p_fd*/,
void */*buf*/, void */*buf*/,
size_t /*len*/); size_t /*len*/);
krb5_ssize_t KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_ssize_t KRB5_LIB_CALL
krb5_net_write ( krb5_net_write (
krb5_context /*context*/, krb5_context /*context*/,
void */*p_fd*/, void */*p_fd*/,
const void */*buf*/, const void */*buf*/,
size_t /*len*/); size_t /*len*/);
krb5_ssize_t KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_ssize_t KRB5_LIB_CALL
krb5_net_write_block ( krb5_net_write_block (
krb5_context /*context*/, krb5_context /*context*/,
void */*p_fd*/, void */*p_fd*/,
const void */*buf*/, const void */*buf*/,
size_t /*len*/, size_t /*len*/,
time_t /*timeout*/); time_t /*timeout*/);
krb5_error_code krb5_error_code
krb5_ntlm_alloc ( krb5_ntlm_alloc (
krb5_context /*context*/, krb5_context /*context*/,
skipping to change at line 3052 skipping to change at line 3053
krb5_ntlm /*ntlm*/, krb5_ntlm /*ntlm*/,
const char */*username*/); const char */*username*/);
krb5_error_code krb5_error_code
krb5_ntlm_request ( krb5_ntlm_request (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ntlm /*ntlm*/, krb5_ntlm /*ntlm*/,
krb5_realm /*realm*/, krb5_realm /*realm*/,
krb5_ccache /*ccache*/); krb5_ccache /*ccache*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_openlog ( krb5_openlog (
krb5_context /*context*/, krb5_context /*context*/,
const char */*program*/, const char */*program*/,
krb5_log_facility **/*fac*/); krb5_log_facility **/*fac*/);
krb5_error_code krb5_error_code
krb5_pac_add_buffer ( krb5_pac_add_buffer (
krb5_context /*context*/, krb5_context /*context*/,
krb5_pac /*p*/, krb5_pac /*p*/,
uint32_t /*type*/, uint32_t /*type*/,
skipping to change at line 3105 skipping to change at line 3106
krb5_error_code krb5_error_code
krb5_pac_verify ( krb5_pac_verify (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_pac /*pac*/, const krb5_pac /*pac*/,
time_t /*authtime*/, time_t /*authtime*/,
krb5_const_principal /*principal*/, krb5_const_principal /*principal*/,
const krb5_keyblock */*server*/, const krb5_keyblock */*server*/,
const krb5_keyblock */*privsvr*/); const krb5_keyblock */*privsvr*/);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
krb5_padata_add ( krb5_padata_add (
krb5_context /*context*/, krb5_context /*context*/,
METHOD_DATA */*md*/, METHOD_DATA */*md*/,
int /*type*/, int /*type*/,
void */*buf*/, void */*buf*/,
size_t /*len*/); size_t /*len*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_parse_address ( krb5_parse_address (
krb5_context /*context*/, krb5_context /*context*/,
const char */*string*/, const char */*string*/,
krb5_addresses */*addresses*/); krb5_addresses */*addresses*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_parse_name ( krb5_parse_name (
krb5_context /*context*/, krb5_context /*context*/,
const char */*name*/, const char */*name*/,
krb5_principal */*principal*/); krb5_principal */*principal*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_parse_name_flags ( krb5_parse_name_flags (
krb5_context /*context*/, krb5_context /*context*/,
const char */*name*/, const char */*name*/,
int /*flags*/, int /*flags*/,
krb5_principal */*principal*/); krb5_principal */*principal*/);
krb5_error_code krb5_error_code
krb5_parse_nametype ( krb5_parse_nametype (
krb5_context /*context*/, krb5_context /*context*/,
const char */*str*/, const char */*str*/,
int32_t */*nametype*/); int32_t */*nametype*/);
const char* KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL
krb5_passwd_result_to_string ( krb5_passwd_result_to_string (
krb5_context /*context*/, krb5_context /*context*/,
int /*result*/); int /*result*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_CALLCONV
krb5_password_key_proc ( krb5_password_key_proc (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*type*/, krb5_enctype /*type*/,
krb5_salt /*salt*/, krb5_salt /*salt*/,
krb5_const_pointer /*keyseed*/, krb5_const_pointer /*keyseed*/,
krb5_keyblock **/*key*/) krb5_keyblock **/*key*/);
KRB5_DEPRECATED;
krb5_error_code krb5_error_code
krb5_plugin_register ( krb5_plugin_register (
krb5_context /*context*/, krb5_context /*context*/,
enum krb5_plugin_type /*type*/, enum krb5_plugin_type /*type*/,
const char */*name*/, const char */*name*/,
void */*symbol*/); void */*symbol*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_prepend_config_files ( krb5_prepend_config_files (
const char */*filelist*/, const char */*filelist*/,
char **/*pq*/, char **/*pq*/,
char ***/*ret_pp*/); char ***/*ret_pp*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_prepend_config_files_default ( krb5_prepend_config_files_default (
const char */*filelist*/, const char */*filelist*/,
char ***/*pfilenames*/); char ***/*pfilenames*/);
void KRB5_LIB_FUNCTION void KRB5_LIB_FUNCTION
krb5_prepend_error_message ( krb5_prepend_error_message (
krb5_context /*context*/, krb5_context /*context*/,
krb5_error_code /*ret*/, krb5_error_code /*ret*/,
const char */*fmt*/, const char */*fmt*/,
...) ...)
__attribute__ ((format (printf, 3, 4))); __attribute__ ((format (printf, 3, 4)));
krb5_realm * KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_realm * KRB5_LIB_CALL
krb5_princ_realm ( krb5_princ_realm (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal /*principal*/) krb5_principal /*principal*/);
KRB5_DEPRECATED;
void KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_princ_set_realm ( krb5_princ_set_realm (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal /*principal*/, krb5_principal /*principal*/,
krb5_realm */*realm*/) krb5_realm */*realm*/);
KRB5_DEPRECATED;
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_principal_compare ( krb5_principal_compare (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*princ1*/, krb5_const_principal /*princ1*/,
krb5_const_principal /*princ2*/); krb5_const_principal /*princ2*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_principal_compare_any_realm ( krb5_principal_compare_any_realm (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*princ1*/, krb5_const_principal /*princ1*/,
krb5_const_principal /*princ2*/); krb5_const_principal /*princ2*/);
const char* KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL
krb5_principal_get_comp_string ( krb5_principal_get_comp_string (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*principal*/, krb5_const_principal /*principal*/,
unsigned int /*component*/); unsigned int /*component*/);
unsigned int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION unsigned int KRB5_LIB_CALL
krb5_principal_get_num_comp ( krb5_principal_get_num_comp (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*principal*/); krb5_const_principal /*principal*/);
const char* KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL
krb5_principal_get_realm ( krb5_principal_get_realm (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*principal*/); krb5_const_principal /*principal*/);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
krb5_principal_get_type ( krb5_principal_get_type (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*principal*/); krb5_const_principal /*principal*/);
krb5_boolean krb5_boolean
krb5_principal_is_krbtgt ( krb5_principal_is_krbtgt (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*p*/); krb5_const_principal /*p*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_principal_match ( krb5_principal_match (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*princ*/, krb5_const_principal /*princ*/,
krb5_const_principal /*pattern*/); krb5_const_principal /*pattern*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_principal_set_realm ( krb5_principal_set_realm (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal /*principal*/, krb5_principal /*principal*/,
krb5_const_realm /*realm*/); krb5_const_realm /*realm*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_principal_set_type ( krb5_principal_set_type (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal /*principal*/, krb5_principal /*principal*/,
int /*type*/); int /*type*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_print_address ( krb5_print_address (
const krb5_address */*addr*/, const krb5_address */*addr*/,
char */*str*/, char */*str*/,
size_t /*len*/, size_t /*len*/,
size_t */*ret_len*/); size_t */*ret_len*/);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
krb5_program_setup ( krb5_program_setup (
krb5_context */*context*/, krb5_context */*context*/,
int /*argc*/, int /*argc*/,
char **/*argv*/, char **/*argv*/,
struct getargs */*args*/, struct getargs */*args*/,
int /*num_args*/, int /*num_args*/,
void (*/*usage*/)(int, struct getargs*, int)); void (KRB5_LIB_CALL *usage)(int, struct getargs*, int));
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_CALLCONV
krb5_prompter_posix ( krb5_prompter_posix (
krb5_context /*context*/, krb5_context /*context*/,
void */*data*/, void */*data*/,
const char */*name*/, const char */*name*/,
const char */*banner*/, const char */*banner*/,
int /*num_prompts*/, int /*num_prompts*/,
krb5_prompt prompts[]); krb5_prompt prompts[]);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_random_to_key ( krb5_random_to_key (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*type*/, krb5_enctype /*type*/,
const void */*data*/, const void */*data*/,
size_t /*size*/, size_t /*size*/,
krb5_keyblock */*key*/); krb5_keyblock */*key*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rc_close ( krb5_rc_close (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rcache /*id*/); krb5_rcache /*id*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rc_default ( krb5_rc_default (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rcache */*id*/); krb5_rcache */*id*/);
const char* KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL
krb5_rc_default_name (krb5_context /*context*/); krb5_rc_default_name (krb5_context /*context*/);
const char* KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL
krb5_rc_default_type (krb5_context /*context*/); krb5_rc_default_type (krb5_context /*context*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rc_destroy ( krb5_rc_destroy (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rcache /*id*/); krb5_rcache /*id*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rc_expunge ( krb5_rc_expunge (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rcache /*id*/); krb5_rcache /*id*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rc_get_lifespan ( krb5_rc_get_lifespan (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rcache /*id*/, krb5_rcache /*id*/,
krb5_deltat */*auth_lifespan*/); krb5_deltat */*auth_lifespan*/);
const char* KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL
krb5_rc_get_name ( krb5_rc_get_name (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rcache /*id*/); krb5_rcache /*id*/);
const char* KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL
krb5_rc_get_type ( krb5_rc_get_type (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rcache /*id*/); krb5_rcache /*id*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rc_initialize ( krb5_rc_initialize (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rcache /*id*/, krb5_rcache /*id*/,
krb5_deltat /*auth_lifespan*/); krb5_deltat /*auth_lifespan*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rc_recover ( krb5_rc_recover (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rcache /*id*/); krb5_rcache /*id*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rc_resolve ( krb5_rc_resolve (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rcache /*id*/, krb5_rcache /*id*/,
const char */*name*/); const char */*name*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rc_resolve_full ( krb5_rc_resolve_full (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rcache */*id*/, krb5_rcache */*id*/,
const char */*string_name*/); const char */*string_name*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rc_resolve_type ( krb5_rc_resolve_type (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rcache */*id*/, krb5_rcache */*id*/,
const char */*type*/); const char */*type*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rc_store ( krb5_rc_store (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rcache /*id*/, krb5_rcache /*id*/,
krb5_donot_replay */*rep*/); krb5_donot_replay */*rep*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rd_cred ( krb5_rd_cred (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_data */*in_data*/, krb5_data */*in_data*/,
krb5_creds ***/*ret_creds*/, krb5_creds ***/*ret_creds*/,
krb5_replay_data */*outdata*/); krb5_replay_data */*outdata*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rd_cred2 ( krb5_rd_cred2 (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
krb5_data */*in_data*/); krb5_data */*in_data*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rd_error ( krb5_rd_error (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_data */*msg*/, const krb5_data */*msg*/,
KRB_ERROR */*result*/); KRB_ERROR */*result*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rd_priv ( krb5_rd_priv (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
const krb5_data */*inbuf*/, const krb5_data */*inbuf*/,
krb5_data */*outbuf*/, krb5_data */*outbuf*/,
krb5_replay_data */*outdata*/); krb5_replay_data */*outdata*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rd_rep ( krb5_rd_rep (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
const krb5_data */*inbuf*/, const krb5_data */*inbuf*/,
krb5_ap_rep_enc_part **/*repl*/); krb5_ap_rep_enc_part **/*repl*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rd_req ( krb5_rd_req (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context */*auth_context*/, krb5_auth_context */*auth_context*/,
const krb5_data */*inbuf*/, const krb5_data */*inbuf*/,
krb5_const_principal /*server*/, krb5_const_principal /*server*/,
krb5_keytab /*keytab*/, krb5_keytab /*keytab*/,
krb5_flags */*ap_req_options*/, krb5_flags */*ap_req_options*/,
krb5_ticket **/*ticket*/); krb5_ticket **/*ticket*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rd_req_ctx ( krb5_rd_req_ctx (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context */*auth_context*/, krb5_auth_context */*auth_context*/,
const krb5_data */*inbuf*/, const krb5_data */*inbuf*/,
krb5_const_principal /*server*/, krb5_const_principal /*server*/,
krb5_rd_req_in_ctx /*inctx*/, krb5_rd_req_in_ctx /*inctx*/,
krb5_rd_req_out_ctx */*outctx*/); krb5_rd_req_out_ctx */*outctx*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rd_req_in_ctx_alloc ( krb5_rd_req_in_ctx_alloc (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rd_req_in_ctx */*ctx*/); krb5_rd_req_in_ctx */*ctx*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_rd_req_in_ctx_free ( krb5_rd_req_in_ctx_free (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rd_req_in_ctx /*ctx*/); krb5_rd_req_in_ctx /*ctx*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rd_req_in_set_keyblock ( krb5_rd_req_in_set_keyblock (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rd_req_in_ctx /*in*/, krb5_rd_req_in_ctx /*in*/,
krb5_keyblock */*keyblock*/); krb5_keyblock */*keyblock*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rd_req_in_set_keytab ( krb5_rd_req_in_set_keytab (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rd_req_in_ctx /*in*/, krb5_rd_req_in_ctx /*in*/,
krb5_keytab /*keytab*/); krb5_keytab /*keytab*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rd_req_in_set_pac_check ( krb5_rd_req_in_set_pac_check (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rd_req_in_ctx /*in*/, krb5_rd_req_in_ctx /*in*/,
krb5_boolean /*flag*/); krb5_boolean /*flag*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_rd_req_out_ctx_free ( krb5_rd_req_out_ctx_free (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rd_req_out_ctx /*ctx*/); krb5_rd_req_out_ctx /*ctx*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rd_req_out_get_ap_req_options ( krb5_rd_req_out_get_ap_req_options (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rd_req_out_ctx /*out*/, krb5_rd_req_out_ctx /*out*/,
krb5_flags */*ap_req_options*/); krb5_flags */*ap_req_options*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rd_req_out_get_keyblock ( krb5_rd_req_out_get_keyblock (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rd_req_out_ctx /*out*/, krb5_rd_req_out_ctx /*out*/,
krb5_keyblock **/*keyblock*/); krb5_keyblock **/*keyblock*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rd_req_out_get_server ( krb5_rd_req_out_get_server (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rd_req_out_ctx /*out*/, krb5_rd_req_out_ctx /*out*/,
krb5_principal */*principal*/); krb5_principal */*principal*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rd_req_out_get_ticket ( krb5_rd_req_out_get_ticket (
krb5_context /*context*/, krb5_context /*context*/,
krb5_rd_req_out_ctx /*out*/, krb5_rd_req_out_ctx /*out*/,
krb5_ticket **/*ticket*/); krb5_ticket **/*ticket*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rd_req_with_keyblock ( krb5_rd_req_with_keyblock (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context */*auth_context*/, krb5_auth_context */*auth_context*/,
const krb5_data */*inbuf*/, const krb5_data */*inbuf*/,
krb5_const_principal /*server*/, krb5_const_principal /*server*/,
krb5_keyblock */*keyblock*/, krb5_keyblock */*keyblock*/,
krb5_flags */*ap_req_options*/, krb5_flags */*ap_req_options*/,
krb5_ticket **/*ticket*/); krb5_ticket **/*ticket*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_rd_safe ( krb5_rd_safe (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*auth_context*/, krb5_auth_context /*auth_context*/,
const krb5_data */*inbuf*/, const krb5_data */*inbuf*/,
krb5_data */*outbuf*/, krb5_data */*outbuf*/,
krb5_replay_data */*outdata*/); krb5_replay_data */*outdata*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_read_message ( krb5_read_message (
krb5_context /*context*/, krb5_context /*context*/,
krb5_pointer /*p_fd*/, krb5_pointer /*p_fd*/,
krb5_data */*data*/); krb5_data */*data*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_read_priv_message ( krb5_read_priv_message (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*ac*/, krb5_auth_context /*ac*/,
krb5_pointer /*p_fd*/, krb5_pointer /*p_fd*/,
krb5_data */*data*/); krb5_data */*data*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_read_safe_message ( krb5_read_safe_message (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*ac*/, krb5_auth_context /*ac*/,
krb5_pointer /*p_fd*/, krb5_pointer /*p_fd*/,
krb5_data */*data*/); krb5_data */*data*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_realm_compare ( krb5_realm_compare (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*princ1*/, krb5_const_principal /*princ1*/,
krb5_const_principal /*princ2*/); krb5_const_principal /*princ2*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_recvauth ( krb5_recvauth (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context */*auth_context*/, krb5_auth_context */*auth_context*/,
krb5_pointer /*p_fd*/, krb5_pointer /*p_fd*/,
const char */*appl_version*/, const char */*appl_version*/,
krb5_principal /*server*/, krb5_principal /*server*/,
int32_t /*flags*/, int32_t /*flags*/,
krb5_keytab /*keytab*/, krb5_keytab /*keytab*/,
krb5_ticket **/*ticket*/); krb5_ticket **/*ticket*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_recvauth_match_version ( krb5_recvauth_match_version (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context */*auth_context*/, krb5_auth_context */*auth_context*/,
krb5_pointer /*p_fd*/, krb5_pointer /*p_fd*/,
krb5_boolean (*/*match_appl_version*/)(const void *, const char*), krb5_boolean (*/*match_appl_version*/)(const void *, const char*),
const void */*match_data*/, const void */*match_data*/,
krb5_principal /*server*/, krb5_principal /*server*/,
int32_t /*flags*/, int32_t /*flags*/,
krb5_keytab /*keytab*/, krb5_keytab /*keytab*/,
krb5_ticket **/*ticket*/); krb5_ticket **/*ticket*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ret_address ( krb5_ret_address (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_address */*adr*/); krb5_address */*adr*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ret_addrs ( krb5_ret_addrs (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_addresses */*adr*/); krb5_addresses */*adr*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ret_authdata ( krb5_ret_authdata (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_authdata */*auth*/); krb5_authdata */*auth*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ret_creds ( krb5_ret_creds (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_creds */*creds*/); krb5_creds */*creds*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ret_creds_tag ( krb5_ret_creds_tag (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_creds */*creds*/); krb5_creds */*creds*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ret_data ( krb5_ret_data (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_data */*data*/); krb5_data */*data*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ret_int16 ( krb5_ret_int16 (
krb5_storage */*sp*/, krb5_storage */*sp*/,
int16_t */*value*/); int16_t */*value*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ret_int32 ( krb5_ret_int32 (
krb5_storage */*sp*/, krb5_storage */*sp*/,
int32_t */*value*/); int32_t */*value*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ret_int8 ( krb5_ret_int8 (
krb5_storage */*sp*/, krb5_storage */*sp*/,
int8_t */*value*/); int8_t */*value*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ret_keyblock ( krb5_ret_keyblock (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_keyblock */*p*/); krb5_keyblock */*p*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ret_principal ( krb5_ret_principal (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_principal */*princ*/); krb5_principal */*princ*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ret_string ( krb5_ret_string (
krb5_storage */*sp*/, krb5_storage */*sp*/,
char **/*string*/); char **/*string*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ret_stringnl ( krb5_ret_stringnl (
krb5_storage */*sp*/, krb5_storage */*sp*/,
char **/*string*/); char **/*string*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ret_stringz ( krb5_ret_stringz (
krb5_storage */*sp*/, krb5_storage */*sp*/,
char **/*string*/); char **/*string*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ret_times ( krb5_ret_times (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_times */*times*/); krb5_times */*times*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ret_uint16 ( krb5_ret_uint16 (
krb5_storage */*sp*/, krb5_storage */*sp*/,
uint16_t */*value*/); uint16_t */*value*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ret_uint32 ( krb5_ret_uint32 (
krb5_storage */*sp*/, krb5_storage */*sp*/,
uint32_t */*value*/); uint32_t */*value*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ret_uint8 ( krb5_ret_uint8 (
krb5_storage */*sp*/, krb5_storage */*sp*/,
uint8_t */*value*/); uint8_t */*value*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_salttype_to_string ( krb5_salttype_to_string (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*etype*/, krb5_enctype /*etype*/,
krb5_salttype /*stype*/, krb5_salttype /*stype*/,
char **/*string*/); char **/*string*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_sendauth ( krb5_sendauth (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context */*auth_context*/, krb5_auth_context */*auth_context*/,
krb5_pointer /*p_fd*/, krb5_pointer /*p_fd*/,
const char */*appl_version*/, const char */*appl_version*/,
krb5_principal /*client*/, krb5_principal /*client*/,
krb5_principal /*server*/, krb5_principal /*server*/,
krb5_flags /*ap_req_options*/, krb5_flags /*ap_req_options*/,
krb5_data */*in_data*/, krb5_data */*in_data*/,
krb5_creds */*in_creds*/, krb5_creds */*in_creds*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
krb5_error **/*ret_error*/, krb5_error **/*ret_error*/,
krb5_ap_rep_enc_part **/*rep_result*/, krb5_ap_rep_enc_part **/*rep_result*/,
krb5_creds **/*out_creds*/); krb5_creds **/*out_creds*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_sendto ( krb5_sendto (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_data */*send_data*/, const krb5_data */*send_data*/,
krb5_krbhst_handle /*handle*/, krb5_krbhst_handle /*handle*/,
krb5_data */*receive*/); krb5_data */*receive*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_sendto_context ( krb5_sendto_context (
krb5_context /*context*/, krb5_context /*context*/,
krb5_sendto_ctx /*ctx*/, krb5_sendto_ctx /*ctx*/,
const krb5_data */*send_data*/, const krb5_data */*send_data*/,
const krb5_realm /*realm*/, const krb5_realm /*realm*/,
krb5_data */*receive*/); krb5_data */*receive*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_sendto_ctx_add_flags ( krb5_sendto_ctx_add_flags (
krb5_sendto_ctx /*ctx*/, krb5_sendto_ctx /*ctx*/,
int /*flags*/); int /*flags*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_sendto_ctx_alloc ( krb5_sendto_ctx_alloc (
krb5_context /*context*/, krb5_context /*context*/,
krb5_sendto_ctx */*ctx*/); krb5_sendto_ctx */*ctx*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_sendto_ctx_free ( krb5_sendto_ctx_free (
krb5_context /*context*/, krb5_context /*context*/,
krb5_sendto_ctx /*ctx*/); krb5_sendto_ctx /*ctx*/);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
krb5_sendto_ctx_get_flags (krb5_sendto_ctx /*ctx*/); krb5_sendto_ctx_get_flags (krb5_sendto_ctx /*ctx*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_sendto_ctx_set_func ( krb5_sendto_ctx_set_func (
krb5_sendto_ctx /*ctx*/, krb5_sendto_ctx /*ctx*/,
krb5_sendto_ctx_func /*func*/, krb5_sendto_ctx_func /*func*/,
void */*data*/); void */*data*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_sendto_ctx_set_type ( krb5_sendto_ctx_set_type (
krb5_sendto_ctx /*ctx*/, krb5_sendto_ctx /*ctx*/,
int /*type*/); int /*type*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_sendto_kdc ( krb5_sendto_kdc (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_data */*send_data*/, const krb5_data */*send_data*/,
const krb5_realm */*realm*/, const krb5_realm */*realm*/,
krb5_data */*receive*/); krb5_data */*receive*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_sendto_kdc_flags ( krb5_sendto_kdc_flags (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_data */*send_data*/, const krb5_data */*send_data*/,
const krb5_realm */*realm*/, const krb5_realm */*realm*/,
krb5_data */*receive*/, krb5_data */*receive*/,
int /*flags*/); int /*flags*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_set_config_files ( krb5_set_config_files (
krb5_context /*context*/, krb5_context /*context*/,
char **/*filenames*/); char **/*filenames*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_set_default_in_tkt_etypes ( krb5_set_default_in_tkt_etypes (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_enctype */*etypes*/); const krb5_enctype */*etypes*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_set_default_realm ( krb5_set_default_realm (
krb5_context /*context*/, krb5_context /*context*/,
const char */*realm*/); const char */*realm*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_set_dns_canonicalize_hostname ( krb5_set_dns_canonicalize_hostname (
krb5_context /*context*/, krb5_context /*context*/,
krb5_boolean /*flag*/); krb5_boolean /*flag*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_set_error_message ( krb5_set_error_message (
krb5_context /*context*/, krb5_context /*context*/,
krb5_error_code /*ret*/, krb5_error_code /*ret*/,
const char */*fmt*/, const char */*fmt*/,
...) ...)
__attribute__ ((format (printf, 3, 4))); __attribute__ ((format (printf, 3, 4)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_set_error_string ( krb5_set_error_string (
krb5_context /*context*/, krb5_context /*context*/,
const char */*fmt*/, const char */*fmt*/,
...) ...)
__attribute__((format (printf, 2, 3))); __attribute__((format (printf, 2, 3)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_set_extra_addresses ( krb5_set_extra_addresses (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_addresses */*addresses*/); const krb5_addresses */*addresses*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_set_fcache_version ( krb5_set_fcache_version (
krb5_context /*context*/, krb5_context /*context*/,
int /*version*/); int /*version*/);
krb5_boolean krb5_boolean
krb5_set_home_dir_access ( krb5_set_home_dir_access (
krb5_context /*context*/, krb5_context /*context*/,
krb5_boolean /*allow*/); krb5_boolean /*allow*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_set_ignore_addresses ( krb5_set_ignore_addresses (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_addresses */*addresses*/); const krb5_addresses */*addresses*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_set_kdc_sec_offset ( krb5_set_kdc_sec_offset (
krb5_context /*context*/, krb5_context /*context*/,
int32_t /*sec*/, int32_t /*sec*/,
int32_t /*usec*/); int32_t /*usec*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_set_max_time_skew ( krb5_set_max_time_skew (
krb5_context /*context*/, krb5_context /*context*/,
time_t /*t*/); time_t /*t*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_set_password ( krb5_set_password (
krb5_context /*context*/, krb5_context /*context*/,
krb5_creds */*creds*/, krb5_creds */*creds*/,
const char */*newpw*/, const char */*newpw*/,
krb5_principal /*targprinc*/, krb5_principal /*targprinc*/,
int */*result_code*/, int */*result_code*/,
krb5_data */*result_code_string*/, krb5_data */*result_code_string*/,
krb5_data */*result_string*/); krb5_data */*result_string*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_set_password_using_ccache ( krb5_set_password_using_ccache (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
const char */*newpw*/, const char */*newpw*/,
krb5_principal /*targprinc*/, krb5_principal /*targprinc*/,
int */*result_code*/, int */*result_code*/,
krb5_data */*result_code_string*/, krb5_data */*result_code_string*/,
krb5_data */*result_string*/); krb5_data */*result_string*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_set_real_time ( krb5_set_real_time (
krb5_context /*context*/, krb5_context /*context*/,
krb5_timestamp /*sec*/, krb5_timestamp /*sec*/,
int32_t /*usec*/); int32_t /*usec*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_set_send_to_kdc_func ( krb5_set_send_to_kdc_func (
krb5_context /*context*/, krb5_context /*context*/,
krb5_send_to_kdc_func /*func*/, krb5_send_to_kdc_func /*func*/,
void */*data*/); void */*data*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_set_use_admin_kdc ( krb5_set_use_admin_kdc (
krb5_context /*context*/, krb5_context /*context*/,
krb5_boolean /*flag*/); krb5_boolean /*flag*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_set_warn_dest ( krb5_set_warn_dest (
krb5_context /*context*/, krb5_context /*context*/,
krb5_log_facility */*fac*/); krb5_log_facility */*fac*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_sname_to_principal ( krb5_sname_to_principal (
krb5_context /*context*/, krb5_context /*context*/,
const char */*hostname*/, const char */*hostname*/,
const char */*sname*/, const char */*sname*/,
int32_t /*type*/, int32_t /*type*/,
krb5_principal */*ret_princ*/); krb5_principal */*ret_princ*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_sock_to_principal ( krb5_sock_to_principal (
krb5_context /*context*/, krb5_context /*context*/,
int /*sock*/, int /*sock*/,
const char */*sname*/, const char */*sname*/,
int32_t /*type*/, int32_t /*type*/,
krb5_principal */*ret_princ*/); krb5_principal */*ret_princ*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_sockaddr2address ( krb5_sockaddr2address (
krb5_context /*context*/, krb5_context /*context*/,
const struct sockaddr */*sa*/, const struct sockaddr */*sa*/,
krb5_address */*addr*/); krb5_address */*addr*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_sockaddr2port ( krb5_sockaddr2port (
krb5_context /*context*/, krb5_context /*context*/,
const struct sockaddr */*sa*/, const struct sockaddr */*sa*/,
int16_t */*port*/); int16_t */*port*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_sockaddr_uninteresting (const struct sockaddr */*sa*/); krb5_sockaddr_uninteresting (const struct sockaddr */*sa*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_std_usage ( krb5_std_usage (
int /*code*/, int /*code*/,
struct getargs */*args*/, struct getargs */*args*/,
int /*num_args*/); int /*num_args*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_storage_clear_flags ( krb5_storage_clear_flags (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_flags /*flags*/); krb5_flags /*flags*/);
krb5_storage * KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL
krb5_storage_emem (void); krb5_storage_emem (void);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_storage_free (krb5_storage */*sp*/); krb5_storage_free (krb5_storage */*sp*/);
krb5_storage * KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL
krb5_storage_from_data (krb5_data */*data*/); krb5_storage_from_data (krb5_data */*data*/);
krb5_storage * KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL
krb5_storage_from_fd (int /*fd*/); krb5_storage_from_fd (krb5_socket_t /*fd_in*/);
krb5_storage * KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL
krb5_storage_from_mem ( krb5_storage_from_mem (
void */*buf*/, void */*buf*/,
size_t /*len*/); size_t /*len*/);
krb5_storage * KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL
krb5_storage_from_readonly_mem ( krb5_storage_from_readonly_mem (
const void */*buf*/, const void */*buf*/,
size_t /*len*/); size_t /*len*/);
krb5_flags KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_flags KRB5_LIB_CALL
krb5_storage_get_byteorder (krb5_storage */*sp*/); krb5_storage_get_byteorder (krb5_storage */*sp*/);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
krb5_storage_get_eof_code (krb5_storage */*sp*/); krb5_storage_get_eof_code (krb5_storage */*sp*/);
krb5_boolean KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_storage_is_flags ( krb5_storage_is_flags (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_flags /*flags*/); krb5_flags /*flags*/);
krb5_ssize_t KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_ssize_t KRB5_LIB_CALL
krb5_storage_read ( krb5_storage_read (
krb5_storage */*sp*/, krb5_storage */*sp*/,
void */*buf*/, void */*buf*/,
size_t /*len*/); size_t /*len*/);
off_t KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION off_t KRB5_LIB_CALL
krb5_storage_seek ( krb5_storage_seek (
krb5_storage */*sp*/, krb5_storage */*sp*/,
off_t /*offset*/, off_t /*offset*/,
int /*whence*/); int /*whence*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_storage_set_byteorder ( krb5_storage_set_byteorder (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_flags /*byteorder*/); krb5_flags /*byteorder*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_storage_set_eof_code ( krb5_storage_set_eof_code (
krb5_storage */*sp*/, krb5_storage */*sp*/,
int /*code*/); int /*code*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_storage_set_flags ( krb5_storage_set_flags (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_flags /*flags*/); krb5_flags /*flags*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_storage_to_data ( krb5_storage_to_data (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_data */*data*/); krb5_data */*data*/);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
krb5_storage_truncate ( krb5_storage_truncate (
krb5_storage */*sp*/, krb5_storage */*sp*/,
off_t /*offset*/); off_t /*offset*/);
krb5_ssize_t KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_ssize_t KRB5_LIB_CALL
krb5_storage_write ( krb5_storage_write (
krb5_storage */*sp*/, krb5_storage */*sp*/,
const void */*buf*/, const void */*buf*/,
size_t /*len*/); size_t /*len*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_store_address ( krb5_store_address (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_address /*p*/); krb5_address /*p*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_store_addrs ( krb5_store_addrs (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_addresses /*p*/); krb5_addresses /*p*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_store_authdata ( krb5_store_authdata (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_authdata /*auth*/); krb5_authdata /*auth*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_store_creds ( krb5_store_creds (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_creds */*creds*/); krb5_creds */*creds*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_store_creds_tag ( krb5_store_creds_tag (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_creds */*creds*/); krb5_creds */*creds*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_store_data ( krb5_store_data (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_data /*data*/); krb5_data /*data*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_store_int16 ( krb5_store_int16 (
krb5_storage */*sp*/, krb5_storage */*sp*/,
int16_t /*value*/); int16_t /*value*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_store_int32 ( krb5_store_int32 (
krb5_storage */*sp*/, krb5_storage */*sp*/,
int32_t /*value*/); int32_t /*value*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_store_int8 ( krb5_store_int8 (
krb5_storage */*sp*/, krb5_storage */*sp*/,
int8_t /*value*/); int8_t /*value*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_store_keyblock ( krb5_store_keyblock (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_keyblock /*p*/); krb5_keyblock /*p*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_store_principal ( krb5_store_principal (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_const_principal /*p*/); krb5_const_principal /*p*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_store_string ( krb5_store_string (
krb5_storage */*sp*/, krb5_storage */*sp*/,
const char */*s*/); const char */*s*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_store_stringnl ( krb5_store_stringnl (
krb5_storage */*sp*/, krb5_storage */*sp*/,
const char */*s*/); const char */*s*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_store_stringz ( krb5_store_stringz (
krb5_storage */*sp*/, krb5_storage */*sp*/,
const char */*s*/); const char */*s*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_store_times ( krb5_store_times (
krb5_storage */*sp*/, krb5_storage */*sp*/,
krb5_times /*times*/); krb5_times /*times*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_store_uint16 ( krb5_store_uint16 (
krb5_storage */*sp*/, krb5_storage */*sp*/,
uint16_t /*value*/); uint16_t /*value*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_store_uint32 ( krb5_store_uint32 (
krb5_storage */*sp*/, krb5_storage */*sp*/,
uint32_t /*value*/); uint32_t /*value*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_store_uint8 ( krb5_store_uint8 (
krb5_storage */*sp*/, krb5_storage */*sp*/,
uint8_t /*value*/); uint8_t /*value*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_string_to_deltat ( krb5_string_to_deltat (
const char */*string*/, const char */*string*/,
krb5_deltat */*deltat*/); krb5_deltat */*deltat*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_string_to_enctype ( krb5_string_to_enctype (
krb5_context /*context*/, krb5_context /*context*/,
const char */*string*/, const char */*string*/,
krb5_enctype */*etype*/); krb5_enctype */*etype*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_string_to_key ( krb5_string_to_key (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*enctype*/, krb5_enctype /*enctype*/,
const char */*password*/, const char */*password*/,
krb5_principal /*principal*/, krb5_principal /*principal*/,
krb5_keyblock */*key*/); krb5_keyblock */*key*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_string_to_key_data ( krb5_string_to_key_data (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*enctype*/, krb5_enctype /*enctype*/,
krb5_data /*password*/, krb5_data /*password*/,
krb5_principal /*principal*/, krb5_principal /*principal*/,
krb5_keyblock */*key*/); krb5_keyblock */*key*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_string_to_key_data_salt ( krb5_string_to_key_data_salt (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*enctype*/, krb5_enctype /*enctype*/,
krb5_data /*password*/, krb5_data /*password*/,
krb5_salt /*salt*/, krb5_salt /*salt*/,
krb5_keyblock */*key*/); krb5_keyblock */*key*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_string_to_key_data_salt_opaque ( krb5_string_to_key_data_salt_opaque (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*enctype*/, krb5_enctype /*enctype*/,
krb5_data /*password*/, krb5_data /*password*/,
krb5_salt /*salt*/, krb5_salt /*salt*/,
krb5_data /*opaque*/, krb5_data /*opaque*/,
krb5_keyblock */*key*/); krb5_keyblock */*key*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_string_to_key_derived ( krb5_string_to_key_derived (
krb5_context /*context*/, krb5_context /*context*/,
const void */*str*/, const void */*str*/,
size_t /*len*/, size_t /*len*/,
krb5_enctype /*etype*/, krb5_enctype /*etype*/,
krb5_keyblock */*key*/); krb5_keyblock */*key*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_string_to_key_salt ( krb5_string_to_key_salt (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*enctype*/, krb5_enctype /*enctype*/,
const char */*password*/, const char */*password*/,
krb5_salt /*salt*/, krb5_salt /*salt*/,
krb5_keyblock */*key*/); krb5_keyblock */*key*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_string_to_key_salt_opaque ( krb5_string_to_key_salt_opaque (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*enctype*/, krb5_enctype /*enctype*/,
const char */*password*/, const char */*password*/,
krb5_salt /*salt*/, krb5_salt /*salt*/,
krb5_data /*opaque*/, krb5_data /*opaque*/,
krb5_keyblock */*key*/); krb5_keyblock */*key*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_string_to_keytype ( krb5_string_to_keytype (
krb5_context /*context*/, krb5_context /*context*/,
const char */*string*/, const char */*string*/,
krb5_keytype */*keytype*/) krb5_keytype */*keytype*/);
KRB5_DEPRECATED;
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_string_to_salttype ( krb5_string_to_salttype (
krb5_context /*context*/, krb5_context /*context*/,
krb5_enctype /*etype*/, krb5_enctype /*etype*/,
const char */*string*/, const char */*string*/,
krb5_salttype */*salttype*/); krb5_salttype */*salttype*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ticket_get_authorization_data_type ( krb5_ticket_get_authorization_data_type (
krb5_context /*context*/, krb5_context /*context*/,
krb5_ticket */*ticket*/, krb5_ticket */*ticket*/,
int /*type*/, int /*type*/,
krb5_data */*data*/); krb5_data */*data*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ticket_get_client ( krb5_ticket_get_client (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_ticket */*ticket*/, const krb5_ticket */*ticket*/,
krb5_principal */*client*/); krb5_principal */*client*/);
time_t KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION time_t KRB5_LIB_CALL
krb5_ticket_get_endtime ( krb5_ticket_get_endtime (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_ticket */*ticket*/); const krb5_ticket */*ticket*/);
unsigned long unsigned long
krb5_ticket_get_flags ( krb5_ticket_get_flags (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_ticket */*ticket*/); const krb5_ticket */*ticket*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_ticket_get_server ( krb5_ticket_get_server (
krb5_context /*context*/, krb5_context /*context*/,
const krb5_ticket */*ticket*/, const krb5_ticket */*ticket*/,
krb5_principal */*server*/); krb5_principal */*server*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_timeofday ( krb5_timeofday (
krb5_context /*context*/, krb5_context /*context*/,
krb5_timestamp */*timeret*/); krb5_timestamp */*timeret*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_unparse_name ( krb5_unparse_name (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*principal*/, krb5_const_principal /*principal*/,
char **/*name*/); char **/*name*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_unparse_name_fixed ( krb5_unparse_name_fixed (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*principal*/, krb5_const_principal /*principal*/,
char */*name*/, char */*name*/,
size_t /*len*/); size_t /*len*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_unparse_name_fixed_flags ( krb5_unparse_name_fixed_flags (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*principal*/, krb5_const_principal /*principal*/,
int /*flags*/, int /*flags*/,
char */*name*/, char */*name*/,
size_t /*len*/); size_t /*len*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_unparse_name_fixed_short ( krb5_unparse_name_fixed_short (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*principal*/, krb5_const_principal /*principal*/,
char */*name*/, char */*name*/,
size_t /*len*/); size_t /*len*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_unparse_name_flags ( krb5_unparse_name_flags (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*principal*/, krb5_const_principal /*principal*/,
int /*flags*/, int /*flags*/,
char **/*name*/); char **/*name*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_unparse_name_short ( krb5_unparse_name_short (
krb5_context /*context*/, krb5_context /*context*/,
krb5_const_principal /*principal*/, krb5_const_principal /*principal*/,
char **/*name*/); char **/*name*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_us_timeofday ( krb5_us_timeofday (
krb5_context /*context*/, krb5_context /*context*/,
krb5_timestamp */*sec*/, krb5_timestamp */*sec*/,
int32_t */*usec*/); int32_t */*usec*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_vabort ( krb5_vabort (
krb5_context /*context*/, krb5_context /*context*/,
krb5_error_code /*code*/, krb5_error_code /*code*/,
const char */*fmt*/, const char */*fmt*/,
va_list /*ap*/) va_list /*ap*/)
__attribute__ ((noreturn, format (printf, 3, 0))); __attribute__ ((noreturn, format (printf, 3, 0)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_vabortx ( krb5_vabortx (
krb5_context /*context*/, krb5_context /*context*/,
const char */*fmt*/, const char */*fmt*/,
va_list /*ap*/) va_list /*ap*/)
__attribute__ ((noreturn, format (printf, 2, 0))); __attribute__ ((noreturn, format (printf, 2, 0)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_verify_ap_req ( krb5_verify_ap_req (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context */*auth_context*/, krb5_auth_context */*auth_context*/,
krb5_ap_req */*ap_req*/, krb5_ap_req */*ap_req*/,
krb5_const_principal /*server*/, krb5_const_principal /*server*/,
krb5_keyblock */*keyblock*/, krb5_keyblock */*keyblock*/,
krb5_flags /*flags*/, krb5_flags /*flags*/,
krb5_flags */*ap_req_options*/, krb5_flags */*ap_req_options*/,
krb5_ticket **/*ticket*/); krb5_ticket **/*ticket*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_verify_ap_req2 ( krb5_verify_ap_req2 (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context */*auth_context*/, krb5_auth_context */*auth_context*/,
krb5_ap_req */*ap_req*/, krb5_ap_req */*ap_req*/,
krb5_const_principal /*server*/, krb5_const_principal /*server*/,
krb5_keyblock */*keyblock*/, krb5_keyblock */*keyblock*/,
krb5_flags /*flags*/, krb5_flags /*flags*/,
krb5_flags */*ap_req_options*/, krb5_flags */*ap_req_options*/,
krb5_ticket **/*ticket*/, krb5_ticket **/*ticket*/,
krb5_key_usage /*usage*/); krb5_key_usage /*usage*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_verify_authenticator_checksum ( krb5_verify_authenticator_checksum (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*ac*/, krb5_auth_context /*ac*/,
void */*data*/, void */*data*/,
size_t /*len*/); size_t /*len*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_verify_checksum ( krb5_verify_checksum (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
krb5_key_usage /*usage*/, krb5_key_usage /*usage*/,
void */*data*/, void */*data*/,
size_t /*len*/, size_t /*len*/,
Checksum */*cksum*/); Checksum */*cksum*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_verify_checksum_iov ( krb5_verify_checksum_iov (
krb5_context /*context*/, krb5_context /*context*/,
krb5_crypto /*crypto*/, krb5_crypto /*crypto*/,
unsigned /*usage*/, unsigned /*usage*/,
krb5_crypto_iov */*data*/, krb5_crypto_iov */*data*/,
unsigned int /*num_data*/, unsigned int /*num_data*/,
krb5_cksumtype */*type*/); krb5_cksumtype */*type*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_verify_init_creds ( krb5_verify_init_creds (
krb5_context /*context*/, krb5_context /*context*/,
krb5_creds */*creds*/, krb5_creds */*creds*/,
krb5_principal /*ap_req_server*/, krb5_principal /*ap_req_server*/,
krb5_keytab /*ap_req_keytab*/, krb5_keytab /*ap_req_keytab*/,
krb5_ccache */*ccache*/, krb5_ccache */*ccache*/,
krb5_verify_init_creds_opt */*options*/); krb5_verify_init_creds_opt */*options*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_verify_init_creds_opt_init (krb5_verify_init_creds_opt */*options*/); krb5_verify_init_creds_opt_init (krb5_verify_init_creds_opt */*options*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_verify_init_creds_opt_set_ap_req_nofail ( krb5_verify_init_creds_opt_set_ap_req_nofail (
krb5_verify_init_creds_opt */*options*/, krb5_verify_init_creds_opt */*options*/,
int /*ap_req_nofail*/); int /*ap_req_nofail*/);
int KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION int KRB5_LIB_CALL
krb5_verify_opt_alloc ( krb5_verify_opt_alloc (
krb5_context /*context*/, krb5_context /*context*/,
krb5_verify_opt **/*opt*/); krb5_verify_opt **/*opt*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_verify_opt_free (krb5_verify_opt */*opt*/); krb5_verify_opt_free (krb5_verify_opt */*opt*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_verify_opt_init (krb5_verify_opt */*opt*/); krb5_verify_opt_init (krb5_verify_opt */*opt*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_verify_opt_set_ccache ( krb5_verify_opt_set_ccache (
krb5_verify_opt */*opt*/, krb5_verify_opt */*opt*/,
krb5_ccache /*ccache*/); krb5_ccache /*ccache*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_verify_opt_set_flags ( krb5_verify_opt_set_flags (
krb5_verify_opt */*opt*/, krb5_verify_opt */*opt*/,
unsigned int /*flags*/); unsigned int /*flags*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_verify_opt_set_keytab ( krb5_verify_opt_set_keytab (
krb5_verify_opt */*opt*/, krb5_verify_opt */*opt*/,
krb5_keytab /*keytab*/); krb5_keytab /*keytab*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_verify_opt_set_secure ( krb5_verify_opt_set_secure (
krb5_verify_opt */*opt*/, krb5_verify_opt */*opt*/,
krb5_boolean /*secure*/); krb5_boolean /*secure*/);
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_verify_opt_set_service ( krb5_verify_opt_set_service (
krb5_verify_opt */*opt*/, krb5_verify_opt */*opt*/,
const char */*service*/); const char */*service*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_verify_user ( krb5_verify_user (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal /*principal*/, krb5_principal /*principal*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
const char */*password*/, const char */*password*/,
krb5_boolean /*secure*/, krb5_boolean /*secure*/,
const char */*service*/); const char */*service*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_verify_user_lrealm ( krb5_verify_user_lrealm (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal /*principal*/, krb5_principal /*principal*/,
krb5_ccache /*ccache*/, krb5_ccache /*ccache*/,
const char */*password*/, const char */*password*/,
krb5_boolean /*secure*/, krb5_boolean /*secure*/,
const char */*service*/); const char */*service*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_verify_user_opt ( krb5_verify_user_opt (
krb5_context /*context*/, krb5_context /*context*/,
krb5_principal /*principal*/, krb5_principal /*principal*/,
const char */*password*/, const char */*password*/,
krb5_verify_opt */*opt*/); krb5_verify_opt */*opt*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_verr ( krb5_verr (
krb5_context /*context*/, krb5_context /*context*/,
int /*eval*/, int /*eval*/,
krb5_error_code /*code*/, krb5_error_code /*code*/,
const char */*fmt*/, const char */*fmt*/,
va_list /*ap*/) va_list /*ap*/)
__attribute__ ((noreturn, format (printf, 4, 0))); __attribute__ ((noreturn, format (printf, 4, 0)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_verrx ( krb5_verrx (
krb5_context /*context*/, krb5_context /*context*/,
int /*eval*/, int /*eval*/,
const char */*fmt*/, const char */*fmt*/,
va_list /*ap*/) va_list /*ap*/)
__attribute__ ((noreturn, format (printf, 3, 0))); __attribute__ ((noreturn, format (printf, 3, 0)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_vlog ( krb5_vlog (
krb5_context /*context*/, krb5_context /*context*/,
krb5_log_facility */*fac*/, krb5_log_facility */*fac*/,
int /*level*/, int /*level*/,
const char */*fmt*/, const char */*fmt*/,
va_list /*ap*/) va_list /*ap*/)
__attribute__((format (printf, 4, 0))); __attribute__((format (printf, 4, 0)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_vlog_msg ( krb5_vlog_msg (
krb5_context /*context*/, krb5_context /*context*/,
krb5_log_facility */*fac*/, krb5_log_facility */*fac*/,
char **/*reply*/, char **/*reply*/,
int /*level*/, int /*level*/,
const char */*fmt*/, const char */*fmt*/,
va_list /*ap*/) va_list /*ap*/)
__attribute__((format (printf, 5, 0))); __attribute__((format (printf, 5, 0)));
void KRB5_LIB_FUNCTION void KRB5_LIB_FUNCTION
krb5_vprepend_error_message ( krb5_vprepend_error_message (
krb5_context /*context*/, krb5_context /*context*/,
krb5_error_code /*ret*/, krb5_error_code /*ret*/,
const char */*fmt*/, const char */*fmt*/,
va_list /*args*/) va_list /*args*/)
__attribute__ ((format (printf, 3, 0))); __attribute__ ((format (printf, 3, 0)));
void KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_vset_error_message ( krb5_vset_error_message (
krb5_context /*context*/, krb5_context /*context*/,
krb5_error_code /*ret*/, krb5_error_code /*ret*/,
const char */*fmt*/, const char */*fmt*/,
va_list /*args*/) va_list /*args*/)
__attribute__ ((format (printf, 3, 0))); __attribute__ ((format (printf, 3, 0)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_DEPRECATED KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_vset_error_string ( krb5_vset_error_string (
krb5_context /*context*/, krb5_context /*context*/,
const char */*fmt*/, const char */*fmt*/,
va_list /*args*/) va_list /*args*/)
__attribute__ ((format (printf, 2, 0))); __attribute__ ((format (printf, 2, 0)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_vwarn ( krb5_vwarn (
krb5_context /*context*/, krb5_context /*context*/,
krb5_error_code /*code*/, krb5_error_code /*code*/,
const char */*fmt*/, const char */*fmt*/,
va_list /*ap*/) va_list /*ap*/)
__attribute__ ((format (printf, 3, 0))); __attribute__ ((format (printf, 3, 0)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_vwarnx ( krb5_vwarnx (
krb5_context /*context*/, krb5_context /*context*/,
const char */*fmt*/, const char */*fmt*/,
va_list /*ap*/) va_list /*ap*/)
__attribute__ ((format (printf, 2, 0))); __attribute__ ((format (printf, 2, 0)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_warn ( krb5_warn (
krb5_context /*context*/, krb5_context /*context*/,
krb5_error_code /*code*/, krb5_error_code /*code*/,
const char */*fmt*/, const char */*fmt*/,
...) ...)
__attribute__ ((format (printf, 3, 4))); __attribute__ ((format (printf, 3, 4)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_warnx ( krb5_warnx (
krb5_context /*context*/, krb5_context /*context*/,
const char */*fmt*/, const char */*fmt*/,
...) ...)
__attribute__ ((format (printf, 2, 3))); __attribute__ ((format (printf, 2, 3)));
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_write_message ( krb5_write_message (
krb5_context /*context*/, krb5_context /*context*/,
krb5_pointer /*p_fd*/, krb5_pointer /*p_fd*/,
krb5_data */*data*/); krb5_data */*data*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_write_priv_message ( krb5_write_priv_message (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*ac*/, krb5_auth_context /*ac*/,
krb5_pointer /*p_fd*/, krb5_pointer /*p_fd*/,
krb5_data */*data*/); krb5_data */*data*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_write_safe_message ( krb5_write_safe_message (
krb5_context /*context*/, krb5_context /*context*/,
krb5_auth_context /*ac*/, krb5_auth_context /*ac*/,
krb5_pointer /*p_fd*/, krb5_pointer /*p_fd*/,
krb5_data */*data*/); krb5_data */*data*/);
krb5_error_code KRB5_LIB_FUNCTION KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_xfree (void */*ptr*/); krb5_xfree (void */*ptr*/);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* __krb5_protos_h__ */ #endif /* __krb5_protos_h__ */
 End of changes. 672 change blocks. 
721 lines changed or deleted 718 lines changed or added


 krb5-types.h   krb5-types.h 
skipping to change at line 16 skipping to change at line 16
#include <inttypes.h> #include <inttypes.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/bitypes.h> #include <sys/bitypes.h>
#include <sys/socket.h> #include <sys/socket.h>
typedef socklen_t krb5_socklen_t; typedef socklen_t krb5_socklen_t;
#include <unistd.h> #include <unistd.h>
typedef ssize_t krb5_ssize_t; typedef ssize_t krb5_ssize_t;
typedef int krb5_socket_t;
#endif /* __krb5_types_h__ */ #endif /* __krb5_types_h__ */
 End of changes. 1 change blocks. 
0 lines changed or deleted 2 lines changed or added


 krb5.h   krb5.h 
/* /*
* Copyright (c) 1997 - 2007 Kungliga Tekniska Högskolan * Copyright (c) 1997 - 2007 Kungliga Tekniska Högskolan
* (Royal Institute of Technology, Stockholm, Sweden). * (Royal Institute of Technology, Stockholm, Sweden).
* All rights reserved. * All rights reserved.
* *
* Portions Copyright (c) 2009 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions * modification, are permitted provided that the following conditions
* are met: * are met:
* *
* 1. Redistributions of source code must retain the above copyright * 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer. * notice, this list of conditions and the following disclaimer.
* *
* 2. Redistributions in binary form must reproduce the above copyright * 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the * notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution. * documentation and/or other materials provided with the distribution.
skipping to change at line 64 skipping to change at line 66
#ifndef KRB5_DEPRECATED #ifndef KRB5_DEPRECATED
#if defined(__GNUC__) && ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MIN OR__ >= 1 ))) #if defined(__GNUC__) && ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MIN OR__ >= 1 )))
#define KRB5_DEPRECATED __attribute__((deprecated)) #define KRB5_DEPRECATED __attribute__((deprecated))
#elif defined(_MSC_VER) && (_MSC_VER>1200) #elif defined(_MSC_VER) && (_MSC_VER>1200)
#define KRB5_DEPRECATED __declspec(deprecated) #define KRB5_DEPRECATED __declspec(deprecated)
#else #else
#define KRB5_DEPRECATED #define KRB5_DEPRECATED
#endif #endif
#endif #endif
#ifdef _WIN32
#define KRB5_CALLCONV __stdcall
#else
#define KRB5_CALLCONV
#endif
/* simple constants */ /* simple constants */
#ifndef TRUE #ifndef TRUE
#define TRUE 1 #define TRUE 1
#define FALSE 0 #define FALSE 0
#endif #endif
typedef int krb5_boolean; typedef int krb5_boolean;
typedef int32_t krb5_error_code; typedef int32_t krb5_error_code;
skipping to change at line 304 skipping to change at line 312
KEYTYPE_ARCFOUR = ETYPE_ARCFOUR_HMAC_MD5, KEYTYPE_ARCFOUR = ETYPE_ARCFOUR_HMAC_MD5,
KEYTYPE_ARCFOUR_56 = ETYPE_ARCFOUR_HMAC_MD5_56 KEYTYPE_ARCFOUR_56 = ETYPE_ARCFOUR_HMAC_MD5_56
} krb5_keytype; } krb5_keytype;
typedef EncryptionKey krb5_keyblock; typedef EncryptionKey krb5_keyblock;
typedef AP_REQ krb5_ap_req; typedef AP_REQ krb5_ap_req;
struct krb5_cc_ops; struct krb5_cc_ops;
#ifdef _WIN32
#define KRB5_USE_PATH_TOKENS 1
#endif
#ifdef KRB5_USE_PATH_TOKENS
#define KRB5_DEFAULT_CCFILE_ROOT "%{TEMP}/krb5cc_"
#else
#define KRB5_DEFAULT_CCFILE_ROOT "/tmp/krb5cc_" #define KRB5_DEFAULT_CCFILE_ROOT "/tmp/krb5cc_"
#endif
#define KRB5_DEFAULT_CCROOT "FILE:" KRB5_DEFAULT_CCFILE_ROOT #define KRB5_DEFAULT_CCROOT "FILE:" KRB5_DEFAULT_CCFILE_ROOT
#define KRB5_ACCEPT_NULL_ADDRESSES(C) \ #define KRB5_ACCEPT_NULL_ADDRESSES(C) \
krb5_config_get_bool_default((C), NULL, TRUE, \ krb5_config_get_bool_default((C), NULL, TRUE, \
"libdefaults", "accept_null_addresses", \ "libdefaults", "accept_null_addresses", \
NULL) NULL)
typedef void *krb5_cc_cursor; typedef void *krb5_cc_cursor;
typedef struct krb5_cccol_cursor_data *krb5_cccol_cursor; typedef struct krb5_cccol_cursor_data *krb5_cccol_cursor;
skipping to change at line 415 skipping to change at line 431
krb5_times times; krb5_times times;
krb5_data ticket; krb5_data ticket;
krb5_data second_ticket; krb5_data second_ticket;
krb5_authdata authdata; krb5_authdata authdata;
krb5_addresses addresses; krb5_addresses addresses;
krb5_ticket_flags flags; krb5_ticket_flags flags;
} krb5_creds; } krb5_creds;
typedef struct krb5_cc_cache_cursor_data *krb5_cc_cache_cursor; typedef struct krb5_cc_cache_cursor_data *krb5_cc_cache_cursor;
#define KRB5_CC_OPS_VERSION 2 #define KRB5_CC_OPS_VERSION 3
typedef struct krb5_cc_ops { typedef struct krb5_cc_ops {
int version; int version;
const char *prefix; const char *prefix;
const char* (*get_name)(krb5_context, krb5_ccache); const char* (KRB5_CALLCONV * get_name)(krb5_context, krb5_ccache);
krb5_error_code (*resolve)(krb5_context, krb5_ccache *, const char *); krb5_error_code (KRB5_CALLCONV * resolve)(krb5_context, krb5_ccache *,
krb5_error_code (*gen_new)(krb5_context, krb5_ccache *); const char *);
krb5_error_code (*init)(krb5_context, krb5_ccache, krb5_principal); krb5_error_code (KRB5_CALLCONV * gen_new)(krb5_context, krb5_ccache *);
krb5_error_code (*destroy)(krb5_context, krb5_ccache); krb5_error_code (KRB5_CALLCONV * init)(krb5_context, krb5_ccache, krb5_
krb5_error_code (*close)(krb5_context, krb5_ccache); principal);
krb5_error_code (*store)(krb5_context, krb5_ccache, krb5_creds*); krb5_error_code (KRB5_CALLCONV * destroy)(krb5_context, krb5_ccache);
krb5_error_code (*retrieve)(krb5_context, krb5_ccache, krb5_error_code (KRB5_CALLCONV * close)(krb5_context, krb5_ccache);
krb5_flags, const krb5_creds*, krb5_creds *) krb5_error_code (KRB5_CALLCONV * store)(krb5_context, krb5_ccache, krb5
; _creds*);
krb5_error_code (*get_princ)(krb5_context, krb5_ccache, krb5_principal* krb5_error_code (KRB5_CALLCONV * retrieve)(krb5_context, krb5_ccache,
); krb5_flags, const krb5_creds*
krb5_error_code (*get_first)(krb5_context, krb5_ccache, krb5_cc_cursor , krb5_creds *);
*); krb5_error_code (KRB5_CALLCONV * get_princ)(krb5_context, krb5_ccache,
krb5_error_code (*get_next)(krb5_context, krb5_ccache, krb5_principal*);
krb5_cc_cursor*, krb5_creds*); krb5_error_code (KRB5_CALLCONV * get_first)(krb5_context, krb5_ccache,
krb5_error_code (*end_get)(krb5_context, krb5_ccache, krb5_cc_cursor*); krb5_cc_cursor *);
krb5_error_code (*remove_cred)(krb5_context, krb5_ccache, krb5_error_code (KRB5_CALLCONV * get_next)(krb5_context, krb5_ccache,
krb5_flags, krb5_creds*); krb5_cc_cursor*, krb5_creds*)
krb5_error_code (*set_flags)(krb5_context, krb5_ccache, krb5_flags); ;
int (*get_version)(krb5_context, krb5_ccache); krb5_error_code (KRB5_CALLCONV * end_get)(krb5_context, krb5_ccache, kr
krb5_error_code (*get_cache_first)(krb5_context, krb5_cc_cursor *); b5_cc_cursor*);
krb5_error_code (*get_cache_next)(krb5_context, krb5_cc_cursor, krb5_cc krb5_error_code (KRB5_CALLCONV * remove_cred)(krb5_context, krb5_ccache
ache *); ,
krb5_error_code (*end_cache_get)(krb5_context, krb5_cc_cursor); krb5_flags, krb5_creds*);
krb5_error_code (*move)(krb5_context, krb5_ccache, krb5_ccache); krb5_error_code (KRB5_CALLCONV * set_flags)(krb5_context, krb5_ccache,
krb5_error_code (*get_default_name)(krb5_context, char **); krb5_flags);
krb5_error_code (*set_default)(krb5_context, krb5_ccache); int (KRB5_CALLCONV * get_version)(krb5_context, krb5_ccache);
krb5_error_code (*lastchange)(krb5_context, krb5_ccache, krb5_timestamp krb5_error_code (KRB5_CALLCONV * get_cache_first)(krb5_context, krb5_cc
*); _cursor *);
krb5_error_code (KRB5_CALLCONV * get_cache_next)(krb5_context, krb5_cc_
cursor,
krb5_ccache *);
krb5_error_code (KRB5_CALLCONV * end_cache_get)(krb5_context, krb5_cc_c
ursor);
krb5_error_code (KRB5_CALLCONV * move)(krb5_context, krb5_ccache, krb5_
ccache);
krb5_error_code (KRB5_CALLCONV * get_default_name)(krb5_context, char *
*);
krb5_error_code (KRB5_CALLCONV * set_default)(krb5_context, krb5_ccache
);
krb5_error_code (KRB5_CALLCONV * lastchange)(krb5_context, krb5_ccache,
krb5_timestamp *);
krb5_error_code (KRB5_CALLCONV * set_kdc_offset)(krb5_context, krb5_cca
che, krb5_deltat);
krb5_error_code (KRB5_CALLCONV * get_kdc_offset)(krb5_context, krb5_cca
che, krb5_deltat *);
} krb5_cc_ops; } krb5_cc_ops;
struct krb5_log_facility; struct krb5_log_facility;
struct krb5_config_binding { struct krb5_config_binding {
enum { krb5_config_string, krb5_config_list } type; enum { krb5_config_string, krb5_config_list } type;
char *name; char *name;
struct krb5_config_binding *next; struct krb5_config_binding *next;
union { union {
char *string; char *string;
skipping to change at line 514 skipping to change at line 533
} krb5_kt_cursor; } krb5_kt_cursor;
struct krb5_keytab_data; struct krb5_keytab_data;
typedef struct krb5_keytab_data *krb5_keytab; typedef struct krb5_keytab_data *krb5_keytab;
#define KRB5_KT_PREFIX_MAX_LEN 30 #define KRB5_KT_PREFIX_MAX_LEN 30
struct krb5_keytab_data { struct krb5_keytab_data {
const char *prefix; const char *prefix;
krb5_error_code (*resolve)(krb5_context, const char*, krb5_keytab); krb5_error_code (KRB5_CALLCONV * resolve)(krb5_context, const char*, kr
krb5_error_code (*get_name)(krb5_context, krb5_keytab, char*, size_t); b5_keytab);
krb5_error_code (*close)(krb5_context, krb5_keytab); krb5_error_code (KRB5_CALLCONV * get_name)(krb5_context, krb5_keytab, c
krb5_error_code (*destroy)(krb5_context, krb5_keytab); har*, size_t);
krb5_error_code (*get)(krb5_context, krb5_keytab, krb5_const_principal, krb5_error_code (KRB5_CALLCONV * close)(krb5_context, krb5_keytab);
krb5_kvno, krb5_enctype, krb5_keytab_entry*); krb5_error_code (KRB5_CALLCONV * destroy)(krb5_context, krb5_keytab);
krb5_error_code (*start_seq_get)(krb5_context, krb5_keytab, krb5_kt_cur krb5_error_code (KRB5_CALLCONV * get)(krb5_context, krb5_keytab, krb5_c
sor*); onst_principal,
krb5_error_code (*next_entry)(krb5_context, krb5_keytab, krb5_kvno, krb5_enctype, krb5_keyt
krb5_keytab_entry*, krb5_kt_cursor*); ab_entry*);
krb5_error_code (*end_seq_get)(krb5_context, krb5_keytab, krb5_kt_curso krb5_error_code (KRB5_CALLCONV * start_seq_get)(krb5_context, krb5_keyt
r*); ab, krb5_kt_cursor*);
krb5_error_code (*add)(krb5_context, krb5_keytab, krb5_keytab_entry*); krb5_error_code (KRB5_CALLCONV * next_entry)(krb5_context, krb5_keytab,
krb5_error_code (*remove)(krb5_context, krb5_keytab, krb5_keytab_entry* krb5_keytab_entry*, krb5_kt
); _cursor*);
krb5_error_code (KRB5_CALLCONV * end_seq_get)(krb5_context, krb5_keytab
, krb5_kt_cursor*);
krb5_error_code (KRB5_CALLCONV * add)(krb5_context, krb5_keytab, krb5_k
eytab_entry*);
krb5_error_code (KRB5_CALLCONV * remove)(krb5_context, krb5_keytab, krb
5_keytab_entry*);
void *data; void *data;
int32_t version; int32_t version;
}; };
typedef struct krb5_keytab_data krb5_kt_ops; typedef struct krb5_keytab_data krb5_kt_ops;
struct krb5_keytab_key_proc_args { struct krb5_keytab_key_proc_args {
krb5_keytab keytab; krb5_keytab keytab;
krb5_principal principal; krb5_principal principal;
}; };
skipping to change at line 597 skipping to change at line 616
}krb5_auth_context_data, *krb5_auth_context; }krb5_auth_context_data, *krb5_auth_context;
typedef struct { typedef struct {
KDC_REP kdc_rep; KDC_REP kdc_rep;
EncKDCRepPart enc_part; EncKDCRepPart enc_part;
KRB_ERROR error; KRB_ERROR error;
} krb5_kdc_rep; } krb5_kdc_rep;
extern const char *heimdal_version, *heimdal_long_version; extern const char *heimdal_version, *heimdal_long_version;
typedef void (*krb5_log_log_func_t)(const char*, const char*, void*); typedef void (KRB5_CALLCONV * krb5_log_log_func_t)(const char*, const char*
typedef void (*krb5_log_close_func_t)(void*); , void*);
typedef void (KRB5_CALLCONV * krb5_log_close_func_t)(void*);
typedef struct krb5_log_facility { typedef struct krb5_log_facility {
char *program; char *program;
int len; int len;
struct facility *val; struct facility *val;
} krb5_log_facility; } krb5_log_facility;
typedef EncAPRepPart krb5_ap_rep_enc_part; typedef EncAPRepPart krb5_ap_rep_enc_part;
#define KRB5_RECVAUTH_IGNORE_VERSION 1 #define KRB5_RECVAUTH_IGNORE_VERSION 1
skipping to change at line 633 skipping to change at line 652
KRB5_PROMPT_TYPE_INFO = 0x5 KRB5_PROMPT_TYPE_INFO = 0x5
} krb5_prompt_type; } krb5_prompt_type;
typedef struct _krb5_prompt { typedef struct _krb5_prompt {
const char *prompt; const char *prompt;
int hidden; int hidden;
krb5_data *reply; krb5_data *reply;
krb5_prompt_type type; krb5_prompt_type type;
} krb5_prompt; } krb5_prompt;
typedef int (*krb5_prompter_fct)(krb5_context /*context*/, typedef int (KRB5_CALLCONV * krb5_prompter_fct)(krb5_context /*context*/,
void * /*data*/, void * /*data*/,
const char * /*name*/, const char * /*name*/,
const char * /*banner*/, const char * /*banner*/,
int /*num_prompts*/, int /*num_prompts*/,
krb5_prompt /*prompts*/[]); krb5_prompt /*prompts*/[]);
typedef krb5_error_code (*krb5_key_proc)(krb5_context /*context*/, typedef krb5_error_code (KRB5_CALLCONV * krb5_key_proc)(krb5_context /*cont
krb5_enctype /*type*/, ext*/,
krb5_salt /*salt*/, krb5_enctype /*type*
krb5_const_pointer /*keyseed*/, /,
krb5_keyblock ** /*key*/); krb5_salt /*salt*/,
typedef krb5_error_code (*krb5_decrypt_proc)(krb5_context /*context*/, krb5_const_pointer /
krb5_keyblock * /*key*/, *keyseed*/,
krb5_key_usage /*usage*/, krb5_keyblock ** /*k
krb5_const_pointer /*decrypt_ar ey*/);
g*/, typedef krb5_error_code (KRB5_CALLCONV * krb5_decrypt_proc)(krb5_context /*
krb5_kdc_rep * /*dec_rep*/); context*/,
typedef krb5_error_code (*krb5_s2k_proc)(krb5_context /*context*/, krb5_keyblock *
krb5_enctype /*type*/, /*key*/,
krb5_const_pointer /*keyseed*/, krb5_key_usage /
krb5_salt /*salt*/, *usage*/,
krb5_data * /*s2kparms*/, krb5_const_point
krb5_keyblock ** /*key*/); er /*decrypt_arg*/,
krb5_kdc_rep * /
*dec_rep*/);
typedef krb5_error_code (KRB5_CALLCONV * krb5_s2k_proc)(krb5_context /*cont
ext*/,
krb5_enctype /*type*
/,
krb5_const_pointer /
*keyseed*/,
krb5_salt /*salt*/,
krb5_data * /*s2kpar
ms*/,
krb5_keyblock ** /*k
ey*/);
struct _krb5_get_init_creds_opt_private; struct _krb5_get_init_creds_opt_private;
struct _krb5_get_init_creds_opt { struct _krb5_get_init_creds_opt {
krb5_flags flags; krb5_flags flags;
krb5_deltat tkt_life; krb5_deltat tkt_life;
krb5_deltat renew_life; krb5_deltat renew_life;
int forwardable; int forwardable;
int proxiable; int proxiable;
int anonymous; int anonymous;
skipping to change at line 689 skipping to change at line 708
#define KRB5_GET_INIT_CREDS_OPT_RENEW_LIFE 0x0002 #define KRB5_GET_INIT_CREDS_OPT_RENEW_LIFE 0x0002
#define KRB5_GET_INIT_CREDS_OPT_FORWARDABLE 0x0004 #define KRB5_GET_INIT_CREDS_OPT_FORWARDABLE 0x0004
#define KRB5_GET_INIT_CREDS_OPT_PROXIABLE 0x0008 #define KRB5_GET_INIT_CREDS_OPT_PROXIABLE 0x0008
#define KRB5_GET_INIT_CREDS_OPT_ETYPE_LIST 0x0010 #define KRB5_GET_INIT_CREDS_OPT_ETYPE_LIST 0x0010
#define KRB5_GET_INIT_CREDS_OPT_ADDRESS_LIST 0x0020 #define KRB5_GET_INIT_CREDS_OPT_ADDRESS_LIST 0x0020
#define KRB5_GET_INIT_CREDS_OPT_PREAUTH_LIST 0x0040 #define KRB5_GET_INIT_CREDS_OPT_PREAUTH_LIST 0x0040
#define KRB5_GET_INIT_CREDS_OPT_SALT 0x0080 /* no supported */ #define KRB5_GET_INIT_CREDS_OPT_SALT 0x0080 /* no supported */
#define KRB5_GET_INIT_CREDS_OPT_ANONYMOUS 0x0100 #define KRB5_GET_INIT_CREDS_OPT_ANONYMOUS 0x0100
#define KRB5_GET_INIT_CREDS_OPT_DISABLE_TRANSITED_CHECK 0x0200 #define KRB5_GET_INIT_CREDS_OPT_DISABLE_TRANSITED_CHECK 0x0200
/* krb5_init_creds_step flags argument */
#define KRB5_INIT_CREDS_STEP_FLAG_CONTINUE 0x0001
typedef struct _krb5_verify_init_creds_opt { typedef struct _krb5_verify_init_creds_opt {
krb5_flags flags; krb5_flags flags;
int ap_req_nofail; int ap_req_nofail;
} krb5_verify_init_creds_opt; } krb5_verify_init_creds_opt;
#define KRB5_VERIFY_INIT_CREDS_OPT_AP_REQ_NOFAIL 0x0001 #define KRB5_VERIFY_INIT_CREDS_OPT_AP_REQ_NOFAIL 0x0001
typedef struct krb5_verify_opt { typedef struct krb5_verify_opt {
unsigned int flags; unsigned int flags;
krb5_ccache ccache; krb5_ccache ccache;
skipping to change at line 748 skipping to change at line 770
struct krb5_krbhst_info *next; struct krb5_krbhst_info *next;
char hostname[1]; /* has to come last */ char hostname[1]; /* has to come last */
} krb5_krbhst_info; } krb5_krbhst_info;
/* flags for krb5_krbhst_init_flags (and krb5_send_to_kdc_flags) */ /* flags for krb5_krbhst_init_flags (and krb5_send_to_kdc_flags) */
enum { enum {
KRB5_KRBHST_FLAGS_MASTER = 1, KRB5_KRBHST_FLAGS_MASTER = 1,
KRB5_KRBHST_FLAGS_LARGE_MSG = 2 KRB5_KRBHST_FLAGS_LARGE_MSG = 2
}; };
typedef krb5_error_code (*krb5_send_to_kdc_func)(krb5_context, typedef krb5_error_code
void *, (KRB5_CALLCONV * krb5_send_to_kdc_func)(krb5_context, void *, krb5_krbhst_i
krb5_krbhst_info *, nfo *, time_t,
time_t, const krb5_data *, krb5_data *);
const krb5_data *,
krb5_data *);
/** flags for krb5_parse_name_flags */ /** flags for krb5_parse_name_flags */
enum { enum {
KRB5_PRINCIPAL_PARSE_NO_REALM = 1, /**< Require that there are no realm */ KRB5_PRINCIPAL_PARSE_NO_REALM = 1, /**< Require that there are no realm */
KRB5_PRINCIPAL_PARSE_REQUIRE_REALM = 2, /**< Require a realm present */ KRB5_PRINCIPAL_PARSE_REQUIRE_REALM = 2, /**< Require a realm present */
KRB5_PRINCIPAL_PARSE_ENTERPRISE = 4 /**< Parse as a NT-ENTERPRISE name */ KRB5_PRINCIPAL_PARSE_ENTERPRISE = 4 /**< Parse as a NT-ENTERPRISE name */
}; };
/** flags for krb5_unparse_name_flags */ /** flags for krb5_unparse_name_flags */
enum { enum {
skipping to change at line 775 skipping to change at line 794
KRB5_PRINCIPAL_UNPARSE_NO_REALM = 2, /**< No realm */ KRB5_PRINCIPAL_UNPARSE_NO_REALM = 2, /**< No realm */
KRB5_PRINCIPAL_UNPARSE_DISPLAY = 4 /**< No quoting */ KRB5_PRINCIPAL_UNPARSE_DISPLAY = 4 /**< No quoting */
}; };
typedef struct krb5_sendto_ctx_data *krb5_sendto_ctx; typedef struct krb5_sendto_ctx_data *krb5_sendto_ctx;
#define KRB5_SENDTO_DONE 0 #define KRB5_SENDTO_DONE 0
#define KRB5_SENDTO_RESTART 1 #define KRB5_SENDTO_RESTART 1
#define KRB5_SENDTO_CONTINUE 2 #define KRB5_SENDTO_CONTINUE 2
typedef krb5_error_code (*krb5_sendto_ctx_func)(krb5_context, krb5_sendto_c typedef krb5_error_code
tx, void *, const krb5_data *, int *); (KRB5_CALLCONV * krb5_sendto_ctx_func)(krb5_context, krb5_sendto_ctx, void
*,
const krb5_data *, int *);
struct krb5_plugin; struct krb5_plugin;
enum krb5_plugin_type { enum krb5_plugin_type {
PLUGIN_TYPE_DATA = 1, PLUGIN_TYPE_DATA = 1,
PLUGIN_TYPE_FUNC PLUGIN_TYPE_FUNC
}; };
struct credentials; /* this is to keep the compiler happy */ struct credentials; /* this is to keep the compiler happy */
struct getargs; struct getargs;
struct sockaddr; struct sockaddr;
skipping to change at line 818 skipping to change at line 839
} krb5_crypto_iov; } krb5_crypto_iov;
/* Glue for MIT */ /* Glue for MIT */
typedef struct { typedef struct {
int32_t lr_type; int32_t lr_type;
krb5_timestamp value; krb5_timestamp value;
} krb5_last_req_entry; } krb5_last_req_entry;
typedef krb5_error_code typedef krb5_error_code
(*krb5_gic_process_last_req)(krb5_context, krb5_last_req_entry **, void *); (KRB5_CALLCONV * krb5_gic_process_last_req)(krb5_context, krb5_last_req_ent ry **, void *);
/* /*
* *
*/ */
#include <krb5-protos.h> #include <krb5-protos.h>
/* variables */ /* variables */
extern KRB5_LIB_VARIABLE const char *krb5_config_file; extern KRB5_LIB_VARIABLE const char *krb5_config_file;
extern KRB5_LIB_VARIABLE const char *krb5_defkeyname; extern KRB5_LIB_VARIABLE const char *krb5_defkeyname;
extern KRB5_LIB_VARIABLE const krb5_cc_ops krb5_acc_ops; extern KRB5_LIB_VARIABLE const krb5_cc_ops krb5_acc_ops;
extern KRB5_LIB_VARIABLE const krb5_cc_ops krb5_fcc_ops; extern KRB5_LIB_VARIABLE const krb5_cc_ops krb5_fcc_ops;
extern KRB5_LIB_VARIABLE const krb5_cc_ops krb5_mcc_ops; extern KRB5_LIB_VARIABLE const krb5_cc_ops krb5_mcc_ops;
extern KRB5_LIB_VARIABLE const krb5_cc_ops krb5_kcm_ops; extern KRB5_LIB_VARIABLE const krb5_cc_ops krb5_kcm_ops;
extern KRB5_LIB_VARIABLE const krb5_cc_ops krb5_akcm_ops;
extern KRB5_LIB_VARIABLE const krb5_cc_ops krb5_scc_ops; extern KRB5_LIB_VARIABLE const krb5_cc_ops krb5_scc_ops;
extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_fkt_ops; extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_fkt_ops;
extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_wrfkt_ops; extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_wrfkt_ops;
extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_javakt_ops; extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_javakt_ops;
extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_mkt_ops; extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_mkt_ops;
extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_akf_ops; extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_akf_ops;
extern KRB5_LIB_VARIABLE const krb5_kt_ops krb4_fkt_ops;
extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_srvtab_fkt_ops;
extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_any_ops; extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_any_ops;
extern KRB5_LIB_VARIABLE const char *krb5_cc_type_api; extern KRB5_LIB_VARIABLE const char *krb5_cc_type_api;
extern KRB5_LIB_VARIABLE const char *krb5_cc_type_file; extern KRB5_LIB_VARIABLE const char *krb5_cc_type_file;
extern KRB5_LIB_VARIABLE const char *krb5_cc_type_memory; extern KRB5_LIB_VARIABLE const char *krb5_cc_type_memory;
extern KRB5_LIB_VARIABLE const char *krb5_cc_type_kcm; extern KRB5_LIB_VARIABLE const char *krb5_cc_type_kcm;
extern KRB5_LIB_VARIABLE const char *krb5_cc_type_scc; extern KRB5_LIB_VARIABLE const char *krb5_cc_type_scc;
#endif /* __KRB5_H__ */ #endif /* __KRB5_H__ */
 End of changes. 15 change blocks. 
82 lines changed or deleted 137 lines changed or added


 krb5_asn1.h   krb5_asn1.h 
skipping to change at line 28 skipping to change at line 28
typedef struct heim_octet_string { typedef struct heim_octet_string {
size_t length; size_t length;
void *data; void *data;
} heim_octet_string; } heim_octet_string;
typedef char *heim_general_string; typedef char *heim_general_string;
typedef char *heim_utf8_string; typedef char *heim_utf8_string;
typedef char *heim_printable_string; typedef struct heim_octet_string heim_printable_string;
typedef char *heim_ia5_string; typedef struct heim_octet_string heim_ia5_string;
typedef struct heim_bmp_string { typedef struct heim_bmp_string {
size_t length; size_t length;
uint16_t *data; uint16_t *data;
} heim_bmp_string; } heim_bmp_string;
typedef struct heim_universal_string { typedef struct heim_universal_string {
size_t length; size_t length;
uint32_t *data; uint32_t *data;
} heim_universal_string; } heim_universal_string;
skipping to change at line 73 skipping to change at line 73
} else { \ } else { \
(R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
(S), (L)); \ (S), (L)); \
if((R) != 0) { \ if((R) != 0) { \
free((B)); \ free((B)); \
(B) = NULL; \ (B) = NULL; \
} \ } \
} \ } \
} while (0) } while (0)
#ifdef _WIN32
#ifndef ASN1_LIB
#define ASN1EXP __declspec(dllimport)
#else
#define ASN1EXP
#endif
#define ASN1CALL __stdcall
#else
#define ASN1EXP
#define ASN1CALL
#endif
struct units; struct units;
#endif #endif
/* /*
NAME-TYPE ::= INTEGER { NAME-TYPE ::= INTEGER {
KRB5_NT_UNKNOWN(0), KRB5_NT_UNKNOWN(0),
KRB5_NT_PRINCIPAL(1), KRB5_NT_PRINCIPAL(1),
KRB5_NT_SRV_INST(2), KRB5_NT_SRV_INST(2),
KRB5_NT_SRV_HST(3), KRB5_NT_SRV_HST(3),
skipping to change at line 113 skipping to change at line 124
KRB5_NT_X500_PRINCIPAL = 6, KRB5_NT_X500_PRINCIPAL = 6,
KRB5_NT_SMTP_NAME = 7, KRB5_NT_SMTP_NAME = 7,
KRB5_NT_ENTERPRISE_PRINCIPAL = 10, KRB5_NT_ENTERPRISE_PRINCIPAL = 10,
KRB5_NT_WELLKNOWN = 11, KRB5_NT_WELLKNOWN = 11,
KRB5_NT_ENT_PRINCIPAL_AND_ID = -130, KRB5_NT_ENT_PRINCIPAL_AND_ID = -130,
KRB5_NT_MS_PRINCIPAL = -128, KRB5_NT_MS_PRINCIPAL = -128,
KRB5_NT_MS_PRINCIPAL_AND_ID = -129, KRB5_NT_MS_PRINCIPAL_AND_ID = -129,
KRB5_NT_NTLM = -1200 KRB5_NT_NTLM = -1200
} NAME_TYPE; } NAME_TYPE;
int encode_NAME_TYPE(unsigned char *, size_t, const NAME_TYPE *, size_t ASN1EXP int ASN1CALL decode_NAME_TYPE(const unsigned char *, size_t, NAM
*); E_TYPE *, size_t *);
int decode_NAME_TYPE(const unsigned char *, size_t, NAME_TYPE *, size_t ASN1EXP int ASN1CALL encode_NAME_TYPE(unsigned char *, size_t, const NAM
*); E_TYPE *, size_t *);
void free_NAME_TYPE (NAME_TYPE *); ASN1EXP size_t ASN1CALL length_NAME_TYPE(const NAME_TYPE *);
size_t length_NAME_TYPE(const NAME_TYPE *); ASN1EXP int ASN1CALL copy_NAME_TYPE (const NAME_TYPE *, NAME_TYPE *);
int copy_NAME_TYPE (const NAME_TYPE *, NAME_TYPE *); ASN1EXP void ASN1CALL free_NAME_TYPE (NAME_TYPE *);
/* /*
MESSAGE-TYPE ::= INTEGER { MESSAGE-TYPE ::= INTEGER {
krb_as_req(10), krb_as_req(10),
krb_as_rep(11), krb_as_rep(11),
krb_tgs_req(12), krb_tgs_req(12),
krb_tgs_rep(13), krb_tgs_rep(13),
krb_ap_req(14), krb_ap_req(14),
krb_ap_rep(15), krb_ap_rep(15),
krb_safe(20), krb_safe(20),
skipping to change at line 147 skipping to change at line 158
krb_tgs_req = 12, krb_tgs_req = 12,
krb_tgs_rep = 13, krb_tgs_rep = 13,
krb_ap_req = 14, krb_ap_req = 14,
krb_ap_rep = 15, krb_ap_rep = 15,
krb_safe = 20, krb_safe = 20,
krb_priv = 21, krb_priv = 21,
krb_cred = 22, krb_cred = 22,
krb_error = 30 krb_error = 30
} MESSAGE_TYPE; } MESSAGE_TYPE;
int encode_MESSAGE_TYPE(unsigned char *, size_t, const MESSAGE_TYPE *, s
ize_t *);
int decode_MESSAGE_TYPE(const unsigned char *, size_t, MESSAGE_TYPE *, s
ize_t *);
void free_MESSAGE_TYPE (MESSAGE_TYPE *);
size_t length_MESSAGE_TYPE(const MESSAGE_TYPE *);
int copy_MESSAGE_TYPE (const MESSAGE_TYPE *, MESSAGE_TYPE *);
/* /*
PADATA-TYPE ::= INTEGER { PADATA-TYPE ::= INTEGER {
KRB5_PADATA_NONE(0), KRB5_PADATA_NONE(0),
KRB5_PADATA_TGS_REQ(1), KRB5_PADATA_TGS_REQ(1),
KRB5_PADATA_AP_REQ(1), KRB5_PADATA_AP_REQ(1),
KRB5_PADATA_ENC_TIMESTAMP(2), KRB5_PADATA_ENC_TIMESTAMP(2),
KRB5_PADATA_PW_SALT(3), KRB5_PADATA_PW_SALT(3),
KRB5_PADATA_ENC_UNIX_TIME(5), KRB5_PADATA_ENC_UNIX_TIME(5),
KRB5_PADATA_SANDIA_SECUREID(6), KRB5_PADATA_SANDIA_SECUREID(6),
KRB5_PADATA_SESAME(7), KRB5_PADATA_SESAME(7),
skipping to change at line 279 skipping to change at line 284
KRB5_PADATA_OTP_REQUEST = 142, KRB5_PADATA_OTP_REQUEST = 142,
KBB5_PADATA_OTP_CONFIRM = 143, KBB5_PADATA_OTP_CONFIRM = 143,
KRB5_PADATA_OTP_PIN_CHANGE = 144, KRB5_PADATA_OTP_PIN_CHANGE = 144,
KRB5_PADATA_EPAK_AS_REQ = 145, KRB5_PADATA_EPAK_AS_REQ = 145,
KRB5_PADATA_EPAK_AS_REP = 146, KRB5_PADATA_EPAK_AS_REP = 146,
KRB5_PADATA_PKINIT_KX = 147, KRB5_PADATA_PKINIT_KX = 147,
KRB5_PADATA_PKU2U_NAME = 148, KRB5_PADATA_PKU2U_NAME = 148,
KRB5_PADATA_SUPPORTED_ETYPES = 165 KRB5_PADATA_SUPPORTED_ETYPES = 165
} PADATA_TYPE; } PADATA_TYPE;
int encode_PADATA_TYPE(unsigned char *, size_t, const PADATA_TYPE *, siz ASN1EXP int ASN1CALL decode_PADATA_TYPE(const unsigned char *, size_t, P
e_t *); ADATA_TYPE *, size_t *);
int decode_PADATA_TYPE(const unsigned char *, size_t, PADATA_TYPE *, siz ASN1EXP int ASN1CALL encode_PADATA_TYPE(unsigned char *, size_t, const P
e_t *); ADATA_TYPE *, size_t *);
void free_PADATA_TYPE (PADATA_TYPE *); ASN1EXP size_t ASN1CALL length_PADATA_TYPE(const PADATA_TYPE *);
size_t length_PADATA_TYPE(const PADATA_TYPE *); ASN1EXP int ASN1CALL copy_PADATA_TYPE (const PADATA_TYPE *, PADATA_TYPE
int copy_PADATA_TYPE (const PADATA_TYPE *, PADATA_TYPE *); *);
ASN1EXP void ASN1CALL free_PADATA_TYPE (PADATA_TYPE *);
/* /*
AUTHDATA-TYPE ::= INTEGER { AUTHDATA-TYPE ::= INTEGER {
KRB5_AUTHDATA_IF_RELEVANT(1), KRB5_AUTHDATA_IF_RELEVANT(1),
KRB5_AUTHDATA_INTENDED_FOR_SERVER(2), KRB5_AUTHDATA_INTENDED_FOR_SERVER(2),
KRB5_AUTHDATA_INTENDED_FOR_APPLICATION_CLASS(3), KRB5_AUTHDATA_INTENDED_FOR_APPLICATION_CLASS(3),
KRB5_AUTHDATA_KDC_ISSUED(4), KRB5_AUTHDATA_KDC_ISSUED(4),
KRB5_AUTHDATA_AND_OR(5), KRB5_AUTHDATA_AND_OR(5),
KRB5_AUTHDATA_MANDATORY_TICKET_EXTENSIONS(6), KRB5_AUTHDATA_MANDATORY_TICKET_EXTENSIONS(6),
KRB5_AUTHDATA_IN_TICKET_EXTENSIONS(7), KRB5_AUTHDATA_IN_TICKET_EXTENSIONS(7),
skipping to change at line 327 skipping to change at line 332
KRB5_AUTHDATA_OSF_DCE = 64, KRB5_AUTHDATA_OSF_DCE = 64,
KRB5_AUTHDATA_SESAME = 65, KRB5_AUTHDATA_SESAME = 65,
KRB5_AUTHDATA_OSF_DCE_PKI_CERTID = 66, KRB5_AUTHDATA_OSF_DCE_PKI_CERTID = 66,
KRB5_AUTHDATA_WIN2K_PAC = 128, KRB5_AUTHDATA_WIN2K_PAC = 128,
KRB5_AUTHDATA_GSS_API_ETYPE_NEGOTIATION = 129, KRB5_AUTHDATA_GSS_API_ETYPE_NEGOTIATION = 129,
KRB5_AUTHDATA_SIGNTICKET_OLDER = -17, KRB5_AUTHDATA_SIGNTICKET_OLDER = -17,
KRB5_AUTHDATA_SIGNTICKET_OLD = 142, KRB5_AUTHDATA_SIGNTICKET_OLD = 142,
KRB5_AUTHDATA_SIGNTICKET = 512 KRB5_AUTHDATA_SIGNTICKET = 512
} AUTHDATA_TYPE; } AUTHDATA_TYPE;
int encode_AUTHDATA_TYPE(unsigned char *, size_t, const AUTHDATA_TYPE *, ASN1EXP int ASN1CALL decode_AUTHDATA_TYPE(const unsigned char *, size_t,
size_t *); AUTHDATA_TYPE *, size_t *);
int decode_AUTHDATA_TYPE(const unsigned char *, size_t, AUTHDATA_TYPE *, ASN1EXP int ASN1CALL encode_AUTHDATA_TYPE(unsigned char *, size_t, const
size_t *); AUTHDATA_TYPE *, size_t *);
void free_AUTHDATA_TYPE (AUTHDATA_TYPE *); ASN1EXP size_t ASN1CALL length_AUTHDATA_TYPE(const AUTHDATA_TYPE *);
size_t length_AUTHDATA_TYPE(const AUTHDATA_TYPE *); ASN1EXP int ASN1CALL copy_AUTHDATA_TYPE (const AUTHDATA_TYPE *, AUTHDAT
int copy_AUTHDATA_TYPE (const AUTHDATA_TYPE *, AUTHDATA_TYPE *); A_TYPE *);
ASN1EXP void ASN1CALL free_AUTHDATA_TYPE (AUTHDATA_TYPE *);
/* /*
CKSUMTYPE ::= INTEGER { CKSUMTYPE ::= INTEGER {
CKSUMTYPE_NONE(0), CKSUMTYPE_NONE(0),
CKSUMTYPE_CRC32(1), CKSUMTYPE_CRC32(1),
CKSUMTYPE_RSA_MD4(2), CKSUMTYPE_RSA_MD4(2),
CKSUMTYPE_RSA_MD4_DES(3), CKSUMTYPE_RSA_MD4_DES(3),
CKSUMTYPE_DES_MAC(4), CKSUMTYPE_DES_MAC(4),
CKSUMTYPE_DES_MAC_K(5), CKSUMTYPE_DES_MAC_K(5),
CKSUMTYPE_RSA_MD4_DES_K(6), CKSUMTYPE_RSA_MD4_DES_K(6),
skipping to change at line 377 skipping to change at line 382
CKSUMTYPE_SHA1_OTHER = 10, CKSUMTYPE_SHA1_OTHER = 10,
CKSUMTYPE_HMAC_SHA1_DES3 = 12, CKSUMTYPE_HMAC_SHA1_DES3 = 12,
CKSUMTYPE_SHA1 = 14, CKSUMTYPE_SHA1 = 14,
CKSUMTYPE_HMAC_SHA1_96_AES_128 = 15, CKSUMTYPE_HMAC_SHA1_96_AES_128 = 15,
CKSUMTYPE_HMAC_SHA1_96_AES_256 = 16, CKSUMTYPE_HMAC_SHA1_96_AES_256 = 16,
CKSUMTYPE_GSSAPI = 32771, CKSUMTYPE_GSSAPI = 32771,
CKSUMTYPE_HMAC_MD5 = -138, CKSUMTYPE_HMAC_MD5 = -138,
CKSUMTYPE_HMAC_MD5_ENC = -1138 CKSUMTYPE_HMAC_MD5_ENC = -1138
} CKSUMTYPE; } CKSUMTYPE;
int encode_CKSUMTYPE(unsigned char *, size_t, const CKSUMTYPE *, size_t ASN1EXP int ASN1CALL decode_CKSUMTYPE(const unsigned char *, size_t, CKS
*); UMTYPE *, size_t *);
int decode_CKSUMTYPE(const unsigned char *, size_t, CKSUMTYPE *, size_t ASN1EXP int ASN1CALL encode_CKSUMTYPE(unsigned char *, size_t, const CKS
*); UMTYPE *, size_t *);
void free_CKSUMTYPE (CKSUMTYPE *); ASN1EXP size_t ASN1CALL length_CKSUMTYPE(const CKSUMTYPE *);
size_t length_CKSUMTYPE(const CKSUMTYPE *); ASN1EXP int ASN1CALL copy_CKSUMTYPE (const CKSUMTYPE *, CKSUMTYPE *);
int copy_CKSUMTYPE (const CKSUMTYPE *, CKSUMTYPE *); ASN1EXP void ASN1CALL free_CKSUMTYPE (CKSUMTYPE *);
/* /*
ENCTYPE ::= INTEGER { ENCTYPE ::= INTEGER {
ETYPE_NULL(0), ETYPE_NULL(0),
ETYPE_DES_CBC_CRC(1), ETYPE_DES_CBC_CRC(1),
ETYPE_DES_CBC_MD4(2), ETYPE_DES_CBC_MD4(2),
ETYPE_DES_CBC_MD5(3), ETYPE_DES_CBC_MD5(3),
ETYPE_DES3_CBC_MD5(5), ETYPE_DES3_CBC_MD5(5),
ETYPE_OLD_DES3_CBC_SHA1(7), ETYPE_OLD_DES3_CBC_SHA1(7),
ETYPE_SIGN_DSA_GENERATE(8), ETYPE_SIGN_DSA_GENERATE(8),
skipping to change at line 439 skipping to change at line 444
ETYPE_ARCFOUR_HMAC_OLD = -133, ETYPE_ARCFOUR_HMAC_OLD = -133,
ETYPE_ARCFOUR_HMAC_OLD_EXP = -135, ETYPE_ARCFOUR_HMAC_OLD_EXP = -135,
ETYPE_DES_CBC_NONE = -4096, ETYPE_DES_CBC_NONE = -4096,
ETYPE_DES3_CBC_NONE = -4097, ETYPE_DES3_CBC_NONE = -4097,
ETYPE_DES_CFB64_NONE = -4098, ETYPE_DES_CFB64_NONE = -4098,
ETYPE_DES_PCBC_NONE = -4099, ETYPE_DES_PCBC_NONE = -4099,
ETYPE_DIGEST_MD5_NONE = -4100, ETYPE_DIGEST_MD5_NONE = -4100,
ETYPE_CRAM_MD5_NONE = -4101 ETYPE_CRAM_MD5_NONE = -4101
} ENCTYPE; } ENCTYPE;
int encode_ENCTYPE(unsigned char *, size_t, const ENCTYPE *, size_t *); ASN1EXP int ASN1CALL decode_ENCTYPE(const unsigned char *, size_t, ENCTY
int decode_ENCTYPE(const unsigned char *, size_t, ENCTYPE *, size_t *); PE *, size_t *);
void free_ENCTYPE (ENCTYPE *); ASN1EXP int ASN1CALL encode_ENCTYPE(unsigned char *, size_t, const ENCTY
size_t length_ENCTYPE(const ENCTYPE *); PE *, size_t *);
int copy_ENCTYPE (const ENCTYPE *, ENCTYPE *); 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..2147483647) krb5uint32 ::= INTEGER (0..2147483647)
*/ */
typedef unsigned int krb5uint32; typedef unsigned int krb5uint32;
int encode_krb5uint32(unsigned char *, size_t, const krb5uint32 *, size_
t *);
int decode_krb5uint32(const unsigned char *, size_t, krb5uint32 *, size_
t *);
void free_krb5uint32 (krb5uint32 *);
size_t length_krb5uint32(const krb5uint32 *);
int copy_krb5uint32 (const krb5uint32 *, krb5uint32 *);
/* /*
krb5int32 ::= INTEGER (-2147483648..2147483647) krb5int32 ::= INTEGER (-2147483648..2147483647)
*/ */
typedef int krb5int32; typedef int krb5int32;
int encode_krb5int32(unsigned char *, size_t, const krb5int32 *, size_t
*);
int decode_krb5int32(const unsigned char *, size_t, krb5int32 *, size_t
*);
void free_krb5int32 (krb5int32 *);
size_t length_krb5int32(const krb5int32 *);
int copy_krb5int32 (const krb5int32 *, krb5int32 *);
/* /*
KerberosString ::= GeneralString KerberosString ::= GeneralString
*/ */
typedef heim_general_string KerberosString; typedef heim_general_string KerberosString;
int encode_KerberosString(unsigned char *, size_t, const KerberosString ASN1EXP int ASN1CALL decode_KerberosString(const unsigned char *, size_t
*, size_t *); , KerberosString *, size_t *);
int decode_KerberosString(const unsigned char *, size_t, KerberosString ASN1EXP int ASN1CALL encode_KerberosString(unsigned char *, size_t, cons
*, size_t *); t KerberosString *, size_t *);
void free_KerberosString (KerberosString *); ASN1EXP size_t ASN1CALL length_KerberosString(const KerberosString *);
size_t length_KerberosString(const KerberosString *); ASN1EXP int ASN1CALL copy_KerberosString (const KerberosString *, Kerbe
int copy_KerberosString (const KerberosString *, KerberosString *); rosString *);
ASN1EXP void ASN1CALL free_KerberosString (KerberosString *);
/* /*
Realm ::= GeneralString Realm ::= GeneralString
*/ */
typedef heim_general_string Realm; typedef heim_general_string Realm;
int encode_Realm(unsigned char *, size_t, const Realm *, size_t *); ASN1EXP int ASN1CALL decode_Realm(const unsigned char *, size_t, Realm *
int decode_Realm(const unsigned char *, size_t, Realm *, size_t *); , size_t *);
void free_Realm (Realm *); ASN1EXP int ASN1CALL encode_Realm(unsigned char *, size_t, const Realm *
size_t length_Realm(const Realm *); , size_t *);
int copy_Realm (const Realm *, Realm *); ASN1EXP size_t ASN1CALL length_Realm(const Realm *);
ASN1EXP int ASN1CALL copy_Realm (const Realm *, Realm *);
ASN1EXP void ASN1CALL free_Realm (Realm *);
/* /*
PrincipalName ::= SEQUENCE { PrincipalName ::= SEQUENCE {
name-type [0] NAME-TYPE, name-type [0] NAME-TYPE,
name-string [1] SEQUENCE OF GeneralString, name-string [1] SEQUENCE OF GeneralString,
} }
*/ */
typedef struct PrincipalName { typedef struct PrincipalName {
NAME_TYPE name_type; NAME_TYPE name_type;
struct { struct PrincipalName_name_string {
unsigned int len; unsigned int len;
heim_general_string *val; heim_general_string *val;
} name_string; } name_string;
} PrincipalName; } PrincipalName;
int encode_PrincipalName(unsigned char *, size_t, const PrincipalName *, ASN1EXP int ASN1CALL decode_PrincipalName(const unsigned char *, size_t,
size_t *); PrincipalName *, size_t *);
int decode_PrincipalName(const unsigned char *, size_t, PrincipalName *, ASN1EXP int ASN1CALL encode_PrincipalName(unsigned char *, size_t, const
size_t *); PrincipalName *, size_t *);
void free_PrincipalName (PrincipalName *); ASN1EXP size_t ASN1CALL length_PrincipalName(const PrincipalName *);
size_t length_PrincipalName(const PrincipalName *); ASN1EXP int ASN1CALL copy_PrincipalName (const PrincipalName *, Princip
int copy_PrincipalName (const PrincipalName *, PrincipalName *); alName *);
ASN1EXP void ASN1CALL free_PrincipalName (PrincipalName *);
/* /*
Principal ::= SEQUENCE { Principal ::= SEQUENCE {
name [0] PrincipalName, name [0] PrincipalName,
realm [1] Realm, realm [1] Realm,
} }
*/ */
typedef struct Principal { typedef struct Principal {
PrincipalName name; PrincipalName name;
Realm realm; Realm realm;
} Principal; } Principal;
int encode_Principal(unsigned char *, size_t, const Principal *, size_t ASN1EXP int ASN1CALL decode_Principal(const unsigned char *, size_t, Pri
*); ncipal *, size_t *);
int decode_Principal(const unsigned char *, size_t, Principal *, size_t ASN1EXP int ASN1CALL encode_Principal(unsigned char *, size_t, const Pri
*); ncipal *, size_t *);
void free_Principal (Principal *); ASN1EXP size_t ASN1CALL length_Principal(const Principal *);
size_t length_Principal(const Principal *); ASN1EXP int ASN1CALL copy_Principal (const Principal *, Principal *);
int copy_Principal (const Principal *, Principal *); ASN1EXP void ASN1CALL free_Principal (Principal *);
/* /*
Principals ::= SEQUENCE OF Principal Principals ::= SEQUENCE OF Principal
*/ */
typedef struct Principals { typedef struct Principals {
unsigned int len; unsigned int len;
Principal *val; Principal *val;
} Principals; } Principals;
int encode_Principals(unsigned char *, size_t, const Principals *, size_ ASN1EXP int ASN1CALL add_Principals (Principals *, const Principal *);
t *); ASN1EXP int ASN1CALL remove_Principals (Principals *, unsigned int);
int decode_Principals(const unsigned char *, size_t, Principals *, size_ ASN1EXP int ASN1CALL decode_Principals(const unsigned char *, size_t, Pr
t *); incipals *, size_t *);
void free_Principals (Principals *); ASN1EXP int ASN1CALL encode_Principals(unsigned char *, size_t, const Pr
size_t length_Principals(const Principals *); incipals *, size_t *);
int copy_Principals (const Principals *, Principals *); ASN1EXP size_t ASN1CALL length_Principals(const Principals *);
int add_Principals (Principals *, const Principal *); ASN1EXP int ASN1CALL copy_Principals (const Principals *, Principals *)
int remove_Principals (Principals *, unsigned int); ;
ASN1EXP void ASN1CALL free_Principals (Principals *);
/* /*
HostAddress ::= SEQUENCE { HostAddress ::= SEQUENCE {
addr-type [0] krb5int32, addr-type [0] krb5int32,
address [1] OCTET STRING, address [1] OCTET STRING,
} }
*/ */
typedef struct HostAddress { typedef struct HostAddress {
krb5int32 addr_type; krb5int32 addr_type;
heim_octet_string address; heim_octet_string address;
} HostAddress; } HostAddress;
int encode_HostAddress(unsigned char *, size_t, const HostAddress *, siz ASN1EXP int ASN1CALL decode_HostAddress(const unsigned char *, size_t, H
e_t *); ostAddress *, size_t *);
int decode_HostAddress(const unsigned char *, size_t, HostAddress *, siz ASN1EXP int ASN1CALL encode_HostAddress(unsigned char *, size_t, const H
e_t *); ostAddress *, size_t *);
void free_HostAddress (HostAddress *); ASN1EXP size_t ASN1CALL length_HostAddress(const HostAddress *);
size_t length_HostAddress(const HostAddress *); ASN1EXP int ASN1CALL copy_HostAddress (const HostAddress *, HostAddress
int copy_HostAddress (const HostAddress *, HostAddress *); *);
ASN1EXP void ASN1CALL free_HostAddress (HostAddress *);
/* /*
HostAddresses ::= SEQUENCE OF HostAddress HostAddresses ::= SEQUENCE OF HostAddress
*/ */
typedef struct HostAddresses { typedef struct HostAddresses {
unsigned int len; unsigned int len;
HostAddress *val; HostAddress *val;
} HostAddresses; } HostAddresses;
int encode_HostAddresses(unsigned char *, size_t, const HostAddresses *, ASN1EXP int ASN1CALL decode_HostAddresses(const unsigned char *, size_t,
size_t *); HostAddresses *, size_t *);
int decode_HostAddresses(const unsigned char *, size_t, HostAddresses *, ASN1EXP int ASN1CALL encode_HostAddresses(unsigned char *, size_t, const
size_t *); HostAddresses *, size_t *);
void free_HostAddresses (HostAddresses *); ASN1EXP size_t ASN1CALL length_HostAddresses(const HostAddresses *);
size_t length_HostAddresses(const HostAddresses *); ASN1EXP int ASN1CALL copy_HostAddresses (const HostAddresses *, HostAdd
int copy_HostAddresses (const HostAddresses *, HostAddresses *); resses *);
ASN1EXP void ASN1CALL free_HostAddresses (HostAddresses *);
/* /*
KerberosTime ::= GeneralizedTime KerberosTime ::= GeneralizedTime
*/ */
typedef time_t KerberosTime; typedef time_t KerberosTime;
int encode_KerberosTime(unsigned char *, size_t, const KerberosTime *, s ASN1EXP int ASN1CALL decode_KerberosTime(const unsigned char *, size_t,
ize_t *); KerberosTime *, size_t *);
int decode_KerberosTime(const unsigned char *, size_t, KerberosTime *, s ASN1EXP int ASN1CALL encode_KerberosTime(unsigned char *, size_t, const
ize_t *); KerberosTime *, size_t *);
void free_KerberosTime (KerberosTime *); ASN1EXP size_t ASN1CALL length_KerberosTime(const KerberosTime *);
size_t length_KerberosTime(const KerberosTime *); ASN1EXP int ASN1CALL copy_KerberosTime (const KerberosTime *, KerberosT
int copy_KerberosTime (const KerberosTime *, KerberosTime *); ime *);
ASN1EXP void ASN1CALL free_KerberosTime (KerberosTime *);
/* /*
AuthorizationDataElement ::= SEQUENCE { AuthorizationDataElement ::= SEQUENCE {
ad-type [0] krb5int32, ad-type [0] krb5int32,
ad-data [1] OCTET STRING, ad-data [1] OCTET STRING,
} }
*/ */
typedef struct AuthorizationDataElement { typedef struct AuthorizationDataElement {
krb5int32 ad_type; krb5int32 ad_type;
heim_octet_string ad_data; heim_octet_string ad_data;
} AuthorizationDataElement; } AuthorizationDataElement;
int encode_AuthorizationDataElement(unsigned char *, size_t, const Autho ASN1EXP int ASN1CALL decode_AuthorizationDataElement(const unsigned char
rizationDataElement *, size_t *); *, size_t, AuthorizationDataElement *, size_t *);
int decode_AuthorizationDataElement(const unsigned char *, size_t, Autho ASN1EXP int ASN1CALL encode_AuthorizationDataElement(unsigned char *, si
rizationDataElement *, size_t *); ze_t, const AuthorizationDataElement *, size_t *);
void free_AuthorizationDataElement (AuthorizationDataElement *); ASN1EXP size_t ASN1CALL length_AuthorizationDataElement(const Authorization
size_t length_AuthorizationDataElement(const AuthorizationDataElement *); DataElement *);
int copy_AuthorizationDataElement (const AuthorizationDataElement *, Au ASN1EXP int ASN1CALL copy_AuthorizationDataElement (const Authorization
thorizationDataElement *); DataElement *, AuthorizationDataElement *);
ASN1EXP void ASN1CALL free_AuthorizationDataElement (AuthorizationDataEl
ement *);
/* /*
AuthorizationData ::= SEQUENCE OF AuthorizationDataElement AuthorizationData ::= SEQUENCE OF AuthorizationDataElement
*/ */
typedef struct AuthorizationData { typedef struct AuthorizationData {
unsigned int len; unsigned int len;
AuthorizationDataElement *val; AuthorizationDataElement *val;
} AuthorizationData; } AuthorizationData;
int encode_AuthorizationData(unsigned char *, size_t, const Authorizatio ASN1EXP int ASN1CALL add_AuthorizationData (AuthorizationData *, const A
nData *, size_t *); uthorizationDataElement *);
int decode_AuthorizationData(const unsigned char *, size_t, Authorizatio ASN1EXP int ASN1CALL remove_AuthorizationData (AuthorizationData *, unsi
nData *, size_t *); gned int);
void free_AuthorizationData (AuthorizationData *); ASN1EXP int ASN1CALL decode_AuthorizationData(const unsigned char *, siz
size_t length_AuthorizationData(const AuthorizationData *); e_t, AuthorizationData *, size_t *);
int copy_AuthorizationData (const AuthorizationData *, AuthorizationDat ASN1EXP int ASN1CALL encode_AuthorizationData(unsigned char *, size_t, c
a *); onst AuthorizationData *, size_t *);
int add_AuthorizationData (AuthorizationData *, const AuthorizationDataE ASN1EXP size_t ASN1CALL length_AuthorizationData(const AuthorizationData *)
lement *); ;
int remove_AuthorizationData (AuthorizationData *, unsigned int); ASN1EXP int ASN1CALL copy_AuthorizationData (const AuthorizationData *,
AuthorizationData *);
ASN1EXP void ASN1CALL free_AuthorizationData (AuthorizationData *);
/* /*
APOptions ::= BIT STRING { APOptions ::= BIT STRING {
reserved(0), reserved(0),
use-session-key(1), use-session-key(1),
mutual-required(2) mutual-required(2)
} }
*/ */
typedef struct APOptions { typedef struct APOptions {
unsigned int reserved:1; unsigned int reserved:1;
unsigned int use_session_key:1; unsigned int use_session_key:1;
unsigned int mutual_required:1; unsigned int mutual_required:1;
unsigned int _unused3: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;
} APOptions; } APOptions;
int encode_APOptions(unsigned char *, size_t, const APOptions *, size_t
*);
int decode_APOptions(const unsigned char *, size_t, APOptions *, size_t
*);
void free_APOptions (APOptions *);
size_t length_APOptions(const APOptions *);
int copy_APOptions (const APOptions *, APOptions *);
unsigned APOptions2int(APOptions); unsigned APOptions2int(APOptions);
APOptions int2APOptions(unsigned); APOptions int2APOptions(unsigned);
const struct units * asn1_APOptions_units(void); const struct units * asn1_APOptions_units(void);
/* /*
TicketFlags ::= BIT STRING { TicketFlags ::= BIT STRING {
reserved(0), reserved(0),
forwardable(1), forwardable(1),
forwarded(2), forwarded(2),
proxiable(3), proxiable(3),
proxy(4), proxy(4),
may-postdate(5), may-postdate(5),
postdated(6), postdated(6),
invalid(7), invalid(7),
skipping to change at line 688 skipping to change at line 704
unsigned int may_postdate:1; unsigned int may_postdate:1;
unsigned int postdated:1; unsigned int postdated:1;
unsigned int invalid:1; unsigned int invalid:1;
unsigned int renewable:1; unsigned int renewable:1;
unsigned int initial:1; unsigned int initial:1;
unsigned int pre_authent:1; unsigned int pre_authent:1;
unsigned int hw_authent:1; unsigned int hw_authent:1;
unsigned int transited_policy_checked:1; unsigned int transited_policy_checked:1;
unsigned int ok_as_delegate:1; unsigned int ok_as_delegate:1;
unsigned int anonymous: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 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;
} TicketFlags; } TicketFlags;
int encode_TicketFlags(unsigned char *, size_t, const TicketFlags *, siz
e_t *);
int decode_TicketFlags(const unsigned char *, size_t, TicketFlags *, siz
e_t *);
void free_TicketFlags (TicketFlags *);
size_t length_TicketFlags(const TicketFlags *);
int copy_TicketFlags (const TicketFlags *, TicketFlags *);
unsigned TicketFlags2int(TicketFlags); unsigned TicketFlags2int(TicketFlags);
TicketFlags int2TicketFlags(unsigned); TicketFlags int2TicketFlags(unsigned);
const struct units * asn1_TicketFlags_units(void); const struct units * asn1_TicketFlags_units(void);
ASN1EXP int ASN1CALL decode_TicketFlags(const unsigned char *, size_t, T
icketFlags *, size_t *);
ASN1EXP int ASN1CALL encode_TicketFlags(unsigned char *, size_t, const T
icketFlags *, size_t *);
ASN1EXP size_t ASN1CALL length_TicketFlags(const TicketFlags *);
ASN1EXP int ASN1CALL copy_TicketFlags (const TicketFlags *, TicketFlags
*);
ASN1EXP void ASN1CALL free_TicketFlags (TicketFlags *);
/* /*
KDCOptions ::= BIT STRING { KDCOptions ::= BIT STRING {
reserved(0), reserved(0),
forwardable(1), forwardable(1),
forwarded(2), forwarded(2),
proxiable(3), proxiable(3),
proxy(4), proxy(4),
allow-postdate(5), allow-postdate(5),
postdated(6), postdated(6),
unused7(7),
renewable(8), renewable(8),
unused9(9),
unused10(10),
unused11(11),
request-anonymous(14), request-anonymous(14),
canonicalize(15), canonicalize(15),
constrained-delegation(16), constrained-delegation(16),
disable-transited-check(26), disable-transited-check(26),
renewable-ok(27), renewable-ok(27),
enc-tkt-in-skey(28), enc-tkt-in-skey(28),
renew(30), renew(30),
validate(31) validate(31)
} }
*/ */
typedef struct KDCOptions { typedef struct KDCOptions {
unsigned int reserved:1; unsigned int reserved:1;
unsigned int forwardable:1; unsigned int forwardable:1;
unsigned int forwarded:1; unsigned int forwarded:1;
unsigned int proxiable:1; unsigned int proxiable:1;
unsigned int proxy:1; unsigned int proxy:1;
unsigned int allow_postdate:1; unsigned int allow_postdate:1;
unsigned int postdated:1; unsigned int postdated:1;
unsigned int unused7:1; unsigned int _unused7:1;
unsigned int renewable:1; unsigned int renewable:1;
unsigned int unused9:1; unsigned int _unused9:1;
unsigned int unused10:1; unsigned int _unused10:1;
unsigned int unused11:1; unsigned int _unused11:1;
unsigned int _unused12:1;
unsigned int _unused13:1;
unsigned int request_anonymous:1; unsigned int request_anonymous:1;
unsigned int canonicalize:1; unsigned int canonicalize:1;
unsigned int constrained_delegation:1; unsigned int constrained_delegation: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 disable_transited_check:1; unsigned int disable_transited_check:1;
unsigned int renewable_ok:1; unsigned int renewable_ok:1;
unsigned int enc_tkt_in_skey:1; unsigned int enc_tkt_in_skey:1;
unsigned int _unused29:1;
unsigned int renew:1; unsigned int renew:1;
unsigned int validate:1; unsigned int validate:1;
} KDCOptions; } KDCOptions;
int encode_KDCOptions(unsigned char *, size_t, const KDCOptions *, size_
t *);
int decode_KDCOptions(const unsigned char *, size_t, KDCOptions *, size_
t *);
void free_KDCOptions (KDCOptions *);
size_t length_KDCOptions(const KDCOptions *);
int copy_KDCOptions (const KDCOptions *, KDCOptions *);
unsigned KDCOptions2int(KDCOptions); unsigned KDCOptions2int(KDCOptions);
KDCOptions int2KDCOptions(unsigned); KDCOptions int2KDCOptions(unsigned);
const struct units * asn1_KDCOptions_units(void); const struct units * asn1_KDCOptions_units(void);
ASN1EXP int ASN1CALL decode_KDCOptions(const unsigned char *, size_t, KD
COptions *, size_t *);
ASN1EXP int ASN1CALL encode_KDCOptions(unsigned char *, size_t, const KD
COptions *, 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-TYPE ::= INTEGER { LR-TYPE ::= INTEGER {
LR_NONE(0), LR_NONE(0),
LR_INITIAL_TGT(1), LR_INITIAL_TGT(1),
LR_INITIAL(2), LR_INITIAL(2),
LR_ISSUE_USE_TGT(3), LR_ISSUE_USE_TGT(3),
LR_RENEWAL(4), LR_RENEWAL(4),
LR_REQUEST(5), LR_REQUEST(5),
LR_PW_EXPTIME(6), LR_PW_EXPTIME(6),
skipping to change at line 780 skipping to change at line 821
LR_NONE = 0, LR_NONE = 0,
LR_INITIAL_TGT = 1, LR_INITIAL_TGT = 1,
LR_INITIAL = 2, LR_INITIAL = 2,
LR_ISSUE_USE_TGT = 3, LR_ISSUE_USE_TGT = 3,
LR_RENEWAL = 4, LR_RENEWAL = 4,
LR_REQUEST = 5, LR_REQUEST = 5,
LR_PW_EXPTIME = 6, LR_PW_EXPTIME = 6,
LR_ACCT_EXPTIME = 7 LR_ACCT_EXPTIME = 7
} LR_TYPE; } LR_TYPE;
int encode_LR_TYPE(unsigned char *, size_t, const LR_TYPE *, size_t *); ASN1EXP int ASN1CALL decode_LR_TYPE(const unsigned char *, size_t, LR_TY
int decode_LR_TYPE(const unsigned char *, size_t, LR_TYPE *, size_t *); PE *, size_t *);
void free_LR_TYPE (LR_TYPE *); ASN1EXP int ASN1CALL encode_LR_TYPE(unsigned char *, size_t, const LR_TY
size_t length_LR_TYPE(const LR_TYPE *); PE *, size_t *);
int copy_LR_TYPE (const LR_TYPE *, LR_TYPE *); 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 *);
/* /*
LastReq ::= SEQUENCE OF SEQUENCE { LastReq ::= SEQUENCE OF SEQUENCE {
lr-type [0] LR-TYPE, lr-type [0] LR-TYPE,
lr-value [1] KerberosTime, lr-value [1] KerberosTime,
} }
*/ */
typedef struct LastReq { typedef struct LastReq {
unsigned int len; unsigned int len;
struct { struct LastReq_val {
LR_TYPE lr_type; LR_TYPE lr_type;
KerberosTime lr_value; KerberosTime lr_value;
} *val; } *val;
} LastReq; } LastReq;
int encode_LastReq(unsigned char *, size_t, const LastReq *, size_t *); ASN1EXP int ASN1CALL decode_LastReq(const unsigned char *, size_t, LastR
int decode_LastReq(const unsigned char *, size_t, LastReq *, size_t *); eq *, size_t *);
void free_LastReq (LastReq *); ASN1EXP int ASN1CALL encode_LastReq(unsigned char *, size_t, const LastR
size_t length_LastReq(const LastReq *); eq *, size_t *);
int copy_LastReq (const LastReq *, LastReq *); ASN1EXP size_t ASN1CALL length_LastReq(const LastReq *);
ASN1EXP int ASN1CALL copy_LastReq (const LastReq *, LastReq *);
ASN1EXP void ASN1CALL free_LastReq (LastReq *);
/* /*
EncryptedData ::= SEQUENCE { EncryptedData ::= SEQUENCE {
etype [0] ENCTYPE, etype [0] ENCTYPE,
kvno [1] krb5int32 OPTIONAL, kvno [1] krb5int32 OPTIONAL,
cipher [2] OCTET STRING, cipher [2] OCTET STRING,
} }
*/ */
typedef struct EncryptedData { typedef struct EncryptedData {
ENCTYPE etype; ENCTYPE etype;
krb5int32 *kvno; krb5int32 *kvno;
heim_octet_string cipher; heim_octet_string cipher;
} EncryptedData; } EncryptedData;
int encode_EncryptedData(unsigned char *, size_t, const EncryptedData *, ASN1EXP int ASN1CALL decode_EncryptedData(const unsigned char *, size_t,
size_t *); EncryptedData *, size_t *);
int decode_EncryptedData(const unsigned char *, size_t, EncryptedData *, ASN1EXP int ASN1CALL encode_EncryptedData(unsigned char *, size_t, const
size_t *); EncryptedData *, size_t *);
void free_EncryptedData (EncryptedData *); ASN1EXP size_t ASN1CALL length_EncryptedData(const EncryptedData *);
size_t length_EncryptedData(const EncryptedData *); ASN1EXP int ASN1CALL copy_EncryptedData (const EncryptedData *, Encrypt
int copy_EncryptedData (const EncryptedData *, EncryptedData *); edData *);
ASN1EXP void ASN1CALL free_EncryptedData (EncryptedData *);
/* /*
EncryptionKey ::= SEQUENCE { EncryptionKey ::= SEQUENCE {
keytype [0] krb5int32, keytype [0] krb5int32,
keyvalue [1] OCTET STRING, keyvalue [1] OCTET STRING,
} }
*/ */
typedef struct EncryptionKey { typedef struct EncryptionKey {
krb5int32 keytype; krb5int32 keytype;
heim_octet_string keyvalue; heim_octet_string keyvalue;
} EncryptionKey; } EncryptionKey;
int encode_EncryptionKey(unsigned char *, size_t, const EncryptionKey *, ASN1EXP int ASN1CALL decode_EncryptionKey(const unsigned char *, size_t,
size_t *); EncryptionKey *, size_t *);
int decode_EncryptionKey(const unsigned char *, size_t, EncryptionKey *, ASN1EXP int ASN1CALL encode_EncryptionKey(unsigned char *, size_t, const
size_t *); EncryptionKey *, size_t *);
void free_EncryptionKey (EncryptionKey *); ASN1EXP size_t ASN1CALL length_EncryptionKey(const EncryptionKey *);
size_t length_EncryptionKey(const EncryptionKey *); ASN1EXP int ASN1CALL copy_EncryptionKey (const EncryptionKey *, Encrypt
int copy_EncryptionKey (const EncryptionKey *, EncryptionKey *); ionKey *);
ASN1EXP void ASN1CALL free_EncryptionKey (EncryptionKey *);
/* /*
TransitedEncoding ::= SEQUENCE { TransitedEncoding ::= SEQUENCE {
tr-type [0] krb5int32, tr-type [0] krb5int32,
contents [1] OCTET STRING, contents [1] OCTET STRING,
} }
*/ */
typedef struct TransitedEncoding { typedef struct TransitedEncoding {
krb5int32 tr_type; krb5int32 tr_type;
heim_octet_string contents; heim_octet_string contents;
} TransitedEncoding; } TransitedEncoding;
int encode_TransitedEncoding(unsigned char *, size_t, const TransitedEnc ASN1EXP int ASN1CALL decode_TransitedEncoding(const unsigned char *, siz
oding *, size_t *); e_t, TransitedEncoding *, size_t *);
int decode_TransitedEncoding(const unsigned char *, size_t, TransitedEnc ASN1EXP int ASN1CALL encode_TransitedEncoding(unsigned char *, size_t, c
oding *, size_t *); onst TransitedEncoding *, size_t *);
void free_TransitedEncoding (TransitedEncoding *); ASN1EXP size_t ASN1CALL length_TransitedEncoding(const TransitedEncoding *)
size_t length_TransitedEncoding(const TransitedEncoding *); ;
int copy_TransitedEncoding (const TransitedEncoding *, TransitedEncodin ASN1EXP int ASN1CALL copy_TransitedEncoding (const TransitedEncoding *,
g *); TransitedEncoding *);
ASN1EXP void ASN1CALL free_TransitedEncoding (TransitedEncoding *);
/* /*
Ticket ::= [APPLICATION 1] SEQUENCE { Ticket ::= [APPLICATION 1] SEQUENCE {
tkt-vno [0] krb5int32, tkt-vno [0] krb5int32,
realm [1] Realm, realm [1] Realm,
sname [2] PrincipalName, sname [2] PrincipalName,
enc-part [3] EncryptedData, enc-part [3] EncryptedData,
} }
*/ */
typedef struct Ticket { typedef struct Ticket {
krb5int32 tkt_vno; krb5int32 tkt_vno;
Realm realm; Realm realm;
PrincipalName sname; PrincipalName sname;
EncryptedData enc_part; EncryptedData enc_part;
} Ticket; } Ticket;
int encode_Ticket(unsigned char *, size_t, const Ticket *, size_t *); ASN1EXP int ASN1CALL decode_Ticket(const unsigned char *, size_t, Ticket
int decode_Ticket(const unsigned char *, size_t, Ticket *, size_t *); *, size_t *);
void free_Ticket (Ticket *); ASN1EXP int ASN1CALL encode_Ticket(unsigned char *, size_t, const Ticket
size_t length_Ticket(const Ticket *); *, size_t *);
int copy_Ticket (const Ticket *, Ticket *); ASN1EXP size_t ASN1CALL length_Ticket(const Ticket *);
ASN1EXP int ASN1CALL copy_Ticket (const Ticket *, Ticket *);
ASN1EXP void ASN1CALL free_Ticket (Ticket *);
/* /*
EncTicketPart ::= [APPLICATION 3] SEQUENCE { EncTicketPart ::= [APPLICATION 3] SEQUENCE {
flags [0] TicketFlags, flags [0] TicketFlags,
key [1] EncryptionKey, key [1] EncryptionKey,
crealm [2] Realm, crealm [2] Realm,
cname [3] PrincipalName, cname [3] PrincipalName,
transited [4] TransitedEncoding, transited [4] TransitedEncoding,
authtime [5] KerberosTime, authtime [5] KerberosTime,
starttime [6] KerberosTime OPTIONAL, starttime [6] KerberosTime OPTIONAL,
skipping to change at line 915 skipping to change at line 956
PrincipalName cname; PrincipalName cname;
TransitedEncoding transited; TransitedEncoding transited;
KerberosTime authtime; KerberosTime authtime;
KerberosTime *starttime; KerberosTime *starttime;
KerberosTime endtime; KerberosTime endtime;
KerberosTime *renew_till; KerberosTime *renew_till;
HostAddresses *caddr; HostAddresses *caddr;
AuthorizationData *authorization_data; AuthorizationData *authorization_data;
} EncTicketPart; } EncTicketPart;
int encode_EncTicketPart(unsigned char *, size_t, const EncTicketPart *, ASN1EXP int ASN1CALL decode_EncTicketPart(const unsigned char *, size_t,
size_t *); EncTicketPart *, size_t *);
int decode_EncTicketPart(const unsigned char *, size_t, EncTicketPart *, ASN1EXP int ASN1CALL encode_EncTicketPart(unsigned char *, size_t, const
size_t *); EncTicketPart *, size_t *);
void free_EncTicketPart (EncTicketPart *); ASN1EXP size_t ASN1CALL length_EncTicketPart(const EncTicketPart *);
size_t length_EncTicketPart(const EncTicketPart *); ASN1EXP int ASN1CALL copy_EncTicketPart (const EncTicketPart *, EncTick
int copy_EncTicketPart (const EncTicketPart *, EncTicketPart *); etPart *);
ASN1EXP void ASN1CALL free_EncTicketPart (EncTicketPart *);
/* /*
Checksum ::= SEQUENCE { Checksum ::= SEQUENCE {
cksumtype [0] CKSUMTYPE, cksumtype [0] CKSUMTYPE,
checksum [1] OCTET STRING, checksum [1] OCTET STRING,
} }
*/ */
typedef struct Checksum { typedef struct Checksum {
CKSUMTYPE cksumtype; CKSUMTYPE cksumtype;
heim_octet_string checksum; heim_octet_string checksum;
} Checksum; } Checksum;
int encode_Checksum(unsigned char *, size_t, const Checksum *, size_t *) ASN1EXP int ASN1CALL decode_Checksum(const unsigned char *, size_t, Chec
; ksum *, size_t *);
int decode_Checksum(const unsigned char *, size_t, Checksum *, size_t *) ASN1EXP int ASN1CALL encode_Checksum(unsigned char *, size_t, const Chec
; ksum *, size_t *);
void free_Checksum (Checksum *); ASN1EXP size_t ASN1CALL length_Checksum(const Checksum *);
size_t length_Checksum(const Checksum *); ASN1EXP int ASN1CALL copy_Checksum (const Checksum *, Checksum *);
int copy_Checksum (const Checksum *, Checksum *); ASN1EXP void ASN1CALL free_Checksum (Checksum *);
/* /*
Authenticator ::= [APPLICATION 2] SEQUENCE { Authenticator ::= [APPLICATION 2] SEQUENCE {
authenticator-vno [0] krb5int32, authenticator-vno [0] krb5int32,
crealm [1] Realm, crealm [1] Realm,
cname [2] PrincipalName, cname [2] PrincipalName,
cksum [3] Checksum OPTIONAL, cksum [3] Checksum OPTIONAL,
cusec [4] krb5int32, cusec [4] krb5int32,
ctime [5] KerberosTime, ctime [5] KerberosTime,
subkey [6] EncryptionKey OPTIONAL, subkey [6] EncryptionKey OPTIONAL,
skipping to change at line 965 skipping to change at line 1006
Realm crealm; Realm crealm;
PrincipalName cname; PrincipalName cname;
Checksum *cksum; Checksum *cksum;
krb5int32 cusec; krb5int32 cusec;
KerberosTime ctime; KerberosTime ctime;
EncryptionKey *subkey; EncryptionKey *subkey;
krb5uint32 *seq_number; krb5uint32 *seq_number;
AuthorizationData *authorization_data; AuthorizationData *authorization_data;
} Authenticator; } Authenticator;
int encode_Authenticator(unsigned char *, size_t, const Authenticator *, ASN1EXP int ASN1CALL decode_Authenticator(const unsigned char *, size_t,
size_t *); Authenticator *, size_t *);
int decode_Authenticator(const unsigned char *, size_t, Authenticator *, ASN1EXP int ASN1CALL encode_Authenticator(unsigned char *, size_t, const
size_t *); Authenticator *, size_t *);
void free_Authenticator (Authenticator *); ASN1EXP size_t ASN1CALL length_Authenticator(const Authenticator *);
size_t length_Authenticator(const Authenticator *); ASN1EXP int ASN1CALL copy_Authenticator (const Authenticator *, Authent
int copy_Authenticator (const Authenticator *, Authenticator *); icator *);
ASN1EXP void ASN1CALL free_Authenticator (Authenticator *);
/* /*
PA-DATA ::= SEQUENCE { PA-DATA ::= SEQUENCE {
padata-type [1] PADATA-TYPE, padata-type [1] PADATA-TYPE,
padata-value [2] OCTET STRING, padata-value [2] OCTET STRING,
} }
*/ */
typedef struct PA_DATA { typedef struct PA_DATA {
PADATA_TYPE padata_type; PADATA_TYPE padata_type;
heim_octet_string padata_value; heim_octet_string padata_value;
} PA_DATA; } PA_DATA;
int encode_PA_DATA(unsigned char *, size_t, const PA_DATA *, size_t *); ASN1EXP int ASN1CALL decode_PA_DATA(const unsigned char *, size_t, PA_DA
int decode_PA_DATA(const unsigned char *, size_t, PA_DATA *, size_t *); TA *, size_t *);
void free_PA_DATA (PA_DATA *); ASN1EXP int ASN1CALL encode_PA_DATA(unsigned char *, size_t, const PA_DA
size_t length_PA_DATA(const PA_DATA *); TA *, size_t *);
int copy_PA_DATA (const PA_DATA *, PA_DATA *); 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 *);
/* /*
ETYPE-INFO-ENTRY ::= SEQUENCE { ETYPE-INFO-ENTRY ::= SEQUENCE {
etype [0] ENCTYPE, etype [0] ENCTYPE,
salt [1] OCTET STRING OPTIONAL, salt [1] OCTET STRING OPTIONAL,
salttype [2] krb5int32 OPTIONAL, salttype [2] krb5int32 OPTIONAL,
} }
*/ */
typedef struct ETYPE_INFO_ENTRY { typedef struct ETYPE_INFO_ENTRY {
ENCTYPE etype; ENCTYPE etype;
heim_octet_string *salt; heim_octet_string *salt;
krb5int32 *salttype; krb5int32 *salttype;
} ETYPE_INFO_ENTRY; } ETYPE_INFO_ENTRY;
int encode_ETYPE_INFO_ENTRY(unsigned char *, size_t, const ETYPE_INFO_EN ASN1EXP int ASN1CALL decode_ETYPE_INFO_ENTRY(const unsigned char *, size
TRY *, size_t *); _t, ETYPE_INFO_ENTRY *, size_t *);
int decode_ETYPE_INFO_ENTRY(const unsigned char *, size_t, ETYPE_INFO_EN ASN1EXP int ASN1CALL encode_ETYPE_INFO_ENTRY(unsigned char *, size_t, co
TRY *, size_t *); nst ETYPE_INFO_ENTRY *, size_t *);
void free_ETYPE_INFO_ENTRY (ETYPE_INFO_ENTRY *); ASN1EXP size_t ASN1CALL length_ETYPE_INFO_ENTRY(const ETYPE_INFO_ENTRY *);
size_t length_ETYPE_INFO_ENTRY(const ETYPE_INFO_ENTRY *); ASN1EXP int ASN1CALL copy_ETYPE_INFO_ENTRY (const ETYPE_INFO_ENTRY *, E
int copy_ETYPE_INFO_ENTRY (const ETYPE_INFO_ENTRY *, ETYPE_INFO_ENTRY * TYPE_INFO_ENTRY *);
); ASN1EXP void ASN1CALL free_ETYPE_INFO_ENTRY (ETYPE_INFO_ENTRY *);
/* /*
ETYPE-INFO ::= SEQUENCE OF ETYPE-INFO-ENTRY ETYPE-INFO ::= SEQUENCE OF ETYPE-INFO-ENTRY
*/ */
typedef struct ETYPE_INFO { typedef struct ETYPE_INFO {
unsigned int len; unsigned int len;
ETYPE_INFO_ENTRY *val; ETYPE_INFO_ENTRY *val;
} ETYPE_INFO; } ETYPE_INFO;
int encode_ETYPE_INFO(unsigned char *, size_t, const ETYPE_INFO *, size_ ASN1EXP int ASN1CALL add_ETYPE_INFO (ETYPE_INFO *, const ETYPE_INFO_ENTR
t *); Y *);
int decode_ETYPE_INFO(const unsigned char *, size_t, ETYPE_INFO *, size_ ASN1EXP int ASN1CALL remove_ETYPE_INFO (ETYPE_INFO *, unsigned int);
t *); ASN1EXP int ASN1CALL decode_ETYPE_INFO(const unsigned char *, size_t, ET
void free_ETYPE_INFO (ETYPE_INFO *); YPE_INFO *, size_t *);
size_t length_ETYPE_INFO(const ETYPE_INFO *); ASN1EXP int ASN1CALL encode_ETYPE_INFO(unsigned char *, size_t, const ET
int copy_ETYPE_INFO (const ETYPE_INFO *, ETYPE_INFO *); YPE_INFO *, size_t *);
int add_ETYPE_INFO (ETYPE_INFO *, const ETYPE_INFO_ENTRY *); ASN1EXP size_t ASN1CALL length_ETYPE_INFO(const ETYPE_INFO *);
int remove_ETYPE_INFO (ETYPE_INFO *, unsigned int); ASN1EXP int ASN1CALL copy_ETYPE_INFO (const ETYPE_INFO *, ETYPE_INFO *)
;
ASN1EXP void ASN1CALL free_ETYPE_INFO (ETYPE_INFO *);
/* /*
ETYPE-INFO2-ENTRY ::= SEQUENCE { ETYPE-INFO2-ENTRY ::= SEQUENCE {
etype [0] ENCTYPE, etype [0] ENCTYPE,
salt [1] KerberosString OPTIONAL, salt [1] KerberosString OPTIONAL,
s2kparams [2] OCTET STRING OPTIONAL, s2kparams [2] OCTET STRING OPTIONAL,
} }
*/ */
typedef struct ETYPE_INFO2_ENTRY { typedef struct ETYPE_INFO2_ENTRY {
ENCTYPE etype; ENCTYPE etype;
KerberosString *salt; KerberosString *salt;
heim_octet_string *s2kparams; heim_octet_string *s2kparams;
} ETYPE_INFO2_ENTRY; } ETYPE_INFO2_ENTRY;
int encode_ETYPE_INFO2_ENTRY(unsigned char *, size_t, const ETYPE_INFO2_ ASN1EXP int ASN1CALL decode_ETYPE_INFO2_ENTRY(const unsigned char *, siz
ENTRY *, size_t *); e_t, ETYPE_INFO2_ENTRY *, size_t *);
int decode_ETYPE_INFO2_ENTRY(const unsigned char *, size_t, ETYPE_INFO2_ ASN1EXP int ASN1CALL encode_ETYPE_INFO2_ENTRY(unsigned char *, size_t, c
ENTRY *, size_t *); onst ETYPE_INFO2_ENTRY *, size_t *);
void free_ETYPE_INFO2_ENTRY (ETYPE_INFO2_ENTRY *); ASN1EXP size_t ASN1CALL length_ETYPE_INFO2_ENTRY(const ETYPE_INFO2_ENTRY *)
size_t length_ETYPE_INFO2_ENTRY(const ETYPE_INFO2_ENTRY *); ;
int copy_ETYPE_INFO2_ENTRY (const ETYPE_INFO2_ENTRY *, ETYPE_INFO2_ENTR ASN1EXP int ASN1CALL copy_ETYPE_INFO2_ENTRY (const ETYPE_INFO2_ENTRY *,
Y *); ETYPE_INFO2_ENTRY *);
ASN1EXP void ASN1CALL free_ETYPE_INFO2_ENTRY (ETYPE_INFO2_ENTRY *);
/* /*
ETYPE-INFO2 ::= SEQUENCE OF ETYPE-INFO2-ENTRY ETYPE-INFO2 ::= SEQUENCE OF ETYPE-INFO2-ENTRY
*/ */
typedef struct ETYPE_INFO2 { typedef struct ETYPE_INFO2 {
unsigned int len; unsigned int len;
ETYPE_INFO2_ENTRY *val; ETYPE_INFO2_ENTRY *val;
} ETYPE_INFO2; } ETYPE_INFO2;
int encode_ETYPE_INFO2(unsigned char *, size_t, const ETYPE_INFO2 *, siz ASN1EXP int ASN1CALL add_ETYPE_INFO2 (ETYPE_INFO2 *, const ETYPE_INFO2_E
e_t *); NTRY *);
int decode_ETYPE_INFO2(const unsigned char *, size_t, ETYPE_INFO2 *, siz ASN1EXP int ASN1CALL remove_ETYPE_INFO2 (ETYPE_INFO2 *, unsigned int);
e_t *); ASN1EXP int ASN1CALL decode_ETYPE_INFO2(const unsigned char *, size_t, E
void free_ETYPE_INFO2 (ETYPE_INFO2 *); TYPE_INFO2 *, size_t *);
size_t length_ETYPE_INFO2(const ETYPE_INFO2 *); ASN1EXP int ASN1CALL encode_ETYPE_INFO2(unsigned char *, size_t, const E
int copy_ETYPE_INFO2 (const ETYPE_INFO2 *, ETYPE_INFO2 *); TYPE_INFO2 *, size_t *);
int add_ETYPE_INFO2 (ETYPE_INFO2 *, const ETYPE_INFO2_ENTRY *); ASN1EXP size_t ASN1CALL length_ETYPE_INFO2(const ETYPE_INFO2 *);
int remove_ETYPE_INFO2 (ETYPE_INFO2 *, unsigned int); ASN1EXP int ASN1CALL copy_ETYPE_INFO2 (const ETYPE_INFO2 *, ETYPE_INFO2
*);
ASN1EXP void ASN1CALL free_ETYPE_INFO2 (ETYPE_INFO2 *);
/* /*
METHOD-DATA ::= SEQUENCE OF PA-DATA METHOD-DATA ::= SEQUENCE OF PA-DATA
*/ */
typedef struct METHOD_DATA { typedef struct METHOD_DATA {
unsigned int len; unsigned int len;
PA_DATA *val; PA_DATA *val;
} METHOD_DATA; } METHOD_DATA;
int encode_METHOD_DATA(unsigned char *, size_t, const METHOD_DATA *, siz ASN1EXP int ASN1CALL add_METHOD_DATA (METHOD_DATA *, const PA_DATA *);
e_t *); ASN1EXP int ASN1CALL remove_METHOD_DATA (METHOD_DATA *, unsigned int);
int decode_METHOD_DATA(const unsigned char *, size_t, METHOD_DATA *, siz ASN1EXP int ASN1CALL decode_METHOD_DATA(const unsigned char *, size_t, M
e_t *); ETHOD_DATA *, size_t *);
void free_METHOD_DATA (METHOD_DATA *); ASN1EXP int ASN1CALL encode_METHOD_DATA(unsigned char *, size_t, const M
size_t length_METHOD_DATA(const METHOD_DATA *); ETHOD_DATA *, size_t *);
int copy_METHOD_DATA (const METHOD_DATA *, METHOD_DATA *); ASN1EXP size_t ASN1CALL length_METHOD_DATA(const METHOD_DATA *);
int add_METHOD_DATA (METHOD_DATA *, const PA_DATA *); ASN1EXP int ASN1CALL copy_METHOD_DATA (const METHOD_DATA *, METHOD_DATA
int remove_METHOD_DATA (METHOD_DATA *, unsigned int); *);
ASN1EXP void ASN1CALL free_METHOD_DATA (METHOD_DATA *);
/* /*
TypedData ::= SEQUENCE { TypedData ::= SEQUENCE {
data-type [0] krb5int32, data-type [0] krb5int32,
data-value [1] OCTET STRING OPTIONAL, data-value [1] OCTET STRING OPTIONAL,
} }
*/ */
typedef struct TypedData { typedef struct TypedData {
krb5int32 data_type; krb5int32 data_type;
heim_octet_string *data_value; heim_octet_string *data_value;
} TypedData; } TypedData;
int encode_TypedData(unsigned char *, size_t, const TypedData *, size_t ASN1EXP int ASN1CALL decode_TypedData(const unsigned char *, size_t, Typ
*); edData *, size_t *);
int decode_TypedData(const unsigned char *, size_t, TypedData *, size_t ASN1EXP int ASN1CALL encode_TypedData(unsigned char *, size_t, const Typ
*); edData *, size_t *);
void free_TypedData (TypedData *); ASN1EXP size_t ASN1CALL length_TypedData(const TypedData *);
size_t length_TypedData(const TypedData *); ASN1EXP int ASN1CALL copy_TypedData (const TypedData *, TypedData *);
int copy_TypedData (const TypedData *, TypedData *); ASN1EXP void ASN1CALL free_TypedData (TypedData *);
/* /*
TYPED-DATA ::= SEQUENCE OF TypedData TYPED-DATA ::= SEQUENCE OF TypedData
*/ */
typedef struct TYPED_DATA { typedef struct TYPED_DATA {
unsigned int len; unsigned int len;
TypedData *val; TypedData *val;
} TYPED_DATA; } TYPED_DATA;
int encode_TYPED_DATA(unsigned char *, size_t, const TYPED_DATA *, size_
t *);
int decode_TYPED_DATA(const unsigned char *, size_t, TYPED_DATA *, size_
t *);
void free_TYPED_DATA (TYPED_DATA *);
size_t length_TYPED_DATA(const TYPED_DATA *);
int copy_TYPED_DATA (const TYPED_DATA *, TYPED_DATA *);
/* /*
KDC-REQ-BODY ::= SEQUENCE { KDC-REQ-BODY ::= SEQUENCE {
kdc-options [0] KDCOptions, kdc-options [0] KDCOptions,
cname [1] PrincipalName OPTIONAL, cname [1] PrincipalName OPTIONAL,
realm [2] Realm, realm [2] Realm,
sname [3] PrincipalName OPTIONAL, sname [3] PrincipalName OPTIONAL,
from [4] KerberosTime OPTIONAL, from [4] KerberosTime OPTIONAL,
till [5] KerberosTime OPTIONAL, till [5] KerberosTime OPTIONAL,
rtime [6] KerberosTime OPTIONAL, rtime [6] KerberosTime OPTIONAL,
nonce [7] krb5int32, nonce [7] krb5int32,
skipping to change at line 1139 skipping to change at line 1174
typedef struct KDC_REQ_BODY { typedef struct KDC_REQ_BODY {
KDCOptions kdc_options; KDCOptions kdc_options;
PrincipalName *cname; PrincipalName *cname;
Realm realm; Realm realm;
PrincipalName *sname; PrincipalName *sname;
KerberosTime *from; KerberosTime *from;
KerberosTime *till; KerberosTime *till;
KerberosTime *rtime; KerberosTime *rtime;
krb5int32 nonce; krb5int32 nonce;
struct { struct KDC_REQ_BODY_etype {
unsigned int len; unsigned int len;
ENCTYPE *val; ENCTYPE *val;
} etype; } etype;
HostAddresses *addresses; HostAddresses *addresses;
EncryptedData *enc_authorization_data; EncryptedData *enc_authorization_data;
struct { struct KDC_REQ_BODY_additional_tickets {
unsigned int len; unsigned int len;
Ticket *val; Ticket *val;
} *additional_tickets; } *additional_tickets;
} KDC_REQ_BODY; } KDC_REQ_BODY;
int encode_KDC_REQ_BODY(unsigned char *, size_t, const KDC_REQ_BODY *, s ASN1EXP int ASN1CALL decode_KDC_REQ_BODY(const unsigned char *, size_t,
ize_t *); KDC_REQ_BODY *, size_t *);
int decode_KDC_REQ_BODY(const unsigned char *, size_t, KDC_REQ_BODY *, s ASN1EXP int ASN1CALL encode_KDC_REQ_BODY(unsigned char *, size_t, const
ize_t *); KDC_REQ_BODY *, size_t *);
void free_KDC_REQ_BODY (KDC_REQ_BODY *); ASN1EXP size_t ASN1CALL length_KDC_REQ_BODY(const KDC_REQ_BODY *);
size_t length_KDC_REQ_BODY(const KDC_REQ_BODY *); ASN1EXP int ASN1CALL copy_KDC_REQ_BODY (const KDC_REQ_BODY *, KDC_REQ_B
int copy_KDC_REQ_BODY (const KDC_REQ_BODY *, KDC_REQ_BODY *); ODY *);
ASN1EXP void ASN1CALL free_KDC_REQ_BODY (KDC_REQ_BODY *);
/* /*
KDC-REQ ::= SEQUENCE { KDC-REQ ::= SEQUENCE {
pvno [1] krb5int32, pvno [1] krb5int32,
msg-type [2] MESSAGE-TYPE, msg-type [2] MESSAGE-TYPE,
padata [3] METHOD-DATA OPTIONAL, padata [3] METHOD-DATA OPTIONAL,
req-body [4] KDC-REQ-BODY, req-body [4] KDC-REQ-BODY,
} }
*/ */
typedef struct KDC_REQ { typedef struct KDC_REQ {
krb5int32 pvno; krb5int32 pvno;
MESSAGE_TYPE msg_type; MESSAGE_TYPE msg_type;
METHOD_DATA *padata; METHOD_DATA *padata;
KDC_REQ_BODY req_body; KDC_REQ_BODY req_body;
} KDC_REQ; } KDC_REQ;
int encode_KDC_REQ(unsigned char *, size_t, const KDC_REQ *, size_t *);
int decode_KDC_REQ(const unsigned char *, size_t, KDC_REQ *, size_t *);
void free_KDC_REQ (KDC_REQ *);
size_t length_KDC_REQ(const KDC_REQ *);
int copy_KDC_REQ (const KDC_REQ *, KDC_REQ *);
/* /*
AS-REQ ::= [APPLICATION 10] KDC-REQ AS-REQ ::= [APPLICATION 10] KDC-REQ
*/ */
typedef KDC_REQ AS_REQ; typedef KDC_REQ AS_REQ;
int encode_AS_REQ(unsigned char *, size_t, const AS_REQ *, size_t *); ASN1EXP int ASN1CALL decode_AS_REQ(const unsigned char *, size_t, AS_REQ
int decode_AS_REQ(const unsigned char *, size_t, AS_REQ *, size_t *); *, size_t *);
void free_AS_REQ (AS_REQ *); ASN1EXP int ASN1CALL encode_AS_REQ(unsigned char *, size_t, const AS_REQ
size_t length_AS_REQ(const AS_REQ *); *, size_t *);
int copy_AS_REQ (const AS_REQ *, AS_REQ *); 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 *);
/* /*
TGS-REQ ::= [APPLICATION 12] KDC-REQ TGS-REQ ::= [APPLICATION 12] KDC-REQ
*/ */
typedef KDC_REQ TGS_REQ; typedef KDC_REQ TGS_REQ;
int encode_TGS_REQ(unsigned char *, size_t, const TGS_REQ *, size_t *); ASN1EXP int ASN1CALL decode_TGS_REQ(const unsigned char *, size_t, TGS_R
int decode_TGS_REQ(const unsigned char *, size_t, TGS_REQ *, size_t *); EQ *, size_t *);
void free_TGS_REQ (TGS_REQ *); ASN1EXP int ASN1CALL encode_TGS_REQ(unsigned char *, size_t, const TGS_R
size_t length_TGS_REQ(const TGS_REQ *); EQ *, size_t *);
int copy_TGS_REQ (const TGS_REQ *, TGS_REQ *); 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 *);
/* /*
PA-ENC-TS-ENC ::= SEQUENCE { PA-ENC-TS-ENC ::= SEQUENCE {
patimestamp [0] KerberosTime, patimestamp [0] KerberosTime,
pausec [1] krb5int32 OPTIONAL, pausec [1] krb5int32 OPTIONAL,
} }
*/ */
typedef struct PA_ENC_TS_ENC { typedef struct PA_ENC_TS_ENC {
KerberosTime patimestamp; KerberosTime patimestamp;
krb5int32 *pausec; krb5int32 *pausec;
} PA_ENC_TS_ENC; } PA_ENC_TS_ENC;
int encode_PA_ENC_TS_ENC(unsigned char *, size_t, const PA_ENC_TS_ENC *, ASN1EXP int ASN1CALL decode_PA_ENC_TS_ENC(const unsigned char *, size_t,
size_t *); PA_ENC_TS_ENC *, size_t *);
int decode_PA_ENC_TS_ENC(const unsigned char *, size_t, PA_ENC_TS_ENC *, ASN1EXP int ASN1CALL encode_PA_ENC_TS_ENC(unsigned char *, size_t, const
size_t *); PA_ENC_TS_ENC *, size_t *);
void free_PA_ENC_TS_ENC (PA_ENC_TS_ENC *); ASN1EXP size_t ASN1CALL length_PA_ENC_TS_ENC(const PA_ENC_TS_ENC *);
size_t 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_
int copy_PA_ENC_TS_ENC (const PA_ENC_TS_ENC *, PA_ENC_TS_ENC *); TS_ENC *);
ASN1EXP void ASN1CALL free_PA_ENC_TS_ENC (PA_ENC_TS_ENC *);
/* /*
PA-PAC-REQUEST ::= SEQUENCE { PA-PAC-REQUEST ::= SEQUENCE {
include-pac [0] BOOLEAN, include-pac [0] BOOLEAN,
} }
*/ */
typedef struct PA_PAC_REQUEST { typedef struct PA_PAC_REQUEST {
int include_pac; int include_pac;
} PA_PAC_REQUEST; } PA_PAC_REQUEST;
int encode_PA_PAC_REQUEST(unsigned char *, size_t, const PA_PAC_REQUEST ASN1EXP int ASN1CALL decode_PA_PAC_REQUEST(const unsigned char *, size_t
*, size_t *); , PA_PAC_REQUEST *, size_t *);
int decode_PA_PAC_REQUEST(const unsigned char *, size_t, PA_PAC_REQUEST ASN1EXP int ASN1CALL encode_PA_PAC_REQUEST(unsigned char *, size_t, cons
*, size_t *); t PA_PAC_REQUEST *, size_t *);
void free_PA_PAC_REQUEST (PA_PAC_REQUEST *); ASN1EXP size_t ASN1CALL length_PA_PAC_REQUEST(const PA_PAC_REQUEST *);
size_t length_PA_PAC_REQUEST(const PA_PAC_REQUEST *); ASN1EXP int ASN1CALL copy_PA_PAC_REQUEST (const PA_PAC_REQUEST *, PA_PA
int copy_PA_PAC_REQUEST (const PA_PAC_REQUEST *, PA_PAC_REQUEST *); C_REQUEST *);
ASN1EXP void ASN1CALL free_PA_PAC_REQUEST (PA_PAC_REQUEST *);
/* /*
PROV-SRV-LOCATION ::= GeneralString PROV-SRV-LOCATION ::= GeneralString
*/ */
typedef heim_general_string PROV_SRV_LOCATION; typedef heim_general_string PROV_SRV_LOCATION;
int encode_PROV_SRV_LOCATION(unsigned char *, size_t, const PROV_SRV_LOC
ATION *, size_t *);
int decode_PROV_SRV_LOCATION(const unsigned char *, size_t, PROV_SRV_LOC
ATION *, size_t *);
void free_PROV_SRV_LOCATION (PROV_SRV_LOCATION *);
size_t length_PROV_SRV_LOCATION(const PROV_SRV_LOCATION *);
int copy_PROV_SRV_LOCATION (const PROV_SRV_LOCATION *, PROV_SRV_LOCATIO
N *);
/* /*
KDC-REP ::= SEQUENCE { KDC-REP ::= SEQUENCE {
pvno [0] krb5int32, pvno [0] krb5int32,
msg-type [1] MESSAGE-TYPE, msg-type [1] MESSAGE-TYPE,
padata [2] METHOD-DATA OPTIONAL, padata [2] METHOD-DATA OPTIONAL,
crealm [3] Realm, crealm [3] Realm,
cname [4] PrincipalName, cname [4] PrincipalName,
ticket [5] Ticket, ticket [5] Ticket,
enc-part [6] EncryptedData, enc-part [6] EncryptedData,
} }
skipping to change at line 1271 skipping to change at line 1294
typedef struct KDC_REP { typedef struct KDC_REP {
krb5int32 pvno; krb5int32 pvno;
MESSAGE_TYPE msg_type; MESSAGE_TYPE msg_type;
METHOD_DATA *padata; METHOD_DATA *padata;
Realm crealm; Realm crealm;
PrincipalName cname; PrincipalName cname;
Ticket ticket; Ticket ticket;
EncryptedData enc_part; EncryptedData enc_part;
} KDC_REP; } KDC_REP;
int encode_KDC_REP(unsigned char *, size_t, const KDC_REP *, size_t *); ASN1EXP int ASN1CALL decode_KDC_REP(const unsigned char *, size_t, KDC_R
int decode_KDC_REP(const unsigned char *, size_t, KDC_REP *, size_t *); EP *, size_t *);
void free_KDC_REP (KDC_REP *); ASN1EXP int ASN1CALL encode_KDC_REP(unsigned char *, size_t, const KDC_R
size_t length_KDC_REP(const KDC_REP *); EP *, size_t *);
int copy_KDC_REP (const KDC_REP *, KDC_REP *); 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 *);
/* /*
AS-REP ::= [APPLICATION 11] KDC-REP AS-REP ::= [APPLICATION 11] KDC-REP
*/ */
typedef KDC_REP AS_REP; typedef KDC_REP AS_REP;
int encode_AS_REP(unsigned char *, size_t, const AS_REP *, size_t *); ASN1EXP int ASN1CALL decode_AS_REP(const unsigned char *, size_t, AS_REP
int decode_AS_REP(const unsigned char *, size_t, AS_REP *, size_t *); *, size_t *);
void free_AS_REP (AS_REP *); ASN1EXP int ASN1CALL encode_AS_REP(unsigned char *, size_t, const AS_REP
size_t length_AS_REP(const AS_REP *); *, size_t *);
int copy_AS_REP (const AS_REP *, AS_REP *); 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 *);
/* /*
TGS-REP ::= [APPLICATION 13] KDC-REP TGS-REP ::= [APPLICATION 13] KDC-REP
*/ */
typedef KDC_REP TGS_REP; typedef KDC_REP TGS_REP;
int encode_TGS_REP(unsigned char *, size_t, const TGS_REP *, size_t *); ASN1EXP int ASN1CALL decode_TGS_REP(const unsigned char *, size_t, TGS_R
int decode_TGS_REP(const unsigned char *, size_t, TGS_REP *, size_t *); EP *, size_t *);
void free_TGS_REP (TGS_REP *); ASN1EXP int ASN1CALL encode_TGS_REP(unsigned char *, size_t, const TGS_R
size_t length_TGS_REP(const TGS_REP *); EP *, size_t *);
int copy_TGS_REP (const TGS_REP *, TGS_REP *); 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 *);
/* /*
EncKDCRepPart ::= SEQUENCE { EncKDCRepPart ::= SEQUENCE {
key [0] EncryptionKey, key [0] EncryptionKey,
last-req [1] LastReq, last-req [1] LastReq,
nonce [2] krb5int32, nonce [2] krb5int32,
key-expiration [3] KerberosTime OPTIONAL, key-expiration [3] KerberosTime OPTIONAL,
flags [4] TicketFlags, flags [4] TicketFlags,
authtime [5] KerberosTime, authtime [5] KerberosTime,
starttime [6] KerberosTime OPTIONAL, starttime [6] KerberosTime OPTIONAL,
skipping to change at line 1335 skipping to change at line 1358
KerberosTime authtime; KerberosTime authtime;
KerberosTime *starttime; KerberosTime *starttime;
KerberosTime endtime; KerberosTime endtime;
KerberosTime *renew_till; KerberosTime *renew_till;
Realm srealm; Realm srealm;
PrincipalName sname; PrincipalName sname;
HostAddresses *caddr; HostAddresses *caddr;
METHOD_DATA *encrypted_pa_data; METHOD_DATA *encrypted_pa_data;
} EncKDCRepPart; } EncKDCRepPart;
int encode_EncKDCRepPart(unsigned char *, size_t, const EncKDCRepPart *, ASN1EXP int ASN1CALL decode_EncKDCRepPart(const unsigned char *, size_t,
size_t *); EncKDCRepPart *, size_t *);
int decode_EncKDCRepPart(const unsigned char *, size_t, EncKDCRepPart *, ASN1EXP int ASN1CALL encode_EncKDCRepPart(unsigned char *, size_t, const
size_t *); EncKDCRepPart *, size_t *);
void free_EncKDCRepPart (EncKDCRepPart *); ASN1EXP size_t ASN1CALL length_EncKDCRepPart(const EncKDCRepPart *);
size_t length_EncKDCRepPart(const EncKDCRepPart *); ASN1EXP int ASN1CALL copy_EncKDCRepPart (const EncKDCRepPart *, EncKDCR
int copy_EncKDCRepPart (const EncKDCRepPart *, EncKDCRepPart *); epPart *);
ASN1EXP void ASN1CALL free_EncKDCRepPart (EncKDCRepPart *);
/* /*
EncASRepPart ::= [APPLICATION 25] EncKDCRepPart EncASRepPart ::= [APPLICATION 25] EncKDCRepPart
*/ */
typedef EncKDCRepPart EncASRepPart; typedef EncKDCRepPart EncASRepPart;
int encode_EncASRepPart(unsigned char *, size_t, const EncASRepPart *, s ASN1EXP int ASN1CALL decode_EncASRepPart(const unsigned char *, size_t,
ize_t *); EncASRepPart *, size_t *);
int decode_EncASRepPart(const unsigned char *, size_t, EncASRepPart *, s ASN1EXP int ASN1CALL encode_EncASRepPart(unsigned char *, size_t, const
ize_t *); EncASRepPart *, size_t *);
void free_EncASRepPart (EncASRepPart *); ASN1EXP size_t ASN1CALL length_EncASRepPart(const EncASRepPart *);
size_t length_EncASRepPart(const EncASRepPart *); ASN1EXP int ASN1CALL copy_EncASRepPart (const EncASRepPart *, EncASRepP
int copy_EncASRepPart (const EncASRepPart *, EncASRepPart *); art *);
ASN1EXP void ASN1CALL free_EncASRepPart (EncASRepPart *);
/* /*
EncTGSRepPart ::= [APPLICATION 26] EncKDCRepPart EncTGSRepPart ::= [APPLICATION 26] EncKDCRepPart
*/ */
typedef EncKDCRepPart EncTGSRepPart; typedef EncKDCRepPart EncTGSRepPart;
int encode_EncTGSRepPart(unsigned char *, size_t, const EncTGSRepPart *, ASN1EXP int ASN1CALL decode_EncTGSRepPart(const unsigned char *, size_t,
size_t *); EncTGSRepPart *, size_t *);
int decode_EncTGSRepPart(const unsigned char *, size_t, EncTGSRepPart *, ASN1EXP int ASN1CALL encode_EncTGSRepPart(unsigned char *, size_t, const
size_t *); EncTGSRepPart *, size_t *);
void free_EncTGSRepPart (EncTGSRepPart *); ASN1EXP size_t ASN1CALL length_EncTGSRepPart(const EncTGSRepPart *);
size_t length_EncTGSRepPart(const EncTGSRepPart *); ASN1EXP int ASN1CALL copy_EncTGSRepPart (const EncTGSRepPart *, EncTGSR
int copy_EncTGSRepPart (const EncTGSRepPart *, EncTGSRepPart *); epPart *);
ASN1EXP void ASN1CALL free_EncTGSRepPart (EncTGSRepPart *);
/* /*
AP-REQ ::= [APPLICATION 14] SEQUENCE { AP-REQ ::= [APPLICATION 14] SEQUENCE {
pvno [0] krb5int32, pvno [0] krb5int32,
msg-type [1] MESSAGE-TYPE, msg-type [1] MESSAGE-TYPE,
ap-options [2] APOptions, ap-options [2] APOptions,
ticket [3] Ticket, ticket [3] Ticket,
authenticator [4] EncryptedData, authenticator [4] EncryptedData,
} }
*/ */
typedef struct AP_REQ { typedef struct AP_REQ {
krb5int32 pvno; krb5int32 pvno;
MESSAGE_TYPE msg_type; MESSAGE_TYPE msg_type;
APOptions ap_options; APOptions ap_options;
Ticket ticket; Ticket ticket;
EncryptedData authenticator; EncryptedData authenticator;
} AP_REQ; } AP_REQ;
int encode_AP_REQ(unsigned char *, size_t, const AP_REQ *, size_t *); ASN1EXP int ASN1CALL decode_AP_REQ(const unsigned char *, size_t, AP_REQ
int decode_AP_REQ(const unsigned char *, size_t, AP_REQ *, size_t *); *, size_t *);
void free_AP_REQ (AP_REQ *); ASN1EXP int ASN1CALL encode_AP_REQ(unsigned char *, size_t, const AP_REQ
size_t length_AP_REQ(const AP_REQ *); *, size_t *);
int copy_AP_REQ (const AP_REQ *, AP_REQ *); 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 *);
/* /*
AP-REP ::= [APPLICATION 15] SEQUENCE { AP-REP ::= [APPLICATION 15] SEQUENCE {
pvno [0] krb5int32, pvno [0] krb5int32,
msg-type [1] MESSAGE-TYPE, msg-type [1] MESSAGE-TYPE,
enc-part [2] EncryptedData, enc-part [2] EncryptedData,
} }
*/ */
typedef struct AP_REP { typedef struct AP_REP {
krb5int32 pvno; krb5int32 pvno;
MESSAGE_TYPE msg_type; MESSAGE_TYPE msg_type;
EncryptedData enc_part; EncryptedData enc_part;
} AP_REP; } AP_REP;
int encode_AP_REP(unsigned char *, size_t, const AP_REP *, size_t *); ASN1EXP int ASN1CALL decode_AP_REP(const unsigned char *, size_t, AP_REP
int decode_AP_REP(const unsigned char *, size_t, AP_REP *, size_t *); *, size_t *);
void free_AP_REP (AP_REP *); ASN1EXP int ASN1CALL encode_AP_REP(unsigned char *, size_t, const AP_REP
size_t length_AP_REP(const AP_REP *); *, size_t *);
int copy_AP_REP (const AP_REP *, AP_REP *); 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 *);
/* /*
EncAPRepPart ::= [APPLICATION 27] SEQUENCE { EncAPRepPart ::= [APPLICATION 27] SEQUENCE {
ctime [0] KerberosTime, ctime [0] KerberosTime,
cusec [1] krb5int32, cusec [1] krb5int32,
subkey [2] EncryptionKey OPTIONAL, subkey [2] EncryptionKey OPTIONAL,
seq-number [3] krb5uint32 OPTIONAL, seq-number [3] krb5uint32 OPTIONAL,
} }
*/ */
typedef struct EncAPRepPart { typedef struct EncAPRepPart {
KerberosTime ctime; KerberosTime ctime;
krb5int32 cusec; krb5int32 cusec;
EncryptionKey *subkey; EncryptionKey *subkey;
krb5uint32 *seq_number; krb5uint32 *seq_number;
} EncAPRepPart; } EncAPRepPart;
int encode_EncAPRepPart(unsigned char *, size_t, const EncAPRepPart *, s ASN1EXP int ASN1CALL decode_EncAPRepPart(const unsigned char *, size_t,
ize_t *); EncAPRepPart *, size_t *);
int decode_EncAPRepPart(const unsigned char *, size_t, EncAPRepPart *, s ASN1EXP int ASN1CALL encode_EncAPRepPart(unsigned char *, size_t, const
ize_t *); EncAPRepPart *, size_t *);
void free_EncAPRepPart (EncAPRepPart *); ASN1EXP size_t ASN1CALL length_EncAPRepPart(const EncAPRepPart *);
size_t length_EncAPRepPart(const EncAPRepPart *); ASN1EXP int ASN1CALL copy_EncAPRepPart (const EncAPRepPart *, EncAPRepP
int copy_EncAPRepPart (const EncAPRepPart *, EncAPRepPart *); art *);
ASN1EXP void ASN1CALL free_EncAPRepPart (EncAPRepPart *);
/* /*
KRB-SAFE-BODY ::= SEQUENCE { KRB-SAFE-BODY ::= SEQUENCE {
user-data [0] OCTET STRING, user-data [0] OCTET STRING,
timestamp [1] KerberosTime OPTIONAL, timestamp [1] KerberosTime OPTIONAL,
usec [2] krb5int32 OPTIONAL, usec [2] krb5int32 OPTIONAL,
seq-number [3] krb5uint32 OPTIONAL, seq-number [3] krb5uint32 OPTIONAL,
s-address [4] HostAddress OPTIONAL, s-address [4] HostAddress OPTIONAL,
r-address [5] HostAddress OPTIONAL, r-address [5] HostAddress OPTIONAL,
} }
skipping to change at line 1451 skipping to change at line 1474
typedef struct KRB_SAFE_BODY { typedef struct KRB_SAFE_BODY {
heim_octet_string user_data; heim_octet_string user_data;
KerberosTime *timestamp; KerberosTime *timestamp;
krb5int32 *usec; krb5int32 *usec;
krb5uint32 *seq_number; krb5uint32 *seq_number;
HostAddress *s_address; HostAddress *s_address;
HostAddress *r_address; HostAddress *r_address;
} KRB_SAFE_BODY; } KRB_SAFE_BODY;
int encode_KRB_SAFE_BODY(unsigned char *, size_t, const KRB_SAFE_BODY *, ASN1EXP int ASN1CALL decode_KRB_SAFE_BODY(const unsigned char *, size_t,
size_t *); KRB_SAFE_BODY *, size_t *);
int decode_KRB_SAFE_BODY(const unsigned char *, size_t, KRB_SAFE_BODY *, ASN1EXP int ASN1CALL encode_KRB_SAFE_BODY(unsigned char *, size_t, const
size_t *); KRB_SAFE_BODY *, size_t *);
void free_KRB_SAFE_BODY (KRB_SAFE_BODY *); ASN1EXP size_t ASN1CALL length_KRB_SAFE_BODY(const KRB_SAFE_BODY *);
size_t length_KRB_SAFE_BODY(const KRB_SAFE_BODY *); ASN1EXP int ASN1CALL copy_KRB_SAFE_BODY (const KRB_SAFE_BODY *, KRB_SAF
int copy_KRB_SAFE_BODY (const KRB_SAFE_BODY *, KRB_SAFE_BODY *); E_BODY *);
ASN1EXP void ASN1CALL free_KRB_SAFE_BODY (KRB_SAFE_BODY *);
/* /*
KRB-SAFE ::= [APPLICATION 20] SEQUENCE { KRB-SAFE ::= [APPLICATION 20] SEQUENCE {
pvno [0] krb5int32, pvno [0] krb5int32,
msg-type [1] MESSAGE-TYPE, msg-type [1] MESSAGE-TYPE,
safe-body [2] KRB-SAFE-BODY, safe-body [2] KRB-SAFE-BODY,
cksum [3] Checksum, cksum [3] Checksum,
} }
*/ */
typedef struct KRB_SAFE { typedef struct KRB_SAFE {
krb5int32 pvno; krb5int32 pvno;
MESSAGE_TYPE msg_type; MESSAGE_TYPE msg_type;
KRB_SAFE_BODY safe_body; KRB_SAFE_BODY safe_body;
Checksum cksum; Checksum cksum;
} KRB_SAFE; } KRB_SAFE;
int encode_KRB_SAFE(unsigned char *, size_t, const KRB_SAFE *, size_t *) ASN1EXP int ASN1CALL decode_KRB_SAFE(const unsigned char *, size_t, KRB_
; SAFE *, size_t *);
int 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 *);
void free_KRB_SAFE (KRB_SAFE *); ASN1EXP size_t ASN1CALL length_KRB_SAFE(const KRB_SAFE *);
size_t length_KRB_SAFE(const KRB_SAFE *); ASN1EXP int ASN1CALL copy_KRB_SAFE (const KRB_SAFE *, KRB_SAFE *);
int copy_KRB_SAFE (const KRB_SAFE *, KRB_SAFE *); ASN1EXP void ASN1CALL free_KRB_SAFE (KRB_SAFE *);
/* /*
KRB-PRIV ::= [APPLICATION 21] SEQUENCE { KRB-PRIV ::= [APPLICATION 21] SEQUENCE {
pvno [0] krb5int32, pvno [0] krb5int32,
msg-type [1] MESSAGE-TYPE, msg-type [1] MESSAGE-TYPE,
enc-part [3] EncryptedData, enc-part [3] EncryptedData,
} }
*/ */
typedef struct KRB_PRIV { typedef struct KRB_PRIV {
krb5int32 pvno; krb5int32 pvno;
MESSAGE_TYPE msg_type; MESSAGE_TYPE msg_type;
EncryptedData enc_part; EncryptedData enc_part;
} KRB_PRIV; } KRB_PRIV;
int encode_KRB_PRIV(unsigned char *, size_t, const KRB_PRIV *, size_t *) ASN1EXP int ASN1CALL decode_KRB_PRIV(const unsigned char *, size_t, KRB_
; PRIV *, size_t *);
int 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 *);
void free_KRB_PRIV (KRB_PRIV *); ASN1EXP size_t ASN1CALL length_KRB_PRIV(const KRB_PRIV *);
size_t length_KRB_PRIV(const KRB_PRIV *); ASN1EXP int ASN1CALL copy_KRB_PRIV (const KRB_PRIV *, KRB_PRIV *);
int copy_KRB_PRIV (const KRB_PRIV *, KRB_PRIV *); ASN1EXP void ASN1CALL free_KRB_PRIV (KRB_PRIV *);
/* /*
EncKrbPrivPart ::= [APPLICATION 28] SEQUENCE { EncKrbPrivPart ::= [APPLICATION 28] SEQUENCE {
user-data [0] OCTET STRING, user-data [0] OCTET STRING,
timestamp [1] KerberosTime OPTIONAL, timestamp [1] KerberosTime OPTIONAL,
usec [2] krb5int32 OPTIONAL, usec [2] krb5int32 OPTIONAL,
seq-number [3] krb5uint32 OPTIONAL, seq-number [3] krb5uint32 OPTIONAL,
s-address [4] HostAddress OPTIONAL, s-address [4] HostAddress OPTIONAL,
r-address [5] HostAddress OPTIONAL, r-address [5] HostAddress OPTIONAL,
} }
skipping to change at line 1519 skipping to change at line 1542
typedef struct EncKrbPrivPart { typedef struct EncKrbPrivPart {
heim_octet_string user_data; heim_octet_string user_data;
KerberosTime *timestamp; KerberosTime *timestamp;
krb5int32 *usec; krb5int32 *usec;
krb5uint32 *seq_number; krb5uint32 *seq_number;
HostAddress *s_address; HostAddress *s_address;
HostAddress *r_address; HostAddress *r_address;
} EncKrbPrivPart; } EncKrbPrivPart;
int encode_EncKrbPrivPart(unsigned char *, size_t, const EncKrbPrivPart ASN1EXP int ASN1CALL decode_EncKrbPrivPart(const unsigned char *, size_t
*, size_t *); , EncKrbPrivPart *, size_t *);
int decode_EncKrbPrivPart(const unsigned char *, size_t, EncKrbPrivPart ASN1EXP int ASN1CALL encode_EncKrbPrivPart(unsigned char *, size_t, cons
*, size_t *); t EncKrbPrivPart *, size_t *);
void free_EncKrbPrivPart (EncKrbPrivPart *); ASN1EXP size_t ASN1CALL length_EncKrbPrivPart(const EncKrbPrivPart *);
size_t length_EncKrbPrivPart(const EncKrbPrivPart *); ASN1EXP int ASN1CALL copy_EncKrbPrivPart (const EncKrbPrivPart *, EncKr
int copy_EncKrbPrivPart (const EncKrbPrivPart *, EncKrbPrivPart *); bPrivPart *);
ASN1EXP void ASN1CALL free_EncKrbPrivPart (EncKrbPrivPart *);
/* /*
KRB-CRED ::= [APPLICATION 22] SEQUENCE { KRB-CRED ::= [APPLICATION 22] SEQUENCE {
pvno [0] krb5int32, pvno [0] krb5int32,
msg-type [1] MESSAGE-TYPE, msg-type [1] MESSAGE-TYPE,
tickets [2] SEQUENCE OF Ticket, tickets [2] SEQUENCE OF Ticket,
enc-part [3] EncryptedData, enc-part [3] EncryptedData,
} }
*/ */
typedef struct KRB_CRED { typedef struct KRB_CRED {
krb5int32 pvno; krb5int32 pvno;
MESSAGE_TYPE msg_type; MESSAGE_TYPE msg_type;
struct { struct KRB_CRED_tickets {
unsigned int len; unsigned int len;
Ticket *val; Ticket *val;
} tickets; } tickets;
EncryptedData enc_part; EncryptedData enc_part;
} KRB_CRED; } KRB_CRED;
int encode_KRB_CRED(unsigned char *, size_t, const KRB_CRED *, size_t *) ASN1EXP int ASN1CALL decode_KRB_CRED(const unsigned char *, size_t, KRB_
; CRED *, size_t *);
int 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 *);
void free_KRB_CRED (KRB_CRED *); ASN1EXP size_t ASN1CALL length_KRB_CRED(const KRB_CRED *);
size_t length_KRB_CRED(const KRB_CRED *); ASN1EXP int ASN1CALL copy_KRB_CRED (const KRB_CRED *, KRB_CRED *);
int copy_KRB_CRED (const KRB_CRED *, KRB_CRED *); ASN1EXP void ASN1CALL free_KRB_CRED (KRB_CRED *);
/* /*
KrbCredInfo ::= SEQUENCE { KrbCredInfo ::= SEQUENCE {
key [0] EncryptionKey, key [0] EncryptionKey,
prealm [1] Realm OPTIONAL, prealm [1] Realm OPTIONAL,
pname [2] PrincipalName OPTIONAL, pname [2] PrincipalName OPTIONAL,
flags [3] TicketFlags OPTIONAL, flags [3] TicketFlags OPTIONAL,
authtime [4] KerberosTime OPTIONAL, authtime [4] KerberosTime OPTIONAL,
starttime [5] KerberosTime OPTIONAL, starttime [5] KerberosTime OPTIONAL,
endtime [6] KerberosTime OPTIONAL, endtime [6] KerberosTime OPTIONAL,
skipping to change at line 1580 skipping to change at line 1603
TicketFlags *flags; TicketFlags *flags;
KerberosTime *authtime; KerberosTime *authtime;
KerberosTime *starttime; KerberosTime *starttime;
KerberosTime *endtime; KerberosTime *endtime;
KerberosTime *renew_till; KerberosTime *renew_till;
Realm *srealm; Realm *srealm;
PrincipalName *sname; PrincipalName *sname;
HostAddresses *caddr; HostAddresses *caddr;
} KrbCredInfo; } KrbCredInfo;
int encode_KrbCredInfo(unsigned char *, size_t, const KrbCredInfo *, siz ASN1EXP int ASN1CALL decode_KrbCredInfo(const unsigned char *, size_t, K
e_t *); rbCredInfo *, size_t *);
int decode_KrbCredInfo(const unsigned char *, size_t, KrbCredInfo *, siz ASN1EXP int ASN1CALL encode_KrbCredInfo(unsigned char *, size_t, const K
e_t *); rbCredInfo *, size_t *);
void free_KrbCredInfo (KrbCredInfo *); ASN1EXP size_t ASN1CALL length_KrbCredInfo(const KrbCredInfo *);
size_t length_KrbCredInfo(const KrbCredInfo *); ASN1EXP int ASN1CALL copy_KrbCredInfo (const KrbCredInfo *, KrbCredInfo
int copy_KrbCredInfo (const KrbCredInfo *, KrbCredInfo *); *);
ASN1EXP void ASN1CALL free_KrbCredInfo (KrbCredInfo *);
/* /*
EncKrbCredPart ::= [APPLICATION 29] SEQUENCE { EncKrbCredPart ::= [APPLICATION 29] SEQUENCE {
ticket-info [0] SEQUENCE OF KrbCredInfo, ticket-info [0] SEQUENCE OF KrbCredInfo,
nonce [1] krb5int32 OPTIONAL, nonce [1] krb5int32 OPTIONAL,
timestamp [2] KerberosTime OPTIONAL, timestamp [2] KerberosTime OPTIONAL,
usec [3] krb5int32 OPTIONAL, usec [3] krb5int32 OPTIONAL,
s-address [4] HostAddress OPTIONAL, s-address [4] HostAddress OPTIONAL,
r-address [5] HostAddress OPTIONAL, r-address [5] HostAddress OPTIONAL,
} }
*/ */
typedef struct EncKrbCredPart { typedef struct EncKrbCredPart {
struct { struct EncKrbCredPart_ticket_info {
unsigned int len; unsigned int len;
KrbCredInfo *val; KrbCredInfo *val;
} ticket_info; } ticket_info;
krb5int32 *nonce; krb5int32 *nonce;
KerberosTime *timestamp; KerberosTime *timestamp;
krb5int32 *usec; krb5int32 *usec;
HostAddress *s_address; HostAddress *s_address;
HostAddress *r_address; HostAddress *r_address;
} EncKrbCredPart; } EncKrbCredPart;
int encode_EncKrbCredPart(unsigned char *, size_t, const EncKrbCredPart ASN1EXP int ASN1CALL decode_EncKrbCredPart(const unsigned char *, size_t
*, size_t *); , EncKrbCredPart *, size_t *);
int decode_EncKrbCredPart(const unsigned char *, size_t, EncKrbCredPart ASN1EXP int ASN1CALL encode_EncKrbCredPart(unsigned char *, size_t, cons
*, size_t *); t EncKrbCredPart *, size_t *);
void free_EncKrbCredPart (EncKrbCredPart *); ASN1EXP size_t ASN1CALL length_EncKrbCredPart(const EncKrbCredPart *);
size_t length_EncKrbCredPart(const EncKrbCredPart *); ASN1EXP int ASN1CALL copy_EncKrbCredPart (const EncKrbCredPart *, EncKr
int copy_EncKrbCredPart (const EncKrbCredPart *, EncKrbCredPart *); bCredPart *);
ASN1EXP void ASN1CALL free_EncKrbCredPart (EncKrbCredPart *);
/* /*
KRB-ERROR ::= [APPLICATION 30] SEQUENCE { KRB-ERROR ::= [APPLICATION 30] SEQUENCE {
pvno [0] krb5int32, pvno [0] krb5int32,
msg-type [1] MESSAGE-TYPE, msg-type [1] MESSAGE-TYPE,
ctime [2] KerberosTime OPTIONAL, ctime [2] KerberosTime OPTIONAL,
cusec [3] krb5int32 OPTIONAL, cusec [3] krb5int32 OPTIONAL,
stime [4] KerberosTime, stime [4] KerberosTime,
susec [5] krb5int32, susec [5] krb5int32,
error-code [6] krb5int32, error-code [6] krb5int32,
skipping to change at line 1649 skipping to change at line 1672
krb5int32 susec; krb5int32 susec;
krb5int32 error_code; krb5int32 error_code;
Realm *crealm; Realm *crealm;
PrincipalName *cname; PrincipalName *cname;
Realm realm; Realm realm;
PrincipalName sname; PrincipalName sname;
heim_general_string *e_text; heim_general_string *e_text;
heim_octet_string *e_data; heim_octet_string *e_data;
} KRB_ERROR; } KRB_ERROR;
int encode_KRB_ERROR(unsigned char *, size_t, const KRB_ERROR *, size_t ASN1EXP int ASN1CALL decode_KRB_ERROR(const unsigned char *, size_t, KRB
*); _ERROR *, size_t *);
int 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 *);
void free_KRB_ERROR (KRB_ERROR *); ASN1EXP size_t ASN1CALL length_KRB_ERROR(const KRB_ERROR *);
size_t length_KRB_ERROR(const KRB_ERROR *); ASN1EXP int ASN1CALL copy_KRB_ERROR (const KRB_ERROR *, KRB_ERROR *);
int copy_KRB_ERROR (const KRB_ERROR *, KRB_ERROR *); ASN1EXP void ASN1CALL free_KRB_ERROR (KRB_ERROR *);
/* /*
ChangePasswdDataMS ::= SEQUENCE { ChangePasswdDataMS ::= SEQUENCE {
newpasswd [0] OCTET STRING, newpasswd [0] OCTET STRING,
targname [1] PrincipalName OPTIONAL, targname [1] PrincipalName OPTIONAL,
targrealm [2] Realm OPTIONAL, targrealm [2] Realm OPTIONAL,
} }
*/ */
typedef struct ChangePasswdDataMS { typedef struct ChangePasswdDataMS {
heim_octet_string newpasswd; heim_octet_string newpasswd;
PrincipalName *targname; PrincipalName *targname;
Realm *targrealm; Realm *targrealm;
} ChangePasswdDataMS; } ChangePasswdDataMS;
int encode_ChangePasswdDataMS(unsigned char *, size_t, const ChangePassw ASN1EXP int ASN1CALL decode_ChangePasswdDataMS(const unsigned char *, si
dDataMS *, size_t *); ze_t, ChangePasswdDataMS *, size_t *);
int decode_ChangePasswdDataMS(const unsigned char *, size_t, ChangePassw ASN1EXP int ASN1CALL encode_ChangePasswdDataMS(unsigned char *, size_t,
dDataMS *, size_t *); const ChangePasswdDataMS *, size_t *);
void free_ChangePasswdDataMS (ChangePasswdDataMS *); ASN1EXP size_t ASN1CALL length_ChangePasswdDataMS(const ChangePasswdDataMS
size_t length_ChangePasswdDataMS(const ChangePasswdDataMS *); *);
int copy_ChangePasswdDataMS (const ChangePasswdDataMS *, ChangePasswdDa ASN1EXP int ASN1CALL copy_ChangePasswdDataMS (const ChangePasswdDataMS
taMS *); *, ChangePasswdDataMS *);
ASN1EXP void ASN1CALL free_ChangePasswdDataMS (ChangePasswdDataMS *);
/* /*
EtypeList ::= SEQUENCE OF krb5int32 EtypeList ::= SEQUENCE OF krb5int32
*/ */
typedef struct EtypeList { typedef struct EtypeList {
unsigned int len; unsigned int len;
krb5int32 *val; krb5int32 *val;
} EtypeList; } EtypeList;
int encode_EtypeList(unsigned char *, size_t, const EtypeList *, size_t ASN1EXP int ASN1CALL decode_EtypeList(const unsigned char *, size_t, Ety
*); peList *, size_t *);
int decode_EtypeList(const unsigned char *, size_t, EtypeList *, size_t ASN1EXP int ASN1CALL encode_EtypeList(unsigned char *, size_t, const Ety
*); peList *, size_t *);
void free_EtypeList (EtypeList *); ASN1EXP size_t ASN1CALL length_EtypeList(const EtypeList *);
size_t length_EtypeList(const EtypeList *); ASN1EXP int ASN1CALL copy_EtypeList (const EtypeList *, EtypeList *);
int copy_EtypeList (const EtypeList *, EtypeList *); ASN1EXP void ASN1CALL free_EtypeList (EtypeList *);
enum { krb5_pvno = 5 }; enum { krb5_pvno = 5 };
enum { DOMAIN_X500_COMPRESS = 1 }; enum { DOMAIN_X500_COMPRESS = 1 };
/* /*
AD-IF-RELEVANT ::= AuthorizationData AD-IF-RELEVANT ::= AuthorizationData
*/ */
typedef AuthorizationData AD_IF_RELEVANT; typedef AuthorizationData AD_IF_RELEVANT;
int encode_AD_IF_RELEVANT(unsigned char *, size_t, const AD_IF_RELEVANT ASN1EXP int ASN1CALL decode_AD_IF_RELEVANT(const unsigned char *, size_t
*, size_t *); , AD_IF_RELEVANT *, size_t *);
int decode_AD_IF_RELEVANT(const unsigned char *, size_t, AD_IF_RELEVANT ASN1EXP int ASN1CALL encode_AD_IF_RELEVANT(unsigned char *, size_t, cons
*, size_t *); t AD_IF_RELEVANT *, size_t *);
void free_AD_IF_RELEVANT (AD_IF_RELEVANT *); ASN1EXP size_t ASN1CALL length_AD_IF_RELEVANT(const AD_IF_RELEVANT *);
size_t length_AD_IF_RELEVANT(const AD_IF_RELEVANT *); ASN1EXP int ASN1CALL copy_AD_IF_RELEVANT (const AD_IF_RELEVANT *, AD_IF
int copy_AD_IF_RELEVANT (const AD_IF_RELEVANT *, AD_IF_RELEVANT *); _RELEVANT *);
ASN1EXP void ASN1CALL free_AD_IF_RELEVANT (AD_IF_RELEVANT *);
/* /*
AD-KDCIssued ::= SEQUENCE { AD-KDCIssued ::= SEQUENCE {
ad-checksum [0] Checksum, ad-checksum [0] Checksum,
i-realm [1] Realm OPTIONAL, i-realm [1] Realm OPTIONAL,
i-sname [2] PrincipalName OPTIONAL, i-sname [2] PrincipalName OPTIONAL,
elements [3] AuthorizationData, elements [3] AuthorizationData,
} }
*/ */
typedef struct AD_KDCIssued { typedef struct AD_KDCIssued {
Checksum ad_checksum; Checksum ad_checksum;
Realm *i_realm; Realm *i_realm;
PrincipalName *i_sname; PrincipalName *i_sname;
AuthorizationData elements; AuthorizationData elements;
} AD_KDCIssued; } AD_KDCIssued;
int encode_AD_KDCIssued(unsigned char *, size_t, const AD_KDCIssued *, s ASN1EXP int ASN1CALL decode_AD_KDCIssued(const unsigned char *, size_t,
ize_t *); AD_KDCIssued *, size_t *);
int decode_AD_KDCIssued(const unsigned char *, size_t, AD_KDCIssued *, s ASN1EXP int ASN1CALL encode_AD_KDCIssued(unsigned char *, size_t, const
ize_t *); AD_KDCIssued *, size_t *);
void free_AD_KDCIssued (AD_KDCIssued *); ASN1EXP size_t ASN1CALL length_AD_KDCIssued(const AD_KDCIssued *);
size_t length_AD_KDCIssued(const AD_KDCIssued *); ASN1EXP int ASN1CALL copy_AD_KDCIssued (const AD_KDCIssued *, AD_KDCIss
int copy_AD_KDCIssued (const AD_KDCIssued *, AD_KDCIssued *); ued *);
ASN1EXP void ASN1CALL free_AD_KDCIssued (AD_KDCIssued *);
/* /*
AD-AND-OR ::= SEQUENCE { AD-AND-OR ::= SEQUENCE {
condition-count [0] INTEGER, condition-count [0] INTEGER,
elements [1] AuthorizationData, elements [1] AuthorizationData,
} }
*/ */
typedef struct AD_AND_OR { typedef struct AD_AND_OR {
heim_integer condition_count; heim_integer condition_count;
AuthorizationData elements; AuthorizationData elements;
} AD_AND_OR; } AD_AND_OR;
int encode_AD_AND_OR(unsigned char *, size_t, const AD_AND_OR *, size_t ASN1EXP int ASN1CALL decode_AD_AND_OR(const unsigned char *, size_t, AD_
*); AND_OR *, size_t *);
int 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 *);
void free_AD_AND_OR (AD_AND_OR *); ASN1EXP size_t ASN1CALL length_AD_AND_OR(const AD_AND_OR *);
size_t length_AD_AND_OR(const AD_AND_OR *); ASN1EXP int ASN1CALL copy_AD_AND_OR (const AD_AND_OR *, AD_AND_OR *);
int copy_AD_AND_OR (const AD_AND_OR *, AD_AND_OR *); ASN1EXP void ASN1CALL free_AD_AND_OR (AD_AND_OR *);
/* /*
AD-MANDATORY-FOR-KDC ::= AuthorizationData AD-MANDATORY-FOR-KDC ::= AuthorizationData
*/ */
typedef AuthorizationData AD_MANDATORY_FOR_KDC; typedef AuthorizationData AD_MANDATORY_FOR_KDC;
int encode_AD_MANDATORY_FOR_KDC(unsigned char *, size_t, const AD_MANDAT
ORY_FOR_KDC *, size_t *);
int decode_AD_MANDATORY_FOR_KDC(const unsigned char *, size_t, AD_MANDAT
ORY_FOR_KDC *, size_t *);
void free_AD_MANDATORY_FOR_KDC (AD_MANDATORY_FOR_KDC *);
size_t length_AD_MANDATORY_FOR_KDC(const AD_MANDATORY_FOR_KDC *);
int copy_AD_MANDATORY_FOR_KDC (const AD_MANDATORY_FOR_KDC *, AD_MANDATO
RY_FOR_KDC *);
/* /*
PA-SAM-TYPE ::= INTEGER { PA-SAM-TYPE ::= INTEGER {
PA_SAM_TYPE_ENIGMA(1), PA_SAM_TYPE_ENIGMA(1),
PA_SAM_TYPE_DIGI_PATH(2), PA_SAM_TYPE_DIGI_PATH(2),
PA_SAM_TYPE_SKEY_K0(3), PA_SAM_TYPE_SKEY_K0(3),
PA_SAM_TYPE_SKEY(4), PA_SAM_TYPE_SKEY(4),
PA_SAM_TYPE_SECURID(5), PA_SAM_TYPE_SECURID(5),
PA_SAM_TYPE_CRYPTOCARD(6) PA_SAM_TYPE_CRYPTOCARD(6)
} }
*/ */
typedef enum PA_SAM_TYPE { typedef enum PA_SAM_TYPE {
PA_SAM_TYPE_ENIGMA = 1, PA_SAM_TYPE_ENIGMA = 1,
PA_SAM_TYPE_DIGI_PATH = 2, PA_SAM_TYPE_DIGI_PATH = 2,
PA_SAM_TYPE_SKEY_K0 = 3, PA_SAM_TYPE_SKEY_K0 = 3,
PA_SAM_TYPE_SKEY = 4, PA_SAM_TYPE_SKEY = 4,
PA_SAM_TYPE_SECURID = 5, PA_SAM_TYPE_SECURID = 5,
PA_SAM_TYPE_CRYPTOCARD = 6 PA_SAM_TYPE_CRYPTOCARD = 6
} PA_SAM_TYPE; } PA_SAM_TYPE;
int encode_PA_SAM_TYPE(unsigned char *, size_t, const PA_SAM_TYPE *, siz
e_t *);
int decode_PA_SAM_TYPE(const unsigned char *, size_t, PA_SAM_TYPE *, siz
e_t *);
void free_PA_SAM_TYPE (PA_SAM_TYPE *);
size_t length_PA_SAM_TYPE(const PA_SAM_TYPE *);
int copy_PA_SAM_TYPE (const PA_SAM_TYPE *, PA_SAM_TYPE *);
/* /*
PA-SAM-REDIRECT ::= HostAddresses PA-SAM-REDIRECT ::= HostAddresses
*/ */
typedef HostAddresses PA_SAM_REDIRECT; typedef HostAddresses PA_SAM_REDIRECT;
int encode_PA_SAM_REDIRECT(unsigned char *, size_t, const PA_SAM_REDIREC
T *, size_t *);
int decode_PA_SAM_REDIRECT(const unsigned char *, size_t, PA_SAM_REDIREC
T *, size_t *);
void free_PA_SAM_REDIRECT (PA_SAM_REDIRECT *);
size_t length_PA_SAM_REDIRECT(const PA_SAM_REDIRECT *);
int copy_PA_SAM_REDIRECT (const PA_SAM_REDIRECT *, PA_SAM_REDIRECT *);
/* /*
SAMFlags ::= BIT STRING { SAMFlags ::= BIT STRING {
use-sad-as-key(0), use-sad-as-key(0),
send-encrypted-sad(1), send-encrypted-sad(1),
must-pk-encrypt-sad(2) must-pk-encrypt-sad(2)
} }
*/ */
typedef struct SAMFlags { typedef struct SAMFlags {
unsigned int use_sad_as_key:1; unsigned int use_sad_as_key:1;
unsigned int send_encrypted_sad:1; unsigned int send_encrypted_sad:1;
unsigned int must_pk_encrypt_sad:1; unsigned int must_pk_encrypt_sad:1;
unsigned int _unused3: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;
} SAMFlags; } SAMFlags;
int encode_SAMFlags(unsigned char *, size_t, const SAMFlags *, size_t *)
;
int decode_SAMFlags(const unsigned char *, size_t, SAMFlags *, size_t *)
;
void free_SAMFlags (SAMFlags *);
size_t length_SAMFlags(const SAMFlags *);
int copy_SAMFlags (const SAMFlags *, SAMFlags *);
unsigned SAMFlags2int(SAMFlags); unsigned SAMFlags2int(SAMFlags);
SAMFlags int2SAMFlags(unsigned); SAMFlags int2SAMFlags(unsigned);
const struct units * asn1_SAMFlags_units(void); const struct units * asn1_SAMFlags_units(void);
/* /*
PA-SAM-CHALLENGE-2-BODY ::= SEQUENCE { PA-SAM-CHALLENGE-2-BODY ::= SEQUENCE {
sam-type [0] krb5int32, sam-type [0] krb5int32,
sam-flags [1] SAMFlags, sam-flags [1] SAMFlags,
sam-type-name [2] GeneralString OPTIONAL, sam-type-name [2] GeneralString OPTIONAL,
sam-track-id [3] GeneralString OPTIONAL, sam-track-id [3] GeneralString OPTIONAL,
sam-challenge-label [4] GeneralString OPTIONAL, sam-challenge-label [4] GeneralString OPTIONAL,
sam-challenge [5] GeneralString OPTIONAL, sam-challenge [5] GeneralString OPTIONAL,
sam-response-prompt [6] GeneralString OPTIONAL, sam-response-prompt [6] GeneralString OPTIONAL,
sam-pk-for-sad [7] EncryptionKey OPTIONAL, sam-pk-for-sad [7] EncryptionKey OPTIONAL,
skipping to change at line 1848 skipping to change at line 1876
heim_general_string *sam_type_name; heim_general_string *sam_type_name;
heim_general_string *sam_track_id; heim_general_string *sam_track_id;
heim_general_string *sam_challenge_label; heim_general_string *sam_challenge_label;
heim_general_string *sam_challenge; heim_general_string *sam_challenge;
heim_general_string *sam_response_prompt; heim_general_string *sam_response_prompt;
EncryptionKey *sam_pk_for_sad; EncryptionKey *sam_pk_for_sad;
krb5int32 sam_nonce; krb5int32 sam_nonce;
krb5int32 sam_etype; krb5int32 sam_etype;
} PA_SAM_CHALLENGE_2_BODY; } PA_SAM_CHALLENGE_2_BODY;
int encode_PA_SAM_CHALLENGE_2_BODY(unsigned char *, size_t, const PA_SAM
_CHALLENGE_2_BODY *, size_t *);
int decode_PA_SAM_CHALLENGE_2_BODY(const unsigned char *, size_t, PA_SAM
_CHALLENGE_2_BODY *, size_t *);
void free_PA_SAM_CHALLENGE_2_BODY (PA_SAM_CHALLENGE_2_BODY *);
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_S
AM_CHALLENGE_2_BODY *);
/* /*
PA-SAM-CHALLENGE-2 ::= SEQUENCE { PA-SAM-CHALLENGE-2 ::= SEQUENCE {
sam-body [0] PA-SAM-CHALLENGE-2-BODY, sam-body [0] PA-SAM-CHALLENGE-2-BODY,
sam-cksum [1] SEQUENCE OF Checksum, sam-cksum [1] SEQUENCE OF Checksum,
..., ...,
} }
*/ */
typedef struct PA_SAM_CHALLENGE_2 { typedef struct PA_SAM_CHALLENGE_2 {
PA_SAM_CHALLENGE_2_BODY sam_body; PA_SAM_CHALLENGE_2_BODY sam_body;
struct { struct PA_SAM_CHALLENGE_2_sam_cksum {
unsigned int len; unsigned int len;
Checksum *val; Checksum *val;
} sam_cksum; } sam_cksum;
} PA_SAM_CHALLENGE_2; } PA_SAM_CHALLENGE_2;
int encode_PA_SAM_CHALLENGE_2(unsigned char *, size_t, const PA_SAM_CHAL
LENGE_2 *, size_t *);
int decode_PA_SAM_CHALLENGE_2(const unsigned char *, size_t, PA_SAM_CHAL
LENGE_2 *, size_t *);
void free_PA_SAM_CHALLENGE_2 (PA_SAM_CHALLENGE_2 *);
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_CHALLEN
GE_2 *);
/* /*
PA-SAM-RESPONSE-2 ::= SEQUENCE { PA-SAM-RESPONSE-2 ::= SEQUENCE {
sam-type [0] krb5int32, sam-type [0] krb5int32,
sam-flags [1] SAMFlags, sam-flags [1] SAMFlags,
sam-track-id [2] GeneralString OPTIONAL, sam-track-id [2] GeneralString OPTIONAL,
sam-enc-nonce-or-sad [3] EncryptedData, sam-enc-nonce-or-sad [3] EncryptedData,
sam-nonce [4] krb5int32, sam-nonce [4] krb5int32,
..., ...,
} }
*/ */
typedef struct PA_SAM_RESPONSE_2 { typedef struct PA_SAM_RESPONSE_2 {
krb5int32 sam_type; krb5int32 sam_type;
SAMFlags sam_flags; SAMFlags sam_flags;
heim_general_string *sam_track_id; heim_general_string *sam_track_id;
EncryptedData sam_enc_nonce_or_sad; EncryptedData sam_enc_nonce_or_sad;
krb5int32 sam_nonce; krb5int32 sam_nonce;
} PA_SAM_RESPONSE_2; } PA_SAM_RESPONSE_2;
int encode_PA_SAM_RESPONSE_2(unsigned char *, size_t, const PA_SAM_RESPO
NSE_2 *, size_t *);
int decode_PA_SAM_RESPONSE_2(const unsigned char *, size_t, PA_SAM_RESPO
NSE_2 *, size_t *);
void free_PA_SAM_RESPONSE_2 (PA_SAM_RESPONSE_2 *);
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 *);
/* /*
PA-ENC-SAM-RESPONSE-ENC ::= SEQUENCE { PA-ENC-SAM-RESPONSE-ENC ::= SEQUENCE {
sam-nonce [0] krb5int32, sam-nonce [0] krb5int32,
sam-sad [1] GeneralString OPTIONAL, sam-sad [1] GeneralString OPTIONAL,
..., ...,
} }
*/ */
typedef struct PA_ENC_SAM_RESPONSE_ENC { typedef struct PA_ENC_SAM_RESPONSE_ENC {
krb5int32 sam_nonce; krb5int32 sam_nonce;
heim_general_string *sam_sad; heim_general_string *sam_sad;
} PA_ENC_SAM_RESPONSE_ENC; } PA_ENC_SAM_RESPONSE_ENC;
int encode_PA_ENC_SAM_RESPONSE_ENC(unsigned char *, size_t, const PA_ENC
_SAM_RESPONSE_ENC *, size_t *);
int decode_PA_ENC_SAM_RESPONSE_ENC(const unsigned char *, size_t, PA_ENC
_SAM_RESPONSE_ENC *, size_t *);
void free_PA_ENC_SAM_RESPONSE_ENC (PA_ENC_SAM_RESPONSE_ENC *);
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_E
NC_SAM_RESPONSE_ENC *);
/* /*
PA-S4U2Self ::= SEQUENCE { PA-S4U2Self ::= SEQUENCE {
name [0] PrincipalName, name [0] PrincipalName,
realm [1] Realm, realm [1] Realm,
cksum [2] Checksum, cksum [2] Checksum,
auth [3] GeneralString, auth [3] GeneralString,
} }
*/ */
typedef struct PA_S4U2Self { typedef struct PA_S4U2Self {
PrincipalName name; PrincipalName name;
Realm realm; Realm realm;
Checksum cksum; Checksum cksum;
heim_general_string auth; heim_general_string auth;
} PA_S4U2Self; } PA_S4U2Self;
int encode_PA_S4U2Self(unsigned char *, size_t, const PA_S4U2Self *, siz ASN1EXP int ASN1CALL decode_PA_S4U2Self(const unsigned char *, size_t, P
e_t *); A_S4U2Self *, size_t *);
int decode_PA_S4U2Self(const unsigned char *, size_t, PA_S4U2Self *, siz ASN1EXP int ASN1CALL encode_PA_S4U2Self(unsigned char *, size_t, const P
e_t *); A_S4U2Self *, size_t *);
void free_PA_S4U2Self (PA_S4U2Self *); ASN1EXP size_t ASN1CALL length_PA_S4U2Self(const PA_S4U2Self *);
size_t length_PA_S4U2Self(const PA_S4U2Self *); ASN1EXP int ASN1CALL copy_PA_S4U2Self (const PA_S4U2Self *, PA_S4U2Self
int copy_PA_S4U2Self (const PA_S4U2Self *, PA_S4U2Self *); *);
ASN1EXP void ASN1CALL free_PA_S4U2Self (PA_S4U2Self *);
/* /*
KRB5SignedPathData ::= SEQUENCE { KRB5SignedPathData ::= SEQUENCE {
client [0] Principal OPTIONAL, client [0] Principal OPTIONAL,
authtime [1] KerberosTime, authtime [1] KerberosTime,
delegated [2] Principals OPTIONAL, delegated [2] Principals OPTIONAL,
method_data [3] METHOD-DATA OPTIONAL, method_data [3] METHOD-DATA OPTIONAL,
} }
*/ */
typedef struct KRB5SignedPathData { typedef struct KRB5SignedPathData {
Principal *client; Principal *client;
KerberosTime authtime; KerberosTime authtime;
Principals *delegated; Principals *delegated;
METHOD_DATA *method_data; METHOD_DATA *method_data;
} KRB5SignedPathData; } KRB5SignedPathData;
int encode_KRB5SignedPathData(unsigned char *, size_t, const KRB5SignedP ASN1EXP int ASN1CALL decode_KRB5SignedPathData(const unsigned char *, si
athData *, size_t *); ze_t, KRB5SignedPathData *, size_t *);
int decode_KRB5SignedPathData(const unsigned char *, size_t, KRB5SignedP ASN1EXP int ASN1CALL encode_KRB5SignedPathData(unsigned char *, size_t,
athData *, size_t *); const KRB5SignedPathData *, size_t *);
void free_KRB5SignedPathData (KRB5SignedPathData *); ASN1EXP size_t ASN1CALL length_KRB5SignedPathData(const KRB5SignedPathData
size_t length_KRB5SignedPathData(const KRB5SignedPathData *); *);
int copy_KRB5SignedPathData (const KRB5SignedPathData *, KRB5SignedPath ASN1EXP int ASN1CALL copy_KRB5SignedPathData (const KRB5SignedPathData
Data *); *, KRB5SignedPathData *);
ASN1EXP void ASN1CALL free_KRB5SignedPathData (KRB5SignedPathData *);
/* /*
KRB5SignedPath ::= SEQUENCE { KRB5SignedPath ::= SEQUENCE {
etype [0] ENCTYPE, etype [0] ENCTYPE,
cksum [1] Checksum, cksum [1] Checksum,
delegated [2] Principals OPTIONAL, delegated [2] Principals OPTIONAL,
method_data [3] METHOD-DATA OPTIONAL, method_data [3] METHOD-DATA OPTIONAL,
} }
*/ */
typedef struct KRB5SignedPath { typedef struct KRB5SignedPath {
ENCTYPE etype; ENCTYPE etype;
Checksum cksum; Checksum cksum;
Principals *delegated; Principals *delegated;
METHOD_DATA *method_data; METHOD_DATA *method_data;
} KRB5SignedPath; } KRB5SignedPath;
int encode_KRB5SignedPath(unsigned char *, size_t, const KRB5SignedPath ASN1EXP int ASN1CALL decode_KRB5SignedPath(const unsigned char *, size_t
*, size_t *); , KRB5SignedPath *, size_t *);
int decode_KRB5SignedPath(const unsigned char *, size_t, KRB5SignedPath ASN1EXP int ASN1CALL encode_KRB5SignedPath(unsigned char *, size_t, cons
*, size_t *); t KRB5SignedPath *, size_t *);
void free_KRB5SignedPath (KRB5SignedPath *); ASN1EXP size_t ASN1CALL length_KRB5SignedPath(const KRB5SignedPath *);
size_t length_KRB5SignedPath(const KRB5SignedPath *); ASN1EXP int ASN1CALL copy_KRB5SignedPath (const KRB5SignedPath *, KRB5S
int copy_KRB5SignedPath (const KRB5SignedPath *, KRB5SignedPath *); ignedPath *);
ASN1EXP void ASN1CALL free_KRB5SignedPath (KRB5SignedPath *);
/* /*
PA-ClientCanonicalizedNames ::= SEQUENCE { PA-ClientCanonicalizedNames ::= SEQUENCE {
requested-name [0] PrincipalName, requested-name [0] PrincipalName,
mapped-name [1] PrincipalName, mapped-name [1] PrincipalName,
} }
*/ */
typedef struct PA_ClientCanonicalizedNames { typedef struct PA_ClientCanonicalizedNames {
PrincipalName requested_name; PrincipalName requested_name;
PrincipalName mapped_name; PrincipalName mapped_name;
} PA_ClientCanonicalizedNames; } PA_ClientCanonicalizedNames;
int encode_PA_ClientCanonicalizedNames(unsigned char *, size_t, const PA ASN1EXP int ASN1CALL decode_PA_ClientCanonicalizedNames(const unsigned c
_ClientCanonicalizedNames *, size_t *); har *, size_t, PA_ClientCanonicalizedNames *, size_t *);
int decode_PA_ClientCanonicalizedNames(const unsigned char *, size_t, PA ASN1EXP int ASN1CALL encode_PA_ClientCanonicalizedNames(unsigned char *,
_ClientCanonicalizedNames *, size_t *); size_t, const PA_ClientCanonicalizedNames *, size_t *);
void free_PA_ClientCanonicalizedNames (PA_ClientCanonicalizedNames *); ASN1EXP size_t ASN1CALL length_PA_ClientCanonicalizedNames(const PA_ClientC
size_t length_PA_ClientCanonicalizedNames(const PA_ClientCanonicalizedNames anonicalizedNames *);
*); ASN1EXP int ASN1CALL copy_PA_ClientCanonicalizedNames (const PA_ClientC
int copy_PA_ClientCanonicalizedNames (const PA_ClientCanonicalizedNames anonicalizedNames *, PA_ClientCanonicalizedNames *);
*, PA_ClientCanonicalizedNames *); ASN1EXP void ASN1CALL free_PA_ClientCanonicalizedNames (PA_ClientCanonic
alizedNames *);
/* /*
PA-ClientCanonicalized ::= SEQUENCE { PA-ClientCanonicalized ::= SEQUENCE {
names [0] PA-ClientCanonicalizedNames, names [0] PA-ClientCanonicalizedNames,
canon-checksum [1] Checksum, canon-checksum [1] Checksum,
} }
*/ */
typedef struct PA_ClientCanonicalized { typedef struct PA_ClientCanonicalized {
PA_ClientCanonicalizedNames names; PA_ClientCanonicalizedNames names;
Checksum canon_checksum; Checksum canon_checksum;
} PA_ClientCanonicalized; } PA_ClientCanonicalized;
int encode_PA_ClientCanonicalized(unsigned char *, size_t, const PA_Clie ASN1EXP int ASN1CALL decode_PA_ClientCanonicalized(const unsigned char *
ntCanonicalized *, size_t *); , size_t, PA_ClientCanonicalized *, size_t *);
int decode_PA_ClientCanonicalized(const unsigned char *, size_t, PA_Clie ASN1EXP int ASN1CALL encode_PA_ClientCanonicalized(unsigned char *, size
ntCanonicalized *, size_t *); _t, const PA_ClientCanonicalized *, size_t *);
void free_PA_ClientCanonicalized (PA_ClientCanonicalized *); ASN1EXP size_t ASN1CALL length_PA_ClientCanonicalized(const PA_ClientCanoni
size_t length_PA_ClientCanonicalized(const PA_ClientCanonicalized *); calized *);
int copy_PA_ClientCanonicalized (const PA_ClientCanonicalized *, PA_Cli ASN1EXP int ASN1CALL copy_PA_ClientCanonicalized (const PA_ClientCanoni
entCanonicalized *); calized *, PA_ClientCanonicalized *);
ASN1EXP void ASN1CALL free_PA_ClientCanonicalized (PA_ClientCanonicalize
d *);
/* /*
AD-LoginAlias ::= SEQUENCE { AD-LoginAlias ::= SEQUENCE {
login-alias [0] PrincipalName, login-alias [0] PrincipalName,
checksum [1] Checksum, checksum [1] Checksum,
} }
*/ */
typedef struct AD_LoginAlias { typedef struct AD_LoginAlias {
PrincipalName login_alias; PrincipalName login_alias;
Checksum checksum; Checksum checksum;
} AD_LoginAlias; } AD_LoginAlias;
int encode_AD_LoginAlias(unsigned char *, size_t, const AD_LoginAlias *, ASN1EXP int ASN1CALL decode_AD_LoginAlias(const unsigned char *, size_t,
size_t *); AD_LoginAlias *, size_t *);
int decode_AD_LoginAlias(const unsigned char *, size_t, AD_LoginAlias *, ASN1EXP int ASN1CALL encode_AD_LoginAlias(unsigned char *, size_t, const
size_t *); AD_LoginAlias *, size_t *);
void free_AD_LoginAlias (AD_LoginAlias *); ASN1EXP size_t ASN1CALL length_AD_LoginAlias(const AD_LoginAlias *);
size_t length_AD_LoginAlias(const AD_LoginAlias *); ASN1EXP int ASN1CALL copy_AD_LoginAlias (const AD_LoginAlias *, AD_Logi
int copy_AD_LoginAlias (const AD_LoginAlias *, AD_LoginAlias *); nAlias *);
ASN1EXP void ASN1CALL free_AD_LoginAlias (AD_LoginAlias *);
/* /*
PA-SvrReferralData ::= SEQUENCE { PA-SvrReferralData ::= SEQUENCE {
referred-name [1] PrincipalName OPTIONAL, referred-name [1] PrincipalName OPTIONAL,
referred-realm [0] Realm, referred-realm [0] Realm,
} }
*/ */
typedef struct PA_SvrReferralData { typedef struct PA_SvrReferralData {
PrincipalName *referred_name; PrincipalName *referred_name;
Realm referred_realm; Realm referred_realm;
} PA_SvrReferralData; } PA_SvrReferralData;
int encode_PA_SvrReferralData(unsigned char *, size_t, const PA_SvrRefer ASN1EXP int ASN1CALL decode_PA_SvrReferralData(const unsigned char *, si
ralData *, size_t *); ze_t, PA_SvrReferralData *, size_t *);
int decode_PA_SvrReferralData(const unsigned char *, size_t, PA_SvrRefer ASN1EXP int ASN1CALL encode_PA_SvrReferralData(unsigned char *, size_t,
ralData *, size_t *); const PA_SvrReferralData *, size_t *);
void free_PA_SvrReferralData (PA_SvrReferralData *); ASN1EXP size_t ASN1CALL length_PA_SvrReferralData(const PA_SvrReferralData
size_t length_PA_SvrReferralData(const PA_SvrReferralData *); *);
int copy_PA_SvrReferralData (const PA_SvrReferralData *, PA_SvrReferral ASN1EXP int ASN1CALL copy_PA_SvrReferralData (const PA_SvrReferralData
Data *); *, PA_SvrReferralData *);
ASN1EXP void ASN1CALL free_PA_SvrReferralData (PA_SvrReferralData *);
/* /*
PA-SERVER-REFERRAL-DATA ::= EncryptedData PA-SERVER-REFERRAL-DATA ::= EncryptedData
*/ */
typedef EncryptedData PA_SERVER_REFERRAL_DATA; typedef EncryptedData PA_SERVER_REFERRAL_DATA;
int encode_PA_SERVER_REFERRAL_DATA(unsigned char *, size_t, const PA_SER ASN1EXP int ASN1CALL decode_PA_SERVER_REFERRAL_DATA(const unsigned char
VER_REFERRAL_DATA *, size_t *); *, size_t, PA_SERVER_REFERRAL_DATA *, size_t *);
int decode_PA_SERVER_REFERRAL_DATA(const unsigned char *, size_t, PA_SER ASN1EXP int ASN1CALL encode_PA_SERVER_REFERRAL_DATA(unsigned char *, siz
VER_REFERRAL_DATA *, size_t *); e_t, const PA_SERVER_REFERRAL_DATA *, size_t *);
void free_PA_SERVER_REFERRAL_DATA (PA_SERVER_REFERRAL_DATA *); ASN1EXP size_t ASN1CALL length_PA_SERVER_REFERRAL_DATA(const PA_SERVER_REFE
size_t length_PA_SERVER_REFERRAL_DATA(const PA_SERVER_REFERRAL_DATA *); RRAL_DATA *);
int copy_PA_SERVER_REFERRAL_DATA (const PA_SERVER_REFERRAL_DATA *, PA_S ASN1EXP int ASN1CALL copy_PA_SERVER_REFERRAL_DATA (const PA_SERVER_REFE
ERVER_REFERRAL_DATA *); RRAL_DATA *, PA_SERVER_REFERRAL_DATA *);
ASN1EXP void ASN1CALL free_PA_SERVER_REFERRAL_DATA (PA_SERVER_REFERRAL_D
ATA *);
/* /*
PA-ServerReferralData ::= SEQUENCE { PA-ServerReferralData ::= SEQUENCE {
referred-realm [0] Realm OPTIONAL, referred-realm [0] Realm OPTIONAL,
true-principal-name [1] PrincipalName OPTIONAL, true-principal-name [1] PrincipalName OPTIONAL,
requested-principal-name [2] PrincipalName OPTIONAL, requested-principal-name [2] PrincipalName OPTIONAL,
referral-valid-until [3] KerberosTime OPTIONAL, referral-valid-until [3] KerberosTime OPTIONAL,
..., ...,
} }
*/ */
typedef struct PA_ServerReferralData { typedef struct PA_ServerReferralData {
Realm *referred_realm; Realm *referred_realm;
PrincipalName *true_principal_name; PrincipalName *true_principal_name;
PrincipalName *requested_principal_name; PrincipalName *requested_principal_name;
KerberosTime *referral_valid_until; KerberosTime *referral_valid_until;
} PA_ServerReferralData; } PA_ServerReferralData;
int encode_PA_ServerReferralData(unsigned char *, size_t, const PA_Serve ASN1EXP int ASN1CALL decode_PA_ServerReferralData(const unsigned char *,
rReferralData *, size_t *); size_t, PA_ServerReferralData *, size_t *);
int decode_PA_ServerReferralData(const unsigned char *, size_t, PA_Serve ASN1EXP int ASN1CALL encode_PA_ServerReferralData(unsigned char *, size_
rReferralData *, size_t *); t, const PA_ServerReferralData *, size_t *);
void free_PA_ServerReferralData (PA_ServerReferralData *); ASN1EXP size_t ASN1CALL length_PA_ServerReferralData(const PA_ServerReferra
size_t length_PA_ServerReferralData(const PA_ServerReferralData *); lData *);
int copy_PA_ServerReferralData (const PA_ServerReferralData *, PA_Serve ASN1EXP int ASN1CALL copy_PA_ServerReferralData (const PA_ServerReferra
rReferralData *); lData *, PA_ServerReferralData *);
ASN1EXP void ASN1CALL free_PA_ServerReferralData (PA_ServerReferralData
*);
/* /*
FastOptions ::= BIT STRING { FastOptions ::= BIT STRING {
reserved(0), reserved(0),
hide-client-names(1), hide-client-names(1),
kdc-follow--referrals(16) kdc-follow--referrals(16)
} }
*/ */
typedef struct FastOptions { typedef struct FastOptions {
unsigned int reserved:1; unsigned int reserved:1;
unsigned int hide_client_names:1; unsigned int hide_client_names:1;
unsigned int _unused2:1;
unsigned int _unused3: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 kdc_follow__referrals:1; unsigned int kdc_follow__referrals: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;
} FastOptions; } FastOptions;
int encode_FastOptions(unsigned char *, size_t, const FastOptions *, siz
e_t *);
int decode_FastOptions(const unsigned char *, size_t, FastOptions *, siz
e_t *);
void free_FastOptions (FastOptions *);
size_t length_FastOptions(const FastOptions *);
int copy_FastOptions (const FastOptions *, FastOptions *);
unsigned FastOptions2int(FastOptions); unsigned FastOptions2int(FastOptions);
FastOptions int2FastOptions(unsigned); FastOptions int2FastOptions(unsigned);
const struct units * asn1_FastOptions_units(void); const struct units * asn1_FastOptions_units(void);
/* /*
KrbFastReq ::= SEQUENCE { KrbFastReq ::= SEQUENCE {
fast-options [0] FastOptions, fast-options [0] FastOptions,
padata [1] SEQUENCE OF PA-DATA, padata [1] SEQUENCE OF PA-DATA,
req-body [2] KDC-REQ-BODY, req-body [2] KDC-REQ-BODY,
..., ...,
} }
*/ */
typedef struct KrbFastReq { typedef struct KrbFastReq {
FastOptions fast_options; FastOptions fast_options;
struct { struct KrbFastReq_padata {
unsigned int len; unsigned int len;
PA_DATA *val; PA_DATA *val;
} padata; } padata;
KDC_REQ_BODY req_body; KDC_REQ_BODY req_body;
} KrbFastReq; } KrbFastReq;
int encode_KrbFastReq(unsigned char *, size_t, const KrbFastReq *, size_
t *);
int decode_KrbFastReq(const unsigned char *, size_t, KrbFastReq *, size_
t *);
void free_KrbFastReq (KrbFastReq *);
size_t length_KrbFastReq(const KrbFastReq *);
int copy_KrbFastReq (const KrbFastReq *, KrbFastReq *);
/* /*
KrbFastArmor ::= SEQUENCE { KrbFastArmor ::= SEQUENCE {
armor-type [0] krb5int32, armor-type [0] krb5int32,
armor-value [1] OCTET STRING, armor-value [1] OCTET STRING,
..., ...,
} }
*/ */
typedef struct KrbFastArmor { typedef struct KrbFastArmor {
krb5int32 armor_type; krb5int32 armor_type;
heim_octet_string armor_value; heim_octet_string armor_value;
} KrbFastArmor; } KrbFastArmor;
int encode_KrbFastArmor(unsigned char *, size_t, const KrbFastArmor *, s
ize_t *);
int decode_KrbFastArmor(const unsigned char *, size_t, KrbFastArmor *, s
ize_t *);
void free_KrbFastArmor (KrbFastArmor *);
size_t length_KrbFastArmor(const KrbFastArmor *);
int copy_KrbFastArmor (const KrbFastArmor *, KrbFastArmor *);
/* /*
KrbFastArmoredReq ::= SEQUENCE { KrbFastArmoredReq ::= SEQUENCE {
armor [0] KrbFastArmor OPTIONAL, armor [0] KrbFastArmor OPTIONAL,
req-checksum [1] Checksum, req-checksum [1] Checksum,
enc-fast-req [2] EncryptedData, enc-fast-req [2] EncryptedData,
} }
*/ */
typedef struct KrbFastArmoredReq { typedef struct KrbFastArmoredReq {
KrbFastArmor *armor; KrbFastArmor *armor;
Checksum req_checksum; Checksum req_checksum;
EncryptedData enc_fast_req; EncryptedData enc_fast_req;
} KrbFastArmoredReq; } KrbFastArmoredReq;
int encode_KrbFastArmoredReq(unsigned char *, size_t, const KrbFastArmor
edReq *, size_t *);
int decode_KrbFastArmoredReq(const unsigned char *, size_t, KrbFastArmor
edReq *, size_t *);
void free_KrbFastArmoredReq (KrbFastArmoredReq *);
size_t length_KrbFastArmoredReq(const KrbFastArmoredReq *);
int copy_KrbFastArmoredReq (const KrbFastArmoredReq *, KrbFastArmoredRe
q *);
/* /*
PA-FX-FAST-REQUEST ::= CHOICE { PA-FX-FAST-REQUEST ::= CHOICE {
armored-data [0] KrbFastArmoredReq, armored-data [0] KrbFastArmoredReq,
..., ...,
} }
*/ */
typedef struct PA_FX_FAST_REQUEST { typedef struct PA_FX_FAST_REQUEST {
enum { enum {
choice_PA_FX_FAST_REQUEST_asn1_ellipsis = 0, choice_PA_FX_FAST_REQUEST_asn1_ellipsis = 0,
choice_PA_FX_FAST_REQUEST_armored_data choice_PA_FX_FAST_REQUEST_armored_data
/* ... */ /* ... */
} element; } element;
union { union {
KrbFastArmoredReq armored_data; KrbFastArmoredReq armored_data;
heim_octet_string asn1_ellipsis; heim_octet_string asn1_ellipsis;
} u; } u;
} PA_FX_FAST_REQUEST; } PA_FX_FAST_REQUEST;
int encode_PA_FX_FAST_REQUEST(unsigned char *, size_t, const PA_FX_FAST_
REQUEST *, size_t *);
int decode_PA_FX_FAST_REQUEST(const unsigned char *, size_t, PA_FX_FAST_
REQUEST *, size_t *);
void free_PA_FX_FAST_REQUEST (PA_FX_FAST_REQUEST *);
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_REQ
UEST *);
/* /*
KrbFastFinished ::= SEQUENCE { KrbFastFinished ::= SEQUENCE {
timestamp [0] KerberosTime, timestamp [0] KerberosTime,
usec [1] krb5int32, usec [1] krb5int32,
crealm [2] Realm, crealm [2] Realm,
cname [3] PrincipalName, cname [3] PrincipalName,
checksum [4] Checksum, checksum [4] Checksum,
ticket-checksum [5] Checksum, ticket-checksum [5] Checksum,
..., ...,
} }
skipping to change at line 2225 skipping to change at line 2228
typedef struct KrbFastFinished { typedef struct KrbFastFinished {
KerberosTime timestamp; KerberosTime timestamp;
krb5int32 usec; krb5int32 usec;
Realm crealm; Realm crealm;
PrincipalName cname; PrincipalName cname;
Checksum checksum; Checksum checksum;
Checksum ticket_checksum; Checksum ticket_checksum;
} KrbFastFinished; } KrbFastFinished;
int encode_KrbFastFinished(unsigned char *, size_t, const KrbFastFinishe
d *, size_t *);
int decode_KrbFastFinished(const unsigned char *, size_t, KrbFastFinishe
d *, size_t *);
void free_KrbFastFinished (KrbFastFinished *);
size_t length_KrbFastFinished(const KrbFastFinished *);
int copy_KrbFastFinished (const KrbFastFinished *, KrbFastFinished *);
/* /*
KrbFastResponse ::= SEQUENCE { KrbFastResponse ::= SEQUENCE {
padata [0] SEQUENCE OF PA-DATA, padata [0] SEQUENCE OF PA-DATA,
rep-key [1] EncryptionKey OPTIONAL, rep-key [1] EncryptionKey OPTIONAL,
finished [2] KrbFastFinished OPTIONAL, finished [2] KrbFastFinished OPTIONAL,
..., ...,
} }
*/ */
typedef struct KrbFastResponse { typedef struct KrbFastResponse {
struct { struct KrbFastResponse_padata {
unsigned int len; unsigned int len;
PA_DATA *val; PA_DATA *val;
} padata; } padata;
EncryptionKey *rep_key; EncryptionKey *rep_key;
KrbFastFinished *finished; KrbFastFinished *finished;
} KrbFastResponse; } KrbFastResponse;
int encode_KrbFastResponse(unsigned char *, size_t, const KrbFastRespons
e *, size_t *);
int decode_KrbFastResponse(const unsigned char *, size_t, KrbFastRespons
e *, size_t *);
void free_KrbFastResponse (KrbFastResponse *);
size_t length_KrbFastResponse(const KrbFastResponse *);
int copy_KrbFastResponse (const KrbFastResponse *, KrbFastResponse *);
/* /*
KrbFastArmoredRep ::= SEQUENCE { KrbFastArmoredRep ::= SEQUENCE {
enc-fast-rep [0] EncryptedData, enc-fast-rep [0] EncryptedData,
..., ...,
} }
*/ */
typedef struct KrbFastArmoredRep { typedef struct KrbFastArmoredRep {
EncryptedData enc_fast_rep; EncryptedData enc_fast_rep;
} KrbFastArmoredRep; } KrbFastArmoredRep;
int encode_KrbFastArmoredRep(unsigned char *, size_t, const KrbFastArmor
edRep *, size_t *);
int decode_KrbFastArmoredRep(const unsigned char *, size_t, KrbFastArmor
edRep *, size_t *);
void free_KrbFastArmoredRep (KrbFastArmoredRep *);
size_t length_KrbFastArmoredRep(const KrbFastArmoredRep *);
int copy_KrbFastArmoredRep (const KrbFastArmoredRep *, KrbFastArmoredRe
p *);
/* /*
PA-FX-FAST-REPLY ::= CHOICE { PA-FX-FAST-REPLY ::= CHOICE {
armored-data [0] KrbFastArmoredRep, armored-data [0] KrbFastArmoredRep,
..., ...,
} }
*/ */
typedef struct PA_FX_FAST_REPLY { typedef struct PA_FX_FAST_REPLY {
enum { enum {
choice_PA_FX_FAST_REPLY_asn1_ellipsis = 0, choice_PA_FX_FAST_REPLY_asn1_ellipsis = 0,
choice_PA_FX_FAST_REPLY_armored_data choice_PA_FX_FAST_REPLY_armored_data
/* ... */ /* ... */
} element; } element;
union { union {
KrbFastArmoredRep armored_data; KrbFastArmoredRep armored_data;
heim_octet_string asn1_ellipsis; heim_octet_string asn1_ellipsis;
} u; } u;
} PA_FX_FAST_REPLY; } PA_FX_FAST_REPLY;
int encode_PA_FX_FAST_REPLY(unsigned char *, size_t, const PA_FX_FAST_RE
PLY *, size_t *);
int decode_PA_FX_FAST_REPLY(const unsigned char *, size_t, PA_FX_FAST_RE
PLY *, size_t *);
void free_PA_FX_FAST_REPLY (PA_FX_FAST_REPLY *);
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 *
);
#endif /* __krb5_asn1_h__ */ #endif /* __krb5_asn1_h__ */
 End of changes. 121 change blocks. 
700 lines changed or deleted 700 lines changed or added


 kx509_asn1.h   kx509_asn1.h 
skipping to change at line 28 skipping to change at line 28
typedef struct heim_octet_string { typedef struct heim_octet_string {
size_t length; size_t length;
void *data; void *data;
} heim_octet_string; } heim_octet_string;
typedef char *heim_general_string; typedef char *heim_general_string;
typedef char *heim_utf8_string; typedef char *heim_utf8_string;
typedef char *heim_printable_string; typedef struct heim_octet_string heim_printable_string;
typedef char *heim_ia5_string; typedef struct heim_octet_string heim_ia5_string;
typedef struct heim_bmp_string { typedef struct heim_bmp_string {
size_t length; size_t length;
uint16_t *data; uint16_t *data;
} heim_bmp_string; } heim_bmp_string;
typedef struct heim_universal_string { typedef struct heim_universal_string {
size_t length; size_t length;
uint32_t *data; uint32_t *data;
} heim_universal_string; } heim_universal_string;
skipping to change at line 73 skipping to change at line 73
} else { \ } else { \
(R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
(S), (L)); \ (S), (L)); \
if((R) != 0) { \ if((R) != 0) { \
free((B)); \ free((B)); \
(B) = NULL; \ (B) = NULL; \
} \ } \
} \ } \
} while (0) } while (0)
#ifdef _WIN32
#ifndef ASN1_LIB
#define ASN1EXP __declspec(dllimport)
#else
#define ASN1EXP
#endif
#define ASN1CALL __stdcall
#else
#define ASN1EXP
#define ASN1CALL
#endif
struct units; struct units;
#endif #endif
/* /*
KX509-ERROR-CODE ::= INTEGER { KX509-ERROR-CODE ::= INTEGER {
KX509_STATUS_GOOD(0), KX509_STATUS_GOOD(0),
KX509_STATUS_CLIENT_BAD(1), KX509_STATUS_CLIENT_BAD(1),
KX509_STATUS_CLIENT_FIX(2), KX509_STATUS_CLIENT_FIX(2),
KX509_STATUS_CLIENT_TEMP(3), KX509_STATUS_CLIENT_TEMP(3),
skipping to change at line 99 skipping to change at line 110
typedef enum KX509_ERROR_CODE { typedef enum KX509_ERROR_CODE {
KX509_STATUS_GOOD = 0, KX509_STATUS_GOOD = 0,
KX509_STATUS_CLIENT_BAD = 1, KX509_STATUS_CLIENT_BAD = 1,
KX509_STATUS_CLIENT_FIX = 2, KX509_STATUS_CLIENT_FIX = 2,
KX509_STATUS_CLIENT_TEMP = 3, KX509_STATUS_CLIENT_TEMP = 3,
KX509_STATUS_SERVER_BAD = 4, KX509_STATUS_SERVER_BAD = 4,
KX509_STATUS_SERVER_TEMP = 5, KX509_STATUS_SERVER_TEMP = 5,
KX509_STATUS_SERVER_KEY = 7 KX509_STATUS_SERVER_KEY = 7
} KX509_ERROR_CODE; } KX509_ERROR_CODE;
int encode_KX509_ERROR_CODE(unsigned char *, size_t, const KX509_ERROR_C ASN1EXP int ASN1CALL decode_KX509_ERROR_CODE(const unsigned char *, size
ODE *, size_t *); _t, KX509_ERROR_CODE *, size_t *);
int decode_KX509_ERROR_CODE(const unsigned char *, size_t, KX509_ERROR_C ASN1EXP int ASN1CALL encode_KX509_ERROR_CODE(unsigned char *, size_t, co
ODE *, size_t *); nst KX509_ERROR_CODE *, size_t *);
void free_KX509_ERROR_CODE (KX509_ERROR_CODE *); ASN1EXP size_t ASN1CALL length_KX509_ERROR_CODE(const KX509_ERROR_CODE *);
size_t length_KX509_ERROR_CODE(const KX509_ERROR_CODE *); ASN1EXP int ASN1CALL copy_KX509_ERROR_CODE (const KX509_ERROR_CODE *, K
int copy_KX509_ERROR_CODE (const KX509_ERROR_CODE *, KX509_ERROR_CODE * X509_ERROR_CODE *);
); ASN1EXP void ASN1CALL free_KX509_ERROR_CODE (KX509_ERROR_CODE *);
/* /*
Kx509Request ::= SEQUENCE { Kx509Request ::= SEQUENCE {
authenticator OCTET STRING, authenticator OCTET STRING,
pk-hash OCTET STRING, pk-hash OCTET STRING,
pk-key OCTET STRING, pk-key OCTET STRING,
} }
*/ */
typedef struct Kx509Request { typedef struct Kx509Request {
heim_octet_string authenticator; heim_octet_string authenticator;
heim_octet_string pk_hash; heim_octet_string pk_hash;
heim_octet_string pk_key; heim_octet_string pk_key;
} Kx509Request; } Kx509Request;
int encode_Kx509Request(unsigned char *, size_t, const Kx509Request *, s ASN1EXP int ASN1CALL decode_Kx509Request(const unsigned char *, size_t,
ize_t *); Kx509Request *, size_t *);
int decode_Kx509Request(const unsigned char *, size_t, Kx509Request *, s ASN1EXP int ASN1CALL encode_Kx509Request(unsigned char *, size_t, const
ize_t *); Kx509Request *, size_t *);
void free_Kx509Request (Kx509Request *); ASN1EXP size_t ASN1CALL length_Kx509Request(const Kx509Request *);
size_t length_Kx509Request(const Kx509Request *); ASN1EXP int ASN1CALL copy_Kx509Request (const Kx509Request *, Kx509Requ
int copy_Kx509Request (const Kx509Request *, Kx509Request *); est *);
ASN1EXP void ASN1CALL free_Kx509Request (Kx509Request *);
/* /*
Kx509Response ::= SEQUENCE { Kx509Response ::= SEQUENCE {
error-code [0] INTEGER (-2147483648..2147483647) OPTIONAL, error-code [0] INTEGER (-2147483648..2147483647) OPTIONAL,
hash [1] OCTET STRING OPTIONAL, hash [1] OCTET STRING OPTIONAL,
certificate [2] OCTET STRING OPTIONAL, certificate [2] OCTET STRING OPTIONAL,
e-text [3] VisibleString OPTIONAL, e-text [3] VisibleString OPTIONAL,
} }
*/ */
typedef struct Kx509Response { typedef struct Kx509Response {
int *error_code; int *error_code;
heim_octet_string *hash; heim_octet_string *hash;
heim_octet_string *certificate; heim_octet_string *certificate;
heim_visible_string *e_text; heim_visible_string *e_text;
} Kx509Response; } Kx509Response;
int encode_Kx509Response(unsigned char *, size_t, const Kx509Response *, ASN1EXP int ASN1CALL decode_Kx509Response(const unsigned char *, size_t,
size_t *); Kx509Response *, size_t *);
int decode_Kx509Response(const unsigned char *, size_t, Kx509Response *, ASN1EXP int ASN1CALL encode_Kx509Response(unsigned char *, size_t, const
size_t *); Kx509Response *, size_t *);
void free_Kx509Response (Kx509Response *); ASN1EXP size_t ASN1CALL length_Kx509Response(const Kx509Response *);
size_t length_Kx509Response(const Kx509Response *); ASN1EXP int ASN1CALL copy_Kx509Response (const Kx509Response *, Kx509Re
int copy_Kx509Response (const Kx509Response *, Kx509Response *); sponse *);
ASN1EXP void ASN1CALL free_Kx509Response (Kx509Response *);
#endif /* __kx509_asn1_h__ */ #endif /* __kx509_asn1_h__ */
 End of changes. 6 change blocks. 
24 lines changed or deleted 37 lines changed or added


 parse_bytes.h   parse_bytes.h 
skipping to change at line 41 skipping to change at line 41
* SUCH DAMAGE. * SUCH DAMAGE.
*/ */
/* $Id$ */ /* $Id$ */
#ifndef __PARSE_BYTES_H__ #ifndef __PARSE_BYTES_H__
#define __PARSE_BYTES_H__ #define __PARSE_BYTES_H__
#ifndef ROKEN_LIB_FUNCTION #ifndef ROKEN_LIB_FUNCTION
#ifdef _WIN32 #ifdef _WIN32
#define ROKEN_LIB_FUNCTION _stdcall #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL __cdecl
#else #else
#define ROKEN_LIB_FUNCTION #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL
#endif #endif
#endif #endif
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
parse_bytes (const char *s, const char *def_unit); parse_bytes (const char *s, const char *def_unit);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
unparse_bytes (int t, char *s, size_t len); unparse_bytes (int t, char *s, size_t len);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
unparse_bytes_short (int t, char *s, size_t len); unparse_bytes_short (int t, char *s, size_t len);
#endif /* __PARSE_BYTES_H__ */ #endif /* __PARSE_BYTES_H__ */
 End of changes. 5 change blocks. 
4 lines changed or deleted 6 lines changed or added


 parse_time.h   parse_time.h 
skipping to change at line 41 skipping to change at line 41
* SUCH DAMAGE. * SUCH DAMAGE.
*/ */
/* $Id$ */ /* $Id$ */
#ifndef __PARSE_TIME_H__ #ifndef __PARSE_TIME_H__
#define __PARSE_TIME_H__ #define __PARSE_TIME_H__
#ifndef ROKEN_LIB_FUNCTION #ifndef ROKEN_LIB_FUNCTION
#ifdef _WIN32 #ifdef _WIN32
#define ROKEN_LIB_FUNCTION _stdcall #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL __cdecl
#else #else
#define ROKEN_LIB_FUNCTION #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL
#endif #endif
#endif #endif
int ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
parse_time (const char *s, const char *def_unit); parse_time (const char *s, const char *def_unit);
size_t ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL
unparse_time (int t, char *s, size_t len); unparse_time (int t, char *s, size_t len);
size_t ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL
unparse_time_approx (int t, char *s, size_t len); unparse_time_approx (int t, char *s, size_t len);
void ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
print_time_table (FILE *f); print_time_table (FILE *f);
#endif /* __PARSE_TIME_H__ */ #endif /* __PARSE_TIME_H__ */
 End of changes. 6 change blocks. 
5 lines changed or deleted 7 lines changed or added


 parse_units.h   parse_units.h 
skipping to change at line 44 skipping to change at line 44
/* $Id$ */ /* $Id$ */
#ifndef __PARSE_UNITS_H__ #ifndef __PARSE_UNITS_H__
#define __PARSE_UNITS_H__ #define __PARSE_UNITS_H__
#include <stdio.h> #include <stdio.h>
#include <stddef.h> #include <stddef.h>
#ifndef ROKEN_LIB_FUNCTION #ifndef ROKEN_LIB_FUNCTION
#ifdef _WIN32 #ifdef _WIN32
#define ROKEN_LIB_FUNCTION _stdcall #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL __cdecl
#else #else
#define ROKEN_LIB_FUNCTION #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL
#endif #endif
#endif #endif
struct units { struct units {
const char *name; const char *name;
unsigned mult; unsigned mult;
}; };
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
parse_units (const char *s, const struct units *units, parse_units (const char *s, const struct units *units,
const char *def_unit); const char *def_unit);
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
print_units_table (const struct units *units, FILE *f); print_units_table (const struct units *units, FILE *f);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
parse_flags (const char *s, const struct units *units, parse_flags (const char *s, const struct units *units,
int orig); int orig);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
unparse_units (int num, const struct units *units, char *s, size_t len); unparse_units (int num, const struct units *units, char *s, size_t len);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
unparse_units_approx (int num, const struct units *units, char *s, unparse_units_approx (int num, const struct units *units, char *s,
size_t len); size_t len);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
unparse_flags (int num, const struct units *units, char *s, size_t len); unparse_flags (int num, const struct units *units, char *s, size_t len);
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
print_flags_table (const struct units *units, FILE *f); print_flags_table (const struct units *units, FILE *f);
#endif /* __PARSE_UNITS_H__ */ #endif /* __PARSE_UNITS_H__ */
 End of changes. 9 change blocks. 
8 lines changed or deleted 10 lines changed or added


 pkcs12_asn1.h   pkcs12_asn1.h 
skipping to change at line 28 skipping to change at line 28
typedef struct heim_octet_string { typedef struct heim_octet_string {
size_t length; size_t length;
void *data; void *data;
} heim_octet_string; } heim_octet_string;
typedef char *heim_general_string; typedef char *heim_general_string;
typedef char *heim_utf8_string; typedef char *heim_utf8_string;
typedef char *heim_printable_string; typedef struct heim_octet_string heim_printable_string;
typedef char *heim_ia5_string; typedef struct heim_octet_string heim_ia5_string;
typedef struct heim_bmp_string { typedef struct heim_bmp_string {
size_t length; size_t length;
uint16_t *data; uint16_t *data;
} heim_bmp_string; } heim_bmp_string;
typedef struct heim_universal_string { typedef struct heim_universal_string {
size_t length; size_t length;
uint32_t *data; uint32_t *data;
} heim_universal_string; } heim_universal_string;
skipping to change at line 73 skipping to change at line 73
} else { \ } else { \
(R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
(S), (L)); \ (S), (L)); \
if((R) != 0) { \ if((R) != 0) { \
free((B)); \ free((B)); \
(B) = NULL; \ (B) = NULL; \
} \ } \
} \ } \
} while (0) } while (0)
#ifdef _WIN32
#ifndef ASN1_LIB
#define ASN1EXP __declspec(dllimport)
#else
#define ASN1EXP
#endif
#define ASN1CALL __stdcall
#else
#define ASN1EXP
#define ASN1CALL
#endif
struct units; struct units;
#endif #endif
#include <cms_asn1.h> #include <cms_asn1.h>
#include <rfc2459_asn1.h> #include <rfc2459_asn1.h>
#include <heim_asn1.h> #include <heim_asn1.h>
/* OBJECT IDENTIFIER id-pkcs-12 ::= { iso(1) member-body(2) us(840) rsadsi( 113549) pkcs(1) pkcs-12(12) } */ /* OBJECT IDENTIFIER id-pkcs-12 ::= { iso(1) member-body(2) us(840) rsadsi( 113549) pkcs(1) pkcs-12(12) } */
const heim_oid *oid_id_pkcs_12(void);
extern const heim_oid asn1_oid_id_pkcs_12; extern const heim_oid asn1_oid_id_pkcs_12;
#define ASN1_OID_ID_PKCS_12 (&asn1_oid_id_pkcs_12)
/* OBJECT IDENTIFIER id-pkcs-12PbeIds ::= { iso(1) member-body(2) us(840) r sadsi(113549) pkcs(1) pkcs-12(12) label-less(1) } */ /* OBJECT IDENTIFIER id-pkcs-12PbeIds ::= { iso(1) member-body(2) us(840) r sadsi(113549) pkcs(1) pkcs-12(12) label-less(1) } */
const heim_oid *oid_id_pkcs_12PbeIds(void);
extern const heim_oid asn1_oid_id_pkcs_12PbeIds; extern const heim_oid asn1_oid_id_pkcs_12PbeIds;
#define ASN1_OID_ID_PKCS_12PBEIDS (&asn1_oid_id_pkcs_12PbeIds)
/* OBJECT IDENTIFIER id-pbeWithSHAAnd128BitRC4 ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) label-less(1) } */ /* OBJECT IDENTIFIER id-pbeWithSHAAnd128BitRC4 ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) label-less(1) } */
const heim_oid *oid_id_pbeWithSHAAnd128BitRC4(void);
extern const heim_oid asn1_oid_id_pbeWithSHAAnd128BitRC4; extern const heim_oid asn1_oid_id_pbeWithSHAAnd128BitRC4;
#define ASN1_OID_ID_PBEWITHSHAAND128BITRC4 (&asn1_oid_id_pbeWithSHAAnd128Bi tRC4)
/* OBJECT IDENTIFIER id-pbeWithSHAAnd40BitRC4 ::= { iso(1) member-body(2) u s(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) label-less(2) } */ /* OBJECT IDENTIFIER id-pbeWithSHAAnd40BitRC4 ::= { iso(1) member-body(2) u s(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) label-less(2) } */
const heim_oid *oid_id_pbeWithSHAAnd40BitRC4(void);
extern const heim_oid asn1_oid_id_pbeWithSHAAnd40BitRC4; extern const heim_oid asn1_oid_id_pbeWithSHAAnd40BitRC4;
#define ASN1_OID_ID_PBEWITHSHAAND40BITRC4 (&asn1_oid_id_pbeWithSHAAnd40BitR C4)
/* OBJECT IDENTIFIER id-pbeWithSHAAnd3-KeyTripleDES-CBC ::= { iso(1) member -body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) label-les s(3) } */ /* OBJECT IDENTIFIER id-pbeWithSHAAnd3-KeyTripleDES-CBC ::= { iso(1) member -body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) label-les s(3) } */
const heim_oid *oid_id_pbeWithSHAAnd3_KeyTripleDES_CBC(void);
extern const heim_oid asn1_oid_id_pbeWithSHAAnd3_KeyTripleDES_CBC; extern const heim_oid asn1_oid_id_pbeWithSHAAnd3_KeyTripleDES_CBC;
#define ASN1_OID_ID_PBEWITHSHAAND3_KEYTRIPLEDES_CBC (&asn1_oid_id_pbeWithSH AAnd3_KeyTripleDES_CBC)
/* OBJECT IDENTIFIER id-pbeWithSHAAnd2-KeyTripleDES-CBC ::= { iso(1) member -body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) label-les s(4) } */ /* OBJECT IDENTIFIER id-pbeWithSHAAnd2-KeyTripleDES-CBC ::= { iso(1) member -body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) label-les s(4) } */
const heim_oid *oid_id_pbeWithSHAAnd2_KeyTripleDES_CBC(void);
extern const heim_oid asn1_oid_id_pbeWithSHAAnd2_KeyTripleDES_CBC; extern const heim_oid asn1_oid_id_pbeWithSHAAnd2_KeyTripleDES_CBC;
#define ASN1_OID_ID_PBEWITHSHAAND2_KEYTRIPLEDES_CBC (&asn1_oid_id_pbeWithSH AAnd2_KeyTripleDES_CBC)
/* OBJECT IDENTIFIER id-pbeWithSHAAnd128BitRC2-CBC ::= { iso(1) member-body (2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) label-less(5) } */ /* OBJECT IDENTIFIER id-pbeWithSHAAnd128BitRC2-CBC ::= { iso(1) member-body (2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) label-less(5) } */
const heim_oid *oid_id_pbeWithSHAAnd128BitRC2_CBC(void);
extern const heim_oid asn1_oid_id_pbeWithSHAAnd128BitRC2_CBC; extern const heim_oid asn1_oid_id_pbeWithSHAAnd128BitRC2_CBC;
#define ASN1_OID_ID_PBEWITHSHAAND128BITRC2_CBC (&asn1_oid_id_pbeWithSHAAnd1 28BitRC2_CBC)
/* OBJECT IDENTIFIER id-pbewithSHAAnd40BitRC2-CBC ::= { iso(1) member-body( 2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) label-less(6) } */ /* OBJECT IDENTIFIER id-pbewithSHAAnd40BitRC2-CBC ::= { iso(1) member-body( 2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) label-less(6) } */
const heim_oid *oid_id_pbewithSHAAnd40BitRC2_CBC(void);
extern const heim_oid asn1_oid_id_pbewithSHAAnd40BitRC2_CBC; extern const heim_oid asn1_oid_id_pbewithSHAAnd40BitRC2_CBC;
#define ASN1_OID_ID_PBEWITHSHAAND40BITRC2_CBC (&asn1_oid_id_pbewithSHAAnd40 BitRC2_CBC)
/* OBJECT IDENTIFIER id-pkcs12-bagtypes ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) } */ /* OBJECT IDENTIFIER id-pkcs12-bagtypes ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) } */
const heim_oid *oid_id_pkcs12_bagtypes(void);
extern const heim_oid asn1_oid_id_pkcs12_bagtypes; extern const heim_oid asn1_oid_id_pkcs12_bagtypes;
#define ASN1_OID_ID_PKCS12_BAGTYPES (&asn1_oid_id_pkcs12_bagtypes)
/* OBJECT IDENTIFIER id-pkcs12-keyBag ::= { iso(1) member-body(2) us(840) r sadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) label-less(1 ) } */ /* OBJECT IDENTIFIER id-pkcs12-keyBag ::= { iso(1) member-body(2) us(840) r sadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) label-less(1 ) } */
const heim_oid *oid_id_pkcs12_keyBag(void);
extern const heim_oid asn1_oid_id_pkcs12_keyBag; extern const heim_oid asn1_oid_id_pkcs12_keyBag;
#define ASN1_OID_ID_PKCS12_KEYBAG (&asn1_oid_id_pkcs12_keyBag)
/* OBJECT IDENTIFIER id-pkcs12-pkcs8ShroudedKeyBag ::= { iso(1) member-body (2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) label-less(2) } */ /* OBJECT IDENTIFIER id-pkcs12-pkcs8ShroudedKeyBag ::= { iso(1) member-body (2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) label-less(2) } */
const heim_oid *oid_id_pkcs12_pkcs8ShroudedKeyBag(void);
extern const heim_oid asn1_oid_id_pkcs12_pkcs8ShroudedKeyBag; extern const heim_oid asn1_oid_id_pkcs12_pkcs8ShroudedKeyBag;
#define ASN1_OID_ID_PKCS12_PKCS8SHROUDEDKEYBAG (&asn1_oid_id_pkcs12_pkcs8Sh roudedKeyBag)
/* OBJECT IDENTIFIER id-pkcs12-certBag ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) label-less( 3) } */ /* OBJECT IDENTIFIER id-pkcs12-certBag ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) label-less( 3) } */
const heim_oid *oid_id_pkcs12_certBag(void);
extern const heim_oid asn1_oid_id_pkcs12_certBag; extern const heim_oid asn1_oid_id_pkcs12_certBag;
#define ASN1_OID_ID_PKCS12_CERTBAG (&asn1_oid_id_pkcs12_certBag)
/* OBJECT IDENTIFIER id-pkcs12-crlBag ::= { iso(1) member-body(2) us(840) r sadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) label-less(4 ) } */ /* OBJECT IDENTIFIER id-pkcs12-crlBag ::= { iso(1) member-body(2) us(840) r sadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) label-less(4 ) } */
const heim_oid *oid_id_pkcs12_crlBag(void);
extern const heim_oid asn1_oid_id_pkcs12_crlBag; extern const heim_oid asn1_oid_id_pkcs12_crlBag;
#define ASN1_OID_ID_PKCS12_CRLBAG (&asn1_oid_id_pkcs12_crlBag)
/* OBJECT IDENTIFIER id-pkcs12-secretBag ::= { iso(1) member-body(2) us(840 ) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) label-les s(5) } */ /* OBJECT IDENTIFIER id-pkcs12-secretBag ::= { iso(1) member-body(2) us(840 ) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) label-les s(5) } */
const heim_oid *oid_id_pkcs12_secretBag(void);
extern const heim_oid asn1_oid_id_pkcs12_secretBag; extern const heim_oid asn1_oid_id_pkcs12_secretBag;
#define ASN1_OID_ID_PKCS12_SECRETBAG (&asn1_oid_id_pkcs12_secretBag)
/* OBJECT IDENTIFIER id-pkcs12-safeContentsBag ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) lab el-less(6) } */ /* OBJECT IDENTIFIER id-pkcs12-safeContentsBag ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) lab el-less(6) } */
const heim_oid *oid_id_pkcs12_safeContentsBag(void);
extern const heim_oid asn1_oid_id_pkcs12_safeContentsBag; extern const heim_oid asn1_oid_id_pkcs12_safeContentsBag;
#define ASN1_OID_ID_PKCS12_SAFECONTENTSBAG (&asn1_oid_id_pkcs12_safeContent sBag)
/* /*
PKCS12-MacData ::= SEQUENCE { PKCS12-MacData ::= SEQUENCE {
mac DigestInfo, mac DigestInfo,
macSalt OCTET STRING, macSalt OCTET STRING,
iterations INTEGER OPTIONAL, iterations INTEGER OPTIONAL,
} }
*/ */
typedef struct PKCS12_MacData { typedef struct PKCS12_MacData {
DigestInfo mac; DigestInfo mac;
heim_octet_string macSalt; heim_octet_string macSalt;
heim_integer *iterations; heim_integer *iterations;
} PKCS12_MacData; } PKCS12_MacData;
int encode_PKCS12_MacData(unsigned char *, size_t, const PKCS12_MacData ASN1EXP int ASN1CALL decode_PKCS12_MacData(const unsigned char *, size_t
*, size_t *); , PKCS12_MacData *, size_t *);
int decode_PKCS12_MacData(const unsigned char *, size_t, PKCS12_MacData ASN1EXP int ASN1CALL encode_PKCS12_MacData(unsigned char *, size_t, cons
*, size_t *); t PKCS12_MacData *, size_t *);
void free_PKCS12_MacData (PKCS12_MacData *); ASN1EXP size_t ASN1CALL length_PKCS12_MacData(const PKCS12_MacData *);
size_t length_PKCS12_MacData(const PKCS12_MacData *); ASN1EXP int ASN1CALL copy_PKCS12_MacData (const PKCS12_MacData *, PKCS1
int copy_PKCS12_MacData (const PKCS12_MacData *, PKCS12_MacData *); 2_MacData *);
ASN1EXP void ASN1CALL free_PKCS12_MacData (PKCS12_MacData *);
/* /*
PKCS12-PFX ::= SEQUENCE { PKCS12-PFX ::= SEQUENCE {
version INTEGER, version INTEGER,
authSafe ContentInfo, authSafe ContentInfo,
macData PKCS12-MacData OPTIONAL, macData PKCS12-MacData OPTIONAL,
} }
*/ */
typedef struct PKCS12_PFX { typedef struct PKCS12_PFX {
heim_integer version; heim_integer version;
ContentInfo authSafe; ContentInfo authSafe;
PKCS12_MacData *macData; PKCS12_MacData *macData;
} PKCS12_PFX; } PKCS12_PFX;
int encode_PKCS12_PFX(unsigned char *, size_t, const PKCS12_PFX *, size_ ASN1EXP int ASN1CALL decode_PKCS12_PFX(const unsigned char *, size_t, PK
t *); CS12_PFX *, size_t *);
int decode_PKCS12_PFX(const unsigned char *, size_t, PKCS12_PFX *, size_ ASN1EXP int ASN1CALL encode_PKCS12_PFX(unsigned char *, size_t, const PK
t *); CS12_PFX *, size_t *);
void free_PKCS12_PFX (PKCS12_PFX *); ASN1EXP size_t ASN1CALL length_PKCS12_PFX(const PKCS12_PFX *);
size_t length_PKCS12_PFX(const PKCS12_PFX *); ASN1EXP int ASN1CALL copy_PKCS12_PFX (const PKCS12_PFX *, PKCS12_PFX *)
int copy_PKCS12_PFX (const PKCS12_PFX *, PKCS12_PFX *); ;
ASN1EXP void ASN1CALL free_PKCS12_PFX (PKCS12_PFX *);
/* /*
PKCS12-AuthenticatedSafe ::= SEQUENCE OF ContentInfo PKCS12-AuthenticatedSafe ::= SEQUENCE OF ContentInfo
*/ */
typedef struct PKCS12_AuthenticatedSafe { typedef struct PKCS12_AuthenticatedSafe {
unsigned int len; unsigned int len;
ContentInfo *val; ContentInfo *val;
} PKCS12_AuthenticatedSafe; } PKCS12_AuthenticatedSafe;
int encode_PKCS12_AuthenticatedSafe(unsigned char *, size_t, const PKCS1 ASN1EXP int ASN1CALL decode_PKCS12_AuthenticatedSafe(const unsigned char
2_AuthenticatedSafe *, size_t *); *, size_t, PKCS12_AuthenticatedSafe *, size_t *);
int decode_PKCS12_AuthenticatedSafe(const unsigned char *, size_t, PKCS1 ASN1EXP int ASN1CALL encode_PKCS12_AuthenticatedSafe(unsigned char *, si
2_AuthenticatedSafe *, size_t *); ze_t, const PKCS12_AuthenticatedSafe *, size_t *);
void free_PKCS12_AuthenticatedSafe (PKCS12_AuthenticatedSafe *); ASN1EXP size_t ASN1CALL length_PKCS12_AuthenticatedSafe(const PKCS12_Authen
size_t length_PKCS12_AuthenticatedSafe(const PKCS12_AuthenticatedSafe *); ticatedSafe *);
int copy_PKCS12_AuthenticatedSafe (const PKCS12_AuthenticatedSafe *, PK ASN1EXP int ASN1CALL copy_PKCS12_AuthenticatedSafe (const PKCS12_Authen
CS12_AuthenticatedSafe *); ticatedSafe *, PKCS12_AuthenticatedSafe *);
ASN1EXP void ASN1CALL free_PKCS12_AuthenticatedSafe (PKCS12_Authenticate
dSafe *);
/* /*
PKCS12-Attribute ::= SEQUENCE { PKCS12-Attribute ::= SEQUENCE {
attrId OBJECT IDENTIFIER, attrId OBJECT IDENTIFIER,
attrValues heim_any_set, attrValues heim_any_set,
} }
*/ */
typedef struct PKCS12_Attribute { typedef struct PKCS12_Attribute {
heim_oid attrId; heim_oid attrId;
heim_any_set attrValues; heim_any_set attrValues;
} PKCS12_Attribute; } PKCS12_Attribute;
int encode_PKCS12_Attribute(unsigned char *, size_t, const PKCS12_Attrib ASN1EXP int ASN1CALL decode_PKCS12_Attribute(const unsigned char *, size
ute *, size_t *); _t, PKCS12_Attribute *, size_t *);
int decode_PKCS12_Attribute(const unsigned char *, size_t, PKCS12_Attrib ASN1EXP int ASN1CALL encode_PKCS12_Attribute(unsigned char *, size_t, co
ute *, size_t *); nst PKCS12_Attribute *, size_t *);
void free_PKCS12_Attribute (PKCS12_Attribute *); ASN1EXP size_t ASN1CALL length_PKCS12_Attribute(const PKCS12_Attribute *);
size_t length_PKCS12_Attribute(const PKCS12_Attribute *); ASN1EXP int ASN1CALL copy_PKCS12_Attribute (const PKCS12_Attribute *, P
int copy_PKCS12_Attribute (const PKCS12_Attribute *, PKCS12_Attribute * KCS12_Attribute *);
); ASN1EXP void ASN1CALL free_PKCS12_Attribute (PKCS12_Attribute *);
/* /*
PKCS12-Attributes ::= SET OF PKCS12-Attribute PKCS12-Attributes ::= SET OF PKCS12-Attribute
*/ */
typedef struct PKCS12_Attributes { typedef struct PKCS12_Attributes {
unsigned int len; unsigned int len;
PKCS12_Attribute *val; PKCS12_Attribute *val;
} PKCS12_Attributes; } PKCS12_Attributes;
int encode_PKCS12_Attributes(unsigned char *, size_t, const PKCS12_Attri ASN1EXP int ASN1CALL decode_PKCS12_Attributes(const unsigned char *, siz
butes *, size_t *); e_t, PKCS12_Attributes *, size_t *);
int decode_PKCS12_Attributes(const unsigned char *, size_t, PKCS12_Attri ASN1EXP int ASN1CALL encode_PKCS12_Attributes(unsigned char *, size_t, c
butes *, size_t *); onst PKCS12_Attributes *, size_t *);
void free_PKCS12_Attributes (PKCS12_Attributes *); ASN1EXP size_t ASN1CALL length_PKCS12_Attributes(const PKCS12_Attributes *)
size_t length_PKCS12_Attributes(const PKCS12_Attributes *); ;
int copy_PKCS12_Attributes (const PKCS12_Attributes *, PKCS12_Attribute ASN1EXP int ASN1CALL copy_PKCS12_Attributes (const PKCS12_Attributes *,
s *); PKCS12_Attributes *);
ASN1EXP void ASN1CALL free_PKCS12_Attributes (PKCS12_Attributes *);
/* /*
PKCS12-SafeBag ::= SEQUENCE { PKCS12-SafeBag ::= SEQUENCE {
bagId OBJECT IDENTIFIER, bagId OBJECT IDENTIFIER,
bagValue [0] heim_any, bagValue [0] heim_any,
bagAttributes PKCS12-Attributes OPTIONAL, bagAttributes PKCS12-Attributes OPTIONAL,
} }
*/ */
typedef struct PKCS12_SafeBag { typedef struct PKCS12_SafeBag {
heim_oid bagId; heim_oid bagId;
heim_any bagValue; heim_any bagValue;
PKCS12_Attributes *bagAttributes; PKCS12_Attributes *bagAttributes;
} PKCS12_SafeBag; } PKCS12_SafeBag;
int encode_PKCS12_SafeBag(unsigned char *, size_t, const PKCS12_SafeBag ASN1EXP int ASN1CALL decode_PKCS12_SafeBag(const unsigned char *, size_t
*, size_t *); , PKCS12_SafeBag *, size_t *);
int decode_PKCS12_SafeBag(const unsigned char *, size_t, PKCS12_SafeBag ASN1EXP int ASN1CALL encode_PKCS12_SafeBag(unsigned char *, size_t, cons
*, size_t *); t PKCS12_SafeBag *, size_t *);
void free_PKCS12_SafeBag (PKCS12_SafeBag *); ASN1EXP size_t ASN1CALL length_PKCS12_SafeBag(const PKCS12_SafeBag *);
size_t length_PKCS12_SafeBag(const PKCS12_SafeBag *); ASN1EXP int ASN1CALL copy_PKCS12_SafeBag (const PKCS12_SafeBag *, PKCS1
int copy_PKCS12_SafeBag (const PKCS12_SafeBag *, PKCS12_SafeBag *); 2_SafeBag *);
ASN1EXP void ASN1CALL free_PKCS12_SafeBag (PKCS12_SafeBag *);
/* /*
PKCS12-SafeContents ::= SEQUENCE OF PKCS12-SafeBag PKCS12-SafeContents ::= SEQUENCE OF PKCS12-SafeBag
*/ */
typedef struct PKCS12_SafeContents { typedef struct PKCS12_SafeContents {
unsigned int len; unsigned int len;
PKCS12_SafeBag *val; PKCS12_SafeBag *val;
} PKCS12_SafeContents; } PKCS12_SafeContents;
int encode_PKCS12_SafeContents(unsigned char *, size_t, const PKCS12_Saf ASN1EXP int ASN1CALL decode_PKCS12_SafeContents(const unsigned char *, s
eContents *, size_t *); ize_t, PKCS12_SafeContents *, size_t *);
int decode_PKCS12_SafeContents(const unsigned char *, size_t, PKCS12_Saf ASN1EXP int ASN1CALL encode_PKCS12_SafeContents(unsigned char *, size_t,
eContents *, size_t *); const PKCS12_SafeContents *, size_t *);
void free_PKCS12_SafeContents (PKCS12_SafeContents *); ASN1EXP size_t ASN1CALL length_PKCS12_SafeContents(const PKCS12_SafeContent
size_t length_PKCS12_SafeContents(const PKCS12_SafeContents *); s *);
int copy_PKCS12_SafeContents (const PKCS12_SafeContents *, PKCS12_SafeC ASN1EXP int ASN1CALL copy_PKCS12_SafeContents (const PKCS12_SafeContent
ontents *); s *, PKCS12_SafeContents *);
ASN1EXP void ASN1CALL free_PKCS12_SafeContents (PKCS12_SafeContents *);
/* /*
PKCS12-CertBag ::= SEQUENCE { PKCS12-CertBag ::= SEQUENCE {
certType OBJECT IDENTIFIER, certType OBJECT IDENTIFIER,
certValue [0] heim_any, certValue [0] heim_any,
} }
*/ */
typedef struct PKCS12_CertBag { typedef struct PKCS12_CertBag {
heim_oid certType; heim_oid certType;
heim_any certValue; heim_any certValue;
} PKCS12_CertBag; } PKCS12_CertBag;
int encode_PKCS12_CertBag(unsigned char *, size_t, const PKCS12_CertBag ASN1EXP int ASN1CALL decode_PKCS12_CertBag(const unsigned char *, size_t
*, size_t *); , PKCS12_CertBag *, size_t *);
int decode_PKCS12_CertBag(const unsigned char *, size_t, PKCS12_CertBag ASN1EXP int ASN1CALL encode_PKCS12_CertBag(unsigned char *, size_t, cons
*, size_t *); t PKCS12_CertBag *, size_t *);
void free_PKCS12_CertBag (PKCS12_CertBag *); ASN1EXP size_t ASN1CALL length_PKCS12_CertBag(const PKCS12_CertBag *);
size_t length_PKCS12_CertBag(const PKCS12_CertBag *); ASN1EXP int ASN1CALL copy_PKCS12_CertBag (const PKCS12_CertBag *, PKCS1
int copy_PKCS12_CertBag (const PKCS12_CertBag *, PKCS12_CertBag *); 2_CertBag *);
ASN1EXP void ASN1CALL free_PKCS12_CertBag (PKCS12_CertBag *);
/* /*
PKCS12-PBEParams ::= SEQUENCE { PKCS12-PBEParams ::= SEQUENCE {
salt OCTET STRING, salt OCTET STRING,
iterations INTEGER (0..2147483647) OPTIONAL, iterations INTEGER (0..2147483647) OPTIONAL,
} }
*/ */
typedef struct PKCS12_PBEParams { typedef struct PKCS12_PBEParams {
heim_octet_string salt; heim_octet_string salt;
unsigned int *iterations; unsigned int *iterations;
} PKCS12_PBEParams; } PKCS12_PBEParams;
int encode_PKCS12_PBEParams(unsigned char *, size_t, const PKCS12_PBEPar ASN1EXP int ASN1CALL decode_PKCS12_PBEParams(const unsigned char *, size
ams *, size_t *); _t, PKCS12_PBEParams *, size_t *);
int decode_PKCS12_PBEParams(const unsigned char *, size_t, PKCS12_PBEPar ASN1EXP int ASN1CALL encode_PKCS12_PBEParams(unsigned char *, size_t, co
ams *, size_t *); nst PKCS12_PBEParams *, size_t *);
void free_PKCS12_PBEParams (PKCS12_PBEParams *); ASN1EXP size_t ASN1CALL length_PKCS12_PBEParams(const PKCS12_PBEParams *);
size_t length_PKCS12_PBEParams(const PKCS12_PBEParams *); ASN1EXP int ASN1CALL copy_PKCS12_PBEParams (const PKCS12_PBEParams *, P
int copy_PKCS12_PBEParams (const PKCS12_PBEParams *, PKCS12_PBEParams * KCS12_PBEParams *);
); ASN1EXP void ASN1CALL free_PKCS12_PBEParams (PKCS12_PBEParams *);
/* /*
PKCS12-OctetString ::= OCTET STRING PKCS12-OctetString ::= OCTET STRING
*/ */
typedef heim_octet_string PKCS12_OctetString; typedef heim_octet_string PKCS12_OctetString;
int encode_PKCS12_OctetString(unsigned char *, size_t, const PKCS12_Octe ASN1EXP int ASN1CALL decode_PKCS12_OctetString(const unsigned char *, si
tString *, size_t *); ze_t, PKCS12_OctetString *, size_t *);
int decode_PKCS12_OctetString(const unsigned char *, size_t, PKCS12_Octe ASN1EXP int ASN1CALL encode_PKCS12_OctetString(unsigned char *, size_t,
tString *, size_t *); const PKCS12_OctetString *, size_t *);
void free_PKCS12_OctetString (PKCS12_OctetString *); ASN1EXP size_t ASN1CALL length_PKCS12_OctetString(const PKCS12_OctetString
size_t length_PKCS12_OctetString(const PKCS12_OctetString *); *);
int copy_PKCS12_OctetString (const PKCS12_OctetString *, PKCS12_OctetSt ASN1EXP int ASN1CALL copy_PKCS12_OctetString (const PKCS12_OctetString
ring *); *, PKCS12_OctetString *);
ASN1EXP void ASN1CALL free_PKCS12_OctetString (PKCS12_OctetString *);
#endif /* __pkcs12_asn1_h__ */ #endif /* __pkcs12_asn1_h__ */
 End of changes. 43 change blocks. 
93 lines changed or deleted 113 lines changed or added


 pkcs8_asn1.h   pkcs8_asn1.h 
skipping to change at line 28 skipping to change at line 28
typedef struct heim_octet_string { typedef struct heim_octet_string {
size_t length; size_t length;
void *data; void *data;
} heim_octet_string; } heim_octet_string;
typedef char *heim_general_string; typedef char *heim_general_string;
typedef char *heim_utf8_string; typedef char *heim_utf8_string;
typedef char *heim_printable_string; typedef struct heim_octet_string heim_printable_string;
typedef char *heim_ia5_string; typedef struct heim_octet_string heim_ia5_string;
typedef struct heim_bmp_string { typedef struct heim_bmp_string {
size_t length; size_t length;
uint16_t *data; uint16_t *data;
} heim_bmp_string; } heim_bmp_string;
typedef struct heim_universal_string { typedef struct heim_universal_string {
size_t length; size_t length;
uint32_t *data; uint32_t *data;
} heim_universal_string; } heim_universal_string;
skipping to change at line 73 skipping to change at line 73
} else { \ } else { \
(R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
(S), (L)); \ (S), (L)); \
if((R) != 0) { \ if((R) != 0) { \
free((B)); \ free((B)); \
(B) = NULL; \ (B) = NULL; \
} \ } \
} \ } \
} while (0) } while (0)
#ifdef _WIN32
#ifndef ASN1_LIB
#define ASN1EXP __declspec(dllimport)
#else
#define ASN1EXP
#endif
#define ASN1CALL __stdcall
#else
#define ASN1EXP
#define ASN1CALL
#endif
struct units; struct units;
#endif #endif
#include <rfc2459_asn1.h> #include <rfc2459_asn1.h>
#include <heim_asn1.h> #include <heim_asn1.h>
/* /*
PKCS8PrivateKeyAlgorithmIdentifier ::= AlgorithmIdentifier PKCS8PrivateKeyAlgorithmIdentifier ::= AlgorithmIdentifier
*/ */
typedef AlgorithmIdentifier PKCS8PrivateKeyAlgorithmIdentifier; typedef AlgorithmIdentifier PKCS8PrivateKeyAlgorithmIdentifier;
int encode_PKCS8PrivateKeyAlgorithmIdentifier(unsigned char *, size_t, c ASN1EXP int ASN1CALL decode_PKCS8PrivateKeyAlgorithmIdentifier(const uns
onst PKCS8PrivateKeyAlgorithmIdentifier *, size_t *); igned char *, size_t, PKCS8PrivateKeyAlgorithmIdentifier *, size_t *);
int decode_PKCS8PrivateKeyAlgorithmIdentifier(const unsigned char *, siz ASN1EXP int ASN1CALL encode_PKCS8PrivateKeyAlgorithmIdentifier(unsigned
e_t, PKCS8PrivateKeyAlgorithmIdentifier *, size_t *); char *, size_t, const PKCS8PrivateKeyAlgorithmIdentifier *, size_t *);
void free_PKCS8PrivateKeyAlgorithmIdentifier (PKCS8PrivateKeyAlgorithmId ASN1EXP size_t ASN1CALL length_PKCS8PrivateKeyAlgorithmIdentifier(const PKC
entifier *); S8PrivateKeyAlgorithmIdentifier *);
size_t length_PKCS8PrivateKeyAlgorithmIdentifier(const PKCS8PrivateKeyAlgor ASN1EXP int ASN1CALL copy_PKCS8PrivateKeyAlgorithmIdentifier (const PKC
ithmIdentifier *); S8PrivateKeyAlgorithmIdentifier *, PKCS8PrivateKeyAlgorithmIdentifier *);
int copy_PKCS8PrivateKeyAlgorithmIdentifier (const PKCS8PrivateKeyAlgor ASN1EXP void ASN1CALL free_PKCS8PrivateKeyAlgorithmIdentifier (PKCS8Priv
ithmIdentifier *, PKCS8PrivateKeyAlgorithmIdentifier *); ateKeyAlgorithmIdentifier *);
/* /*
PKCS8PrivateKey ::= OCTET STRING PKCS8PrivateKey ::= OCTET STRING
*/ */
typedef heim_octet_string PKCS8PrivateKey; typedef heim_octet_string PKCS8PrivateKey;
int encode_PKCS8PrivateKey(unsigned char *, size_t, const PKCS8PrivateKe ASN1EXP int ASN1CALL decode_PKCS8PrivateKey(const unsigned char *, size_
y *, size_t *); t, PKCS8PrivateKey *, size_t *);
int decode_PKCS8PrivateKey(const unsigned char *, size_t, PKCS8PrivateKe ASN1EXP int ASN1CALL encode_PKCS8PrivateKey(unsigned char *, size_t, con
y *, size_t *); st PKCS8PrivateKey *, size_t *);
void free_PKCS8PrivateKey (PKCS8PrivateKey *); ASN1EXP size_t ASN1CALL length_PKCS8PrivateKey(const PKCS8PrivateKey *);
size_t length_PKCS8PrivateKey(const PKCS8PrivateKey *); ASN1EXP int ASN1CALL copy_PKCS8PrivateKey (const PKCS8PrivateKey *, PKC
int copy_PKCS8PrivateKey (const PKCS8PrivateKey *, PKCS8PrivateKey *); S8PrivateKey *);
ASN1EXP void ASN1CALL free_PKCS8PrivateKey (PKCS8PrivateKey *);
/* /*
PKCS8Attributes ::= SET OF Attribute PKCS8Attributes ::= SET OF Attribute
*/ */
typedef struct PKCS8Attributes { typedef struct PKCS8Attributes {
unsigned int len; unsigned int len;
Attribute *val; Attribute *val;
} PKCS8Attributes; } PKCS8Attributes;
int encode_PKCS8Attributes(unsigned char *, size_t, const PKCS8Attribute ASN1EXP int ASN1CALL decode_PKCS8Attributes(const unsigned char *, size_
s *, size_t *); t, PKCS8Attributes *, size_t *);
int decode_PKCS8Attributes(const unsigned char *, size_t, PKCS8Attribute ASN1EXP int ASN1CALL encode_PKCS8Attributes(unsigned char *, size_t, con
s *, size_t *); st PKCS8Attributes *, size_t *);
void free_PKCS8Attributes (PKCS8Attributes *); ASN1EXP size_t ASN1CALL length_PKCS8Attributes(const PKCS8Attributes *);
size_t length_PKCS8Attributes(const PKCS8Attributes *); ASN1EXP int ASN1CALL copy_PKCS8Attributes (const PKCS8Attributes *, PKC
int copy_PKCS8Attributes (const PKCS8Attributes *, PKCS8Attributes *); S8Attributes *);
ASN1EXP void ASN1CALL free_PKCS8Attributes (PKCS8Attributes *);
/* /*
PKCS8PrivateKeyInfo ::= SEQUENCE { PKCS8PrivateKeyInfo ::= SEQUENCE {
version INTEGER, version INTEGER,
privateKeyAlgorithm PKCS8PrivateKeyAlgorithmIdentifier, privateKeyAlgorithm PKCS8PrivateKeyAlgorithmIdentifier,
privateKey PKCS8PrivateKey, privateKey PKCS8PrivateKey,
attributes [0] IMPLICIT SET OF Attribute OPTIONAL, attributes [0] IMPLICIT SET OF Attribute OPTIONAL,
} }
*/ */
typedef struct PKCS8PrivateKeyInfo { typedef struct PKCS8PrivateKeyInfo {
heim_integer version; heim_integer version;
PKCS8PrivateKeyAlgorithmIdentifier privateKeyAlgorithm; PKCS8PrivateKeyAlgorithmIdentifier privateKeyAlgorithm;
PKCS8PrivateKey privateKey; PKCS8PrivateKey privateKey;
struct { struct PKCS8PrivateKeyInfo_attributes {
unsigned int len; unsigned int len;
Attribute *val; Attribute *val;
} *attributes; } *attributes;
} PKCS8PrivateKeyInfo; } PKCS8PrivateKeyInfo;
int encode_PKCS8PrivateKeyInfo(unsigned char *, size_t, const PKCS8Priva ASN1EXP int ASN1CALL decode_PKCS8PrivateKeyInfo(const unsigned char *, s
teKeyInfo *, size_t *); ize_t, PKCS8PrivateKeyInfo *, size_t *);
int decode_PKCS8PrivateKeyInfo(const unsigned char *, size_t, PKCS8Priva ASN1EXP int ASN1CALL encode_PKCS8PrivateKeyInfo(unsigned char *, size_t,
teKeyInfo *, size_t *); const PKCS8PrivateKeyInfo *, size_t *);
void free_PKCS8PrivateKeyInfo (PKCS8PrivateKeyInfo *); ASN1EXP size_t ASN1CALL length_PKCS8PrivateKeyInfo(const PKCS8PrivateKeyInf
size_t length_PKCS8PrivateKeyInfo(const PKCS8PrivateKeyInfo *); o *);
int copy_PKCS8PrivateKeyInfo (const PKCS8PrivateKeyInfo *, PKCS8Private ASN1EXP int ASN1CALL copy_PKCS8PrivateKeyInfo (const PKCS8PrivateKeyInf
KeyInfo *); o *, PKCS8PrivateKeyInfo *);
ASN1EXP void ASN1CALL free_PKCS8PrivateKeyInfo (PKCS8PrivateKeyInfo *);
/* /*
PKCS8EncryptedData ::= OCTET STRING PKCS8EncryptedData ::= OCTET STRING
*/ */
typedef heim_octet_string PKCS8EncryptedData; typedef heim_octet_string PKCS8EncryptedData;
int encode_PKCS8EncryptedData(unsigned char *, size_t, const PKCS8Encryp ASN1EXP int ASN1CALL decode_PKCS8EncryptedData(const unsigned char *, si
tedData *, size_t *); ze_t, PKCS8EncryptedData *, size_t *);
int decode_PKCS8EncryptedData(const unsigned char *, size_t, PKCS8Encryp ASN1EXP int ASN1CALL encode_PKCS8EncryptedData(unsigned char *, size_t,
tedData *, size_t *); const PKCS8EncryptedData *, size_t *);
void free_PKCS8EncryptedData (PKCS8EncryptedData *); ASN1EXP size_t ASN1CALL length_PKCS8EncryptedData(const PKCS8EncryptedData
size_t length_PKCS8EncryptedData(const PKCS8EncryptedData *); *);
int copy_PKCS8EncryptedData (const PKCS8EncryptedData *, PKCS8Encrypted ASN1EXP int ASN1CALL copy_PKCS8EncryptedData (const PKCS8EncryptedData
Data *); *, PKCS8EncryptedData *);
ASN1EXP void ASN1CALL free_PKCS8EncryptedData (PKCS8EncryptedData *);
/* /*
PKCS8EncryptedPrivateKeyInfo ::= SEQUENCE { PKCS8EncryptedPrivateKeyInfo ::= SEQUENCE {
encryptionAlgorithm AlgorithmIdentifier, encryptionAlgorithm AlgorithmIdentifier,
encryptedData PKCS8EncryptedData, encryptedData PKCS8EncryptedData,
} }
*/ */
typedef struct PKCS8EncryptedPrivateKeyInfo { typedef struct PKCS8EncryptedPrivateKeyInfo {
AlgorithmIdentifier encryptionAlgorithm; AlgorithmIdentifier encryptionAlgorithm;
PKCS8EncryptedData encryptedData; PKCS8EncryptedData encryptedData;
} PKCS8EncryptedPrivateKeyInfo; } PKCS8EncryptedPrivateKeyInfo;
int encode_PKCS8EncryptedPrivateKeyInfo(unsigned char *, size_t, const P ASN1EXP int ASN1CALL decode_PKCS8EncryptedPrivateKeyInfo(const unsigned
KCS8EncryptedPrivateKeyInfo *, size_t *); char *, size_t, PKCS8EncryptedPrivateKeyInfo *, size_t *);
int decode_PKCS8EncryptedPrivateKeyInfo(const unsigned char *, size_t, P ASN1EXP int ASN1CALL encode_PKCS8EncryptedPrivateKeyInfo(unsigned char *
KCS8EncryptedPrivateKeyInfo *, size_t *); , size_t, const PKCS8EncryptedPrivateKeyInfo *, size_t *);
void free_PKCS8EncryptedPrivateKeyInfo (PKCS8EncryptedPrivateKeyInfo *); ASN1EXP size_t ASN1CALL length_PKCS8EncryptedPrivateKeyInfo(const PKCS8Encr
size_t length_PKCS8EncryptedPrivateKeyInfo(const PKCS8EncryptedPrivateKeyIn yptedPrivateKeyInfo *);
fo *); ASN1EXP int ASN1CALL copy_PKCS8EncryptedPrivateKeyInfo (const PKCS8Encr
int copy_PKCS8EncryptedPrivateKeyInfo (const PKCS8EncryptedPrivateKeyIn yptedPrivateKeyInfo *, PKCS8EncryptedPrivateKeyInfo *);
fo *, PKCS8EncryptedPrivateKeyInfo *); ASN1EXP void ASN1CALL free_PKCS8EncryptedPrivateKeyInfo (PKCS8EncryptedP
rivateKeyInfo *);
#endif /* __pkcs8_asn1_h__ */ #endif /* __pkcs8_asn1_h__ */
 End of changes. 10 change blocks. 
52 lines changed or deleted 68 lines changed or added


 pkcs9_asn1.h   pkcs9_asn1.h 
skipping to change at line 28 skipping to change at line 28
typedef struct heim_octet_string { typedef struct heim_octet_string {
size_t length; size_t length;
void *data; void *data;
} heim_octet_string; } heim_octet_string;
typedef char *heim_general_string; typedef char *heim_general_string;
typedef char *heim_utf8_string; typedef char *heim_utf8_string;
typedef char *heim_printable_string; typedef struct heim_octet_string heim_printable_string;
typedef char *heim_ia5_string; typedef struct heim_octet_string heim_ia5_string;
typedef struct heim_bmp_string { typedef struct heim_bmp_string {
size_t length; size_t length;
uint16_t *data; uint16_t *data;
} heim_bmp_string; } heim_bmp_string;
typedef struct heim_universal_string { typedef struct heim_universal_string {
size_t length; size_t length;
uint32_t *data; uint32_t *data;
} heim_universal_string; } heim_universal_string;
skipping to change at line 73 skipping to change at line 73
} else { \ } else { \
(R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
(S), (L)); \ (S), (L)); \
if((R) != 0) { \ if((R) != 0) { \
free((B)); \ free((B)); \
(B) = NULL; \ (B) = NULL; \
} \ } \
} \ } \
} while (0) } while (0)
#ifdef _WIN32
#ifndef ASN1_LIB
#define ASN1EXP __declspec(dllimport)
#else
#define ASN1EXP
#endif
#define ASN1CALL __stdcall
#else
#define ASN1EXP
#define ASN1CALL
#endif
struct units; struct units;
#endif #endif
/* OBJECT IDENTIFIER id-pkcs-9 ::= { iso(1) member-body(2) us(840) rsadsi(1 13549) pkcs(1) pkcs-9(9) } */ /* OBJECT IDENTIFIER id-pkcs-9 ::= { iso(1) member-body(2) us(840) rsadsi(1 13549) pkcs(1) pkcs-9(9) } */
const heim_oid *oid_id_pkcs_9(void);
extern const heim_oid asn1_oid_id_pkcs_9; extern const heim_oid asn1_oid_id_pkcs_9;
#define ASN1_OID_ID_PKCS_9 (&asn1_oid_id_pkcs_9)
/* OBJECT IDENTIFIER id-pkcs9-emailAddress ::= { iso(1) member-body(2) us(8 40) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(1) } */ /* OBJECT IDENTIFIER id-pkcs9-emailAddress ::= { iso(1) member-body(2) us(8 40) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(1) } */
const heim_oid *oid_id_pkcs9_emailAddress(void);
extern const heim_oid asn1_oid_id_pkcs9_emailAddress; extern const heim_oid asn1_oid_id_pkcs9_emailAddress;
#define ASN1_OID_ID_PKCS9_EMAILADDRESS (&asn1_oid_id_pkcs9_emailAddress)
/* OBJECT IDENTIFIER id-pkcs9-contentType ::= { iso(1) member-body(2) us(84 0) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(3) } */ /* OBJECT IDENTIFIER id-pkcs9-contentType ::= { iso(1) member-body(2) us(84 0) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(3) } */
const heim_oid *oid_id_pkcs9_contentType(void);
extern const heim_oid asn1_oid_id_pkcs9_contentType; extern const heim_oid asn1_oid_id_pkcs9_contentType;
#define ASN1_OID_ID_PKCS9_CONTENTTYPE (&asn1_oid_id_pkcs9_contentType)
/* OBJECT IDENTIFIER id-pkcs9-messageDigest ::= { iso(1) member-body(2) us( 840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(4) } */ /* OBJECT IDENTIFIER id-pkcs9-messageDigest ::= { iso(1) member-body(2) us( 840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(4) } */
const heim_oid *oid_id_pkcs9_messageDigest(void);
extern const heim_oid asn1_oid_id_pkcs9_messageDigest; extern const heim_oid asn1_oid_id_pkcs9_messageDigest;
#define ASN1_OID_ID_PKCS9_MESSAGEDIGEST (&asn1_oid_id_pkcs9_messageDigest)
/* OBJECT IDENTIFIER id-pkcs9-signingTime ::= { iso(1) member-body(2) us(84 0) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(5) } */ /* OBJECT IDENTIFIER id-pkcs9-signingTime ::= { iso(1) member-body(2) us(84 0) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(5) } */
const heim_oid *oid_id_pkcs9_signingTime(void);
extern const heim_oid asn1_oid_id_pkcs9_signingTime; extern const heim_oid asn1_oid_id_pkcs9_signingTime;
#define ASN1_OID_ID_PKCS9_SIGNINGTIME (&asn1_oid_id_pkcs9_signingTime)
/* OBJECT IDENTIFIER id-pkcs9-countersignature ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(6) } */ /* OBJECT IDENTIFIER id-pkcs9-countersignature ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(6) } */
const heim_oid *oid_id_pkcs9_countersignature(void);
extern const heim_oid asn1_oid_id_pkcs9_countersignature; extern const heim_oid asn1_oid_id_pkcs9_countersignature;
#define ASN1_OID_ID_PKCS9_COUNTERSIGNATURE (&asn1_oid_id_pkcs9_countersigna ture)
/* OBJECT IDENTIFIER id-pkcs-9-at-friendlyName ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(20) } */ /* OBJECT IDENTIFIER id-pkcs-9-at-friendlyName ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(20) } */
const heim_oid *oid_id_pkcs_9_at_friendlyName(void);
extern const heim_oid asn1_oid_id_pkcs_9_at_friendlyName; extern const heim_oid asn1_oid_id_pkcs_9_at_friendlyName;
#define ASN1_OID_ID_PKCS_9_AT_FRIENDLYNAME (&asn1_oid_id_pkcs_9_at_friendly Name)
/* OBJECT IDENTIFIER id-pkcs-9-at-localKeyId ::= { iso(1) member-body(2) us (840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(21) } */ /* OBJECT IDENTIFIER id-pkcs-9-at-localKeyId ::= { iso(1) member-body(2) us (840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(21) } */
const heim_oid *oid_id_pkcs_9_at_localKeyId(void);
extern const heim_oid asn1_oid_id_pkcs_9_at_localKeyId; extern const heim_oid asn1_oid_id_pkcs_9_at_localKeyId;
#define ASN1_OID_ID_PKCS_9_AT_LOCALKEYID (&asn1_oid_id_pkcs_9_at_localKeyId )
/* OBJECT IDENTIFIER id-pkcs-9-at-certTypes ::= { iso(1) member-body(2) us( 840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(22) } */ /* OBJECT IDENTIFIER id-pkcs-9-at-certTypes ::= { iso(1) member-body(2) us( 840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(22) } */
const heim_oid *oid_id_pkcs_9_at_certTypes(void);
extern const heim_oid asn1_oid_id_pkcs_9_at_certTypes; extern const heim_oid asn1_oid_id_pkcs_9_at_certTypes;
#define ASN1_OID_ID_PKCS_9_AT_CERTTYPES (&asn1_oid_id_pkcs_9_at_certTypes)
/* OBJECT IDENTIFIER id-pkcs-9-at-certTypes-x509 ::= { iso(1) member-body(2 ) us(840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(22) label-less(1) } * / /* OBJECT IDENTIFIER id-pkcs-9-at-certTypes-x509 ::= { iso(1) member-body(2 ) us(840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(22) label-less(1) } * /
const heim_oid *oid_id_pkcs_9_at_certTypes_x509(void);
extern const heim_oid asn1_oid_id_pkcs_9_at_certTypes_x509; extern const heim_oid asn1_oid_id_pkcs_9_at_certTypes_x509;
#define ASN1_OID_ID_PKCS_9_AT_CERTTYPES_X509 (&asn1_oid_id_pkcs_9_at_certTy pes_x509)
/* /*
PKCS9-BMPString ::= BMPString PKCS9-BMPString ::= BMPString
*/ */
typedef heim_bmp_string PKCS9_BMPString; typedef heim_bmp_string PKCS9_BMPString;
int encode_PKCS9_BMPString(unsigned char *, size_t, const PKCS9_BMPStrin ASN1EXP int ASN1CALL decode_PKCS9_BMPString(const unsigned char *, size_
g *, size_t *); t, PKCS9_BMPString *, size_t *);
int decode_PKCS9_BMPString(const unsigned char *, size_t, PKCS9_BMPStrin ASN1EXP int ASN1CALL encode_PKCS9_BMPString(unsigned char *, size_t, con
g *, size_t *); st PKCS9_BMPString *, size_t *);
void free_PKCS9_BMPString (PKCS9_BMPString *); ASN1EXP size_t ASN1CALL length_PKCS9_BMPString(const PKCS9_BMPString *);
size_t length_PKCS9_BMPString(const PKCS9_BMPString *); ASN1EXP int ASN1CALL copy_PKCS9_BMPString (const PKCS9_BMPString *, PKC
int copy_PKCS9_BMPString (const PKCS9_BMPString *, PKCS9_BMPString *); S9_BMPString *);
ASN1EXP void ASN1CALL free_PKCS9_BMPString (PKCS9_BMPString *);
/* /*
PKCS9-friendlyName ::= SET OF PKCS9-BMPString PKCS9-friendlyName ::= SET OF PKCS9-BMPString
*/ */
typedef struct PKCS9_friendlyName { typedef struct PKCS9_friendlyName {
unsigned int len; unsigned int len;
PKCS9_BMPString *val; PKCS9_BMPString *val;
} PKCS9_friendlyName; } PKCS9_friendlyName;
int encode_PKCS9_friendlyName(unsigned char *, size_t, const PKCS9_frien ASN1EXP int ASN1CALL decode_PKCS9_friendlyName(const unsigned char *, si
dlyName *, size_t *); ze_t, PKCS9_friendlyName *, size_t *);
int decode_PKCS9_friendlyName(const unsigned char *, size_t, PKCS9_frien ASN1EXP int ASN1CALL encode_PKCS9_friendlyName(unsigned char *, size_t,
dlyName *, size_t *); const PKCS9_friendlyName *, size_t *);
void free_PKCS9_friendlyName (PKCS9_friendlyName *); ASN1EXP size_t ASN1CALL length_PKCS9_friendlyName(const PKCS9_friendlyName
size_t length_PKCS9_friendlyName(const PKCS9_friendlyName *); *);
int copy_PKCS9_friendlyName (const PKCS9_friendlyName *, PKCS9_friendly ASN1EXP int ASN1CALL copy_PKCS9_friendlyName (const PKCS9_friendlyName
Name *); *, PKCS9_friendlyName *);
ASN1EXP void ASN1CALL free_PKCS9_friendlyName (PKCS9_friendlyName *);
#endif /* __pkcs9_asn1_h__ */ #endif /* __pkcs9_asn1_h__ */
 End of changes. 25 change blocks. 
27 lines changed or deleted 40 lines changed or added


 pkinit_asn1.h   pkinit_asn1.h 
skipping to change at line 28 skipping to change at line 28
typedef struct heim_octet_string { typedef struct heim_octet_string {
size_t length; size_t length;
void *data; void *data;
} heim_octet_string; } heim_octet_string;
typedef char *heim_general_string; typedef char *heim_general_string;
typedef char *heim_utf8_string; typedef char *heim_utf8_string;
typedef char *heim_printable_string; typedef struct heim_octet_string heim_printable_string;
typedef char *heim_ia5_string; typedef struct heim_octet_string heim_ia5_string;
typedef struct heim_bmp_string { typedef struct heim_bmp_string {
size_t length; size_t length;
uint16_t *data; uint16_t *data;
} heim_bmp_string; } heim_bmp_string;
typedef struct heim_universal_string { typedef struct heim_universal_string {
size_t length; size_t length;
uint32_t *data; uint32_t *data;
} heim_universal_string; } heim_universal_string;
skipping to change at line 73 skipping to change at line 73
} else { \ } else { \
(R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
(S), (L)); \ (S), (L)); \
if((R) != 0) { \ if((R) != 0) { \
free((B)); \ free((B)); \
(B) = NULL; \ (B) = NULL; \
} \ } \
} \ } \
} while (0) } while (0)
#ifdef _WIN32
#ifndef ASN1_LIB
#define ASN1EXP __declspec(dllimport)
#else
#define ASN1EXP
#endif
#define ASN1CALL __stdcall
#else
#define ASN1EXP
#define ASN1CALL
#endif
struct units; struct units;
#endif #endif
#include <krb5_asn1.h> #include <krb5_asn1.h>
#include <cms_asn1.h> #include <cms_asn1.h>
#include <rfc2459_asn1.h> #include <rfc2459_asn1.h>
#include <heim_asn1.h> #include <heim_asn1.h>
/* OBJECT IDENTIFIER id-pkinit ::= { iso(1) org(3) dod(6) internet(1) secur ity(5) kerberosv5(2) pkinit(3) } */ /* OBJECT IDENTIFIER id-pkinit ::= { iso(1) org(3) dod(6) internet(1) secur ity(5) kerberosv5(2) pkinit(3) } */
const heim_oid *oid_id_pkinit(void);
extern const heim_oid asn1_oid_id_pkinit; extern const heim_oid asn1_oid_id_pkinit;
#define ASN1_OID_ID_PKINIT (&asn1_oid_id_pkinit)
/* OBJECT IDENTIFIER id-pkauthdata ::= { iso(1) org(3) dod(6) internet(1) s ecurity(5) kerberosv5(2) pkinit(3) label-less(1) } */ /* OBJECT IDENTIFIER id-pkauthdata ::= { iso(1) org(3) dod(6) internet(1) s ecurity(5) kerberosv5(2) pkinit(3) label-less(1) } */
const heim_oid *oid_id_pkauthdata(void);
extern const heim_oid asn1_oid_id_pkauthdata; extern const heim_oid asn1_oid_id_pkauthdata;
#define ASN1_OID_ID_PKAUTHDATA (&asn1_oid_id_pkauthdata)
/* OBJECT IDENTIFIER id-pkdhkeydata ::= { iso(1) org(3) dod(6) internet(1) security(5) kerberosv5(2) pkinit(3) label-less(2) } */ /* OBJECT IDENTIFIER id-pkdhkeydata ::= { iso(1) org(3) dod(6) internet(1) security(5) kerberosv5(2) pkinit(3) label-less(2) } */
const heim_oid *oid_id_pkdhkeydata(void);
extern const heim_oid asn1_oid_id_pkdhkeydata; extern const heim_oid asn1_oid_id_pkdhkeydata;
#define ASN1_OID_ID_PKDHKEYDATA (&asn1_oid_id_pkdhkeydata)
/* OBJECT IDENTIFIER id-pkrkeydata ::= { iso(1) org(3) dod(6) internet(1) s ecurity(5) kerberosv5(2) pkinit(3) label-less(3) } */ /* OBJECT IDENTIFIER id-pkrkeydata ::= { iso(1) org(3) dod(6) internet(1) s ecurity(5) kerberosv5(2) pkinit(3) label-less(3) } */
const heim_oid *oid_id_pkrkeydata(void);
extern const heim_oid asn1_oid_id_pkrkeydata; extern const heim_oid asn1_oid_id_pkrkeydata;
#define ASN1_OID_ID_PKRKEYDATA (&asn1_oid_id_pkrkeydata)
/* OBJECT IDENTIFIER id-pkekuoid ::= { iso(1) org(3) dod(6) internet(1) sec urity(5) kerberosv5(2) pkinit(3) label-less(4) } */ /* OBJECT IDENTIFIER id-pkekuoid ::= { iso(1) org(3) dod(6) internet(1) sec urity(5) kerberosv5(2) pkinit(3) label-less(4) } */
const heim_oid *oid_id_pkekuoid(void);
extern const heim_oid asn1_oid_id_pkekuoid; extern const heim_oid asn1_oid_id_pkekuoid;
#define ASN1_OID_ID_PKEKUOID (&asn1_oid_id_pkekuoid)
/* OBJECT IDENTIFIER id-pkkdcekuoid ::= { iso(1) org(3) dod(6) internet(1) security(5) kerberosv5(2) pkinit(3) label-less(5) } */ /* OBJECT IDENTIFIER id-pkkdcekuoid ::= { iso(1) org(3) dod(6) internet(1) security(5) kerberosv5(2) pkinit(3) label-less(5) } */
const heim_oid *oid_id_pkkdcekuoid(void);
extern const heim_oid asn1_oid_id_pkkdcekuoid; extern const heim_oid asn1_oid_id_pkkdcekuoid;
#define ASN1_OID_ID_PKKDCEKUOID (&asn1_oid_id_pkkdcekuoid)
/* OBJECT IDENTIFIER id-pkinit-kdf ::= { iso(1) org(3) dod(6) internet(1) s ecurity(5) kerberosv5(2) pkinit(3) label-less(6) } */ /* OBJECT IDENTIFIER id-pkinit-kdf ::= { iso(1) org(3) dod(6) internet(1) s ecurity(5) kerberosv5(2) pkinit(3) label-less(6) } */
const heim_oid *oid_id_pkinit_kdf(void);
extern const heim_oid asn1_oid_id_pkinit_kdf; extern const heim_oid asn1_oid_id_pkinit_kdf;
#define ASN1_OID_ID_PKINIT_KDF (&asn1_oid_id_pkinit_kdf)
/* OBJECT IDENTIFIER id-pkinit-kdf-ah-sha1 ::= { iso(1) org(3) dod(6) inter net(1) security(5) kerberosv5(2) pkinit(3) label-less(6) label-less(1) } */ /* OBJECT IDENTIFIER id-pkinit-kdf-ah-sha1 ::= { iso(1) org(3) dod(6) inter net(1) security(5) kerberosv5(2) pkinit(3) label-less(6) label-less(1) } */
const heim_oid *oid_id_pkinit_kdf_ah_sha1(void);
extern const heim_oid asn1_oid_id_pkinit_kdf_ah_sha1; extern const heim_oid asn1_oid_id_pkinit_kdf_ah_sha1;
#define ASN1_OID_ID_PKINIT_KDF_AH_SHA1 (&asn1_oid_id_pkinit_kdf_ah_sha1)
/* OBJECT IDENTIFIER id-pkinit-kdf-ah-sha256 ::= { iso(1) org(3) dod(6) int ernet(1) security(5) kerberosv5(2) pkinit(3) label-less(6) label-less(2) } */ /* OBJECT IDENTIFIER id-pkinit-kdf-ah-sha256 ::= { iso(1) org(3) dod(6) int ernet(1) security(5) kerberosv5(2) pkinit(3) label-less(6) label-less(2) } */
const heim_oid *oid_id_pkinit_kdf_ah_sha256(void);
extern const heim_oid asn1_oid_id_pkinit_kdf_ah_sha256; extern const heim_oid asn1_oid_id_pkinit_kdf_ah_sha256;
#define ASN1_OID_ID_PKINIT_KDF_AH_SHA256 (&asn1_oid_id_pkinit_kdf_ah_sha256 )
/* OBJECT IDENTIFIER id-pkinit-kdf-ah-sha512 ::= { iso(1) org(3) dod(6) int ernet(1) security(5) kerberosv5(2) pkinit(3) label-less(6) label-less(3) } */ /* OBJECT IDENTIFIER id-pkinit-kdf-ah-sha512 ::= { iso(1) org(3) dod(6) int ernet(1) security(5) kerberosv5(2) pkinit(3) label-less(6) label-less(3) } */
const heim_oid *oid_id_pkinit_kdf_ah_sha512(void);
extern const heim_oid asn1_oid_id_pkinit_kdf_ah_sha512; extern const heim_oid asn1_oid_id_pkinit_kdf_ah_sha512;
#define ASN1_OID_ID_PKINIT_KDF_AH_SHA512 (&asn1_oid_id_pkinit_kdf_ah_sha512 )
/* OBJECT IDENTIFIER id-pkinit-san ::= { iso(1) org(3) dod(6) internet(1) s ecurity(5) kerberosv5(2) x509-sanan(2) } */ /* OBJECT IDENTIFIER id-pkinit-san ::= { iso(1) org(3) dod(6) internet(1) s ecurity(5) kerberosv5(2) x509-sanan(2) } */
const heim_oid *oid_id_pkinit_san(void);
extern const heim_oid asn1_oid_id_pkinit_san; extern const heim_oid asn1_oid_id_pkinit_san;
#define ASN1_OID_ID_PKINIT_SAN (&asn1_oid_id_pkinit_san)
/* OBJECT IDENTIFIER id-pkinit-ms-eku ::= { iso(1) org(3) dod(6) internet(1 ) private(4) enterprise(1) microsoft(311) label-less(20) label-less(2) labe l-less(2) } */ /* OBJECT IDENTIFIER id-pkinit-ms-eku ::= { iso(1) org(3) dod(6) internet(1 ) private(4) enterprise(1) microsoft(311) label-less(20) label-less(2) labe l-less(2) } */
const heim_oid *oid_id_pkinit_ms_eku(void);
extern const heim_oid asn1_oid_id_pkinit_ms_eku; extern const heim_oid asn1_oid_id_pkinit_ms_eku;
#define ASN1_OID_ID_PKINIT_MS_EKU (&asn1_oid_id_pkinit_ms_eku)
/* OBJECT IDENTIFIER id-pkinit-ms-san ::= { iso(1) org(3) dod(6) internet(1 ) private(4) enterprise(1) microsoft(311) label-less(20) label-less(2) labe l-less(3) } */ /* OBJECT IDENTIFIER id-pkinit-ms-san ::= { iso(1) org(3) dod(6) internet(1 ) private(4) enterprise(1) microsoft(311) label-less(20) label-less(2) labe l-less(3) } */
const heim_oid *oid_id_pkinit_ms_san(void);
extern const heim_oid asn1_oid_id_pkinit_ms_san; extern const heim_oid asn1_oid_id_pkinit_ms_san;
#define ASN1_OID_ID_PKINIT_MS_SAN (&asn1_oid_id_pkinit_ms_san)
/* /*
MS-UPN-SAN ::= UTF8String MS-UPN-SAN ::= UTF8String
*/ */
typedef heim_utf8_string MS_UPN_SAN; typedef heim_utf8_string MS_UPN_SAN;
int encode_MS_UPN_SAN(unsigned char *, size_t, const MS_UPN_SAN *, size_ ASN1EXP int ASN1CALL decode_MS_UPN_SAN(const unsigned char *, size_t, MS
t *); _UPN_SAN *, size_t *);
int decode_MS_UPN_SAN(const unsigned char *, size_t, MS_UPN_SAN *, size_ ASN1EXP int ASN1CALL encode_MS_UPN_SAN(unsigned char *, size_t, const MS
t *); _UPN_SAN *, size_t *);
void free_MS_UPN_SAN (MS_UPN_SAN *); ASN1EXP size_t ASN1CALL length_MS_UPN_SAN(const MS_UPN_SAN *);
size_t length_MS_UPN_SAN(const MS_UPN_SAN *); ASN1EXP int ASN1CALL copy_MS_UPN_SAN (const MS_UPN_SAN *, MS_UPN_SAN *)
int copy_MS_UPN_SAN (const MS_UPN_SAN *, MS_UPN_SAN *); ;
ASN1EXP void ASN1CALL free_MS_UPN_SAN (MS_UPN_SAN *);
enum { pa_pk_as_req = 16 }; enum { pa_pk_as_req = 16 };
enum { pa_pk_as_rep = 17 }; enum { pa_pk_as_rep = 17 };
enum { td_trusted_certifiers = 104 }; enum { td_trusted_certifiers = 104 };
enum { td_invalid_certificates = 105 }; enum { td_invalid_certificates = 105 };
enum { td_dh_parameters = 109 }; enum { td_dh_parameters = 109 };
/* /*
DHNonce ::= OCTET STRING DHNonce ::= OCTET STRING
*/ */
typedef heim_octet_string DHNonce; typedef heim_octet_string DHNonce;
int encode_DHNonce(unsigned char *, size_t, const DHNonce *, size_t *); ASN1EXP int ASN1CALL decode_DHNonce(const unsigned char *, size_t, DHNon
int decode_DHNonce(const unsigned char *, size_t, DHNonce *, size_t *); ce *, size_t *);
void free_DHNonce (DHNonce *); ASN1EXP int ASN1CALL encode_DHNonce(unsigned char *, size_t, const DHNon
size_t length_DHNonce(const DHNonce *); ce *, size_t *);
int copy_DHNonce (const DHNonce *, DHNonce *); ASN1EXP size_t ASN1CALL length_DHNonce(const DHNonce *);
ASN1EXP int ASN1CALL copy_DHNonce (const DHNonce *, DHNonce *);
ASN1EXP void ASN1CALL free_DHNonce (DHNonce *);
/* /*
KDFAlgorithmId ::= SEQUENCE { KDFAlgorithmId ::= SEQUENCE {
kdf-id [0] OBJECT IDENTIFIER, kdf-id [0] OBJECT IDENTIFIER,
..., ...,
} }
*/ */
typedef struct KDFAlgorithmId { typedef struct KDFAlgorithmId {
heim_oid kdf_id; heim_oid kdf_id;
} KDFAlgorithmId; } KDFAlgorithmId;
int encode_KDFAlgorithmId(unsigned char *, size_t, const KDFAlgorithmId ASN1EXP int ASN1CALL decode_KDFAlgorithmId(const unsigned char *, size_t
*, size_t *); , KDFAlgorithmId *, size_t *);
int decode_KDFAlgorithmId(const unsigned char *, size_t, KDFAlgorithmId ASN1EXP int ASN1CALL encode_KDFAlgorithmId(unsigned char *, size_t, cons
*, size_t *); t KDFAlgorithmId *, size_t *);
void free_KDFAlgorithmId (KDFAlgorithmId *); ASN1EXP size_t ASN1CALL length_KDFAlgorithmId(const KDFAlgorithmId *);
size_t length_KDFAlgorithmId(const KDFAlgorithmId *); ASN1EXP int ASN1CALL copy_KDFAlgorithmId (const KDFAlgorithmId *, KDFAl
int copy_KDFAlgorithmId (const KDFAlgorithmId *, KDFAlgorithmId *); gorithmId *);
ASN1EXP void ASN1CALL free_KDFAlgorithmId (KDFAlgorithmId *);
/* /*
TrustedCA ::= SEQUENCE { TrustedCA ::= SEQUENCE {
caName [0] IMPLICIT OCTET STRING, caName [0] IMPLICIT OCTET STRING,
certificateSerialNumber [1] INTEGER OPTIONAL, certificateSerialNumber [1] INTEGER OPTIONAL,
subjectKeyIdentifier [2] OCTET STRING OPTIONAL, subjectKeyIdentifier [2] OCTET STRING OPTIONAL,
..., ...,
} }
*/ */
typedef struct TrustedCA { typedef struct TrustedCA {
heim_octet_string caName; heim_octet_string caName;
heim_integer *certificateSerialNumber; heim_integer *certificateSerialNumber;
heim_octet_string *subjectKeyIdentifier; heim_octet_string *subjectKeyIdentifier;
} TrustedCA; } TrustedCA;
int encode_TrustedCA(unsigned char *, size_t, const TrustedCA *, size_t ASN1EXP int ASN1CALL decode_TrustedCA(const unsigned char *, size_t, Tru
*); stedCA *, size_t *);
int decode_TrustedCA(const unsigned char *, size_t, TrustedCA *, size_t ASN1EXP int ASN1CALL encode_TrustedCA(unsigned char *, size_t, const Tru
*); stedCA *, size_t *);
void free_TrustedCA (TrustedCA *); ASN1EXP size_t ASN1CALL length_TrustedCA(const TrustedCA *);
size_t length_TrustedCA(const TrustedCA *); ASN1EXP int ASN1CALL copy_TrustedCA (const TrustedCA *, TrustedCA *);
int copy_TrustedCA (const TrustedCA *, TrustedCA *); ASN1EXP void ASN1CALL free_TrustedCA (TrustedCA *);
/* /*
ExternalPrincipalIdentifier ::= SEQUENCE { ExternalPrincipalIdentifier ::= SEQUENCE {
subjectName [0] IMPLICIT OCTET STRING OPTIONAL, subjectName [0] IMPLICIT OCTET STRING OPTIONAL,
issuerAndSerialNumber [1] IMPLICIT OCTET STRING OPTIONAL, issuerAndSerialNumber [1] IMPLICIT OCTET STRING OPTIONAL,
subjectKeyIdentifier [2] IMPLICIT OCTET STRING OPTIONAL, subjectKeyIdentifier [2] IMPLICIT OCTET STRING OPTIONAL,
..., ...,
} }
*/ */
typedef struct ExternalPrincipalIdentifier { typedef struct ExternalPrincipalIdentifier {
heim_octet_string *subjectName; heim_octet_string *subjectName;
heim_octet_string *issuerAndSerialNumber; heim_octet_string *issuerAndSerialNumber;
heim_octet_string *subjectKeyIdentifier; heim_octet_string *subjectKeyIdentifier;
} ExternalPrincipalIdentifier; } ExternalPrincipalIdentifier;
int encode_ExternalPrincipalIdentifier(unsigned char *, size_t, const Ex ASN1EXP int ASN1CALL decode_ExternalPrincipalIdentifier(const unsigned c
ternalPrincipalIdentifier *, size_t *); har *, size_t, ExternalPrincipalIdentifier *, size_t *);
int decode_ExternalPrincipalIdentifier(const unsigned char *, size_t, Ex ASN1EXP int ASN1CALL encode_ExternalPrincipalIdentifier(unsigned char *,
ternalPrincipalIdentifier *, size_t *); size_t, const ExternalPrincipalIdentifier *, size_t *);
void free_ExternalPrincipalIdentifier (ExternalPrincipalIdentifier *); ASN1EXP size_t ASN1CALL length_ExternalPrincipalIdentifier(const ExternalPr
size_t length_ExternalPrincipalIdentifier(const ExternalPrincipalIdentifier incipalIdentifier *);
*); ASN1EXP int ASN1CALL copy_ExternalPrincipalIdentifier (const ExternalPr
int copy_ExternalPrincipalIdentifier (const ExternalPrincipalIdentifier incipalIdentifier *, ExternalPrincipalIdentifier *);
*, ExternalPrincipalIdentifier *); ASN1EXP void ASN1CALL free_ExternalPrincipalIdentifier (ExternalPrincipa
lIdentifier *);
/* /*
ExternalPrincipalIdentifiers ::= SEQUENCE OF ExternalPrincipalIdentifier ExternalPrincipalIdentifiers ::= SEQUENCE OF ExternalPrincipalIdentifier
*/ */
typedef struct ExternalPrincipalIdentifiers { typedef struct ExternalPrincipalIdentifiers {
unsigned int len; unsigned int len;
ExternalPrincipalIdentifier *val; ExternalPrincipalIdentifier *val;
} ExternalPrincipalIdentifiers; } ExternalPrincipalIdentifiers;
int encode_ExternalPrincipalIdentifiers(unsigned char *, size_t, const E ASN1EXP int ASN1CALL decode_ExternalPrincipalIdentifiers(const unsigned
xternalPrincipalIdentifiers *, size_t *); char *, size_t, ExternalPrincipalIdentifiers *, size_t *);
int decode_ExternalPrincipalIdentifiers(const unsigned char *, size_t, E ASN1EXP int ASN1CALL encode_ExternalPrincipalIdentifiers(unsigned char *
xternalPrincipalIdentifiers *, size_t *); , size_t, const ExternalPrincipalIdentifiers *, size_t *);
void free_ExternalPrincipalIdentifiers (ExternalPrincipalIdentifiers *); ASN1EXP size_t ASN1CALL length_ExternalPrincipalIdentifiers(const ExternalP
size_t length_ExternalPrincipalIdentifiers(const ExternalPrincipalIdentifie rincipalIdentifiers *);
rs *); ASN1EXP int ASN1CALL copy_ExternalPrincipalIdentifiers (const ExternalP
int copy_ExternalPrincipalIdentifiers (const ExternalPrincipalIdentifie rincipalIdentifiers *, ExternalPrincipalIdentifiers *);
rs *, ExternalPrincipalIdentifiers *); ASN1EXP void ASN1CALL free_ExternalPrincipalIdentifiers (ExternalPrincip
alIdentifiers *);
/* /*
PA-PK-AS-REQ ::= SEQUENCE { PA-PK-AS-REQ ::= SEQUENCE {
signedAuthPack [0] IMPLICIT OCTET STRING, signedAuthPack [0] IMPLICIT OCTET STRING,
trustedCertifiers [1] ExternalPrincipalIdentifiers OPTIONAL, trustedCertifiers [1] ExternalPrincipalIdentifiers OPTIONAL,
kdcPkId [2] IMPLICIT OCTET STRING OPTIONAL, kdcPkId [2] IMPLICIT OCTET STRING OPTIONAL,
..., ...,
} }
*/ */
typedef struct PA_PK_AS_REQ { typedef struct PA_PK_AS_REQ {
heim_octet_string signedAuthPack; heim_octet_string signedAuthPack;
ExternalPrincipalIdentifiers *trustedCertifiers; ExternalPrincipalIdentifiers *trustedCertifiers;
heim_octet_string *kdcPkId; heim_octet_string *kdcPkId;
} PA_PK_AS_REQ; } PA_PK_AS_REQ;
int encode_PA_PK_AS_REQ(unsigned char *, size_t, const PA_PK_AS_REQ *, s ASN1EXP int ASN1CALL decode_PA_PK_AS_REQ(const unsigned char *, size_t,
ize_t *); PA_PK_AS_REQ *, size_t *);
int decode_PA_PK_AS_REQ(const unsigned char *, size_t, PA_PK_AS_REQ *, s ASN1EXP int ASN1CALL encode_PA_PK_AS_REQ(unsigned char *, size_t, const
ize_t *); PA_PK_AS_REQ *, size_t *);
void free_PA_PK_AS_REQ (PA_PK_AS_REQ *); ASN1EXP size_t ASN1CALL length_PA_PK_AS_REQ(const PA_PK_AS_REQ *);
size_t length_PA_PK_AS_REQ(const PA_PK_AS_REQ *); ASN1EXP int ASN1CALL copy_PA_PK_AS_REQ (const PA_PK_AS_REQ *, PA_PK_AS_
int copy_PA_PK_AS_REQ (const PA_PK_AS_REQ *, PA_PK_AS_REQ *); REQ *);
ASN1EXP void ASN1CALL free_PA_PK_AS_REQ (PA_PK_AS_REQ *);
/* /*
PKAuthenticator ::= SEQUENCE { PKAuthenticator ::= SEQUENCE {
cusec [0] INTEGER, cusec [0] INTEGER,
ctime [1] KerberosTime, ctime [1] KerberosTime,
nonce [2] INTEGER (0..2147483647), nonce [2] INTEGER (0..2147483647),
paChecksum [3] OCTET STRING OPTIONAL, paChecksum [3] OCTET STRING OPTIONAL,
..., ...,
} }
*/ */
typedef struct PKAuthenticator { typedef struct PKAuthenticator {
heim_integer cusec; heim_integer cusec;
KerberosTime ctime; KerberosTime ctime;
unsigned int nonce; unsigned int nonce;
heim_octet_string *paChecksum; heim_octet_string *paChecksum;
} PKAuthenticator; } PKAuthenticator;
int encode_PKAuthenticator(unsigned char *, size_t, const PKAuthenticato ASN1EXP int ASN1CALL decode_PKAuthenticator(const unsigned char *, size_
r *, size_t *); t, PKAuthenticator *, size_t *);
int decode_PKAuthenticator(const unsigned char *, size_t, PKAuthenticato ASN1EXP int ASN1CALL encode_PKAuthenticator(unsigned char *, size_t, con
r *, size_t *); st PKAuthenticator *, size_t *);
void free_PKAuthenticator (PKAuthenticator *); ASN1EXP size_t ASN1CALL length_PKAuthenticator(const PKAuthenticator *);
size_t length_PKAuthenticator(const PKAuthenticator *); ASN1EXP int ASN1CALL copy_PKAuthenticator (const PKAuthenticator *, PKA
int copy_PKAuthenticator (const PKAuthenticator *, PKAuthenticator *); uthenticator *);
ASN1EXP void ASN1CALL free_PKAuthenticator (PKAuthenticator *);
/* /*
AuthPack ::= SEQUENCE { AuthPack ::= SEQUENCE {
pkAuthenticator [0] PKAuthenticator, pkAuthenticator [0] PKAuthenticator,
clientPublicValue [1] SubjectPublicKeyInfo OPTIONAL, clientPublicValue [1] SubjectPublicKeyInfo OPTIONAL,
supportedCMSTypes [2] SEQUENCE OF AlgorithmIdentifier OPTIONAL, supportedCMSTypes [2] SEQUENCE OF AlgorithmIdentifier OPTIONAL,
clientDHNonce [3] DHNonce OPTIONAL, clientDHNonce [3] DHNonce OPTIONAL,
..., ...,
supportedKDFs [4] SEQUENCE OF KDFAlgorithmId OPTIONAL, supportedKDFs [4] SEQUENCE OF KDFAlgorithmId OPTIONAL,
..., ...,
} }
*/ */
typedef struct AuthPack { typedef struct AuthPack {
PKAuthenticator pkAuthenticator; PKAuthenticator pkAuthenticator;
SubjectPublicKeyInfo *clientPublicValue; SubjectPublicKeyInfo *clientPublicValue;
struct { struct AuthPack_supportedCMSTypes {
unsigned int len; unsigned int len;
AlgorithmIdentifier *val; AlgorithmIdentifier *val;
} *supportedCMSTypes; } *supportedCMSTypes;
DHNonce *clientDHNonce; DHNonce *clientDHNonce;
struct { struct AuthPack_supportedKDFs {
unsigned int len; unsigned int len;
KDFAlgorithmId *val; KDFAlgorithmId *val;
} *supportedKDFs; } *supportedKDFs;
} AuthPack; } AuthPack;
int encode_AuthPack(unsigned char *, size_t, const AuthPack *, size_t *) ASN1EXP int ASN1CALL decode_AuthPack(const unsigned char *, size_t, Auth
; Pack *, size_t *);
int decode_AuthPack(const unsigned char *, size_t, AuthPack *, size_t *) ASN1EXP int ASN1CALL encode_AuthPack(unsigned char *, size_t, const Auth
; Pack *, size_t *);
void free_AuthPack (AuthPack *); ASN1EXP size_t ASN1CALL length_AuthPack(const AuthPack *);
size_t length_AuthPack(const AuthPack *); ASN1EXP int ASN1CALL copy_AuthPack (const AuthPack *, AuthPack *);
int copy_AuthPack (const AuthPack *, AuthPack *); ASN1EXP void ASN1CALL free_AuthPack (AuthPack *);
/* /*
TD-TRUSTED-CERTIFIERS ::= ExternalPrincipalIdentifiers TD-TRUSTED-CERTIFIERS ::= ExternalPrincipalIdentifiers
*/ */
typedef ExternalPrincipalIdentifiers TD_TRUSTED_CERTIFIERS; typedef ExternalPrincipalIdentifiers TD_TRUSTED_CERTIFIERS;
int encode_TD_TRUSTED_CERTIFIERS(unsigned char *, size_t, const TD_TRUST ASN1EXP int ASN1CALL decode_TD_TRUSTED_CERTIFIERS(const unsigned char *,
ED_CERTIFIERS *, size_t *); size_t, TD_TRUSTED_CERTIFIERS *, size_t *);
int decode_TD_TRUSTED_CERTIFIERS(const unsigned char *, size_t, TD_TRUST ASN1EXP int ASN1CALL encode_TD_TRUSTED_CERTIFIERS(unsigned char *, size_
ED_CERTIFIERS *, size_t *); t, const TD_TRUSTED_CERTIFIERS *, size_t *);
void free_TD_TRUSTED_CERTIFIERS (TD_TRUSTED_CERTIFIERS *); ASN1EXP size_t ASN1CALL length_TD_TRUSTED_CERTIFIERS(const TD_TRUSTED_CERTI
size_t length_TD_TRUSTED_CERTIFIERS(const TD_TRUSTED_CERTIFIERS *); FIERS *);
int copy_TD_TRUSTED_CERTIFIERS (const TD_TRUSTED_CERTIFIERS *, TD_TRUST ASN1EXP int ASN1CALL copy_TD_TRUSTED_CERTIFIERS (const TD_TRUSTED_CERTI
ED_CERTIFIERS *); FIERS *, TD_TRUSTED_CERTIFIERS *);
ASN1EXP void ASN1CALL free_TD_TRUSTED_CERTIFIERS (TD_TRUSTED_CERTIFIERS
*);
/* /*
TD-INVALID-CERTIFICATES ::= ExternalPrincipalIdentifiers TD-INVALID-CERTIFICATES ::= ExternalPrincipalIdentifiers
*/ */
typedef ExternalPrincipalIdentifiers TD_INVALID_CERTIFICATES; typedef ExternalPrincipalIdentifiers TD_INVALID_CERTIFICATES;
int encode_TD_INVALID_CERTIFICATES(unsigned char *, size_t, const TD_INV ASN1EXP int ASN1CALL decode_TD_INVALID_CERTIFICATES(const unsigned char
ALID_CERTIFICATES *, size_t *); *, size_t, TD_INVALID_CERTIFICATES *, size_t *);
int decode_TD_INVALID_CERTIFICATES(const unsigned char *, size_t, TD_INV ASN1EXP int ASN1CALL encode_TD_INVALID_CERTIFICATES(unsigned char *, siz
ALID_CERTIFICATES *, size_t *); e_t, const TD_INVALID_CERTIFICATES *, size_t *);
void free_TD_INVALID_CERTIFICATES (TD_INVALID_CERTIFICATES *); ASN1EXP size_t ASN1CALL length_TD_INVALID_CERTIFICATES(const TD_INVALID_CER
size_t length_TD_INVALID_CERTIFICATES(const TD_INVALID_CERTIFICATES *); TIFICATES *);
int copy_TD_INVALID_CERTIFICATES (const TD_INVALID_CERTIFICATES *, TD_I ASN1EXP int ASN1CALL copy_TD_INVALID_CERTIFICATES (const TD_INVALID_CER
NVALID_CERTIFICATES *); TIFICATES *, TD_INVALID_CERTIFICATES *);
ASN1EXP void ASN1CALL free_TD_INVALID_CERTIFICATES (TD_INVALID_CERTIFICA
TES *);
/* /*
KRB5PrincipalName ::= SEQUENCE { KRB5PrincipalName ::= SEQUENCE {
realm [0] Realm, realm [0] Realm,
principalName [1] PrincipalName, principalName [1] PrincipalName,
} }
*/ */
typedef struct KRB5PrincipalName { typedef struct KRB5PrincipalName {
Realm realm; Realm realm;
PrincipalName principalName; PrincipalName principalName;
} KRB5PrincipalName; } KRB5PrincipalName;
int encode_KRB5PrincipalName(unsigned char *, size_t, const KRB5Principa ASN1EXP int ASN1CALL decode_KRB5PrincipalName(const unsigned char *, siz
lName *, size_t *); e_t, KRB5PrincipalName *, size_t *);
int decode_KRB5PrincipalName(const unsigned char *, size_t, KRB5Principa ASN1EXP int ASN1CALL encode_KRB5PrincipalName(unsigned char *, size_t, c
lName *, size_t *); onst KRB5PrincipalName *, size_t *);
void free_KRB5PrincipalName (KRB5PrincipalName *); ASN1EXP size_t ASN1CALL length_KRB5PrincipalName(const KRB5PrincipalName *)
size_t length_KRB5PrincipalName(const KRB5PrincipalName *); ;
int copy_KRB5PrincipalName (const KRB5PrincipalName *, KRB5PrincipalNam ASN1EXP int ASN1CALL copy_KRB5PrincipalName (const KRB5PrincipalName *,
e *); KRB5PrincipalName *);
ASN1EXP void ASN1CALL free_KRB5PrincipalName (KRB5PrincipalName *);
/* /*
AD-INITIAL-VERIFIED-CAS ::= SEQUENCE OF ExternalPrincipalIdentifier AD-INITIAL-VERIFIED-CAS ::= SEQUENCE OF ExternalPrincipalIdentifier
*/ */
typedef struct AD_INITIAL_VERIFIED_CAS { typedef struct AD_INITIAL_VERIFIED_CAS {
unsigned int len; unsigned int len;
ExternalPrincipalIdentifier *val; ExternalPrincipalIdentifier *val;
} AD_INITIAL_VERIFIED_CAS; } AD_INITIAL_VERIFIED_CAS;
int encode_AD_INITIAL_VERIFIED_CAS(unsigned char *, size_t, const AD_INI ASN1EXP int ASN1CALL decode_AD_INITIAL_VERIFIED_CAS(const unsigned char
TIAL_VERIFIED_CAS *, size_t *); *, size_t, AD_INITIAL_VERIFIED_CAS *, size_t *);
int decode_AD_INITIAL_VERIFIED_CAS(const unsigned char *, size_t, AD_INI ASN1EXP int ASN1CALL encode_AD_INITIAL_VERIFIED_CAS(unsigned char *, siz
TIAL_VERIFIED_CAS *, size_t *); e_t, const AD_INITIAL_VERIFIED_CAS *, size_t *);
void free_AD_INITIAL_VERIFIED_CAS (AD_INITIAL_VERIFIED_CAS *); ASN1EXP size_t ASN1CALL length_AD_INITIAL_VERIFIED_CAS(const AD_INITIAL_VER
size_t length_AD_INITIAL_VERIFIED_CAS(const AD_INITIAL_VERIFIED_CAS *); IFIED_CAS *);
int copy_AD_INITIAL_VERIFIED_CAS (const AD_INITIAL_VERIFIED_CAS *, AD_I ASN1EXP int ASN1CALL copy_AD_INITIAL_VERIFIED_CAS (const AD_INITIAL_VER
NITIAL_VERIFIED_CAS *); IFIED_CAS *, AD_INITIAL_VERIFIED_CAS *);
ASN1EXP void ASN1CALL free_AD_INITIAL_VERIFIED_CAS (AD_INITIAL_VERIFIED_
CAS *);
/* /*
DHRepInfo ::= SEQUENCE { DHRepInfo ::= SEQUENCE {
dhSignedData [0] IMPLICIT OCTET STRING, dhSignedData [0] IMPLICIT OCTET STRING,
serverDHNonce [1] DHNonce OPTIONAL, serverDHNonce [1] DHNonce OPTIONAL,
..., ...,
kdf [2] KDFAlgorithmId OPTIONAL, kdf [2] KDFAlgorithmId OPTIONAL,
..., ...,
} }
*/ */
typedef struct DHRepInfo { typedef struct DHRepInfo {
heim_octet_string dhSignedData; heim_octet_string dhSignedData;
DHNonce *serverDHNonce; DHNonce *serverDHNonce;
KDFAlgorithmId *kdf; KDFAlgorithmId *kdf;
} DHRepInfo; } DHRepInfo;
int encode_DHRepInfo(unsigned char *, size_t, const DHRepInfo *, size_t ASN1EXP int ASN1CALL decode_DHRepInfo(const unsigned char *, size_t, DHR
*); epInfo *, size_t *);
int decode_DHRepInfo(const unsigned char *, size_t, DHRepInfo *, size_t ASN1EXP int ASN1CALL encode_DHRepInfo(unsigned char *, size_t, const DHR
*); epInfo *, size_t *);
void free_DHRepInfo (DHRepInfo *); ASN1EXP size_t ASN1CALL length_DHRepInfo(const DHRepInfo *);
size_t length_DHRepInfo(const DHRepInfo *); ASN1EXP int ASN1CALL copy_DHRepInfo (const DHRepInfo *, DHRepInfo *);
int copy_DHRepInfo (const DHRepInfo *, DHRepInfo *); ASN1EXP void ASN1CALL free_DHRepInfo (DHRepInfo *);
/* /*
PA-PK-AS-REP ::= CHOICE { PA-PK-AS-REP ::= CHOICE {
dhInfo [0] DHRepInfo, dhInfo [0] DHRepInfo,
encKeyPack [1] IMPLICIT OCTET STRING, encKeyPack [1] IMPLICIT OCTET STRING,
..., ...,
} }
*/ */
typedef struct PA_PK_AS_REP { typedef struct PA_PK_AS_REP {
skipping to change at line 418 skipping to change at line 429
choice_PA_PK_AS_REP_encKeyPack choice_PA_PK_AS_REP_encKeyPack
/* ... */ /* ... */
} element; } element;
union { union {
DHRepInfo dhInfo; DHRepInfo dhInfo;
heim_octet_string encKeyPack; heim_octet_string encKeyPack;
heim_octet_string asn1_ellipsis; heim_octet_string asn1_ellipsis;
} u; } u;
} PA_PK_AS_REP; } PA_PK_AS_REP;
int encode_PA_PK_AS_REP(unsigned char *, size_t, const PA_PK_AS_REP *, s ASN1EXP int ASN1CALL decode_PA_PK_AS_REP(const unsigned char *, size_t,
ize_t *); PA_PK_AS_REP *, size_t *);
int decode_PA_PK_AS_REP(const unsigned char *, size_t, PA_PK_AS_REP *, s ASN1EXP int ASN1CALL encode_PA_PK_AS_REP(unsigned char *, size_t, const
ize_t *); PA_PK_AS_REP *, size_t *);
void free_PA_PK_AS_REP (PA_PK_AS_REP *); ASN1EXP size_t ASN1CALL length_PA_PK_AS_REP(const PA_PK_AS_REP *);
size_t length_PA_PK_AS_REP(const PA_PK_AS_REP *); ASN1EXP int ASN1CALL copy_PA_PK_AS_REP (const PA_PK_AS_REP *, PA_PK_AS_
int copy_PA_PK_AS_REP (const PA_PK_AS_REP *, PA_PK_AS_REP *); REP *);
ASN1EXP void ASN1CALL free_PA_PK_AS_REP (PA_PK_AS_REP *);
/* /*
KDCDHKeyInfo ::= SEQUENCE { KDCDHKeyInfo ::= SEQUENCE {
subjectPublicKey [0] BIT STRING { subjectPublicKey [0] BIT STRING {
}, },
nonce [1] INTEGER (0..2147483647), nonce [1] INTEGER (0..2147483647),
dhKeyExpiration [2] KerberosTime OPTIONAL, dhKeyExpiration [2] KerberosTime OPTIONAL,
..., ...,
} }
*/ */
typedef struct KDCDHKeyInfo { typedef struct KDCDHKeyInfo {
heim_bit_string subjectPublicKey; heim_bit_string subjectPublicKey;
unsigned int nonce; unsigned int nonce;
KerberosTime *dhKeyExpiration; KerberosTime *dhKeyExpiration;
} KDCDHKeyInfo; } KDCDHKeyInfo;
int encode_KDCDHKeyInfo(unsigned char *, size_t, const KDCDHKeyInfo *, s ASN1EXP int ASN1CALL decode_KDCDHKeyInfo(const unsigned char *, size_t,
ize_t *); KDCDHKeyInfo *, size_t *);
int decode_KDCDHKeyInfo(const unsigned char *, size_t, KDCDHKeyInfo *, s ASN1EXP int ASN1CALL encode_KDCDHKeyInfo(unsigned char *, size_t, const
ize_t *); KDCDHKeyInfo *, size_t *);
void free_KDCDHKeyInfo (KDCDHKeyInfo *); ASN1EXP size_t ASN1CALL length_KDCDHKeyInfo(const KDCDHKeyInfo *);
size_t length_KDCDHKeyInfo(const KDCDHKeyInfo *); ASN1EXP int ASN1CALL copy_KDCDHKeyInfo (const KDCDHKeyInfo *, KDCDHKeyI
int copy_KDCDHKeyInfo (const KDCDHKeyInfo *, KDCDHKeyInfo *); nfo *);
ASN1EXP void ASN1CALL free_KDCDHKeyInfo (KDCDHKeyInfo *);
/* /*
ReplyKeyPack ::= SEQUENCE { ReplyKeyPack ::= SEQUENCE {
replyKey [0] EncryptionKey, replyKey [0] EncryptionKey,
asChecksum [1] Checksum, asChecksum [1] Checksum,
..., ...,
} }
*/ */
typedef struct ReplyKeyPack { typedef struct ReplyKeyPack {
EncryptionKey replyKey; EncryptionKey replyKey;
Checksum asChecksum; Checksum asChecksum;
} ReplyKeyPack; } ReplyKeyPack;
int encode_ReplyKeyPack(unsigned char *, size_t, const ReplyKeyPack *, s ASN1EXP int ASN1CALL decode_ReplyKeyPack(const unsigned char *, size_t,
ize_t *); ReplyKeyPack *, size_t *);
int decode_ReplyKeyPack(const unsigned char *, size_t, ReplyKeyPack *, s ASN1EXP int ASN1CALL encode_ReplyKeyPack(unsigned char *, size_t, const
ize_t *); ReplyKeyPack *, size_t *);
void free_ReplyKeyPack (ReplyKeyPack *); ASN1EXP size_t ASN1CALL length_ReplyKeyPack(const ReplyKeyPack *);
size_t length_ReplyKeyPack(const ReplyKeyPack *); ASN1EXP int ASN1CALL copy_ReplyKeyPack (const ReplyKeyPack *, ReplyKeyP
int copy_ReplyKeyPack (const ReplyKeyPack *, ReplyKeyPack *); ack *);
ASN1EXP void ASN1CALL free_ReplyKeyPack (ReplyKeyPack *);
/* /*
TD-DH-PARAMETERS ::= SEQUENCE OF AlgorithmIdentifier TD-DH-PARAMETERS ::= SEQUENCE OF AlgorithmIdentifier
*/ */
typedef struct TD_DH_PARAMETERS { typedef struct TD_DH_PARAMETERS {
unsigned int len; unsigned int len;
AlgorithmIdentifier *val; AlgorithmIdentifier *val;
} TD_DH_PARAMETERS; } TD_DH_PARAMETERS;
int encode_TD_DH_PARAMETERS(unsigned char *, size_t, const TD_DH_PARAMET ASN1EXP int ASN1CALL decode_TD_DH_PARAMETERS(const unsigned char *, size
ERS *, size_t *); _t, TD_DH_PARAMETERS *, size_t *);
int decode_TD_DH_PARAMETERS(const unsigned char *, size_t, TD_DH_PARAMET ASN1EXP int ASN1CALL encode_TD_DH_PARAMETERS(unsigned char *, size_t, co
ERS *, size_t *); nst TD_DH_PARAMETERS *, size_t *);
void free_TD_DH_PARAMETERS (TD_DH_PARAMETERS *); ASN1EXP size_t ASN1CALL length_TD_DH_PARAMETERS(const TD_DH_PARAMETERS *);
size_t length_TD_DH_PARAMETERS(const TD_DH_PARAMETERS *); ASN1EXP int ASN1CALL copy_TD_DH_PARAMETERS (const TD_DH_PARAMETERS *, T
int copy_TD_DH_PARAMETERS (const TD_DH_PARAMETERS *, TD_DH_PARAMETERS * D_DH_PARAMETERS *);
); ASN1EXP void ASN1CALL free_TD_DH_PARAMETERS (TD_DH_PARAMETERS *);
/* /*
PKAuthenticator-Win2k ::= SEQUENCE { PKAuthenticator-Win2k ::= SEQUENCE {
kdcName [0] PrincipalName, kdcName [0] PrincipalName,
kdcRealm [1] Realm, kdcRealm [1] Realm,
cusec [2] INTEGER (0..2147483647), cusec [2] INTEGER (0..2147483647),
ctime [3] KerberosTime, ctime [3] KerberosTime,
nonce [4] INTEGER (-2147483648..2147483647), nonce [4] INTEGER (-2147483648..2147483647),
} }
*/ */
typedef struct PKAuthenticator_Win2k { typedef struct PKAuthenticator_Win2k {
PrincipalName kdcName; PrincipalName kdcName;
Realm kdcRealm; Realm kdcRealm;
unsigned int cusec; unsigned int cusec;
KerberosTime ctime; KerberosTime ctime;
int nonce; int nonce;
} PKAuthenticator_Win2k; } PKAuthenticator_Win2k;
int encode_PKAuthenticator_Win2k(unsigned char *, size_t, const PKAuthen ASN1EXP int ASN1CALL decode_PKAuthenticator_Win2k(const unsigned char *,
ticator_Win2k *, size_t *); size_t, PKAuthenticator_Win2k *, size_t *);
int decode_PKAuthenticator_Win2k(const unsigned char *, size_t, PKAuthen ASN1EXP int ASN1CALL encode_PKAuthenticator_Win2k(unsigned char *, size_
ticator_Win2k *, size_t *); t, const PKAuthenticator_Win2k *, size_t *);
void free_PKAuthenticator_Win2k (PKAuthenticator_Win2k *); ASN1EXP size_t ASN1CALL length_PKAuthenticator_Win2k(const PKAuthenticator_
size_t length_PKAuthenticator_Win2k(const PKAuthenticator_Win2k *); Win2k *);
int copy_PKAuthenticator_Win2k (const PKAuthenticator_Win2k *, PKAuthen ASN1EXP int ASN1CALL copy_PKAuthenticator_Win2k (const PKAuthenticator_
ticator_Win2k *); Win2k *, PKAuthenticator_Win2k *);
ASN1EXP void ASN1CALL free_PKAuthenticator_Win2k (PKAuthenticator_Win2k
*);
/* /*
AuthPack-Win2k ::= SEQUENCE { AuthPack-Win2k ::= SEQUENCE {
pkAuthenticator [0] PKAuthenticator-Win2k, pkAuthenticator [0] PKAuthenticator-Win2k,
clientPublicValue [1] SubjectPublicKeyInfo OPTIONAL, clientPublicValue [1] SubjectPublicKeyInfo OPTIONAL,
} }
*/ */
typedef struct AuthPack_Win2k { typedef struct AuthPack_Win2k {
PKAuthenticator_Win2k pkAuthenticator; PKAuthenticator_Win2k pkAuthenticator;
SubjectPublicKeyInfo *clientPublicValue; SubjectPublicKeyInfo *clientPublicValue;
} AuthPack_Win2k; } AuthPack_Win2k;
int encode_AuthPack_Win2k(unsigned char *, size_t, const AuthPack_Win2k ASN1EXP int ASN1CALL decode_AuthPack_Win2k(const unsigned char *, size_t
*, size_t *); , AuthPack_Win2k *, size_t *);
int decode_AuthPack_Win2k(const unsigned char *, size_t, AuthPack_Win2k ASN1EXP int ASN1CALL encode_AuthPack_Win2k(unsigned char *, size_t, cons
*, size_t *); t AuthPack_Win2k *, size_t *);
void free_AuthPack_Win2k (AuthPack_Win2k *); ASN1EXP size_t ASN1CALL length_AuthPack_Win2k(const AuthPack_Win2k *);
size_t length_AuthPack_Win2k(const AuthPack_Win2k *); ASN1EXP int ASN1CALL copy_AuthPack_Win2k (const AuthPack_Win2k *, AuthP
int copy_AuthPack_Win2k (const AuthPack_Win2k *, AuthPack_Win2k *); ack_Win2k *);
ASN1EXP void ASN1CALL free_AuthPack_Win2k (AuthPack_Win2k *);
/* /*
TrustedCA-Win2k ::= CHOICE { TrustedCA-Win2k ::= CHOICE {
caName [1] heim_any, caName [1] heim_any,
issuerAndSerial [2] IssuerAndSerialNumber, issuerAndSerial [2] IssuerAndSerialNumber,
} }
*/ */
typedef struct TrustedCA_Win2k { typedef struct TrustedCA_Win2k {
enum { enum {
choice_TrustedCA_Win2k_caName = 1, choice_TrustedCA_Win2k_caName = 1,
choice_TrustedCA_Win2k_issuerAndSerial choice_TrustedCA_Win2k_issuerAndSerial
} element; } element;
union { union {
heim_any caName; heim_any caName;
IssuerAndSerialNumber issuerAndSerial; IssuerAndSerialNumber issuerAndSerial;
} u; } u;
} TrustedCA_Win2k; } TrustedCA_Win2k;
int encode_TrustedCA_Win2k(unsigned char *, size_t, const TrustedCA_Win2 ASN1EXP int ASN1CALL decode_TrustedCA_Win2k(const unsigned char *, size_
k *, size_t *); t, TrustedCA_Win2k *, size_t *);
int decode_TrustedCA_Win2k(const unsigned char *, size_t, TrustedCA_Win2 ASN1EXP int ASN1CALL encode_TrustedCA_Win2k(unsigned char *, size_t, con
k *, size_t *); st TrustedCA_Win2k *, size_t *);
void free_TrustedCA_Win2k (TrustedCA_Win2k *); ASN1EXP size_t ASN1CALL length_TrustedCA_Win2k(const TrustedCA_Win2k *);
size_t length_TrustedCA_Win2k(const TrustedCA_Win2k *); ASN1EXP int ASN1CALL copy_TrustedCA_Win2k (const TrustedCA_Win2k *, Tru
int copy_TrustedCA_Win2k (const TrustedCA_Win2k *, TrustedCA_Win2k *); stedCA_Win2k *);
ASN1EXP void ASN1CALL free_TrustedCA_Win2k (TrustedCA_Win2k *);
/* /*
PA-PK-AS-REQ-Win2k ::= SEQUENCE { PA-PK-AS-REQ-Win2k ::= SEQUENCE {
signed-auth-pack [0] IMPLICIT OCTET STRING, signed-auth-pack [0] IMPLICIT OCTET STRING,
trusted-certifiers [2] SEQUENCE OF TrustedCA-Win2k OPTIONAL, trusted-certifiers [2] SEQUENCE OF TrustedCA-Win2k OPTIONAL,
kdc-cert [3] IMPLICIT OCTET STRING OPTIONAL, kdc-cert [3] IMPLICIT OCTET STRING OPTIONAL,
encryption-cert [4] IMPLICIT OCTET STRING OPTIONAL, encryption-cert [4] IMPLICIT OCTET STRING OPTIONAL,
} }
*/ */
typedef struct PA_PK_AS_REQ_Win2k { typedef struct PA_PK_AS_REQ_Win2k {
heim_octet_string signed_auth_pack; heim_octet_string signed_auth_pack;
struct { struct PA_PK_AS_REQ_Win2k_trusted_certifiers {
unsigned int len; unsigned int len;
TrustedCA_Win2k *val; TrustedCA_Win2k *val;
} *trusted_certifiers; } *trusted_certifiers;
heim_octet_string *kdc_cert; heim_octet_string *kdc_cert;
heim_octet_string *encryption_cert; heim_octet_string *encryption_cert;
} PA_PK_AS_REQ_Win2k; } PA_PK_AS_REQ_Win2k;
int encode_PA_PK_AS_REQ_Win2k(unsigned char *, size_t, const PA_PK_AS_RE ASN1EXP int ASN1CALL decode_PA_PK_AS_REQ_Win2k(const unsigned char *, si
Q_Win2k *, size_t *); ze_t, PA_PK_AS_REQ_Win2k *, size_t *);
int decode_PA_PK_AS_REQ_Win2k(const unsigned char *, size_t, PA_PK_AS_RE ASN1EXP int ASN1CALL encode_PA_PK_AS_REQ_Win2k(unsigned char *, size_t,
Q_Win2k *, size_t *); const PA_PK_AS_REQ_Win2k *, size_t *);
void free_PA_PK_AS_REQ_Win2k (PA_PK_AS_REQ_Win2k *); ASN1EXP size_t ASN1CALL length_PA_PK_AS_REQ_Win2k(const PA_PK_AS_REQ_Win2k
size_t length_PA_PK_AS_REQ_Win2k(const PA_PK_AS_REQ_Win2k *); *);
int copy_PA_PK_AS_REQ_Win2k (const PA_PK_AS_REQ_Win2k *, PA_PK_AS_REQ_W ASN1EXP int ASN1CALL copy_PA_PK_AS_REQ_Win2k (const PA_PK_AS_REQ_Win2k
in2k *); *, PA_PK_AS_REQ_Win2k *);
ASN1EXP void ASN1CALL free_PA_PK_AS_REQ_Win2k (PA_PK_AS_REQ_Win2k *);
/* /*
PA-PK-AS-REP-Win2k ::= CHOICE { PA-PK-AS-REP-Win2k ::= CHOICE {
dhSignedData [0] IMPLICIT OCTET STRING, dhSignedData [0] IMPLICIT OCTET STRING,
encKeyPack [1] IMPLICIT OCTET STRING, encKeyPack [1] IMPLICIT OCTET STRING,
} }
*/ */
typedef struct PA_PK_AS_REP_Win2k { typedef struct PA_PK_AS_REP_Win2k {
enum { enum {
choice_PA_PK_AS_REP_Win2k_dhSignedData = 1, choice_PA_PK_AS_REP_Win2k_dhSignedData = 1,
choice_PA_PK_AS_REP_Win2k_encKeyPack choice_PA_PK_AS_REP_Win2k_encKeyPack
} element; } element;
union { union {
heim_octet_string dhSignedData; heim_octet_string dhSignedData;
heim_octet_string encKeyPack; heim_octet_string encKeyPack;
} u; } u;
} PA_PK_AS_REP_Win2k; } PA_PK_AS_REP_Win2k;
int encode_PA_PK_AS_REP_Win2k(unsigned char *, size_t, const PA_PK_AS_RE ASN1EXP int ASN1CALL decode_PA_PK_AS_REP_Win2k(const unsigned char *, si
P_Win2k *, size_t *); ze_t, PA_PK_AS_REP_Win2k *, size_t *);
int decode_PA_PK_AS_REP_Win2k(const unsigned char *, size_t, PA_PK_AS_RE ASN1EXP int ASN1CALL encode_PA_PK_AS_REP_Win2k(unsigned char *, size_t,
P_Win2k *, size_t *); const PA_PK_AS_REP_Win2k *, size_t *);
void free_PA_PK_AS_REP_Win2k (PA_PK_AS_REP_Win2k *); ASN1EXP size_t ASN1CALL length_PA_PK_AS_REP_Win2k(const PA_PK_AS_REP_Win2k
size_t length_PA_PK_AS_REP_Win2k(const PA_PK_AS_REP_Win2k *); *);
int copy_PA_PK_AS_REP_Win2k (const PA_PK_AS_REP_Win2k *, PA_PK_AS_REP_W ASN1EXP int ASN1CALL copy_PA_PK_AS_REP_Win2k (const PA_PK_AS_REP_Win2k
in2k *); *, PA_PK_AS_REP_Win2k *);
ASN1EXP void ASN1CALL free_PA_PK_AS_REP_Win2k (PA_PK_AS_REP_Win2k *);
/* /*
KDCDHKeyInfo-Win2k ::= SEQUENCE { KDCDHKeyInfo-Win2k ::= SEQUENCE {
nonce [0] INTEGER (-2147483648..2147483647), nonce [0] INTEGER (-2147483648..2147483647),
subjectPublicKey [2] BIT STRING { subjectPublicKey [2] BIT STRING {
}, },
} }
*/ */
typedef struct KDCDHKeyInfo_Win2k { typedef struct KDCDHKeyInfo_Win2k {
int nonce; int nonce;
heim_bit_string subjectPublicKey; heim_bit_string subjectPublicKey;
} KDCDHKeyInfo_Win2k; } KDCDHKeyInfo_Win2k;
int encode_KDCDHKeyInfo_Win2k(unsigned char *, size_t, const KDCDHKeyInf ASN1EXP int ASN1CALL decode_KDCDHKeyInfo_Win2k(const unsigned char *, si
o_Win2k *, size_t *); ze_t, KDCDHKeyInfo_Win2k *, size_t *);
int decode_KDCDHKeyInfo_Win2k(const unsigned char *, size_t, KDCDHKeyInf ASN1EXP int ASN1CALL encode_KDCDHKeyInfo_Win2k(unsigned char *, size_t,
o_Win2k *, size_t *); const KDCDHKeyInfo_Win2k *, size_t *);
void free_KDCDHKeyInfo_Win2k (KDCDHKeyInfo_Win2k *); ASN1EXP size_t ASN1CALL length_KDCDHKeyInfo_Win2k(const KDCDHKeyInfo_Win2k
size_t length_KDCDHKeyInfo_Win2k(const KDCDHKeyInfo_Win2k *); *);
int copy_KDCDHKeyInfo_Win2k (const KDCDHKeyInfo_Win2k *, KDCDHKeyInfo_W ASN1EXP int ASN1CALL copy_KDCDHKeyInfo_Win2k (const KDCDHKeyInfo_Win2k
in2k *); *, KDCDHKeyInfo_Win2k *);
ASN1EXP void ASN1CALL free_KDCDHKeyInfo_Win2k (KDCDHKeyInfo_Win2k *);
/* /*
ReplyKeyPack-Win2k ::= SEQUENCE { ReplyKeyPack-Win2k ::= SEQUENCE {
replyKey [0] EncryptionKey, replyKey [0] EncryptionKey,
nonce [1] INTEGER (-2147483648..2147483647), nonce [1] INTEGER (-2147483648..2147483647),
..., ...,
} }
*/ */
typedef struct ReplyKeyPack_Win2k { typedef struct ReplyKeyPack_Win2k {
EncryptionKey replyKey; EncryptionKey replyKey;
int nonce; int nonce;
} ReplyKeyPack_Win2k; } ReplyKeyPack_Win2k;
int encode_ReplyKeyPack_Win2k(unsigned char *, size_t, const ReplyKeyPac ASN1EXP int ASN1CALL decode_ReplyKeyPack_Win2k(const unsigned char *, si
k_Win2k *, size_t *); ze_t, ReplyKeyPack_Win2k *, size_t *);
int decode_ReplyKeyPack_Win2k(const unsigned char *, size_t, ReplyKeyPac ASN1EXP int ASN1CALL encode_ReplyKeyPack_Win2k(unsigned char *, size_t,
k_Win2k *, size_t *); const ReplyKeyPack_Win2k *, size_t *);
void free_ReplyKeyPack_Win2k (ReplyKeyPack_Win2k *); ASN1EXP size_t ASN1CALL length_ReplyKeyPack_Win2k(const ReplyKeyPack_Win2k
size_t length_ReplyKeyPack_Win2k(const ReplyKeyPack_Win2k *); *);
int copy_ReplyKeyPack_Win2k (const ReplyKeyPack_Win2k *, ReplyKeyPack_W ASN1EXP int ASN1CALL copy_ReplyKeyPack_Win2k (const ReplyKeyPack_Win2k
in2k *); *, ReplyKeyPack_Win2k *);
ASN1EXP void ASN1CALL free_ReplyKeyPack_Win2k (ReplyKeyPack_Win2k *);
/* /*
PA-PK-AS-REP-BTMM ::= SEQUENCE { PA-PK-AS-REP-BTMM ::= SEQUENCE {
dhSignedData [0] heim_any OPTIONAL, dhSignedData [0] heim_any OPTIONAL,
encKeyPack [1] heim_any OPTIONAL, encKeyPack [1] heim_any OPTIONAL,
} }
*/ */
typedef struct PA_PK_AS_REP_BTMM { typedef struct PA_PK_AS_REP_BTMM {
heim_any *dhSignedData; heim_any *dhSignedData;
heim_any *encKeyPack; heim_any *encKeyPack;
} PA_PK_AS_REP_BTMM; } PA_PK_AS_REP_BTMM;
int encode_PA_PK_AS_REP_BTMM(unsigned char *, size_t, const PA_PK_AS_REP ASN1EXP int ASN1CALL decode_PA_PK_AS_REP_BTMM(const unsigned char *, siz
_BTMM *, size_t *); e_t, PA_PK_AS_REP_BTMM *, size_t *);
int decode_PA_PK_AS_REP_BTMM(const unsigned char *, size_t, PA_PK_AS_REP ASN1EXP int ASN1CALL encode_PA_PK_AS_REP_BTMM(unsigned char *, size_t, c
_BTMM *, size_t *); onst PA_PK_AS_REP_BTMM *, size_t *);
void free_PA_PK_AS_REP_BTMM (PA_PK_AS_REP_BTMM *); ASN1EXP size_t ASN1CALL length_PA_PK_AS_REP_BTMM(const PA_PK_AS_REP_BTMM *)
size_t length_PA_PK_AS_REP_BTMM(const PA_PK_AS_REP_BTMM *); ;
int copy_PA_PK_AS_REP_BTMM (const PA_PK_AS_REP_BTMM *, PA_PK_AS_REP_BTM ASN1EXP int ASN1CALL copy_PA_PK_AS_REP_BTMM (const PA_PK_AS_REP_BTMM *,
M *); PA_PK_AS_REP_BTMM *);
ASN1EXP void ASN1CALL free_PA_PK_AS_REP_BTMM (PA_PK_AS_REP_BTMM *);
/* /*
PkinitSP80056AOtherInfo ::= SEQUENCE { PkinitSP80056AOtherInfo ::= SEQUENCE {
algorithmID AlgorithmIdentifier, algorithmID AlgorithmIdentifier,
partyUInfo [0] OCTET STRING, partyUInfo [0] OCTET STRING,
partyVInfo [1] OCTET STRING, partyVInfo [1] OCTET STRING,
suppPubInfo [2] OCTET STRING OPTIONAL, suppPubInfo [2] OCTET STRING OPTIONAL,
suppPrivInfo [3] OCTET STRING OPTIONAL, suppPrivInfo [3] OCTET STRING OPTIONAL,
} }
*/ */
typedef struct PkinitSP80056AOtherInfo { typedef struct PkinitSP80056AOtherInfo {
AlgorithmIdentifier algorithmID; AlgorithmIdentifier algorithmID;
heim_octet_string partyUInfo; heim_octet_string partyUInfo;
heim_octet_string partyVInfo; heim_octet_string partyVInfo;
heim_octet_string *suppPubInfo; heim_octet_string *suppPubInfo;
heim_octet_string *suppPrivInfo; heim_octet_string *suppPrivInfo;
} PkinitSP80056AOtherInfo; } PkinitSP80056AOtherInfo;
int encode_PkinitSP80056AOtherInfo(unsigned char *, size_t, const Pkinit ASN1EXP int ASN1CALL decode_PkinitSP80056AOtherInfo(const unsigned char
SP80056AOtherInfo *, size_t *); *, size_t, PkinitSP80056AOtherInfo *, size_t *);
int decode_PkinitSP80056AOtherInfo(const unsigned char *, size_t, Pkinit ASN1EXP int ASN1CALL encode_PkinitSP80056AOtherInfo(unsigned char *, siz
SP80056AOtherInfo *, size_t *); e_t, const PkinitSP80056AOtherInfo *, size_t *);
void free_PkinitSP80056AOtherInfo (PkinitSP80056AOtherInfo *); ASN1EXP size_t ASN1CALL length_PkinitSP80056AOtherInfo(const PkinitSP80056A
size_t length_PkinitSP80056AOtherInfo(const PkinitSP80056AOtherInfo *); OtherInfo *);
int copy_PkinitSP80056AOtherInfo (const PkinitSP80056AOtherInfo *, Pkin ASN1EXP int ASN1CALL copy_PkinitSP80056AOtherInfo (const PkinitSP80056A
itSP80056AOtherInfo *); OtherInfo *, PkinitSP80056AOtherInfo *);
ASN1EXP void ASN1CALL free_PkinitSP80056AOtherInfo (PkinitSP80056AOtherI
nfo *);
/* /*
PkinitSuppPubInfo ::= SEQUENCE { PkinitSuppPubInfo ::= SEQUENCE {
enctype [0] INTEGER (-2147483648..2147483647), enctype [0] INTEGER (-2147483648..2147483647),
as-REQ [1] OCTET STRING, as-REQ [1] OCTET STRING,
pk-as-rep [2] OCTET STRING, pk-as-rep [2] OCTET STRING,
ticket [3] Ticket, ticket [3] Ticket,
..., ...,
} }
*/ */
typedef struct PkinitSuppPubInfo { typedef struct PkinitSuppPubInfo {
int enctype; int enctype;
heim_octet_string as_REQ; heim_octet_string as_REQ;
heim_octet_string pk_as_rep; heim_octet_string pk_as_rep;
Ticket ticket; Ticket ticket;
} PkinitSuppPubInfo; } PkinitSuppPubInfo;
int encode_PkinitSuppPubInfo(unsigned char *, size_t, const PkinitSuppPu ASN1EXP int ASN1CALL decode_PkinitSuppPubInfo(const unsigned char *, siz
bInfo *, size_t *); e_t, PkinitSuppPubInfo *, size_t *);
int decode_PkinitSuppPubInfo(const unsigned char *, size_t, PkinitSuppPu ASN1EXP int ASN1CALL encode_PkinitSuppPubInfo(unsigned char *, size_t, c
bInfo *, size_t *); onst PkinitSuppPubInfo *, size_t *);
void free_PkinitSuppPubInfo (PkinitSuppPubInfo *); ASN1EXP size_t ASN1CALL length_PkinitSuppPubInfo(const PkinitSuppPubInfo *)
size_t length_PkinitSuppPubInfo(const PkinitSuppPubInfo *); ;
int copy_PkinitSuppPubInfo (const PkinitSuppPubInfo *, PkinitSuppPubInf ASN1EXP int ASN1CALL copy_PkinitSuppPubInfo (const PkinitSuppPubInfo *,
o *); PkinitSuppPubInfo *);
ASN1EXP void ASN1CALL free_PkinitSuppPubInfo (PkinitSuppPubInfo *);
#endif /* __pkinit_asn1_h__ */ #endif /* __pkinit_asn1_h__ */
 End of changes. 60 change blocks. 
229 lines changed or deleted 270 lines changed or added


 private.h   private.h 
skipping to change at line 77 skipping to change at line 77
int fd; int fd;
char *name; char *name;
krb5_auth_context ac; krb5_auth_context ac;
struct kadm5_log_peer *next; struct kadm5_log_peer *next;
} kadm5_log_peer; } kadm5_log_peer;
typedef struct kadm5_log_context { typedef struct kadm5_log_context {
char *log_file; char *log_file;
int log_fd; int log_fd;
uint32_t version; uint32_t version;
#ifndef NO_UNIX_SOCKETS
struct sockaddr_un socket_name; struct sockaddr_un socket_name;
int socket_fd; #else
struct addrinfo *socket_info;
#endif
krb5_socket_t socket_fd;
} kadm5_log_context; } kadm5_log_context;
typedef struct kadm5_server_context { typedef struct kadm5_server_context {
krb5_context context; krb5_context context;
krb5_boolean my_context; krb5_boolean my_context;
struct kadm_func funcs; struct kadm_func funcs;
/* */ /* */
kadm5_config_params config; kadm5_config_params config;
HDB *db; HDB *db;
krb5_principal caller; krb5_principal caller;
 End of changes. 2 change blocks. 
1 lines changed or deleted 5 lines changed or added


 resolve.h   resolve.h 
skipping to change at line 41 skipping to change at line 41
* SUCH DAMAGE. * SUCH DAMAGE.
*/ */
/* $Id$ */ /* $Id$ */
#ifndef __RESOLVE_H__ #ifndef __RESOLVE_H__
#define __RESOLVE_H__ #define __RESOLVE_H__
#ifndef ROKEN_LIB_FUNCTION #ifndef ROKEN_LIB_FUNCTION
#ifdef _WIN32 #ifdef _WIN32
#define ROKEN_LIB_FUNCTION _stdcall #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL __cdecl
#else #else
#define ROKEN_LIB_FUNCTION #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL
#endif #endif
#endif #endif
enum { enum {
rk_ns_c_in = 1 rk_ns_c_in = 1
}; };
enum { enum {
rk_ns_t_invalid = 0, /* Cookie. */ rk_ns_t_invalid = 0, /* Cookie. */
rk_ns_t_a = 1, /* Host address. */ rk_ns_t_a = 1, /* Host address. */
skipping to change at line 154 skipping to change at line 156
struct rk_sig_record { struct rk_sig_record {
unsigned type; unsigned type;
unsigned algorithm; unsigned algorithm;
unsigned labels; unsigned labels;
unsigned orig_ttl; unsigned orig_ttl;
unsigned sig_expiration; unsigned sig_expiration;
unsigned sig_inception; unsigned sig_inception;
unsigned key_tag; unsigned key_tag;
char *signer; char *signer;
unsigned sig_len; size_t sig_len;
char sig_data[1]; /* also includes signer */ char sig_data[1]; /* also includes signer */
}; };
struct rk_cert_record { struct rk_cert_record {
unsigned type; unsigned type;
unsigned tag; unsigned tag;
unsigned algorithm; unsigned algorithm;
size_t cert_len; size_t cert_len;
u_char cert_data[1]; u_char cert_data[1];
}; };
skipping to change at line 177 skipping to change at line 179
unsigned algorithm; unsigned algorithm;
unsigned type; unsigned type;
size_t sshfp_len; size_t sshfp_len;
u_char sshfp_data[1]; u_char sshfp_data[1];
}; };
struct rk_ds_record { struct rk_ds_record {
unsigned key_tag; unsigned key_tag;
unsigned algorithm; unsigned algorithm;
unsigned digest_type; unsigned digest_type;
unsigned digest_len; size_t digest_len;
u_char digest_data[1]; u_char digest_data[1];
}; };
struct rk_resource_record{ struct rk_resource_record{
char *domain; char *domain;
unsigned type; unsigned type;
unsigned class; unsigned class;
unsigned ttl; unsigned ttl;
unsigned size; unsigned size;
union { union {
skipping to change at line 233 skipping to change at line 235
struct rk_dns_reply{ struct rk_dns_reply{
struct rk_dns_header h; struct rk_dns_header h;
struct rk_dns_query q; struct rk_dns_query q;
struct rk_resource_record *head; struct rk_resource_record *head;
}; };
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
struct rk_dns_reply* ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION struct rk_dns_reply* ROKEN_LIB_CALL
rk_dns_lookup(const char *, const char *); rk_dns_lookup(const char *, const char *);
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
rk_dns_free_data(struct rk_dns_reply *); rk_dns_free_data(struct rk_dns_reply *);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rk_dns_string_to_type(const char *name); rk_dns_string_to_type(const char *name);
const char *ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION const char * ROKEN_LIB_CALL
rk_dns_type_to_string(int type); rk_dns_type_to_string(int type);
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
rk_dns_srv_order(struct rk_dns_reply*); rk_dns_srv_order(struct rk_dns_reply*);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* __RESOLVE_H__ */ #endif /* __RESOLVE_H__ */
 End of changes. 9 change blocks. 
8 lines changed or deleted 10 lines changed or added


 rfc2459_asn1.h   rfc2459_asn1.h 
skipping to change at line 28 skipping to change at line 28
typedef struct heim_octet_string { typedef struct heim_octet_string {
size_t length; size_t length;
void *data; void *data;
} heim_octet_string; } heim_octet_string;
typedef char *heim_general_string; typedef char *heim_general_string;
typedef char *heim_utf8_string; typedef char *heim_utf8_string;
typedef char *heim_printable_string; typedef struct heim_octet_string heim_printable_string;
typedef char *heim_ia5_string; typedef struct heim_octet_string heim_ia5_string;
typedef struct heim_bmp_string { typedef struct heim_bmp_string {
size_t length; size_t length;
uint16_t *data; uint16_t *data;
} heim_bmp_string; } heim_bmp_string;
typedef struct heim_universal_string { typedef struct heim_universal_string {
size_t length; size_t length;
uint32_t *data; uint32_t *data;
} heim_universal_string; } heim_universal_string;
skipping to change at line 73 skipping to change at line 73
} else { \ } else { \
(R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
(S), (L)); \ (S), (L)); \
if((R) != 0) { \ if((R) != 0) { \
free((B)); \ free((B)); \
(B) = NULL; \ (B) = NULL; \
} \ } \
} \ } \
} while (0) } while (0)
#ifdef _WIN32
#ifndef ASN1_LIB
#define ASN1EXP __declspec(dllimport)
#else
#define ASN1EXP
#endif
#define ASN1CALL __stdcall
#else
#define ASN1EXP
#define ASN1CALL
#endif
struct units; struct units;
#endif #endif
#include <heim_asn1.h> #include <heim_asn1.h>
/* /*
Version ::= INTEGER { Version ::= INTEGER {
rfc3280_version_1(0), rfc3280_version_1(0),
rfc3280_version_2(1), rfc3280_version_2(1),
rfc3280_version_3(2) rfc3280_version_3(2)
} }
*/ */
typedef enum Version { typedef enum Version {
rfc3280_version_1 = 0, rfc3280_version_1 = 0,
rfc3280_version_2 = 1, rfc3280_version_2 = 1,
rfc3280_version_3 = 2 rfc3280_version_3 = 2
} Version; } Version;
int encode_Version(unsigned char *, size_t, const Version *, size_t *); ASN1EXP int ASN1CALL decode_Version(const unsigned char *, size_t, Versi
int decode_Version(const unsigned char *, size_t, Version *, size_t *); on *, size_t *);
void free_Version (Version *); ASN1EXP int ASN1CALL encode_Version(unsigned char *, size_t, const Versi
size_t length_Version(const Version *); on *, size_t *);
int copy_Version (const Version *, Version *); ASN1EXP size_t ASN1CALL length_Version(const Version *);
ASN1EXP int ASN1CALL copy_Version (const Version *, Version *);
ASN1EXP void ASN1CALL free_Version (Version *);
/* OBJECT IDENTIFIER id-pkcs-1 ::= { iso(1) member-body(2) us(840) rsadsi(1 13549) pkcs(1) label-less(1) } */ /* OBJECT IDENTIFIER id-pkcs-1 ::= { iso(1) member-body(2) us(840) rsadsi(1 13549) pkcs(1) label-less(1) } */
const heim_oid *oid_id_pkcs_1(void);
extern const heim_oid asn1_oid_id_pkcs_1; extern const heim_oid asn1_oid_id_pkcs_1;
#define ASN1_OID_ID_PKCS_1 (&asn1_oid_id_pkcs_1)
/* OBJECT IDENTIFIER id-pkcs1-rsaEncryption ::= { iso(1) member-body(2) us( 840) rsadsi(113549) pkcs(1) label-less(1) label-less(1) } */ /* OBJECT IDENTIFIER id-pkcs1-rsaEncryption ::= { iso(1) member-body(2) us( 840) rsadsi(113549) pkcs(1) label-less(1) label-less(1) } */
const heim_oid *oid_id_pkcs1_rsaEncryption(void);
extern const heim_oid asn1_oid_id_pkcs1_rsaEncryption; extern const heim_oid asn1_oid_id_pkcs1_rsaEncryption;
#define ASN1_OID_ID_PKCS1_RSAENCRYPTION (&asn1_oid_id_pkcs1_rsaEncryption)
/* OBJECT IDENTIFIER id-pkcs1-md2WithRSAEncryption ::= { iso(1) member-body (2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(2) } */ /* OBJECT IDENTIFIER id-pkcs1-md2WithRSAEncryption ::= { iso(1) member-body (2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(2) } */
const heim_oid *oid_id_pkcs1_md2WithRSAEncryption(void);
extern const heim_oid asn1_oid_id_pkcs1_md2WithRSAEncryption; extern const heim_oid asn1_oid_id_pkcs1_md2WithRSAEncryption;
#define ASN1_OID_ID_PKCS1_MD2WITHRSAENCRYPTION (&asn1_oid_id_pkcs1_md2WithR SAEncryption)
/* OBJECT IDENTIFIER id-pkcs1-md5WithRSAEncryption ::= { iso(1) member-body (2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(4) } */ /* OBJECT IDENTIFIER id-pkcs1-md5WithRSAEncryption ::= { iso(1) member-body (2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(4) } */
const heim_oid *oid_id_pkcs1_md5WithRSAEncryption(void);
extern const heim_oid asn1_oid_id_pkcs1_md5WithRSAEncryption; extern const heim_oid asn1_oid_id_pkcs1_md5WithRSAEncryption;
#define ASN1_OID_ID_PKCS1_MD5WITHRSAENCRYPTION (&asn1_oid_id_pkcs1_md5WithR SAEncryption)
/* OBJECT IDENTIFIER id-pkcs1-sha1WithRSAEncryption ::= { iso(1) member-bod y(2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(5) } */ /* OBJECT IDENTIFIER id-pkcs1-sha1WithRSAEncryption ::= { iso(1) member-bod y(2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(5) } */
const heim_oid *oid_id_pkcs1_sha1WithRSAEncryption(void);
extern const heim_oid asn1_oid_id_pkcs1_sha1WithRSAEncryption; extern const heim_oid asn1_oid_id_pkcs1_sha1WithRSAEncryption;
#define ASN1_OID_ID_PKCS1_SHA1WITHRSAENCRYPTION (&asn1_oid_id_pkcs1_sha1Wit hRSAEncryption)
/* OBJECT IDENTIFIER id-pkcs1-sha256WithRSAEncryption ::= { iso(1) member-b ody(2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(11) } */ /* OBJECT IDENTIFIER id-pkcs1-sha256WithRSAEncryption ::= { iso(1) member-b ody(2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(11) } */
const heim_oid *oid_id_pkcs1_sha256WithRSAEncryption(void);
extern const heim_oid asn1_oid_id_pkcs1_sha256WithRSAEncryption; extern const heim_oid asn1_oid_id_pkcs1_sha256WithRSAEncryption;
#define ASN1_OID_ID_PKCS1_SHA256WITHRSAENCRYPTION (&asn1_oid_id_pkcs1_sha25 6WithRSAEncryption)
/* OBJECT IDENTIFIER id-pkcs1-sha384WithRSAEncryption ::= { iso(1) member-b ody(2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(12) } */ /* OBJECT IDENTIFIER id-pkcs1-sha384WithRSAEncryption ::= { iso(1) member-b ody(2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(12) } */
const heim_oid *oid_id_pkcs1_sha384WithRSAEncryption(void);
extern const heim_oid asn1_oid_id_pkcs1_sha384WithRSAEncryption; extern const heim_oid asn1_oid_id_pkcs1_sha384WithRSAEncryption;
#define ASN1_OID_ID_PKCS1_SHA384WITHRSAENCRYPTION (&asn1_oid_id_pkcs1_sha38 4WithRSAEncryption)
/* OBJECT IDENTIFIER id-pkcs1-sha512WithRSAEncryption ::= { iso(1) member-b ody(2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(13) } */ /* OBJECT IDENTIFIER id-pkcs1-sha512WithRSAEncryption ::= { iso(1) member-b ody(2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(13) } */
const heim_oid *oid_id_pkcs1_sha512WithRSAEncryption(void);
extern const heim_oid asn1_oid_id_pkcs1_sha512WithRSAEncryption; extern const heim_oid asn1_oid_id_pkcs1_sha512WithRSAEncryption;
#define ASN1_OID_ID_PKCS1_SHA512WITHRSAENCRYPTION (&asn1_oid_id_pkcs1_sha51 2WithRSAEncryption)
/* OBJECT IDENTIFIER id-heim-rsa-pkcs1-x509 ::= { label-less(1) label-less( 2) label-less(752) label-less(43) label-less(16) label-less(1) } */ /* OBJECT IDENTIFIER id-heim-rsa-pkcs1-x509 ::= { label-less(1) label-less( 2) label-less(752) label-less(43) label-less(16) label-less(1) } */
const heim_oid *oid_id_heim_rsa_pkcs1_x509(void);
extern const heim_oid asn1_oid_id_heim_rsa_pkcs1_x509; extern const heim_oid asn1_oid_id_heim_rsa_pkcs1_x509;
#define ASN1_OID_ID_HEIM_RSA_PKCS1_X509 (&asn1_oid_id_heim_rsa_pkcs1_x509)
/* OBJECT IDENTIFIER id-pkcs-2 ::= { iso(1) member-body(2) us(840) rsadsi(1 13549) pkcs(1) label-less(2) } */ /* OBJECT IDENTIFIER id-pkcs-2 ::= { iso(1) member-body(2) us(840) rsadsi(1 13549) pkcs(1) label-less(2) } */
const heim_oid *oid_id_pkcs_2(void);
extern const heim_oid asn1_oid_id_pkcs_2; extern const heim_oid asn1_oid_id_pkcs_2;
#define ASN1_OID_ID_PKCS_2 (&asn1_oid_id_pkcs_2)
/* OBJECT IDENTIFIER id-pkcs2-md2 ::= { iso(1) member-body(2) us(840) rsads i(113549) pkcs(1) label-less(2) label-less(2) } */ /* OBJECT IDENTIFIER id-pkcs2-md2 ::= { iso(1) member-body(2) us(840) rsads i(113549) pkcs(1) label-less(2) label-less(2) } */
const heim_oid *oid_id_pkcs2_md2(void);
extern const heim_oid asn1_oid_id_pkcs2_md2; extern const heim_oid asn1_oid_id_pkcs2_md2;
#define ASN1_OID_ID_PKCS2_MD2 (&asn1_oid_id_pkcs2_md2)
/* OBJECT IDENTIFIER id-pkcs2-md4 ::= { iso(1) member-body(2) us(840) rsads i(113549) pkcs(1) label-less(2) label-less(4) } */ /* OBJECT IDENTIFIER id-pkcs2-md4 ::= { iso(1) member-body(2) us(840) rsads i(113549) pkcs(1) label-less(2) label-less(4) } */
const heim_oid *oid_id_pkcs2_md4(void);
extern const heim_oid asn1_oid_id_pkcs2_md4; extern const heim_oid asn1_oid_id_pkcs2_md4;
#define ASN1_OID_ID_PKCS2_MD4 (&asn1_oid_id_pkcs2_md4)
/* OBJECT IDENTIFIER id-pkcs2-md5 ::= { iso(1) member-body(2) us(840) rsads i(113549) pkcs(1) label-less(2) label-less(5) } */ /* OBJECT IDENTIFIER id-pkcs2-md5 ::= { iso(1) member-body(2) us(840) rsads i(113549) pkcs(1) label-less(2) label-less(5) } */
const heim_oid *oid_id_pkcs2_md5(void);
extern const heim_oid asn1_oid_id_pkcs2_md5; extern const heim_oid asn1_oid_id_pkcs2_md5;
#define ASN1_OID_ID_PKCS2_MD5 (&asn1_oid_id_pkcs2_md5)
/* OBJECT IDENTIFIER id-rsa-digestAlgorithm ::= { iso(1) member-body(2) us( 840) rsadsi(113549) label-less(2) } */ /* OBJECT IDENTIFIER id-rsa-digestAlgorithm ::= { iso(1) member-body(2) us( 840) rsadsi(113549) label-less(2) } */
const heim_oid *oid_id_rsa_digestAlgorithm(void);
extern const heim_oid asn1_oid_id_rsa_digestAlgorithm; extern const heim_oid asn1_oid_id_rsa_digestAlgorithm;
#define ASN1_OID_ID_RSA_DIGESTALGORITHM (&asn1_oid_id_rsa_digestAlgorithm)
/* OBJECT IDENTIFIER id-rsa-digest-md2 ::= { iso(1) member-body(2) us(840) rsadsi(113549) label-less(2) label-less(2) } */ /* OBJECT IDENTIFIER id-rsa-digest-md2 ::= { iso(1) member-body(2) us(840) rsadsi(113549) label-less(2) label-less(2) } */
const heim_oid *oid_id_rsa_digest_md2(void);
extern const heim_oid asn1_oid_id_rsa_digest_md2; extern const heim_oid asn1_oid_id_rsa_digest_md2;
#define ASN1_OID_ID_RSA_DIGEST_MD2 (&asn1_oid_id_rsa_digest_md2)
/* OBJECT IDENTIFIER id-rsa-digest-md4 ::= { iso(1) member-body(2) us(840) rsadsi(113549) label-less(2) label-less(4) } */ /* OBJECT IDENTIFIER id-rsa-digest-md4 ::= { iso(1) member-body(2) us(840) rsadsi(113549) label-less(2) label-less(4) } */
const heim_oid *oid_id_rsa_digest_md4(void);
extern const heim_oid asn1_oid_id_rsa_digest_md4; extern const heim_oid asn1_oid_id_rsa_digest_md4;
#define ASN1_OID_ID_RSA_DIGEST_MD4 (&asn1_oid_id_rsa_digest_md4)
/* OBJECT IDENTIFIER id-rsa-digest-md5 ::= { iso(1) member-body(2) us(840) rsadsi(113549) label-less(2) label-less(5) } */ /* OBJECT IDENTIFIER id-rsa-digest-md5 ::= { iso(1) member-body(2) us(840) rsadsi(113549) label-less(2) label-less(5) } */
const heim_oid *oid_id_rsa_digest_md5(void);
extern const heim_oid asn1_oid_id_rsa_digest_md5; extern const heim_oid asn1_oid_id_rsa_digest_md5;
#define ASN1_OID_ID_RSA_DIGEST_MD5 (&asn1_oid_id_rsa_digest_md5)
/* OBJECT IDENTIFIER id-pkcs-3 ::= { iso(1) member-body(2) us(840) rsadsi(1 13549) pkcs(1) label-less(3) } */ /* OBJECT IDENTIFIER id-pkcs-3 ::= { iso(1) member-body(2) us(840) rsadsi(1 13549) pkcs(1) label-less(3) } */
const heim_oid *oid_id_pkcs_3(void);
extern const heim_oid asn1_oid_id_pkcs_3; extern const heim_oid asn1_oid_id_pkcs_3;
#define ASN1_OID_ID_PKCS_3 (&asn1_oid_id_pkcs_3)
/* OBJECT IDENTIFIER id-pkcs3-rc2-cbc ::= { iso(1) member-body(2) us(840) r sadsi(113549) pkcs(1) label-less(3) label-less(2) } */ /* OBJECT IDENTIFIER id-pkcs3-rc2-cbc ::= { iso(1) member-body(2) us(840) r sadsi(113549) pkcs(1) label-less(3) label-less(2) } */
const heim_oid *oid_id_pkcs3_rc2_cbc(void);
extern const heim_oid asn1_oid_id_pkcs3_rc2_cbc; extern const heim_oid asn1_oid_id_pkcs3_rc2_cbc;
#define ASN1_OID_ID_PKCS3_RC2_CBC (&asn1_oid_id_pkcs3_rc2_cbc)
/* OBJECT IDENTIFIER id-pkcs3-rc4 ::= { iso(1) member-body(2) us(840) rsads i(113549) pkcs(1) label-less(3) label-less(4) } */ /* OBJECT IDENTIFIER id-pkcs3-rc4 ::= { iso(1) member-body(2) us(840) rsads i(113549) pkcs(1) label-less(3) label-less(4) } */
const heim_oid *oid_id_pkcs3_rc4(void);
extern const heim_oid asn1_oid_id_pkcs3_rc4; extern const heim_oid asn1_oid_id_pkcs3_rc4;
#define ASN1_OID_ID_PKCS3_RC4 (&asn1_oid_id_pkcs3_rc4)
/* OBJECT IDENTIFIER id-pkcs3-des-ede3-cbc ::= { iso(1) member-body(2) us(8 40) rsadsi(113549) pkcs(1) label-less(3) label-less(7) } */ /* OBJECT IDENTIFIER id-pkcs3-des-ede3-cbc ::= { iso(1) member-body(2) us(8 40) rsadsi(113549) pkcs(1) label-less(3) label-less(7) } */
const heim_oid *oid_id_pkcs3_des_ede3_cbc(void);
extern const heim_oid asn1_oid_id_pkcs3_des_ede3_cbc; extern const heim_oid asn1_oid_id_pkcs3_des_ede3_cbc;
#define ASN1_OID_ID_PKCS3_DES_EDE3_CBC (&asn1_oid_id_pkcs3_des_ede3_cbc)
/* OBJECT IDENTIFIER id-rsadsi-encalg ::= { iso(1) member-body(2) us(840) r sadsi(113549) label-less(3) } */ /* OBJECT IDENTIFIER id-rsadsi-encalg ::= { iso(1) member-body(2) us(840) r sadsi(113549) label-less(3) } */
const heim_oid *oid_id_rsadsi_encalg(void);
extern const heim_oid asn1_oid_id_rsadsi_encalg; extern const heim_oid asn1_oid_id_rsadsi_encalg;
#define ASN1_OID_ID_RSADSI_ENCALG (&asn1_oid_id_rsadsi_encalg)
/* OBJECT IDENTIFIER id-rsadsi-rc2-cbc ::= { iso(1) member-body(2) us(840) rsadsi(113549) label-less(3) label-less(2) } */ /* OBJECT IDENTIFIER id-rsadsi-rc2-cbc ::= { iso(1) member-body(2) us(840) rsadsi(113549) label-less(3) label-less(2) } */
const heim_oid *oid_id_rsadsi_rc2_cbc(void);
extern const heim_oid asn1_oid_id_rsadsi_rc2_cbc; extern const heim_oid asn1_oid_id_rsadsi_rc2_cbc;
#define ASN1_OID_ID_RSADSI_RC2_CBC (&asn1_oid_id_rsadsi_rc2_cbc)
/* OBJECT IDENTIFIER id-rsadsi-des-ede3-cbc ::= { iso(1) member-body(2) us( 840) rsadsi(113549) label-less(3) label-less(7) } */ /* OBJECT IDENTIFIER id-rsadsi-des-ede3-cbc ::= { iso(1) member-body(2) us( 840) rsadsi(113549) label-less(3) label-less(7) } */
const heim_oid *oid_id_rsadsi_des_ede3_cbc(void);
extern const heim_oid asn1_oid_id_rsadsi_des_ede3_cbc; extern const heim_oid asn1_oid_id_rsadsi_des_ede3_cbc;
#define ASN1_OID_ID_RSADSI_DES_EDE3_CBC (&asn1_oid_id_rsadsi_des_ede3_cbc)
/* OBJECT IDENTIFIER id-secsig-sha-1 ::= { iso(1) identified-organization(3 ) oiw(14) secsig(3) algorithm(2) label-less(26) } */ /* OBJECT IDENTIFIER id-secsig-sha-1 ::= { iso(1) identified-organization(3 ) oiw(14) secsig(3) algorithm(2) label-less(26) } */
const heim_oid *oid_id_secsig_sha_1(void);
extern const heim_oid asn1_oid_id_secsig_sha_1; extern const heim_oid asn1_oid_id_secsig_sha_1;
#define ASN1_OID_ID_SECSIG_SHA_1 (&asn1_oid_id_secsig_sha_1)
/* OBJECT IDENTIFIER id-secsig-sha-1WithRSAEncryption ::= { iso(1) identifi
ed-organization(3) oiw(14) secsig(3) algorithm(2) label-less(29) } */
extern const heim_oid asn1_oid_id_secsig_sha_1WithRSAEncryption;
#define ASN1_OID_ID_SECSIG_SHA_1WITHRSAENCRYPTION (&asn1_oid_id_secsig_sha_
1WithRSAEncryption)
/* OBJECT IDENTIFIER id-nistAlgorithm ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) } */ /* OBJECT IDENTIFIER id-nistAlgorithm ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) } */
const heim_oid *oid_id_nistAlgorithm(void);
extern const heim_oid asn1_oid_id_nistAlgorithm; extern const heim_oid asn1_oid_id_nistAlgorithm;
#define ASN1_OID_ID_NISTALGORITHM (&asn1_oid_id_nistAlgorithm)
/* OBJECT IDENTIFIER id-nist-aes-algs ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(1) } */ /* OBJECT IDENTIFIER id-nist-aes-algs ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(1) } */
const heim_oid *oid_id_nist_aes_algs(void);
extern const heim_oid asn1_oid_id_nist_aes_algs; extern const heim_oid asn1_oid_id_nist_aes_algs;
#define ASN1_OID_ID_NIST_AES_ALGS (&asn1_oid_id_nist_aes_algs)
/* OBJECT IDENTIFIER id-aes-128-cbc ::= { joint-iso-itu-t(2) country(16) us (840) organization(1) gov(101) csor(3) label-less(4) label-less(1) label-le ss(2) } */ /* OBJECT IDENTIFIER id-aes-128-cbc ::= { joint-iso-itu-t(2) country(16) us (840) organization(1) gov(101) csor(3) label-less(4) label-less(1) label-le ss(2) } */
const heim_oid *oid_id_aes_128_cbc(void);
extern const heim_oid asn1_oid_id_aes_128_cbc; extern const heim_oid asn1_oid_id_aes_128_cbc;
#define ASN1_OID_ID_AES_128_CBC (&asn1_oid_id_aes_128_cbc)
/* OBJECT IDENTIFIER id-aes-192-cbc ::= { joint-iso-itu-t(2) country(16) us (840) organization(1) gov(101) csor(3) label-less(4) label-less(1) label-le ss(22) } */ /* OBJECT IDENTIFIER id-aes-192-cbc ::= { joint-iso-itu-t(2) country(16) us (840) organization(1) gov(101) csor(3) label-less(4) label-less(1) label-le ss(22) } */
const heim_oid *oid_id_aes_192_cbc(void);
extern const heim_oid asn1_oid_id_aes_192_cbc; extern const heim_oid asn1_oid_id_aes_192_cbc;
#define ASN1_OID_ID_AES_192_CBC (&asn1_oid_id_aes_192_cbc)
/* OBJECT IDENTIFIER id-aes-256-cbc ::= { joint-iso-itu-t(2) country(16) us (840) organization(1) gov(101) csor(3) label-less(4) label-less(1) label-le ss(42) } */ /* OBJECT IDENTIFIER id-aes-256-cbc ::= { joint-iso-itu-t(2) country(16) us (840) organization(1) gov(101) csor(3) label-less(4) label-less(1) label-le ss(42) } */
const heim_oid *oid_id_aes_256_cbc(void);
extern const heim_oid asn1_oid_id_aes_256_cbc; extern const heim_oid asn1_oid_id_aes_256_cbc;
#define ASN1_OID_ID_AES_256_CBC (&asn1_oid_id_aes_256_cbc)
/* OBJECT IDENTIFIER id-nist-sha-algs ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(2) } */ /* OBJECT IDENTIFIER id-nist-sha-algs ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(2) } */
const heim_oid *oid_id_nist_sha_algs(void);
extern const heim_oid asn1_oid_id_nist_sha_algs; extern const heim_oid asn1_oid_id_nist_sha_algs;
#define ASN1_OID_ID_NIST_SHA_ALGS (&asn1_oid_id_nist_sha_algs)
/* OBJECT IDENTIFIER id-sha256 ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(2) label-less(1) } */ /* OBJECT IDENTIFIER id-sha256 ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(2) label-less(1) } */
const heim_oid *oid_id_sha256(void);
extern const heim_oid asn1_oid_id_sha256; extern const heim_oid asn1_oid_id_sha256;
#define ASN1_OID_ID_SHA256 (&asn1_oid_id_sha256)
/* OBJECT IDENTIFIER id-sha224 ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(2) label-less(4) } */ /* OBJECT IDENTIFIER id-sha224 ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(2) label-less(4) } */
const heim_oid *oid_id_sha224(void);
extern const heim_oid asn1_oid_id_sha224; extern const heim_oid asn1_oid_id_sha224;
#define ASN1_OID_ID_SHA224 (&asn1_oid_id_sha224)
/* OBJECT IDENTIFIER id-sha384 ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(2) label-less(2) } */ /* OBJECT IDENTIFIER id-sha384 ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(2) label-less(2) } */
const heim_oid *oid_id_sha384(void);
extern const heim_oid asn1_oid_id_sha384; extern const heim_oid asn1_oid_id_sha384;
#define ASN1_OID_ID_SHA384 (&asn1_oid_id_sha384)
/* OBJECT IDENTIFIER id-sha512 ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(2) label-less(3) } */ /* OBJECT IDENTIFIER id-sha512 ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(2) label-less(3) } */
const heim_oid *oid_id_sha512(void);
extern const heim_oid asn1_oid_id_sha512; extern const heim_oid asn1_oid_id_sha512;
#define ASN1_OID_ID_SHA512 (&asn1_oid_id_sha512)
/* OBJECT IDENTIFIER id-dhpublicnumber ::= { iso(1) member-body(2) us(840) ansi-x942(10046) number-type(2) label-less(1) } */ /* OBJECT IDENTIFIER id-dhpublicnumber ::= { iso(1) member-body(2) us(840) ansi-x942(10046) number-type(2) label-less(1) } */
const heim_oid *oid_id_dhpublicnumber(void);
extern const heim_oid asn1_oid_id_dhpublicnumber; extern const heim_oid asn1_oid_id_dhpublicnumber;
#define ASN1_OID_ID_DHPUBLICNUMBER (&asn1_oid_id_dhpublicnumber)
/* OBJECT IDENTIFIER id-ecPublicKey ::= { iso(1) member-body(2) us(840) ans i-X9-62(10045) keyType(2) label-less(1) } */ /* OBJECT IDENTIFIER id-ecPublicKey ::= { iso(1) member-body(2) us(840) ans i-X9-62(10045) keyType(2) label-less(1) } */
const heim_oid *oid_id_ecPublicKey(void);
extern const heim_oid asn1_oid_id_ecPublicKey; extern const heim_oid asn1_oid_id_ecPublicKey;
#define ASN1_OID_ID_ECPUBLICKEY (&asn1_oid_id_ecPublicKey)
/* OBJECT IDENTIFIER id-ecDH ::= { iso(1) identified-organization(3) certic om(132) schemes(1) ecdh(12) } */ /* OBJECT IDENTIFIER id-ecDH ::= { iso(1) identified-organization(3) certic om(132) schemes(1) ecdh(12) } */
const heim_oid *oid_id_ecDH(void);
extern const heim_oid asn1_oid_id_ecDH; extern const heim_oid asn1_oid_id_ecDH;
#define ASN1_OID_ID_ECDH (&asn1_oid_id_ecDH)
/* OBJECT IDENTIFIER id-ecMQV ::= { iso(1) identified-organization(3) certi com(132) schemes(1) ecmqv(13) } */ /* OBJECT IDENTIFIER id-ecMQV ::= { iso(1) identified-organization(3) certi com(132) schemes(1) ecmqv(13) } */
const heim_oid *oid_id_ecMQV(void);
extern const heim_oid asn1_oid_id_ecMQV; extern const heim_oid asn1_oid_id_ecMQV;
#define ASN1_OID_ID_ECMQV (&asn1_oid_id_ecMQV)
/* OBJECT IDENTIFIER id-ecdsa-with-SHA256 ::= { iso(1) member-body(2) us(84 0) ansi-X9-62(10045) signatures(4) ecdsa-with-SHA2(3) label-less(2) } */ /* OBJECT IDENTIFIER id-ecdsa-with-SHA256 ::= { iso(1) member-body(2) us(84 0) ansi-X9-62(10045) signatures(4) ecdsa-with-SHA2(3) label-less(2) } */
const heim_oid *oid_id_ecdsa_with_SHA256(void);
extern const heim_oid asn1_oid_id_ecdsa_with_SHA256; extern const heim_oid asn1_oid_id_ecdsa_with_SHA256;
#define ASN1_OID_ID_ECDSA_WITH_SHA256 (&asn1_oid_id_ecdsa_with_SHA256)
/* OBJECT IDENTIFIER id-ecdsa-with-SHA1 ::= { iso(1) member-body(2) us(840) ansi-X9-62(10045) signatures(4) label-less(1) } */ /* OBJECT IDENTIFIER id-ecdsa-with-SHA1 ::= { iso(1) member-body(2) us(840) ansi-X9-62(10045) signatures(4) label-less(1) } */
const heim_oid *oid_id_ecdsa_with_SHA1(void);
extern const heim_oid asn1_oid_id_ecdsa_with_SHA1; extern const heim_oid asn1_oid_id_ecdsa_with_SHA1;
#define ASN1_OID_ID_ECDSA_WITH_SHA1 (&asn1_oid_id_ecdsa_with_SHA1)
/* OBJECT IDENTIFIER id-ec-group-secp256r1 ::= { iso(1) member-body(2) us(8 40) ansi-X9-62(10045) curves(3) prime(1) label-less(7) } */ /* OBJECT IDENTIFIER id-ec-group-secp256r1 ::= { iso(1) member-body(2) us(8 40) ansi-X9-62(10045) curves(3) prime(1) label-less(7) } */
const heim_oid *oid_id_ec_group_secp256r1(void);
extern const heim_oid asn1_oid_id_ec_group_secp256r1; extern const heim_oid asn1_oid_id_ec_group_secp256r1;
#define ASN1_OID_ID_EC_GROUP_SECP256R1 (&asn1_oid_id_ec_group_secp256r1)
/* OBJECT IDENTIFIER id-ec-group-secp160r1 ::= { iso(1) identified-organiza tion(3) certicom(132) label-less(0) label-less(8) } */ /* OBJECT IDENTIFIER id-ec-group-secp160r1 ::= { iso(1) identified-organiza tion(3) certicom(132) label-less(0) label-less(8) } */
const heim_oid *oid_id_ec_group_secp160r1(void);
extern const heim_oid asn1_oid_id_ec_group_secp160r1; extern const heim_oid asn1_oid_id_ec_group_secp160r1;
#define ASN1_OID_ID_EC_GROUP_SECP160R1 (&asn1_oid_id_ec_group_secp160r1)
/* OBJECT IDENTIFIER id-ec-group-secp160r2 ::= { iso(1) identified-organiza tion(3) certicom(132) label-less(0) label-less(30) } */ /* OBJECT IDENTIFIER id-ec-group-secp160r2 ::= { iso(1) identified-organiza tion(3) certicom(132) label-less(0) label-less(30) } */
const heim_oid *oid_id_ec_group_secp160r2(void);
extern const heim_oid asn1_oid_id_ec_group_secp160r2; extern const heim_oid asn1_oid_id_ec_group_secp160r2;
#define ASN1_OID_ID_EC_GROUP_SECP160R2 (&asn1_oid_id_ec_group_secp160r2)
/* OBJECT IDENTIFIER id-x9-57 ::= { iso(1) member-body(2) us(840) ansi-x942 (10046) label-less(4) } */ /* OBJECT IDENTIFIER id-x9-57 ::= { iso(1) member-body(2) us(840) ansi-x942 (10046) label-less(4) } */
const heim_oid *oid_id_x9_57(void);
extern const heim_oid asn1_oid_id_x9_57; extern const heim_oid asn1_oid_id_x9_57;
#define ASN1_OID_ID_X9_57 (&asn1_oid_id_x9_57)
/* OBJECT IDENTIFIER id-dsa ::= { iso(1) member-body(2) us(840) ansi-x942(1 0046) label-less(4) label-less(1) } */ /* OBJECT IDENTIFIER id-dsa ::= { iso(1) member-body(2) us(840) ansi-x942(1 0046) label-less(4) label-less(1) } */
const heim_oid *oid_id_dsa(void);
extern const heim_oid asn1_oid_id_dsa; extern const heim_oid asn1_oid_id_dsa;
#define ASN1_OID_ID_DSA (&asn1_oid_id_dsa)
/* OBJECT IDENTIFIER id-dsa-with-sha1 ::= { iso(1) member-body(2) us(840) a nsi-x942(10046) label-less(4) label-less(3) } */ /* OBJECT IDENTIFIER id-dsa-with-sha1 ::= { iso(1) member-body(2) us(840) a nsi-x942(10046) label-less(4) label-less(3) } */
const heim_oid *oid_id_dsa_with_sha1(void);
extern const heim_oid asn1_oid_id_dsa_with_sha1; extern const heim_oid asn1_oid_id_dsa_with_sha1;
#define ASN1_OID_ID_DSA_WITH_SHA1 (&asn1_oid_id_dsa_with_sha1)
/* OBJECT IDENTIFIER id-x520-at ::= { joint-iso-ccitt(2) ds(5) label-less(4 ) } */ /* OBJECT IDENTIFIER id-x520-at ::= { joint-iso-ccitt(2) ds(5) label-less(4 ) } */
const heim_oid *oid_id_x520_at(void);
extern const heim_oid asn1_oid_id_x520_at; extern const heim_oid asn1_oid_id_x520_at;
#define ASN1_OID_ID_X520_AT (&asn1_oid_id_x520_at)
/* OBJECT IDENTIFIER id-at-commonName ::= { joint-iso-ccitt(2) ds(5) label- less(4) label-less(3) } */ /* OBJECT IDENTIFIER id-at-commonName ::= { joint-iso-ccitt(2) ds(5) label- less(4) label-less(3) } */
const heim_oid *oid_id_at_commonName(void);
extern const heim_oid asn1_oid_id_at_commonName; extern const heim_oid asn1_oid_id_at_commonName;
#define ASN1_OID_ID_AT_COMMONNAME (&asn1_oid_id_at_commonName)
/* OBJECT IDENTIFIER id-at-surname ::= { joint-iso-ccitt(2) ds(5) label-les s(4) label-less(4) } */ /* OBJECT IDENTIFIER id-at-surname ::= { joint-iso-ccitt(2) ds(5) label-les s(4) label-less(4) } */
const heim_oid *oid_id_at_surname(void);
extern const heim_oid asn1_oid_id_at_surname; extern const heim_oid asn1_oid_id_at_surname;
#define ASN1_OID_ID_AT_SURNAME (&asn1_oid_id_at_surname)
/* OBJECT IDENTIFIER id-at-serialNumber ::= { joint-iso-ccitt(2) ds(5) labe l-less(4) label-less(5) } */ /* OBJECT IDENTIFIER id-at-serialNumber ::= { joint-iso-ccitt(2) ds(5) labe l-less(4) label-less(5) } */
const heim_oid *oid_id_at_serialNumber(void);
extern const heim_oid asn1_oid_id_at_serialNumber; extern const heim_oid asn1_oid_id_at_serialNumber;
#define ASN1_OID_ID_AT_SERIALNUMBER (&asn1_oid_id_at_serialNumber)
/* OBJECT IDENTIFIER id-at-countryName ::= { joint-iso-ccitt(2) ds(5) label -less(4) label-less(6) } */ /* OBJECT IDENTIFIER id-at-countryName ::= { joint-iso-ccitt(2) ds(5) label -less(4) label-less(6) } */
const heim_oid *oid_id_at_countryName(void);
extern const heim_oid asn1_oid_id_at_countryName; extern const heim_oid asn1_oid_id_at_countryName;
#define ASN1_OID_ID_AT_COUNTRYNAME (&asn1_oid_id_at_countryName)
/* OBJECT IDENTIFIER id-at-localityName ::= { joint-iso-ccitt(2) ds(5) labe l-less(4) label-less(7) } */ /* OBJECT IDENTIFIER id-at-localityName ::= { joint-iso-ccitt(2) ds(5) labe l-less(4) label-less(7) } */
const heim_oid *oid_id_at_localityName(void);
extern const heim_oid asn1_oid_id_at_localityName; extern const heim_oid asn1_oid_id_at_localityName;
#define ASN1_OID_ID_AT_LOCALITYNAME (&asn1_oid_id_at_localityName)
/* OBJECT IDENTIFIER id-at-stateOrProvinceName ::= { joint-iso-ccitt(2) ds( 5) label-less(4) label-less(8) } */ /* OBJECT IDENTIFIER id-at-stateOrProvinceName ::= { joint-iso-ccitt(2) ds( 5) label-less(4) label-less(8) } */
const heim_oid *oid_id_at_stateOrProvinceName(void);
extern const heim_oid asn1_oid_id_at_stateOrProvinceName; extern const heim_oid asn1_oid_id_at_stateOrProvinceName;
#define ASN1_OID_ID_AT_STATEORPROVINCENAME (&asn1_oid_id_at_stateOrProvince Name)
/* OBJECT IDENTIFIER id-at-streetAddress ::= { joint-iso-ccitt(2) ds(5) lab el-less(4) label-less(9) } */ /* OBJECT IDENTIFIER id-at-streetAddress ::= { joint-iso-ccitt(2) ds(5) lab el-less(4) label-less(9) } */
const heim_oid *oid_id_at_streetAddress(void);
extern const heim_oid asn1_oid_id_at_streetAddress; extern const heim_oid asn1_oid_id_at_streetAddress;
#define ASN1_OID_ID_AT_STREETADDRESS (&asn1_oid_id_at_streetAddress)
/* OBJECT IDENTIFIER id-at-organizationName ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(10) } */ /* OBJECT IDENTIFIER id-at-organizationName ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(10) } */
const heim_oid *oid_id_at_organizationName(void);
extern const heim_oid asn1_oid_id_at_organizationName; extern const heim_oid asn1_oid_id_at_organizationName;
#define ASN1_OID_ID_AT_ORGANIZATIONNAME (&asn1_oid_id_at_organizationName)
/* OBJECT IDENTIFIER id-at-organizationalUnitName ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(11) } */ /* OBJECT IDENTIFIER id-at-organizationalUnitName ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(11) } */
const heim_oid *oid_id_at_organizationalUnitName(void);
extern const heim_oid asn1_oid_id_at_organizationalUnitName; extern const heim_oid asn1_oid_id_at_organizationalUnitName;
#define ASN1_OID_ID_AT_ORGANIZATIONALUNITNAME (&asn1_oid_id_at_organization alUnitName)
/* OBJECT IDENTIFIER id-at-name ::= { joint-iso-ccitt(2) ds(5) label-less(4 ) label-less(41) } */ /* OBJECT IDENTIFIER id-at-name ::= { joint-iso-ccitt(2) ds(5) label-less(4 ) label-less(41) } */
const heim_oid *oid_id_at_name(void);
extern const heim_oid asn1_oid_id_at_name; extern const heim_oid asn1_oid_id_at_name;
#define ASN1_OID_ID_AT_NAME (&asn1_oid_id_at_name)
/* OBJECT IDENTIFIER id-at-givenName ::= { joint-iso-ccitt(2) ds(5) label-l ess(4) label-less(42) } */ /* OBJECT IDENTIFIER id-at-givenName ::= { joint-iso-ccitt(2) ds(5) label-l ess(4) label-less(42) } */
const heim_oid *oid_id_at_givenName(void);
extern const heim_oid asn1_oid_id_at_givenName; extern const heim_oid asn1_oid_id_at_givenName;
#define ASN1_OID_ID_AT_GIVENNAME (&asn1_oid_id_at_givenName)
/* OBJECT IDENTIFIER id-at-initials ::= { joint-iso-ccitt(2) ds(5) label-le ss(4) label-less(43) } */ /* OBJECT IDENTIFIER id-at-initials ::= { joint-iso-ccitt(2) ds(5) label-le ss(4) label-less(43) } */
const heim_oid *oid_id_at_initials(void);
extern const heim_oid asn1_oid_id_at_initials; extern const heim_oid asn1_oid_id_at_initials;
#define ASN1_OID_ID_AT_INITIALS (&asn1_oid_id_at_initials)
/* OBJECT IDENTIFIER id-at-generationQualifier ::= { joint-iso-ccitt(2) ds( 5) label-less(4) label-less(44) } */ /* OBJECT IDENTIFIER id-at-generationQualifier ::= { joint-iso-ccitt(2) ds( 5) label-less(4) label-less(44) } */
const heim_oid *oid_id_at_generationQualifier(void);
extern const heim_oid asn1_oid_id_at_generationQualifier; extern const heim_oid asn1_oid_id_at_generationQualifier;
#define ASN1_OID_ID_AT_GENERATIONQUALIFIER (&asn1_oid_id_at_generationQuali fier)
/* OBJECT IDENTIFIER id-at-pseudonym ::= { joint-iso-ccitt(2) ds(5) label-l ess(4) label-less(65) } */ /* OBJECT IDENTIFIER id-at-pseudonym ::= { joint-iso-ccitt(2) ds(5) label-l ess(4) label-less(65) } */
const heim_oid *oid_id_at_pseudonym(void);
extern const heim_oid asn1_oid_id_at_pseudonym; extern const heim_oid asn1_oid_id_at_pseudonym;
#define ASN1_OID_ID_AT_PSEUDONYM (&asn1_oid_id_at_pseudonym)
/* OBJECT IDENTIFIER id-Userid ::= { label-less(0) label-less(9) label-less (2342) label-less(19200300) label-less(100) label-less(1) label-less(1) } * / /* OBJECT IDENTIFIER id-Userid ::= { label-less(0) label-less(9) label-less (2342) label-less(19200300) label-less(100) label-less(1) label-less(1) } * /
const heim_oid *oid_id_Userid(void);
extern const heim_oid asn1_oid_id_Userid; extern const heim_oid asn1_oid_id_Userid;
#define ASN1_OID_ID_USERID (&asn1_oid_id_Userid)
/* OBJECT IDENTIFIER id-domainComponent ::= { label-less(0) label-less(9) l abel-less(2342) label-less(19200300) label-less(100) label-less(1) label-le ss(25) } */ /* OBJECT IDENTIFIER id-domainComponent ::= { label-less(0) label-less(9) l abel-less(2342) label-less(19200300) label-less(100) label-less(1) label-le ss(25) } */
const heim_oid *oid_id_domainComponent(void);
extern const heim_oid asn1_oid_id_domainComponent; extern const heim_oid asn1_oid_id_domainComponent;
#define ASN1_OID_ID_DOMAINCOMPONENT (&asn1_oid_id_domainComponent)
/* OBJECT IDENTIFIER id-x509-ce ::= { joint-iso-ccitt(2) ds(5) label-less(2 9) } */ /* OBJECT IDENTIFIER id-x509-ce ::= { joint-iso-ccitt(2) ds(5) label-less(2 9) } */
const heim_oid *oid_id_x509_ce(void);
extern const heim_oid asn1_oid_id_x509_ce; extern const heim_oid asn1_oid_id_x509_ce;
#define ASN1_OID_ID_X509_CE (&asn1_oid_id_x509_ce)
/* /*
AlgorithmIdentifier ::= SEQUENCE { AlgorithmIdentifier ::= SEQUENCE {
algorithm OBJECT IDENTIFIER, algorithm OBJECT IDENTIFIER,
parameters heim_any OPTIONAL, parameters heim_any OPTIONAL,
} }
*/ */
typedef struct AlgorithmIdentifier { typedef struct AlgorithmIdentifier {
heim_oid algorithm; heim_oid algorithm;
heim_any *parameters; heim_any *parameters;
} AlgorithmIdentifier; } AlgorithmIdentifier;
int encode_AlgorithmIdentifier(unsigned char *, size_t, const AlgorithmI ASN1EXP int ASN1CALL decode_AlgorithmIdentifier(const unsigned char *, s
dentifier *, size_t *); ize_t, AlgorithmIdentifier *, size_t *);
int decode_AlgorithmIdentifier(const unsigned char *, size_t, AlgorithmI ASN1EXP int ASN1CALL encode_AlgorithmIdentifier(unsigned char *, size_t,
dentifier *, size_t *); const AlgorithmIdentifier *, size_t *);
void free_AlgorithmIdentifier (AlgorithmIdentifier *); ASN1EXP size_t ASN1CALL length_AlgorithmIdentifier(const AlgorithmIdentifie
size_t length_AlgorithmIdentifier(const AlgorithmIdentifier *); r *);
int copy_AlgorithmIdentifier (const AlgorithmIdentifier *, AlgorithmIde ASN1EXP int ASN1CALL copy_AlgorithmIdentifier (const AlgorithmIdentifie
ntifier *); r *, AlgorithmIdentifier *);
ASN1EXP void ASN1CALL free_AlgorithmIdentifier (AlgorithmIdentifier *);
/* /*
AttributeType ::= OBJECT IDENTIFIER AttributeType ::= OBJECT IDENTIFIER
*/ */
typedef heim_oid AttributeType; typedef heim_oid AttributeType;
int encode_AttributeType(unsigned char *, size_t, const AttributeType *, ASN1EXP int ASN1CALL decode_AttributeType(const unsigned char *, size_t,
size_t *); AttributeType *, size_t *);
int decode_AttributeType(const unsigned char *, size_t, AttributeType *, ASN1EXP int ASN1CALL encode_AttributeType(unsigned char *, size_t, const
size_t *); AttributeType *, size_t *);
void free_AttributeType (AttributeType *); ASN1EXP size_t ASN1CALL length_AttributeType(const AttributeType *);
size_t length_AttributeType(const AttributeType *); ASN1EXP int ASN1CALL copy_AttributeType (const AttributeType *, Attribu
int copy_AttributeType (const AttributeType *, AttributeType *); teType *);
ASN1EXP void ASN1CALL free_AttributeType (AttributeType *);
/* /*
AttributeValue ::= heim_any AttributeValue ::= heim_any
*/ */
typedef heim_any AttributeValue; typedef heim_any AttributeValue;
int encode_AttributeValue(unsigned char *, size_t, const AttributeValue ASN1EXP int ASN1CALL decode_AttributeValue(const unsigned char *, size_t
*, size_t *); , AttributeValue *, size_t *);
int decode_AttributeValue(const unsigned char *, size_t, AttributeValue ASN1EXP int ASN1CALL encode_AttributeValue(unsigned char *, size_t, cons
*, size_t *); t AttributeValue *, size_t *);
void free_AttributeValue (AttributeValue *); ASN1EXP size_t ASN1CALL length_AttributeValue(const AttributeValue *);
size_t length_AttributeValue(const AttributeValue *); ASN1EXP int ASN1CALL copy_AttributeValue (const AttributeValue *, Attri
int copy_AttributeValue (const AttributeValue *, AttributeValue *); buteValue *);
ASN1EXP void ASN1CALL free_AttributeValue (AttributeValue *);
/* /*
DirectoryString ::= CHOICE { DirectoryString ::= CHOICE {
ia5String IA5String, ia5String IA5String,
teletexString TeletexString, teletexString TeletexString,
printableString PrintableString, printableString PrintableString,
universalString UniversalString, universalString UniversalString,
utf8String UTF8String, utf8String UTF8String,
bmpString BMPString, bmpString BMPString,
} }
skipping to change at line 430 skipping to change at line 445
union { union {
heim_ia5_string ia5String; heim_ia5_string ia5String;
heim_general_string teletexString; heim_general_string teletexString;
heim_printable_string printableString; heim_printable_string printableString;
heim_universal_string universalString; heim_universal_string universalString;
heim_utf8_string utf8String; heim_utf8_string utf8String;
heim_bmp_string bmpString; heim_bmp_string bmpString;
} u; } u;
} DirectoryString; } DirectoryString;
int encode_DirectoryString(unsigned char *, size_t, const DirectoryStrin ASN1EXP int ASN1CALL decode_DirectoryString(const unsigned char *, size_
g *, size_t *); t, DirectoryString *, size_t *);
int decode_DirectoryString(const unsigned char *, size_t, DirectoryStrin ASN1EXP int ASN1CALL encode_DirectoryString(unsigned char *, size_t, con
g *, size_t *); st DirectoryString *, size_t *);
void free_DirectoryString (DirectoryString *); ASN1EXP size_t ASN1CALL length_DirectoryString(const DirectoryString *);
size_t length_DirectoryString(const DirectoryString *); ASN1EXP int ASN1CALL copy_DirectoryString (const DirectoryString *, Dir
int copy_DirectoryString (const DirectoryString *, DirectoryString *); ectoryString *);
ASN1EXP void ASN1CALL free_DirectoryString (DirectoryString *);
/* /*
Attribute ::= SEQUENCE { Attribute ::= SEQUENCE {
type AttributeType, type AttributeType,
value SET OF heim_any, value SET OF heim_any,
} }
*/ */
typedef struct Attribute { typedef struct Attribute {
AttributeType type; AttributeType type;
struct { struct Attribute_value {
unsigned int len; unsigned int len;
heim_any *val; heim_any *val;
} value; } value;
} Attribute; } Attribute;
int encode_Attribute(unsigned char *, size_t, const Attribute *, size_t ASN1EXP int ASN1CALL decode_Attribute(const unsigned char *, size_t, Att
*); ribute *, size_t *);
int decode_Attribute(const unsigned char *, size_t, Attribute *, size_t ASN1EXP int ASN1CALL encode_Attribute(unsigned char *, size_t, const Att
*); ribute *, size_t *);
void free_Attribute (Attribute *); ASN1EXP size_t ASN1CALL length_Attribute(const Attribute *);
size_t length_Attribute(const Attribute *); ASN1EXP int ASN1CALL copy_Attribute (const Attribute *, Attribute *);
int copy_Attribute (const Attribute *, Attribute *); ASN1EXP void ASN1CALL free_Attribute (Attribute *);
/* /*
AttributeTypeAndValue ::= SEQUENCE { AttributeTypeAndValue ::= SEQUENCE {
type AttributeType, type AttributeType,
value DirectoryString, value DirectoryString,
} }
*/ */
typedef struct AttributeTypeAndValue { typedef struct AttributeTypeAndValue {
AttributeType type; AttributeType type;
DirectoryString value; DirectoryString value;
} AttributeTypeAndValue; } AttributeTypeAndValue;
int encode_AttributeTypeAndValue(unsigned char *, size_t, const Attribut ASN1EXP int ASN1CALL decode_AttributeTypeAndValue(const unsigned char *,
eTypeAndValue *, size_t *); size_t, AttributeTypeAndValue *, size_t *);
int decode_AttributeTypeAndValue(const unsigned char *, size_t, Attribut ASN1EXP int ASN1CALL encode_AttributeTypeAndValue(unsigned char *, size_
eTypeAndValue *, size_t *); t, const AttributeTypeAndValue *, size_t *);
void free_AttributeTypeAndValue (AttributeTypeAndValue *); ASN1EXP size_t ASN1CALL length_AttributeTypeAndValue(const AttributeTypeAnd
size_t length_AttributeTypeAndValue(const AttributeTypeAndValue *); Value *);
int copy_AttributeTypeAndValue (const AttributeTypeAndValue *, Attribut ASN1EXP int ASN1CALL copy_AttributeTypeAndValue (const AttributeTypeAnd
eTypeAndValue *); Value *, AttributeTypeAndValue *);
ASN1EXP void ASN1CALL free_AttributeTypeAndValue (AttributeTypeAndValue
*);
/* /*
RelativeDistinguishedName ::= SET OF AttributeTypeAndValue RelativeDistinguishedName ::= SET OF AttributeTypeAndValue
*/ */
typedef struct RelativeDistinguishedName { typedef struct RelativeDistinguishedName {
unsigned int len; unsigned int len;
AttributeTypeAndValue *val; AttributeTypeAndValue *val;
} RelativeDistinguishedName; } RelativeDistinguishedName;
int encode_RelativeDistinguishedName(unsigned char *, size_t, const Rela ASN1EXP int ASN1CALL decode_RelativeDistinguishedName(const unsigned cha
tiveDistinguishedName *, size_t *); r *, size_t, RelativeDistinguishedName *, size_t *);
int decode_RelativeDistinguishedName(const unsigned char *, size_t, Rela ASN1EXP int ASN1CALL encode_RelativeDistinguishedName(unsigned char *, s
tiveDistinguishedName *, size_t *); ize_t, const RelativeDistinguishedName *, size_t *);
void free_RelativeDistinguishedName (RelativeDistinguishedName *); ASN1EXP size_t ASN1CALL length_RelativeDistinguishedName(const RelativeDist
size_t length_RelativeDistinguishedName(const RelativeDistinguishedName *); inguishedName *);
int copy_RelativeDistinguishedName (const RelativeDistinguishedName *, ASN1EXP int ASN1CALL copy_RelativeDistinguishedName (const RelativeDist
RelativeDistinguishedName *); inguishedName *, RelativeDistinguishedName *);
ASN1EXP void ASN1CALL free_RelativeDistinguishedName (RelativeDistinguis
hedName *);
/* /*
RDNSequence ::= SEQUENCE OF RelativeDistinguishedName RDNSequence ::= SEQUENCE OF RelativeDistinguishedName
*/ */
typedef struct RDNSequence { typedef struct RDNSequence {
unsigned int len; unsigned int len;
RelativeDistinguishedName *val; RelativeDistinguishedName *val;
} RDNSequence; } RDNSequence;
int encode_RDNSequence(unsigned char *, size_t, const RDNSequence *, siz ASN1EXP int ASN1CALL decode_RDNSequence(const unsigned char *, size_t, R
e_t *); DNSequence *, size_t *);
int decode_RDNSequence(const unsigned char *, size_t, RDNSequence *, siz ASN1EXP int ASN1CALL encode_RDNSequence(unsigned char *, size_t, const R
e_t *); DNSequence *, size_t *);
void free_RDNSequence (RDNSequence *); ASN1EXP size_t ASN1CALL length_RDNSequence(const RDNSequence *);
size_t length_RDNSequence(const RDNSequence *); ASN1EXP int ASN1CALL copy_RDNSequence (const RDNSequence *, RDNSequence
int copy_RDNSequence (const RDNSequence *, RDNSequence *); *);
ASN1EXP void ASN1CALL free_RDNSequence (RDNSequence *);
/* /*
Name ::= CHOICE { Name ::= CHOICE {
rdnSequence RDNSequence, rdnSequence RDNSequence,
} }
*/ */
typedef struct Name { typedef struct Name {
heim_octet_string _save; heim_octet_string _save;
enum { enum {
choice_Name_rdnSequence = 1 choice_Name_rdnSequence = 1
} element; } element;
union { union {
RDNSequence rdnSequence; RDNSequence rdnSequence;
} u; } u;
} Name; } Name;
int encode_Name(unsigned char *, size_t, const Name *, size_t *); ASN1EXP int ASN1CALL decode_Name(const unsigned char *, size_t, Name *,
int decode_Name(const unsigned char *, size_t, Name *, size_t *); size_t *);
void free_Name (Name *); ASN1EXP int ASN1CALL encode_Name(unsigned char *, size_t, const Name *,
size_t length_Name(const Name *); size_t *);
int copy_Name (const Name *, Name *); ASN1EXP size_t ASN1CALL length_Name(const Name *);
ASN1EXP int ASN1CALL copy_Name (const Name *, Name *);
ASN1EXP void ASN1CALL free_Name (Name *);
/* /*
CertificateSerialNumber ::= INTEGER CertificateSerialNumber ::= INTEGER
*/ */
typedef heim_integer CertificateSerialNumber; typedef heim_integer CertificateSerialNumber;
int encode_CertificateSerialNumber(unsigned char *, size_t, const Certif ASN1EXP int ASN1CALL decode_CertificateSerialNumber(const unsigned char
icateSerialNumber *, size_t *); *, size_t, CertificateSerialNumber *, size_t *);
int decode_CertificateSerialNumber(const unsigned char *, size_t, Certif ASN1EXP int ASN1CALL encode_CertificateSerialNumber(unsigned char *, siz
icateSerialNumber *, size_t *); e_t, const CertificateSerialNumber *, size_t *);
void free_CertificateSerialNumber (CertificateSerialNumber *); ASN1EXP size_t ASN1CALL length_CertificateSerialNumber(const CertificateSer
size_t length_CertificateSerialNumber(const CertificateSerialNumber *); ialNumber *);
int copy_CertificateSerialNumber (const CertificateSerialNumber *, Cert ASN1EXP int ASN1CALL copy_CertificateSerialNumber (const CertificateSer
ificateSerialNumber *); ialNumber *, CertificateSerialNumber *);
ASN1EXP void ASN1CALL free_CertificateSerialNumber (CertificateSerialNum
ber *);
/* /*
Time ::= CHOICE { Time ::= CHOICE {
utcTime UTCTime, utcTime UTCTime,
generalTime GeneralizedTime, generalTime GeneralizedTime,
} }
*/ */
typedef struct Time { typedef struct Time {
enum { enum {
choice_Time_utcTime = 1, choice_Time_utcTime = 1,
choice_Time_generalTime choice_Time_generalTime
} element; } element;
union { union {
time_t utcTime; time_t utcTime;
time_t generalTime; time_t generalTime;
} u; } u;
} Time; } Time;
int encode_Time(unsigned char *, size_t, const Time *, size_t *); ASN1EXP int ASN1CALL decode_Time(const unsigned char *, size_t, Time *,
int decode_Time(const unsigned char *, size_t, Time *, size_t *); size_t *);
void free_Time (Time *); ASN1EXP int ASN1CALL encode_Time(unsigned char *, size_t, const Time *,
size_t length_Time(const Time *); size_t *);
int copy_Time (const Time *, Time *); ASN1EXP size_t ASN1CALL length_Time(const Time *);
ASN1EXP int ASN1CALL copy_Time (const Time *, Time *);
ASN1EXP void ASN1CALL free_Time (Time *);
/* /*
Validity ::= SEQUENCE { Validity ::= SEQUENCE {
notBefore Time, notBefore Time,
notAfter Time, notAfter Time,
} }
*/ */
typedef struct Validity { typedef struct Validity {
Time notBefore; Time notBefore;
Time notAfter; Time notAfter;
} Validity; } Validity;
int encode_Validity(unsigned char *, size_t, const Validity *, size_t *) ASN1EXP int ASN1CALL decode_Validity(const unsigned char *, size_t, Vali
; dity *, size_t *);
int decode_Validity(const unsigned char *, size_t, Validity *, size_t *) ASN1EXP int ASN1CALL encode_Validity(unsigned char *, size_t, const Vali
; dity *, size_t *);
void free_Validity (Validity *); ASN1EXP size_t ASN1CALL length_Validity(const Validity *);
size_t length_Validity(const Validity *); ASN1EXP int ASN1CALL copy_Validity (const Validity *, Validity *);
int copy_Validity (const Validity *, Validity *); ASN1EXP void ASN1CALL free_Validity (Validity *);
/* /*
UniqueIdentifier ::= BIT STRING { UniqueIdentifier ::= BIT STRING {
} }
*/ */
typedef heim_bit_string UniqueIdentifier; typedef heim_bit_string UniqueIdentifier;
int encode_UniqueIdentifier(unsigned char *, size_t, const UniqueIdentif ASN1EXP int ASN1CALL decode_UniqueIdentifier(const unsigned char *, size
ier *, size_t *); _t, UniqueIdentifier *, size_t *);
int decode_UniqueIdentifier(const unsigned char *, size_t, UniqueIdentif ASN1EXP int ASN1CALL encode_UniqueIdentifier(unsigned char *, size_t, co
ier *, size_t *); nst UniqueIdentifier *, size_t *);
void free_UniqueIdentifier (UniqueIdentifier *); ASN1EXP size_t ASN1CALL length_UniqueIdentifier(const UniqueIdentifier *);
size_t length_UniqueIdentifier(const UniqueIdentifier *); ASN1EXP int ASN1CALL copy_UniqueIdentifier (const UniqueIdentifier *, U
int copy_UniqueIdentifier (const UniqueIdentifier *, UniqueIdentifier * niqueIdentifier *);
); ASN1EXP void ASN1CALL free_UniqueIdentifier (UniqueIdentifier *);
/* /*
SubjectPublicKeyInfo ::= SEQUENCE { SubjectPublicKeyInfo ::= SEQUENCE {
algorithm AlgorithmIdentifier, algorithm AlgorithmIdentifier,
subjectPublicKey BIT STRING { subjectPublicKey BIT STRING {
}, },
} }
*/ */
typedef struct SubjectPublicKeyInfo { typedef struct SubjectPublicKeyInfo {
AlgorithmIdentifier algorithm; AlgorithmIdentifier algorithm;
heim_bit_string subjectPublicKey; heim_bit_string subjectPublicKey;
} SubjectPublicKeyInfo; } SubjectPublicKeyInfo;
int encode_SubjectPublicKeyInfo(unsigned char *, size_t, const SubjectPu ASN1EXP int ASN1CALL decode_SubjectPublicKeyInfo(const unsigned char *,
blicKeyInfo *, size_t *); size_t, SubjectPublicKeyInfo *, size_t *);
int decode_SubjectPublicKeyInfo(const unsigned char *, size_t, SubjectPu ASN1EXP int ASN1CALL encode_SubjectPublicKeyInfo(unsigned char *, size_t
blicKeyInfo *, size_t *); , const SubjectPublicKeyInfo *, size_t *);
void free_SubjectPublicKeyInfo (SubjectPublicKeyInfo *); ASN1EXP size_t ASN1CALL length_SubjectPublicKeyInfo(const SubjectPublicKeyI
size_t length_SubjectPublicKeyInfo(const SubjectPublicKeyInfo *); nfo *);
int copy_SubjectPublicKeyInfo (const SubjectPublicKeyInfo *, SubjectPub ASN1EXP int ASN1CALL copy_SubjectPublicKeyInfo (const SubjectPublicKeyI
licKeyInfo *); nfo *, SubjectPublicKeyInfo *);
ASN1EXP void ASN1CALL free_SubjectPublicKeyInfo (SubjectPublicKeyInfo *)
;
/* /*
Extension ::= SEQUENCE { Extension ::= SEQUENCE {
extnID OBJECT IDENTIFIER, extnID OBJECT IDENTIFIER,
critical BOOLEAN OPTIONAL, critical BOOLEAN OPTIONAL,
extnValue OCTET STRING, extnValue OCTET STRING,
} }
*/ */
typedef struct Extension { typedef struct Extension {
heim_oid extnID; heim_oid extnID;
int *critical; int *critical;
heim_octet_string extnValue; heim_octet_string extnValue;
} Extension; } Extension;
int encode_Extension(unsigned char *, size_t, const Extension *, size_t ASN1EXP int ASN1CALL decode_Extension(const unsigned char *, size_t, Ext
*); ension *, size_t *);
int decode_Extension(const unsigned char *, size_t, Extension *, size_t ASN1EXP int ASN1CALL encode_Extension(unsigned char *, size_t, const Ext
*); ension *, size_t *);
void free_Extension (Extension *); ASN1EXP size_t ASN1CALL length_Extension(const Extension *);
size_t length_Extension(const Extension *); ASN1EXP int ASN1CALL copy_Extension (const Extension *, Extension *);
int copy_Extension (const Extension *, Extension *); ASN1EXP void ASN1CALL free_Extension (Extension *);
/* /*
Extensions ::= SEQUENCE OF Extension Extensions ::= SEQUENCE OF Extension
*/ */
typedef struct Extensions { typedef struct Extensions {
unsigned int len; unsigned int len;
Extension *val; Extension *val;
} Extensions; } Extensions;
int encode_Extensions(unsigned char *, size_t, const Extensions *, size_ ASN1EXP int ASN1CALL add_Extensions (Extensions *, const Extension *);
t *); ASN1EXP int ASN1CALL remove_Extensions (Extensions *, unsigned int);
int decode_Extensions(const unsigned char *, size_t, Extensions *, size_ ASN1EXP int ASN1CALL decode_Extensions(const unsigned char *, size_t, Ex
t *); tensions *, size_t *);
void free_Extensions (Extensions *); ASN1EXP int ASN1CALL encode_Extensions(unsigned char *, size_t, const Ex
size_t length_Extensions(const Extensions *); tensions *, size_t *);
int copy_Extensions (const Extensions *, Extensions *); ASN1EXP size_t ASN1CALL length_Extensions(const Extensions *);
int add_Extensions (Extensions *, const Extension *); ASN1EXP int ASN1CALL copy_Extensions (const Extensions *, Extensions *)
int remove_Extensions (Extensions *, unsigned int); ;
ASN1EXP void ASN1CALL free_Extensions (Extensions *);
/* /*
TBSCertificate ::= SEQUENCE { TBSCertificate ::= SEQUENCE {
version [0] Version OPTIONAL, version [0] Version OPTIONAL,
serialNumber CertificateSerialNumber, serialNumber CertificateSerialNumber,
signature AlgorithmIdentifier, signature AlgorithmIdentifier,
issuer Name, issuer Name,
validity Validity, validity Validity,
subject Name, subject Name,
subjectPublicKeyInfo SubjectPublicKeyInfo, subjectPublicKeyInfo SubjectPublicKeyInfo,
skipping to change at line 681 skipping to change at line 696
AlgorithmIdentifier signature; AlgorithmIdentifier signature;
Name issuer; Name issuer;
Validity validity; Validity validity;
Name subject; Name subject;
SubjectPublicKeyInfo subjectPublicKeyInfo; SubjectPublicKeyInfo subjectPublicKeyInfo;
heim_bit_string *issuerUniqueID; heim_bit_string *issuerUniqueID;
heim_bit_string *subjectUniqueID; heim_bit_string *subjectUniqueID;
Extensions *extensions; Extensions *extensions;
} TBSCertificate; } TBSCertificate;
int encode_TBSCertificate(unsigned char *, size_t, const TBSCertificate ASN1EXP int ASN1CALL decode_TBSCertificate(const unsigned char *, size_t
*, size_t *); , TBSCertificate *, size_t *);
int decode_TBSCertificate(const unsigned char *, size_t, TBSCertificate ASN1EXP int ASN1CALL encode_TBSCertificate(unsigned char *, size_t, cons
*, size_t *); t TBSCertificate *, size_t *);
void free_TBSCertificate (TBSCertificate *); ASN1EXP size_t ASN1CALL length_TBSCertificate(const TBSCertificate *);
size_t length_TBSCertificate(const TBSCertificate *); ASN1EXP int ASN1CALL copy_TBSCertificate (const TBSCertificate *, TBSCe
int copy_TBSCertificate (const TBSCertificate *, TBSCertificate *); rtificate *);
ASN1EXP void ASN1CALL free_TBSCertificate (TBSCertificate *);
/* /*
Certificate ::= SEQUENCE { Certificate ::= SEQUENCE {
tbsCertificate TBSCertificate, tbsCertificate TBSCertificate,
signatureAlgorithm AlgorithmIdentifier, signatureAlgorithm AlgorithmIdentifier,
signatureValue BIT STRING { signatureValue BIT STRING {
}, },
} }
*/ */
typedef struct Certificate { typedef struct Certificate {
TBSCertificate tbsCertificate; TBSCertificate tbsCertificate;
AlgorithmIdentifier signatureAlgorithm; AlgorithmIdentifier signatureAlgorithm;
heim_bit_string signatureValue; heim_bit_string signatureValue;
} Certificate; } Certificate;
int encode_Certificate(unsigned char *, size_t, const Certificate *, siz ASN1EXP int ASN1CALL decode_Certificate(const unsigned char *, size_t, C
e_t *); ertificate *, size_t *);
int decode_Certificate(const unsigned char *, size_t, Certificate *, siz ASN1EXP int ASN1CALL encode_Certificate(unsigned char *, size_t, const C
e_t *); ertificate *, size_t *);
void free_Certificate (Certificate *); ASN1EXP size_t ASN1CALL length_Certificate(const Certificate *);
size_t length_Certificate(const Certificate *); ASN1EXP int ASN1CALL copy_Certificate (const Certificate *, Certificate
int copy_Certificate (const Certificate *, Certificate *); *);
ASN1EXP void ASN1CALL free_Certificate (Certificate *);
/* /*
Certificates ::= SEQUENCE OF Certificate Certificates ::= SEQUENCE OF Certificate
*/ */
typedef struct Certificates { typedef struct Certificates {
unsigned int len; unsigned int len;
Certificate *val; Certificate *val;
} Certificates; } Certificates;
int encode_Certificates(unsigned char *, size_t, const Certificates *, s ASN1EXP int ASN1CALL decode_Certificates(const unsigned char *, size_t,
ize_t *); Certificates *, size_t *);
int decode_Certificates(const unsigned char *, size_t, Certificates *, s ASN1EXP int ASN1CALL encode_Certificates(unsigned char *, size_t, const
ize_t *); Certificates *, size_t *);
void free_Certificates (Certificates *); ASN1EXP size_t ASN1CALL length_Certificates(const Certificates *);
size_t length_Certificates(const Certificates *); ASN1EXP int ASN1CALL copy_Certificates (const Certificates *, Certifica
int copy_Certificates (const Certificates *, Certificates *); tes *);
ASN1EXP void ASN1CALL free_Certificates (Certificates *);
/* /*
ValidationParms ::= SEQUENCE { ValidationParms ::= SEQUENCE {
seed BIT STRING { seed BIT STRING {
}, },
pgenCounter INTEGER, pgenCounter INTEGER,
} }
*/ */
typedef struct ValidationParms { typedef struct ValidationParms {
heim_bit_string seed; heim_bit_string seed;
heim_integer pgenCounter; heim_integer pgenCounter;
} ValidationParms; } ValidationParms;
int encode_ValidationParms(unsigned char *, size_t, const ValidationParm ASN1EXP int ASN1CALL decode_ValidationParms(const unsigned char *, size_
s *, size_t *); t, ValidationParms *, size_t *);
int decode_ValidationParms(const unsigned char *, size_t, ValidationParm ASN1EXP int ASN1CALL encode_ValidationParms(unsigned char *, size_t, con
s *, size_t *); st ValidationParms *, size_t *);
void free_ValidationParms (ValidationParms *); ASN1EXP size_t ASN1CALL length_ValidationParms(const ValidationParms *);
size_t length_ValidationParms(const ValidationParms *); ASN1EXP int ASN1CALL copy_ValidationParms (const ValidationParms *, Val
int copy_ValidationParms (const ValidationParms *, ValidationParms *); idationParms *);
ASN1EXP void ASN1CALL free_ValidationParms (ValidationParms *);
/* /*
DomainParameters ::= SEQUENCE { DomainParameters ::= SEQUENCE {
p INTEGER, p INTEGER,
g INTEGER, g INTEGER,
q INTEGER, q INTEGER,
j INTEGER OPTIONAL, j INTEGER OPTIONAL,
validationParms ValidationParms OPTIONAL, validationParms ValidationParms OPTIONAL,
} }
*/ */
typedef struct DomainParameters { typedef struct DomainParameters {
heim_integer p; heim_integer p;
heim_integer g; heim_integer g;
heim_integer q; heim_integer q;
heim_integer *j; heim_integer *j;
ValidationParms *validationParms; ValidationParms *validationParms;
} DomainParameters; } DomainParameters;
int encode_DomainParameters(unsigned char *, size_t, const DomainParamet ASN1EXP int ASN1CALL decode_DomainParameters(const unsigned char *, size
ers *, size_t *); _t, DomainParameters *, size_t *);
int decode_DomainParameters(const unsigned char *, size_t, DomainParamet ASN1EXP int ASN1CALL encode_DomainParameters(unsigned char *, size_t, co
ers *, size_t *); nst DomainParameters *, size_t *);
void free_DomainParameters (DomainParameters *); ASN1EXP size_t ASN1CALL length_DomainParameters(const DomainParameters *);
size_t length_DomainParameters(const DomainParameters *); ASN1EXP int ASN1CALL copy_DomainParameters (const DomainParameters *, D
int copy_DomainParameters (const DomainParameters *, DomainParameters * omainParameters *);
); ASN1EXP void ASN1CALL free_DomainParameters (DomainParameters *);
/*
DHParameter ::= SEQUENCE {
prime INTEGER,
base INTEGER,
privateValueLength INTEGER OPTIONAL,
}
*/
typedef struct DHParameter {
heim_integer prime;
heim_integer base;
heim_integer *privateValueLength;
} DHParameter;
ASN1EXP int ASN1CALL decode_DHParameter(const unsigned char *, size_t, D
HParameter *, size_t *);
ASN1EXP int ASN1CALL encode_DHParameter(unsigned char *, size_t, const D
HParameter *, size_t *);
ASN1EXP size_t ASN1CALL length_DHParameter(const DHParameter *);
ASN1EXP int ASN1CALL copy_DHParameter (const DHParameter *, DHParameter
*);
ASN1EXP void ASN1CALL free_DHParameter (DHParameter *);
/* /*
DHPublicKey ::= INTEGER DHPublicKey ::= INTEGER
*/ */
typedef heim_integer DHPublicKey; typedef heim_integer DHPublicKey;
int encode_DHPublicKey(unsigned char *, size_t, const DHPublicKey *, siz ASN1EXP int ASN1CALL decode_DHPublicKey(const unsigned char *, size_t, D
e_t *); HPublicKey *, size_t *);
int decode_DHPublicKey(const unsigned char *, size_t, DHPublicKey *, siz ASN1EXP int ASN1CALL encode_DHPublicKey(unsigned char *, size_t, const D
e_t *); HPublicKey *, size_t *);
void free_DHPublicKey (DHPublicKey *); ASN1EXP size_t ASN1CALL length_DHPublicKey(const DHPublicKey *);
size_t length_DHPublicKey(const DHPublicKey *); ASN1EXP int ASN1CALL copy_DHPublicKey (const DHPublicKey *, DHPublicKey
int copy_DHPublicKey (const DHPublicKey *, DHPublicKey *); *);
ASN1EXP void ASN1CALL free_DHPublicKey (DHPublicKey *);
/* /*
OtherName ::= SEQUENCE { OtherName ::= SEQUENCE {
type-id OBJECT IDENTIFIER, type-id OBJECT IDENTIFIER,
value [0] heim_any, value [0] heim_any,
} }
*/ */
typedef struct OtherName { typedef struct OtherName {
heim_oid type_id; heim_oid type_id;
heim_any value; heim_any value;
} OtherName; } OtherName;
int encode_OtherName(unsigned char *, size_t, const OtherName *, size_t ASN1EXP int ASN1CALL decode_OtherName(const unsigned char *, size_t, Oth
*); erName *, size_t *);
int decode_OtherName(const unsigned char *, size_t, OtherName *, size_t ASN1EXP int ASN1CALL encode_OtherName(unsigned char *, size_t, const Oth
*); erName *, size_t *);
void free_OtherName (OtherName *); ASN1EXP size_t ASN1CALL length_OtherName(const OtherName *);
size_t length_OtherName(const OtherName *); ASN1EXP int ASN1CALL copy_OtherName (const OtherName *, OtherName *);
int copy_OtherName (const OtherName *, OtherName *); ASN1EXP void ASN1CALL free_OtherName (OtherName *);
/* /*
GeneralName ::= CHOICE { GeneralName ::= CHOICE {
otherName [0] IMPLICIT SEQUENCE { otherName [0] IMPLICIT SEQUENCE {
type-id OBJECT IDENTIFIER, type-id OBJECT IDENTIFIER,
value [0] heim_any, value [0] heim_any,
}, },
rfc822Name [1] IMPLICIT IA5String, rfc822Name [1] IMPLICIT IA5String,
dNSName [2] IMPLICIT IA5String, dNSName [2] IMPLICIT IA5String,
directoryName [4] IMPLICIT CHOICE { directoryName [4] IMPLICIT CHOICE {
skipping to change at line 824 skipping to change at line 859
enum { enum {
choice_GeneralName_otherName = 1, choice_GeneralName_otherName = 1,
choice_GeneralName_rfc822Name, choice_GeneralName_rfc822Name,
choice_GeneralName_dNSName, choice_GeneralName_dNSName,
choice_GeneralName_directoryName, choice_GeneralName_directoryName,
choice_GeneralName_uniformResourceIdentifier, choice_GeneralName_uniformResourceIdentifier,
choice_GeneralName_iPAddress, choice_GeneralName_iPAddress,
choice_GeneralName_registeredID choice_GeneralName_registeredID
} element; } element;
union { union {
struct { struct GeneralName_otherName {
heim_oid type_id; heim_oid type_id;
heim_any value; heim_any value;
} otherName; } otherName;
heim_ia5_string rfc822Name; heim_ia5_string rfc822Name;
heim_ia5_string dNSName; heim_ia5_string dNSName;
struct { struct GeneralName_directoryName {
enum { enum {
choice_GeneralName_directoryName_rdnSequence = 1 choice_GeneralName_directoryName_rdnSequence = 1
} element; } element;
union { union {
RDNSequence rdnSequence; RDNSequence rdnSequence;
} u; } u;
} directoryName; } directoryName;
heim_ia5_string uniformResourceIdentifier; heim_ia5_string uniformResourceIdentifier;
heim_octet_string iPAddress; heim_octet_string iPAddress;
heim_oid registeredID; heim_oid registeredID;
} u; } u;
} GeneralName; } GeneralName;
int encode_GeneralName(unsigned char *, size_t, const GeneralName *, siz ASN1EXP int ASN1CALL decode_GeneralName(const unsigned char *, size_t, G
e_t *); eneralName *, size_t *);
int decode_GeneralName(const unsigned char *, size_t, GeneralName *, siz ASN1EXP int ASN1CALL encode_GeneralName(unsigned char *, size_t, const G
e_t *); eneralName *, size_t *);
void free_GeneralName (GeneralName *); ASN1EXP size_t ASN1CALL length_GeneralName(const GeneralName *);
size_t length_GeneralName(const GeneralName *); ASN1EXP int ASN1CALL copy_GeneralName (const GeneralName *, GeneralName
int copy_GeneralName (const GeneralName *, GeneralName *); *);
ASN1EXP void ASN1CALL free_GeneralName (GeneralName *);
/* /*
GeneralNames ::= SEQUENCE OF GeneralName GeneralNames ::= SEQUENCE OF GeneralName
*/ */
typedef struct GeneralNames { typedef struct GeneralNames {
unsigned int len; unsigned int len;
GeneralName *val; GeneralName *val;
} GeneralNames; } GeneralNames;
int encode_GeneralNames(unsigned char *, size_t, const GeneralNames *, s ASN1EXP int ASN1CALL add_GeneralNames (GeneralNames *, const GeneralName
ize_t *); *);
int decode_GeneralNames(const unsigned char *, size_t, GeneralNames *, s ASN1EXP int ASN1CALL remove_GeneralNames (GeneralNames *, unsigned int);
ize_t *); ASN1EXP int ASN1CALL decode_GeneralNames(const unsigned char *, size_t,
void free_GeneralNames (GeneralNames *); GeneralNames *, size_t *);
size_t length_GeneralNames(const GeneralNames *); ASN1EXP int ASN1CALL encode_GeneralNames(unsigned char *, size_t, const
int copy_GeneralNames (const GeneralNames *, GeneralNames *); GeneralNames *, size_t *);
int add_GeneralNames (GeneralNames *, const GeneralName *); ASN1EXP size_t ASN1CALL length_GeneralNames(const GeneralNames *);
int remove_GeneralNames (GeneralNames *, unsigned int); ASN1EXP int ASN1CALL copy_GeneralNames (const GeneralNames *, GeneralNa
mes *);
ASN1EXP void ASN1CALL free_GeneralNames (GeneralNames *);
/* OBJECT IDENTIFIER id-x509-ce-keyUsage ::= { joint-iso-ccitt(2) ds(5) lab el-less(29) label-less(15) } */ /* OBJECT IDENTIFIER id-x509-ce-keyUsage ::= { joint-iso-ccitt(2) ds(5) lab el-less(29) label-less(15) } */
const heim_oid *oid_id_x509_ce_keyUsage(void);
extern const heim_oid asn1_oid_id_x509_ce_keyUsage; extern const heim_oid asn1_oid_id_x509_ce_keyUsage;
#define ASN1_OID_ID_X509_CE_KEYUSAGE (&asn1_oid_id_x509_ce_keyUsage)
/* /*
KeyUsage ::= BIT STRING { KeyUsage ::= BIT STRING {
digitalSignature(0), digitalSignature(0),
nonRepudiation(1), nonRepudiation(1),
keyEncipherment(2), keyEncipherment(2),
dataEncipherment(3), dataEncipherment(3),
keyAgreement(4), keyAgreement(4),
keyCertSign(5), keyCertSign(5),
cRLSign(6), cRLSign(6),
skipping to change at line 895 skipping to change at line 930
typedef struct KeyUsage { typedef struct KeyUsage {
unsigned int digitalSignature:1; unsigned int digitalSignature:1;
unsigned int nonRepudiation:1; unsigned int nonRepudiation:1;
unsigned int keyEncipherment:1; unsigned int keyEncipherment:1;
unsigned int dataEncipherment:1; unsigned int dataEncipherment:1;
unsigned int keyAgreement:1; unsigned int keyAgreement:1;
unsigned int keyCertSign:1; unsigned int keyCertSign:1;
unsigned int cRLSign:1; unsigned int cRLSign:1;
unsigned int encipherOnly:1; unsigned int encipherOnly:1;
unsigned int decipherOnly:1; unsigned int decipherOnly: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;
} KeyUsage; } KeyUsage;
int encode_KeyUsage(unsigned char *, size_t, const KeyUsage *, size_t *)
;
int decode_KeyUsage(const unsigned char *, size_t, KeyUsage *, size_t *)
;
void free_KeyUsage (KeyUsage *);
size_t length_KeyUsage(const KeyUsage *);
int copy_KeyUsage (const KeyUsage *, KeyUsage *);
unsigned KeyUsage2int(KeyUsage); unsigned KeyUsage2int(KeyUsage);
KeyUsage int2KeyUsage(unsigned); KeyUsage int2KeyUsage(unsigned);
const struct units * asn1_KeyUsage_units(void); const struct units * asn1_KeyUsage_units(void);
ASN1EXP int ASN1CALL decode_KeyUsage(const unsigned char *, size_t, KeyU
sage *, size_t *);
ASN1EXP int ASN1CALL encode_KeyUsage(unsigned char *, size_t, const KeyU
sage *, size_t *);
ASN1EXP size_t ASN1CALL length_KeyUsage(const KeyUsage *);
ASN1EXP int ASN1CALL copy_KeyUsage (const KeyUsage *, KeyUsage *);
ASN1EXP void ASN1CALL free_KeyUsage (KeyUsage *);
/* OBJECT IDENTIFIER id-x509-ce-authorityKeyIdentifier ::= { joint-iso-ccit t(2) ds(5) label-less(29) label-less(35) } */ /* OBJECT IDENTIFIER id-x509-ce-authorityKeyIdentifier ::= { joint-iso-ccit t(2) ds(5) label-less(29) label-less(35) } */
const heim_oid *oid_id_x509_ce_authorityKeyIdentifier(void);
extern const heim_oid asn1_oid_id_x509_ce_authorityKeyIdentifier; extern const heim_oid asn1_oid_id_x509_ce_authorityKeyIdentifier;
#define ASN1_OID_ID_X509_CE_AUTHORITYKEYIDENTIFIER (&asn1_oid_id_x509_ce_au thorityKeyIdentifier)
/* /*
KeyIdentifier ::= OCTET STRING KeyIdentifier ::= OCTET STRING
*/ */
typedef heim_octet_string KeyIdentifier; typedef heim_octet_string KeyIdentifier;
int encode_KeyIdentifier(unsigned char *, size_t, const KeyIdentifier *, ASN1EXP int ASN1CALL decode_KeyIdentifier(const unsigned char *, size_t,
size_t *); KeyIdentifier *, size_t *);
int decode_KeyIdentifier(const unsigned char *, size_t, KeyIdentifier *, ASN1EXP int ASN1CALL encode_KeyIdentifier(unsigned char *, size_t, const
size_t *); KeyIdentifier *, size_t *);
void free_KeyIdentifier (KeyIdentifier *); ASN1EXP size_t ASN1CALL length_KeyIdentifier(const KeyIdentifier *);
size_t length_KeyIdentifier(const KeyIdentifier *); ASN1EXP int ASN1CALL copy_KeyIdentifier (const KeyIdentifier *, KeyIden
int copy_KeyIdentifier (const KeyIdentifier *, KeyIdentifier *); tifier *);
ASN1EXP void ASN1CALL free_KeyIdentifier (KeyIdentifier *);
/* /*
AuthorityKeyIdentifier ::= SEQUENCE { AuthorityKeyIdentifier ::= SEQUENCE {
keyIdentifier [0] IMPLICIT OCTET STRING OPTIONAL, keyIdentifier [0] IMPLICIT OCTET STRING OPTIONAL,
authorityCertIssuer [1] IMPLICIT SEQUENCE OF GeneralName OPTIONAL , authorityCertIssuer [1] IMPLICIT SEQUENCE OF GeneralName OPTIONAL ,
authorityCertSerialNumber [2] IMPLICIT INTEGER OPTIONAL, authorityCertSerialNumber [2] IMPLICIT INTEGER OPTIONAL,
} }
*/ */
typedef struct AuthorityKeyIdentifier { typedef struct AuthorityKeyIdentifier {
heim_octet_string *keyIdentifier; heim_octet_string *keyIdentifier;
struct { struct AuthorityKeyIdentifier_authorityCertIssuer {
unsigned int len; unsigned int len;
GeneralName *val; GeneralName *val;
} *authorityCertIssuer; } *authorityCertIssuer;
heim_integer *authorityCertSerialNumber; heim_integer *authorityCertSerialNumber;
} AuthorityKeyIdentifier; } AuthorityKeyIdentifier;
int encode_AuthorityKeyIdentifier(unsigned char *, size_t, const Authori ASN1EXP int ASN1CALL decode_AuthorityKeyIdentifier(const unsigned char *
tyKeyIdentifier *, size_t *); , size_t, AuthorityKeyIdentifier *, size_t *);
int decode_AuthorityKeyIdentifier(const unsigned char *, size_t, Authori ASN1EXP int ASN1CALL encode_AuthorityKeyIdentifier(unsigned char *, size
tyKeyIdentifier *, size_t *); _t, const AuthorityKeyIdentifier *, size_t *);
void free_AuthorityKeyIdentifier (AuthorityKeyIdentifier *); ASN1EXP size_t ASN1CALL length_AuthorityKeyIdentifier(const AuthorityKeyIde
size_t length_AuthorityKeyIdentifier(const AuthorityKeyIdentifier *); ntifier *);
int copy_AuthorityKeyIdentifier (const AuthorityKeyIdentifier *, Author ASN1EXP int ASN1CALL copy_AuthorityKeyIdentifier (const AuthorityKeyIde
ityKeyIdentifier *); ntifier *, AuthorityKeyIdentifier *);
ASN1EXP void ASN1CALL free_AuthorityKeyIdentifier (AuthorityKeyIdentifie
r *);
/* OBJECT IDENTIFIER id-x509-ce-subjectKeyIdentifier ::= { joint-iso-ccitt( 2) ds(5) label-less(29) label-less(14) } */ /* OBJECT IDENTIFIER id-x509-ce-subjectKeyIdentifier ::= { joint-iso-ccitt( 2) ds(5) label-less(29) label-less(14) } */
const heim_oid *oid_id_x509_ce_subjectKeyIdentifier(void);
extern const heim_oid asn1_oid_id_x509_ce_subjectKeyIdentifier; extern const heim_oid asn1_oid_id_x509_ce_subjectKeyIdentifier;
#define ASN1_OID_ID_X509_CE_SUBJECTKEYIDENTIFIER (&asn1_oid_id_x509_ce_subj ectKeyIdentifier)
/* /*
SubjectKeyIdentifier ::= KeyIdentifier SubjectKeyIdentifier ::= KeyIdentifier
*/ */
typedef KeyIdentifier SubjectKeyIdentifier; typedef KeyIdentifier SubjectKeyIdentifier;
int encode_SubjectKeyIdentifier(unsigned char *, size_t, const SubjectKe ASN1EXP int ASN1CALL decode_SubjectKeyIdentifier(const unsigned char *,
yIdentifier *, size_t *); size_t, SubjectKeyIdentifier *, size_t *);
int decode_SubjectKeyIdentifier(const unsigned char *, size_t, SubjectKe ASN1EXP int ASN1CALL encode_SubjectKeyIdentifier(unsigned char *, size_t
yIdentifier *, size_t *); , const SubjectKeyIdentifier *, size_t *);
void free_SubjectKeyIdentifier (SubjectKeyIdentifier *); ASN1EXP size_t ASN1CALL length_SubjectKeyIdentifier(const SubjectKeyIdentif
size_t length_SubjectKeyIdentifier(const SubjectKeyIdentifier *); ier *);
int copy_SubjectKeyIdentifier (const SubjectKeyIdentifier *, SubjectKey ASN1EXP int ASN1CALL copy_SubjectKeyIdentifier (const SubjectKeyIdentif
Identifier *); ier *, SubjectKeyIdentifier *);
ASN1EXP void ASN1CALL free_SubjectKeyIdentifier (SubjectKeyIdentifier *)
;
/* OBJECT IDENTIFIER id-x509-ce-basicConstraints ::= { joint-iso-ccitt(2) d s(5) label-less(29) label-less(19) } */ /* OBJECT IDENTIFIER id-x509-ce-basicConstraints ::= { joint-iso-ccitt(2) d s(5) label-less(29) label-less(19) } */
const heim_oid *oid_id_x509_ce_basicConstraints(void);
extern const heim_oid asn1_oid_id_x509_ce_basicConstraints; extern const heim_oid asn1_oid_id_x509_ce_basicConstraints;
#define ASN1_OID_ID_X509_CE_BASICCONSTRAINTS (&asn1_oid_id_x509_ce_basicCon straints)
/* /*
BasicConstraints ::= SEQUENCE { BasicConstraints ::= SEQUENCE {
cA BOOLEAN OPTIONAL, cA BOOLEAN OPTIONAL,
pathLenConstraint INTEGER (0..2147483647) OPTIONAL, pathLenConstraint INTEGER (0..2147483647) OPTIONAL,
} }
*/ */
typedef struct BasicConstraints { typedef struct BasicConstraints {
int *cA; int *cA;
unsigned int *pathLenConstraint; unsigned int *pathLenConstraint;
} BasicConstraints; } BasicConstraints;
int encode_BasicConstraints(unsigned char *, size_t, const BasicConstrai ASN1EXP int ASN1CALL decode_BasicConstraints(const unsigned char *, size
nts *, size_t *); _t, BasicConstraints *, size_t *);
int decode_BasicConstraints(const unsigned char *, size_t, BasicConstrai ASN1EXP int ASN1CALL encode_BasicConstraints(unsigned char *, size_t, co
nts *, size_t *); nst BasicConstraints *, size_t *);
void free_BasicConstraints (BasicConstraints *); ASN1EXP size_t ASN1CALL length_BasicConstraints(const BasicConstraints *);
size_t length_BasicConstraints(const BasicConstraints *); ASN1EXP int ASN1CALL copy_BasicConstraints (const BasicConstraints *, B
int copy_BasicConstraints (const BasicConstraints *, BasicConstraints * asicConstraints *);
); ASN1EXP void ASN1CALL free_BasicConstraints (BasicConstraints *);
/* OBJECT IDENTIFIER id-x509-ce-nameConstraints ::= { joint-iso-ccitt(2) ds (5) label-less(29) label-less(30) } */ /* OBJECT IDENTIFIER id-x509-ce-nameConstraints ::= { joint-iso-ccitt(2) ds (5) label-less(29) label-less(30) } */
const heim_oid *oid_id_x509_ce_nameConstraints(void);
extern const heim_oid asn1_oid_id_x509_ce_nameConstraints; extern const heim_oid asn1_oid_id_x509_ce_nameConstraints;
#define ASN1_OID_ID_X509_CE_NAMECONSTRAINTS (&asn1_oid_id_x509_ce_nameConst raints)
/* /*
BaseDistance ::= INTEGER BaseDistance ::= INTEGER
*/ */
typedef heim_integer BaseDistance; typedef heim_integer BaseDistance;
int encode_BaseDistance(unsigned char *, size_t, const BaseDistance *, s ASN1EXP int ASN1CALL decode_BaseDistance(const unsigned char *, size_t,
ize_t *); BaseDistance *, size_t *);
int decode_BaseDistance(const unsigned char *, size_t, BaseDistance *, s ASN1EXP int ASN1CALL encode_BaseDistance(unsigned char *, size_t, const
ize_t *); BaseDistance *, size_t *);
void free_BaseDistance (BaseDistance *); ASN1EXP size_t ASN1CALL length_BaseDistance(const BaseDistance *);
size_t length_BaseDistance(const BaseDistance *); ASN1EXP int ASN1CALL copy_BaseDistance (const BaseDistance *, BaseDista
int copy_BaseDistance (const BaseDistance *, BaseDistance *); nce *);
ASN1EXP void ASN1CALL free_BaseDistance (BaseDistance *);
/* /*
GeneralSubtree ::= SEQUENCE { GeneralSubtree ::= SEQUENCE {
base GeneralName, base GeneralName,
minimum [0] IMPLICIT INTEGER OPTIONAL, minimum [0] IMPLICIT INTEGER OPTIONAL,
maximum [1] IMPLICIT INTEGER OPTIONAL, maximum [1] IMPLICIT INTEGER OPTIONAL,
} }
*/ */
typedef struct GeneralSubtree { typedef struct GeneralSubtree {
GeneralName base; GeneralName base;
heim_integer *minimum; heim_integer *minimum;
heim_integer *maximum; heim_integer *maximum;
} GeneralSubtree; } GeneralSubtree;
int encode_GeneralSubtree(unsigned char *, size_t, const GeneralSubtree ASN1EXP int ASN1CALL decode_GeneralSubtree(const unsigned char *, size_t
*, size_t *); , GeneralSubtree *, size_t *);
int decode_GeneralSubtree(const unsigned char *, size_t, GeneralSubtree ASN1EXP int ASN1CALL encode_GeneralSubtree(unsigned char *, size_t, cons
*, size_t *); t GeneralSubtree *, size_t *);
void free_GeneralSubtree (GeneralSubtree *); ASN1EXP size_t ASN1CALL length_GeneralSubtree(const GeneralSubtree *);
size_t length_GeneralSubtree(const GeneralSubtree *); ASN1EXP int ASN1CALL copy_GeneralSubtree (const GeneralSubtree *, Gener
int copy_GeneralSubtree (const GeneralSubtree *, GeneralSubtree *); alSubtree *);
ASN1EXP void ASN1CALL free_GeneralSubtree (GeneralSubtree *);
/* /*
GeneralSubtrees ::= SEQUENCE OF GeneralSubtree GeneralSubtrees ::= SEQUENCE OF GeneralSubtree
*/ */
typedef struct GeneralSubtrees { typedef struct GeneralSubtrees {
unsigned int len; unsigned int len;
GeneralSubtree *val; GeneralSubtree *val;
} GeneralSubtrees; } GeneralSubtrees;
int encode_GeneralSubtrees(unsigned char *, size_t, const GeneralSubtree ASN1EXP int ASN1CALL decode_GeneralSubtrees(const unsigned char *, size_
s *, size_t *); t, GeneralSubtrees *, size_t *);
int decode_GeneralSubtrees(const unsigned char *, size_t, GeneralSubtree ASN1EXP int ASN1CALL encode_GeneralSubtrees(unsigned char *, size_t, con
s *, size_t *); st GeneralSubtrees *, size_t *);
void free_GeneralSubtrees (GeneralSubtrees *); ASN1EXP size_t ASN1CALL length_GeneralSubtrees(const GeneralSubtrees *);
size_t length_GeneralSubtrees(const GeneralSubtrees *); ASN1EXP int ASN1CALL copy_GeneralSubtrees (const GeneralSubtrees *, Gen
int copy_GeneralSubtrees (const GeneralSubtrees *, GeneralSubtrees *); eralSubtrees *);
ASN1EXP void ASN1CALL free_GeneralSubtrees (GeneralSubtrees *);
/* /*
NameConstraints ::= SEQUENCE { NameConstraints ::= SEQUENCE {
permittedSubtrees [0] IMPLICIT SEQUENCE OF GeneralSubtree OPTIONAL, permittedSubtrees [0] IMPLICIT SEQUENCE OF GeneralSubtree OPTIONAL,
excludedSubtrees [1] IMPLICIT SEQUENCE OF GeneralSubtree OPTIONAL, excludedSubtrees [1] IMPLICIT SEQUENCE OF GeneralSubtree OPTIONAL,
} }
*/ */
typedef struct NameConstraints { typedef struct NameConstraints {
struct { struct NameConstraints_permittedSubtrees {
unsigned int len; unsigned int len;
GeneralSubtree *val; GeneralSubtree *val;
} *permittedSubtrees; } *permittedSubtrees;
struct { struct NameConstraints_excludedSubtrees {
unsigned int len; unsigned int len;
GeneralSubtree *val; GeneralSubtree *val;
} *excludedSubtrees; } *excludedSubtrees;
} NameConstraints; } NameConstraints;
int encode_NameConstraints(unsigned char *, size_t, const NameConstraint ASN1EXP int ASN1CALL decode_NameConstraints(const unsigned char *, size_
s *, size_t *); t, NameConstraints *, size_t *);
int decode_NameConstraints(const unsigned char *, size_t, NameConstraint ASN1EXP int ASN1CALL encode_NameConstraints(unsigned char *, size_t, con
s *, size_t *); st NameConstraints *, size_t *);
void free_NameConstraints (NameConstraints *); ASN1EXP size_t ASN1CALL length_NameConstraints(const NameConstraints *);
size_t length_NameConstraints(const NameConstraints *); ASN1EXP int ASN1CALL copy_NameConstraints (const NameConstraints *, Nam
int copy_NameConstraints (const NameConstraints *, NameConstraints *); eConstraints *);
ASN1EXP void ASN1CALL free_NameConstraints (NameConstraints *);
/* OBJECT IDENTIFIER id-x509-ce-privateKeyUsagePeriod ::= { joint-iso-ccitt (2) ds(5) label-less(29) label-less(16) } */ /* OBJECT IDENTIFIER id-x509-ce-privateKeyUsagePeriod ::= { joint-iso-ccitt (2) ds(5) label-less(29) label-less(16) } */
const heim_oid *oid_id_x509_ce_privateKeyUsagePeriod(void);
extern const heim_oid asn1_oid_id_x509_ce_privateKeyUsagePeriod; extern const heim_oid asn1_oid_id_x509_ce_privateKeyUsagePeriod;
#define ASN1_OID_ID_X509_CE_PRIVATEKEYUSAGEPERIOD (&asn1_oid_id_x509_ce_pri vateKeyUsagePeriod)
/* OBJECT IDENTIFIER id-x509-ce-certificatePolicies ::= { joint-iso-ccitt(2 ) ds(5) label-less(29) label-less(32) } */ /* OBJECT IDENTIFIER id-x509-ce-certificatePolicies ::= { joint-iso-ccitt(2 ) ds(5) label-less(29) label-less(32) } */
const heim_oid *oid_id_x509_ce_certificatePolicies(void);
extern const heim_oid asn1_oid_id_x509_ce_certificatePolicies; extern const heim_oid asn1_oid_id_x509_ce_certificatePolicies;
#define ASN1_OID_ID_X509_CE_CERTIFICATEPOLICIES (&asn1_oid_id_x509_ce_certi ficatePolicies)
/* OBJECT IDENTIFIER id-x509-ce-policyMappings ::= { joint-iso-ccitt(2) ds( 5) label-less(29) label-less(33) } */ /* OBJECT IDENTIFIER id-x509-ce-policyMappings ::= { joint-iso-ccitt(2) ds( 5) label-less(29) label-less(33) } */
const heim_oid *oid_id_x509_ce_policyMappings(void);
extern const heim_oid asn1_oid_id_x509_ce_policyMappings; extern const heim_oid asn1_oid_id_x509_ce_policyMappings;
#define ASN1_OID_ID_X509_CE_POLICYMAPPINGS (&asn1_oid_id_x509_ce_policyMapp ings)
/* OBJECT IDENTIFIER id-x509-ce-subjectAltName ::= { joint-iso-ccitt(2) ds( 5) label-less(29) label-less(17) } */ /* OBJECT IDENTIFIER id-x509-ce-subjectAltName ::= { joint-iso-ccitt(2) ds( 5) label-less(29) label-less(17) } */
const heim_oid *oid_id_x509_ce_subjectAltName(void);
extern const heim_oid asn1_oid_id_x509_ce_subjectAltName; extern const heim_oid asn1_oid_id_x509_ce_subjectAltName;
#define ASN1_OID_ID_X509_CE_SUBJECTALTNAME (&asn1_oid_id_x509_ce_subjectAlt Name)
/* OBJECT IDENTIFIER id-x509-ce-issuerAltName ::= { joint-iso-ccitt(2) ds(5 ) label-less(29) label-less(18) } */ /* OBJECT IDENTIFIER id-x509-ce-issuerAltName ::= { joint-iso-ccitt(2) ds(5 ) label-less(29) label-less(18) } */
const heim_oid *oid_id_x509_ce_issuerAltName(void);
extern const heim_oid asn1_oid_id_x509_ce_issuerAltName; extern const heim_oid asn1_oid_id_x509_ce_issuerAltName;
#define ASN1_OID_ID_X509_CE_ISSUERALTNAME (&asn1_oid_id_x509_ce_issuerAltNa me)
/* OBJECT IDENTIFIER id-x509-ce-subjectDirectoryAttributes ::= { joint-iso- ccitt(2) ds(5) label-less(29) label-less(9) } */ /* OBJECT IDENTIFIER id-x509-ce-subjectDirectoryAttributes ::= { joint-iso- ccitt(2) ds(5) label-less(29) label-less(9) } */
const heim_oid *oid_id_x509_ce_subjectDirectoryAttributes(void);
extern const heim_oid asn1_oid_id_x509_ce_subjectDirectoryAttributes; extern const heim_oid asn1_oid_id_x509_ce_subjectDirectoryAttributes;
#define ASN1_OID_ID_X509_CE_SUBJECTDIRECTORYATTRIBUTES (&asn1_oid_id_x509_c e_subjectDirectoryAttributes)
/* OBJECT IDENTIFIER id-x509-ce-policyConstraints ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(36) } */ /* OBJECT IDENTIFIER id-x509-ce-policyConstraints ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(36) } */
const heim_oid *oid_id_x509_ce_policyConstraints(void);
extern const heim_oid asn1_oid_id_x509_ce_policyConstraints; extern const heim_oid asn1_oid_id_x509_ce_policyConstraints;
#define ASN1_OID_ID_X509_CE_POLICYCONSTRAINTS (&asn1_oid_id_x509_ce_policyC onstraints)
/* OBJECT IDENTIFIER id-x509-ce-extKeyUsage ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(37) } */ /* OBJECT IDENTIFIER id-x509-ce-extKeyUsage ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(37) } */
const heim_oid *oid_id_x509_ce_extKeyUsage(void);
extern const heim_oid asn1_oid_id_x509_ce_extKeyUsage; extern const heim_oid asn1_oid_id_x509_ce_extKeyUsage;
#define ASN1_OID_ID_X509_CE_EXTKEYUSAGE (&asn1_oid_id_x509_ce_extKeyUsage)
/* /*
ExtKeyUsage ::= SEQUENCE OF OBJECT IDENTIFIER ExtKeyUsage ::= SEQUENCE OF OBJECT IDENTIFIER
*/ */
typedef struct ExtKeyUsage { typedef struct ExtKeyUsage {
unsigned int len; unsigned int len;
heim_oid *val; heim_oid *val;
} ExtKeyUsage; } ExtKeyUsage;
int encode_ExtKeyUsage(unsigned char *, size_t, const ExtKeyUsage *, siz ASN1EXP int ASN1CALL decode_ExtKeyUsage(const unsigned char *, size_t, E
e_t *); xtKeyUsage *, size_t *);
int decode_ExtKeyUsage(const unsigned char *, size_t, ExtKeyUsage *, siz ASN1EXP int ASN1CALL encode_ExtKeyUsage(unsigned char *, size_t, const E
e_t *); xtKeyUsage *, size_t *);
void free_ExtKeyUsage (ExtKeyUsage *); ASN1EXP size_t ASN1CALL length_ExtKeyUsage(const ExtKeyUsage *);
size_t length_ExtKeyUsage(const ExtKeyUsage *); ASN1EXP int ASN1CALL copy_ExtKeyUsage (const ExtKeyUsage *, ExtKeyUsage
int copy_ExtKeyUsage (const ExtKeyUsage *, ExtKeyUsage *); *);
ASN1EXP void ASN1CALL free_ExtKeyUsage (ExtKeyUsage *);
/* OBJECT IDENTIFIER id-x509-ce-cRLDistributionPoints ::= { joint-iso-ccitt (2) ds(5) label-less(29) label-less(31) } */ /* OBJECT IDENTIFIER id-x509-ce-cRLDistributionPoints ::= { joint-iso-ccitt (2) ds(5) label-less(29) label-less(31) } */
const heim_oid *oid_id_x509_ce_cRLDistributionPoints(void);
extern const heim_oid asn1_oid_id_x509_ce_cRLDistributionPoints; extern const heim_oid asn1_oid_id_x509_ce_cRLDistributionPoints;
#define ASN1_OID_ID_X509_CE_CRLDISTRIBUTIONPOINTS (&asn1_oid_id_x509_ce_cRL DistributionPoints)
/* OBJECT IDENTIFIER id-x509-ce-deltaCRLIndicator ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(27) } */ /* OBJECT IDENTIFIER id-x509-ce-deltaCRLIndicator ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(27) } */
const heim_oid *oid_id_x509_ce_deltaCRLIndicator(void);
extern const heim_oid asn1_oid_id_x509_ce_deltaCRLIndicator; extern const heim_oid asn1_oid_id_x509_ce_deltaCRLIndicator;
#define ASN1_OID_ID_X509_CE_DELTACRLINDICATOR (&asn1_oid_id_x509_ce_deltaCR LIndicator)
/* OBJECT IDENTIFIER id-x509-ce-issuingDistributionPoint ::= { joint-iso-cc itt(2) ds(5) label-less(29) label-less(28) } */ /* OBJECT IDENTIFIER id-x509-ce-issuingDistributionPoint ::= { joint-iso-cc itt(2) ds(5) label-less(29) label-less(28) } */
const heim_oid *oid_id_x509_ce_issuingDistributionPoint(void);
extern const heim_oid asn1_oid_id_x509_ce_issuingDistributionPoint; extern const heim_oid asn1_oid_id_x509_ce_issuingDistributionPoint;
#define ASN1_OID_ID_X509_CE_ISSUINGDISTRIBUTIONPOINT (&asn1_oid_id_x509_ce_ issuingDistributionPoint)
/* OBJECT IDENTIFIER id-x509-ce-holdInstructionCode ::= { joint-iso-ccitt(2 ) ds(5) label-less(29) label-less(23) } */ /* OBJECT IDENTIFIER id-x509-ce-holdInstructionCode ::= { joint-iso-ccitt(2 ) ds(5) label-less(29) label-less(23) } */
const heim_oid *oid_id_x509_ce_holdInstructionCode(void);
extern const heim_oid asn1_oid_id_x509_ce_holdInstructionCode; extern const heim_oid asn1_oid_id_x509_ce_holdInstructionCode;
#define ASN1_OID_ID_X509_CE_HOLDINSTRUCTIONCODE (&asn1_oid_id_x509_ce_holdI nstructionCode)
/* OBJECT IDENTIFIER id-x509-ce-invalidityDate ::= { joint-iso-ccitt(2) ds( 5) label-less(29) label-less(24) } */ /* OBJECT IDENTIFIER id-x509-ce-invalidityDate ::= { joint-iso-ccitt(2) ds( 5) label-less(29) label-less(24) } */
const heim_oid *oid_id_x509_ce_invalidityDate(void);
extern const heim_oid asn1_oid_id_x509_ce_invalidityDate; extern const heim_oid asn1_oid_id_x509_ce_invalidityDate;
#define ASN1_OID_ID_X509_CE_INVALIDITYDATE (&asn1_oid_id_x509_ce_invalidity Date)
/* OBJECT IDENTIFIER id-x509-ce-certificateIssuer ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(29) } */ /* OBJECT IDENTIFIER id-x509-ce-certificateIssuer ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(29) } */
const heim_oid *oid_id_x509_ce_certificateIssuer(void);
extern const heim_oid asn1_oid_id_x509_ce_certificateIssuer; extern const heim_oid asn1_oid_id_x509_ce_certificateIssuer;
#define ASN1_OID_ID_X509_CE_CERTIFICATEISSUER (&asn1_oid_id_x509_ce_certifi cateIssuer)
/* OBJECT IDENTIFIER id-x509-ce-inhibitAnyPolicy ::= { joint-iso-ccitt(2) d s(5) label-less(29) label-less(54) } */ /* OBJECT IDENTIFIER id-x509-ce-inhibitAnyPolicy ::= { joint-iso-ccitt(2) d s(5) label-less(29) label-less(54) } */
const heim_oid *oid_id_x509_ce_inhibitAnyPolicy(void);
extern const heim_oid asn1_oid_id_x509_ce_inhibitAnyPolicy; extern const heim_oid asn1_oid_id_x509_ce_inhibitAnyPolicy;
#define ASN1_OID_ID_X509_CE_INHIBITANYPOLICY (&asn1_oid_id_x509_ce_inhibitA nyPolicy)
/* /*
DistributionPointReasonFlags ::= BIT STRING { DistributionPointReasonFlags ::= BIT STRING {
unused(0), unused(0),
keyCompromise(1), keyCompromise(1),
cACompromise(2), cACompromise(2),
affiliationChanged(3), affiliationChanged(3),
superseded(4), superseded(4),
cessationOfOperation(5), cessationOfOperation(5),
certificateHold(6), certificateHold(6),
skipping to change at line 1157 skipping to change at line 1215
typedef struct DistributionPointReasonFlags { typedef struct DistributionPointReasonFlags {
unsigned int unused:1; unsigned int unused:1;
unsigned int keyCompromise:1; unsigned int keyCompromise:1;
unsigned int cACompromise:1; unsigned int cACompromise:1;
unsigned int affiliationChanged:1; unsigned int affiliationChanged:1;
unsigned int superseded:1; unsigned int superseded:1;
unsigned int cessationOfOperation:1; unsigned int cessationOfOperation:1;
unsigned int certificateHold:1; unsigned int certificateHold:1;
unsigned int privilegeWithdrawn:1; unsigned int privilegeWithdrawn:1;
unsigned int aACompromise:1; unsigned int aACompromise: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;
} DistributionPointReasonFlags; } DistributionPointReasonFlags;
int encode_DistributionPointReasonFlags(unsigned char *, size_t, const D
istributionPointReasonFlags *, size_t *);
int decode_DistributionPointReasonFlags(const unsigned char *, size_t, D
istributionPointReasonFlags *, size_t *);
void free_DistributionPointReasonFlags (DistributionPointReasonFlags *);
size_t length_DistributionPointReasonFlags(const DistributionPointReasonFla
gs *);
int copy_DistributionPointReasonFlags (const DistributionPointReasonFla
gs *, DistributionPointReasonFlags *);
unsigned DistributionPointReasonFlags2int(DistributionPointReasonFlags); unsigned DistributionPointReasonFlags2int(DistributionPointReasonFlags);
DistributionPointReasonFlags int2DistributionPointReasonFlags(unsigned); DistributionPointReasonFlags int2DistributionPointReasonFlags(unsigned);
const struct units * asn1_DistributionPointReasonFlags_units(void); const struct units * asn1_DistributionPointReasonFlags_units(void);
ASN1EXP int ASN1CALL decode_DistributionPointReasonFlags(const unsigned
char *, size_t, DistributionPointReasonFlags *, size_t *);
ASN1EXP int ASN1CALL encode_DistributionPointReasonFlags(unsigned char *
, size_t, const DistributionPointReasonFlags *, size_t *);
ASN1EXP size_t ASN1CALL length_DistributionPointReasonFlags(const Distribut
ionPointReasonFlags *);
ASN1EXP int ASN1CALL copy_DistributionPointReasonFlags (const Distribut
ionPointReasonFlags *, DistributionPointReasonFlags *);
ASN1EXP void ASN1CALL free_DistributionPointReasonFlags (DistributionPoi
ntReasonFlags *);
/* /*
DistributionPointName ::= CHOICE { DistributionPointName ::= CHOICE {
fullName [0] IMPLICIT SEQUENCE OF GeneralName, fullName [0] IMPLICIT SEQUENCE OF GeneralName,
nameRelativeToCRLIssuer [1] RelativeDistinguishedName, nameRelativeToCRLIssuer [1] RelativeDistinguishedName,
} }
*/ */
typedef struct DistributionPointName { typedef struct DistributionPointName {
enum { enum {
choice_DistributionPointName_fullName = 1, choice_DistributionPointName_fullName = 1,
choice_DistributionPointName_nameRelativeToCRLIssuer choice_DistributionPointName_nameRelativeToCRLIssuer
} element; } element;
union { union {
struct { struct DistributionPointName_fullName {
unsigned int len; unsigned int len;
GeneralName *val; GeneralName *val;
} fullName; } fullName;
RelativeDistinguishedName nameRelativeToCRLIssuer; RelativeDistinguishedName nameRelativeToCRLIssuer;
} u; } u;
} DistributionPointName; } DistributionPointName;
int encode_DistributionPointName(unsigned char *, size_t, const Distribu ASN1EXP int ASN1CALL decode_DistributionPointName(const unsigned char *,
tionPointName *, size_t *); size_t, DistributionPointName *, size_t *);
int decode_DistributionPointName(const unsigned char *, size_t, Distribu ASN1EXP int ASN1CALL encode_DistributionPointName(unsigned char *, size_
tionPointName *, size_t *); t, const DistributionPointName *, size_t *);
void free_DistributionPointName (DistributionPointName *); ASN1EXP size_t ASN1CALL length_DistributionPointName(const DistributionPoin
size_t length_DistributionPointName(const DistributionPointName *); tName *);
int copy_DistributionPointName (const DistributionPointName *, Distribu ASN1EXP int ASN1CALL copy_DistributionPointName (const DistributionPoin
tionPointName *); tName *, DistributionPointName *);
ASN1EXP void ASN1CALL free_DistributionPointName (DistributionPointName
*);
/* /*
DistributionPoint ::= SEQUENCE { DistributionPoint ::= SEQUENCE {
distributionPoint [0] IMPLICIT heim_any OPTIONAL, distributionPoint [0] IMPLICIT heim_any OPTIONAL,
reasons [1] IMPLICIT heim_any OPTIONAL, reasons [1] IMPLICIT heim_any OPTIONAL,
cRLIssuer [2] IMPLICIT heim_any OPTIONAL, cRLIssuer [2] IMPLICIT heim_any OPTIONAL,
} }
*/ */
typedef struct DistributionPoint { typedef struct DistributionPoint {
heim_any *distributionPoint; heim_any *distributionPoint;
heim_any *reasons; heim_any *reasons;
heim_any *cRLIssuer; heim_any *cRLIssuer;
} DistributionPoint; } DistributionPoint;
int encode_DistributionPoint(unsigned char *, size_t, const Distribution ASN1EXP int ASN1CALL decode_DistributionPoint(const unsigned char *, siz
Point *, size_t *); e_t, DistributionPoint *, size_t *);
int decode_DistributionPoint(const unsigned char *, size_t, Distribution ASN1EXP int ASN1CALL encode_DistributionPoint(unsigned char *, size_t, c
Point *, size_t *); onst DistributionPoint *, size_t *);
void free_DistributionPoint (DistributionPoint *); ASN1EXP size_t ASN1CALL length_DistributionPoint(const DistributionPoint *)
size_t length_DistributionPoint(const DistributionPoint *); ;
int copy_DistributionPoint (const DistributionPoint *, DistributionPoin ASN1EXP int ASN1CALL copy_DistributionPoint (const DistributionPoint *,
t *); DistributionPoint *);
ASN1EXP void ASN1CALL free_DistributionPoint (DistributionPoint *);
/* /*
CRLDistributionPoints ::= SEQUENCE OF DistributionPoint CRLDistributionPoints ::= SEQUENCE OF DistributionPoint
*/ */
typedef struct CRLDistributionPoints { typedef struct CRLDistributionPoints {
unsigned int len; unsigned int len;
DistributionPoint *val; DistributionPoint *val;
} CRLDistributionPoints; } CRLDistributionPoints;
int encode_CRLDistributionPoints(unsigned char *, size_t, const CRLDistr ASN1EXP int ASN1CALL add_CRLDistributionPoints (CRLDistributionPoints *,
ibutionPoints *, size_t *); const DistributionPoint *);
int decode_CRLDistributionPoints(const unsigned char *, size_t, CRLDistr ASN1EXP int ASN1CALL remove_CRLDistributionPoints (CRLDistributionPoints
ibutionPoints *, size_t *); *, unsigned int);
void free_CRLDistributionPoints (CRLDistributionPoints *); ASN1EXP int ASN1CALL decode_CRLDistributionPoints(const unsigned char *,
size_t length_CRLDistributionPoints(const CRLDistributionPoints *); size_t, CRLDistributionPoints *, size_t *);
int copy_CRLDistributionPoints (const CRLDistributionPoints *, CRLDistr ASN1EXP int ASN1CALL encode_CRLDistributionPoints(unsigned char *, size_
ibutionPoints *); t, const CRLDistributionPoints *, size_t *);
int add_CRLDistributionPoints (CRLDistributionPoints *, const Distributi ASN1EXP size_t ASN1CALL length_CRLDistributionPoints(const CRLDistributionP
onPoint *); oints *);
int remove_CRLDistributionPoints (CRLDistributionPoints *, unsigned int) ASN1EXP int ASN1CALL copy_CRLDistributionPoints (const CRLDistributionP
; oints *, CRLDistributionPoints *);
ASN1EXP void ASN1CALL free_CRLDistributionPoints (CRLDistributionPoints
*);
/* /*
DSASigValue ::= SEQUENCE { DSASigValue ::= SEQUENCE {
r INTEGER, r INTEGER,
s INTEGER, s INTEGER,
} }
*/ */
typedef struct DSASigValue { typedef struct DSASigValue {
heim_integer r; heim_integer r;
heim_integer s; heim_integer s;
} DSASigValue; } DSASigValue;
int encode_DSASigValue(unsigned char *, size_t, const DSASigValue *, siz ASN1EXP int ASN1CALL decode_DSASigValue(const unsigned char *, size_t, D
e_t *); SASigValue *, size_t *);
int decode_DSASigValue(const unsigned char *, size_t, DSASigValue *, siz ASN1EXP int ASN1CALL encode_DSASigValue(unsigned char *, size_t, const D
e_t *); SASigValue *, size_t *);
void free_DSASigValue (DSASigValue *); ASN1EXP size_t ASN1CALL length_DSASigValue(const DSASigValue *);
size_t length_DSASigValue(const DSASigValue *); ASN1EXP int ASN1CALL copy_DSASigValue (const DSASigValue *, DSASigValue
int copy_DSASigValue (const DSASigValue *, DSASigValue *); *);
ASN1EXP void ASN1CALL free_DSASigValue (DSASigValue *);
/* /*
DSAPublicKey ::= INTEGER DSAPublicKey ::= INTEGER
*/ */
typedef heim_integer DSAPublicKey; typedef heim_integer DSAPublicKey;
int encode_DSAPublicKey(unsigned char *, size_t, const DSAPublicKey *, s ASN1EXP int ASN1CALL decode_DSAPublicKey(const unsigned char *, size_t,
ize_t *); DSAPublicKey *, size_t *);
int decode_DSAPublicKey(const unsigned char *, size_t, DSAPublicKey *, s ASN1EXP int ASN1CALL encode_DSAPublicKey(unsigned char *, size_t, const
ize_t *); DSAPublicKey *, size_t *);
void free_DSAPublicKey (DSAPublicKey *); ASN1EXP size_t ASN1CALL length_DSAPublicKey(const DSAPublicKey *);
size_t length_DSAPublicKey(const DSAPublicKey *); ASN1EXP int ASN1CALL copy_DSAPublicKey (const DSAPublicKey *, DSAPublic
int copy_DSAPublicKey (const DSAPublicKey *, DSAPublicKey *); Key *);
ASN1EXP void ASN1CALL free_DSAPublicKey (DSAPublicKey *);
/* /*
DSAParams ::= SEQUENCE { DSAParams ::= SEQUENCE {
p INTEGER, p INTEGER,
q INTEGER, q INTEGER,
g INTEGER, g INTEGER,
} }
*/ */
typedef struct DSAParams { typedef struct DSAParams {
heim_integer p; heim_integer p;
heim_integer q; heim_integer q;
heim_integer g; heim_integer g;
} DSAParams; } DSAParams;
int encode_DSAParams(unsigned char *, size_t, const DSAParams *, size_t ASN1EXP int ASN1CALL decode_DSAParams(const unsigned char *, size_t, DSA
*); Params *, size_t *);
int decode_DSAParams(const unsigned char *, size_t, DSAParams *, size_t ASN1EXP int ASN1CALL encode_DSAParams(unsigned char *, size_t, const DSA
*); Params *, size_t *);
void free_DSAParams (DSAParams *); ASN1EXP size_t ASN1CALL length_DSAParams(const DSAParams *);
size_t length_DSAParams(const DSAParams *); ASN1EXP int ASN1CALL copy_DSAParams (const DSAParams *, DSAParams *);
int copy_DSAParams (const DSAParams *, DSAParams *); ASN1EXP void ASN1CALL free_DSAParams (DSAParams *);
/* /*
ECPoint ::= OCTET STRING ECPoint ::= OCTET STRING
*/ */
typedef heim_octet_string ECPoint; typedef heim_octet_string ECPoint;
int encode_ECPoint(unsigned char *, size_t, const ECPoint *, size_t *); ASN1EXP int ASN1CALL decode_ECPoint(const unsigned char *, size_t, ECPoi
int decode_ECPoint(const unsigned char *, size_t, ECPoint *, size_t *); nt *, size_t *);
void free_ECPoint (ECPoint *); ASN1EXP int ASN1CALL encode_ECPoint(unsigned char *, size_t, const ECPoi
size_t length_ECPoint(const ECPoint *); nt *, size_t *);
int copy_ECPoint (const ECPoint *, ECPoint *); ASN1EXP size_t ASN1CALL length_ECPoint(const ECPoint *);
ASN1EXP int ASN1CALL copy_ECPoint (const ECPoint *, ECPoint *);
ASN1EXP void ASN1CALL free_ECPoint (ECPoint *);
/* /*
ECParameters ::= CHOICE { ECParameters ::= CHOICE {
namedCurve OBJECT IDENTIFIER, namedCurve OBJECT IDENTIFIER,
} }
*/ */
typedef struct ECParameters { typedef struct ECParameters {
enum { enum {
choice_ECParameters_namedCurve = 1 choice_ECParameters_namedCurve = 1
} element; } element;
union { union {
heim_oid namedCurve; heim_oid namedCurve;
} u; } u;
} ECParameters; } ECParameters;
int encode_ECParameters(unsigned char *, size_t, const ECParameters *, s ASN1EXP int ASN1CALL decode_ECParameters(const unsigned char *, size_t,
ize_t *); ECParameters *, size_t *);
int decode_ECParameters(const unsigned char *, size_t, ECParameters *, s ASN1EXP int ASN1CALL encode_ECParameters(unsigned char *, size_t, const
ize_t *); ECParameters *, size_t *);
void free_ECParameters (ECParameters *); ASN1EXP size_t ASN1CALL length_ECParameters(const ECParameters *);
size_t length_ECParameters(const ECParameters *); ASN1EXP int ASN1CALL copy_ECParameters (const ECParameters *, ECParamet
int copy_ECParameters (const ECParameters *, ECParameters *); ers *);
ASN1EXP void ASN1CALL free_ECParameters (ECParameters *);
/* /*
ECDSA-Sig-Value ::= SEQUENCE { ECDSA-Sig-Value ::= SEQUENCE {
r INTEGER, r INTEGER,
s INTEGER, s INTEGER,
} }
*/ */
typedef struct ECDSA_Sig_Value { typedef struct ECDSA_Sig_Value {
heim_integer r; heim_integer r;
heim_integer s; heim_integer s;
} ECDSA_Sig_Value; } ECDSA_Sig_Value;
int encode_ECDSA_Sig_Value(unsigned char *, size_t, const ECDSA_Sig_Valu ASN1EXP int ASN1CALL decode_ECDSA_Sig_Value(const unsigned char *, size_
e *, size_t *); t, ECDSA_Sig_Value *, size_t *);
int decode_ECDSA_Sig_Value(const unsigned char *, size_t, ECDSA_Sig_Valu ASN1EXP int ASN1CALL encode_ECDSA_Sig_Value(unsigned char *, size_t, con
e *, size_t *); st ECDSA_Sig_Value *, size_t *);
void free_ECDSA_Sig_Value (ECDSA_Sig_Value *); ASN1EXP size_t ASN1CALL length_ECDSA_Sig_Value(const ECDSA_Sig_Value *);
size_t length_ECDSA_Sig_Value(const ECDSA_Sig_Value *); ASN1EXP int ASN1CALL copy_ECDSA_Sig_Value (const ECDSA_Sig_Value *, ECD
int copy_ECDSA_Sig_Value (const ECDSA_Sig_Value *, ECDSA_Sig_Value *); SA_Sig_Value *);
ASN1EXP void ASN1CALL free_ECDSA_Sig_Value (ECDSA_Sig_Value *);
/* /*
RSAPublicKey ::= SEQUENCE { RSAPublicKey ::= SEQUENCE {
modulus INTEGER, modulus INTEGER,
publicExponent INTEGER, publicExponent INTEGER,
} }
*/ */
typedef struct RSAPublicKey { typedef struct RSAPublicKey {
heim_integer modulus; heim_integer modulus;
heim_integer publicExponent; heim_integer publicExponent;
} RSAPublicKey; } RSAPublicKey;
int encode_RSAPublicKey(unsigned char *, size_t, const RSAPublicKey *, s ASN1EXP int ASN1CALL decode_RSAPublicKey(const unsigned char *, size_t,
ize_t *); RSAPublicKey *, size_t *);
int decode_RSAPublicKey(const unsigned char *, size_t, RSAPublicKey *, s ASN1EXP int ASN1CALL encode_RSAPublicKey(unsigned char *, size_t, const
ize_t *); RSAPublicKey *, size_t *);
void free_RSAPublicKey (RSAPublicKey *); ASN1EXP size_t ASN1CALL length_RSAPublicKey(const RSAPublicKey *);
size_t length_RSAPublicKey(const RSAPublicKey *); ASN1EXP int ASN1CALL copy_RSAPublicKey (const RSAPublicKey *, RSAPublic
int copy_RSAPublicKey (const RSAPublicKey *, RSAPublicKey *); Key *);
ASN1EXP void ASN1CALL free_RSAPublicKey (RSAPublicKey *);
/* /*
RSAPrivateKey ::= SEQUENCE { RSAPrivateKey ::= SEQUENCE {
version INTEGER (0..2147483647), version INTEGER (0..2147483647),
modulus INTEGER, modulus INTEGER,
publicExponent INTEGER, publicExponent INTEGER,
privateExponent INTEGER, privateExponent INTEGER,
prime1 INTEGER, prime1 INTEGER,
prime2 INTEGER, prime2 INTEGER,
exponent1 INTEGER, exponent1 INTEGER,
skipping to change at line 1377 skipping to change at line 1458
heim_integer modulus; heim_integer modulus;
heim_integer publicExponent; heim_integer publicExponent;
heim_integer privateExponent; heim_integer privateExponent;
heim_integer prime1; heim_integer prime1;
heim_integer prime2; heim_integer prime2;
heim_integer exponent1; heim_integer exponent1;
heim_integer exponent2; heim_integer exponent2;
heim_integer coefficient; heim_integer coefficient;
} RSAPrivateKey; } RSAPrivateKey;
int encode_RSAPrivateKey(unsigned char *, size_t, const RSAPrivateKey *, ASN1EXP int ASN1CALL decode_RSAPrivateKey(const unsigned char *, size_t,
size_t *); RSAPrivateKey *, size_t *);
int decode_RSAPrivateKey(const unsigned char *, size_t, RSAPrivateKey *, ASN1EXP int ASN1CALL encode_RSAPrivateKey(unsigned char *, size_t, const
size_t *); RSAPrivateKey *, size_t *);
void free_RSAPrivateKey (RSAPrivateKey *); ASN1EXP size_t ASN1CALL length_RSAPrivateKey(const RSAPrivateKey *);
size_t length_RSAPrivateKey(const RSAPrivateKey *); ASN1EXP int ASN1CALL copy_RSAPrivateKey (const RSAPrivateKey *, RSAPriv
int copy_RSAPrivateKey (const RSAPrivateKey *, RSAPrivateKey *); ateKey *);
ASN1EXP void ASN1CALL free_RSAPrivateKey (RSAPrivateKey *);
/* /*
DigestInfo ::= SEQUENCE { DigestInfo ::= SEQUENCE {
digestAlgorithm AlgorithmIdentifier, digestAlgorithm AlgorithmIdentifier,
digest OCTET STRING, digest OCTET STRING,
} }
*/ */
typedef struct DigestInfo { typedef struct DigestInfo {
AlgorithmIdentifier digestAlgorithm; AlgorithmIdentifier digestAlgorithm;
heim_octet_string digest; heim_octet_string digest;
} DigestInfo; } DigestInfo;
int encode_DigestInfo(unsigned char *, size_t, const DigestInfo *, size_ ASN1EXP int ASN1CALL decode_DigestInfo(const unsigned char *, size_t, Di
t *); gestInfo *, size_t *);
int decode_DigestInfo(const unsigned char *, size_t, DigestInfo *, size_ ASN1EXP int ASN1CALL encode_DigestInfo(unsigned char *, size_t, const Di
t *); gestInfo *, size_t *);
void free_DigestInfo (DigestInfo *); ASN1EXP size_t ASN1CALL length_DigestInfo(const DigestInfo *);
size_t length_DigestInfo(const DigestInfo *); ASN1EXP int ASN1CALL copy_DigestInfo (const DigestInfo *, DigestInfo *)
int copy_DigestInfo (const DigestInfo *, DigestInfo *); ;
ASN1EXP void ASN1CALL free_DigestInfo (DigestInfo *);
/* /*
TBSCRLCertList ::= SEQUENCE { TBSCRLCertList ::= SEQUENCE {
version Version OPTIONAL, version Version OPTIONAL,
signature AlgorithmIdentifier, signature AlgorithmIdentifier,
issuer Name, issuer Name,
thisUpdate Time, thisUpdate Time,
nextUpdate Time OPTIONAL, nextUpdate Time OPTIONAL,
revokedCertificates SEQUENCE OF SEQUENCE { revokedCertificates SEQUENCE OF SEQUENCE {
userCertificate CertificateSerialNumber, userCertificate CertificateSerialNumber,
skipping to change at line 1424 skipping to change at line 1505
} }
*/ */
typedef struct TBSCRLCertList { typedef struct TBSCRLCertList {
heim_octet_string _save; heim_octet_string _save;
Version *version; Version *version;
AlgorithmIdentifier signature; AlgorithmIdentifier signature;
Name issuer; Name issuer;
Time thisUpdate; Time thisUpdate;
Time *nextUpdate; Time *nextUpdate;
struct { struct TBSCRLCertList_revokedCertificates {
unsigned int len; unsigned int len;
struct { struct TBSCRLCertList_revokedCertificates_val {
CertificateSerialNumber userCertificate; CertificateSerialNumber userCertificate;
Time revocationDate; Time revocationDate;
Extensions *crlEntryExtensions; Extensions *crlEntryExtensions;
} *val; } *val;
} *revokedCertificates; } *revokedCertificates;
Extensions *crlExtensions; Extensions *crlExtensions;
} TBSCRLCertList; } TBSCRLCertList;
int encode_TBSCRLCertList(unsigned char *, size_t, const TBSCRLCertList ASN1EXP int ASN1CALL decode_TBSCRLCertList(const unsigned char *, size_t
*, size_t *); , TBSCRLCertList *, size_t *);
int decode_TBSCRLCertList(const unsigned char *, size_t, TBSCRLCertList ASN1EXP int ASN1CALL encode_TBSCRLCertList(unsigned char *, size_t, cons
*, size_t *); t TBSCRLCertList *, size_t *);
void free_TBSCRLCertList (TBSCRLCertList *); ASN1EXP size_t ASN1CALL length_TBSCRLCertList(const TBSCRLCertList *);
size_t length_TBSCRLCertList(const TBSCRLCertList *); ASN1EXP int ASN1CALL copy_TBSCRLCertList (const TBSCRLCertList *, TBSCR
int copy_TBSCRLCertList (const TBSCRLCertList *, TBSCRLCertList *); LCertList *);
ASN1EXP void ASN1CALL free_TBSCRLCertList (TBSCRLCertList *);
/* /*
CRLCertificateList ::= SEQUENCE { CRLCertificateList ::= SEQUENCE {
tbsCertList TBSCRLCertList, tbsCertList TBSCRLCertList,
signatureAlgorithm AlgorithmIdentifier, signatureAlgorithm AlgorithmIdentifier,
signatureValue BIT STRING { signatureValue BIT STRING {
}, },
} }
*/ */
typedef struct CRLCertificateList { typedef struct CRLCertificateList {
TBSCRLCertList tbsCertList; TBSCRLCertList tbsCertList;
AlgorithmIdentifier signatureAlgorithm; AlgorithmIdentifier signatureAlgorithm;
heim_bit_string signatureValue; heim_bit_string signatureValue;
} CRLCertificateList; } CRLCertificateList;
int encode_CRLCertificateList(unsigned char *, size_t, const CRLCertific ASN1EXP int ASN1CALL decode_CRLCertificateList(const unsigned char *, si
ateList *, size_t *); ze_t, CRLCertificateList *, size_t *);
int decode_CRLCertificateList(const unsigned char *, size_t, CRLCertific ASN1EXP int ASN1CALL encode_CRLCertificateList(unsigned char *, size_t,
ateList *, size_t *); const CRLCertificateList *, size_t *);
void free_CRLCertificateList (CRLCertificateList *); ASN1EXP size_t ASN1CALL length_CRLCertificateList(const CRLCertificateList
size_t length_CRLCertificateList(const CRLCertificateList *); *);
int copy_CRLCertificateList (const CRLCertificateList *, CRLCertificate ASN1EXP int ASN1CALL copy_CRLCertificateList (const CRLCertificateList
List *); *, CRLCertificateList *);
ASN1EXP void ASN1CALL free_CRLCertificateList (CRLCertificateList *);
/* OBJECT IDENTIFIER id-x509-ce-cRLNumber ::= { joint-iso-ccitt(2) ds(5) la bel-less(29) label-less(20) } */ /* OBJECT IDENTIFIER id-x509-ce-cRLNumber ::= { joint-iso-ccitt(2) ds(5) la bel-less(29) label-less(20) } */
const heim_oid *oid_id_x509_ce_cRLNumber(void);
extern const heim_oid asn1_oid_id_x509_ce_cRLNumber; extern const heim_oid asn1_oid_id_x509_ce_cRLNumber;
#define ASN1_OID_ID_X509_CE_CRLNUMBER (&asn1_oid_id_x509_ce_cRLNumber)
/* OBJECT IDENTIFIER id-x509-ce-freshestCRL ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(46) } */ /* OBJECT IDENTIFIER id-x509-ce-freshestCRL ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(46) } */
const heim_oid *oid_id_x509_ce_freshestCRL(void);
extern const heim_oid asn1_oid_id_x509_ce_freshestCRL; extern const heim_oid asn1_oid_id_x509_ce_freshestCRL;
#define ASN1_OID_ID_X509_CE_FRESHESTCRL (&asn1_oid_id_x509_ce_freshestCRL)
/* OBJECT IDENTIFIER id-x509-ce-cRLReason ::= { joint-iso-ccitt(2) ds(5) la bel-less(29) label-less(21) } */ /* OBJECT IDENTIFIER id-x509-ce-cRLReason ::= { joint-iso-ccitt(2) ds(5) la bel-less(29) label-less(21) } */
const heim_oid *oid_id_x509_ce_cRLReason(void);
extern const heim_oid asn1_oid_id_x509_ce_cRLReason; extern const heim_oid asn1_oid_id_x509_ce_cRLReason;
#define ASN1_OID_ID_X509_CE_CRLREASON (&asn1_oid_id_x509_ce_cRLReason)
/* /*
CRLReason ::= INTEGER { CRLReason ::= INTEGER {
unspecified(0), unspecified(0),
keyCompromise(1), keyCompromise(1),
cACompromise(2), cACompromise(2),
affiliationChanged(3), affiliationChanged(3),
superseded(4), superseded(4),
cessationOfOperation(5), cessationOfOperation(5),
certificateHold(6), certificateHold(6),
skipping to change at line 1502 skipping to change at line 1583
cACompromise = 2, cACompromise = 2,
affiliationChanged = 3, affiliationChanged = 3,
superseded = 4, superseded = 4,
cessationOfOperation = 5, cessationOfOperation = 5,
certificateHold = 6, certificateHold = 6,
removeFromCRL = 8, removeFromCRL = 8,
privilegeWithdrawn = 9, privilegeWithdrawn = 9,
aACompromise = 10 aACompromise = 10
} CRLReason; } CRLReason;
int encode_CRLReason(unsigned char *, size_t, const CRLReason *, size_t ASN1EXP int ASN1CALL decode_CRLReason(const unsigned char *, size_t, CRL
*); Reason *, size_t *);
int decode_CRLReason(const unsigned char *, size_t, CRLReason *, size_t ASN1EXP int ASN1CALL encode_CRLReason(unsigned char *, size_t, const CRL
*); Reason *, size_t *);
void free_CRLReason (CRLReason *); ASN1EXP size_t ASN1CALL length_CRLReason(const CRLReason *);
size_t length_CRLReason(const CRLReason *); ASN1EXP int ASN1CALL copy_CRLReason (const CRLReason *, CRLReason *);
int copy_CRLReason (const CRLReason *, CRLReason *); ASN1EXP void ASN1CALL free_CRLReason (CRLReason *);
/* /*
PKIXXmppAddr ::= UTF8String PKIXXmppAddr ::= UTF8String
*/ */
typedef heim_utf8_string PKIXXmppAddr; typedef heim_utf8_string PKIXXmppAddr;
int encode_PKIXXmppAddr(unsigned char *, size_t, const PKIXXmppAddr *, s ASN1EXP int ASN1CALL decode_PKIXXmppAddr(const unsigned char *, size_t,
ize_t *); PKIXXmppAddr *, size_t *);
int decode_PKIXXmppAddr(const unsigned char *, size_t, PKIXXmppAddr *, s ASN1EXP int ASN1CALL encode_PKIXXmppAddr(unsigned char *, size_t, const
ize_t *); PKIXXmppAddr *, size_t *);
void free_PKIXXmppAddr (PKIXXmppAddr *); ASN1EXP size_t ASN1CALL length_PKIXXmppAddr(const PKIXXmppAddr *);
size_t length_PKIXXmppAddr(const PKIXXmppAddr *); ASN1EXP int ASN1CALL copy_PKIXXmppAddr (const PKIXXmppAddr *, PKIXXmppA
int copy_PKIXXmppAddr (const PKIXXmppAddr *, PKIXXmppAddr *); ddr *);
ASN1EXP void ASN1CALL free_PKIXXmppAddr (PKIXXmppAddr *);
/* OBJECT IDENTIFIER id-pkix ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) } */ /* OBJECT IDENTIFIER id-pkix ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) } */
const heim_oid *oid_id_pkix(void);
extern const heim_oid asn1_oid_id_pkix; extern const heim_oid asn1_oid_id_pkix;
#define ASN1_OID_ID_PKIX (&asn1_oid_id_pkix)
/* OBJECT IDENTIFIER id-pkix-on ::= { iso(1) identified-organization(3) dod (6) internet(1) security(5) mechanisms(5) pkix(7) label-less(8) } */ /* OBJECT IDENTIFIER id-pkix-on ::= { iso(1) identified-organization(3) dod (6) internet(1) security(5) mechanisms(5) pkix(7) label-less(8) } */
const heim_oid *oid_id_pkix_on(void);
extern const heim_oid asn1_oid_id_pkix_on; extern const heim_oid asn1_oid_id_pkix_on;
#define ASN1_OID_ID_PKIX_ON (&asn1_oid_id_pkix_on)
/* OBJECT IDENTIFIER id-pkix-on-xmppAddr ::= { iso(1) identified-organizati on(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(8) la bel-less(5) } */ /* OBJECT IDENTIFIER id-pkix-on-xmppAddr ::= { iso(1) identified-organizati on(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(8) la bel-less(5) } */
const heim_oid *oid_id_pkix_on_xmppAddr(void);
extern const heim_oid asn1_oid_id_pkix_on_xmppAddr; extern const heim_oid asn1_oid_id_pkix_on_xmppAddr;
#define ASN1_OID_ID_PKIX_ON_XMPPADDR (&asn1_oid_id_pkix_on_xmppAddr)
/* OBJECT IDENTIFIER id-pkix-on-dnsSRV ::= { iso(1) identified-organization (3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(8) labe l-less(7) } */ /* OBJECT IDENTIFIER id-pkix-on-dnsSRV ::= { iso(1) identified-organization (3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(8) labe l-less(7) } */
const heim_oid *oid_id_pkix_on_dnsSRV(void);
extern const heim_oid asn1_oid_id_pkix_on_dnsSRV; extern const heim_oid asn1_oid_id_pkix_on_dnsSRV;
#define ASN1_OID_ID_PKIX_ON_DNSSRV (&asn1_oid_id_pkix_on_dnsSRV)
/* OBJECT IDENTIFIER id-pkix-kp ::= { iso(1) identified-organization(3) dod (6) internet(1) security(5) mechanisms(5) pkix(7) label-less(3) } */ /* OBJECT IDENTIFIER id-pkix-kp ::= { iso(1) identified-organization(3) dod (6) internet(1) security(5) mechanisms(5) pkix(7) label-less(3) } */
const heim_oid *oid_id_pkix_kp(void);
extern const heim_oid asn1_oid_id_pkix_kp; extern const heim_oid asn1_oid_id_pkix_kp;
#define ASN1_OID_ID_PKIX_KP (&asn1_oid_id_pkix_kp)
/* OBJECT IDENTIFIER id-pkix-kp-serverAuth ::= { iso(1) identified-organiza tion(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(3) label-less(1) } */ /* OBJECT IDENTIFIER id-pkix-kp-serverAuth ::= { iso(1) identified-organiza tion(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(3) label-less(1) } */
const heim_oid *oid_id_pkix_kp_serverAuth(void);
extern const heim_oid asn1_oid_id_pkix_kp_serverAuth; extern const heim_oid asn1_oid_id_pkix_kp_serverAuth;
#define ASN1_OID_ID_PKIX_KP_SERVERAUTH (&asn1_oid_id_pkix_kp_serverAuth)
/* OBJECT IDENTIFIER id-pkix-kp-clientAuth ::= { iso(1) identified-organiza tion(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(3) label-less(2) } */ /* OBJECT IDENTIFIER id-pkix-kp-clientAuth ::= { iso(1) identified-organiza tion(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(3) label-less(2) } */
const heim_oid *oid_id_pkix_kp_clientAuth(void);
extern const heim_oid asn1_oid_id_pkix_kp_clientAuth; extern const heim_oid asn1_oid_id_pkix_kp_clientAuth;
#define ASN1_OID_ID_PKIX_KP_CLIENTAUTH (&asn1_oid_id_pkix_kp_clientAuth)
/* OBJECT IDENTIFIER id-pkix-kp-emailProtection ::= { iso(1) identified-org anization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-les s(3) label-less(4) } */ /* OBJECT IDENTIFIER id-pkix-kp-emailProtection ::= { iso(1) identified-org anization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-les s(3) label-less(4) } */
const heim_oid *oid_id_pkix_kp_emailProtection(void);
extern const heim_oid asn1_oid_id_pkix_kp_emailProtection; extern const heim_oid asn1_oid_id_pkix_kp_emailProtection;
#define ASN1_OID_ID_PKIX_KP_EMAILPROTECTION (&asn1_oid_id_pkix_kp_emailProt ection)
/* OBJECT IDENTIFIER id-pkix-kp-timeStamping ::= { iso(1) identified-organi zation(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(3 ) label-less(8) } */ /* OBJECT IDENTIFIER id-pkix-kp-timeStamping ::= { iso(1) identified-organi zation(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(3 ) label-less(8) } */
const heim_oid *oid_id_pkix_kp_timeStamping(void);
extern const heim_oid asn1_oid_id_pkix_kp_timeStamping; extern const heim_oid asn1_oid_id_pkix_kp_timeStamping;
#define ASN1_OID_ID_PKIX_KP_TIMESTAMPING (&asn1_oid_id_pkix_kp_timeStamping )
/* OBJECT IDENTIFIER id-pkix-kp-OCSPSigning ::= { iso(1) identified-organiz ation(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(3) label-less(9) } */ /* OBJECT IDENTIFIER id-pkix-kp-OCSPSigning ::= { iso(1) identified-organiz ation(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(3) label-less(9) } */
const heim_oid *oid_id_pkix_kp_OCSPSigning(void);
extern const heim_oid asn1_oid_id_pkix_kp_OCSPSigning; extern const heim_oid asn1_oid_id_pkix_kp_OCSPSigning;
#define ASN1_OID_ID_PKIX_KP_OCSPSIGNING (&asn1_oid_id_pkix_kp_OCSPSigning)
/* OBJECT IDENTIFIER id-pkix-pe ::= { iso(1) identified-organization(3) dod (6) internet(1) security(5) mechanisms(5) pkix(7) label-less(1) } */ /* OBJECT IDENTIFIER id-pkix-pe ::= { iso(1) identified-organization(3) dod (6) internet(1) security(5) mechanisms(5) pkix(7) label-less(1) } */
const heim_oid *oid_id_pkix_pe(void);
extern const heim_oid asn1_oid_id_pkix_pe; extern const heim_oid asn1_oid_id_pkix_pe;
#define ASN1_OID_ID_PKIX_PE (&asn1_oid_id_pkix_pe)
/* OBJECT IDENTIFIER id-pkix-pe-authorityInfoAccess ::= { iso(1) identified -organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label -less(1) label-less(1) } */ /* OBJECT IDENTIFIER id-pkix-pe-authorityInfoAccess ::= { iso(1) identified -organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label -less(1) label-less(1) } */
const heim_oid *oid_id_pkix_pe_authorityInfoAccess(void);
extern const heim_oid asn1_oid_id_pkix_pe_authorityInfoAccess; extern const heim_oid asn1_oid_id_pkix_pe_authorityInfoAccess;
#define ASN1_OID_ID_PKIX_PE_AUTHORITYINFOACCESS (&asn1_oid_id_pkix_pe_autho rityInfoAccess)
/* /*
AccessDescription ::= SEQUENCE { AccessDescription ::= SEQUENCE {
accessMethod OBJECT IDENTIFIER, accessMethod OBJECT IDENTIFIER,
accessLocation GeneralName, accessLocation GeneralName,
} }
*/ */
typedef struct AccessDescription { typedef struct AccessDescription {
heim_oid accessMethod; heim_oid accessMethod;
GeneralName accessLocation; GeneralName accessLocation;
} AccessDescription; } AccessDescription;
int encode_AccessDescription(unsigned char *, size_t, const AccessDescri ASN1EXP int ASN1CALL decode_AccessDescription(const unsigned char *, siz
ption *, size_t *); e_t, AccessDescription *, size_t *);
int decode_AccessDescription(const unsigned char *, size_t, AccessDescri ASN1EXP int ASN1CALL encode_AccessDescription(unsigned char *, size_t, c
ption *, size_t *); onst AccessDescription *, size_t *);
void free_AccessDescription (AccessDescription *); ASN1EXP size_t ASN1CALL length_AccessDescription(const AccessDescription *)
size_t length_AccessDescription(const AccessDescription *); ;
int copy_AccessDescription (const AccessDescription *, AccessDescriptio ASN1EXP int ASN1CALL copy_AccessDescription (const AccessDescription *,
n *); AccessDescription *);
ASN1EXP void ASN1CALL free_AccessDescription (AccessDescription *);
/* /*
AuthorityInfoAccessSyntax ::= SEQUENCE OF AccessDescription AuthorityInfoAccessSyntax ::= SEQUENCE OF AccessDescription
*/ */
typedef struct AuthorityInfoAccessSyntax { typedef struct AuthorityInfoAccessSyntax {
unsigned int len; unsigned int len;
AccessDescription *val; AccessDescription *val;
} AuthorityInfoAccessSyntax; } AuthorityInfoAccessSyntax;
int encode_AuthorityInfoAccessSyntax(unsigned char *, size_t, const Auth ASN1EXP int ASN1CALL decode_AuthorityInfoAccessSyntax(const unsigned cha
orityInfoAccessSyntax *, size_t *); r *, size_t, AuthorityInfoAccessSyntax *, size_t *);
int decode_AuthorityInfoAccessSyntax(const unsigned char *, size_t, Auth ASN1EXP int ASN1CALL encode_AuthorityInfoAccessSyntax(unsigned char *, s
orityInfoAccessSyntax *, size_t *); ize_t, const AuthorityInfoAccessSyntax *, size_t *);
void free_AuthorityInfoAccessSyntax (AuthorityInfoAccessSyntax *); ASN1EXP size_t ASN1CALL length_AuthorityInfoAccessSyntax(const AuthorityInf
size_t length_AuthorityInfoAccessSyntax(const AuthorityInfoAccessSyntax *); oAccessSyntax *);
int copy_AuthorityInfoAccessSyntax (const AuthorityInfoAccessSyntax *, ASN1EXP int ASN1CALL copy_AuthorityInfoAccessSyntax (const AuthorityInf
AuthorityInfoAccessSyntax *); oAccessSyntax *, AuthorityInfoAccessSyntax *);
ASN1EXP void ASN1CALL free_AuthorityInfoAccessSyntax (AuthorityInfoAcces
sSyntax *);
/* OBJECT IDENTIFIER id-pkix-pe-proxyCertInfo ::= { iso(1) identified-organ ization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less( 1) label-less(14) } */ /* OBJECT IDENTIFIER id-pkix-pe-proxyCertInfo ::= { iso(1) identified-organ ization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less( 1) label-less(14) } */
const heim_oid *oid_id_pkix_pe_proxyCertInfo(void);
extern const heim_oid asn1_oid_id_pkix_pe_proxyCertInfo; extern const heim_oid asn1_oid_id_pkix_pe_proxyCertInfo;
#define ASN1_OID_ID_PKIX_PE_PROXYCERTINFO (&asn1_oid_id_pkix_pe_proxyCertIn fo)
/* OBJECT IDENTIFIER id-pkix-ppl ::= { iso(1) identified-organization(3) do d(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(21) } */ /* OBJECT IDENTIFIER id-pkix-ppl ::= { iso(1) identified-organization(3) do d(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(21) } */
const heim_oid *oid_id_pkix_ppl(void);
extern const heim_oid asn1_oid_id_pkix_ppl; extern const heim_oid asn1_oid_id_pkix_ppl;
#define ASN1_OID_ID_PKIX_PPL (&asn1_oid_id_pkix_ppl)
/* OBJECT IDENTIFIER id-pkix-ppl-anyLanguage ::= { iso(1) identified-organi zation(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(2 1) label-less(0) } */ /* OBJECT IDENTIFIER id-pkix-ppl-anyLanguage ::= { iso(1) identified-organi zation(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(2 1) label-less(0) } */
const heim_oid *oid_id_pkix_ppl_anyLanguage(void);
extern const heim_oid asn1_oid_id_pkix_ppl_anyLanguage; extern const heim_oid asn1_oid_id_pkix_ppl_anyLanguage;
#define ASN1_OID_ID_PKIX_PPL_ANYLANGUAGE (&asn1_oid_id_pkix_ppl_anyLanguage )
/* OBJECT IDENTIFIER id-pkix-ppl-inheritAll ::= { iso(1) identified-organiz ation(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(21 ) label-less(1) } */ /* OBJECT IDENTIFIER id-pkix-ppl-inheritAll ::= { iso(1) identified-organiz ation(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(21 ) label-less(1) } */
const heim_oid *oid_id_pkix_ppl_inheritAll(void);
extern const heim_oid asn1_oid_id_pkix_ppl_inheritAll; extern const heim_oid asn1_oid_id_pkix_ppl_inheritAll;
#define ASN1_OID_ID_PKIX_PPL_INHERITALL (&asn1_oid_id_pkix_ppl_inheritAll)
/* OBJECT IDENTIFIER id-pkix-ppl-independent ::= { iso(1) identified-organi zation(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(2 1) label-less(2) } */ /* OBJECT IDENTIFIER id-pkix-ppl-independent ::= { iso(1) identified-organi zation(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(2 1) label-less(2) } */
const heim_oid *oid_id_pkix_ppl_independent(void);
extern const heim_oid asn1_oid_id_pkix_ppl_independent; extern const heim_oid asn1_oid_id_pkix_ppl_independent;
#define ASN1_OID_ID_PKIX_PPL_INDEPENDENT (&asn1_oid_id_pkix_ppl_independent )
/* /*
ProxyPolicy ::= SEQUENCE { ProxyPolicy ::= SEQUENCE {
policyLanguage OBJECT IDENTIFIER, policyLanguage OBJECT IDENTIFIER,
policy OCTET STRING OPTIONAL, policy OCTET STRING OPTIONAL,
} }
*/ */
typedef struct ProxyPolicy { typedef struct ProxyPolicy {
heim_oid policyLanguage; heim_oid policyLanguage;
heim_octet_string *policy; heim_octet_string *policy;
} ProxyPolicy; } ProxyPolicy;
int encode_ProxyPolicy(unsigned char *, size_t, const ProxyPolicy *, siz ASN1EXP int ASN1CALL decode_ProxyPolicy(const unsigned char *, size_t, P
e_t *); roxyPolicy *, size_t *);
int decode_ProxyPolicy(const unsigned char *, size_t, ProxyPolicy *, siz ASN1EXP int ASN1CALL encode_ProxyPolicy(unsigned char *, size_t, const P
e_t *); roxyPolicy *, size_t *);
void free_ProxyPolicy (ProxyPolicy *); ASN1EXP size_t ASN1CALL length_ProxyPolicy(const ProxyPolicy *);
size_t length_ProxyPolicy(const ProxyPolicy *); ASN1EXP int ASN1CALL copy_ProxyPolicy (const ProxyPolicy *, ProxyPolicy
int copy_ProxyPolicy (const ProxyPolicy *, ProxyPolicy *); *);
ASN1EXP void ASN1CALL free_ProxyPolicy (ProxyPolicy *);
/* /*
ProxyCertInfo ::= SEQUENCE { ProxyCertInfo ::= SEQUENCE {
pCPathLenConstraint INTEGER (0..2147483647) OPTIONAL, pCPathLenConstraint INTEGER (0..2147483647) OPTIONAL,
proxyPolicy ProxyPolicy, proxyPolicy ProxyPolicy,
} }
*/ */
typedef struct ProxyCertInfo { typedef struct ProxyCertInfo {
unsigned int *pCPathLenConstraint; unsigned int *pCPathLenConstraint;
ProxyPolicy proxyPolicy; ProxyPolicy proxyPolicy;
} ProxyCertInfo; } ProxyCertInfo;
int encode_ProxyCertInfo(unsigned char *, size_t, const ProxyCertInfo *, ASN1EXP int ASN1CALL decode_ProxyCertInfo(const unsigned char *, size_t,
size_t *); ProxyCertInfo *, size_t *);
int decode_ProxyCertInfo(const unsigned char *, size_t, ProxyCertInfo *, ASN1EXP int ASN1CALL encode_ProxyCertInfo(unsigned char *, size_t, const
size_t *); ProxyCertInfo *, size_t *);
void free_ProxyCertInfo (ProxyCertInfo *); ASN1EXP size_t ASN1CALL length_ProxyCertInfo(const ProxyCertInfo *);
size_t length_ProxyCertInfo(const ProxyCertInfo *); ASN1EXP int ASN1CALL copy_ProxyCertInfo (const ProxyCertInfo *, ProxyCe
int copy_ProxyCertInfo (const ProxyCertInfo *, ProxyCertInfo *); rtInfo *);
ASN1EXP void ASN1CALL free_ProxyCertInfo (ProxyCertInfo *);
/* OBJECT IDENTIFIER id-uspkicommon-card-id ::= { label-less(2) label-less( 16) label-less(840) label-less(1) label-less(101) label-less(3) label-less( 6) label-less(6) } */ /* OBJECT IDENTIFIER id-uspkicommon-card-id ::= { label-less(2) label-less( 16) label-less(840) label-less(1) label-less(101) label-less(3) label-less( 6) label-less(6) } */
const heim_oid *oid_id_uspkicommon_card_id(void);
extern const heim_oid asn1_oid_id_uspkicommon_card_id; extern const heim_oid asn1_oid_id_uspkicommon_card_id;
#define ASN1_OID_ID_USPKICOMMON_CARD_ID (&asn1_oid_id_uspkicommon_card_id)
/* OBJECT IDENTIFIER id-uspkicommon-piv-interim ::= { label-less(2) label-l ess(16) label-less(840) label-less(1) label-less(101) label-less(3) label-l ess(6) label-less(9) label-less(1) } */ /* OBJECT IDENTIFIER id-uspkicommon-piv-interim ::= { label-less(2) label-l ess(16) label-less(840) label-less(1) label-less(101) label-less(3) label-l ess(6) label-less(9) label-less(1) } */
const heim_oid *oid_id_uspkicommon_piv_interim(void);
extern const heim_oid asn1_oid_id_uspkicommon_piv_interim; extern const heim_oid asn1_oid_id_uspkicommon_piv_interim;
#define ASN1_OID_ID_USPKICOMMON_PIV_INTERIM (&asn1_oid_id_uspkicommon_piv_i nterim)
/* OBJECT IDENTIFIER id-netscape ::= { joint-iso-itu-t(2) country(16) us(84 0) organization(1) netscape(113730) } */ /* OBJECT IDENTIFIER id-netscape ::= { joint-iso-itu-t(2) country(16) us(84 0) organization(1) netscape(113730) } */
const heim_oid *oid_id_netscape(void);
extern const heim_oid asn1_oid_id_netscape; extern const heim_oid asn1_oid_id_netscape;
#define ASN1_OID_ID_NETSCAPE (&asn1_oid_id_netscape)
/* OBJECT IDENTIFIER id-netscape-cert-comment ::= { joint-iso-itu-t(2) coun try(16) us(840) organization(1) netscape(113730) label-less(1) label-less(1 3) } */ /* OBJECT IDENTIFIER id-netscape-cert-comment ::= { joint-iso-itu-t(2) coun try(16) us(840) organization(1) netscape(113730) label-less(1) label-less(1 3) } */
const heim_oid *oid_id_netscape_cert_comment(void);
extern const heim_oid asn1_oid_id_netscape_cert_comment; extern const heim_oid asn1_oid_id_netscape_cert_comment;
#define ASN1_OID_ID_NETSCAPE_CERT_COMMENT (&asn1_oid_id_netscape_cert_comme nt)
/* OBJECT IDENTIFIER id-ms-cert-enroll-domaincontroller ::= { label-less(1) label-less(3) label-less(6) label-less(1) label-less(4) label-less(1) labe l-less(311) label-less(20) label-less(2) } */ /* OBJECT IDENTIFIER id-ms-cert-enroll-domaincontroller ::= { label-less(1) label-less(3) label-less(6) label-less(1) label-less(4) label-less(1) labe l-less(311) label-less(20) label-less(2) } */
const heim_oid *oid_id_ms_cert_enroll_domaincontroller(void);
extern const heim_oid asn1_oid_id_ms_cert_enroll_domaincontroller; extern const heim_oid asn1_oid_id_ms_cert_enroll_domaincontroller;
#define ASN1_OID_ID_MS_CERT_ENROLL_DOMAINCONTROLLER (&asn1_oid_id_ms_cert_e nroll_domaincontroller)
/* OBJECT IDENTIFIER id-ms-client-authentication ::= { label-less(1) label- less(3) label-less(6) label-less(1) label-less(5) label-less(5) label-less( 7) label-less(3) label-less(2) } */ /* OBJECT IDENTIFIER id-ms-client-authentication ::= { label-less(1) label- less(3) label-less(6) label-less(1) label-less(5) label-less(5) label-less( 7) label-less(3) label-less(2) } */
const heim_oid *oid_id_ms_client_authentication(void);
extern const heim_oid asn1_oid_id_ms_client_authentication; extern const heim_oid asn1_oid_id_ms_client_authentication;
#define ASN1_OID_ID_MS_CLIENT_AUTHENTICATION (&asn1_oid_id_ms_client_authen tication)
#endif /* __rfc2459_asn1_h__ */ #endif /* __rfc2459_asn1_h__ */
 End of changes. 295 change blocks. 
539 lines changed or deleted 686 lines changed or added


 roken-common.h   roken-common.h 
skipping to change at line 41 skipping to change at line 41
* SUCH DAMAGE. * SUCH DAMAGE.
*/ */
/* $Id$ */ /* $Id$ */
#ifndef __ROKEN_COMMON_H__ #ifndef __ROKEN_COMMON_H__
#define __ROKEN_COMMON_H__ #define __ROKEN_COMMON_H__
#ifndef ROKEN_LIB_FUNCTION #ifndef ROKEN_LIB_FUNCTION
#ifdef _WIN32 #ifdef _WIN32
#define ROKEN_LIB_FUNCTION _stdcall #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL __cdecl
#else #else
#define ROKEN_LIB_FUNCTION #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL
#endif #endif
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
#define ROKEN_CPP_START extern "C" { #define ROKEN_CPP_START extern "C" {
#define ROKEN_CPP_END } #define ROKEN_CPP_END }
#else #else
#define ROKEN_CPP_START #define ROKEN_CPP_START
#define ROKEN_CPP_END #define ROKEN_CPP_END
#endif #endif
skipping to change at line 123 skipping to change at line 125
#endif #endif
#ifndef F_OK #ifndef F_OK
#define F_OK 0 #define F_OK 0
#endif #endif
#ifndef O_ACCMODE #ifndef O_ACCMODE
#define O_ACCMODE 003 #define O_ACCMODE 003
#endif #endif
#ifndef _WIN32
#ifndef _PATH_DEV #ifndef _PATH_DEV
#define _PATH_DEV "/dev/" #define _PATH_DEV "/dev/"
#endif #endif
#ifndef _PATH_DEVNULL #ifndef _PATH_DEVNULL
#define _PATH_DEVNULL "/dev/null" #define _PATH_DEVNULL "/dev/null"
#endif #endif
#ifndef _PATH_HEQUIV #ifndef _PATH_HEQUIV
#define _PATH_HEQUIV "/etc/hosts.equiv" #define _PATH_HEQUIV "/etc/hosts.equiv"
skipping to change at line 147 skipping to change at line 151
#endif #endif
#ifndef _PATH_BSHELL #ifndef _PATH_BSHELL
#define _PATH_BSHELL "/bin/sh" #define _PATH_BSHELL "/bin/sh"
#endif #endif
#ifndef MAXPATHLEN #ifndef MAXPATHLEN
#define MAXPATHLEN (1024+4) #define MAXPATHLEN (1024+4)
#endif #endif
#endif /* !_WIN32 */
#ifndef PATH_MAX
#define PATH_MAX MAX_PATH
#endif
#ifndef RETSIGTYPE
#define RETSIGTYPE void
#endif
#ifndef SIG_ERR #ifndef SIG_ERR
#define SIG_ERR ((RETSIGTYPE (*)(int))-1) #define SIG_ERR ((RETSIGTYPE (*)(int))-1)
#endif #endif
/* /*
* error code for getipnodeby{name,addr} * error code for getipnodeby{name,addr}
*/ */
#ifndef HOST_NOT_FOUND #ifndef HOST_NOT_FOUND
#define HOST_NOT_FOUND 1 #define HOST_NOT_FOUND 1
skipping to change at line 264 skipping to change at line 278
#define SHUT_RDWR 2 #define SHUT_RDWR 2
#endif #endif
#ifndef HAVE___ATTRIBUTE__ #ifndef HAVE___ATTRIBUTE__
#define __attribute__(x) #define __attribute__(x)
#endif #endif
ROKEN_CPP_START ROKEN_CPP_START
#ifndef IRIX4 /* fix for compiler bug */ #ifndef IRIX4 /* fix for compiler bug */
#ifndef _WIN32
#ifdef RETSIGTYPE #ifdef RETSIGTYPE
typedef RETSIGTYPE (*SigAction)(int); typedef RETSIGTYPE (*SigAction)(int);
SigAction signal(int iSig, SigAction pAction); /* BSD compatible */ SigAction signal(int iSig, SigAction pAction); /* BSD compatible */
#endif #endif
#endif #endif
#endif
#define SE_E_UNSPECIFIED (-1)
#define SE_E_FORKFAILED (-2)
#define SE_E_WAITPIDFAILED (-3)
#define SE_E_EXECTIMEOUT (-4)
#define SE_E_NOEXEC 126
#define SE_E_NOTFOUND 127
#define SE_PROCSTATUS(st) (((st) >= 0 && (st) < 126)? st: -1)
#define SE_PROCSIGNAL(st) (((st) >= 128)? (st) - 128: -1)
#define SE_IS_ERROR(st) ((st) < 0 || (st) >= 126)
#define simple_execve rk_simple_execve #define simple_execve rk_simple_execve
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
simple_execve(const char*, char*const[], char*const[]); simple_execve(const char*, char*const[], char*const[]);
#define simple_execve_timed rk_simple_execve_timed #define simple_execve_timed rk_simple_execve_timed
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
simple_execve_timed(const char *, char *const[], simple_execve_timed(const char *, char *const[],
char *const [], time_t (*)(void *), char *const [], time_t (*)(void *),
void *, time_t); void *, time_t);
#define simple_execvp rk_simple_execvp #define simple_execvp rk_simple_execvp
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
simple_execvp(const char*, char *const[]); simple_execvp(const char*, char *const[]);
#define simple_execvp_timed rk_simple_execvp_timed #define simple_execvp_timed rk_simple_execvp_timed
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
simple_execvp_timed(const char *, char *const[], simple_execvp_timed(const char *, char *const[],
time_t (*)(void *), void *, time_t); time_t (*)(void *), void *, time_t);
#define simple_execlp rk_simple_execlp #define simple_execlp rk_simple_execlp
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
simple_execlp(const char*, ...); simple_execlp(const char*, ...);
#define simple_execle rk_simple_execle #define simple_execle rk_simple_execle
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
simple_execle(const char*, ...); simple_execle(const char*, ...);
#define wait_for_process rk_wait_for_process #define wait_for_process rk_wait_for_process
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
wait_for_process(pid_t); wait_for_process(pid_t);
#define wait_for_process_timed rk_wait_for_process_timed #define wait_for_process_timed rk_wait_for_process_timed
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
wait_for_process_timed(pid_t, time_t (*)(void *), wait_for_process_timed(pid_t, time_t (*)(void *),
void *, time_t); void *, time_t);
#define pipe_execv rk_pipe_execv #define pipe_execv rk_pipe_execv
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
pipe_execv(FILE**, FILE**, FILE**, const char*, ...); pipe_execv(FILE**, FILE**, FILE**, const char*, ...);
#define print_version rk_print_version #define print_version rk_print_version
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
print_version(const char *); print_version(const char *);
#define eread rk_eread #define eread rk_eread
ssize_t ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION ssize_t ROKEN_LIB_CALL
eread (int fd, void *buf, size_t nbytes); eread (int fd, void *buf, size_t nbytes);
#define ewrite rk_ewrite #define ewrite rk_ewrite
ssize_t ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION ssize_t ROKEN_LIB_CALL
ewrite (int fd, const void *buf, size_t nbytes); ewrite (int fd, const void *buf, size_t nbytes);
struct hostent; struct hostent;
#define hostent_find_fqdn rk_hostent_find_fqdn #define hostent_find_fqdn rk_hostent_find_fqdn
const char * ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION const char * ROKEN_LIB_CALL
hostent_find_fqdn (const struct hostent *); hostent_find_fqdn (const struct hostent *);
#define esetenv rk_esetenv #define esetenv rk_esetenv
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
esetenv(const char *, const char *, int); esetenv(const char *, const char *, int);
#define socket_set_address_and_port rk_socket_set_address_and_port #define socket_set_address_and_port rk_socket_set_address_and_port
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
socket_set_address_and_port (struct sockaddr *, const void *, int); socket_set_address_and_port (struct sockaddr *, const void *, int);
#define socket_addr_size rk_socket_addr_size #define socket_addr_size rk_socket_addr_size
size_t ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL
socket_addr_size (const struct sockaddr *); socket_addr_size (const struct sockaddr *);
#define socket_set_any rk_socket_set_any #define socket_set_any rk_socket_set_any
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
socket_set_any (struct sockaddr *, int); socket_set_any (struct sockaddr *, int);
#define socket_sockaddr_size rk_socket_sockaddr_size #define socket_sockaddr_size rk_socket_sockaddr_size
size_t ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL
socket_sockaddr_size (const struct sockaddr *); socket_sockaddr_size (const struct sockaddr *);
#define socket_get_address rk_socket_get_address #define socket_get_address rk_socket_get_address
void * ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void * ROKEN_LIB_CALL
socket_get_address (const struct sockaddr *); socket_get_address (const struct sockaddr *);
#define socket_get_port rk_socket_get_port #define socket_get_port rk_socket_get_port
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
socket_get_port (const struct sockaddr *); socket_get_port (const struct sockaddr *);
#define socket_set_port rk_socket_set_port #define socket_set_port rk_socket_set_port
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
socket_set_port (struct sockaddr *, int); socket_set_port (struct sockaddr *, int);
#define socket_set_portrange rk_socket_set_portrange #define socket_set_portrange rk_socket_set_portrange
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
socket_set_portrange (int, int, int); socket_set_portrange (rk_socket_t, int, int);
#define socket_set_debug rk_socket_set_debug #define socket_set_debug rk_socket_set_debug
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
socket_set_debug (int); socket_set_debug (rk_socket_t);
#define socket_set_tos rk_socket_set_tos #define socket_set_tos rk_socket_set_tos
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
socket_set_tos (int, int); socket_set_tos (rk_socket_t, int);
#define socket_set_reuseaddr rk_socket_set_reuseaddr #define socket_set_reuseaddr rk_socket_set_reuseaddr
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
socket_set_reuseaddr (int, int); socket_set_reuseaddr (rk_socket_t, int);
#define socket_set_ipv6only rk_socket_set_ipv6only #define socket_set_ipv6only rk_socket_set_ipv6only
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
socket_set_ipv6only (int, int); socket_set_ipv6only (rk_socket_t, int);
#define socket_to_fd rk_socket_to_fd
ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
socket_to_fd(rk_socket_t, int);
#define vstrcollect rk_vstrcollect #define vstrcollect rk_vstrcollect
char ** ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION char ** ROKEN_LIB_CALL
vstrcollect(va_list *ap); vstrcollect(va_list *ap);
#define strcollect rk_strcollect #define strcollect rk_strcollect
char ** ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION char ** ROKEN_LIB_CALL
strcollect(char *first, ...); strcollect(char *first, ...);
#define timevalfix rk_timevalfix #define timevalfix rk_timevalfix
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
timevalfix(struct timeval *t1); timevalfix(struct timeval *t1);
#define timevaladd rk_timevaladd #define timevaladd rk_timevaladd
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
timevaladd(struct timeval *t1, const struct timeval *t2); timevaladd(struct timeval *t1, const struct timeval *t2);
#define timevalsub rk_timevalsub #define timevalsub rk_timevalsub
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
timevalsub(struct timeval *t1, const struct timeval *t2); timevalsub(struct timeval *t1, const struct timeval *t2);
#define pid_file_write rk_pid_file_write #define pid_file_write rk_pid_file_write
char *ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL
pid_file_write (const char *progname); pid_file_write (const char *progname);
#define pid_file_delete rk_pid_file_delete #define pid_file_delete rk_pid_file_delete
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
pid_file_delete (char **); pid_file_delete (char **);
#define read_environment rk_read_environment #define read_environment rk_read_environment
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
read_environment(const char *file, char ***env); read_environment(const char *file, char ***env);
#define free_environment rk_free_environment #define free_environment rk_free_environment
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
free_environment(char **); free_environment(char **);
#define warnerr rk_warnerr #define warnerr rk_warnerr
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
rk_warnerr(int doerrno, const char *fmt, va_list ap) rk_warnerr(int doerrno, const char *fmt, va_list ap)
__attribute__ ((format (printf, 2, 0))); __attribute__ ((format (printf, 2, 0)));
void * ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void * ROKEN_LIB_CALL
rk_realloc(void *, size_t); rk_realloc(void *, size_t);
struct rk_strpool; struct rk_strpool;
char * ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL
rk_strpoolcollect(struct rk_strpool *); rk_strpoolcollect(struct rk_strpool *);
struct rk_strpool * ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION struct rk_strpool * ROKEN_LIB_CALL
rk_strpoolprintf(struct rk_strpool *, const char *, ...) rk_strpoolprintf(struct rk_strpool *, const char *, ...)
__attribute__ ((format (printf, 2, 3))); __attribute__ ((format (printf, 2, 3)));
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
rk_strpoolfree(struct rk_strpool *); rk_strpoolfree(struct rk_strpool *);
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
rk_dumpdata (const char *, const void *, size_t); rk_dumpdata (const char *, const void *, size_t);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rk_undumpdata (const char *, void **, size_t *); rk_undumpdata (const char *, void **, size_t *);
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
rk_xfree (void *); rk_xfree (void *);
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
rk_cloexec(int); rk_cloexec(int);
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
rk_cloexec_file(FILE *); rk_cloexec_file(FILE *);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
rk_cloexec_dir(DIR *);
ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
ct_memcmp(const void *, const void *, size_t); ct_memcmp(const void *, const void *, size_t);
ROKEN_CPP_END ROKEN_CPP_END
#endif /* __ROKEN_COMMON_H__ */ #endif /* __ROKEN_COMMON_H__ */
 End of changes. 53 change blocks. 
53 lines changed or deleted 88 lines changed or added


 roken.h   roken.h 
skipping to change at line 47 skipping to change at line 47
* SUCH DAMAGE. * SUCH DAMAGE.
*/ */
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
#include <signal.h> #include <signal.h>
typedef int rk_socket_t;
#define rk_closesocket(x) close(x)
#define rk_SOCK_IOCTL(s,c,a) ioctl((s),(c),(a))
#define rk_IS_BAD_SOCKET(s) ((s) < 0)
#define rk_IS_SOCKET_ERROR(rv) ((rv) < 0)
#define rk_SOCK_ERRNO errno
#define rk_INVALID_SOCKET (-1)
#define rk_SOCK_INIT() 0
#define rk_SOCK_EXIT() do { } while(0)
#define UNREACHABLE(x)
#define UNUSED_ARGUMENT(x)
#include <sys/param.h> #include <sys/param.h>
#include <inttypes.h> #include <inttypes.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/bitypes.h> #include <sys/bitypes.h>
#include <unistd.h> #include <unistd.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/uio.h> #include <sys/uio.h>
#include <grp.h> #include <grp.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <netinet/in.h> #include <netinet/in.h>
skipping to change at line 72 skipping to change at line 87
#include <fcntl.h> #include <fcntl.h>
#include <errno.h> #include <errno.h>
#include <err.h> #include <err.h>
#include <termios.h> #include <termios.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>
#include <sys/time.h> #include <sys/time.h>
#include <time.h> #include <time.h>
#include <paths.h> #include <paths.h>
#include <dirent.h>
#include <roken-common.h> #include <roken-common.h>
ROKEN_CPP_START ROKEN_CPP_START
#define rk_UNCONST(x) ((void *)(uintptr_t)(const void *)(x)) #define rk_UNCONST(x) ((void *)(uintptr_t)(const void *)(x))
#define asnprintf rk_asnprintf #define asnprintf rk_asnprintf
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rk_asnprintf (char **, size_t, const char *, ...) rk_asnprintf (char **, size_t, const char *, ...)
__attribute__ ((format (printf, 3, 4))); __attribute__ ((format (printf, 3, 4)));
#define vasnprintf rk_vasnprintf #define vasnprintf rk_vasnprintf
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
vasnprintf (char **, size_t, const char *, va_list) vasnprintf (char **, size_t, const char *, va_list)
__attribute__((format (printf, 3, 0))); __attribute__((format (printf, 3, 0)));
#define strlwr rk_strlwr #define strlwr rk_strlwr
char * ROKEN_LIB_FUNCTION strlwr(char *); ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL strlwr(char *);
#define strsep_copy rk_strsep_copy #define strsep_copy rk_strsep_copy
ssize_t ROKEN_LIB_FUNCTION strsep_copy(const char**, const char*, char*, si ze_t); ROKEN_LIB_FUNCTION ssize_t ROKEN_LIB_CALL strsep_copy(const char**, const c har*, char*, size_t);
#define strupr rk_strupr #define strupr rk_strupr
char * ROKEN_LIB_FUNCTION strupr(char *); ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL strupr(char *);
#define strlcpy rk_strlcpy #define strlcpy rk_strlcpy
size_t ROKEN_LIB_FUNCTION strlcpy (char *, const char *, size_t); ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL strlcpy (char *, const char *, siz e_t);
#define strlcat rk_strlcat #define strlcat rk_strlcat
size_t ROKEN_LIB_FUNCTION strlcat (char *, const char *, size_t); ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL strlcat (char *, const char *, siz e_t);
int ROKEN_LIB_FUNCTION rk_strerror_r(int, char *, size_t); int ROKEN_LIB_FUNCTION rk_strerror_r(int, char *, size_t);
#include <pwd.h> #include <pwd.h>
struct passwd * ROKEN_LIB_FUNCTION k_getpwnam (const char *); ROKEN_LIB_FUNCTION struct passwd * ROKEN_LIB_CALL k_getpwnam (const char *)
struct passwd * ROKEN_LIB_FUNCTION k_getpwuid (uid_t); ;
ROKEN_LIB_FUNCTION struct passwd * ROKEN_LIB_CALL k_getpwuid (uid_t);
const char * ROKEN_LIB_FUNCTION get_default_username (void); ROKEN_LIB_FUNCTION const char * ROKEN_LIB_CALL get_default_username (void);
int ROKEN_LIB_FUNCTION mkstemp(char *); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL mkstemp(char *);
#define cgetent rk_cgetent #define cgetent rk_cgetent
#define cgetstr rk_cgetstr #define cgetstr rk_cgetstr
int ROKEN_LIB_FUNCTION cgetent(char **, char **, const char *); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL cgetent(char **, char **, const char
int ROKEN_LIB_FUNCTION cgetstr(char *, const char *, char **); *);
ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL cgetstr(char *, const char *, char **
);
#define pidfile rk_pidfile #define pidfile rk_pidfile
void ROKEN_LIB_FUNCTION pidfile (const char*); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL pidfile (const char*);
#define bswap32 rk_bswap32 #define bswap32 rk_bswap32
unsigned int ROKEN_LIB_FUNCTION bswap32(unsigned int); ROKEN_LIB_FUNCTION unsigned int ROKEN_LIB_CALL bswap32(unsigned int);
#define bswap16 rk_bswap16 #define bswap16 rk_bswap16
unsigned short ROKEN_LIB_FUNCTION bswap16(unsigned short); ROKEN_LIB_FUNCTION unsigned short ROKEN_LIB_CALL bswap16(unsigned short);
time_t ROKEN_LIB_FUNCTION tm2time (struct tm, int); ROKEN_LIB_FUNCTION time_t ROKEN_LIB_CALL tm2time (struct tm, int);
int ROKEN_LIB_FUNCTION unix_verify_user(char *, char *); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL unix_verify_user(char *, char *);
int ROKEN_LIB_FUNCTION roken_concat (char *, size_t, ...); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL roken_concat (char *, size_t, ...);
size_t ROKEN_LIB_FUNCTION roken_mconcat (char **, size_t, ...); ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL roken_mconcat (char **, size_t, .. .);
int ROKEN_LIB_FUNCTION roken_vconcat (char *, size_t, va_list); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL roken_vconcat (char *, size_t, va_lis t);
size_t ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL
roken_vmconcat (char **, size_t, va_list); roken_vmconcat (char **, size_t, va_list);
ssize_t ROKEN_LIB_FUNCTION net_write (int, const void *, size_t); ROKEN_LIB_FUNCTION ssize_t ROKEN_LIB_CALL
net_write (rk_socket_t, const void *, size_t);
ssize_t ROKEN_LIB_FUNCTION net_read (int, void *, size_t); ROKEN_LIB_FUNCTION ssize_t ROKEN_LIB_CALL
net_read (rk_socket_t, void *, size_t);
int ROKEN_LIB_FUNCTION issuid(void); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
issuid(void);
int ROKEN_LIB_FUNCTION get_window_size(int fd, struct winsize *); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL get_window_size(int fd, struct winsiz e *);
#define getipnodebyname rk_getipnodebyname #define getipnodebyname rk_getipnodebyname
struct hostent * ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION struct hostent * ROKEN_LIB_CALL
getipnodebyname (const char *, int, int, int *); getipnodebyname (const char *, int, int, int *);
#define getipnodebyaddr rk_getipnodebyaddr #define getipnodebyaddr rk_getipnodebyaddr
struct hostent * ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION struct hostent * ROKEN_LIB_CALL
getipnodebyaddr (const void *, size_t, int, int *); getipnodebyaddr (const void *, size_t, int, int *);
#define freehostent rk_freehostent #define freehostent rk_freehostent
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
freehostent (struct hostent *); freehostent (struct hostent *);
#define copyhostent rk_copyhostent #define copyhostent rk_copyhostent
struct hostent * ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION struct hostent * ROKEN_LIB_CALL
copyhostent (const struct hostent *); copyhostent (const struct hostent *);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
getnameinfo_verified(const struct sockaddr *, socklen_t, getnameinfo_verified(const struct sockaddr *, socklen_t,
char *, size_t, char *, size_t,
char *, size_t, char *, size_t,
int); int);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
roken_getaddrinfo_hostspec(const char *, int, struct addrinfo **); roken_getaddrinfo_hostspec(const char *, int, struct addrinfo **);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
roken_getaddrinfo_hostspec2(const char *, int, int, struct addrinfo **); roken_getaddrinfo_hostspec2(const char *, int, int, struct addrinfo **);
#define emalloc rk_emalloc #define emalloc rk_emalloc
void * ROKEN_LIB_FUNCTION emalloc (size_t); ROKEN_LIB_FUNCTION void * ROKEN_LIB_CALL emalloc (size_t);
#define ecalloc rk_ecalloc #define ecalloc rk_ecalloc
void * ROKEN_LIB_FUNCTION ecalloc(size_t, size_t); ROKEN_LIB_FUNCTION void * ROKEN_LIB_CALL ecalloc(size_t, size_t);
#define erealloc rk_erealloc #define erealloc rk_erealloc
void * ROKEN_LIB_FUNCTION erealloc (void *, size_t); ROKEN_LIB_FUNCTION void * ROKEN_LIB_CALL erealloc (void *, size_t);
#define estrdup rk_estrdup #define estrdup rk_estrdup
char * ROKEN_LIB_FUNCTION estrdup (const char *); ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL estrdup (const char *);
/* /*
* kludges and such * kludges and such
*/ */
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
roken_gethostby_setup(const char*, const char*); roken_gethostby_setup(const char*, const char*);
struct hostent* ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION struct hostent* ROKEN_LIB_CALL
roken_gethostbyname(const char*); roken_gethostbyname(const char*);
struct hostent* ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION struct hostent* ROKEN_LIB_CALL
roken_gethostbyaddr(const void*, size_t, int); roken_gethostbyaddr(const void*, size_t, int);
#define roken_getservbyname(x,y) getservbyname(x,y) #define roken_getservbyname(x,y) getservbyname(x,y)
#define roken_openlog(a,b,c) openlog(a,b,c) #define roken_openlog(a,b,c) openlog(a,b,c)
#define roken_getsockname(a,b,c) getsockname(a,b,c) #define roken_getsockname(a,b,c) getsockname(a,b,c)
#define setprogname rk_setprogname #define setprogname rk_setprogname
void ROKEN_LIB_FUNCTION setprogname(const char *); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL setprogname(const char *);
#define getprogname rk_getprogname #define getprogname rk_getprogname
const char * ROKEN_LIB_FUNCTION getprogname(void); ROKEN_LIB_FUNCTION const char * ROKEN_LIB_CALL getprogname(void);
extern const char *__progname; extern const char *__progname;
void ROKEN_LIB_FUNCTION mini_inetd_addrinfo (struct addrinfo*); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
void ROKEN_LIB_FUNCTION mini_inetd (int); mini_inetd_addrinfo (struct addrinfo*, rk_socket_t *);
ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
mini_inetd (int, rk_socket_t *);
#define strsvis rk_strsvis #define strsvis rk_strsvis
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
strsvis(char *, const char *, int, const char *); strsvis(char *, const char *, int, const char *);
#define strsvisx rk_strsvisx #define strsvisx rk_strsvisx
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
strsvisx(char *, const char *, size_t, int, const char *); strsvisx(char *, const char *, size_t, int, const char *);
#define strunvis rk_strunvis #define strunvis rk_strunvis
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
strunvis(char *, const char *); strunvis(char *, const char *);
#define strvis rk_strvis #define strvis rk_strvis
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
strvis(char *, const char *, int); strvis(char *, const char *, int);
#define strvisx rk_strvisx #define strvisx rk_strvisx
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
strvisx(char *, const char *, size_t, int); strvisx(char *, const char *, size_t, int);
#define svis rk_svis #define svis rk_svis
char * ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL
svis(char *, int, int, int, const char *); svis(char *, int, int, int, const char *);
#define unvis rk_unvis #define unvis rk_unvis
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
unvis(char *, int, int *, int); unvis(char *, int, int *, int);
#define vis rk_vis #define vis rk_vis
char * ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL
vis(char *, int, int, int); vis(char *, int, int, int);
#define closefrom rk_closefrom #define closefrom rk_closefrom
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
closefrom(int); closefrom(int);
#undef socket #undef socket
#define socket(_fam,_type,_prot) rk_socket(_fam,_type,_prot) #define socket(_fam,_type,_prot) rk_socket(_fam,_type,_prot)
int ROKEN_LIB_FUNCTION rk_socket(int, int, int); int ROKEN_LIB_FUNCTION rk_socket(int, int, int);
ROKEN_CPP_END ROKEN_CPP_END
#endif /* __ROKEN_H__ */ #endif /* __ROKEN_H__ */
 End of changes. 52 change blocks. 
53 lines changed or deleted 79 lines changed or added


 rtbl.h   rtbl.h 
skipping to change at line 40 skipping to change at line 40
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE. * SUCH DAMAGE.
*/ */
/* $Id$ */ /* $Id$ */
#ifndef __rtbl_h__ #ifndef __rtbl_h__
#define __rtbl_h__ #define __rtbl_h__
#ifndef ROKEN_LIB_FUNCTION #ifndef ROKEN_LIB_FUNCTION
#ifdef _WIN32 #ifdef _WIN32
#define ROKEN_LIB_FUNCTION _stdcall #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL __cdecl
#else #else
#define ROKEN_LIB_FUNCTION #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL
#endif #endif
#endif #endif
#if !defined(__GNUC__) && !defined(__attribute__) #if !defined(__GNUC__) && !defined(__attribute__)
#define __attribute__(x) #define __attribute__(x)
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
struct rtbl_data; struct rtbl_data;
typedef struct rtbl_data *rtbl_t; typedef struct rtbl_data *rtbl_t;
#define RTBL_ALIGN_LEFT 0 #define RTBL_ALIGN_LEFT 0
#define RTBL_ALIGN_RIGHT 1 #define RTBL_ALIGN_RIGHT 1
/* flags */ /* flags */
#define RTBL_HEADER_STYLE_NONE 1 #define RTBL_HEADER_STYLE_NONE 1
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rtbl_add_column (rtbl_t, const char*, unsigned int); rtbl_add_column (rtbl_t, const char*, unsigned int);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rtbl_add_column_by_id (rtbl_t, unsigned int, const char*, unsigned int); rtbl_add_column_by_id (rtbl_t, unsigned int, const char*, unsigned int);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rtbl_add_column_entryv_by_id (rtbl_t table, unsigned int id, rtbl_add_column_entryv_by_id (rtbl_t table, unsigned int id,
const char *fmt, ...) const char *fmt, ...)
__attribute__ ((format (printf, 3, 0))); __attribute__ ((format (printf, 3, 0)));
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rtbl_add_column_entry (rtbl_t, const char*, const char*); rtbl_add_column_entry (rtbl_t, const char*, const char*);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rtbl_add_column_entryv (rtbl_t, const char*, const char*, ...) rtbl_add_column_entryv (rtbl_t, const char*, const char*, ...)
__attribute__ ((format (printf, 3, 0))); __attribute__ ((format (printf, 3, 0)));
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rtbl_add_column_entry_by_id (rtbl_t, unsigned int, const char*); rtbl_add_column_entry_by_id (rtbl_t, unsigned int, const char*);
rtbl_t ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION rtbl_t ROKEN_LIB_CALL
rtbl_create (void); rtbl_create (void);
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
rtbl_destroy (rtbl_t); rtbl_destroy (rtbl_t);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rtbl_format (rtbl_t, FILE*); rtbl_format (rtbl_t, FILE*);
unsigned int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION unsigned int ROKEN_LIB_CALL
rtbl_get_flags (rtbl_t); rtbl_get_flags (rtbl_t);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rtbl_new_row (rtbl_t); rtbl_new_row (rtbl_t);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rtbl_set_column_affix_by_id (rtbl_t, unsigned int, const char*, const char* ); rtbl_set_column_affix_by_id (rtbl_t, unsigned int, const char*, const char* );
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rtbl_set_column_prefix (rtbl_t, const char*, const char*); rtbl_set_column_prefix (rtbl_t, const char*, const char*);
void ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
rtbl_set_flags (rtbl_t, unsigned int); rtbl_set_flags (rtbl_t, unsigned int);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rtbl_set_prefix (rtbl_t, const char*); rtbl_set_prefix (rtbl_t, const char*);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rtbl_set_separator (rtbl_t, const char*); rtbl_set_separator (rtbl_t, const char*);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* __rtbl_h__ */ #endif /* __rtbl_h__ */
 End of changes. 18 change blocks. 
17 lines changed or deleted 19 lines changed or added


 vis.h   vis.h 
skipping to change at line 39 skipping to change at line 39
* SUCH DAMAGE. * SUCH DAMAGE.
* *
* @(#)vis.h 8.1 (Berkeley) 6/2/93 * @(#)vis.h 8.1 (Berkeley) 6/2/93
*/ */
#ifndef _VIS_H_ #ifndef _VIS_H_
#define _VIS_H_ #define _VIS_H_
#ifndef ROKEN_LIB_FUNCTION #ifndef ROKEN_LIB_FUNCTION
#ifdef _WIN32 #ifdef _WIN32
#define ROKEN_LIB_FUNCTION _stdcall #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL __cdecl
#else #else
#define ROKEN_LIB_FUNCTION #define ROKEN_LIB_FUNCTION
#define ROKEN_LIB_CALL
#endif #endif
#endif #endif
#include <sys/types.h> #include <sys/types.h>
#include <roken.h> #include <roken.h>
/* /*
* to select alternate encoding format * to select alternate encoding format
*/ */
skipping to change at line 87 skipping to change at line 89
#define UNVIS_SYNBAD -1 /* unrecognized escape sequence */ #define UNVIS_SYNBAD -1 /* unrecognized escape sequence */
#define UNVIS_ERROR -2 /* decoder in unknown state (unrecov erable) */ #define UNVIS_ERROR -2 /* decoder in unknown state (unrecov erable) */
/* /*
* unvis flags * unvis flags
*/ */
#define UNVIS_END 1 /* no more characters */ #define UNVIS_END 1 /* no more characters */
ROKEN_CPP_START ROKEN_CPP_START
char * ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL
rk_vis(char *, int, int, int); rk_vis(char *, int, int, int);
char * ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL
rk_svis(char *, int, int, int, const char *); rk_svis(char *, int, int, int, const char *);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rk_strvis(char *, const char *, int); rk_strvis(char *, const char *, int);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rk_strsvis(char *, const char *, int, const char *); rk_strsvis(char *, const char *, int, const char *);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rk_strvisx(char *, const char *, size_t, int); rk_strvisx(char *, const char *, size_t, int);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rk_strsvisx(char *, const char *, size_t, int, const char *); rk_strsvisx(char *, const char *, size_t, int, const char *);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rk_strunvis(char *, const char *); rk_strunvis(char *, const char *);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rk_strunvisx(char *, const char *, int); rk_strunvisx(char *, const char *, int);
int ROKEN_LIB_FUNCTION ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rk_unvis(char *, int, int *, int); rk_unvis(char *, int, int *, int);
ROKEN_CPP_END ROKEN_CPP_END
#ifndef HAVE_VIS #ifndef HAVE_VIS
#undef vis #undef vis
#define vis(a,b,c,d) rk_vis(a,b,c,d) #define vis(a,b,c,d) rk_vis(a,b,c,d)
#endif #endif
#ifndef HAVE_SVIS #ifndef HAVE_SVIS
#undef svis #undef svis
#define svis(a,b,c,d,e) rk_svis(a,b,c,d,e) #define svis(a,b,c,d,e) rk_svis(a,b,c,d,e)
 End of changes. 12 change blocks. 
10 lines changed or deleted 13 lines changed or added


 wind.h   wind.h 
skipping to change at line 49 skipping to change at line 49
#include <stddef.h> #include <stddef.h>
#include <krb5-types.h> #include <krb5-types.h>
#include <wind_err.h> #include <wind_err.h>
typedef unsigned int wind_profile_flags; typedef unsigned int wind_profile_flags;
#define WIND_PROFILE_NAME 0x00000001 #define WIND_PROFILE_NAME 0x00000001
#define WIND_PROFILE_SASL 0x00000002 #define WIND_PROFILE_SASL 0x00000002
#define WIND_PROFILE_LDAP 0x00000004 #define WIND_PROFILE_LDAP 0x00000004
#define WIND_PROFILE_LDAP_CASE 0x00000008
#define WIND_PROFILE_LDAP_CASE_EXACT_ATTRIBUTE 0x00010000 #define WIND_PROFILE_LDAP_CASE_EXACT_ATTRIBUTE 0x00010000
#define WIND_PROFILE_LDAP_CASE_EXACT_ASSERTION 0x00020000 #define WIND_PROFILE_LDAP_CASE_EXACT_ASSERTION 0x00020000
#define WIND_PROFILE_LDAP_NUMERIC 0x00040000 #define WIND_PROFILE_LDAP_NUMERIC 0x00040000
#define WIND_PROFILE_LDAP_TELEPHONE 0x00080000 #define WIND_PROFILE_LDAP_TELEPHONE 0x00080000
/* flags to wind_ucs2read/wind_ucs2write */ /* flags to wind_ucs2read/wind_ucs2write */
#define WIND_RW_LE 1 #define WIND_RW_LE 1
#define WIND_RW_BE 2 #define WIND_RW_BE 2
#define WIND_RW_BOM 4 #define WIND_RW_BOM 4
 End of changes. 1 change blocks. 
0 lines changed or deleted 1 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/