From ba7fb8308a83cf68403a469eec8876337ca1a5d6 Mon Sep 17 00:00:00 2001 From: Blake Ramsdell Date: Sat, 29 Sep 2007 15:42:29 -0700 Subject: [PATCH] Regenerated to latest code. We need the -inline=static option for gcc. --- printcert/rfc3280.h | 1351 ++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 1345 insertions(+), 6 deletions(-) diff --git a/printcert/rfc3280.h b/printcert/rfc3280.h index 6a4d403..d455324 100644 --- a/printcert/rfc3280.h +++ b/printcert/rfc3280.h @@ -48,6 +48,19 @@ extern const A2C_INTEGER_NATIVE Cert_ub_match; typedef A2C_PRINTABLE_STRING Cert_x520countryName__Type; extern const A2C_DESCRIPTOR Cert_x520countryName__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_x520countryName__Type(Cert_x520countryName__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_x520countryName__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_x520countryName__Type(Cert_x520countryName__Type * p) { return A2C_Free((PVOID) p, &Cert_x520countryName__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_x520countryName__Type(Cert_x520countryName__Type * p) { return A2C_Init((PVOID) p, &Cert_x520countryName__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_x520countryName__Type(Cert_x520countryName__Type * p) { return A2C_Release((PVOID) p, &Cert_x520countryName__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_x520countryName__Type(Cert_x520countryName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_x520countryName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_x520countryName__Type(Cert_x520countryName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_x520countryName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_x520countryName__Type(Cert_x520countryName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_x520countryName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_x520countryName__Type(Cert_x520countryName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_x520countryName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_x520countryName__Type(Cert_x520countryName__Type * pDst, Cert_x520countryName__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_x520countryName__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_x520countryName__Type(Cert_x520countryName__Type const * pLeft, Cert_x520countryName__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_x520countryName__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_x520countryName__Type(Cert_x520countryName__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_x520countryName__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_x520countryName__Type(Cert_x520countryName__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_x520countryName__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_x520countryName__Type(Cert_x520countryName__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_x520countryName__Type_descriptor, ppcxt, pf, pstm); } extern const A2C_INTEGER_NATIVE Cert_ub_common_name; extern const A2C_INTEGER_NATIVE Cert_ub_numeric_user_id_length; @@ -57,6 +70,19 @@ typedef struct { } Cert_AttributeTypeAndValue; extern const A2C_DESCRIPTOR Cert_AttributeTypeAndValue_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_AttributeTypeAndValue(Cert_AttributeTypeAndValue ** p) { return A2C_Alloc((PVOID *) p, &Cert_AttributeTypeAndValue_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_AttributeTypeAndValue(Cert_AttributeTypeAndValue * p) { return A2C_Free((PVOID) p, &Cert_AttributeTypeAndValue_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_AttributeTypeAndValue(Cert_AttributeTypeAndValue * p) { return A2C_Init((PVOID) p, &Cert_AttributeTypeAndValue_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_AttributeTypeAndValue(Cert_AttributeTypeAndValue * p) { return A2C_Release((PVOID) p, &Cert_AttributeTypeAndValue_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_AttributeTypeAndValue(Cert_AttributeTypeAndValue const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_AttributeTypeAndValue_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_AttributeTypeAndValue(Cert_AttributeTypeAndValue * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_AttributeTypeAndValue_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_AttributeTypeAndValue(Cert_AttributeTypeAndValue const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_AttributeTypeAndValue_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_AttributeTypeAndValue(Cert_AttributeTypeAndValue * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_AttributeTypeAndValue_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_AttributeTypeAndValue(Cert_AttributeTypeAndValue * pDst, Cert_AttributeTypeAndValue * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_AttributeTypeAndValue_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_AttributeTypeAndValue(Cert_AttributeTypeAndValue const * pLeft, Cert_AttributeTypeAndValue const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_AttributeTypeAndValue_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_AttributeTypeAndValue(Cert_AttributeTypeAndValue * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_AttributeTypeAndValue_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_AttributeTypeAndValue(Cert_AttributeTypeAndValue * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_AttributeTypeAndValue_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_AttributeTypeAndValue(Cert_AttributeTypeAndValue * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_AttributeTypeAndValue_descriptor, ppcxt, pf, pstm); } typedef struct { int count; @@ -65,6 +91,19 @@ typedef struct { } Cert_RelativeDistinguishedName; extern const A2C_DESCRIPTOR Cert_RelativeDistinguishedName_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_RelativeDistinguishedName(Cert_RelativeDistinguishedName ** p) { return A2C_Alloc((PVOID *) p, &Cert_RelativeDistinguishedName_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_RelativeDistinguishedName(Cert_RelativeDistinguishedName * p) { return A2C_Free((PVOID) p, &Cert_RelativeDistinguishedName_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_RelativeDistinguishedName(Cert_RelativeDistinguishedName * p) { return A2C_Init((PVOID) p, &Cert_RelativeDistinguishedName_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_RelativeDistinguishedName(Cert_RelativeDistinguishedName * p) { return A2C_Release((PVOID) p, &Cert_RelativeDistinguishedName_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_RelativeDistinguishedName(Cert_RelativeDistinguishedName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_RelativeDistinguishedName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_RelativeDistinguishedName(Cert_RelativeDistinguishedName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_RelativeDistinguishedName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_RelativeDistinguishedName(Cert_RelativeDistinguishedName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_RelativeDistinguishedName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_RelativeDistinguishedName(Cert_RelativeDistinguishedName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_RelativeDistinguishedName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_RelativeDistinguishedName(Cert_RelativeDistinguishedName * pDst, Cert_RelativeDistinguishedName * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_RelativeDistinguishedName_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_RelativeDistinguishedName(Cert_RelativeDistinguishedName const * pLeft, Cert_RelativeDistinguishedName const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_RelativeDistinguishedName_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_RelativeDistinguishedName(Cert_RelativeDistinguishedName * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_RelativeDistinguishedName_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_RelativeDistinguishedName(Cert_RelativeDistinguishedName * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_RelativeDistinguishedName_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_RelativeDistinguishedName(Cert_RelativeDistinguishedName * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_RelativeDistinguishedName_descriptor, ppcxt, pf, pstm); } typedef struct { int count; @@ -73,6 +112,19 @@ typedef struct { } Cert_RDNSequence; extern const A2C_DESCRIPTOR Cert_RDNSequence_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_RDNSequence(Cert_RDNSequence ** p) { return A2C_Alloc((PVOID *) p, &Cert_RDNSequence_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_RDNSequence(Cert_RDNSequence * p) { return A2C_Free((PVOID) p, &Cert_RDNSequence_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_RDNSequence(Cert_RDNSequence * p) { return A2C_Init((PVOID) p, &Cert_RDNSequence_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_RDNSequence(Cert_RDNSequence * p) { return A2C_Release((PVOID) p, &Cert_RDNSequence_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_RDNSequence(Cert_RDNSequence const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_RDNSequence_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_RDNSequence(Cert_RDNSequence * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_RDNSequence_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_RDNSequence(Cert_RDNSequence const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_RDNSequence_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_RDNSequence(Cert_RDNSequence * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_RDNSequence_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_RDNSequence(Cert_RDNSequence * pDst, Cert_RDNSequence * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_RDNSequence_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_RDNSequence(Cert_RDNSequence const * pLeft, Cert_RDNSequence const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_RDNSequence_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_RDNSequence(Cert_RDNSequence * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_RDNSequence_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_RDNSequence(Cert_RDNSequence * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_RDNSequence_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_RDNSequence(Cert_RDNSequence * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_RDNSequence_descriptor, ppcxt, pf, pstm); } typedef struct { int index; @@ -83,6 +135,19 @@ typedef struct { } Cert_Name; extern const A2C_DESCRIPTOR Cert_Name_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_Name(Cert_Name ** p) { return A2C_Alloc((PVOID *) p, &Cert_Name_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_Name(Cert_Name * p) { return A2C_Free((PVOID) p, &Cert_Name_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_Name(Cert_Name * p) { return A2C_Init((PVOID) p, &Cert_Name_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_Name(Cert_Name * p) { return A2C_Release((PVOID) p, &Cert_Name_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_Name(Cert_Name const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_Name_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_Name(Cert_Name * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_Name_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_Name(Cert_Name const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_Name_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_Name(Cert_Name * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_Name_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_Name(Cert_Name * pDst, Cert_Name * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_Name_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_Name(Cert_Name const * pLeft, Cert_Name const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_Name_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_Name(Cert_Name * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_Name_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_Name(Cert_Name * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_Name_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_Name(Cert_Name * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_Name_descriptor, ppcxt, pf, pstm); } typedef struct { const A2C_OBJECT_IDENTIFIER * id; @@ -107,11 +172,37 @@ typedef struct { } Cert_PDSParameter; extern const A2C_DESCRIPTOR Cert_PDSParameter_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_PDSParameter(Cert_PDSParameter ** p) { return A2C_Alloc((PVOID *) p, &Cert_PDSParameter_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_PDSParameter(Cert_PDSParameter * p) { return A2C_Free((PVOID) p, &Cert_PDSParameter_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_PDSParameter(Cert_PDSParameter * p) { return A2C_Init((PVOID) p, &Cert_PDSParameter_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_PDSParameter(Cert_PDSParameter * p) { return A2C_Release((PVOID) p, &Cert_PDSParameter_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_PDSParameter(Cert_PDSParameter const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_PDSParameter_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_PDSParameter(Cert_PDSParameter * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_PDSParameter_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_PDSParameter(Cert_PDSParameter const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_PDSParameter_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_PDSParameter(Cert_PDSParameter * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_PDSParameter_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_PDSParameter(Cert_PDSParameter * pDst, Cert_PDSParameter * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_PDSParameter_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_PDSParameter(Cert_PDSParameter const * pLeft, Cert_PDSParameter const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_PDSParameter_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_PDSParameter(Cert_PDSParameter * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_PDSParameter_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_PDSParameter(Cert_PDSParameter * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_PDSParameter_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_PDSParameter(Cert_PDSParameter * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_PDSParameter_descriptor, ppcxt, pf, pstm); } extern const Cert_EXTENSION_ATTRIBUTE Cert_physicalDeliveryOrganizationName; typedef A2C_PRINTABLE_STRING Cert_ea_commonName__Type; extern const A2C_DESCRIPTOR Cert_ea_commonName__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_ea_commonName__Type(Cert_ea_commonName__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_ea_commonName__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_ea_commonName__Type(Cert_ea_commonName__Type * p) { return A2C_Free((PVOID) p, &Cert_ea_commonName__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_ea_commonName__Type(Cert_ea_commonName__Type * p) { return A2C_Init((PVOID) p, &Cert_ea_commonName__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_ea_commonName__Type(Cert_ea_commonName__Type * p) { return A2C_Release((PVOID) p, &Cert_ea_commonName__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_ea_commonName__Type(Cert_ea_commonName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_ea_commonName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_ea_commonName__Type(Cert_ea_commonName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_ea_commonName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_ea_commonName__Type(Cert_ea_commonName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_ea_commonName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_ea_commonName__Type(Cert_ea_commonName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_ea_commonName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_ea_commonName__Type(Cert_ea_commonName__Type * pDst, Cert_ea_commonName__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_ea_commonName__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_ea_commonName__Type(Cert_ea_commonName__Type const * pLeft, Cert_ea_commonName__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_ea_commonName__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_ea_commonName__Type(Cert_ea_commonName__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_ea_commonName__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_ea_commonName__Type(Cert_ea_commonName__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_ea_commonName__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_ea_commonName__Type(Cert_ea_commonName__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_ea_commonName__Type_descriptor, ppcxt, pf, pstm); } extern const Cert_EXTENSION_ATTRIBUTE Cert_ea_commonName; extern const Cert_EXTENSION_ATTRIBUTE Cert_extensionPhysicalDeliveryAddressComponents; extern const Cert_EXTENSION_ATTRIBUTE Cert_extensionORAddressComponents; @@ -125,11 +216,37 @@ typedef struct { } Cert_AlgorithmIdentifier; extern const A2C_DESCRIPTOR Cert_AlgorithmIdentifier_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_AlgorithmIdentifier(Cert_AlgorithmIdentifier ** p) { return A2C_Alloc((PVOID *) p, &Cert_AlgorithmIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_AlgorithmIdentifier(Cert_AlgorithmIdentifier * p) { return A2C_Free((PVOID) p, &Cert_AlgorithmIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_AlgorithmIdentifier(Cert_AlgorithmIdentifier * p) { return A2C_Init((PVOID) p, &Cert_AlgorithmIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_AlgorithmIdentifier(Cert_AlgorithmIdentifier * p) { return A2C_Release((PVOID) p, &Cert_AlgorithmIdentifier_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_AlgorithmIdentifier(Cert_AlgorithmIdentifier const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_AlgorithmIdentifier_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_AlgorithmIdentifier(Cert_AlgorithmIdentifier * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_AlgorithmIdentifier_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_AlgorithmIdentifier(Cert_AlgorithmIdentifier const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_AlgorithmIdentifier_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_AlgorithmIdentifier(Cert_AlgorithmIdentifier * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_AlgorithmIdentifier_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_AlgorithmIdentifier(Cert_AlgorithmIdentifier * pDst, Cert_AlgorithmIdentifier * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_AlgorithmIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_AlgorithmIdentifier(Cert_AlgorithmIdentifier const * pLeft, Cert_AlgorithmIdentifier const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_AlgorithmIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_AlgorithmIdentifier(Cert_AlgorithmIdentifier * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_AlgorithmIdentifier_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_AlgorithmIdentifier(Cert_AlgorithmIdentifier * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_AlgorithmIdentifier_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_AlgorithmIdentifier(Cert_AlgorithmIdentifier * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_AlgorithmIdentifier_descriptor, ppcxt, pf, pstm); } extern const A2C_INTEGER_NATIVE Cert_ub_given_name_length; typedef A2C_OBJECT_IDENTIFIER Cert_AttributeType; extern const A2C_DESCRIPTOR Cert_AttributeType_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_AttributeType(Cert_AttributeType ** p) { return A2C_Alloc((PVOID *) p, &Cert_AttributeType_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_AttributeType(Cert_AttributeType * p) { return A2C_Free((PVOID) p, &Cert_AttributeType_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_AttributeType(Cert_AttributeType * p) { return A2C_Init((PVOID) p, &Cert_AttributeType_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_AttributeType(Cert_AttributeType * p) { return A2C_Release((PVOID) p, &Cert_AttributeType_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_AttributeType(Cert_AttributeType const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_AttributeType_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_AttributeType(Cert_AttributeType * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_AttributeType_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_AttributeType(Cert_AttributeType const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_AttributeType_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_AttributeType(Cert_AttributeType * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_AttributeType_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_AttributeType(Cert_AttributeType * pDst, Cert_AttributeType * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_AttributeType_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_AttributeType(Cert_AttributeType const * pLeft, Cert_AttributeType const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_AttributeType_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_AttributeType(Cert_AttributeType * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_AttributeType_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_AttributeType(Cert_AttributeType * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_AttributeType_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_AttributeType(Cert_AttributeType * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_AttributeType_descriptor, ppcxt, pf, pstm); } extern const Cert_AttributeType Cert_id_at_localityName; extern const A2C_INTEGER_NATIVE Cert_teletexCommonName__id; extern const A2C_OBJECT_IDENTIFIER Cert_id_ad; @@ -139,6 +256,19 @@ extern const Cert_AttributeType Cert_id_at_generationQualifier; typedef A2C_INTEGER_HUGE Cert_CertificateSerialNumber; extern const A2C_DESCRIPTOR Cert_CertificateSerialNumber_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_CertificateSerialNumber(Cert_CertificateSerialNumber ** p) { return A2C_Alloc((PVOID *) p, &Cert_CertificateSerialNumber_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_CertificateSerialNumber(Cert_CertificateSerialNumber * p) { return A2C_Free((PVOID) p, &Cert_CertificateSerialNumber_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_CertificateSerialNumber(Cert_CertificateSerialNumber * p) { return A2C_Init((PVOID) p, &Cert_CertificateSerialNumber_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_CertificateSerialNumber(Cert_CertificateSerialNumber * p) { return A2C_Release((PVOID) p, &Cert_CertificateSerialNumber_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_CertificateSerialNumber(Cert_CertificateSerialNumber const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_CertificateSerialNumber_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_CertificateSerialNumber(Cert_CertificateSerialNumber * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_CertificateSerialNumber_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_CertificateSerialNumber(Cert_CertificateSerialNumber const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_CertificateSerialNumber_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_CertificateSerialNumber(Cert_CertificateSerialNumber * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_CertificateSerialNumber_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_CertificateSerialNumber(Cert_CertificateSerialNumber * pDst, Cert_CertificateSerialNumber * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_CertificateSerialNumber_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_CertificateSerialNumber(Cert_CertificateSerialNumber const * pLeft, Cert_CertificateSerialNumber const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_CertificateSerialNumber_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_CertificateSerialNumber(Cert_CertificateSerialNumber * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_CertificateSerialNumber_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_CertificateSerialNumber(Cert_CertificateSerialNumber * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_CertificateSerialNumber_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_CertificateSerialNumber(Cert_CertificateSerialNumber * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_CertificateSerialNumber_descriptor, ppcxt, pf, pstm); } typedef struct { int index; @@ -151,6 +281,19 @@ typedef struct { } Cert_Time; extern const A2C_DESCRIPTOR Cert_Time_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_Time(Cert_Time ** p) { return A2C_Alloc((PVOID *) p, &Cert_Time_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_Time(Cert_Time * p) { return A2C_Free((PVOID) p, &Cert_Time_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_Time(Cert_Time * p) { return A2C_Init((PVOID) p, &Cert_Time_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_Time(Cert_Time * p) { return A2C_Release((PVOID) p, &Cert_Time_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_Time(Cert_Time const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_Time_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_Time(Cert_Time * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_Time_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_Time(Cert_Time const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_Time_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_Time(Cert_Time * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_Time_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_Time(Cert_Time * pDst, Cert_Time * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_Time_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_Time(Cert_Time const * pLeft, Cert_Time const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_Time_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_Time(Cert_Time * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_Time_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_Time(Cert_Time * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_Time_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_Time(Cert_Time * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_Time_descriptor, ppcxt, pf, pstm); } typedef struct { A2C_OBJECT_IDENTIFIER extnID; @@ -159,6 +302,19 @@ typedef struct { } Cert_Extension; extern const A2C_DESCRIPTOR Cert_Extension_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_Extension(Cert_Extension ** p) { return A2C_Alloc((PVOID *) p, &Cert_Extension_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_Extension(Cert_Extension * p) { return A2C_Free((PVOID) p, &Cert_Extension_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_Extension(Cert_Extension * p) { return A2C_Init((PVOID) p, &Cert_Extension_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_Extension(Cert_Extension * p) { return A2C_Release((PVOID) p, &Cert_Extension_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_Extension(Cert_Extension const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_Extension_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_Extension(Cert_Extension * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_Extension_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_Extension(Cert_Extension const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_Extension_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_Extension(Cert_Extension * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_Extension_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_Extension(Cert_Extension * pDst, Cert_Extension * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_Extension_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_Extension(Cert_Extension const * pLeft, Cert_Extension const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_Extension_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_Extension(Cert_Extension * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_Extension_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_Extension(Cert_Extension * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_Extension_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_Extension(Cert_Extension * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_Extension_descriptor, ppcxt, pf, pstm); } typedef struct { int count; @@ -167,20 +323,46 @@ typedef struct { } Cert_Extensions; extern const A2C_DESCRIPTOR Cert_Extensions_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_Extensions(Cert_Extensions ** p) { return A2C_Alloc((PVOID *) p, &Cert_Extensions_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_Extensions(Cert_Extensions * p) { return A2C_Free((PVOID) p, &Cert_Extensions_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_Extensions(Cert_Extensions * p) { return A2C_Init((PVOID) p, &Cert_Extensions_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_Extensions(Cert_Extensions * p) { return A2C_Release((PVOID) p, &Cert_Extensions_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_Extensions(Cert_Extensions const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_Extensions_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_Extensions(Cert_Extensions * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_Extensions_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_Extensions(Cert_Extensions const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_Extensions_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_Extensions(Cert_Extensions * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_Extensions_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_Extensions(Cert_Extensions * pDst, Cert_Extensions * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_Extensions_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_Extensions(Cert_Extensions const * pLeft, Cert_Extensions const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_Extensions_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_Extensions(Cert_Extensions * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_Extensions_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_Extensions(Cert_Extensions * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_Extensions_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_Extensions(Cert_Extensions * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_Extensions_descriptor, ppcxt, pf, pstm); } typedef struct { unsigned int optionalFields; #define Cert_TBSCertList__revokedCertificates_array_crlEntryExtensions_present 1 Cert_CertificateSerialNumber userCertificate; Cert_Time revocationDate; - + /* Start Extension */ /* Extension Group version: 2 */ Cert_Extensions crlEntryExtensions; - + A2C_EXTENSION _extension; } Cert_TBSCertList__revokedCertificates_array; extern const A2C_DESCRIPTOR Cert_TBSCertList__revokedCertificates_array_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_TBSCertList__revokedCertificates_array(Cert_TBSCertList__revokedCertificates_array ** p) { return A2C_Alloc((PVOID *) p, &Cert_TBSCertList__revokedCertificates_array_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_TBSCertList__revokedCertificates_array(Cert_TBSCertList__revokedCertificates_array * p) { return A2C_Free((PVOID) p, &Cert_TBSCertList__revokedCertificates_array_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_TBSCertList__revokedCertificates_array(Cert_TBSCertList__revokedCertificates_array * p) { return A2C_Init((PVOID) p, &Cert_TBSCertList__revokedCertificates_array_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_TBSCertList__revokedCertificates_array(Cert_TBSCertList__revokedCertificates_array * p) { return A2C_Release((PVOID) p, &Cert_TBSCertList__revokedCertificates_array_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_TBSCertList__revokedCertificates_array(Cert_TBSCertList__revokedCertificates_array const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_TBSCertList__revokedCertificates_array_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_TBSCertList__revokedCertificates_array(Cert_TBSCertList__revokedCertificates_array * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_TBSCertList__revokedCertificates_array_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_TBSCertList__revokedCertificates_array(Cert_TBSCertList__revokedCertificates_array const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_TBSCertList__revokedCertificates_array_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_TBSCertList__revokedCertificates_array(Cert_TBSCertList__revokedCertificates_array * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_TBSCertList__revokedCertificates_array_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_TBSCertList__revokedCertificates_array(Cert_TBSCertList__revokedCertificates_array * pDst, Cert_TBSCertList__revokedCertificates_array * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_TBSCertList__revokedCertificates_array_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_TBSCertList__revokedCertificates_array(Cert_TBSCertList__revokedCertificates_array const * pLeft, Cert_TBSCertList__revokedCertificates_array const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_TBSCertList__revokedCertificates_array_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_TBSCertList__revokedCertificates_array(Cert_TBSCertList__revokedCertificates_array * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_TBSCertList__revokedCertificates_array_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_TBSCertList__revokedCertificates_array(Cert_TBSCertList__revokedCertificates_array * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_TBSCertList__revokedCertificates_array_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_TBSCertList__revokedCertificates_array(Cert_TBSCertList__revokedCertificates_array * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_TBSCertList__revokedCertificates_array_descriptor, ppcxt, pf, pstm); } typedef struct { unsigned int optionalFields; @@ -195,12 +377,38 @@ typedef struct { } Cert_unformattedPostalAddress__Type; extern const A2C_DESCRIPTOR Cert_unformattedPostalAddress__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_unformattedPostalAddress__Type(Cert_unformattedPostalAddress__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_unformattedPostalAddress__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_unformattedPostalAddress__Type(Cert_unformattedPostalAddress__Type * p) { return A2C_Free((PVOID) p, &Cert_unformattedPostalAddress__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_unformattedPostalAddress__Type(Cert_unformattedPostalAddress__Type * p) { return A2C_Init((PVOID) p, &Cert_unformattedPostalAddress__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_unformattedPostalAddress__Type(Cert_unformattedPostalAddress__Type * p) { return A2C_Release((PVOID) p, &Cert_unformattedPostalAddress__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_unformattedPostalAddress__Type(Cert_unformattedPostalAddress__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_unformattedPostalAddress__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_unformattedPostalAddress__Type(Cert_unformattedPostalAddress__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_unformattedPostalAddress__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_unformattedPostalAddress__Type(Cert_unformattedPostalAddress__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_unformattedPostalAddress__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_unformattedPostalAddress__Type(Cert_unformattedPostalAddress__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_unformattedPostalAddress__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_unformattedPostalAddress__Type(Cert_unformattedPostalAddress__Type * pDst, Cert_unformattedPostalAddress__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_unformattedPostalAddress__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_unformattedPostalAddress__Type(Cert_unformattedPostalAddress__Type const * pLeft, Cert_unformattedPostalAddress__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_unformattedPostalAddress__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_unformattedPostalAddress__Type(Cert_unformattedPostalAddress__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_unformattedPostalAddress__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_unformattedPostalAddress__Type(Cert_unformattedPostalAddress__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_unformattedPostalAddress__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_unformattedPostalAddress__Type(Cert_unformattedPostalAddress__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_unformattedPostalAddress__Type_descriptor, ppcxt, pf, pstm); } extern const Cert_EXTENSION_ATTRIBUTE Cert_unformattedPostalAddress; extern const A2C_INTEGER_NATIVE Cert_ub_state_name; typedef A2C_TELETEX_STRING Cert_TeletexOrganizationalUnitName; extern const A2C_DESCRIPTOR Cert_TeletexOrganizationalUnitName_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_TeletexOrganizationalUnitName(Cert_TeletexOrganizationalUnitName ** p) { return A2C_Alloc((PVOID *) p, &Cert_TeletexOrganizationalUnitName_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_TeletexOrganizationalUnitName(Cert_TeletexOrganizationalUnitName * p) { return A2C_Free((PVOID) p, &Cert_TeletexOrganizationalUnitName_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_TeletexOrganizationalUnitName(Cert_TeletexOrganizationalUnitName * p) { return A2C_Init((PVOID) p, &Cert_TeletexOrganizationalUnitName_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_TeletexOrganizationalUnitName(Cert_TeletexOrganizationalUnitName * p) { return A2C_Release((PVOID) p, &Cert_TeletexOrganizationalUnitName_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_TeletexOrganizationalUnitName(Cert_TeletexOrganizationalUnitName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_TeletexOrganizationalUnitName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_TeletexOrganizationalUnitName(Cert_TeletexOrganizationalUnitName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_TeletexOrganizationalUnitName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_TeletexOrganizationalUnitName(Cert_TeletexOrganizationalUnitName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_TeletexOrganizationalUnitName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_TeletexOrganizationalUnitName(Cert_TeletexOrganizationalUnitName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_TeletexOrganizationalUnitName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_TeletexOrganizationalUnitName(Cert_TeletexOrganizationalUnitName * pDst, Cert_TeletexOrganizationalUnitName * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_TeletexOrganizationalUnitName_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_TeletexOrganizationalUnitName(Cert_TeletexOrganizationalUnitName const * pLeft, Cert_TeletexOrganizationalUnitName const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_TeletexOrganizationalUnitName_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_TeletexOrganizationalUnitName(Cert_TeletexOrganizationalUnitName * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_TeletexOrganizationalUnitName_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_TeletexOrganizationalUnitName(Cert_TeletexOrganizationalUnitName * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_TeletexOrganizationalUnitName_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_TeletexOrganizationalUnitName(Cert_TeletexOrganizationalUnitName * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_TeletexOrganizationalUnitName_descriptor, ppcxt, pf, pstm); } typedef struct { int count; @@ -209,6 +417,19 @@ typedef struct { } Cert_teletexOrganizationalUnitNames__Type; extern const A2C_DESCRIPTOR Cert_teletexOrganizationalUnitNames__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_teletexOrganizationalUnitNames__Type(Cert_teletexOrganizationalUnitNames__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_teletexOrganizationalUnitNames__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_teletexOrganizationalUnitNames__Type(Cert_teletexOrganizationalUnitNames__Type * p) { return A2C_Free((PVOID) p, &Cert_teletexOrganizationalUnitNames__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_teletexOrganizationalUnitNames__Type(Cert_teletexOrganizationalUnitNames__Type * p) { return A2C_Init((PVOID) p, &Cert_teletexOrganizationalUnitNames__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_teletexOrganizationalUnitNames__Type(Cert_teletexOrganizationalUnitNames__Type * p) { return A2C_Release((PVOID) p, &Cert_teletexOrganizationalUnitNames__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_teletexOrganizationalUnitNames__Type(Cert_teletexOrganizationalUnitNames__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_teletexOrganizationalUnitNames__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_teletexOrganizationalUnitNames__Type(Cert_teletexOrganizationalUnitNames__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_teletexOrganizationalUnitNames__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_teletexOrganizationalUnitNames__Type(Cert_teletexOrganizationalUnitNames__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_teletexOrganizationalUnitNames__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_teletexOrganizationalUnitNames__Type(Cert_teletexOrganizationalUnitNames__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_teletexOrganizationalUnitNames__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_teletexOrganizationalUnitNames__Type(Cert_teletexOrganizationalUnitNames__Type * pDst, Cert_teletexOrganizationalUnitNames__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_teletexOrganizationalUnitNames__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_teletexOrganizationalUnitNames__Type(Cert_teletexOrganizationalUnitNames__Type const * pLeft, Cert_teletexOrganizationalUnitNames__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_teletexOrganizationalUnitNames__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_teletexOrganizationalUnitNames__Type(Cert_teletexOrganizationalUnitNames__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_teletexOrganizationalUnitNames__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_teletexOrganizationalUnitNames__Type(Cert_teletexOrganizationalUnitNames__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_teletexOrganizationalUnitNames__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_teletexOrganizationalUnitNames__Type(Cert_teletexOrganizationalUnitNames__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_teletexOrganizationalUnitNames__Type_descriptor, ppcxt, pf, pstm); } extern const Cert_AttributeType Cert_id_at_initials; extern const A2C_OBJECT_IDENTIFIER Cert_id_qt; @@ -223,6 +444,19 @@ typedef struct { } Cert_CountryName; extern const A2C_DESCRIPTOR Cert_CountryName_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_CountryName(Cert_CountryName ** p) { return A2C_Alloc((PVOID *) p, &Cert_CountryName_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_CountryName(Cert_CountryName * p) { return A2C_Free((PVOID) p, &Cert_CountryName_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_CountryName(Cert_CountryName * p) { return A2C_Init((PVOID) p, &Cert_CountryName_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_CountryName(Cert_CountryName * p) { return A2C_Release((PVOID) p, &Cert_CountryName_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_CountryName(Cert_CountryName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_CountryName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_CountryName(Cert_CountryName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_CountryName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_CountryName(Cert_CountryName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_CountryName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_CountryName(Cert_CountryName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_CountryName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_CountryName(Cert_CountryName * pDst, Cert_CountryName * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_CountryName_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_CountryName(Cert_CountryName const * pLeft, Cert_CountryName const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_CountryName_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_CountryName(Cert_CountryName * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_CountryName_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_CountryName(Cert_CountryName * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_CountryName_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_CountryName(Cert_CountryName * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_CountryName_descriptor, ppcxt, pf, pstm); } typedef struct { int index; @@ -235,18 +469,70 @@ typedef struct { } Cert_AdministrationDomainName; extern const A2C_DESCRIPTOR Cert_AdministrationDomainName_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_AdministrationDomainName(Cert_AdministrationDomainName ** p) { return A2C_Alloc((PVOID *) p, &Cert_AdministrationDomainName_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_AdministrationDomainName(Cert_AdministrationDomainName * p) { return A2C_Free((PVOID) p, &Cert_AdministrationDomainName_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_AdministrationDomainName(Cert_AdministrationDomainName * p) { return A2C_Init((PVOID) p, &Cert_AdministrationDomainName_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_AdministrationDomainName(Cert_AdministrationDomainName * p) { return A2C_Release((PVOID) p, &Cert_AdministrationDomainName_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_AdministrationDomainName(Cert_AdministrationDomainName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_AdministrationDomainName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_AdministrationDomainName(Cert_AdministrationDomainName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_AdministrationDomainName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_AdministrationDomainName(Cert_AdministrationDomainName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_AdministrationDomainName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_AdministrationDomainName(Cert_AdministrationDomainName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_AdministrationDomainName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_AdministrationDomainName(Cert_AdministrationDomainName * pDst, Cert_AdministrationDomainName * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_AdministrationDomainName_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_AdministrationDomainName(Cert_AdministrationDomainName const * pLeft, Cert_AdministrationDomainName const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_AdministrationDomainName_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_AdministrationDomainName(Cert_AdministrationDomainName * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_AdministrationDomainName_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_AdministrationDomainName(Cert_AdministrationDomainName * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_AdministrationDomainName_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_AdministrationDomainName(Cert_AdministrationDomainName * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_AdministrationDomainName_descriptor, ppcxt, pf, pstm); } typedef A2C_NUMERIC_STRING Cert_X121Address; extern const A2C_DESCRIPTOR Cert_X121Address_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_X121Address(Cert_X121Address ** p) { return A2C_Alloc((PVOID *) p, &Cert_X121Address_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_X121Address(Cert_X121Address * p) { return A2C_Free((PVOID) p, &Cert_X121Address_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_X121Address(Cert_X121Address * p) { return A2C_Init((PVOID) p, &Cert_X121Address_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_X121Address(Cert_X121Address * p) { return A2C_Release((PVOID) p, &Cert_X121Address_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_X121Address(Cert_X121Address const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_X121Address_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_X121Address(Cert_X121Address * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_X121Address_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_X121Address(Cert_X121Address const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_X121Address_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_X121Address(Cert_X121Address * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_X121Address_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_X121Address(Cert_X121Address * pDst, Cert_X121Address * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_X121Address_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_X121Address(Cert_X121Address const * pLeft, Cert_X121Address const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_X121Address_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_X121Address(Cert_X121Address * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_X121Address_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_X121Address(Cert_X121Address * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_X121Address_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_X121Address(Cert_X121Address * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_X121Address_descriptor, ppcxt, pf, pstm); } typedef Cert_X121Address Cert_NetworkAddress; extern const A2C_DESCRIPTOR Cert_NetworkAddress_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_NetworkAddress(Cert_NetworkAddress ** p) { return A2C_Alloc((PVOID *) p, &Cert_NetworkAddress_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_NetworkAddress(Cert_NetworkAddress * p) { return A2C_Free((PVOID) p, &Cert_NetworkAddress_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_NetworkAddress(Cert_NetworkAddress * p) { return A2C_Init((PVOID) p, &Cert_NetworkAddress_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_NetworkAddress(Cert_NetworkAddress * p) { return A2C_Release((PVOID) p, &Cert_NetworkAddress_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_NetworkAddress(Cert_NetworkAddress const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_NetworkAddress_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_NetworkAddress(Cert_NetworkAddress * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_NetworkAddress_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_NetworkAddress(Cert_NetworkAddress const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_NetworkAddress_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_NetworkAddress(Cert_NetworkAddress * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_NetworkAddress_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_NetworkAddress(Cert_NetworkAddress * pDst, Cert_NetworkAddress * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_NetworkAddress_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_NetworkAddress(Cert_NetworkAddress const * pLeft, Cert_NetworkAddress const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_NetworkAddress_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_NetworkAddress(Cert_NetworkAddress * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_NetworkAddress_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_NetworkAddress(Cert_NetworkAddress * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_NetworkAddress_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_NetworkAddress(Cert_NetworkAddress * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_NetworkAddress_descriptor, ppcxt, pf, pstm); } typedef A2C_PRINTABLE_STRING Cert_TerminalIdentifier; extern const A2C_DESCRIPTOR Cert_TerminalIdentifier_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_TerminalIdentifier(Cert_TerminalIdentifier ** p) { return A2C_Alloc((PVOID *) p, &Cert_TerminalIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_TerminalIdentifier(Cert_TerminalIdentifier * p) { return A2C_Free((PVOID) p, &Cert_TerminalIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_TerminalIdentifier(Cert_TerminalIdentifier * p) { return A2C_Init((PVOID) p, &Cert_TerminalIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_TerminalIdentifier(Cert_TerminalIdentifier * p) { return A2C_Release((PVOID) p, &Cert_TerminalIdentifier_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_TerminalIdentifier(Cert_TerminalIdentifier const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_TerminalIdentifier_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_TerminalIdentifier(Cert_TerminalIdentifier * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_TerminalIdentifier_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_TerminalIdentifier(Cert_TerminalIdentifier const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_TerminalIdentifier_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_TerminalIdentifier(Cert_TerminalIdentifier * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_TerminalIdentifier_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_TerminalIdentifier(Cert_TerminalIdentifier * pDst, Cert_TerminalIdentifier * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_TerminalIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_TerminalIdentifier(Cert_TerminalIdentifier const * pLeft, Cert_TerminalIdentifier const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_TerminalIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_TerminalIdentifier(Cert_TerminalIdentifier * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_TerminalIdentifier_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_TerminalIdentifier(Cert_TerminalIdentifier * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_TerminalIdentifier_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_TerminalIdentifier(Cert_TerminalIdentifier * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_TerminalIdentifier_descriptor, ppcxt, pf, pstm); } typedef struct { int index; @@ -259,14 +545,53 @@ typedef struct { } Cert_PrivateDomainName; extern const A2C_DESCRIPTOR Cert_PrivateDomainName_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_PrivateDomainName(Cert_PrivateDomainName ** p) { return A2C_Alloc((PVOID *) p, &Cert_PrivateDomainName_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_PrivateDomainName(Cert_PrivateDomainName * p) { return A2C_Free((PVOID) p, &Cert_PrivateDomainName_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_PrivateDomainName(Cert_PrivateDomainName * p) { return A2C_Init((PVOID) p, &Cert_PrivateDomainName_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_PrivateDomainName(Cert_PrivateDomainName * p) { return A2C_Release((PVOID) p, &Cert_PrivateDomainName_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_PrivateDomainName(Cert_PrivateDomainName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_PrivateDomainName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_PrivateDomainName(Cert_PrivateDomainName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_PrivateDomainName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_PrivateDomainName(Cert_PrivateDomainName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_PrivateDomainName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_PrivateDomainName(Cert_PrivateDomainName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_PrivateDomainName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_PrivateDomainName(Cert_PrivateDomainName * pDst, Cert_PrivateDomainName * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_PrivateDomainName_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_PrivateDomainName(Cert_PrivateDomainName const * pLeft, Cert_PrivateDomainName const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_PrivateDomainName_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_PrivateDomainName(Cert_PrivateDomainName * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_PrivateDomainName_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_PrivateDomainName(Cert_PrivateDomainName * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_PrivateDomainName_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_PrivateDomainName(Cert_PrivateDomainName * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_PrivateDomainName_descriptor, ppcxt, pf, pstm); } typedef A2C_PRINTABLE_STRING Cert_OrganizationName; extern const A2C_DESCRIPTOR Cert_OrganizationName_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_OrganizationName(Cert_OrganizationName ** p) { return A2C_Alloc((PVOID *) p, &Cert_OrganizationName_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_OrganizationName(Cert_OrganizationName * p) { return A2C_Free((PVOID) p, &Cert_OrganizationName_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_OrganizationName(Cert_OrganizationName * p) { return A2C_Init((PVOID) p, &Cert_OrganizationName_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_OrganizationName(Cert_OrganizationName * p) { return A2C_Release((PVOID) p, &Cert_OrganizationName_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_OrganizationName(Cert_OrganizationName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_OrganizationName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_OrganizationName(Cert_OrganizationName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_OrganizationName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_OrganizationName(Cert_OrganizationName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_OrganizationName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_OrganizationName(Cert_OrganizationName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_OrganizationName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_OrganizationName(Cert_OrganizationName * pDst, Cert_OrganizationName * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_OrganizationName_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_OrganizationName(Cert_OrganizationName const * pLeft, Cert_OrganizationName const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_OrganizationName_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_OrganizationName(Cert_OrganizationName * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_OrganizationName_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_OrganizationName(Cert_OrganizationName * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_OrganizationName_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_OrganizationName(Cert_OrganizationName * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_OrganizationName_descriptor, ppcxt, pf, pstm); } typedef A2C_NUMERIC_STRING Cert_NumericUserIdentifier; extern const A2C_DESCRIPTOR Cert_NumericUserIdentifier_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_NumericUserIdentifier(Cert_NumericUserIdentifier ** p) { return A2C_Alloc((PVOID *) p, &Cert_NumericUserIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_NumericUserIdentifier(Cert_NumericUserIdentifier * p) { return A2C_Free((PVOID) p, &Cert_NumericUserIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_NumericUserIdentifier(Cert_NumericUserIdentifier * p) { return A2C_Init((PVOID) p, &Cert_NumericUserIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_NumericUserIdentifier(Cert_NumericUserIdentifier * p) { return A2C_Release((PVOID) p, &Cert_NumericUserIdentifier_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_NumericUserIdentifier(Cert_NumericUserIdentifier const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_NumericUserIdentifier_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_NumericUserIdentifier(Cert_NumericUserIdentifier * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_NumericUserIdentifier_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_NumericUserIdentifier(Cert_NumericUserIdentifier const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_NumericUserIdentifier_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_NumericUserIdentifier(Cert_NumericUserIdentifier * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_NumericUserIdentifier_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_NumericUserIdentifier(Cert_NumericUserIdentifier * pDst, Cert_NumericUserIdentifier * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_NumericUserIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_NumericUserIdentifier(Cert_NumericUserIdentifier const * pLeft, Cert_NumericUserIdentifier const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_NumericUserIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_NumericUserIdentifier(Cert_NumericUserIdentifier * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_NumericUserIdentifier_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_NumericUserIdentifier(Cert_NumericUserIdentifier * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_NumericUserIdentifier_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_NumericUserIdentifier(Cert_NumericUserIdentifier * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_NumericUserIdentifier_descriptor, ppcxt, pf, pstm); } typedef struct { unsigned int optionalFields; @@ -280,10 +605,36 @@ typedef struct { } Cert_PersonalName; extern const A2C_DESCRIPTOR Cert_PersonalName_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_PersonalName(Cert_PersonalName ** p) { return A2C_Alloc((PVOID *) p, &Cert_PersonalName_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_PersonalName(Cert_PersonalName * p) { return A2C_Free((PVOID) p, &Cert_PersonalName_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_PersonalName(Cert_PersonalName * p) { return A2C_Init((PVOID) p, &Cert_PersonalName_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_PersonalName(Cert_PersonalName * p) { return A2C_Release((PVOID) p, &Cert_PersonalName_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_PersonalName(Cert_PersonalName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_PersonalName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_PersonalName(Cert_PersonalName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_PersonalName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_PersonalName(Cert_PersonalName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_PersonalName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_PersonalName(Cert_PersonalName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_PersonalName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_PersonalName(Cert_PersonalName * pDst, Cert_PersonalName * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_PersonalName_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_PersonalName(Cert_PersonalName const * pLeft, Cert_PersonalName const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_PersonalName_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_PersonalName(Cert_PersonalName * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_PersonalName_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_PersonalName(Cert_PersonalName * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_PersonalName_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_PersonalName(Cert_PersonalName * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_PersonalName_descriptor, ppcxt, pf, pstm); } typedef A2C_PRINTABLE_STRING Cert_OrganizationalUnitName; extern const A2C_DESCRIPTOR Cert_OrganizationalUnitName_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_OrganizationalUnitName(Cert_OrganizationalUnitName ** p) { return A2C_Alloc((PVOID *) p, &Cert_OrganizationalUnitName_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_OrganizationalUnitName(Cert_OrganizationalUnitName * p) { return A2C_Free((PVOID) p, &Cert_OrganizationalUnitName_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_OrganizationalUnitName(Cert_OrganizationalUnitName * p) { return A2C_Init((PVOID) p, &Cert_OrganizationalUnitName_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_OrganizationalUnitName(Cert_OrganizationalUnitName * p) { return A2C_Release((PVOID) p, &Cert_OrganizationalUnitName_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_OrganizationalUnitName(Cert_OrganizationalUnitName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_OrganizationalUnitName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_OrganizationalUnitName(Cert_OrganizationalUnitName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_OrganizationalUnitName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_OrganizationalUnitName(Cert_OrganizationalUnitName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_OrganizationalUnitName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_OrganizationalUnitName(Cert_OrganizationalUnitName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_OrganizationalUnitName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_OrganizationalUnitName(Cert_OrganizationalUnitName * pDst, Cert_OrganizationalUnitName * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_OrganizationalUnitName_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_OrganizationalUnitName(Cert_OrganizationalUnitName const * pLeft, Cert_OrganizationalUnitName const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_OrganizationalUnitName_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_OrganizationalUnitName(Cert_OrganizationalUnitName * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_OrganizationalUnitName_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_OrganizationalUnitName(Cert_OrganizationalUnitName * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_OrganizationalUnitName_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_OrganizationalUnitName(Cert_OrganizationalUnitName * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_OrganizationalUnitName_descriptor, ppcxt, pf, pstm); } typedef struct { int count; @@ -292,6 +643,19 @@ typedef struct { } Cert_OrganizationalUnitNames; extern const A2C_DESCRIPTOR Cert_OrganizationalUnitNames_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_OrganizationalUnitNames(Cert_OrganizationalUnitNames ** p) { return A2C_Alloc((PVOID *) p, &Cert_OrganizationalUnitNames_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_OrganizationalUnitNames(Cert_OrganizationalUnitNames * p) { return A2C_Free((PVOID) p, &Cert_OrganizationalUnitNames_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_OrganizationalUnitNames(Cert_OrganizationalUnitNames * p) { return A2C_Init((PVOID) p, &Cert_OrganizationalUnitNames_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_OrganizationalUnitNames(Cert_OrganizationalUnitNames * p) { return A2C_Release((PVOID) p, &Cert_OrganizationalUnitNames_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_OrganizationalUnitNames(Cert_OrganizationalUnitNames const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_OrganizationalUnitNames_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_OrganizationalUnitNames(Cert_OrganizationalUnitNames * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_OrganizationalUnitNames_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_OrganizationalUnitNames(Cert_OrganizationalUnitNames const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_OrganizationalUnitNames_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_OrganizationalUnitNames(Cert_OrganizationalUnitNames * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_OrganizationalUnitNames_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_OrganizationalUnitNames(Cert_OrganizationalUnitNames * pDst, Cert_OrganizationalUnitNames * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_OrganizationalUnitNames_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_OrganizationalUnitNames(Cert_OrganizationalUnitNames const * pLeft, Cert_OrganizationalUnitNames const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_OrganizationalUnitNames_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_OrganizationalUnitNames(Cert_OrganizationalUnitNames * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_OrganizationalUnitNames_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_OrganizationalUnitNames(Cert_OrganizationalUnitNames * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_OrganizationalUnitNames_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_OrganizationalUnitNames(Cert_OrganizationalUnitNames * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_OrganizationalUnitNames_descriptor, ppcxt, pf, pstm); } typedef struct { unsigned int optionalFields; @@ -316,6 +680,19 @@ typedef struct { } Cert_BuiltInStandardAttributes; extern const A2C_DESCRIPTOR Cert_BuiltInStandardAttributes_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_BuiltInStandardAttributes(Cert_BuiltInStandardAttributes ** p) { return A2C_Alloc((PVOID *) p, &Cert_BuiltInStandardAttributes_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_BuiltInStandardAttributes(Cert_BuiltInStandardAttributes * p) { return A2C_Free((PVOID) p, &Cert_BuiltInStandardAttributes_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_BuiltInStandardAttributes(Cert_BuiltInStandardAttributes * p) { return A2C_Init((PVOID) p, &Cert_BuiltInStandardAttributes_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_BuiltInStandardAttributes(Cert_BuiltInStandardAttributes * p) { return A2C_Release((PVOID) p, &Cert_BuiltInStandardAttributes_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_BuiltInStandardAttributes(Cert_BuiltInStandardAttributes const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_BuiltInStandardAttributes_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_BuiltInStandardAttributes(Cert_BuiltInStandardAttributes * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_BuiltInStandardAttributes_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_BuiltInStandardAttributes(Cert_BuiltInStandardAttributes const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_BuiltInStandardAttributes_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_BuiltInStandardAttributes(Cert_BuiltInStandardAttributes * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_BuiltInStandardAttributes_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_BuiltInStandardAttributes(Cert_BuiltInStandardAttributes * pDst, Cert_BuiltInStandardAttributes * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_BuiltInStandardAttributes_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_BuiltInStandardAttributes(Cert_BuiltInStandardAttributes const * pLeft, Cert_BuiltInStandardAttributes const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_BuiltInStandardAttributes_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_BuiltInStandardAttributes(Cert_BuiltInStandardAttributes * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_BuiltInStandardAttributes_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_BuiltInStandardAttributes(Cert_BuiltInStandardAttributes * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_BuiltInStandardAttributes_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_BuiltInStandardAttributes(Cert_BuiltInStandardAttributes * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_BuiltInStandardAttributes_descriptor, ppcxt, pf, pstm); } typedef struct { A2C_PRINTABLE_STRING type; @@ -323,6 +700,19 @@ typedef struct { } Cert_BuiltInDomainDefinedAttribute; extern const A2C_DESCRIPTOR Cert_BuiltInDomainDefinedAttribute_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_BuiltInDomainDefinedAttribute(Cert_BuiltInDomainDefinedAttribute ** p) { return A2C_Alloc((PVOID *) p, &Cert_BuiltInDomainDefinedAttribute_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_BuiltInDomainDefinedAttribute(Cert_BuiltInDomainDefinedAttribute * p) { return A2C_Free((PVOID) p, &Cert_BuiltInDomainDefinedAttribute_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_BuiltInDomainDefinedAttribute(Cert_BuiltInDomainDefinedAttribute * p) { return A2C_Init((PVOID) p, &Cert_BuiltInDomainDefinedAttribute_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_BuiltInDomainDefinedAttribute(Cert_BuiltInDomainDefinedAttribute * p) { return A2C_Release((PVOID) p, &Cert_BuiltInDomainDefinedAttribute_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_BuiltInDomainDefinedAttribute(Cert_BuiltInDomainDefinedAttribute const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_BuiltInDomainDefinedAttribute_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_BuiltInDomainDefinedAttribute(Cert_BuiltInDomainDefinedAttribute * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_BuiltInDomainDefinedAttribute_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_BuiltInDomainDefinedAttribute(Cert_BuiltInDomainDefinedAttribute const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_BuiltInDomainDefinedAttribute_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_BuiltInDomainDefinedAttribute(Cert_BuiltInDomainDefinedAttribute * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_BuiltInDomainDefinedAttribute_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_BuiltInDomainDefinedAttribute(Cert_BuiltInDomainDefinedAttribute * pDst, Cert_BuiltInDomainDefinedAttribute * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_BuiltInDomainDefinedAttribute_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_BuiltInDomainDefinedAttribute(Cert_BuiltInDomainDefinedAttribute const * pLeft, Cert_BuiltInDomainDefinedAttribute const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_BuiltInDomainDefinedAttribute_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_BuiltInDomainDefinedAttribute(Cert_BuiltInDomainDefinedAttribute * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_BuiltInDomainDefinedAttribute_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_BuiltInDomainDefinedAttribute(Cert_BuiltInDomainDefinedAttribute * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_BuiltInDomainDefinedAttribute_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_BuiltInDomainDefinedAttribute(Cert_BuiltInDomainDefinedAttribute * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_BuiltInDomainDefinedAttribute_descriptor, ppcxt, pf, pstm); } typedef struct { int count; @@ -331,6 +721,19 @@ typedef struct { } Cert_BuiltInDomainDefinedAttributes; extern const A2C_DESCRIPTOR Cert_BuiltInDomainDefinedAttributes_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_BuiltInDomainDefinedAttributes(Cert_BuiltInDomainDefinedAttributes ** p) { return A2C_Alloc((PVOID *) p, &Cert_BuiltInDomainDefinedAttributes_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_BuiltInDomainDefinedAttributes(Cert_BuiltInDomainDefinedAttributes * p) { return A2C_Free((PVOID) p, &Cert_BuiltInDomainDefinedAttributes_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_BuiltInDomainDefinedAttributes(Cert_BuiltInDomainDefinedAttributes * p) { return A2C_Init((PVOID) p, &Cert_BuiltInDomainDefinedAttributes_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_BuiltInDomainDefinedAttributes(Cert_BuiltInDomainDefinedAttributes * p) { return A2C_Release((PVOID) p, &Cert_BuiltInDomainDefinedAttributes_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_BuiltInDomainDefinedAttributes(Cert_BuiltInDomainDefinedAttributes const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_BuiltInDomainDefinedAttributes_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_BuiltInDomainDefinedAttributes(Cert_BuiltInDomainDefinedAttributes * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_BuiltInDomainDefinedAttributes_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_BuiltInDomainDefinedAttributes(Cert_BuiltInDomainDefinedAttributes const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_BuiltInDomainDefinedAttributes_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_BuiltInDomainDefinedAttributes(Cert_BuiltInDomainDefinedAttributes * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_BuiltInDomainDefinedAttributes_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_BuiltInDomainDefinedAttributes(Cert_BuiltInDomainDefinedAttributes * pDst, Cert_BuiltInDomainDefinedAttributes * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_BuiltInDomainDefinedAttributes_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_BuiltInDomainDefinedAttributes(Cert_BuiltInDomainDefinedAttributes const * pLeft, Cert_BuiltInDomainDefinedAttributes const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_BuiltInDomainDefinedAttributes_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_BuiltInDomainDefinedAttributes(Cert_BuiltInDomainDefinedAttributes * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_BuiltInDomainDefinedAttributes_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_BuiltInDomainDefinedAttributes(Cert_BuiltInDomainDefinedAttributes * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_BuiltInDomainDefinedAttributes_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_BuiltInDomainDefinedAttributes(Cert_BuiltInDomainDefinedAttributes * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_BuiltInDomainDefinedAttributes_descriptor, ppcxt, pf, pstm); } typedef struct { A2C_INTEGER_NATIVE extension_attribute_type; @@ -338,6 +741,19 @@ typedef struct { } Cert_ExtensionAttribute; extern const A2C_DESCRIPTOR Cert_ExtensionAttribute_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_ExtensionAttribute(Cert_ExtensionAttribute ** p) { return A2C_Alloc((PVOID *) p, &Cert_ExtensionAttribute_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_ExtensionAttribute(Cert_ExtensionAttribute * p) { return A2C_Free((PVOID) p, &Cert_ExtensionAttribute_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_ExtensionAttribute(Cert_ExtensionAttribute * p) { return A2C_Init((PVOID) p, &Cert_ExtensionAttribute_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_ExtensionAttribute(Cert_ExtensionAttribute * p) { return A2C_Release((PVOID) p, &Cert_ExtensionAttribute_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_ExtensionAttribute(Cert_ExtensionAttribute const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_ExtensionAttribute_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_ExtensionAttribute(Cert_ExtensionAttribute * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_ExtensionAttribute_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_ExtensionAttribute(Cert_ExtensionAttribute const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_ExtensionAttribute_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_ExtensionAttribute(Cert_ExtensionAttribute * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_ExtensionAttribute_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_ExtensionAttribute(Cert_ExtensionAttribute * pDst, Cert_ExtensionAttribute * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_ExtensionAttribute_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_ExtensionAttribute(Cert_ExtensionAttribute const * pLeft, Cert_ExtensionAttribute const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_ExtensionAttribute_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_ExtensionAttribute(Cert_ExtensionAttribute * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_ExtensionAttribute_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_ExtensionAttribute(Cert_ExtensionAttribute * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_ExtensionAttribute_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_ExtensionAttribute(Cert_ExtensionAttribute * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_ExtensionAttribute_descriptor, ppcxt, pf, pstm); } typedef struct { int count; @@ -346,6 +762,19 @@ typedef struct { } Cert_ExtensionAttributes; extern const A2C_DESCRIPTOR Cert_ExtensionAttributes_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_ExtensionAttributes(Cert_ExtensionAttributes ** p) { return A2C_Alloc((PVOID *) p, &Cert_ExtensionAttributes_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_ExtensionAttributes(Cert_ExtensionAttributes * p) { return A2C_Free((PVOID) p, &Cert_ExtensionAttributes_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_ExtensionAttributes(Cert_ExtensionAttributes * p) { return A2C_Init((PVOID) p, &Cert_ExtensionAttributes_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_ExtensionAttributes(Cert_ExtensionAttributes * p) { return A2C_Release((PVOID) p, &Cert_ExtensionAttributes_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_ExtensionAttributes(Cert_ExtensionAttributes const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_ExtensionAttributes_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_ExtensionAttributes(Cert_ExtensionAttributes * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_ExtensionAttributes_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_ExtensionAttributes(Cert_ExtensionAttributes const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_ExtensionAttributes_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_ExtensionAttributes(Cert_ExtensionAttributes * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_ExtensionAttributes_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_ExtensionAttributes(Cert_ExtensionAttributes * pDst, Cert_ExtensionAttributes * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_ExtensionAttributes_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_ExtensionAttributes(Cert_ExtensionAttributes const * pLeft, Cert_ExtensionAttributes const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_ExtensionAttributes_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_ExtensionAttributes(Cert_ExtensionAttributes * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_ExtensionAttributes_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_ExtensionAttributes(Cert_ExtensionAttributes * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_ExtensionAttributes_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_ExtensionAttributes(Cert_ExtensionAttributes * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_ExtensionAttributes_descriptor, ppcxt, pf, pstm); } typedef struct { unsigned int optionalFields; @@ -357,16 +786,55 @@ typedef struct { } Cert_ORAddress; extern const A2C_DESCRIPTOR Cert_ORAddress_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_ORAddress(Cert_ORAddress ** p) { return A2C_Alloc((PVOID *) p, &Cert_ORAddress_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_ORAddress(Cert_ORAddress * p) { return A2C_Free((PVOID) p, &Cert_ORAddress_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_ORAddress(Cert_ORAddress * p) { return A2C_Init((PVOID) p, &Cert_ORAddress_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_ORAddress(Cert_ORAddress * p) { return A2C_Release((PVOID) p, &Cert_ORAddress_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_ORAddress(Cert_ORAddress const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_ORAddress_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_ORAddress(Cert_ORAddress * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_ORAddress_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_ORAddress(Cert_ORAddress const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_ORAddress_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_ORAddress(Cert_ORAddress * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_ORAddress_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_ORAddress(Cert_ORAddress * pDst, Cert_ORAddress * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_ORAddress_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_ORAddress(Cert_ORAddress const * pLeft, Cert_ORAddress const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_ORAddress_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_ORAddress(Cert_ORAddress * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_ORAddress_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_ORAddress(Cert_ORAddress * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_ORAddress_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_ORAddress(Cert_ORAddress * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_ORAddress_descriptor, ppcxt, pf, pstm); } typedef A2C_TELETEX_STRING Cert_teletexCommonName__Type; extern const A2C_DESCRIPTOR Cert_teletexCommonName__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_teletexCommonName__Type(Cert_teletexCommonName__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_teletexCommonName__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_teletexCommonName__Type(Cert_teletexCommonName__Type * p) { return A2C_Free((PVOID) p, &Cert_teletexCommonName__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_teletexCommonName__Type(Cert_teletexCommonName__Type * p) { return A2C_Init((PVOID) p, &Cert_teletexCommonName__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_teletexCommonName__Type(Cert_teletexCommonName__Type * p) { return A2C_Release((PVOID) p, &Cert_teletexCommonName__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_teletexCommonName__Type(Cert_teletexCommonName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_teletexCommonName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_teletexCommonName__Type(Cert_teletexCommonName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_teletexCommonName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_teletexCommonName__Type(Cert_teletexCommonName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_teletexCommonName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_teletexCommonName__Type(Cert_teletexCommonName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_teletexCommonName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_teletexCommonName__Type(Cert_teletexCommonName__Type * pDst, Cert_teletexCommonName__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_teletexCommonName__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_teletexCommonName__Type(Cert_teletexCommonName__Type const * pLeft, Cert_teletexCommonName__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_teletexCommonName__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_teletexCommonName__Type(Cert_teletexCommonName__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_teletexCommonName__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_teletexCommonName__Type(Cert_teletexCommonName__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_teletexCommonName__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_teletexCommonName__Type(Cert_teletexCommonName__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_teletexCommonName__Type_descriptor, ppcxt, pf, pstm); } extern const A2C_INTEGER_NATIVE Cert_extensionORAddressComponents__id; extern const A2C_INTEGER_NATIVE Cert_ub_pds_physical_address_lines; typedef A2C_INTEGER_NATIVE Cert_Version; extern const A2C_DESCRIPTOR Cert_Version_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_Version(Cert_Version ** p) { return A2C_Alloc((PVOID *) p, &Cert_Version_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_Version(Cert_Version * p) { return A2C_Free((PVOID) p, &Cert_Version_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_Version(Cert_Version * p) { return A2C_Init((PVOID) p, &Cert_Version_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_Version(Cert_Version * p) { return A2C_Release((PVOID) p, &Cert_Version_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_Version(Cert_Version const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_Version_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_Version(Cert_Version * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_Version_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_Version(Cert_Version const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_Version_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_Version(Cert_Version * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_Version_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_Version(Cert_Version * pDst, Cert_Version * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_Version_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_Version(Cert_Version const * pLeft, Cert_Version const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_Version_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_Version(Cert_Version * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_Version_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_Version(Cert_Version * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_Version_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_Version(Cert_Version * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_Version_descriptor, ppcxt, pf, pstm); } typedef struct { Cert_Time notBefore; @@ -374,6 +842,19 @@ typedef struct { } Cert_Validity; extern const A2C_DESCRIPTOR Cert_Validity_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_Validity(Cert_Validity ** p) { return A2C_Alloc((PVOID *) p, &Cert_Validity_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_Validity(Cert_Validity * p) { return A2C_Free((PVOID) p, &Cert_Validity_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_Validity(Cert_Validity * p) { return A2C_Init((PVOID) p, &Cert_Validity_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_Validity(Cert_Validity * p) { return A2C_Release((PVOID) p, &Cert_Validity_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_Validity(Cert_Validity const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_Validity_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_Validity(Cert_Validity * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_Validity_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_Validity(Cert_Validity const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_Validity_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_Validity(Cert_Validity * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_Validity_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_Validity(Cert_Validity * pDst, Cert_Validity * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_Validity_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_Validity(Cert_Validity const * pLeft, Cert_Validity const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_Validity_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_Validity(Cert_Validity * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_Validity_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_Validity(Cert_Validity * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_Validity_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_Validity(Cert_Validity * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_Validity_descriptor, ppcxt, pf, pstm); } typedef struct { Cert_AlgorithmIdentifier algorithm; @@ -381,10 +862,36 @@ typedef struct { } Cert_SubjectPublicKeyInfo; extern const A2C_DESCRIPTOR Cert_SubjectPublicKeyInfo_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_SubjectPublicKeyInfo(Cert_SubjectPublicKeyInfo ** p) { return A2C_Alloc((PVOID *) p, &Cert_SubjectPublicKeyInfo_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_SubjectPublicKeyInfo(Cert_SubjectPublicKeyInfo * p) { return A2C_Free((PVOID) p, &Cert_SubjectPublicKeyInfo_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_SubjectPublicKeyInfo(Cert_SubjectPublicKeyInfo * p) { return A2C_Init((PVOID) p, &Cert_SubjectPublicKeyInfo_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_SubjectPublicKeyInfo(Cert_SubjectPublicKeyInfo * p) { return A2C_Release((PVOID) p, &Cert_SubjectPublicKeyInfo_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_SubjectPublicKeyInfo(Cert_SubjectPublicKeyInfo const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_SubjectPublicKeyInfo_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_SubjectPublicKeyInfo(Cert_SubjectPublicKeyInfo * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_SubjectPublicKeyInfo_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_SubjectPublicKeyInfo(Cert_SubjectPublicKeyInfo const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_SubjectPublicKeyInfo_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_SubjectPublicKeyInfo(Cert_SubjectPublicKeyInfo * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_SubjectPublicKeyInfo_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_SubjectPublicKeyInfo(Cert_SubjectPublicKeyInfo * pDst, Cert_SubjectPublicKeyInfo * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_SubjectPublicKeyInfo_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_SubjectPublicKeyInfo(Cert_SubjectPublicKeyInfo const * pLeft, Cert_SubjectPublicKeyInfo const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_SubjectPublicKeyInfo_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_SubjectPublicKeyInfo(Cert_SubjectPublicKeyInfo * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_SubjectPublicKeyInfo_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_SubjectPublicKeyInfo(Cert_SubjectPublicKeyInfo * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_SubjectPublicKeyInfo_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_SubjectPublicKeyInfo(Cert_SubjectPublicKeyInfo * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_SubjectPublicKeyInfo_descriptor, ppcxt, pf, pstm); } typedef A2C_BIT_STRING Cert_UniqueIdentifier; extern const A2C_DESCRIPTOR Cert_UniqueIdentifier_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_UniqueIdentifier(Cert_UniqueIdentifier ** p) { return A2C_Alloc((PVOID *) p, &Cert_UniqueIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_UniqueIdentifier(Cert_UniqueIdentifier * p) { return A2C_Free((PVOID) p, &Cert_UniqueIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_UniqueIdentifier(Cert_UniqueIdentifier * p) { return A2C_Init((PVOID) p, &Cert_UniqueIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_UniqueIdentifier(Cert_UniqueIdentifier * p) { return A2C_Release((PVOID) p, &Cert_UniqueIdentifier_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_UniqueIdentifier(Cert_UniqueIdentifier const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_UniqueIdentifier_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_UniqueIdentifier(Cert_UniqueIdentifier * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_UniqueIdentifier_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_UniqueIdentifier(Cert_UniqueIdentifier const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_UniqueIdentifier_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_UniqueIdentifier(Cert_UniqueIdentifier * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_UniqueIdentifier_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_UniqueIdentifier(Cert_UniqueIdentifier * pDst, Cert_UniqueIdentifier * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_UniqueIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_UniqueIdentifier(Cert_UniqueIdentifier const * pLeft, Cert_UniqueIdentifier const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_UniqueIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_UniqueIdentifier(Cert_UniqueIdentifier * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_UniqueIdentifier_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_UniqueIdentifier(Cert_UniqueIdentifier * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_UniqueIdentifier_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_UniqueIdentifier(Cert_UniqueIdentifier * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_UniqueIdentifier_descriptor, ppcxt, pf, pstm); } typedef struct { unsigned int optionalFields; @@ -398,7 +905,7 @@ typedef struct { Cert_Validity validity; Cert_Name subject; Cert_SubjectPublicKeyInfo subjectPublicKeyInfo; - + /* Start Extension */ /* Extension Group version: 2 */ Cert_UniqueIdentifier issuerUniqueID; Cert_UniqueIdentifier subjectUniqueID; @@ -406,10 +913,23 @@ typedef struct { /* Extension Group version: 3 */ Cert_Extensions extensions; - + A2C_EXTENSION _extension; } Cert_TBSCertificate; extern const A2C_DESCRIPTOR Cert_TBSCertificate_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_TBSCertificate(Cert_TBSCertificate ** p) { return A2C_Alloc((PVOID *) p, &Cert_TBSCertificate_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_TBSCertificate(Cert_TBSCertificate * p) { return A2C_Free((PVOID) p, &Cert_TBSCertificate_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_TBSCertificate(Cert_TBSCertificate * p) { return A2C_Init((PVOID) p, &Cert_TBSCertificate_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_TBSCertificate(Cert_TBSCertificate * p) { return A2C_Release((PVOID) p, &Cert_TBSCertificate_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_TBSCertificate(Cert_TBSCertificate const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_TBSCertificate_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_TBSCertificate(Cert_TBSCertificate * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_TBSCertificate_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_TBSCertificate(Cert_TBSCertificate const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_TBSCertificate_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_TBSCertificate(Cert_TBSCertificate * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_TBSCertificate_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_TBSCertificate(Cert_TBSCertificate * pDst, Cert_TBSCertificate * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_TBSCertificate_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_TBSCertificate(Cert_TBSCertificate const * pLeft, Cert_TBSCertificate const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_TBSCertificate_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_TBSCertificate(Cert_TBSCertificate * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_TBSCertificate_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_TBSCertificate(Cert_TBSCertificate * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_TBSCertificate_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_TBSCertificate(Cert_TBSCertificate * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_TBSCertificate_descriptor, ppcxt, pf, pstm); } typedef struct { unsigned int optionalFields; @@ -423,6 +943,19 @@ typedef struct { } Cert_teletexPersonalName__Type; extern const A2C_DESCRIPTOR Cert_teletexPersonalName__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_teletexPersonalName__Type(Cert_teletexPersonalName__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_teletexPersonalName__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_teletexPersonalName__Type(Cert_teletexPersonalName__Type * p) { return A2C_Free((PVOID) p, &Cert_teletexPersonalName__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_teletexPersonalName__Type(Cert_teletexPersonalName__Type * p) { return A2C_Init((PVOID) p, &Cert_teletexPersonalName__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_teletexPersonalName__Type(Cert_teletexPersonalName__Type * p) { return A2C_Release((PVOID) p, &Cert_teletexPersonalName__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_teletexPersonalName__Type(Cert_teletexPersonalName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_teletexPersonalName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_teletexPersonalName__Type(Cert_teletexPersonalName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_teletexPersonalName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_teletexPersonalName__Type(Cert_teletexPersonalName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_teletexPersonalName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_teletexPersonalName__Type(Cert_teletexPersonalName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_teletexPersonalName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_teletexPersonalName__Type(Cert_teletexPersonalName__Type * pDst, Cert_teletexPersonalName__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_teletexPersonalName__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_teletexPersonalName__Type(Cert_teletexPersonalName__Type const * pLeft, Cert_teletexPersonalName__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_teletexPersonalName__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_teletexPersonalName__Type(Cert_teletexPersonalName__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_teletexPersonalName__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_teletexPersonalName__Type(Cert_teletexPersonalName__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_teletexPersonalName__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_teletexPersonalName__Type(Cert_teletexPersonalName__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_teletexPersonalName__Type_descriptor, ppcxt, pf, pstm); } extern const A2C_INTEGER_NATIVE Cert_ub_locality_name; extern const A2C_INTEGER_NATIVE Cert_ub_common_name_length; @@ -432,6 +965,19 @@ typedef struct { } Cert_TeletexDomainDefinedAttribute; extern const A2C_DESCRIPTOR Cert_TeletexDomainDefinedAttribute_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_TeletexDomainDefinedAttribute(Cert_TeletexDomainDefinedAttribute ** p) { return A2C_Alloc((PVOID *) p, &Cert_TeletexDomainDefinedAttribute_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_TeletexDomainDefinedAttribute(Cert_TeletexDomainDefinedAttribute * p) { return A2C_Free((PVOID) p, &Cert_TeletexDomainDefinedAttribute_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_TeletexDomainDefinedAttribute(Cert_TeletexDomainDefinedAttribute * p) { return A2C_Init((PVOID) p, &Cert_TeletexDomainDefinedAttribute_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_TeletexDomainDefinedAttribute(Cert_TeletexDomainDefinedAttribute * p) { return A2C_Release((PVOID) p, &Cert_TeletexDomainDefinedAttribute_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_TeletexDomainDefinedAttribute(Cert_TeletexDomainDefinedAttribute const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_TeletexDomainDefinedAttribute_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_TeletexDomainDefinedAttribute(Cert_TeletexDomainDefinedAttribute * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_TeletexDomainDefinedAttribute_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_TeletexDomainDefinedAttribute(Cert_TeletexDomainDefinedAttribute const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_TeletexDomainDefinedAttribute_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_TeletexDomainDefinedAttribute(Cert_TeletexDomainDefinedAttribute * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_TeletexDomainDefinedAttribute_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_TeletexDomainDefinedAttribute(Cert_TeletexDomainDefinedAttribute * pDst, Cert_TeletexDomainDefinedAttribute * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_TeletexDomainDefinedAttribute_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_TeletexDomainDefinedAttribute(Cert_TeletexDomainDefinedAttribute const * pLeft, Cert_TeletexDomainDefinedAttribute const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_TeletexDomainDefinedAttribute_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_TeletexDomainDefinedAttribute(Cert_TeletexDomainDefinedAttribute * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_TeletexDomainDefinedAttribute_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_TeletexDomainDefinedAttribute(Cert_TeletexDomainDefinedAttribute * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_TeletexDomainDefinedAttribute_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_TeletexDomainDefinedAttribute(Cert_TeletexDomainDefinedAttribute * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_TeletexDomainDefinedAttribute_descriptor, ppcxt, pf, pstm); } typedef struct { int count; @@ -440,6 +986,19 @@ typedef struct { } Cert_teletexDomainDefinedAttributes__Type; extern const A2C_DESCRIPTOR Cert_teletexDomainDefinedAttributes__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_teletexDomainDefinedAttributes__Type(Cert_teletexDomainDefinedAttributes__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_teletexDomainDefinedAttributes__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_teletexDomainDefinedAttributes__Type(Cert_teletexDomainDefinedAttributes__Type * p) { return A2C_Free((PVOID) p, &Cert_teletexDomainDefinedAttributes__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_teletexDomainDefinedAttributes__Type(Cert_teletexDomainDefinedAttributes__Type * p) { return A2C_Init((PVOID) p, &Cert_teletexDomainDefinedAttributes__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_teletexDomainDefinedAttributes__Type(Cert_teletexDomainDefinedAttributes__Type * p) { return A2C_Release((PVOID) p, &Cert_teletexDomainDefinedAttributes__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_teletexDomainDefinedAttributes__Type(Cert_teletexDomainDefinedAttributes__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_teletexDomainDefinedAttributes__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_teletexDomainDefinedAttributes__Type(Cert_teletexDomainDefinedAttributes__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_teletexDomainDefinedAttributes__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_teletexDomainDefinedAttributes__Type(Cert_teletexDomainDefinedAttributes__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_teletexDomainDefinedAttributes__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_teletexDomainDefinedAttributes__Type(Cert_teletexDomainDefinedAttributes__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_teletexDomainDefinedAttributes__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_teletexDomainDefinedAttributes__Type(Cert_teletexDomainDefinedAttributes__Type * pDst, Cert_teletexDomainDefinedAttributes__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_teletexDomainDefinedAttributes__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_teletexDomainDefinedAttributes__Type(Cert_teletexDomainDefinedAttributes__Type const * pLeft, Cert_teletexDomainDefinedAttributes__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_teletexDomainDefinedAttributes__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_teletexDomainDefinedAttributes__Type(Cert_teletexDomainDefinedAttributes__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_teletexDomainDefinedAttributes__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_teletexDomainDefinedAttributes__Type(Cert_teletexDomainDefinedAttributes__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_teletexDomainDefinedAttributes__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_teletexDomainDefinedAttributes__Type(Cert_teletexDomainDefinedAttributes__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_teletexDomainDefinedAttributes__Type_descriptor, ppcxt, pf, pstm); } extern const Cert_EXTENSION_ATTRIBUTE Cert_teletexDomainDefinedAttributes; extern const Cert_EXTENSION_ATTRIBUTE Cert_posteRestanteAddress; extern const A2C_OBJECT_IDENTIFIER Cert_id_at; @@ -447,6 +1006,19 @@ extern const A2C_OBJECT_IDENTIFIER Cert_id_at; typedef Cert_RDNSequence Cert_DistinguishedName; extern const A2C_DESCRIPTOR Cert_DistinguishedName_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_DistinguishedName(Cert_DistinguishedName ** p) { return A2C_Alloc((PVOID *) p, &Cert_DistinguishedName_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_DistinguishedName(Cert_DistinguishedName * p) { return A2C_Free((PVOID) p, &Cert_DistinguishedName_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_DistinguishedName(Cert_DistinguishedName * p) { return A2C_Init((PVOID) p, &Cert_DistinguishedName_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_DistinguishedName(Cert_DistinguishedName * p) { return A2C_Release((PVOID) p, &Cert_DistinguishedName_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_DistinguishedName(Cert_DistinguishedName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_DistinguishedName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_DistinguishedName(Cert_DistinguishedName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_DistinguishedName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_DistinguishedName(Cert_DistinguishedName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_DistinguishedName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_DistinguishedName(Cert_DistinguishedName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_DistinguishedName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_DistinguishedName(Cert_DistinguishedName * pDst, Cert_DistinguishedName * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_DistinguishedName_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_DistinguishedName(Cert_DistinguishedName const * pLeft, Cert_DistinguishedName const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_DistinguishedName_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_DistinguishedName(Cert_DistinguishedName * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_DistinguishedName_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_DistinguishedName(Cert_DistinguishedName * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_DistinguishedName_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_DistinguishedName(Cert_DistinguishedName * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_DistinguishedName_descriptor, ppcxt, pf, pstm); } extern const A2C_INTEGER_NATIVE Cert_ub_x121_address_length; typedef struct { @@ -465,6 +1037,19 @@ typedef struct { } Cert_postalCode__Type; extern const A2C_DESCRIPTOR Cert_postalCode__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_postalCode__Type(Cert_postalCode__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_postalCode__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_postalCode__Type(Cert_postalCode__Type * p) { return A2C_Free((PVOID) p, &Cert_postalCode__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_postalCode__Type(Cert_postalCode__Type * p) { return A2C_Init((PVOID) p, &Cert_postalCode__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_postalCode__Type(Cert_postalCode__Type * p) { return A2C_Release((PVOID) p, &Cert_postalCode__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_postalCode__Type(Cert_postalCode__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_postalCode__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_postalCode__Type(Cert_postalCode__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_postalCode__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_postalCode__Type(Cert_postalCode__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_postalCode__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_postalCode__Type(Cert_postalCode__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_postalCode__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_postalCode__Type(Cert_postalCode__Type * pDst, Cert_postalCode__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_postalCode__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_postalCode__Type(Cert_postalCode__Type const * pLeft, Cert_postalCode__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_postalCode__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_postalCode__Type(Cert_postalCode__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_postalCode__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_postalCode__Type(Cert_postalCode__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_postalCode__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_postalCode__Type(Cert_postalCode__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_postalCode__Type_descriptor, ppcxt, pf, pstm); } typedef struct { unsigned int optionalFields; @@ -482,14 +1067,27 @@ typedef struct { int countAllocated; Cert_TBSCertList__revokedCertificates_array * array; } revokedCertificates; - + /* Start Extension */ /* Extension Group version: 2 */ Cert_Extensions crlExtensions; - + A2C_EXTENSION _extension; } Cert_TBSCertList; extern const A2C_DESCRIPTOR Cert_TBSCertList_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_TBSCertList(Cert_TBSCertList ** p) { return A2C_Alloc((PVOID *) p, &Cert_TBSCertList_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_TBSCertList(Cert_TBSCertList * p) { return A2C_Free((PVOID) p, &Cert_TBSCertList_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_TBSCertList(Cert_TBSCertList * p) { return A2C_Init((PVOID) p, &Cert_TBSCertList_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_TBSCertList(Cert_TBSCertList * p) { return A2C_Release((PVOID) p, &Cert_TBSCertList_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_TBSCertList(Cert_TBSCertList const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_TBSCertList_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_TBSCertList(Cert_TBSCertList * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_TBSCertList_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_TBSCertList(Cert_TBSCertList const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_TBSCertList_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_TBSCertList(Cert_TBSCertList * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_TBSCertList_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_TBSCertList(Cert_TBSCertList * pDst, Cert_TBSCertList * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_TBSCertList_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_TBSCertList(Cert_TBSCertList const * pLeft, Cert_TBSCertList const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_TBSCertList_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_TBSCertList(Cert_TBSCertList * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_TBSCertList_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_TBSCertList(Cert_TBSCertList * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_TBSCertList_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_TBSCertList(Cert_TBSCertList * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_TBSCertList_descriptor, ppcxt, pf, pstm); } extern const A2C_INTEGER_NATIVE Cert_ub_title; extern const A2C_OBJECT_IDENTIFIER Cert_id_ad_caRepository; extern const A2C_INTEGER_NATIVE Cert_physicalDeliveryCountryName__id; @@ -512,6 +1110,19 @@ typedef struct { } Cert_CommonName; extern const A2C_DESCRIPTOR Cert_CommonName_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_CommonName(Cert_CommonName ** p) { return A2C_Alloc((PVOID *) p, &Cert_CommonName_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_CommonName(Cert_CommonName * p) { return A2C_Free((PVOID) p, &Cert_CommonName_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_CommonName(Cert_CommonName * p) { return A2C_Init((PVOID) p, &Cert_CommonName_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_CommonName(Cert_CommonName * p) { return A2C_Release((PVOID) p, &Cert_CommonName_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_CommonName(Cert_CommonName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_CommonName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_CommonName(Cert_CommonName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_CommonName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_CommonName(Cert_CommonName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_CommonName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_CommonName(Cert_CommonName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_CommonName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_CommonName(Cert_CommonName * pDst, Cert_CommonName * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_CommonName_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_CommonName(Cert_CommonName const * pLeft, Cert_CommonName const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_CommonName_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_CommonName(Cert_CommonName * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_CommonName_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_CommonName(Cert_CommonName * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_CommonName_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_CommonName(Cert_CommonName * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_CommonName_descriptor, ppcxt, pf, pstm); } extern const A2C_INTEGER_NATIVE Cert_ub_emailaddress_length; extern const A2C_INTEGER_NATIVE Cert_uniquePostalName__id; extern const A2C_INTEGER_NATIVE Cert_ub_domain_name_length; @@ -533,6 +1144,19 @@ typedef struct { } Cert_X520name; extern const A2C_DESCRIPTOR Cert_X520name_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_X520name(Cert_X520name ** p) { return A2C_Alloc((PVOID *) p, &Cert_X520name_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_X520name(Cert_X520name * p) { return A2C_Free((PVOID) p, &Cert_X520name_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_X520name(Cert_X520name * p) { return A2C_Init((PVOID) p, &Cert_X520name_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_X520name(Cert_X520name * p) { return A2C_Release((PVOID) p, &Cert_X520name_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_X520name(Cert_X520name const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_X520name_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_X520name(Cert_X520name * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_X520name_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_X520name(Cert_X520name const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_X520name_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_X520name(Cert_X520name * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_X520name_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_X520name(Cert_X520name * pDst, Cert_X520name * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_X520name_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_X520name(Cert_X520name const * pLeft, Cert_X520name const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_X520name_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_X520name(Cert_X520name * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_X520name_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_X520name(Cert_X520name * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_X520name_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_X520name(Cert_X520name * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_X520name_descriptor, ppcxt, pf, pstm); } extern const Cert_ATTRIBUTE Cert_x520name; extern const A2C_INTEGER_NATIVE Cert_localPostalAttributes__id; extern const A2C_INTEGER_NATIVE Cert_physicalDeliveryOrganizationName__id; @@ -554,11 +1178,37 @@ typedef struct { } Cert_x520Title__Type; extern const A2C_DESCRIPTOR Cert_x520Title__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_x520Title__Type(Cert_x520Title__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_x520Title__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_x520Title__Type(Cert_x520Title__Type * p) { return A2C_Free((PVOID) p, &Cert_x520Title__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_x520Title__Type(Cert_x520Title__Type * p) { return A2C_Init((PVOID) p, &Cert_x520Title__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_x520Title__Type(Cert_x520Title__Type * p) { return A2C_Release((PVOID) p, &Cert_x520Title__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_x520Title__Type(Cert_x520Title__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_x520Title__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_x520Title__Type(Cert_x520Title__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_x520Title__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_x520Title__Type(Cert_x520Title__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_x520Title__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_x520Title__Type(Cert_x520Title__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_x520Title__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_x520Title__Type(Cert_x520Title__Type * pDst, Cert_x520Title__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_x520Title__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_x520Title__Type(Cert_x520Title__Type const * pLeft, Cert_x520Title__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_x520Title__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_x520Title__Type(Cert_x520Title__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_x520Title__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_x520Title__Type(Cert_x520Title__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_x520Title__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_x520Title__Type(Cert_x520Title__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_x520Title__Type_descriptor, ppcxt, pf, pstm); } extern const Cert_ATTRIBUTE Cert_x520Title; typedef A2C_IA5_STRING Cert_emailAddress__Type; extern const A2C_DESCRIPTOR Cert_emailAddress__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_emailAddress__Type(Cert_emailAddress__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_emailAddress__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_emailAddress__Type(Cert_emailAddress__Type * p) { return A2C_Free((PVOID) p, &Cert_emailAddress__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_emailAddress__Type(Cert_emailAddress__Type * p) { return A2C_Init((PVOID) p, &Cert_emailAddress__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_emailAddress__Type(Cert_emailAddress__Type * p) { return A2C_Release((PVOID) p, &Cert_emailAddress__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_emailAddress__Type(Cert_emailAddress__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_emailAddress__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_emailAddress__Type(Cert_emailAddress__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_emailAddress__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_emailAddress__Type(Cert_emailAddress__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_emailAddress__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_emailAddress__Type(Cert_emailAddress__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_emailAddress__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_emailAddress__Type(Cert_emailAddress__Type * pDst, Cert_emailAddress__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_emailAddress__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_emailAddress__Type(Cert_emailAddress__Type const * pLeft, Cert_emailAddress__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_emailAddress__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_emailAddress__Type(Cert_emailAddress__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_emailAddress__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_emailAddress__Type(Cert_emailAddress__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_emailAddress__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_emailAddress__Type(Cert_emailAddress__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_emailAddress__Type_descriptor, ppcxt, pf, pstm); } extern const Cert_ATTRIBUTE Cert_emailAddress; extern const A2C_INTEGER_NATIVE Cert_teletexOrganizationalUnitNames__id; extern const A2C_OBJECT_IDENTIFIER Cert_id_qt_unotice; @@ -566,6 +1216,19 @@ extern const A2C_OBJECT_IDENTIFIER Cert_id_qt_unotice; typedef A2C_PRINTABLE_STRING Cert_x520SerialNumber__Type; extern const A2C_DESCRIPTOR Cert_x520SerialNumber__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_x520SerialNumber__Type(Cert_x520SerialNumber__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_x520SerialNumber__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_x520SerialNumber__Type(Cert_x520SerialNumber__Type * p) { return A2C_Free((PVOID) p, &Cert_x520SerialNumber__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_x520SerialNumber__Type(Cert_x520SerialNumber__Type * p) { return A2C_Init((PVOID) p, &Cert_x520SerialNumber__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_x520SerialNumber__Type(Cert_x520SerialNumber__Type * p) { return A2C_Release((PVOID) p, &Cert_x520SerialNumber__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_x520SerialNumber__Type(Cert_x520SerialNumber__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_x520SerialNumber__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_x520SerialNumber__Type(Cert_x520SerialNumber__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_x520SerialNumber__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_x520SerialNumber__Type(Cert_x520SerialNumber__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_x520SerialNumber__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_x520SerialNumber__Type(Cert_x520SerialNumber__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_x520SerialNumber__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_x520SerialNumber__Type(Cert_x520SerialNumber__Type * pDst, Cert_x520SerialNumber__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_x520SerialNumber__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_x520SerialNumber__Type(Cert_x520SerialNumber__Type const * pLeft, Cert_x520SerialNumber__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_x520SerialNumber__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_x520SerialNumber__Type(Cert_x520SerialNumber__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_x520SerialNumber__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_x520SerialNumber__Type(Cert_x520SerialNumber__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_x520SerialNumber__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_x520SerialNumber__Type(Cert_x520SerialNumber__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_x520SerialNumber__Type_descriptor, ppcxt, pf, pstm); } extern const Cert_ATTRIBUTE Cert_x520SerialNumber; extern const A2C_INTEGER_NATIVE Cert_ub_e163_4_number_length; extern const A2C_INTEGER_NATIVE Cert_ub_integer_options; @@ -586,6 +1249,19 @@ typedef struct { } Cert_physicalDeliveryCountryName__Type; extern const A2C_DESCRIPTOR Cert_physicalDeliveryCountryName__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_physicalDeliveryCountryName__Type(Cert_physicalDeliveryCountryName__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_physicalDeliveryCountryName__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_physicalDeliveryCountryName__Type(Cert_physicalDeliveryCountryName__Type * p) { return A2C_Free((PVOID) p, &Cert_physicalDeliveryCountryName__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_physicalDeliveryCountryName__Type(Cert_physicalDeliveryCountryName__Type * p) { return A2C_Init((PVOID) p, &Cert_physicalDeliveryCountryName__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_physicalDeliveryCountryName__Type(Cert_physicalDeliveryCountryName__Type * p) { return A2C_Release((PVOID) p, &Cert_physicalDeliveryCountryName__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_physicalDeliveryCountryName__Type(Cert_physicalDeliveryCountryName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_physicalDeliveryCountryName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_physicalDeliveryCountryName__Type(Cert_physicalDeliveryCountryName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_physicalDeliveryCountryName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_physicalDeliveryCountryName__Type(Cert_physicalDeliveryCountryName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_physicalDeliveryCountryName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_physicalDeliveryCountryName__Type(Cert_physicalDeliveryCountryName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_physicalDeliveryCountryName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_physicalDeliveryCountryName__Type(Cert_physicalDeliveryCountryName__Type * pDst, Cert_physicalDeliveryCountryName__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_physicalDeliveryCountryName__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_physicalDeliveryCountryName__Type(Cert_physicalDeliveryCountryName__Type const * pLeft, Cert_physicalDeliveryCountryName__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_physicalDeliveryCountryName__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_physicalDeliveryCountryName__Type(Cert_physicalDeliveryCountryName__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_physicalDeliveryCountryName__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_physicalDeliveryCountryName__Type(Cert_physicalDeliveryCountryName__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_physicalDeliveryCountryName__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_physicalDeliveryCountryName__Type(Cert_physicalDeliveryCountryName__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_physicalDeliveryCountryName__Type_descriptor, ppcxt, pf, pstm); } extern const Cert_EXTENSION_ATTRIBUTE Cert_physicalDeliveryCountryName; extern const Cert_ATTRIBUTE Cert_commonName; @@ -606,6 +1282,19 @@ typedef struct { } Cert_x520LocalityName__Type; extern const A2C_DESCRIPTOR Cert_x520LocalityName__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_x520LocalityName__Type(Cert_x520LocalityName__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_x520LocalityName__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_x520LocalityName__Type(Cert_x520LocalityName__Type * p) { return A2C_Free((PVOID) p, &Cert_x520LocalityName__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_x520LocalityName__Type(Cert_x520LocalityName__Type * p) { return A2C_Init((PVOID) p, &Cert_x520LocalityName__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_x520LocalityName__Type(Cert_x520LocalityName__Type * p) { return A2C_Release((PVOID) p, &Cert_x520LocalityName__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_x520LocalityName__Type(Cert_x520LocalityName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_x520LocalityName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_x520LocalityName__Type(Cert_x520LocalityName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_x520LocalityName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_x520LocalityName__Type(Cert_x520LocalityName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_x520LocalityName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_x520LocalityName__Type(Cert_x520LocalityName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_x520LocalityName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_x520LocalityName__Type(Cert_x520LocalityName__Type * pDst, Cert_x520LocalityName__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_x520LocalityName__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_x520LocalityName__Type(Cert_x520LocalityName__Type const * pLeft, Cert_x520LocalityName__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_x520LocalityName__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_x520LocalityName__Type(Cert_x520LocalityName__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_x520LocalityName__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_x520LocalityName__Type(Cert_x520LocalityName__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_x520LocalityName__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_x520LocalityName__Type(Cert_x520LocalityName__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_x520LocalityName__Type_descriptor, ppcxt, pf, pstm); } extern const Cert_ATTRIBUTE Cert_x520LocalityName; typedef struct { @@ -625,6 +1314,19 @@ typedef struct { } Cert_x520StateOrProvinceName__Type; extern const A2C_DESCRIPTOR Cert_x520StateOrProvinceName__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_x520StateOrProvinceName__Type(Cert_x520StateOrProvinceName__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_x520StateOrProvinceName__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_x520StateOrProvinceName__Type(Cert_x520StateOrProvinceName__Type * p) { return A2C_Free((PVOID) p, &Cert_x520StateOrProvinceName__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_x520StateOrProvinceName__Type(Cert_x520StateOrProvinceName__Type * p) { return A2C_Init((PVOID) p, &Cert_x520StateOrProvinceName__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_x520StateOrProvinceName__Type(Cert_x520StateOrProvinceName__Type * p) { return A2C_Release((PVOID) p, &Cert_x520StateOrProvinceName__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_x520StateOrProvinceName__Type(Cert_x520StateOrProvinceName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_x520StateOrProvinceName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_x520StateOrProvinceName__Type(Cert_x520StateOrProvinceName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_x520StateOrProvinceName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_x520StateOrProvinceName__Type(Cert_x520StateOrProvinceName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_x520StateOrProvinceName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_x520StateOrProvinceName__Type(Cert_x520StateOrProvinceName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_x520StateOrProvinceName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_x520StateOrProvinceName__Type(Cert_x520StateOrProvinceName__Type * pDst, Cert_x520StateOrProvinceName__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_x520StateOrProvinceName__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_x520StateOrProvinceName__Type(Cert_x520StateOrProvinceName__Type const * pLeft, Cert_x520StateOrProvinceName__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_x520StateOrProvinceName__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_x520StateOrProvinceName__Type(Cert_x520StateOrProvinceName__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_x520StateOrProvinceName__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_x520StateOrProvinceName__Type(Cert_x520StateOrProvinceName__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_x520StateOrProvinceName__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_x520StateOrProvinceName__Type(Cert_x520StateOrProvinceName__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_x520StateOrProvinceName__Type_descriptor, ppcxt, pf, pstm); } extern const Cert_ATTRIBUTE Cert_x520StateOrProvinceName; typedef struct { @@ -644,6 +1346,19 @@ typedef struct { } Cert_x520OrganizationName__Type; extern const A2C_DESCRIPTOR Cert_x520OrganizationName__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_x520OrganizationName__Type(Cert_x520OrganizationName__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_x520OrganizationName__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_x520OrganizationName__Type(Cert_x520OrganizationName__Type * p) { return A2C_Free((PVOID) p, &Cert_x520OrganizationName__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_x520OrganizationName__Type(Cert_x520OrganizationName__Type * p) { return A2C_Init((PVOID) p, &Cert_x520OrganizationName__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_x520OrganizationName__Type(Cert_x520OrganizationName__Type * p) { return A2C_Release((PVOID) p, &Cert_x520OrganizationName__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_x520OrganizationName__Type(Cert_x520OrganizationName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_x520OrganizationName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_x520OrganizationName__Type(Cert_x520OrganizationName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_x520OrganizationName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_x520OrganizationName__Type(Cert_x520OrganizationName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_x520OrganizationName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_x520OrganizationName__Type(Cert_x520OrganizationName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_x520OrganizationName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_x520OrganizationName__Type(Cert_x520OrganizationName__Type * pDst, Cert_x520OrganizationName__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_x520OrganizationName__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_x520OrganizationName__Type(Cert_x520OrganizationName__Type const * pLeft, Cert_x520OrganizationName__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_x520OrganizationName__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_x520OrganizationName__Type(Cert_x520OrganizationName__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_x520OrganizationName__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_x520OrganizationName__Type(Cert_x520OrganizationName__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_x520OrganizationName__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_x520OrganizationName__Type(Cert_x520OrganizationName__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_x520OrganizationName__Type_descriptor, ppcxt, pf, pstm); } extern const Cert_ATTRIBUTE Cert_x520OrganizationName; typedef struct { @@ -663,6 +1378,19 @@ typedef struct { } Cert_x520OrganizationalUnitName__Type; extern const A2C_DESCRIPTOR Cert_x520OrganizationalUnitName__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_x520OrganizationalUnitName__Type(Cert_x520OrganizationalUnitName__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_x520OrganizationalUnitName__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_x520OrganizationalUnitName__Type(Cert_x520OrganizationalUnitName__Type * p) { return A2C_Free((PVOID) p, &Cert_x520OrganizationalUnitName__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_x520OrganizationalUnitName__Type(Cert_x520OrganizationalUnitName__Type * p) { return A2C_Init((PVOID) p, &Cert_x520OrganizationalUnitName__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_x520OrganizationalUnitName__Type(Cert_x520OrganizationalUnitName__Type * p) { return A2C_Release((PVOID) p, &Cert_x520OrganizationalUnitName__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_x520OrganizationalUnitName__Type(Cert_x520OrganizationalUnitName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_x520OrganizationalUnitName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_x520OrganizationalUnitName__Type(Cert_x520OrganizationalUnitName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_x520OrganizationalUnitName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_x520OrganizationalUnitName__Type(Cert_x520OrganizationalUnitName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_x520OrganizationalUnitName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_x520OrganizationalUnitName__Type(Cert_x520OrganizationalUnitName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_x520OrganizationalUnitName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_x520OrganizationalUnitName__Type(Cert_x520OrganizationalUnitName__Type * pDst, Cert_x520OrganizationalUnitName__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_x520OrganizationalUnitName__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_x520OrganizationalUnitName__Type(Cert_x520OrganizationalUnitName__Type const * pLeft, Cert_x520OrganizationalUnitName__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_x520OrganizationalUnitName__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_x520OrganizationalUnitName__Type(Cert_x520OrganizationalUnitName__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_x520OrganizationalUnitName__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_x520OrganizationalUnitName__Type(Cert_x520OrganizationalUnitName__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_x520OrganizationalUnitName__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_x520OrganizationalUnitName__Type(Cert_x520OrganizationalUnitName__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_x520OrganizationalUnitName__Type_descriptor, ppcxt, pf, pstm); } extern const Cert_ATTRIBUTE Cert_x520OrganizationalUnitName; extern const Cert_ATTRIBUTE Cert_x520countryName; @@ -683,6 +1411,19 @@ typedef struct { } Cert_x520Pseudonym__Type; extern const A2C_DESCRIPTOR Cert_x520Pseudonym__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_x520Pseudonym__Type(Cert_x520Pseudonym__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_x520Pseudonym__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_x520Pseudonym__Type(Cert_x520Pseudonym__Type * p) { return A2C_Free((PVOID) p, &Cert_x520Pseudonym__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_x520Pseudonym__Type(Cert_x520Pseudonym__Type * p) { return A2C_Init((PVOID) p, &Cert_x520Pseudonym__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_x520Pseudonym__Type(Cert_x520Pseudonym__Type * p) { return A2C_Release((PVOID) p, &Cert_x520Pseudonym__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_x520Pseudonym__Type(Cert_x520Pseudonym__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_x520Pseudonym__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_x520Pseudonym__Type(Cert_x520Pseudonym__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_x520Pseudonym__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_x520Pseudonym__Type(Cert_x520Pseudonym__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_x520Pseudonym__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_x520Pseudonym__Type(Cert_x520Pseudonym__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_x520Pseudonym__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_x520Pseudonym__Type(Cert_x520Pseudonym__Type * pDst, Cert_x520Pseudonym__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_x520Pseudonym__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_x520Pseudonym__Type(Cert_x520Pseudonym__Type const * pLeft, Cert_x520Pseudonym__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_x520Pseudonym__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_x520Pseudonym__Type(Cert_x520Pseudonym__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_x520Pseudonym__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_x520Pseudonym__Type(Cert_x520Pseudonym__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_x520Pseudonym__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_x520Pseudonym__Type(Cert_x520Pseudonym__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_x520Pseudonym__Type_descriptor, ppcxt, pf, pstm); } extern const Cert_ATTRIBUTE Cert_x520Pseudonym; extern const Cert_ATTRIBUTE Cert_domainComponent; @@ -696,6 +1437,19 @@ typedef struct { } Cert_Certificate; extern const A2C_DESCRIPTOR Cert_Certificate_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_Certificate(Cert_Certificate ** p) { return A2C_Alloc((PVOID *) p, &Cert_Certificate_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_Certificate(Cert_Certificate * p) { return A2C_Free((PVOID) p, &Cert_Certificate_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_Certificate(Cert_Certificate * p) { return A2C_Init((PVOID) p, &Cert_Certificate_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_Certificate(Cert_Certificate * p) { return A2C_Release((PVOID) p, &Cert_Certificate_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_Certificate(Cert_Certificate const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_Certificate_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_Certificate(Cert_Certificate * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_Certificate_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_Certificate(Cert_Certificate const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_Certificate_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_Certificate(Cert_Certificate * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_Certificate_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_Certificate(Cert_Certificate * pDst, Cert_Certificate * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_Certificate_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_Certificate(Cert_Certificate const * pLeft, Cert_Certificate const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_Certificate_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_Certificate(Cert_Certificate * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_Certificate_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_Certificate(Cert_Certificate * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_Certificate_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_Certificate(Cert_Certificate * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_Certificate_descriptor, ppcxt, pf, pstm); } extern const Cert_AttributeType Cert_id_at_organizationName; extern const A2C_OBJECT_IDENTIFIER Cert_id_kp; extern const A2C_OBJECT_IDENTIFIER Cert_id_ad_caIssuers; @@ -719,6 +1473,19 @@ extern const Cert_AttributeType Cert_id_at_name; typedef A2C_TELETEX_STRING Cert_teletexOrganizationName__Type; extern const A2C_DESCRIPTOR Cert_teletexOrganizationName__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_teletexOrganizationName__Type(Cert_teletexOrganizationName__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_teletexOrganizationName__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_teletexOrganizationName__Type(Cert_teletexOrganizationName__Type * p) { return A2C_Free((PVOID) p, &Cert_teletexOrganizationName__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_teletexOrganizationName__Type(Cert_teletexOrganizationName__Type * p) { return A2C_Init((PVOID) p, &Cert_teletexOrganizationName__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_teletexOrganizationName__Type(Cert_teletexOrganizationName__Type * p) { return A2C_Release((PVOID) p, &Cert_teletexOrganizationName__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_teletexOrganizationName__Type(Cert_teletexOrganizationName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_teletexOrganizationName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_teletexOrganizationName__Type(Cert_teletexOrganizationName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_teletexOrganizationName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_teletexOrganizationName__Type(Cert_teletexOrganizationName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_teletexOrganizationName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_teletexOrganizationName__Type(Cert_teletexOrganizationName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_teletexOrganizationName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_teletexOrganizationName__Type(Cert_teletexOrganizationName__Type * pDst, Cert_teletexOrganizationName__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_teletexOrganizationName__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_teletexOrganizationName__Type(Cert_teletexOrganizationName__Type const * pLeft, Cert_teletexOrganizationName__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_teletexOrganizationName__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_teletexOrganizationName__Type(Cert_teletexOrganizationName__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_teletexOrganizationName__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_teletexOrganizationName__Type(Cert_teletexOrganizationName__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_teletexOrganizationName__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_teletexOrganizationName__Type(Cert_teletexOrganizationName__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_teletexOrganizationName__Type_descriptor, ppcxt, pf, pstm); } extern const Cert_EXTENSION_ATTRIBUTE Cert_teletexOrganizationName; extern const Cert_AttributeType Cert_id_at_commonName; extern const A2C_INTEGER_NATIVE Cert_streetAddress__id; @@ -729,6 +1496,19 @@ extern const A2C_INTEGER_NATIVE Cert_extendedNetworkAddress__id; typedef A2C_PRINTABLE_STRING Cert_pDSName__Type; extern const A2C_DESCRIPTOR Cert_pDSName__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_pDSName__Type(Cert_pDSName__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_pDSName__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_pDSName__Type(Cert_pDSName__Type * p) { return A2C_Free((PVOID) p, &Cert_pDSName__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_pDSName__Type(Cert_pDSName__Type * p) { return A2C_Init((PVOID) p, &Cert_pDSName__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_pDSName__Type(Cert_pDSName__Type * p) { return A2C_Release((PVOID) p, &Cert_pDSName__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_pDSName__Type(Cert_pDSName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_pDSName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_pDSName__Type(Cert_pDSName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_pDSName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_pDSName__Type(Cert_pDSName__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_pDSName__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_pDSName__Type(Cert_pDSName__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_pDSName__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_pDSName__Type(Cert_pDSName__Type * pDst, Cert_pDSName__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_pDSName__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_pDSName__Type(Cert_pDSName__Type const * pLeft, Cert_pDSName__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_pDSName__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_pDSName__Type(Cert_pDSName__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_pDSName__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_pDSName__Type(Cert_pDSName__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_pDSName__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_pDSName__Type(Cert_pDSName__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_pDSName__Type_descriptor, ppcxt, pf, pstm); } extern const Cert_AttributeType Cert_id_at_title; extern const A2C_INTEGER_NATIVE Cert_pDSName__id; extern const A2C_INTEGER_NATIVE Cert_ub_pseudonym; @@ -750,6 +1530,19 @@ typedef struct { } Cert_PresentationAddress; extern const A2C_DESCRIPTOR Cert_PresentationAddress_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_PresentationAddress(Cert_PresentationAddress ** p) { return A2C_Alloc((PVOID *) p, &Cert_PresentationAddress_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_PresentationAddress(Cert_PresentationAddress * p) { return A2C_Free((PVOID) p, &Cert_PresentationAddress_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_PresentationAddress(Cert_PresentationAddress * p) { return A2C_Init((PVOID) p, &Cert_PresentationAddress_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_PresentationAddress(Cert_PresentationAddress * p) { return A2C_Release((PVOID) p, &Cert_PresentationAddress_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_PresentationAddress(Cert_PresentationAddress const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_PresentationAddress_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_PresentationAddress(Cert_PresentationAddress * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_PresentationAddress_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_PresentationAddress(Cert_PresentationAddress const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_PresentationAddress_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_PresentationAddress(Cert_PresentationAddress * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_PresentationAddress_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_PresentationAddress(Cert_PresentationAddress * pDst, Cert_PresentationAddress * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_PresentationAddress_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_PresentationAddress(Cert_PresentationAddress const * pLeft, Cert_PresentationAddress const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_PresentationAddress_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_PresentationAddress(Cert_PresentationAddress * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_PresentationAddress_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_PresentationAddress(Cert_PresentationAddress * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_PresentationAddress_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_PresentationAddress(Cert_PresentationAddress * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_PresentationAddress_descriptor, ppcxt, pf, pstm); } extern const Cert_AttributeType Cert_id_at_countryName; extern const A2C_INTEGER_NATIVE Cert_ub_organizational_units; extern const Cert_AttributeType Cert_id_at_stateOrProvinceName; @@ -767,6 +1560,19 @@ typedef struct { } Cert_CertificateList; extern const A2C_DESCRIPTOR Cert_CertificateList_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_CertificateList(Cert_CertificateList ** p) { return A2C_Alloc((PVOID *) p, &Cert_CertificateList_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_CertificateList(Cert_CertificateList * p) { return A2C_Free((PVOID) p, &Cert_CertificateList_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_CertificateList(Cert_CertificateList * p) { return A2C_Init((PVOID) p, &Cert_CertificateList_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_CertificateList(Cert_CertificateList * p) { return A2C_Release((PVOID) p, &Cert_CertificateList_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_CertificateList(Cert_CertificateList const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_CertificateList_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_CertificateList(Cert_CertificateList * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_CertificateList_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_CertificateList(Cert_CertificateList const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_CertificateList_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_CertificateList(Cert_CertificateList * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_CertificateList_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_CertificateList(Cert_CertificateList * pDst, Cert_CertificateList * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_CertificateList_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_CertificateList(Cert_CertificateList const * pLeft, Cert_CertificateList const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_CertificateList_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_CertificateList(Cert_CertificateList * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_CertificateList_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_CertificateList(Cert_CertificateList * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_CertificateList_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_CertificateList(Cert_CertificateList * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_CertificateList_descriptor, ppcxt, pf, pstm); } extern const Cert_AttributeType Cert_id_at_dnQualifier; extern const A2C_INTEGER_NATIVE Cert_teletexOrganizationName__id; extern const Cert_EXTENSION_ATTRIBUTE Cert_postalCode; @@ -780,6 +1586,19 @@ extern const A2C_INTEGER_NATIVE Cert_ub_surname_length; typedef A2C_INTEGER_NATIVE Cert_terminalType__Type; extern const A2C_DESCRIPTOR Cert_terminalType__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_terminalType__Type(Cert_terminalType__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_terminalType__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_terminalType__Type(Cert_terminalType__Type * p) { return A2C_Free((PVOID) p, &Cert_terminalType__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_terminalType__Type(Cert_terminalType__Type * p) { return A2C_Init((PVOID) p, &Cert_terminalType__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_terminalType__Type(Cert_terminalType__Type * p) { return A2C_Release((PVOID) p, &Cert_terminalType__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_terminalType__Type(Cert_terminalType__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_terminalType__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_terminalType__Type(Cert_terminalType__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_terminalType__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_terminalType__Type(Cert_terminalType__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_terminalType__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_terminalType__Type(Cert_terminalType__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_terminalType__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_terminalType__Type(Cert_terminalType__Type * pDst, Cert_terminalType__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_terminalType__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_terminalType__Type(Cert_terminalType__Type const * pLeft, Cert_terminalType__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_terminalType__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_terminalType__Type(Cert_terminalType__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_terminalType__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_terminalType__Type(Cert_terminalType__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_terminalType__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_terminalType__Type(Cert_terminalType__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_terminalType__Type_descriptor, ppcxt, pf, pstm); } extern const Cert_EXTENSION_ATTRIBUTE Cert_terminalType; extern const A2C_INTEGER_NATIVE Cert_ub_pds_name_length; extern const A2C_INTEGER_NATIVE Cert_ub_e163_4_sub_address_length; @@ -816,6 +1635,19 @@ typedef struct { } Cert_extendedNetworkAddress__Type; extern const A2C_DESCRIPTOR Cert_extendedNetworkAddress__Type_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_extendedNetworkAddress__Type(Cert_extendedNetworkAddress__Type ** p) { return A2C_Alloc((PVOID *) p, &Cert_extendedNetworkAddress__Type_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_extendedNetworkAddress__Type(Cert_extendedNetworkAddress__Type * p) { return A2C_Free((PVOID) p, &Cert_extendedNetworkAddress__Type_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_extendedNetworkAddress__Type(Cert_extendedNetworkAddress__Type * p) { return A2C_Init((PVOID) p, &Cert_extendedNetworkAddress__Type_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_extendedNetworkAddress__Type(Cert_extendedNetworkAddress__Type * p) { return A2C_Release((PVOID) p, &Cert_extendedNetworkAddress__Type_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_extendedNetworkAddress__Type(Cert_extendedNetworkAddress__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_extendedNetworkAddress__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_extendedNetworkAddress__Type(Cert_extendedNetworkAddress__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_extendedNetworkAddress__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_extendedNetworkAddress__Type(Cert_extendedNetworkAddress__Type const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_extendedNetworkAddress__Type_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_extendedNetworkAddress__Type(Cert_extendedNetworkAddress__Type * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_extendedNetworkAddress__Type_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_extendedNetworkAddress__Type(Cert_extendedNetworkAddress__Type * pDst, Cert_extendedNetworkAddress__Type * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_extendedNetworkAddress__Type_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_extendedNetworkAddress__Type(Cert_extendedNetworkAddress__Type const * pLeft, Cert_extendedNetworkAddress__Type const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_extendedNetworkAddress__Type_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_extendedNetworkAddress__Type(Cert_extendedNetworkAddress__Type * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_extendedNetworkAddress__Type_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_extendedNetworkAddress__Type(Cert_extendedNetworkAddress__Type * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_extendedNetworkAddress__Type_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_extendedNetworkAddress__Type(Cert_extendedNetworkAddress__Type * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_extendedNetworkAddress__Type_descriptor, ppcxt, pf, pstm); } extern const A2C_OBJECT_IDENTIFIER Cert_id_pe; extern const Cert_EXTENSION_ATTRIBUTE Cert_teletexCommonName; @@ -829,6 +1661,19 @@ typedef struct { } Cert_Attribute; extern const A2C_DESCRIPTOR Cert_Attribute_descriptor; +static __inline A2C_ERROR A2C_Alloc_Cert_Attribute(Cert_Attribute ** p) { return A2C_Alloc((PVOID *) p, &Cert_Attribute_descriptor); } +static __inline A2C_ERROR A2C_Free_Cert_Attribute(Cert_Attribute * p) { return A2C_Free((PVOID) p, &Cert_Attribute_descriptor); } +static __inline A2C_ERROR A2C_Init_Cert_Attribute(Cert_Attribute * p) { return A2C_Init((PVOID) p, &Cert_Attribute_descriptor); } +static __inline A2C_ERROR A2C_Release_Cert_Attribute(Cert_Attribute * p) { return A2C_Release((PVOID) p, &Cert_Attribute_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_Cert_Attribute(Cert_Attribute const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &Cert_Attribute_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_Cert_Attribute(Cert_Attribute * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_Attribute_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_Cert_Attribute(Cert_Attribute const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &Cert_Attribute_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_Cert_Attribute(Cert_Attribute * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &Cert_Attribute_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_Cert_Attribute(Cert_Attribute * pDst, Cert_Attribute * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &Cert_Attribute_descriptor); } +static __inline A2C_ERROR A2C_Compare_Cert_Attribute(Cert_Attribute const * pLeft, Cert_Attribute const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &Cert_Attribute_descriptor); } +static __inline A2C_ERROR A2C_Print_Cert_Attribute(Cert_Attribute * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &Cert_Attribute_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_Cert_Attribute(Cert_Attribute * p, int * pf) { return A2C_Validate((PVOID) p, &Cert_Attribute_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_Cert_Attribute(Cert_Attribute * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &Cert_Attribute_descriptor, ppcxt, pf, pstm); } extern const Cert_EXTENSION_ATTRIBUTE Cert_extendedNetworkAddress; extern const Cert_EXTENSION_ATTRIBUTE Cert_streetAddress; extern const Cert_EXTENSION_ATTRIBUTE Cert_physicalDeliveryOfficeName; @@ -874,6 +1719,19 @@ typedef struct { } CertImpl_EDIPartyName; extern const A2C_DESCRIPTOR CertImpl_EDIPartyName_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_EDIPartyName(CertImpl_EDIPartyName ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_EDIPartyName_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_EDIPartyName(CertImpl_EDIPartyName * p) { return A2C_Free((PVOID) p, &CertImpl_EDIPartyName_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_EDIPartyName(CertImpl_EDIPartyName * p) { return A2C_Init((PVOID) p, &CertImpl_EDIPartyName_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_EDIPartyName(CertImpl_EDIPartyName * p) { return A2C_Release((PVOID) p, &CertImpl_EDIPartyName_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_EDIPartyName(CertImpl_EDIPartyName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_EDIPartyName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_EDIPartyName(CertImpl_EDIPartyName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_EDIPartyName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_EDIPartyName(CertImpl_EDIPartyName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_EDIPartyName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_EDIPartyName(CertImpl_EDIPartyName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_EDIPartyName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_EDIPartyName(CertImpl_EDIPartyName * pDst, CertImpl_EDIPartyName * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_EDIPartyName_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_EDIPartyName(CertImpl_EDIPartyName const * pLeft, CertImpl_EDIPartyName const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_EDIPartyName_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_EDIPartyName(CertImpl_EDIPartyName * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_EDIPartyName_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_EDIPartyName(CertImpl_EDIPartyName * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_EDIPartyName_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_EDIPartyName(CertImpl_EDIPartyName * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_EDIPartyName_descriptor, ppcxt, pf, pstm); } typedef struct { int index; @@ -903,6 +1761,19 @@ typedef struct { } CertImpl_GeneralName; extern const A2C_DESCRIPTOR CertImpl_GeneralName_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_GeneralName(CertImpl_GeneralName ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_GeneralName_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_GeneralName(CertImpl_GeneralName * p) { return A2C_Free((PVOID) p, &CertImpl_GeneralName_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_GeneralName(CertImpl_GeneralName * p) { return A2C_Init((PVOID) p, &CertImpl_GeneralName_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_GeneralName(CertImpl_GeneralName * p) { return A2C_Release((PVOID) p, &CertImpl_GeneralName_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_GeneralName(CertImpl_GeneralName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_GeneralName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_GeneralName(CertImpl_GeneralName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_GeneralName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_GeneralName(CertImpl_GeneralName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_GeneralName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_GeneralName(CertImpl_GeneralName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_GeneralName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_GeneralName(CertImpl_GeneralName * pDst, CertImpl_GeneralName * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_GeneralName_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_GeneralName(CertImpl_GeneralName const * pLeft, CertImpl_GeneralName const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_GeneralName_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_GeneralName(CertImpl_GeneralName * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_GeneralName_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_GeneralName(CertImpl_GeneralName * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_GeneralName_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_GeneralName(CertImpl_GeneralName * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_GeneralName_descriptor, ppcxt, pf, pstm); } typedef struct { A2C_OBJECT_IDENTIFIER accessMethod; @@ -910,6 +1781,19 @@ typedef struct { } CertImpl_AccessDescription; extern const A2C_DESCRIPTOR CertImpl_AccessDescription_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_AccessDescription(CertImpl_AccessDescription ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_AccessDescription_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_AccessDescription(CertImpl_AccessDescription * p) { return A2C_Free((PVOID) p, &CertImpl_AccessDescription_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_AccessDescription(CertImpl_AccessDescription * p) { return A2C_Init((PVOID) p, &CertImpl_AccessDescription_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_AccessDescription(CertImpl_AccessDescription * p) { return A2C_Release((PVOID) p, &CertImpl_AccessDescription_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_AccessDescription(CertImpl_AccessDescription const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_AccessDescription_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_AccessDescription(CertImpl_AccessDescription * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_AccessDescription_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_AccessDescription(CertImpl_AccessDescription const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_AccessDescription_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_AccessDescription(CertImpl_AccessDescription * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_AccessDescription_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_AccessDescription(CertImpl_AccessDescription * pDst, CertImpl_AccessDescription * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_AccessDescription_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_AccessDescription(CertImpl_AccessDescription const * pLeft, CertImpl_AccessDescription const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_AccessDescription_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_AccessDescription(CertImpl_AccessDescription * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_AccessDescription_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_AccessDescription(CertImpl_AccessDescription * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_AccessDescription_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_AccessDescription(CertImpl_AccessDescription * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_AccessDescription_descriptor, ppcxt, pf, pstm); } typedef struct { int count; @@ -918,11 +1802,37 @@ typedef struct { } CertImpl_AuthorityInfoAccessSyntax; extern const A2C_DESCRIPTOR CertImpl_AuthorityInfoAccessSyntax_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_AuthorityInfoAccessSyntax(CertImpl_AuthorityInfoAccessSyntax ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_AuthorityInfoAccessSyntax_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_AuthorityInfoAccessSyntax(CertImpl_AuthorityInfoAccessSyntax * p) { return A2C_Free((PVOID) p, &CertImpl_AuthorityInfoAccessSyntax_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_AuthorityInfoAccessSyntax(CertImpl_AuthorityInfoAccessSyntax * p) { return A2C_Init((PVOID) p, &CertImpl_AuthorityInfoAccessSyntax_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_AuthorityInfoAccessSyntax(CertImpl_AuthorityInfoAccessSyntax * p) { return A2C_Release((PVOID) p, &CertImpl_AuthorityInfoAccessSyntax_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_AuthorityInfoAccessSyntax(CertImpl_AuthorityInfoAccessSyntax const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_AuthorityInfoAccessSyntax_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_AuthorityInfoAccessSyntax(CertImpl_AuthorityInfoAccessSyntax * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_AuthorityInfoAccessSyntax_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_AuthorityInfoAccessSyntax(CertImpl_AuthorityInfoAccessSyntax const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_AuthorityInfoAccessSyntax_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_AuthorityInfoAccessSyntax(CertImpl_AuthorityInfoAccessSyntax * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_AuthorityInfoAccessSyntax_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_AuthorityInfoAccessSyntax(CertImpl_AuthorityInfoAccessSyntax * pDst, CertImpl_AuthorityInfoAccessSyntax * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_AuthorityInfoAccessSyntax_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_AuthorityInfoAccessSyntax(CertImpl_AuthorityInfoAccessSyntax const * pLeft, CertImpl_AuthorityInfoAccessSyntax const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_AuthorityInfoAccessSyntax_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_AuthorityInfoAccessSyntax(CertImpl_AuthorityInfoAccessSyntax * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_AuthorityInfoAccessSyntax_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_AuthorityInfoAccessSyntax(CertImpl_AuthorityInfoAccessSyntax * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_AuthorityInfoAccessSyntax_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_AuthorityInfoAccessSyntax(CertImpl_AuthorityInfoAccessSyntax * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_AuthorityInfoAccessSyntax_descriptor, ppcxt, pf, pstm); } extern const Cert_EXTENSION CertImpl_ext_AuthorityInfoAccessSyntax; typedef A2C_OBJECT_IDENTIFIER CertImpl_KeyPurposeId; extern const A2C_DESCRIPTOR CertImpl_KeyPurposeId_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_KeyPurposeId(CertImpl_KeyPurposeId ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_KeyPurposeId_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_KeyPurposeId(CertImpl_KeyPurposeId * p) { return A2C_Free((PVOID) p, &CertImpl_KeyPurposeId_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_KeyPurposeId(CertImpl_KeyPurposeId * p) { return A2C_Init((PVOID) p, &CertImpl_KeyPurposeId_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_KeyPurposeId(CertImpl_KeyPurposeId * p) { return A2C_Release((PVOID) p, &CertImpl_KeyPurposeId_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_KeyPurposeId(CertImpl_KeyPurposeId const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_KeyPurposeId_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_KeyPurposeId(CertImpl_KeyPurposeId * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_KeyPurposeId_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_KeyPurposeId(CertImpl_KeyPurposeId const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_KeyPurposeId_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_KeyPurposeId(CertImpl_KeyPurposeId * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_KeyPurposeId_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_KeyPurposeId(CertImpl_KeyPurposeId * pDst, CertImpl_KeyPurposeId * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_KeyPurposeId_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_KeyPurposeId(CertImpl_KeyPurposeId const * pLeft, CertImpl_KeyPurposeId const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_KeyPurposeId_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_KeyPurposeId(CertImpl_KeyPurposeId * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_KeyPurposeId_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_KeyPurposeId(CertImpl_KeyPurposeId * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_KeyPurposeId_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_KeyPurposeId(CertImpl_KeyPurposeId * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_KeyPurposeId_descriptor, ppcxt, pf, pstm); } typedef struct { int count; @@ -931,6 +1841,19 @@ typedef struct { } CertImpl_ExtKeyUsageSyntax; extern const A2C_DESCRIPTOR CertImpl_ExtKeyUsageSyntax_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_ExtKeyUsageSyntax(CertImpl_ExtKeyUsageSyntax ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_ExtKeyUsageSyntax_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_ExtKeyUsageSyntax(CertImpl_ExtKeyUsageSyntax * p) { return A2C_Free((PVOID) p, &CertImpl_ExtKeyUsageSyntax_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_ExtKeyUsageSyntax(CertImpl_ExtKeyUsageSyntax * p) { return A2C_Init((PVOID) p, &CertImpl_ExtKeyUsageSyntax_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_ExtKeyUsageSyntax(CertImpl_ExtKeyUsageSyntax * p) { return A2C_Release((PVOID) p, &CertImpl_ExtKeyUsageSyntax_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_ExtKeyUsageSyntax(CertImpl_ExtKeyUsageSyntax const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_ExtKeyUsageSyntax_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_ExtKeyUsageSyntax(CertImpl_ExtKeyUsageSyntax * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_ExtKeyUsageSyntax_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_ExtKeyUsageSyntax(CertImpl_ExtKeyUsageSyntax const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_ExtKeyUsageSyntax_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_ExtKeyUsageSyntax(CertImpl_ExtKeyUsageSyntax * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_ExtKeyUsageSyntax_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_ExtKeyUsageSyntax(CertImpl_ExtKeyUsageSyntax * pDst, CertImpl_ExtKeyUsageSyntax * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_ExtKeyUsageSyntax_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_ExtKeyUsageSyntax(CertImpl_ExtKeyUsageSyntax const * pLeft, CertImpl_ExtKeyUsageSyntax const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_ExtKeyUsageSyntax_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_ExtKeyUsageSyntax(CertImpl_ExtKeyUsageSyntax * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_ExtKeyUsageSyntax_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_ExtKeyUsageSyntax(CertImpl_ExtKeyUsageSyntax * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_ExtKeyUsageSyntax_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_ExtKeyUsageSyntax(CertImpl_ExtKeyUsageSyntax * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_ExtKeyUsageSyntax_descriptor, ppcxt, pf, pstm); } typedef struct { int count; @@ -939,6 +1862,19 @@ typedef struct { } CertImpl_GeneralNames; extern const A2C_DESCRIPTOR CertImpl_GeneralNames_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_GeneralNames(CertImpl_GeneralNames ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_GeneralNames_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_GeneralNames(CertImpl_GeneralNames * p) { return A2C_Free((PVOID) p, &CertImpl_GeneralNames_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_GeneralNames(CertImpl_GeneralNames * p) { return A2C_Init((PVOID) p, &CertImpl_GeneralNames_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_GeneralNames(CertImpl_GeneralNames * p) { return A2C_Release((PVOID) p, &CertImpl_GeneralNames_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_GeneralNames(CertImpl_GeneralNames const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_GeneralNames_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_GeneralNames(CertImpl_GeneralNames * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_GeneralNames_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_GeneralNames(CertImpl_GeneralNames const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_GeneralNames_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_GeneralNames(CertImpl_GeneralNames * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_GeneralNames_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_GeneralNames(CertImpl_GeneralNames * pDst, CertImpl_GeneralNames * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_GeneralNames_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_GeneralNames(CertImpl_GeneralNames const * pLeft, CertImpl_GeneralNames const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_GeneralNames_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_GeneralNames(CertImpl_GeneralNames * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_GeneralNames_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_GeneralNames(CertImpl_GeneralNames * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_GeneralNames_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_GeneralNames(CertImpl_GeneralNames * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_GeneralNames_descriptor, ppcxt, pf, pstm); } typedef struct { int index; @@ -951,10 +1887,36 @@ typedef struct { } CertImpl_DistributionPointName; extern const A2C_DESCRIPTOR CertImpl_DistributionPointName_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_DistributionPointName(CertImpl_DistributionPointName ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_DistributionPointName_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_DistributionPointName(CertImpl_DistributionPointName * p) { return A2C_Free((PVOID) p, &CertImpl_DistributionPointName_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_DistributionPointName(CertImpl_DistributionPointName * p) { return A2C_Init((PVOID) p, &CertImpl_DistributionPointName_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_DistributionPointName(CertImpl_DistributionPointName * p) { return A2C_Release((PVOID) p, &CertImpl_DistributionPointName_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_DistributionPointName(CertImpl_DistributionPointName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_DistributionPointName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_DistributionPointName(CertImpl_DistributionPointName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_DistributionPointName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_DistributionPointName(CertImpl_DistributionPointName const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_DistributionPointName_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_DistributionPointName(CertImpl_DistributionPointName * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_DistributionPointName_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_DistributionPointName(CertImpl_DistributionPointName * pDst, CertImpl_DistributionPointName * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_DistributionPointName_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_DistributionPointName(CertImpl_DistributionPointName const * pLeft, CertImpl_DistributionPointName const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_DistributionPointName_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_DistributionPointName(CertImpl_DistributionPointName * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_DistributionPointName_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_DistributionPointName(CertImpl_DistributionPointName * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_DistributionPointName_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_DistributionPointName(CertImpl_DistributionPointName * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_DistributionPointName_descriptor, ppcxt, pf, pstm); } typedef A2C_BIT_STRING_NAMED CertImpl_ReasonFlags; extern const A2C_DESCRIPTOR CertImpl_ReasonFlags_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_ReasonFlags(CertImpl_ReasonFlags ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_ReasonFlags_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_ReasonFlags(CertImpl_ReasonFlags * p) { return A2C_Free((PVOID) p, &CertImpl_ReasonFlags_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_ReasonFlags(CertImpl_ReasonFlags * p) { return A2C_Init((PVOID) p, &CertImpl_ReasonFlags_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_ReasonFlags(CertImpl_ReasonFlags * p) { return A2C_Release((PVOID) p, &CertImpl_ReasonFlags_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_ReasonFlags(CertImpl_ReasonFlags const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_ReasonFlags_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_ReasonFlags(CertImpl_ReasonFlags * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_ReasonFlags_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_ReasonFlags(CertImpl_ReasonFlags const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_ReasonFlags_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_ReasonFlags(CertImpl_ReasonFlags * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_ReasonFlags_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_ReasonFlags(CertImpl_ReasonFlags * pDst, CertImpl_ReasonFlags * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_ReasonFlags_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_ReasonFlags(CertImpl_ReasonFlags const * pLeft, CertImpl_ReasonFlags const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_ReasonFlags_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_ReasonFlags(CertImpl_ReasonFlags * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_ReasonFlags_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_ReasonFlags(CertImpl_ReasonFlags * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_ReasonFlags_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_ReasonFlags(CertImpl_ReasonFlags * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_ReasonFlags_descriptor, ppcxt, pf, pstm); } typedef struct { unsigned int optionalFields; @@ -967,6 +1929,19 @@ typedef struct { } CertImpl_DistributionPoint; extern const A2C_DESCRIPTOR CertImpl_DistributionPoint_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_DistributionPoint(CertImpl_DistributionPoint ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_DistributionPoint_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_DistributionPoint(CertImpl_DistributionPoint * p) { return A2C_Free((PVOID) p, &CertImpl_DistributionPoint_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_DistributionPoint(CertImpl_DistributionPoint * p) { return A2C_Init((PVOID) p, &CertImpl_DistributionPoint_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_DistributionPoint(CertImpl_DistributionPoint * p) { return A2C_Release((PVOID) p, &CertImpl_DistributionPoint_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_DistributionPoint(CertImpl_DistributionPoint const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_DistributionPoint_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_DistributionPoint(CertImpl_DistributionPoint * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_DistributionPoint_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_DistributionPoint(CertImpl_DistributionPoint const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_DistributionPoint_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_DistributionPoint(CertImpl_DistributionPoint * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_DistributionPoint_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_DistributionPoint(CertImpl_DistributionPoint * pDst, CertImpl_DistributionPoint * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_DistributionPoint_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_DistributionPoint(CertImpl_DistributionPoint const * pLeft, CertImpl_DistributionPoint const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_DistributionPoint_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_DistributionPoint(CertImpl_DistributionPoint * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_DistributionPoint_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_DistributionPoint(CertImpl_DistributionPoint * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_DistributionPoint_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_DistributionPoint(CertImpl_DistributionPoint * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_DistributionPoint_descriptor, ppcxt, pf, pstm); } typedef struct { int count; @@ -975,10 +1950,36 @@ typedef struct { } CertImpl_CRLDistributionPoints; extern const A2C_DESCRIPTOR CertImpl_CRLDistributionPoints_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_CRLDistributionPoints(CertImpl_CRLDistributionPoints ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_CRLDistributionPoints_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_CRLDistributionPoints(CertImpl_CRLDistributionPoints * p) { return A2C_Free((PVOID) p, &CertImpl_CRLDistributionPoints_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_CRLDistributionPoints(CertImpl_CRLDistributionPoints * p) { return A2C_Init((PVOID) p, &CertImpl_CRLDistributionPoints_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_CRLDistributionPoints(CertImpl_CRLDistributionPoints * p) { return A2C_Release((PVOID) p, &CertImpl_CRLDistributionPoints_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_CRLDistributionPoints(CertImpl_CRLDistributionPoints const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_CRLDistributionPoints_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_CRLDistributionPoints(CertImpl_CRLDistributionPoints * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_CRLDistributionPoints_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_CRLDistributionPoints(CertImpl_CRLDistributionPoints const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_CRLDistributionPoints_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_CRLDistributionPoints(CertImpl_CRLDistributionPoints * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_CRLDistributionPoints_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_CRLDistributionPoints(CertImpl_CRLDistributionPoints * pDst, CertImpl_CRLDistributionPoints * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_CRLDistributionPoints_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_CRLDistributionPoints(CertImpl_CRLDistributionPoints const * pLeft, CertImpl_CRLDistributionPoints const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_CRLDistributionPoints_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_CRLDistributionPoints(CertImpl_CRLDistributionPoints * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_CRLDistributionPoints_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_CRLDistributionPoints(CertImpl_CRLDistributionPoints * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_CRLDistributionPoints_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_CRLDistributionPoints(CertImpl_CRLDistributionPoints * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_CRLDistributionPoints_descriptor, ppcxt, pf, pstm); } typedef A2C_INTEGER_NATIVE CertImpl_BaseDistance; extern const A2C_DESCRIPTOR CertImpl_BaseDistance_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_BaseDistance(CertImpl_BaseDistance ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_BaseDistance_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_BaseDistance(CertImpl_BaseDistance * p) { return A2C_Free((PVOID) p, &CertImpl_BaseDistance_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_BaseDistance(CertImpl_BaseDistance * p) { return A2C_Init((PVOID) p, &CertImpl_BaseDistance_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_BaseDistance(CertImpl_BaseDistance * p) { return A2C_Release((PVOID) p, &CertImpl_BaseDistance_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_BaseDistance(CertImpl_BaseDistance const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_BaseDistance_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_BaseDistance(CertImpl_BaseDistance * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_BaseDistance_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_BaseDistance(CertImpl_BaseDistance const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_BaseDistance_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_BaseDistance(CertImpl_BaseDistance * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_BaseDistance_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_BaseDistance(CertImpl_BaseDistance * pDst, CertImpl_BaseDistance * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_BaseDistance_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_BaseDistance(CertImpl_BaseDistance const * pLeft, CertImpl_BaseDistance const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_BaseDistance_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_BaseDistance(CertImpl_BaseDistance * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_BaseDistance_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_BaseDistance(CertImpl_BaseDistance * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_BaseDistance_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_BaseDistance(CertImpl_BaseDistance * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_BaseDistance_descriptor, ppcxt, pf, pstm); } typedef struct { unsigned int optionalFields; @@ -989,6 +1990,19 @@ typedef struct { } CertImpl_GeneralSubtree; extern const A2C_DESCRIPTOR CertImpl_GeneralSubtree_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_GeneralSubtree(CertImpl_GeneralSubtree ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_GeneralSubtree_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_GeneralSubtree(CertImpl_GeneralSubtree * p) { return A2C_Free((PVOID) p, &CertImpl_GeneralSubtree_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_GeneralSubtree(CertImpl_GeneralSubtree * p) { return A2C_Init((PVOID) p, &CertImpl_GeneralSubtree_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_GeneralSubtree(CertImpl_GeneralSubtree * p) { return A2C_Release((PVOID) p, &CertImpl_GeneralSubtree_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_GeneralSubtree(CertImpl_GeneralSubtree const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_GeneralSubtree_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_GeneralSubtree(CertImpl_GeneralSubtree * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_GeneralSubtree_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_GeneralSubtree(CertImpl_GeneralSubtree const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_GeneralSubtree_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_GeneralSubtree(CertImpl_GeneralSubtree * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_GeneralSubtree_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_GeneralSubtree(CertImpl_GeneralSubtree * pDst, CertImpl_GeneralSubtree * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_GeneralSubtree_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_GeneralSubtree(CertImpl_GeneralSubtree const * pLeft, CertImpl_GeneralSubtree const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_GeneralSubtree_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_GeneralSubtree(CertImpl_GeneralSubtree * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_GeneralSubtree_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_GeneralSubtree(CertImpl_GeneralSubtree * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_GeneralSubtree_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_GeneralSubtree(CertImpl_GeneralSubtree * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_GeneralSubtree_descriptor, ppcxt, pf, pstm); } typedef struct { int count; @@ -997,6 +2011,19 @@ typedef struct { } CertImpl_GeneralSubtrees; extern const A2C_DESCRIPTOR CertImpl_GeneralSubtrees_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_GeneralSubtrees(CertImpl_GeneralSubtrees ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_GeneralSubtrees_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_GeneralSubtrees(CertImpl_GeneralSubtrees * p) { return A2C_Free((PVOID) p, &CertImpl_GeneralSubtrees_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_GeneralSubtrees(CertImpl_GeneralSubtrees * p) { return A2C_Init((PVOID) p, &CertImpl_GeneralSubtrees_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_GeneralSubtrees(CertImpl_GeneralSubtrees * p) { return A2C_Release((PVOID) p, &CertImpl_GeneralSubtrees_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_GeneralSubtrees(CertImpl_GeneralSubtrees const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_GeneralSubtrees_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_GeneralSubtrees(CertImpl_GeneralSubtrees * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_GeneralSubtrees_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_GeneralSubtrees(CertImpl_GeneralSubtrees const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_GeneralSubtrees_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_GeneralSubtrees(CertImpl_GeneralSubtrees * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_GeneralSubtrees_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_GeneralSubtrees(CertImpl_GeneralSubtrees * pDst, CertImpl_GeneralSubtrees * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_GeneralSubtrees_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_GeneralSubtrees(CertImpl_GeneralSubtrees const * pLeft, CertImpl_GeneralSubtrees const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_GeneralSubtrees_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_GeneralSubtrees(CertImpl_GeneralSubtrees * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_GeneralSubtrees_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_GeneralSubtrees(CertImpl_GeneralSubtrees * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_GeneralSubtrees_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_GeneralSubtrees(CertImpl_GeneralSubtrees * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_GeneralSubtrees_descriptor, ppcxt, pf, pstm); } typedef struct { unsigned int optionalFields; @@ -1007,6 +2034,19 @@ typedef struct { } CertImpl_NameConstraints; extern const A2C_DESCRIPTOR CertImpl_NameConstraints_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_NameConstraints(CertImpl_NameConstraints ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_NameConstraints_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_NameConstraints(CertImpl_NameConstraints * p) { return A2C_Free((PVOID) p, &CertImpl_NameConstraints_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_NameConstraints(CertImpl_NameConstraints * p) { return A2C_Init((PVOID) p, &CertImpl_NameConstraints_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_NameConstraints(CertImpl_NameConstraints * p) { return A2C_Release((PVOID) p, &CertImpl_NameConstraints_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_NameConstraints(CertImpl_NameConstraints const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_NameConstraints_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_NameConstraints(CertImpl_NameConstraints * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_NameConstraints_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_NameConstraints(CertImpl_NameConstraints const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_NameConstraints_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_NameConstraints(CertImpl_NameConstraints * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_NameConstraints_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_NameConstraints(CertImpl_NameConstraints * pDst, CertImpl_NameConstraints * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_NameConstraints_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_NameConstraints(CertImpl_NameConstraints const * pLeft, CertImpl_NameConstraints const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_NameConstraints_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_NameConstraints(CertImpl_NameConstraints * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_NameConstraints_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_NameConstraints(CertImpl_NameConstraints * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_NameConstraints_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_NameConstraints(CertImpl_NameConstraints * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_NameConstraints_descriptor, ppcxt, pf, pstm); } extern const Cert_EXTENSION CertImpl_ext_NameConstraints; typedef struct { @@ -1018,6 +2058,19 @@ extern const A2C_OBJECT_IDENTIFIER CertImpl_id_ce_policyConstraints; typedef A2C_OCTET_STRING CertImpl_KeyIdentifier; extern const A2C_DESCRIPTOR CertImpl_KeyIdentifier_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_KeyIdentifier(CertImpl_KeyIdentifier ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_KeyIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_KeyIdentifier(CertImpl_KeyIdentifier * p) { return A2C_Free((PVOID) p, &CertImpl_KeyIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_KeyIdentifier(CertImpl_KeyIdentifier * p) { return A2C_Init((PVOID) p, &CertImpl_KeyIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_KeyIdentifier(CertImpl_KeyIdentifier * p) { return A2C_Release((PVOID) p, &CertImpl_KeyIdentifier_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_KeyIdentifier(CertImpl_KeyIdentifier const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_KeyIdentifier_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_KeyIdentifier(CertImpl_KeyIdentifier * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_KeyIdentifier_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_KeyIdentifier(CertImpl_KeyIdentifier const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_KeyIdentifier_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_KeyIdentifier(CertImpl_KeyIdentifier * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_KeyIdentifier_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_KeyIdentifier(CertImpl_KeyIdentifier * pDst, CertImpl_KeyIdentifier * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_KeyIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_KeyIdentifier(CertImpl_KeyIdentifier const * pLeft, CertImpl_KeyIdentifier const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_KeyIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_KeyIdentifier(CertImpl_KeyIdentifier * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_KeyIdentifier_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_KeyIdentifier(CertImpl_KeyIdentifier * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_KeyIdentifier_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_KeyIdentifier(CertImpl_KeyIdentifier * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_KeyIdentifier_descriptor, ppcxt, pf, pstm); } typedef struct { unsigned int optionalFields; @@ -1030,6 +2083,19 @@ typedef struct { } CertImpl_AuthorityKeyIdentifier; extern const A2C_DESCRIPTOR CertImpl_AuthorityKeyIdentifier_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_AuthorityKeyIdentifier(CertImpl_AuthorityKeyIdentifier ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_AuthorityKeyIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_AuthorityKeyIdentifier(CertImpl_AuthorityKeyIdentifier * p) { return A2C_Free((PVOID) p, &CertImpl_AuthorityKeyIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_AuthorityKeyIdentifier(CertImpl_AuthorityKeyIdentifier * p) { return A2C_Init((PVOID) p, &CertImpl_AuthorityKeyIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_AuthorityKeyIdentifier(CertImpl_AuthorityKeyIdentifier * p) { return A2C_Release((PVOID) p, &CertImpl_AuthorityKeyIdentifier_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_AuthorityKeyIdentifier(CertImpl_AuthorityKeyIdentifier const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_AuthorityKeyIdentifier_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_AuthorityKeyIdentifier(CertImpl_AuthorityKeyIdentifier * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_AuthorityKeyIdentifier_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_AuthorityKeyIdentifier(CertImpl_AuthorityKeyIdentifier const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_AuthorityKeyIdentifier_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_AuthorityKeyIdentifier(CertImpl_AuthorityKeyIdentifier * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_AuthorityKeyIdentifier_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_AuthorityKeyIdentifier(CertImpl_AuthorityKeyIdentifier * pDst, CertImpl_AuthorityKeyIdentifier * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_AuthorityKeyIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_AuthorityKeyIdentifier(CertImpl_AuthorityKeyIdentifier const * pLeft, CertImpl_AuthorityKeyIdentifier const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_AuthorityKeyIdentifier_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_AuthorityKeyIdentifier(CertImpl_AuthorityKeyIdentifier * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_AuthorityKeyIdentifier_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_AuthorityKeyIdentifier(CertImpl_AuthorityKeyIdentifier * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_AuthorityKeyIdentifier_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_AuthorityKeyIdentifier(CertImpl_AuthorityKeyIdentifier * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_AuthorityKeyIdentifier_descriptor, ppcxt, pf, pstm); } extern const A2C_OBJECT_IDENTIFIER CertImpl_id_ce_nameConstraints; typedef struct { @@ -1040,11 +2106,37 @@ typedef struct { } CertImpl_BasicConstraints; extern const A2C_DESCRIPTOR CertImpl_BasicConstraints_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_BasicConstraints(CertImpl_BasicConstraints ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_BasicConstraints_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_BasicConstraints(CertImpl_BasicConstraints * p) { return A2C_Free((PVOID) p, &CertImpl_BasicConstraints_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_BasicConstraints(CertImpl_BasicConstraints * p) { return A2C_Init((PVOID) p, &CertImpl_BasicConstraints_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_BasicConstraints(CertImpl_BasicConstraints * p) { return A2C_Release((PVOID) p, &CertImpl_BasicConstraints_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_BasicConstraints(CertImpl_BasicConstraints const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_BasicConstraints_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_BasicConstraints(CertImpl_BasicConstraints * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_BasicConstraints_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_BasicConstraints(CertImpl_BasicConstraints const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_BasicConstraints_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_BasicConstraints(CertImpl_BasicConstraints * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_BasicConstraints_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_BasicConstraints(CertImpl_BasicConstraints * pDst, CertImpl_BasicConstraints * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_BasicConstraints_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_BasicConstraints(CertImpl_BasicConstraints const * pLeft, CertImpl_BasicConstraints const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_BasicConstraints_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_BasicConstraints(CertImpl_BasicConstraints * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_BasicConstraints_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_BasicConstraints(CertImpl_BasicConstraints * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_BasicConstraints_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_BasicConstraints(CertImpl_BasicConstraints * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_BasicConstraints_descriptor, ppcxt, pf, pstm); } extern const Cert_EXTENSION CertImpl_ext_ExtKeyUsageSyntax; typedef A2C_ENUMERATED_NATIVE CertImpl_CRLReason; extern const A2C_DESCRIPTOR CertImpl_CRLReason_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_CRLReason(CertImpl_CRLReason ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_CRLReason_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_CRLReason(CertImpl_CRLReason * p) { return A2C_Free((PVOID) p, &CertImpl_CRLReason_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_CRLReason(CertImpl_CRLReason * p) { return A2C_Init((PVOID) p, &CertImpl_CRLReason_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_CRLReason(CertImpl_CRLReason * p) { return A2C_Release((PVOID) p, &CertImpl_CRLReason_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_CRLReason(CertImpl_CRLReason const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_CRLReason_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_CRLReason(CertImpl_CRLReason * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_CRLReason_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_CRLReason(CertImpl_CRLReason const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_CRLReason_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_CRLReason(CertImpl_CRLReason * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_CRLReason_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_CRLReason(CertImpl_CRLReason * pDst, CertImpl_CRLReason * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_CRLReason_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_CRLReason(CertImpl_CRLReason const * pLeft, CertImpl_CRLReason const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_CRLReason_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_CRLReason(CertImpl_CRLReason * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_CRLReason_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_CRLReason(CertImpl_CRLReason * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_CRLReason_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_CRLReason(CertImpl_CRLReason * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_CRLReason_descriptor, ppcxt, pf, pstm); } extern const A2C_OBJECT_IDENTIFIER CertImpl_id_ce_holdInstructionCode; extern const A2C_OBJECT_IDENTIFIER CertImpl_id_pe_subjectInfoAccess; @@ -1054,10 +2146,36 @@ typedef struct { } CertImpl_PolicyQualifierInfo; extern const A2C_DESCRIPTOR CertImpl_PolicyQualifierInfo_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_PolicyQualifierInfo(CertImpl_PolicyQualifierInfo ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_PolicyQualifierInfo_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_PolicyQualifierInfo(CertImpl_PolicyQualifierInfo * p) { return A2C_Free((PVOID) p, &CertImpl_PolicyQualifierInfo_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_PolicyQualifierInfo(CertImpl_PolicyQualifierInfo * p) { return A2C_Init((PVOID) p, &CertImpl_PolicyQualifierInfo_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_PolicyQualifierInfo(CertImpl_PolicyQualifierInfo * p) { return A2C_Release((PVOID) p, &CertImpl_PolicyQualifierInfo_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_PolicyQualifierInfo(CertImpl_PolicyQualifierInfo const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_PolicyQualifierInfo_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_PolicyQualifierInfo(CertImpl_PolicyQualifierInfo * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_PolicyQualifierInfo_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_PolicyQualifierInfo(CertImpl_PolicyQualifierInfo const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_PolicyQualifierInfo_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_PolicyQualifierInfo(CertImpl_PolicyQualifierInfo * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_PolicyQualifierInfo_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_PolicyQualifierInfo(CertImpl_PolicyQualifierInfo * pDst, CertImpl_PolicyQualifierInfo * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_PolicyQualifierInfo_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_PolicyQualifierInfo(CertImpl_PolicyQualifierInfo const * pLeft, CertImpl_PolicyQualifierInfo const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_PolicyQualifierInfo_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_PolicyQualifierInfo(CertImpl_PolicyQualifierInfo * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_PolicyQualifierInfo_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_PolicyQualifierInfo(CertImpl_PolicyQualifierInfo * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_PolicyQualifierInfo_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_PolicyQualifierInfo(CertImpl_PolicyQualifierInfo * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_PolicyQualifierInfo_descriptor, ppcxt, pf, pstm); } typedef A2C_OBJECT_IDENTIFIER CertImpl_CertPolicyId; extern const A2C_DESCRIPTOR CertImpl_CertPolicyId_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_CertPolicyId(CertImpl_CertPolicyId ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_CertPolicyId_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_CertPolicyId(CertImpl_CertPolicyId * p) { return A2C_Free((PVOID) p, &CertImpl_CertPolicyId_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_CertPolicyId(CertImpl_CertPolicyId * p) { return A2C_Init((PVOID) p, &CertImpl_CertPolicyId_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_CertPolicyId(CertImpl_CertPolicyId * p) { return A2C_Release((PVOID) p, &CertImpl_CertPolicyId_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_CertPolicyId(CertImpl_CertPolicyId const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_CertPolicyId_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_CertPolicyId(CertImpl_CertPolicyId * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_CertPolicyId_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_CertPolicyId(CertImpl_CertPolicyId const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_CertPolicyId_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_CertPolicyId(CertImpl_CertPolicyId * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_CertPolicyId_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_CertPolicyId(CertImpl_CertPolicyId * pDst, CertImpl_CertPolicyId * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_CertPolicyId_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_CertPolicyId(CertImpl_CertPolicyId const * pLeft, CertImpl_CertPolicyId const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_CertPolicyId_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_CertPolicyId(CertImpl_CertPolicyId * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_CertPolicyId_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_CertPolicyId(CertImpl_CertPolicyId * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_CertPolicyId_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_CertPolicyId(CertImpl_CertPolicyId * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_CertPolicyId_descriptor, ppcxt, pf, pstm); } typedef struct { unsigned int optionalFields; @@ -1071,6 +2189,19 @@ typedef struct { } CertImpl_PolicyInformation; extern const A2C_DESCRIPTOR CertImpl_PolicyInformation_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_PolicyInformation(CertImpl_PolicyInformation ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_PolicyInformation_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_PolicyInformation(CertImpl_PolicyInformation * p) { return A2C_Free((PVOID) p, &CertImpl_PolicyInformation_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_PolicyInformation(CertImpl_PolicyInformation * p) { return A2C_Init((PVOID) p, &CertImpl_PolicyInformation_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_PolicyInformation(CertImpl_PolicyInformation * p) { return A2C_Release((PVOID) p, &CertImpl_PolicyInformation_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_PolicyInformation(CertImpl_PolicyInformation const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_PolicyInformation_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_PolicyInformation(CertImpl_PolicyInformation * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_PolicyInformation_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_PolicyInformation(CertImpl_PolicyInformation const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_PolicyInformation_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_PolicyInformation(CertImpl_PolicyInformation * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_PolicyInformation_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_PolicyInformation(CertImpl_PolicyInformation * pDst, CertImpl_PolicyInformation * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_PolicyInformation_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_PolicyInformation(CertImpl_PolicyInformation const * pLeft, CertImpl_PolicyInformation const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_PolicyInformation_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_PolicyInformation(CertImpl_PolicyInformation * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_PolicyInformation_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_PolicyInformation(CertImpl_PolicyInformation * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_PolicyInformation_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_PolicyInformation(CertImpl_PolicyInformation * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_PolicyInformation_descriptor, ppcxt, pf, pstm); } typedef struct { CertImpl_CertPolicyId issuerDomainPolicy; @@ -1078,6 +2209,19 @@ typedef struct { } CertImpl_PolicyMappings__array; extern const A2C_DESCRIPTOR CertImpl_PolicyMappings__array_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_PolicyMappings__array(CertImpl_PolicyMappings__array ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_PolicyMappings__array_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_PolicyMappings__array(CertImpl_PolicyMappings__array * p) { return A2C_Free((PVOID) p, &CertImpl_PolicyMappings__array_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_PolicyMappings__array(CertImpl_PolicyMappings__array * p) { return A2C_Init((PVOID) p, &CertImpl_PolicyMappings__array_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_PolicyMappings__array(CertImpl_PolicyMappings__array * p) { return A2C_Release((PVOID) p, &CertImpl_PolicyMappings__array_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_PolicyMappings__array(CertImpl_PolicyMappings__array const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_PolicyMappings__array_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_PolicyMappings__array(CertImpl_PolicyMappings__array * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_PolicyMappings__array_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_PolicyMappings__array(CertImpl_PolicyMappings__array const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_PolicyMappings__array_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_PolicyMappings__array(CertImpl_PolicyMappings__array * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_PolicyMappings__array_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_PolicyMappings__array(CertImpl_PolicyMappings__array * pDst, CertImpl_PolicyMappings__array * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_PolicyMappings__array_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_PolicyMappings__array(CertImpl_PolicyMappings__array const * pLeft, CertImpl_PolicyMappings__array const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_PolicyMappings__array_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_PolicyMappings__array(CertImpl_PolicyMappings__array * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_PolicyMappings__array_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_PolicyMappings__array(CertImpl_PolicyMappings__array * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_PolicyMappings__array_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_PolicyMappings__array(CertImpl_PolicyMappings__array * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_PolicyMappings__array_descriptor, ppcxt, pf, pstm); } typedef struct { int count; @@ -1086,6 +2230,19 @@ typedef struct { } CertImpl_PolicyMappings; extern const A2C_DESCRIPTOR CertImpl_PolicyMappings_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_PolicyMappings(CertImpl_PolicyMappings ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_PolicyMappings_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_PolicyMappings(CertImpl_PolicyMappings * p) { return A2C_Free((PVOID) p, &CertImpl_PolicyMappings_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_PolicyMappings(CertImpl_PolicyMappings * p) { return A2C_Init((PVOID) p, &CertImpl_PolicyMappings_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_PolicyMappings(CertImpl_PolicyMappings * p) { return A2C_Release((PVOID) p, &CertImpl_PolicyMappings_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_PolicyMappings(CertImpl_PolicyMappings const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_PolicyMappings_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_PolicyMappings(CertImpl_PolicyMappings * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_PolicyMappings_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_PolicyMappings(CertImpl_PolicyMappings const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_PolicyMappings_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_PolicyMappings(CertImpl_PolicyMappings * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_PolicyMappings_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_PolicyMappings(CertImpl_PolicyMappings * pDst, CertImpl_PolicyMappings * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_PolicyMappings_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_PolicyMappings(CertImpl_PolicyMappings const * pLeft, CertImpl_PolicyMappings const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_PolicyMappings_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_PolicyMappings(CertImpl_PolicyMappings * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_PolicyMappings_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_PolicyMappings(CertImpl_PolicyMappings * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_PolicyMappings_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_PolicyMappings(CertImpl_PolicyMappings * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_PolicyMappings_descriptor, ppcxt, pf, pstm); } typedef struct { int count; @@ -1094,17 +2251,56 @@ typedef struct { } CertImpl_SubjectDirectoryAttributes; extern const A2C_DESCRIPTOR CertImpl_SubjectDirectoryAttributes_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_SubjectDirectoryAttributes(CertImpl_SubjectDirectoryAttributes ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_SubjectDirectoryAttributes_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_SubjectDirectoryAttributes(CertImpl_SubjectDirectoryAttributes * p) { return A2C_Free((PVOID) p, &CertImpl_SubjectDirectoryAttributes_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_SubjectDirectoryAttributes(CertImpl_SubjectDirectoryAttributes * p) { return A2C_Init((PVOID) p, &CertImpl_SubjectDirectoryAttributes_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_SubjectDirectoryAttributes(CertImpl_SubjectDirectoryAttributes * p) { return A2C_Release((PVOID) p, &CertImpl_SubjectDirectoryAttributes_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_SubjectDirectoryAttributes(CertImpl_SubjectDirectoryAttributes const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_SubjectDirectoryAttributes_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_SubjectDirectoryAttributes(CertImpl_SubjectDirectoryAttributes * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_SubjectDirectoryAttributes_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_SubjectDirectoryAttributes(CertImpl_SubjectDirectoryAttributes const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_SubjectDirectoryAttributes_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_SubjectDirectoryAttributes(CertImpl_SubjectDirectoryAttributes * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_SubjectDirectoryAttributes_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_SubjectDirectoryAttributes(CertImpl_SubjectDirectoryAttributes * pDst, CertImpl_SubjectDirectoryAttributes * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_SubjectDirectoryAttributes_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_SubjectDirectoryAttributes(CertImpl_SubjectDirectoryAttributes const * pLeft, CertImpl_SubjectDirectoryAttributes const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_SubjectDirectoryAttributes_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_SubjectDirectoryAttributes(CertImpl_SubjectDirectoryAttributes * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_SubjectDirectoryAttributes_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_SubjectDirectoryAttributes(CertImpl_SubjectDirectoryAttributes * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_SubjectDirectoryAttributes_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_SubjectDirectoryAttributes(CertImpl_SubjectDirectoryAttributes * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_SubjectDirectoryAttributes_descriptor, ppcxt, pf, pstm); } extern const Cert_EXTENSION CertImpl_ext_SubjectDirectoryAttributes; typedef A2C_IA5_STRING CertImpl_CPSuri; extern const A2C_DESCRIPTOR CertImpl_CPSuri_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_CPSuri(CertImpl_CPSuri ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_CPSuri_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_CPSuri(CertImpl_CPSuri * p) { return A2C_Free((PVOID) p, &CertImpl_CPSuri_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_CPSuri(CertImpl_CPSuri * p) { return A2C_Init((PVOID) p, &CertImpl_CPSuri_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_CPSuri(CertImpl_CPSuri * p) { return A2C_Release((PVOID) p, &CertImpl_CPSuri_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_CPSuri(CertImpl_CPSuri const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_CPSuri_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_CPSuri(CertImpl_CPSuri * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_CPSuri_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_CPSuri(CertImpl_CPSuri const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_CPSuri_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_CPSuri(CertImpl_CPSuri * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_CPSuri_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_CPSuri(CertImpl_CPSuri * pDst, CertImpl_CPSuri * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_CPSuri_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_CPSuri(CertImpl_CPSuri const * pLeft, CertImpl_CPSuri const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_CPSuri_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_CPSuri(CertImpl_CPSuri * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_CPSuri_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_CPSuri(CertImpl_CPSuri * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_CPSuri_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_CPSuri(CertImpl_CPSuri * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_CPSuri_descriptor, ppcxt, pf, pstm); } extern const CertImpl_POLICY_QUALIFIER_INFO CertImpl_pqid_cps; extern const Cert_EXTENSION CertImpl_ext_SubjectKeyIdentifier; typedef A2C_INTEGER_NATIVE CertImpl_SkipCerts; extern const A2C_DESCRIPTOR CertImpl_SkipCerts_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_SkipCerts(CertImpl_SkipCerts ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_SkipCerts_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_SkipCerts(CertImpl_SkipCerts * p) { return A2C_Free((PVOID) p, &CertImpl_SkipCerts_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_SkipCerts(CertImpl_SkipCerts * p) { return A2C_Init((PVOID) p, &CertImpl_SkipCerts_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_SkipCerts(CertImpl_SkipCerts * p) { return A2C_Release((PVOID) p, &CertImpl_SkipCerts_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_SkipCerts(CertImpl_SkipCerts const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_SkipCerts_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_SkipCerts(CertImpl_SkipCerts * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_SkipCerts_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_SkipCerts(CertImpl_SkipCerts const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_SkipCerts_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_SkipCerts(CertImpl_SkipCerts * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_SkipCerts_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_SkipCerts(CertImpl_SkipCerts * pDst, CertImpl_SkipCerts * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_SkipCerts_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_SkipCerts(CertImpl_SkipCerts const * pLeft, CertImpl_SkipCerts const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_SkipCerts_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_SkipCerts(CertImpl_SkipCerts * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_SkipCerts_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_SkipCerts(CertImpl_SkipCerts * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_SkipCerts_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_SkipCerts(CertImpl_SkipCerts * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_SkipCerts_descriptor, ppcxt, pf, pstm); } typedef struct { unsigned int optionalFields; @@ -1115,6 +2311,19 @@ typedef struct { } CertImpl_PolicyConstraints; extern const A2C_DESCRIPTOR CertImpl_PolicyConstraints_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_PolicyConstraints(CertImpl_PolicyConstraints ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_PolicyConstraints_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_PolicyConstraints(CertImpl_PolicyConstraints * p) { return A2C_Free((PVOID) p, &CertImpl_PolicyConstraints_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_PolicyConstraints(CertImpl_PolicyConstraints * p) { return A2C_Init((PVOID) p, &CertImpl_PolicyConstraints_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_PolicyConstraints(CertImpl_PolicyConstraints * p) { return A2C_Release((PVOID) p, &CertImpl_PolicyConstraints_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_PolicyConstraints(CertImpl_PolicyConstraints const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_PolicyConstraints_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_PolicyConstraints(CertImpl_PolicyConstraints * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_PolicyConstraints_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_PolicyConstraints(CertImpl_PolicyConstraints const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_PolicyConstraints_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_PolicyConstraints(CertImpl_PolicyConstraints * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_PolicyConstraints_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_PolicyConstraints(CertImpl_PolicyConstraints * pDst, CertImpl_PolicyConstraints * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_PolicyConstraints_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_PolicyConstraints(CertImpl_PolicyConstraints const * pLeft, CertImpl_PolicyConstraints const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_PolicyConstraints_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_PolicyConstraints(CertImpl_PolicyConstraints * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_PolicyConstraints_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_PolicyConstraints(CertImpl_PolicyConstraints * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_PolicyConstraints_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_PolicyConstraints(CertImpl_PolicyConstraints * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_PolicyConstraints_descriptor, ppcxt, pf, pstm); } extern const Cert_EXTENSION CertImpl_ext_PolicyConstraints; extern const A2C_OBJECT_IDENTIFIER CertImpl_id_ce_privateKeyUsagePeriod; extern const Cert_EXTENSION CertImpl_ext_BasicConstraints; @@ -1128,6 +2337,19 @@ typedef struct { } CertImpl_CertificatePolicies; extern const A2C_DESCRIPTOR CertImpl_CertificatePolicies_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_CertificatePolicies(CertImpl_CertificatePolicies ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_CertificatePolicies_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_CertificatePolicies(CertImpl_CertificatePolicies * p) { return A2C_Free((PVOID) p, &CertImpl_CertificatePolicies_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_CertificatePolicies(CertImpl_CertificatePolicies * p) { return A2C_Init((PVOID) p, &CertImpl_CertificatePolicies_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_CertificatePolicies(CertImpl_CertificatePolicies * p) { return A2C_Release((PVOID) p, &CertImpl_CertificatePolicies_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_CertificatePolicies(CertImpl_CertificatePolicies const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_CertificatePolicies_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_CertificatePolicies(CertImpl_CertificatePolicies * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_CertificatePolicies_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_CertificatePolicies(CertImpl_CertificatePolicies const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_CertificatePolicies_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_CertificatePolicies(CertImpl_CertificatePolicies * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_CertificatePolicies_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_CertificatePolicies(CertImpl_CertificatePolicies * pDst, CertImpl_CertificatePolicies * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_CertificatePolicies_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_CertificatePolicies(CertImpl_CertificatePolicies const * pLeft, CertImpl_CertificatePolicies const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_CertificatePolicies_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_CertificatePolicies(CertImpl_CertificatePolicies * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_CertificatePolicies_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_CertificatePolicies(CertImpl_CertificatePolicies * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_CertificatePolicies_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_CertificatePolicies(CertImpl_CertificatePolicies * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_CertificatePolicies_descriptor, ppcxt, pf, pstm); } extern const A2C_OBJECT_IDENTIFIER CertImpl_id_pe_authorityInfoAccess; extern const Cert_EXTENSION CertImpl_ext_SubjectAltName; extern const A2C_OBJECT_IDENTIFIER CertImpl_id_ce; @@ -1139,6 +2361,19 @@ typedef struct { } CertImpl_SubjectInfoAccessSyntax; extern const A2C_DESCRIPTOR CertImpl_SubjectInfoAccessSyntax_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_SubjectInfoAccessSyntax(CertImpl_SubjectInfoAccessSyntax ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_SubjectInfoAccessSyntax_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_SubjectInfoAccessSyntax(CertImpl_SubjectInfoAccessSyntax * p) { return A2C_Free((PVOID) p, &CertImpl_SubjectInfoAccessSyntax_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_SubjectInfoAccessSyntax(CertImpl_SubjectInfoAccessSyntax * p) { return A2C_Init((PVOID) p, &CertImpl_SubjectInfoAccessSyntax_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_SubjectInfoAccessSyntax(CertImpl_SubjectInfoAccessSyntax * p) { return A2C_Release((PVOID) p, &CertImpl_SubjectInfoAccessSyntax_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_SubjectInfoAccessSyntax(CertImpl_SubjectInfoAccessSyntax const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_SubjectInfoAccessSyntax_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_SubjectInfoAccessSyntax(CertImpl_SubjectInfoAccessSyntax * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_SubjectInfoAccessSyntax_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_SubjectInfoAccessSyntax(CertImpl_SubjectInfoAccessSyntax const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_SubjectInfoAccessSyntax_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_SubjectInfoAccessSyntax(CertImpl_SubjectInfoAccessSyntax * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_SubjectInfoAccessSyntax_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_SubjectInfoAccessSyntax(CertImpl_SubjectInfoAccessSyntax * pDst, CertImpl_SubjectInfoAccessSyntax * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_SubjectInfoAccessSyntax_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_SubjectInfoAccessSyntax(CertImpl_SubjectInfoAccessSyntax const * pLeft, CertImpl_SubjectInfoAccessSyntax const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_SubjectInfoAccessSyntax_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_SubjectInfoAccessSyntax(CertImpl_SubjectInfoAccessSyntax * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_SubjectInfoAccessSyntax_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_SubjectInfoAccessSyntax(CertImpl_SubjectInfoAccessSyntax * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_SubjectInfoAccessSyntax_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_SubjectInfoAccessSyntax(CertImpl_SubjectInfoAccessSyntax * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_SubjectInfoAccessSyntax_descriptor, ppcxt, pf, pstm); } typedef struct { int index; @@ -1155,6 +2390,19 @@ typedef struct { } CertImpl_DisplayText; extern const A2C_DESCRIPTOR CertImpl_DisplayText_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_DisplayText(CertImpl_DisplayText ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_DisplayText_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_DisplayText(CertImpl_DisplayText * p) { return A2C_Free((PVOID) p, &CertImpl_DisplayText_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_DisplayText(CertImpl_DisplayText * p) { return A2C_Init((PVOID) p, &CertImpl_DisplayText_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_DisplayText(CertImpl_DisplayText * p) { return A2C_Release((PVOID) p, &CertImpl_DisplayText_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_DisplayText(CertImpl_DisplayText const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_DisplayText_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_DisplayText(CertImpl_DisplayText * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_DisplayText_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_DisplayText(CertImpl_DisplayText const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_DisplayText_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_DisplayText(CertImpl_DisplayText * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_DisplayText_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_DisplayText(CertImpl_DisplayText * pDst, CertImpl_DisplayText * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_DisplayText_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_DisplayText(CertImpl_DisplayText const * pLeft, CertImpl_DisplayText const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_DisplayText_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_DisplayText(CertImpl_DisplayText * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_DisplayText_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_DisplayText(CertImpl_DisplayText * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_DisplayText_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_DisplayText(CertImpl_DisplayText * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_DisplayText_descriptor, ppcxt, pf, pstm); } typedef struct { CertImpl_DisplayText organization; @@ -1166,6 +2414,19 @@ typedef struct { } CertImpl_NoticeReference; extern const A2C_DESCRIPTOR CertImpl_NoticeReference_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_NoticeReference(CertImpl_NoticeReference ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_NoticeReference_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_NoticeReference(CertImpl_NoticeReference * p) { return A2C_Free((PVOID) p, &CertImpl_NoticeReference_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_NoticeReference(CertImpl_NoticeReference * p) { return A2C_Init((PVOID) p, &CertImpl_NoticeReference_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_NoticeReference(CertImpl_NoticeReference * p) { return A2C_Release((PVOID) p, &CertImpl_NoticeReference_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_NoticeReference(CertImpl_NoticeReference const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_NoticeReference_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_NoticeReference(CertImpl_NoticeReference * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_NoticeReference_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_NoticeReference(CertImpl_NoticeReference const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_NoticeReference_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_NoticeReference(CertImpl_NoticeReference * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_NoticeReference_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_NoticeReference(CertImpl_NoticeReference * pDst, CertImpl_NoticeReference * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_NoticeReference_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_NoticeReference(CertImpl_NoticeReference const * pLeft, CertImpl_NoticeReference const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_NoticeReference_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_NoticeReference(CertImpl_NoticeReference * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_NoticeReference_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_NoticeReference(CertImpl_NoticeReference * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_NoticeReference_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_NoticeReference(CertImpl_NoticeReference * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_NoticeReference_descriptor, ppcxt, pf, pstm); } typedef struct { unsigned int optionalFields; @@ -1176,11 +2437,37 @@ typedef struct { } CertImpl_PrivateKeyUsagePeriod; extern const A2C_DESCRIPTOR CertImpl_PrivateKeyUsagePeriod_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_PrivateKeyUsagePeriod(CertImpl_PrivateKeyUsagePeriod ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_PrivateKeyUsagePeriod_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_PrivateKeyUsagePeriod(CertImpl_PrivateKeyUsagePeriod * p) { return A2C_Free((PVOID) p, &CertImpl_PrivateKeyUsagePeriod_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_PrivateKeyUsagePeriod(CertImpl_PrivateKeyUsagePeriod * p) { return A2C_Init((PVOID) p, &CertImpl_PrivateKeyUsagePeriod_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_PrivateKeyUsagePeriod(CertImpl_PrivateKeyUsagePeriod * p) { return A2C_Release((PVOID) p, &CertImpl_PrivateKeyUsagePeriod_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_PrivateKeyUsagePeriod(CertImpl_PrivateKeyUsagePeriod const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_PrivateKeyUsagePeriod_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_PrivateKeyUsagePeriod(CertImpl_PrivateKeyUsagePeriod * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_PrivateKeyUsagePeriod_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_PrivateKeyUsagePeriod(CertImpl_PrivateKeyUsagePeriod const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_PrivateKeyUsagePeriod_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_PrivateKeyUsagePeriod(CertImpl_PrivateKeyUsagePeriod * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_PrivateKeyUsagePeriod_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_PrivateKeyUsagePeriod(CertImpl_PrivateKeyUsagePeriod * pDst, CertImpl_PrivateKeyUsagePeriod * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_PrivateKeyUsagePeriod_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_PrivateKeyUsagePeriod(CertImpl_PrivateKeyUsagePeriod const * pLeft, CertImpl_PrivateKeyUsagePeriod const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_PrivateKeyUsagePeriod_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_PrivateKeyUsagePeriod(CertImpl_PrivateKeyUsagePeriod * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_PrivateKeyUsagePeriod_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_PrivateKeyUsagePeriod(CertImpl_PrivateKeyUsagePeriod * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_PrivateKeyUsagePeriod_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_PrivateKeyUsagePeriod(CertImpl_PrivateKeyUsagePeriod * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_PrivateKeyUsagePeriod_descriptor, ppcxt, pf, pstm); } extern const A2C_OBJECT_IDENTIFIER CertImpl_id_kp_serverAuth; typedef A2C_INTEGER_NATIVE CertImpl_ext_CRLNumber__ExtnType; extern const A2C_DESCRIPTOR CertImpl_ext_CRLNumber__ExtnType_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_ext_CRLNumber__ExtnType(CertImpl_ext_CRLNumber__ExtnType ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_ext_CRLNumber__ExtnType_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_ext_CRLNumber__ExtnType(CertImpl_ext_CRLNumber__ExtnType * p) { return A2C_Free((PVOID) p, &CertImpl_ext_CRLNumber__ExtnType_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_ext_CRLNumber__ExtnType(CertImpl_ext_CRLNumber__ExtnType * p) { return A2C_Init((PVOID) p, &CertImpl_ext_CRLNumber__ExtnType_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_ext_CRLNumber__ExtnType(CertImpl_ext_CRLNumber__ExtnType * p) { return A2C_Release((PVOID) p, &CertImpl_ext_CRLNumber__ExtnType_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_ext_CRLNumber__ExtnType(CertImpl_ext_CRLNumber__ExtnType const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_ext_CRLNumber__ExtnType_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_ext_CRLNumber__ExtnType(CertImpl_ext_CRLNumber__ExtnType * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_ext_CRLNumber__ExtnType_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_ext_CRLNumber__ExtnType(CertImpl_ext_CRLNumber__ExtnType const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_ext_CRLNumber__ExtnType_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_ext_CRLNumber__ExtnType(CertImpl_ext_CRLNumber__ExtnType * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_ext_CRLNumber__ExtnType_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_ext_CRLNumber__ExtnType(CertImpl_ext_CRLNumber__ExtnType * pDst, CertImpl_ext_CRLNumber__ExtnType * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_ext_CRLNumber__ExtnType_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_ext_CRLNumber__ExtnType(CertImpl_ext_CRLNumber__ExtnType const * pLeft, CertImpl_ext_CRLNumber__ExtnType const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_ext_CRLNumber__ExtnType_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_ext_CRLNumber__ExtnType(CertImpl_ext_CRLNumber__ExtnType * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_ext_CRLNumber__ExtnType_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_ext_CRLNumber__ExtnType(CertImpl_ext_CRLNumber__ExtnType * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_ext_CRLNumber__ExtnType_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_ext_CRLNumber__ExtnType(CertImpl_ext_CRLNumber__ExtnType * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_ext_CRLNumber__ExtnType_descriptor, ppcxt, pf, pstm); } extern const Cert_EXTENSION CertImpl_ext_PolicyMappings; extern const Cert_EXTENSION CertImpl_ext_CRLDistributionPoints; extern const A2C_OBJECT_IDENTIFIER CertImpl_id_holdinstruction_reject; @@ -1200,6 +2487,19 @@ typedef struct { } CertImpl_IssuingDistributionPoint; extern const A2C_DESCRIPTOR CertImpl_IssuingDistributionPoint_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_IssuingDistributionPoint(CertImpl_IssuingDistributionPoint ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_IssuingDistributionPoint_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_IssuingDistributionPoint(CertImpl_IssuingDistributionPoint * p) { return A2C_Free((PVOID) p, &CertImpl_IssuingDistributionPoint_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_IssuingDistributionPoint(CertImpl_IssuingDistributionPoint * p) { return A2C_Init((PVOID) p, &CertImpl_IssuingDistributionPoint_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_IssuingDistributionPoint(CertImpl_IssuingDistributionPoint * p) { return A2C_Release((PVOID) p, &CertImpl_IssuingDistributionPoint_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_IssuingDistributionPoint(CertImpl_IssuingDistributionPoint const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_IssuingDistributionPoint_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_IssuingDistributionPoint(CertImpl_IssuingDistributionPoint * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_IssuingDistributionPoint_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_IssuingDistributionPoint(CertImpl_IssuingDistributionPoint const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_IssuingDistributionPoint_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_IssuingDistributionPoint(CertImpl_IssuingDistributionPoint * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_IssuingDistributionPoint_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_IssuingDistributionPoint(CertImpl_IssuingDistributionPoint * pDst, CertImpl_IssuingDistributionPoint * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_IssuingDistributionPoint_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_IssuingDistributionPoint(CertImpl_IssuingDistributionPoint const * pLeft, CertImpl_IssuingDistributionPoint const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_IssuingDistributionPoint_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_IssuingDistributionPoint(CertImpl_IssuingDistributionPoint * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_IssuingDistributionPoint_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_IssuingDistributionPoint(CertImpl_IssuingDistributionPoint * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_IssuingDistributionPoint_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_IssuingDistributionPoint(CertImpl_IssuingDistributionPoint * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_IssuingDistributionPoint_descriptor, ppcxt, pf, pstm); } extern const Cert_EXTENSION CertImpl_ext_IssuingDistributionPoint; typedef struct { @@ -1210,6 +2510,19 @@ typedef struct { typedef A2C_INTEGER_NATIVE CertImpl_CRLNumber; extern const A2C_DESCRIPTOR CertImpl_CRLNumber_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_CRLNumber(CertImpl_CRLNumber ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_CRLNumber_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_CRLNumber(CertImpl_CRLNumber * p) { return A2C_Free((PVOID) p, &CertImpl_CRLNumber_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_CRLNumber(CertImpl_CRLNumber * p) { return A2C_Init((PVOID) p, &CertImpl_CRLNumber_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_CRLNumber(CertImpl_CRLNumber * p) { return A2C_Release((PVOID) p, &CertImpl_CRLNumber_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_CRLNumber(CertImpl_CRLNumber const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_CRLNumber_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_CRLNumber(CertImpl_CRLNumber * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_CRLNumber_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_CRLNumber(CertImpl_CRLNumber const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_CRLNumber_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_CRLNumber(CertImpl_CRLNumber * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_CRLNumber_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_CRLNumber(CertImpl_CRLNumber * pDst, CertImpl_CRLNumber * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_CRLNumber_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_CRLNumber(CertImpl_CRLNumber const * pLeft, CertImpl_CRLNumber const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_CRLNumber_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_CRLNumber(CertImpl_CRLNumber * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_CRLNumber_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_CRLNumber(CertImpl_CRLNumber * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_CRLNumber_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_CRLNumber(CertImpl_CRLNumber * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_CRLNumber_descriptor, ppcxt, pf, pstm); } extern const A2C_OBJECT_IDENTIFIER CertImpl_id_ce_inhibitAnyPolicy; extern const A2C_OBJECT_IDENTIFIER CertImpl_id_ce_authorityKeyIdentifier; extern const A2C_OBJECT_IDENTIFIER CertImpl_id_ce_cRLNumber; @@ -1224,6 +2537,19 @@ extern const A2C_OBJECT_IDENTIFIER CertImpl_id_ce_certificateIssuer; typedef A2C_BIT_STRING_NAMED CertImpl_KeyUsage; extern const A2C_DESCRIPTOR CertImpl_KeyUsage_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_KeyUsage(CertImpl_KeyUsage ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_KeyUsage_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_KeyUsage(CertImpl_KeyUsage * p) { return A2C_Free((PVOID) p, &CertImpl_KeyUsage_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_KeyUsage(CertImpl_KeyUsage * p) { return A2C_Init((PVOID) p, &CertImpl_KeyUsage_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_KeyUsage(CertImpl_KeyUsage * p) { return A2C_Release((PVOID) p, &CertImpl_KeyUsage_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_KeyUsage(CertImpl_KeyUsage const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_KeyUsage_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_KeyUsage(CertImpl_KeyUsage * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_KeyUsage_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_KeyUsage(CertImpl_KeyUsage const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_KeyUsage_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_KeyUsage(CertImpl_KeyUsage * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_KeyUsage_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_KeyUsage(CertImpl_KeyUsage * pDst, CertImpl_KeyUsage * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_KeyUsage_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_KeyUsage(CertImpl_KeyUsage const * pLeft, CertImpl_KeyUsage const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_KeyUsage_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_KeyUsage(CertImpl_KeyUsage * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_KeyUsage_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_KeyUsage(CertImpl_KeyUsage * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_KeyUsage_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_KeyUsage(CertImpl_KeyUsage * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_KeyUsage_descriptor, ppcxt, pf, pstm); } extern const Cert_EXTENSION CertImpl_ext_KeyUsage; extern const A2C_OBJECT_IDENTIFIER CertImpl_id_kp_timeStamping; extern const A2C_OBJECT_IDENTIFIER CertImpl_id_ce_subjectDirectoryAttributes; @@ -1240,6 +2566,19 @@ typedef struct { } CertImpl_UserNotice; extern const A2C_DESCRIPTOR CertImpl_UserNotice_descriptor; +static __inline A2C_ERROR A2C_Alloc_CertImpl_UserNotice(CertImpl_UserNotice ** p) { return A2C_Alloc((PVOID *) p, &CertImpl_UserNotice_descriptor); } +static __inline A2C_ERROR A2C_Free_CertImpl_UserNotice(CertImpl_UserNotice * p) { return A2C_Free((PVOID) p, &CertImpl_UserNotice_descriptor); } +static __inline A2C_ERROR A2C_Init_CertImpl_UserNotice(CertImpl_UserNotice * p) { return A2C_Init((PVOID) p, &CertImpl_UserNotice_descriptor); } +static __inline A2C_ERROR A2C_Release_CertImpl_UserNotice(CertImpl_UserNotice * p) { return A2C_Release((PVOID) p, &CertImpl_UserNotice_descriptor); } +static __inline A2C_ERROR A2C_EncodeBer_CertImpl_UserNotice(CertImpl_UserNotice const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PCVOID) p, &CertImpl_UserNotice_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeBer_CertImpl_UserNotice(CertImpl_UserNotice * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_UserNotice_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_EncodeDer_CertImpl_UserNotice(CertImpl_UserNotice const * p, int flags, A2C_CONTEXT ** ppcxt, PA2C_STREAM pstm) { return A2C_EncodeBer((PVOID) p, &CertImpl_UserNotice_descriptor, flags, ppcxt, pstm); } +static __inline A2C_ERROR A2C_DecodeDer_CertImpl_UserNotice(CertImpl_UserNotice * p, int flags, A2C_CONTEXT ** ppcxt, PCBYTE pb, size_t cb) { return A2C_DecodeBer((PVOID) p, &CertImpl_UserNotice_descriptor, flags, ppcxt, pb, cb); } +static __inline A2C_ERROR A2C_Copy_CertImpl_UserNotice(CertImpl_UserNotice * pDst, CertImpl_UserNotice * pSrc) { return A2C_Copy((PVOID) pDst, (PCVOID) pSrc, &CertImpl_UserNotice_descriptor); } +static __inline A2C_ERROR A2C_Compare_CertImpl_UserNotice(CertImpl_UserNotice const * pLeft, CertImpl_UserNotice const * pRight) { return A2C_Compare((PCVOID) pLeft, (PCVOID) pRight, &CertImpl_UserNotice_descriptor); } +static __inline A2C_ERROR A2C_Print_CertImpl_UserNotice(CertImpl_UserNotice * p, PA2C_STREAM pstm) { return A2C_Print((PVOID) p, &CertImpl_UserNotice_descriptor, pstm); } +static __inline A2C_ERROR A2C_Validate_CertImpl_UserNotice(CertImpl_UserNotice * p, int * pf) { return A2C_Validate((PVOID) p, &CertImpl_UserNotice_descriptor, pf); } +static __inline A2C_ERROR A2C_Validate2_CertImpl_UserNotice(CertImpl_UserNotice * p, A2C_CONTEXT ** ppcxt, int * pf, PA2C_STREAM pstm) { return A2C_Validate2((PVOID) p, &CertImpl_UserNotice_descriptor, ppcxt, pf, pstm); } extern const CertImpl_POLICY_QUALIFIER_INFO CertImpl_pqid_unotice; extern const A2C_OBJECT_SET CertImpl_PolicyQualifierId; -- 2.11.4.GIT