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