ASN_CMS_NewRC2CBCParameter( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeRC2CBCParameter( ASN_CMS_CONTEXT *ctx, ASN_CMS_RC2CBCParameter *f); size_t ASN_CMS_SizeofRC2CBCParameter ( ASN_CMS_CONTEXT *ctx, ASN_CMS_RC2CBCParameter *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackRC2CBCParameter( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_RC2CBCParameter *asnstruct, int *erret); size_t ASN_CMS_UnpackRC2CBCParameter( ASN_CMS_CONTEXT *ctx, ASN_CMS_RC2CBCParameter **asnstruct, const unsigned char *buf, size_t buflen, int *erret); #define ASN_CMS_NewRC2wrapParameter (ASN_CMS_RC2wrapParameter *)ASN_CMS_NewRC2ParameterVersion #define ASN_CMS_FreeRC2wrapParameter ASN_CMS_FreeRC2ParameterVersion #define ASN_CMS_SizeofRC2wrapParameter ASN_CMS_SizeofRC2ParameterVersion #define ASN_CMS_PackRC2wrapParameter ASN_CMS_PackRC2ParameterVersion #define ASN_CMS_UnpackRC2wrapParameter ASN_CMS_UnpackRC2ParameterVersion ASN_CMS_Time *ASN_CMS_NewTime( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeTime( ASN_CMS_CONTEXT *ctx, ASN_CMS_Time *f); size_t ASN_CMS_SizeofTime ( ASN_CMS_CONTEXT *ctx, ASN_CMS_Time *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackTime( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_Time *asnstruct, int *erret); size_t ASN_CMS_UnpackTime( ASN_CMS_CONTEXT *ctx, ASN_CMS_Time **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_attrValues_SET_OF *ASN_CMS_NewattrValues_SET_OF( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeattrValues_SET_OF( ASN_CMS_CONTEXT *ctx, ASN_CMS_attrValues_SET_OF *f); size_t ASN_CMS_SizeofattrValues_SET_OF ( ASN_CMS_CONTEXT *ctx, ASN_CMS_attrValues_SET_OF *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackattrValues_SET_OF( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_attrValues_SET_OF *asnstruct, int *erret); size_t ASN_CMS_UnpackattrValues_SET_OF( ASN_CMS_CONTEXT *ctx, ASN_CMS_attrValues_SET_OF **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_Attribute *ASN_CMS_NewAttribute( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeAttribute( ASN_CMS_CONTEXT *ctx, ASN_CMS_Attribute *f); size_t ASN_CMS_SizeofAttribute ( ASN_CMS_CONTEXT *ctx, ASN_CMS_Attribute *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackAttribute( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_Attribute *asnstruct, int *erret); size_t ASN_CMS_UnpackAttribute( ASN_CMS_CONTEXT *ctx, ASN_CMS_Attribute **asnstruct, const unsigned char *buf, size_t buflen, int *erret); #define ASN_CMS_NewContentEncryptionAlgorithmIdentifier (ASN_CMS_ContentEncryptionAlgorithmIdentifier *)ASN_CMS_NewAlgorithmIdentifier #define ASN_CMS_FreeContentEncryptionAlgorithmIdentifier ASN_CMS_FreeAlgorithmIdentifier #define ASN_CMS_SizeofContentEncryptionAlgorithmIdentifier ASN_CMS_SizeofAlgorithmIdentifier #define ASN_CMS_PackContentEncryptionAlgorithmIdentifier ASN_CMS_PackAlgorithmIdentifier #define ASN_CMS_UnpackContentEncryptionAlgorithmIdentifier ASN_CMS_UnpackAlgorithmIdentifier #define ASN_CMS_NewDigestAlgorithmIdentifier (ASN_CMS_DigestAlgorithmIdentifier *)ASN_CMS_NewAlgorithmIdentifier #define ASN_CMS_FreeDigestAlgorithmIdentifier ASN_CMS_FreeAlgorithmIdentifier #define ASN_CMS_SizeofDigestAlgorithmIdentifier ASN_CMS_SizeofAlgorithmIdentifier #define ASN_CMS_PackDigestAlgorithmIdentifier ASN_CMS_PackAlgorithmIdentifier #define ASN_CMS_UnpackDigestAlgorithmIdentifier ASN_CMS_UnpackAlgorithmIdentifier ASN_CMS_Extensions *ASN_CMS_NewExtensions( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeExtensions( ASN_CMS_CONTEXT *ctx, ASN_CMS_Extensions *f); size_t ASN_CMS_SizeofExtensions ( ASN_CMS_CONTEXT *ctx, ASN_CMS_Extensions *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackExtensions( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_Extensions *asnstruct, int *erret); size_t ASN_CMS_UnpackExtensions( ASN_CMS_CONTEXT *ctx, ASN_CMS_Extensions **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_KEKIdentifier *ASN_CMS_NewKEKIdentifier( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeKEKIdentifier( ASN_CMS_CONTEXT *ctx, ASN_CMS_KEKIdentifier *f); size_t ASN_CMS_SizeofKEKIdentifier ( ASN_CMS_CONTEXT *ctx, ASN_CMS_KEKIdentifier *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackKEKIdentifier( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_KEKIdentifier *asnstruct, int *erret); size_t ASN_CMS_UnpackKEKIdentifier( ASN_CMS_CONTEXT *ctx, ASN_CMS_KEKIdentifier **asnstruct, const unsigned char *buf, size_t buflen, int *erret); #define ASN_CMS_NewKeyEncryptionAlgorithmIdentifier (ASN_CMS_KeyEncryptionAlgorithmIdentifier *)ASN_CMS_NewAlgorithmIdentifier #define ASN_CMS_FreeKeyEncryptionAlgorithmIdentifier ASN_CMS_FreeAlgorithmIdentifier #define ASN_CMS_SizeofKeyEncryptionAlgorithmIdentifier ASN_CMS_SizeofAlgorithmIdentifier #define ASN_CMS_PackKeyEncryptionAlgorithmIdentifier ASN_CMS_PackAlgorithmIdentifier #define ASN_CMS_UnpackKeyEncryptionAlgorithmIdentifier ASN_CMS_UnpackAlgorithmIdentifier #define ASN_CMS_NewKeyWrapAlgorithm (ASN_CMS_KeyWrapAlgorithm *)ASN_CMS_NewAlgorithmIdentifier #define ASN_CMS_FreeKeyWrapAlgorithm ASN_CMS_FreeAlgorithmIdentifier #define ASN_CMS_SizeofKeyWrapAlgorithm ASN_CMS_SizeofAlgorithmIdentifier #define ASN_CMS_PackKeyWrapAlgorithm ASN_CMS_PackAlgorithmIdentifier #define ASN_CMS_UnpackKeyWrapAlgorithm ASN_CMS_UnpackAlgorithmIdentifier #define ASN_CMS_NewMessageAuthenticationCodeAlgorithm (ASN_CMS_MessageAuthenticationCodeAlgorithm *)ASN_CMS_NewAlgorithmIdentifier #define ASN_CMS_FreeMessageAuthenticationCodeAlgorithm ASN_CMS_FreeAlgorithmIdentifier #define ASN_CMS_SizeofMessageAuthenticationCodeAlgorithm ASN_CMS_SizeofAlgorithmIdentifier #define ASN_CMS_PackMessageAuthenticationCodeAlgorithm ASN_CMS_PackAlgorithmIdentifier #define ASN_CMS_UnpackMessageAuthenticationCodeAlgorithm ASN_CMS_UnpackAlgorithmIdentifier ASN_CMS_OriginatorPublicKey *ASN_CMS_NewOriginatorPublicKey( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeOriginatorPublicKey( ASN_CMS_CONTEXT *ctx, ASN_CMS_OriginatorPublicKey *f); size_t ASN_CMS_SizeofOriginatorPublicKey ( ASN_CMS_CONTEXT *ctx, ASN_CMS_OriginatorPublicKey *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackOriginatorPublicKey( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_OriginatorPublicKey *asnstruct, int *erret); size_t ASN_CMS_UnpackOriginatorPublicKey( ASN_CMS_CONTEXT *ctx, ASN_CMS_OriginatorPublicKey **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_RecipientIdentifier *ASN_CMS_NewRecipientIdentifier( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeRecipientIdentifier( ASN_CMS_CONTEXT *ctx, ASN_CMS_RecipientIdentifier *f); size_t ASN_CMS_SizeofRecipientIdentifier ( ASN_CMS_CONTEXT *ctx, ASN_CMS_RecipientIdentifier *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackRecipientIdentifier( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_RecipientIdentifier *asnstruct, int *erret); size_t ASN_CMS_UnpackRecipientIdentifier( ASN_CMS_CONTEXT *ctx, ASN_CMS_RecipientIdentifier **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_RecipientKeyIdentifier *ASN_CMS_NewRecipientKeyIdentifier( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeRecipientKeyIdentifier( ASN_CMS_CONTEXT *ctx, ASN_CMS_RecipientKeyIdentifier *f); size_t ASN_CMS_SizeofRecipientKeyIdentifier ( ASN_CMS_CONTEXT *ctx, ASN_CMS_RecipientKeyIdentifier *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackRecipientKeyIdentifier( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_RecipientKeyIdentifier *asnstruct, int *erret); size_t ASN_CMS_UnpackRecipientKeyIdentifier( ASN_CMS_CONTEXT *ctx, ASN_CMS_RecipientKeyIdentifier **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_RelativeDistinguishedName *ASN_CMS_NewRelativeDistinguishedName( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeRelativeDistinguishedName( ASN_CMS_CONTEXT *ctx, ASN_CMS_RelativeDistinguishedName *f); size_t ASN_CMS_SizeofRelativeDistinguishedName ( ASN_CMS_CONTEXT *ctx, ASN_CMS_RelativeDistinguishedName *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackRelativeDistinguishedName( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_RelativeDistinguishedName *asnstruct, int *erret); size_t ASN_CMS_UnpackRelativeDistinguishedName( ASN_CMS_CONTEXT *ctx, ASN_CMS_RelativeDistinguishedName **asnstruct, const unsigned char *buf, size_t buflen, int *erret); #define ASN_CMS_NewSignatureAlgorithmIdentifier (ASN_CMS_SignatureAlgorithmIdentifier *)ASN_CMS_NewAlgorithmIdentifier #define ASN_CMS_FreeSignatureAlgorithmIdentifier ASN_CMS_FreeAlgorithmIdentifier #define ASN_CMS_SizeofSignatureAlgorithmIdentifier ASN_CMS_SizeofAlgorithmIdentifier #define ASN_CMS_PackSignatureAlgorithmIdentifier ASN_CMS_PackAlgorithmIdentifier #define ASN_CMS_UnpackSignatureAlgorithmIdentifier ASN_CMS_UnpackAlgorithmIdentifier ASN_CMS_SignerIdentifier *ASN_CMS_NewSignerIdentifier( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeSignerIdentifier( ASN_CMS_CONTEXT *ctx, ASN_CMS_SignerIdentifier *f); size_t ASN_CMS_SizeofSignerIdentifier ( ASN_CMS_CONTEXT *ctx, ASN_CMS_SignerIdentifier *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackSignerIdentifier( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_SignerIdentifier *asnstruct, int *erret); size_t ASN_CMS_UnpackSignerIdentifier( ASN_CMS_CONTEXT *ctx, ASN_CMS_SignerIdentifier **asnstruct, const unsigned char *buf, size_t buflen, int *erret); #define ASN_CMS_NewSigningTime (ASN_CMS_SigningTime *)ASN_CMS_NewTime #define ASN_CMS_FreeSigningTime ASN_CMS_FreeTime #define ASN_CMS_SizeofSigningTime ASN_CMS_SizeofTime #define ASN_CMS_PackSigningTime ASN_CMS_PackTime #define ASN_CMS_UnpackSigningTime ASN_CMS_UnpackTime ASN_CMS_SubjectPublicKeyInfo *ASN_CMS_NewSubjectPublicKeyInfo( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeSubjectPublicKeyInfo( ASN_CMS_CONTEXT *ctx, ASN_CMS_SubjectPublicKeyInfo *f); size_t ASN_CMS_SizeofSubjectPublicKeyInfo ( ASN_CMS_CONTEXT *ctx, ASN_CMS_SubjectPublicKeyInfo *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackSubjectPublicKeyInfo( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_SubjectPublicKeyInfo *asnstruct, int *erret); size_t ASN_CMS_UnpackSubjectPublicKeyInfo( ASN_CMS_CONTEXT *ctx, ASN_CMS_SubjectPublicKeyInfo **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_Validity *ASN_CMS_NewValidity( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeValidity( ASN_CMS_CONTEXT *ctx, ASN_CMS_Validity *f); size_t ASN_CMS_SizeofValidity ( ASN_CMS_CONTEXT *ctx, ASN_CMS_Validity *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackValidity( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_Validity *asnstruct, int *erret); size_t ASN_CMS_UnpackValidity( ASN_CMS_CONTEXT *ctx, ASN_CMS_Validity **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_AuthAttributes *ASN_CMS_NewAuthAttributes( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeAuthAttributes( ASN_CMS_CONTEXT *ctx, ASN_CMS_AuthAttributes *f); size_t ASN_CMS_SizeofAuthAttributes ( ASN_CMS_CONTEXT *ctx, ASN_CMS_AuthAttributes *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackAuthAttributes( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_AuthAttributes *asnstruct, int *erret); size_t ASN_CMS_UnpackAuthAttributes( ASN_CMS_CONTEXT *ctx, ASN_CMS_AuthAttributes **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_DigestAlgorithmIdentifiers *ASN_CMS_NewDigestAlgorithmIdentifiers( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeDigestAlgorithmIdentifiers( ASN_CMS_CONTEXT *ctx, ASN_CMS_DigestAlgorithmIdentifiers *f); size_t ASN_CMS_SizeofDigestAlgorithmIdentifiers ( ASN_CMS_CONTEXT *ctx, ASN_CMS_DigestAlgorithmIdentifiers *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackDigestAlgorithmIdentifiers( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_DigestAlgorithmIdentifiers *asnstruct, int *erret); size_t ASN_CMS_UnpackDigestAlgorithmIdentifiers( ASN_CMS_CONTEXT *ctx, ASN_CMS_DigestAlgorithmIdentifiers **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_DigestedData *ASN_CMS_NewDigestedData( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeDigestedData( ASN_CMS_CONTEXT *ctx, ASN_CMS_DigestedData *f); size_t ASN_CMS_SizeofDigestedData ( ASN_CMS_CONTEXT *ctx, ASN_CMS_DigestedData *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackDigestedData( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_DigestedData *asnstruct, int *erret); size_t ASN_CMS_UnpackDigestedData( ASN_CMS_CONTEXT *ctx, ASN_CMS_DigestedData **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_EncryptedContentInfo *ASN_CMS_NewEncryptedContentInfo( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeEncryptedContentInfo( ASN_CMS_CONTEXT *ctx, ASN_CMS_EncryptedContentInfo *f); size_t ASN_CMS_SizeofEncryptedContentInfo ( ASN_CMS_CONTEXT *ctx, ASN_CMS_EncryptedContentInfo *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackEncryptedContentInfo( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_EncryptedContentInfo *asnstruct, int *erret); size_t ASN_CMS_UnpackEncryptedContentInfo( ASN_CMS_CONTEXT *ctx, ASN_CMS_EncryptedContentInfo **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_KEKRecipientInfo *ASN_CMS_NewKEKRecipientInfo( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeKEKRecipientInfo( ASN_CMS_CONTEXT *ctx, ASN_CMS_KEKRecipientInfo *f); size_t ASN_CMS_SizeofKEKRecipientInfo ( ASN_CMS_CONTEXT *ctx, ASN_CMS_KEKRecipientInfo *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackKEKRecipientInfo( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_KEKRecipientInfo *asnstruct, int *erret); size_t ASN_CMS_UnpackKEKRecipientInfo( ASN_CMS_CONTEXT *ctx, ASN_CMS_KEKRecipientInfo **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_KeyAgreeRecipientIdentifier *ASN_CMS_NewKeyAgreeRecipientIdentifier( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeKeyAgreeRecipientIdentifier( ASN_CMS_CONTEXT *ctx, ASN_CMS_KeyAgreeRecipientIdentifier *f); size_t ASN_CMS_SizeofKeyAgreeRecipientIdentifier ( ASN_CMS_CONTEXT *ctx, ASN_CMS_KeyAgreeRecipientIdentifier *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackKeyAgreeRecipientIdentifier( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_KeyAgreeRecipientIdentifier *asnstruct, int *erret); size_t ASN_CMS_UnpackKeyAgreeRecipientIdentifier( ASN_CMS_CONTEXT *ctx, ASN_CMS_KeyAgreeRecipientIdentifier **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_KeyTransRecipientInfo *ASN_CMS_NewKeyTransRecipientInfo( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeKeyTransRecipientInfo( ASN_CMS_CONTEXT *ctx, ASN_CMS_KeyTransRecipientInfo *f); size_t ASN_CMS_SizeofKeyTransRecipientInfo ( ASN_CMS_CONTEXT *ctx, ASN_CMS_KeyTransRecipientInfo *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackKeyTransRecipientInfo( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_KeyTransRecipientInfo *asnstruct, int *erret); size_t ASN_CMS_UnpackKeyTransRecipientInfo( ASN_CMS_CONTEXT *ctx, ASN_CMS_KeyTransRecipientInfo **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_OriginatorIdentifierOrKey *ASN_CMS_NewOriginatorIdentifierOrKey( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeOriginatorIdentifierOrKey( ASN_CMS_CONTEXT *ctx, ASN_CMS_OriginatorIdentifierOrKey *f); size_t ASN_CMS_SizeofOriginatorIdentifierOrKey ( ASN_CMS_CONTEXT *ctx, ASN_CMS_OriginatorIdentifierOrKey *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackOriginatorIdentifierOrKey( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_OriginatorIdentifierOrKey *asnstruct, int *erret); size_t ASN_CMS_UnpackOriginatorIdentifierOrKey( ASN_CMS_CONTEXT *ctx, ASN_CMS_OriginatorIdentifierOrKey **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_RDNSequence *ASN_CMS_NewRDNSequence( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeRDNSequence( ASN_CMS_CONTEXT *ctx, ASN_CMS_RDNSequence *f); size_t ASN_CMS_SizeofRDNSequence ( ASN_CMS_CONTEXT *ctx, ASN_CMS_RDNSequence *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackRDNSequence( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_RDNSequence *asnstruct, int *erret); size_t ASN_CMS_UnpackRDNSequence( ASN_CMS_CONTEXT *ctx, ASN_CMS_RDNSequence **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_SignedAttributes *ASN_CMS_NewSignedAttributes( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeSignedAttributes( ASN_CMS_CONTEXT *ctx, ASN_CMS_SignedAttributes *f); size_t ASN_CMS_SizeofSignedAttributes ( ASN_CMS_CONTEXT *ctx, ASN_CMS_SignedAttributes *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackSignedAttributes( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_SignedAttributes *asnstruct, int *erret); size_t ASN_CMS_UnpackSignedAttributes( ASN_CMS_CONTEXT *ctx, ASN_CMS_SignedAttributes **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_ToBeSigned *ASN_CMS_NewToBeSigned( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeToBeSigned( ASN_CMS_CONTEXT *ctx, ASN_CMS_ToBeSigned *f); size_t ASN_CMS_SizeofToBeSigned ( ASN_CMS_CONTEXT *ctx, ASN_CMS_ToBeSigned *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackToBeSigned( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_ToBeSigned *asnstruct, int *erret); size_t ASN_CMS_UnpackToBeSigned( ASN_CMS_CONTEXT *ctx, ASN_CMS_ToBeSigned **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_UnauthAttributes *ASN_CMS_NewUnauthAttributes( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeUnauthAttributes( ASN_CMS_CONTEXT *ctx, ASN_CMS_UnauthAttributes *f); size_t ASN_CMS_SizeofUnauthAttributes ( ASN_CMS_CONTEXT *ctx, ASN_CMS_UnauthAttributes *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackUnauthAttributes( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_UnauthAttributes *asnstruct, int *erret); size_t ASN_CMS_UnpackUnauthAttributes( ASN_CMS_CONTEXT *ctx, ASN_CMS_UnauthAttributes **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_UnprotectedAttributes *ASN_CMS_NewUnprotectedAttributes( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeUnprotectedAttributes( ASN_CMS_CONTEXT *ctx, ASN_CMS_UnprotectedAttributes *f); size_t ASN_CMS_SizeofUnprotectedAttributes ( ASN_CMS_CONTEXT *ctx, ASN_CMS_UnprotectedAttributes *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackUnprotectedAttributes( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_UnprotectedAttributes *asnstruct, int *erret); size_t ASN_CMS_UnpackUnprotectedAttributes( ASN_CMS_CONTEXT *ctx, ASN_CMS_UnprotectedAttributes **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_UnsignedAttributes *ASN_CMS_NewUnsignedAttributes( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeUnsignedAttributes( ASN_CMS_CONTEXT *ctx, ASN_CMS_UnsignedAttributes *f); size_t ASN_CMS_SizeofUnsignedAttributes ( ASN_CMS_CONTEXT *ctx, ASN_CMS_UnsignedAttributes *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackUnsignedAttributes( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_UnsignedAttributes *asnstruct, int *erret); size_t ASN_CMS_UnpackUnsignedAttributes( ASN_CMS_CONTEXT *ctx, ASN_CMS_UnsignedAttributes **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_revokedCertificates_SEQ_OF_SEQUENCE *ASN_CMS_NewrevokedCertificates_SEQ_OF_SEQUENCE( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreerevokedCertificates_SEQ_OF_SEQUENCE( ASN_CMS_CONTEXT *ctx, ASN_CMS_revokedCertificates_SEQ_OF_SEQUENCE *f); size_t ASN_CMS_SizeofrevokedCertificates_SEQ_OF_SEQUENCE ( ASN_CMS_CONTEXT *ctx, ASN_CMS_revokedCertificates_SEQ_OF_SEQUENCE *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackrevokedCertificates_SEQ_OF_SEQUENCE( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_revokedCertificates_SEQ_OF_SEQUENCE *asnstruct, int *erret); size_t ASN_CMS_UnpackrevokedCertificates_SEQ_OF_SEQUENCE( ASN_CMS_CONTEXT *ctx, ASN_CMS_revokedCertificates_SEQ_OF_SEQUENCE **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_Certificate *ASN_CMS_NewCertificate( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeCertificate( ASN_CMS_CONTEXT *ctx, ASN_CMS_Certificate *f); size_t ASN_CMS_SizeofCertificate ( ASN_CMS_CONTEXT *ctx, ASN_CMS_Certificate *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackCertificate( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_Certificate *asnstruct, int *erret); size_t ASN_CMS_UnpackCertificate( ASN_CMS_CONTEXT *ctx, ASN_CMS_Certificate **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_EncryptedData *ASN_CMS_NewEncryptedData( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeEncryptedData( ASN_CMS_CONTEXT *ctx, ASN_CMS_EncryptedData *f); size_t ASN_CMS_SizeofEncryptedData ( ASN_CMS_CONTEXT *ctx, ASN_CMS_EncryptedData *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackEncryptedData( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_EncryptedData *asnstruct, int *erret); size_t ASN_CMS_UnpackEncryptedData( ASN_CMS_CONTEXT *ctx, ASN_CMS_EncryptedData **asnstruct, const unsigned char *buf, size_t buflen, int *erret); #define ASN_CMS_NewName (ASN_CMS_Name *)ASN_CMS_NewRDNSequence #define ASN_CMS_FreeName ASN_CMS_FreeRDNSequence #define ASN_CMS_SizeofName ASN_CMS_SizeofRDNSequence #define ASN_CMS_PackName ASN_CMS_PackRDNSequence #define ASN_CMS_UnpackName ASN_CMS_UnpackRDNSequence ASN_CMS_RecipientEncryptedKey *ASN_CMS_NewRecipientEncryptedKey( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeRecipientEncryptedKey( ASN_CMS_CONTEXT *ctx, ASN_CMS_RecipientEncryptedKey *f); size_t ASN_CMS_SizeofRecipientEncryptedKey ( ASN_CMS_CONTEXT *ctx, ASN_CMS_RecipientEncryptedKey *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackRecipientEncryptedKey( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_RecipientEncryptedKey *asnstruct, int *erret); size_t ASN_CMS_UnpackRecipientEncryptedKey( ASN_CMS_CONTEXT *ctx, ASN_CMS_RecipientEncryptedKey **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_SignerInfo *ASN_CMS_NewSignerInfo( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeSignerInfo( ASN_CMS_CONTEXT *ctx, ASN_CMS_SignerInfo *f); size_t ASN_CMS_SizeofSignerInfo ( ASN_CMS_CONTEXT *ctx, ASN_CMS_SignerInfo *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackSignerInfo( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_SignerInfo *asnstruct, int *erret); size_t ASN_CMS_UnpackSignerInfo( ASN_CMS_CONTEXT *ctx, ASN_CMS_SignerInfo **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_revokedCertificates_SEQ_OF *ASN_CMS_NewrevokedCertificates_SEQ_OF( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreerevokedCertificates_SEQ_OF( ASN_CMS_CONTEXT *ctx, ASN_CMS_revokedCertificates_SEQ_OF *f); size_t ASN_CMS_SizeofrevokedCertificates_SEQ_OF ( ASN_CMS_CONTEXT *ctx, ASN_CMS_revokedCertificates_SEQ_OF *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackrevokedCertificates_SEQ_OF( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_revokedCertificates_SEQ_OF *asnstruct, int *erret); size_t ASN_CMS_UnpackrevokedCertificates_SEQ_OF( ASN_CMS_CONTEXT *ctx, ASN_CMS_revokedCertificates_SEQ_OF **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_CertificateList *ASN_CMS_NewCertificateList( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeCertificateList( ASN_CMS_CONTEXT *ctx, ASN_CMS_CertificateList *f); size_t ASN_CMS_SizeofCertificateList ( ASN_CMS_CONTEXT *ctx, ASN_CMS_CertificateList *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackCertificateList( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_CertificateList *asnstruct, int *erret); size_t ASN_CMS_UnpackCertificateList( ASN_CMS_CONTEXT *ctx, ASN_CMS_CertificateList **asnstruct, const unsigned char *buf, size_t buflen, int *erret); #define ASN_CMS_NewCountersignature (ASN_CMS_Countersignature *)ASN_CMS_NewSignerInfo #define ASN_CMS_FreeCountersignature ASN_CMS_FreeSignerInfo #define ASN_CMS_SizeofCountersignature ASN_CMS_SizeofSignerInfo #define ASN_CMS_PackCountersignature ASN_CMS_PackSignerInfo #define ASN_CMS_UnpackCountersignature ASN_CMS_UnpackSignerInfo ASN_CMS_ExtendedCertificateInfo *ASN_CMS_NewExtendedCertificateInfo( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeExtendedCertificateInfo( ASN_CMS_CONTEXT *ctx, ASN_CMS_ExtendedCertificateInfo *f); size_t ASN_CMS_SizeofExtendedCertificateInfo ( ASN_CMS_CONTEXT *ctx, ASN_CMS_ExtendedCertificateInfo *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackExtendedCertificateInfo( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_ExtendedCertificateInfo *asnstruct, int *erret); size_t ASN_CMS_UnpackExtendedCertificateInfo( ASN_CMS_CONTEXT *ctx, ASN_CMS_ExtendedCertificateInfo **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_RecipientEncryptedKeys *ASN_CMS_NewRecipientEncryptedKeys( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeRecipientEncryptedKeys( ASN_CMS_CONTEXT *ctx, ASN_CMS_RecipientEncryptedKeys *f); size_t ASN_CMS_SizeofRecipientEncryptedKeys ( ASN_CMS_CONTEXT *ctx, ASN_CMS_RecipientEncryptedKeys *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackRecipientEncryptedKeys( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_RecipientEncryptedKeys *asnstruct, int *erret); size_t ASN_CMS_UnpackRecipientEncryptedKeys( ASN_CMS_CONTEXT *ctx, ASN_CMS_RecipientEncryptedKeys **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_SignerInfos *ASN_CMS_NewSignerInfos( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeSignerInfos( ASN_CMS_CONTEXT *ctx, ASN_CMS_SignerInfos *f); size_t ASN_CMS_SizeofSignerInfos ( ASN_CMS_CONTEXT *ctx, ASN_CMS_SignerInfos *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackSignerInfos( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_SignerInfos *asnstruct, int *erret); size_t ASN_CMS_UnpackSignerInfos( ASN_CMS_CONTEXT *ctx, ASN_CMS_SignerInfos **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_CertificateRevocationLists *ASN_CMS_NewCertificateRevocationLists( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeCertificateRevocationLists( ASN_CMS_CONTEXT *ctx, ASN_CMS_CertificateRevocationLists *f); size_t ASN_CMS_SizeofCertificateRevocationLists ( ASN_CMS_CONTEXT *ctx, ASN_CMS_CertificateRevocationLists *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackCertificateRevocationLists( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_CertificateRevocationLists *asnstruct, int *erret); size_t ASN_CMS_UnpackCertificateRevocationLists( ASN_CMS_CONTEXT *ctx, ASN_CMS_CertificateRevocationLists **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_ExtendedCertificate *ASN_CMS_NewExtendedCertificate( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeExtendedCertificate( ASN_CMS_CONTEXT *ctx, ASN_CMS_ExtendedCertificate *f); size_t ASN_CMS_SizeofExtendedCertificate ( ASN_CMS_CONTEXT *ctx, ASN_CMS_ExtendedCertificate *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackExtendedCertificate( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_ExtendedCertificate *asnstruct, int *erret); size_t ASN_CMS_UnpackExtendedCertificate( ASN_CMS_CONTEXT *ctx, ASN_CMS_ExtendedCertificate **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_KeyAgreeRecipientInfo *ASN_CMS_NewKeyAgreeRecipientInfo( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeKeyAgreeRecipientInfo( ASN_CMS_CONTEXT *ctx, ASN_CMS_KeyAgreeRecipientInfo *f); size_t ASN_CMS_SizeofKeyAgreeRecipientInfo ( ASN_CMS_CONTEXT *ctx, ASN_CMS_KeyAgreeRecipientInfo *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackKeyAgreeRecipientInfo( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_KeyAgreeRecipientInfo *asnstruct, int *erret); size_t ASN_CMS_UnpackKeyAgreeRecipientInfo( ASN_CMS_CONTEXT *ctx, ASN_CMS_KeyAgreeRecipientInfo **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_CertificateChoices *ASN_CMS_NewCertificateChoices( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeCertificateChoices( ASN_CMS_CONTEXT *ctx, ASN_CMS_CertificateChoices *f); size_t ASN_CMS_SizeofCertificateChoices ( ASN_CMS_CONTEXT *ctx, ASN_CMS_CertificateChoices *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackCertificateChoices( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_CertificateChoices *asnstruct, int *erret); size_t ASN_CMS_UnpackCertificateChoices( ASN_CMS_CONTEXT *ctx, ASN_CMS_CertificateChoices **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_RecipientInfo *ASN_CMS_NewRecipientInfo( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeRecipientInfo( ASN_CMS_CONTEXT *ctx, ASN_CMS_RecipientInfo *f); size_t ASN_CMS_SizeofRecipientInfo ( ASN_CMS_CONTEXT *ctx, ASN_CMS_RecipientInfo *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackRecipientInfo( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_RecipientInfo *asnstruct, int *erret); size_t ASN_CMS_UnpackRecipientInfo( ASN_CMS_CONTEXT *ctx, ASN_CMS_RecipientInfo **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_CertificateSet *ASN_CMS_NewCertificateSet( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeCertificateSet( ASN_CMS_CONTEXT *ctx, ASN_CMS_CertificateSet *f); size_t ASN_CMS_SizeofCertificateSet ( ASN_CMS_CONTEXT *ctx, ASN_CMS_CertificateSet *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackCertificateSet( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_CertificateSet *asnstruct, int *erret); size_t ASN_CMS_UnpackCertificateSet( ASN_CMS_CONTEXT *ctx, ASN_CMS_CertificateSet **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_RecipientInfos *ASN_CMS_NewRecipientInfos( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeRecipientInfos( ASN_CMS_CONTEXT *ctx, ASN_CMS_RecipientInfos *f); size_t ASN_CMS_SizeofRecipientInfos ( ASN_CMS_CONTEXT *ctx, ASN_CMS_RecipientInfos *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackRecipientInfos( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_RecipientInfos *asnstruct, int *erret); size_t ASN_CMS_UnpackRecipientInfos( ASN_CMS_CONTEXT *ctx, ASN_CMS_RecipientInfos **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_OriginatorInfo *ASN_CMS_NewOriginatorInfo( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeOriginatorInfo( ASN_CMS_CONTEXT *ctx, ASN_CMS_OriginatorInfo *f); size_t ASN_CMS_SizeofOriginatorInfo ( ASN_CMS_CONTEXT *ctx, ASN_CMS_OriginatorInfo *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackOriginatorInfo( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_OriginatorInfo *asnstruct, int *erret); size_t ASN_CMS_UnpackOriginatorInfo( ASN_CMS_CONTEXT *ctx, ASN_CMS_OriginatorInfo **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_SignedData *ASN_CMS_NewSignedData( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeSignedData( ASN_CMS_CONTEXT *ctx, ASN_CMS_SignedData *f); size_t ASN_CMS_SizeofSignedData ( ASN_CMS_CONTEXT *ctx, ASN_CMS_SignedData *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackSignedData( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_SignedData *asnstruct, int *erret); size_t ASN_CMS_UnpackSignedData( ASN_CMS_CONTEXT *ctx, ASN_CMS_SignedData **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_AuthenticatedData *ASN_CMS_NewAuthenticatedData( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeAuthenticatedData( ASN_CMS_CONTEXT *ctx, ASN_CMS_AuthenticatedData *f); size_t ASN_CMS_SizeofAuthenticatedData ( ASN_CMS_CONTEXT *ctx, ASN_CMS_AuthenticatedData *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackAuthenticatedData( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_AuthenticatedData *asnstruct, int *erret); size_t ASN_CMS_UnpackAuthenticatedData( ASN_CMS_CONTEXT *ctx, ASN_CMS_AuthenticatedData **asnstruct, const unsigned char *buf, size_t buflen, int *erret); ASN_CMS_EnvelopedData *ASN_CMS_NewEnvelopedData( ASN_CMS_CONTEXT *ctx); void ASN_CMS_FreeEnvelopedData( ASN_CMS_CONTEXT *ctx, ASN_CMS_EnvelopedData *f); size_t ASN_CMS_SizeofEnvelopedData ( ASN_CMS_CONTEXT *ctx, ASN_CMS_EnvelopedData *asnstruct, int outerSizeFlag); size_t ASN_CMS_PackEnvelopedData( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_EnvelopedData *asnstruct, int *erret); size_t ASN_CMS_UnpackEnvelopedData( ASN_CMS_CONTEXT *ctx, ASN_CMS_EnvelopedData **asnstruct, const unsigned char *buf, size_t buflen, int *erret); #endif /* pgpASN_CMS_ASN_H_ */ ock for it */ bytesused = ASN_CMS_UnpkInPlacerevokedCertificates_SEQ_OF_SEQUENCE(ctx, local, buf, buflen, tag, erret); if (*erret != 0) { if (local != NULL) ASN_CMS_FreerevokedCertificates_SEQ_OF_SEQUENCE(ctx, local); return 0; } *asnstruct = local; return bytesused; } /* ASN_CMS_UnpackrevokedCertificates_SEQ_OF_SEQUENCEInternal */ /****************************************************************** * Routines for Certificate ******************************************************************/ size_t ASN_CMS_SizeofCertificateInternal( ASN_CMS_Certificate *asnstruct, int outerSizeFlag, int expTaggedFlag) { size_t body_size = 0; if (asnstruct == NULL) return 0; body_size = ASN_CMS_SizeofToBeSignedInternal(&asnstruct->tbsCertificate, ASN_CMS_TRUE, ASN_CMS_FALSE) + ASN_CMS_SizeofAlgorithmIdentifierInternal(&asnstruct->signatureAlgorithm, ASN_CMS_TRUE, ASN_CMS_FALSE) + ASN_CMS_SizeofBIT_STRINGInternal(&asnstruc/******************************************************************* * * This file was generated by TIS/ASN1COMP Ver. 4.3 (mod 7), an ASN.1 compiler. * TIS/ASN1COMP is Copyright (c) 1998, TIS Labs at Network Associates, Inc. * * This file was AUTOMATICALLY GENERATED on Tue May 13 17:29:00 2003 * ******************************************************************/ /****************************************************************** * * Defines for OIDs * *******************************************************************/ #ifndef _pgpASN_CMS_oid_H_ #define _pgpASN_CMS_oid_H_ extern unsigned char ASN_CMS_pkcs_OID[]; #define ASN_CMS_pkcs_OID_LEN 7 extern unsigned char ASN_CMS_dhKeyAgreement_OID[]; #define ASN_CMS_dhKeyAgreement_OID_LEN 9 extern unsigned char ASN_CMS_des_ede3_cbc_OID[]; #define ASN_CMS_des_ede3_cbc_OID_LEN 8 extern unsigned char ASN_CMS_aes_OID[]; #define ASN_CMS_aes_OID_LEN 8 extern unsigned char ASN_CMS_md5_OID[]; #define ASN_CMS_md5_OID_LEN 8 extern unsigned char ASN_CMS_id_dsa_with_sha1_OID[]; #define ASN_CMS_id_dsa_with_sha1_OID_LEN 7 extern unsigned char ASN_CMS_dh_public_number_OID[]; #define ASN_CMS_dh_public_number_OID_LEN 7 extern unsigned char ASN_CMS_id_alg_ESDH_OID[]; #define ASN_CMS_id_alg_ESDH_OID_LEN 11 extern unsigned char ASN_CMS_id_alg_CMS3DESwrap_OID[]; #define ASN_CMS_id_alg_CMS3DESwrap_OID_LEN 11 extern unsigned char ASN_CMS_hMAC_SHA1_OID[]; #define ASN_CMS_hMAC_SHA1_OID_LEN 8 extern unsigned char ASN_CMS_id_RSAES_OAEP_OID[]; #define ASN_CMS_id_RSAES_OAEP_OID_LEN 9 extern unsigned char ASN_CMS_id_aes128_CBC_OID[]; #define ASN_CMS_id_aes128_CBC_OID_LEN 9 extern unsigned char ASN_CMS_id_aes192_CBC_OID[]; #define ASN_CMS_id_aes192_CBC_OID_LEN 9 extern unsigned char ASN_CMS_id_aes256_CBC_OID[]; #define ASN_CMS_id_aes256_CBC_OID_LEN 9 extern unsigned char ASN_CMS_id_alg_CMSRC2wrap_OID[]; #define ASN_CMS_id_alg_CMSRC2wrap_OID_LEN 11 extern unsigned char ASN_CMS_id_ct_contentInfo_OID[]; #define ASN_CMS_id_ct_contentInfo_OID_LEN 11 extern unsigned char ASN_CMS_id_ct_authData_OID[]; #define ASN_CMS_id_ct_authData_OID_LEN 11 extern unsigned char ASN_CMS_id_contentType_OID[]; #define ASN_CMS_id_contentType_OID_LEN 9 extern unsigned char ASN_CMS_id_ce_OID[]; #define ASN_CMS_id_ce_OID_LEN 2 extern unsigned char ASN_CMS_id_ce_subjectKeyIdentifier_OID[]; #define ASN_CMS_id_ce_subjectKeyIdentifier_OID_LEN 3 extern unsigned char ASN_CMS_id_countersignature_OID[]; #define ASN_CMS_id_countersignature_OID_LEN 9 extern unsigned char ASN_CMS_id_data_OID[]; #define ASN_CMS_id_data_OID_LEN 9 extern unsigned char ASN_CMS_id_digestedData_OID[]; #define ASN_CMS_id_digestedData_OID_LEN 9 extern unsigned char ASN_CMS_id_signedData_OID[]; #define ASN_CMS_id_signedData_OID_LEN 9 extern unsigned char ASN_CMS_id_envelopedData_OID[]; #define ASN_CMS_id_envelopedData_OID_LEN 9 extern unsigned char ASN_CMS_id_encryptedData_OID[]; #define ASN_CMS_id_encryptedData_OID_LEN 9 extern unsigned char ASN_CMS_id_messageDigest_OID[]; #define ASN_CMS_id_messageDigest_OID_LEN 9 extern unsigned char ASN_CMS_id_signingTime_OID[]; #define ASN_CMS_id_signingTime_OID_LEN 9 extern unsigned char ASN_CMS_pkcs_1_OID[]; #define ASN_CMS_pkcs_1_OID_LEN 8 extern unsigned char ASN_CMS_pkcs_3_OID[]; #define ASN_CMS_pkcs_3_OID_LEN 8 extern unsigned char ASN_CMS_pkcs_7_OID[]; #define ASN_CMS_pkcs_7_OID_LEN 8 extern unsigned char ASN_CMS_pkcs_9_OID[]; #define ASN_CMS_pkcs_9_OID_LEN 8 extern unsigned char ASN_CMS_sha_1_OID[]; #define ASN_CMS_sha_1_OID_LEN 5 extern unsigned char ASN_CMS_rsaEncryption_OID[]; #define ASN_CMS_rsaEncryption_OID_LEN 9 extern unsigned char ASN_CMS_rc2_cbc_OID[]; #define ASN_CMS_rc2_cbc_OID_LEN 8 #endif /* _pgpASN_CMS_H_*/ /******************************************************************* * * This file was generated by TIS/ASN1COMP Ver. 4.3 (mod 7), an ASN.1 compiler. * TIS/ASN1COMP is Copyright (c) 1998, TIS Labs at Network Associates, Inc. * * This file was AUTOMATICALLY GENERATED on Sun Apr 20 19:54:44 2003 * ******************************************************************/ #ifndef pgpASN_CMS_STRUCT_H_ #define pgpASN_CMS_STRUCT_H_ #include "pgpASN_CMS_util.h" /******************************************************************* * * Structure and type definitions * ******************************************************************/ typedef ASN_CMS_BIT_STRING ASN_CMS_AttributeCertificate; #define ASN_CMS_ID_AttributeCertificate ASN_CMS_ID_BIT_STRING typedef ASN_CMS_OBJECT_ID ASN_CMS_AttributeType; #define ASN_CMS_ID_AttributeType ASN_CMS_ID_OBJECT_ID typedef ASN_CMS_ANY ASN_CMS_AttributeValue; #define ASN_CMS_ID_AttributeValue ASN_CMS_ID_ANY typedef ASN_CMS_INTEGER ASN_CMS_CMSVersion; #define ASN_CMS_ID_CMSVersion ASN_CMS_ID_INTEGER /* define values for ASN_CMS_CMSVersion */ #define ASN_CMS_CMSVersion_v0 0 #define ASN_CMS_CMSVersion_v1 1 #define ASN_CMS_CMSVersion_v2 2 #define ASN_CMS_CMSVersion_v3 3 #define ASN_CMS_CMSVersion_v4 4 /* end of values for ASN_CMS_CMSVersion */ typedef ASN_CMS_INTEGER ASN_CMS_CertificateSerialNumber; #define ASN_CMS_ID_CertificateSerialNumber ASN_CMS_ID_INTEGER typedef ASN_CMS_OBJECT_ID ASN_CMS_ContentType; #define ASN_CMS_ID_ContentType ASN_CMS_ID_OBJECT_ID typedef ASN_CMS_OCTET_STRING ASN_CMS_Digest; #define ASN_CMS_ID_Digest ASN_CMS_ID_OCTET_STRING typedef ASN_CMS_OCTET_STRING ASN_CMS_EncryptedContent; #define ASN_CMS_ID_EncryptedContent ASN_CMS_ID_OCTET_STRING typedef ASN_CMS_OCTET_STRING ASN_CMS_EncryptedKey; #define ASN_CMS_ID_EncryptedKey ASN_CMS_ID_OCTET_STRING typedef ASN_CMS_OCTET_STRING ASN_CMS_IV; #define ASN_CMS_ID_IV ASN_CMS_ID_OCTET_STRING typedef ASN_CMS_OCTET_STRING ASN_CMS_MessageAuthenticationCode; #define ASN_CMS_ID_MessageAuthenticationCode ASN_CMS_ID_OCTET_STRING typedef ASN_CMS_OCTET_STRING ASN_CMS_MessageDigest; #define ASN_CMS_ID_MessageDigest ASN_CMS_ID_OCTET_STRING typedef ASN_CMS_ANY ASN_CMS_Name_opaque; #define ASN_CMS_ID_Name_opaque ASN_CMS_ID_ANY typedef ASN_CMS_INTEGER ASN_CMS_RC2ParameterVersion; #define ASN_CMS_ID_RC2ParameterVersion ASN_CMS_ID_INTEGER typedef ASN_CMS_BIT_STRING ASN_CMS_Signature; #define ASN_CMS_ID_Signature ASN_CMS_ID_BIT_STRING typedef ASN_CMS_OCTET_STRING ASN_CMS_SignatureValue; #define ASN_CMS_ID_SignatureValue ASN_CMS_ID_OCTET_STRING typedef ASN_CMS_OCTET_STRING ASN_CMS_SubjectKeyIdentifier; #define ASN_CMS_ID_SubjectKeyIdentifier ASN_CMS_ID_OCTET_STRING typedef ASN_CMS_BIT_STRING ASN_CMS_UniqueIdentifier; #define ASN_CMS_ID_UniqueIdentifier ASN_CMS_ID_BIT_STRING typedef ASN_CMS_OCTET_STRING ASN_CMS_UserKeyingMaterial; #define ASN_CMS_ID_UserKeyingMaterial ASN_CMS_ID_OCTET_STRING typedef ASN_CMS_INTEGER ASN_CMS_Version; #define ASN_CMS_ID_Version ASN_CMS_ID_INTEGER /* define values for ASN_CMS_Version */ #define ASN_CMS_Version_v1 0 #define ASN_CMS_Version_v2 1 #define ASN_CMS_Version_v3 2 /* end of values for ASN_CMS_Version */ typedef struct { ASN_CMS_OBJECT_ID algorithm; ASN_CMS_ANY *parameters; } ASN_CMS_AlgorithmIdentifier; #define ASN_CMS_ID_AlgorithmIdentifier ASN_CMS_ID_SEQUENCE typedef struct { ASN_CMS_AttributeType type; ASN_CMS_AttributeValue value; } ASN_CMS_AttributeTypeAndDistinguishedValue; #define ASN_CMS_ID_AttributeTypeAndDistinguishedValue ASN_CMS_ID_SEQUENCE typedef ASN_CMS_IV ASN_CMS_CBCParameter; #define ASN_CMS_ID_CBCParameter ASN_CMS_ID_IV typedef struct { ASN_CMS_ContentType contentType; ASN_CMS_ANY content; } ASN_CMS_ContentInfo; #define ASN_CMS_ID_ContentInfo ASN_CMS_ID_SEQUENCE typedef struct { ASN_CMS_ContentType eContentType; ASN_CMS_OCTET_STRING *eContent; } ASN_CMS_EncapsulatedContentInfo; #define ASN_CMS_ID_EncapsulatedContentInfo ASN_CMS_ID_SEQUENCE typedef struct { ASN_CMS_OBJECT_ID extnID; ASN_CMS_BOOLEAN *critical; ASN_CMS_OCTET_STRING extnValue; } ASN_CMS_Extension; #define ASN_CMS_ID_Extension ASN_CMS_ID_SEQUENCE typedef struct { ASN_CMS_Name_opaque issuer; ASN_CMS_CertificateSerialNumber serialNumber; } ASN_CMS_IssuerAndSerialNumber; #define ASN_CMS_ID_IssuerAndSerialNumber ASN_CMS_ID_SEQUENCE typedef struct { ASN_CMS_OBJECT_ID keyAttrId; ASN_CMS_ANY *keyAttr; } ASN_CMS_OtherKeyAttribute; #define ASN_CMS_ID_OtherKeyAttribute ASN_CMS_ID_SEQUENCE typedef struct { ASN_CMS_INTEGER rc2ParameterVersion; ASN_CMS_OCTET_STRING iv; } ASN_CMS_RC2CBCParameter; #define ASN_CMS_ID_RC2CBCParameter ASN_CMS_ID_SEQUENCE typedef ASN_CMS_RC2ParameterVersion ASN_CMS_RC2wrapParameter; #define ASN_CMS_ID_RC2wrapParameter ASN_CMS_ID_RC2ParameterVersion typedef struct { unsigned char CHOICE_field_type; void *data; } ASN_CMS_Time; #define ASN_CMS_ID_Time ASN_CMS_ID_CHOICE /* tags for fields defined for Time */ #define ASN_CMS_utcTime_TimeFieldTag ASN_CMS_ID_UTCTime #define ASN_CMS_generalTime_TimeFieldTag ASN_CMS_ID_GeneralizedTime typedef struct { long n; /* number of elements */ ASN_CMS_AttributeValue **elt; } ASN_CMS_attrValues_SET_OF; #define ASN_CMS_ID_attrValues_SET_OF ASN_CMS_ID_SET_OF typedef struct { ASN_CMS_OBJECT_ID attrType; ASN_CMS_attrValues_SET_OF attrValues; } ASN_CMS_Attribute; #define ASN_CMS_ID_Attribute ASN_CMS_ID_SEQUENCE typedef ASN_CMS_AlgorithmIdentifier ASN_CMS_ContentEncryptionAlgorithmIdentifier; #define ASN_CMS_ID_ContentEncryptionAlgorithmIdentifier ASN_CMS_ID_AlgorithmIdentifier typedef ASN_CMS_AlgorithmIdentifier ASN_CMS_DigestAlgorithmIdentifier; #define ASN_CMS_ID_DigestAlgorithmIdentifier ASN_CMS_ID_AlgorithmIdentifier typedef struct { long n; /* number of elements */ ASN_CMS_Extension **elt; } ASN_CMS_Extensions; #define ASN_CMS_ID_Extensions ASN_CMS_ID_SEQUENCE_OF typedef struct { ASN_CMS_OCTET_STRING keyIdentifier; ASN_CMS_GeneralizedTime *date; ASN_CMS_OtherKeyAttribute *other; } ASN_CMS_KEKIdentifier; #define ASN_CMS_ID_KEKIdentifier ASN_CMS_ID_SEQUENCE typedef ASN_CMS_AlgorithmIdentifier ASN_CMS_KeyEncryptionAlgorithmIdentifier; #define ASN_CMS_ID_KeyEncryptionAlgorithmIdentifier ASN_CMS_ID_AlgorithmIdentifier typedef ASN_CMS_AlgorithmIdentifier ASN_CMS_KeyWrapAlgorithm; #define ASN_CMS_ID_KeyWrapAlgorithm ASN_CMS_ID_AlgorithmIdentifier typedef ASN_CMS_AlgorithmIdentifier ASN_CMS_MessageAuthenticationCodeAlgorithm; #define ASN_CMS_ID_MessageAuthenticationCodeAlgorithm ASN_CMS_ID_AlgorithmIdentifier typedef struct { ASN_CMS_AlgorithmIdentifier algorithm; ASN_CMS_BIT_STRING publicKey; } ASN_CMS_OriginatorPublicKey; #define ASN_CMS_ID_OriginatorPublicKey ASN_CMS_ID_SEQUENCE typedef struct { unsigned char CHOICE_field_type; void *data; } ASN_CMS_RecipientIdentifier; #define ASN_CMS_ID_RecipientIdentifier ASN_CMS_ID_CHOICE /* tags for fields defined for RecipientIdentifier */ #define ASN_CMS_issuerAndSerialNumber_RecipientIdentifierFieldTag ASN_CMS_ID_IssuerAndSerialNumber #define ASN_CMS_subjectKeyIdentifier_RecipientIdentifierFieldTag 0x80|0x00 typedef struct { ASN_CMS_SubjectKeyIdentifier subjectKeyIdentifier; ASN_CMS_GeneralizedTime *date; ASN_CMS_OtherKeyAttribute *other; } ASN_CMS_RecipientKeyIdentifier; #define ASN_CMS_ID_RecipientKeyIdentifier ASN_CMS_ID_SEQUENCE typedef struct { long n; /* number of elements */ ASN_CMS_AttributeTypeAndDistinguishedValue **elt; } ASN_CMS_RelativeDistinguishedName; #define ASN_CMS_ID_RelativeDistinguishedName ASN_CMS_ID_SET_OF typedef ASN_CMS_AlgorithmIdentifier ASN_CMS_SignatureAlgorithmIdentifier; #define ASN_CMS_ID_SignatureAlgorithmIdentifier ASN_CMS_ID_AlgorithmIdentifier typedef struct { unsigned char CHOICE_field_type; void *data; } ASN_CMS_SignerIdentifier; #define ASN_CMS_ID_SignerIdentifier ASN_CMS_ID_CHOICE /* tags for fields defined for SignerIdentifier */ #define ASN_CMS_issuerAndSerialNumber_SignerIdentifierFieldTag ASN_CMS_ID_IssuerAndSerialNumber #define ASN_CMS_subjectKeyIdentifier_SignerIdentifierFieldTag 0x80|0x00 typedef ASN_CMS_Time ASN_CMS_SigningTime; #define ASN_CMS_ID_SigningTime ASN_CMS_ID_Time typedef struct { ASN_CMS_AlgorithmIdentifier algorithm; ASN_CMS_BIT_STRING subjectPublicKey; } ASN_CMS_SubjectPublicKeyInfo; #define ASN_CMS_ID_SubjectPublicKeyInfo ASN_CMS_ID_SEQUENCE typedef struct { ASN_CMS_Time notBefore; ASN_CMS_Time notAfter; } ASN_CMS_Validity; #define ASN_CMS_ID_Validity ASN_CMS_ID_SEQUENCE typedef struct { long n; /* number of elements */ ASN_CMS_Attribute **elt; } ASN_CMS_AuthAttributes; #define ASN_CMS_ID_AuthAttributes ASN_CMS_ID_SET_OF typedef struct { long n; /* number of elements */ ASN_CMS_DigestAlgorithmIdentifier **elt; } ASN_CMS_DigestAlgorithmIdentifiers; #define ASN_CMS_ID_DigestAlgorithmIdentifiers ASN_CMS_ID_SET_OF typedef struct { ASN_CMS_CMSVersion version; ASN_CMS_DigestAlgorithmIdentifier digestAlgorithm; ASN_CMS_EncapsulatedContentInfo encapContentInfo; ASN_CMS_Digest digest; } ASN_CMS_DigestedData; #define ASN_CMS_ID_DigestedData ASN_CMS_ID_SEQUENCE typedef struct { ASN_CMS_ContentType contentType; ASN_CMS_ContentEncryptionAlgorithmIdentifier contentEncryptionAlgorithm; ASN_CMS_EncryptedContent encryptedContent; } ASN_CMS_EncryptedContentInfo; #define ASN_CMS_ID_EncryptedContentInfo ASN_CMS_ID_SEQUENCE typedef struct { ASN_CMS_CMSVersion version; ASN_CMS_KEKIdentifier kekid; ASN_CMS_KeyEncryptionAlgorithmIdentifier keyEncryptionAlgorithm; ASN_CMS_EncryptedKey encryptedKey; } ASN_CMS_KEKRecipientInfo; #define ASN_CMS_ID_KEKRecipientInfo ASN_CMS_ID_SEQUENCE typedef struct { unsigned char CHOICE_field_type; void *data; } ASN_CMS_KeyAgreeRecipientIdentifier; #define ASN_CMS_ID_KeyAgreeRecipientIdentifier ASN_CMS_ID_CHOICE /* tags for fields defined for KeyAgreeRecipientIdentifier */ #define ASN_CMS_issuerAndSerialNumber_KeyAgreeRecipientIdentifierFieldTag ASN_CMS_ID_IssuerAndSerialNumber #define ASN_CMS_rKeyId_KeyAgreeRecipientIdentifierFieldTag 0x80|0x00 typedef struct { ASN_CMS_CMSVersion version; ASN_CMS_RecipientIdentifier rid; ASN_CMS_KeyEncryptionAlgorithmIdentifier keyEncryptionAlgorithm; ASN_CMS_EncryptedKey encryptedKey; } ASN_CMS_KeyTransRecipientInfo; #define ASN_CMS_ID_KeyTransRecipientInfo ASN_CMS_ID_SEQUENCE typedef struct { unsigned char CHOICE_field_type; void *data; } ASN_CMS_OriginatorIdentifierOrKey; #define ASN_CMS_ID_OriginatorIdentifierOrKey ASN_CMS_ID_CHOICE /* tags for fields defined for OriginatorIdentifierOrKey */ #define ASN_CMS_issuerAndSerialNumber_OriginatorIdentifierOrKeyFieldTag ASN_CMS_ID_IssuerAndSerialNumber #define ASN_CMS_subjectKeyIdentifier_OriginatorIdentifierOrKeyFieldTag 0x80|0x00 #define ASN_CMS_originatorKey_OriginatorIdentifierOrKeyFieldTag 0x80|0x01 typedef struct { long n; /* number of elements */ ASN_CMS_RelativeDistinguishedName **elt; } ASN_CMS_RDNSequence; #define ASN_CMS_ID_RDNSequence ASN_CMS_ID_SEQUENCE_OF typedef struct { long n; /* number of elements */ ASN_CMS_Attribute **elt; } ASN_CMS_SignedAttributes; #define ASN_CMS_ID_SignedAttributes ASN_CMS_ID_SET_OF typedef struct { ASN_CMS_Version *version; ASN_CMS_CertificateSerialNumber serialNumber; ASN_CMS_AlgorithmIdentifier signature; ASN_CMS_Name_opaque issuer; ASN_CMS_Validity validity; ASN_CMS_Name_opaque subject; ASN_CMS_SubjectPublicKeyInfo subjectPublicKeyInfo; ASN_CMS_UniqueIdentifier *issuerUniqueIdentifier; ASN_CMS_UniqueIdentifier *subjectUniqueIdentifier; ASN_CMS_Extensions *extensions; } ASN_CMS_ToBeSigned; #define ASN_CMS_ID_ToBeSigned ASN_CMS_ID_SEQUENCE typedef struct { long n; /* number of elements */ ASN_CMS_Attribute **elt; } ASN_CMS_UnauthAttributes; #define ASN_CMS_ID_UnauthAttributes ASN_CMS_ID_SET_OF typedef struct { long n; /* number of elements */ ASN_CMS_Attribute **elt; } ASN_CMS_UnprotectedAttributes; #define ASN_CMS_ID_UnprotectedAttributes ASN_CMS_ID_SET_OF typedef struct { long n; /* number of elements */ ASN_CMS_Attribute **elt; } ASN_CMS_UnsignedAttributes; #define ASN_CMS_ID_UnsignedAttributes ASN_CMS_ID_SET_OF typedef struct { ASN_CMS_CertificateSerialNumber userCertificate; ASN_CMS_Time revocationDate; ASN_CMS_Extensions *crlEntryExtensions; } ASN_CMS_revokedCertificates_SEQ_OF_SEQUENCE; #define ASN_CMS_ID_revokedCertificates_SEQ_OF_SEQUENCE ASN_CMS_ID_SEQUENCE typedef struct { ASN_CMS_ToBeSigned tbsCertificate; ASN_CMS_AlgorithmIdentifier signatureAlgorithm; ASN_CMS_BIT_STRING signature; } ASN_CMS_Certificate; #define ASN_CMS_ID_Certificate ASN_CMS_ID_SEQUENCE typedef struct { ASN_CMS_CMSVersion version; ASN_CMS_EncryptedContentInfo encryptedContentInfo; ASN_CMS_UnprotectedAttributes *unprotectedAttrs; } ASN_CMS_EncryptedData; #define ASN_CMS_ID_EncryptedData ASN_CMS_ID_SEQUENCE typedef ASN_CMS_RDNSequence ASN_CMS_Name; #define ASN_CMS_ID_Name ASN_CMS_ID_RDNSequence typedef struct { ASN_CMS_KeyAgreeRecipientIdentifier rid; ASN_CMS_EncryptedKey encryptedKey; } ASN_CMS_RecipientEncryptedKey; #define ASN_CMS_ID_RecipientEncryptedKey ASN_CMS_ID_SEQUENCE typedef struct { ASN_CMS_CMSVersion version; ASN_CMS_SignerIdentifier sid; ASN_CMS_DigestAlgorithmIdentifier digestAlgorithm; ASN_CMS_SignedAttributes *signedAttrs; ASN_CMS_SignatureAlgorithmIdentifier signatureAlgorithm; ASN_CMS_SignatureValue signature; ASN_CMS_UnsignedAttributes *unsignedAttrs; } ASN_CMS_SignerInfo; #define ASN_CMS_ID_SignerInfo ASN_CMS_ID_SEQUENCE typedef struct { long n; /* number of elements */ ASN_CMS_revokedCertificates_SEQ_OF_SEQUENCE **elt; } ASN_CMS_revokedCertificates_SEQ_OF; #define ASN_CMS_ID_revokedCertificates_SEQ_OF ASN_CMS_ID_SEQUENCE_OF typedef struct { ASN_CMS_Version *version; ASN_CMS_AlgorithmIdentifier signature; ASN_CMS_Name_opaque issuer; ASN_CMS_Time thisUpdate; ASN_CMS_Time *nextUpdate; ASN_CMS_revokedCertificates_SEQ_OF *revokedCertificates; ASN_CMS_Extensions *crlExtensions; } ASN_CMS_CertificateList; #define ASN_CMS_ID_CertificateList ASN_CMS_ID_SEQUENCE typedef ASN_CMS_SignerInfo ASN_CMS_Countersignature; #define ASN_CMS_ID_Countersignature ASN_CMS_ID_SignerInfo typedef struct { ASN_CMS_CMSVersion version; ASN_CMS_Certificate certificate; ASN_CMS_UnauthAttributes attributes; } ASN_CMS_ExtendedCertificateInfo; #define ASN_CMS_ID_ExtendedCertificateInfo ASN_CMS_ID_SEQUENCE typedef struct { long n; /* number of elements */ ASN_CMS_RecipientEncryptedKey **elt; } ASN_CMS_RecipientEncryptedKeys; #define ASN_CMS_ID_RecipientEncryptedKeys ASN_CMS_ID_SEQUENCE_OF typedef struct { long n; /* number of elements */ ASN_CMS_SignerInfo **elt; } ASN_CMS_SignerInfos; #define ASN_CMS_ID_SignerInfos ASN_CMS_ID_SET_OF typedef struct { long n; /* number of elements */ ASN_CMS_CertificateList **elt; } ASN_CMS_CertificateRevocationLists; #define ASN_CMS_ID_CertificateRevocationLists ASN_CMS_ID_SET_OF typedef struct { ASN_CMS_ExtendedCertificateInfo extendedCertificateInfo; ASN_CMS_SignatureAlgorithmIdentifier signatureAlgorithm; ASN_CMS_Signature signature; } ASN_CMS_ExtendedCertificate; #define ASN_CMS_ID_ExtendedCertificate ASN_CMS_ID_SEQUENCE typedef struct { ASN_CMS_CMSVersion version; ASN_CMS_OriginatorIdentifierOrKey originator; ASN_CMS_UserKeyingMaterial *ukm; ASN_CMS_KeyEncryptionAlgorithmIdentifier keyEncryptionAlgorithm; ASN_CMS_RecipientEncryptedKeys recipientEncryptedKeys; } ASN_CMS_KeyAgreeRecipientInfo; #define ASN_CMS_ID_KeyAgreeRecipientInfo ASN_CMS_ID_SEQUENCE typedef struct { unsigned char CHOICE_field_type; void *data; } ASN_CMS_CertificateChoices; #define ASN_CMS_ID_CertificateChoices ASN_CMS_ID_CHOICE /* tags for fields defined for CertificateChoices */ #define ASN_CMS_certificate_CertificateChoicesFieldTag ASN_CMS_ID_Certificate #define ASN_CMS_extendedCertificate_CertificateChoicesFieldTag 0x80|0x00 #define ASN_CMS_attrCert_CertificateChoicesFieldTag 0x80|0x01 typedef struct { unsigned char CHOICE_field_type; void *data; } ASN_CMS_RecipientInfo; #define ASN_CMS_ID_RecipientInfo ASN_CMS_ID_CHOICE /* tags for fields defined for RecipientInfo */ #define ASN_CMS_ktri_RecipientInfoFieldTag ASN_CMS_ID_KeyTransRecipientInfo #define ASN_CMS_kari_RecipientInfoFieldTag 0x80|0x01 #define ASN_CMS_kekri_RecipientInfoFieldTag 0x80|0x02 typedef struct { long n; /* number of elements */ ASN_CMS_CertificateChoices **elt; } ASN_CMS_CertificateSet; #define ASN_CMS_ID_CertificateSet ASN_CMS_ID_SET_OF typedef struct { long n; /* number of elements */ ASN_CMS_RecipientInfo **elt; } ASN_CMS_RecipientInfos; #define ASN_CMS_ID_RecipientInfos ASN_CMS_ID_SET_OF typedef struct { ASN_CMS_CertificateSet *certs; ASN_CMS_CertificateRevocationLists *crls; } ASN_CMS_OriginatorInfo; #define ASN_CMS_ID_OriginatorInfo ASN_CMS_ID_SEQUENCE typedef struct { ASN_CMS_CMSVersion version; ASN_CMS_DigestAlgorithmIdentifiers digestAlgorithms; ASN_CMS_EncapsulatedContentInfo encapContentInfo; ASN_CMS_CertificateSet *certificates; ASN_CMS_CertificateRevocationLists *crls; ASN_CMS_SignerInfos signerInfos; } ASN_CMS_SignedData; #define ASN_CMS_ID_SignedData ASN_CMS_ID_SEQUENCE typedef struct { ASN_CMS_CMSVersion version; ASN_CMS_OriginatorInfo *originatorInfo; ASN_CMS_RecipientInfos recipientInfos; ASN_CMS_MessageAuthenticationCodeAlgorithm macAlgorithm; ASN_CMS_DigestAlgorithmIdentifier *digestAlgorithm; ASN_CMS_EncapsulatedContentInfo encapContentInfo; ASN_CMS_AuthAttributes *authenticatedAttributes; ASN_CMS_MessageAuthenticationCode mac; ASN_CMS_UnauthAttributes *unauthenticatedAttributes; } ASN_CMS_AuthenticatedData; #define ASN_CMS_ID_AuthenticatedData ASN_CMS_ID_SEQUENCE typedef struct { ASN_CMS_CMSVersion version; ASN_CMS_OriginatorInfo *originatorInfo; ASN_CMS_RecipientInfos recipientInfos; ASN_CMS_EncryptedContentInfo encryptedContentInfo; ASN_CMS_UnprotectedAttributes *unprotectedAttrs; } ASN_CMS_EnvelopedData; #define ASN_CMS_ID_EnvelopedData ASN_CMS_ID_SEQUENCE #endif /* pgpASN_CMS_STRUCT_H_ */ (ctx, f->signedAttrs); f->signedAttrs = NULL; ASN_CMS_DropInPlaceSignatureAlgorithmIdentifier(ctx, &(f->signatureAlgorithm)); ASN_CMS_DropInPlaceSignatureValue(ctx, &(f->signature)); ASN_CMS_FreeUnsignedAttributes(ctx, f->unsignedAttrs); f->unsignedAttrs = NULL; } /* ASN_CMS_DropInPlaceSignerInfo */ size_t ASN_CMS_PackSignerInfoInternal( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_SignerInfo *asnstruct, unsigned char tag, int *erret) { size_t bytesused; size_t tagsize; size_t datasize; if (erret == NULL) return 0; /* can't report errors */ if (ctx == NULL) { ASN_CMS_ERR(ASN_CMS_ErrBadContext); return 0; } if (asnstruct == NULL) return 0; /* lth of the block body */ datasize = ASN_CMS_SizeofSignerInfo(ctx, asnstruct, ASN_CMS_FALSE); tagsize = 1 + ASN_CMS_LengthSize(datasize); if (datasize+tagsize > buflen) { ASN_CMS_ERR(ASN_CMS_ErrPackBufferTooShort); return 0; } /* this is a SEQUENCE */ bytesused = ASN_CMS_PutTag(buf, (unsigned char)(tag|0x20), datasize); if (bytesused != tagsize) { ASN_CMS_ERR(ASN_CMS_ErrPackOverrun); return bytesused; } datasize += tagsize; do { /* field version of SignerInfo */ bytesused += ASN_CMS_PackCMSVersionInternal(ctx, buf+bytesused, buflen-bytesused, &(asnstruct->version), ASN_CMS_ID_CMSVersion, erret); if (bytesused > datasize || *erret != 0) break; /******************************************************************* * * This file was generated by TIS/ASN1COMP Ver. 4.3 (mod 7), an ASN.1 compiler. * TIS/ASN1COMP is Copyright (c) 1998, TIS Labs at Network Associates, Inc. * * This file was AUTOMATICALLY GENERATED on Sun Apr 20 19:54:44 2003 * ******************************************************************/ #ifndef pgpASN_CMS_UTIL_H_ #define pgpASN_CMS_UTIL_H_ #include #include #ifndef ASN_CMS_TRUE #define ASN_CMS_FALSE (0) #define ASN_CMS_TRUE (1) #endif #ifndef NULL #define NULL ((void *) 0) #endif /***** * * Primitive type definitions * *****/ /* BOOLEAN */ typedef struct { size_t len; /* # of bytes in value */ int val; /* the boolean */ } ASN_CMS_BooleanBlock; /* NULL */ typedef struct { size_t len; /* unused */ } ASN_CMS_NullBlock; /* Variable Length Entity */ typedef struct { size_t len; /* # of bytes in value */ unsigned char *val; /* pointer to the bytes of value */ } ASN_CMS_VariableBlock; /* Bit String Entity */ typedef struct { size_t len; /* # of bytes in value */ unsigned char *val; /* pointer to the bytes of value */ int nuub; /* number of unused bits in LSByte */ } ASN_CMS_BitstringBlock; typedef ASN_CMS_NullBlock ASN_CMS_NULL; typedef ASN_CMS_BooleanBlock ASN_CMS_BOOLEAN ; typedef ASN_CMS_VariableBlock ASN_CMS_OBJECT_ID ; typedef ASN_CMS_VariableBlock ASN_CMS_GeneralizedTime ; typedef ASN_CMS_VariableBlock ASN_CMS_IA5String ; typedef ASN_CMS_VariableBlock ASN_CMS_INTEGER ; typedef ASN_CMS_BitstringBlock ASN_CMS_BIT_STRING ; typedef ASN_CMS_VariableBlock ASN_CMS_OCTET_STRING ; typedef ASN_CMS_VariableBlock ASN_CMS_T61String ; typedef ASN_CMS_VariableBlock ASN_CMS_ANY ; typedef ASN_CMS_VariableBlock ASN_CMS_UTCTime ; typedef ASN_CMS_VariableBlock ASN_CMS_NumericString ; typedef ASN_CMS_VariableBlock ASN_CMS_PrintableString ; typedef ASN_CMS_VariableBlock ASN_CMS_VisibleString ; /* * #define ID values for defines for asn types. */ #define ASN_CMS_ID_reserved 0x00 #define ASN_CMS_ID_BOOLEAN 0x01 #define ASN_CMS_ID_INTEGER 0x02 #define ASN_CMS_ID_BIT_STRING 0x03 #define ASN_CMS_ID_OCTET_STRING 0x04 #define ASN_CMS_ID_NULL 0x05 #define ASN_CMS_ID_OBJECT_IDENTIFIER 0x06 #define ASN_CMS_ID_OBJECT_ID 0x06 #define ASN_CMS_ID_ObjectDescriptor 0x07 #define ASN_CMS_ID_EXTERNAL 0x08 #define ASN_CMS_ID_REAL 0x09 #define ASN_CMS_ID_SEQUENCE 0x10 #define ASN_CMS_ID_SEQUENCE_OF 0x10 #define ASN_CMS_ID_SET 0x11 #define ASN_CMS_ID_SET_OF 0x011 #define ASN_CMS_ID_NumericString 0x12 #define ASN_CMS_ID_PrintableString 0x13 #define ASN_CMS_ID_T61String 0x14 #define ASN_CMS_ID_TeletexString 0x14 #define ASN_CMS_ID_VideotexString 0x15 #define ASN_CMS_ID_IA5String 0x16 #define ASN_CMS_ID_UTCTime 0x17 #define ASN_CMS_ID_GeneralizedTime 0x18 #define ASN_CMS_ID_GraphicString 0x19 #define ASN_CMS_ID_VisibleString 0x1a #define ASN_CMS_ID_ISO646String 0x1a #define ASN_CMS_ID_GeneralString 0x1b #define ASN_CMS_ID_IMPORTED 0xFA #define ASN_CMS_ID_UNIVERSAL 0xFB #define ASN_CMS_ID_CHOICE 0xFC #define ASN_CMS_ID_SYNONYM 0xFD #define ASN_CMS_ID_ANY 0xFE /********************************************************************* * Error return codes from pack and unpack (uip). **********************************************************************/ #define ASN_CMS_ErrPackUnderrun (-1) #define ASN_CMS_ErrPackOverrun (-2) #define ASN_CMS_ErrPackSEQOFArrayTooLong (-3) /* lth > MAX of that type */ #define ASN_CMS_ErrPackNoBlock (-5) /* ASN block ptr is NULL */ #define ASN_CMS_ErrUnpackNoStructure (-6) /* block pointer is NULL */ #define ASN_CMS_ErrUnpackNoBlockPtr (-7) /* ASN block pointer pointer is NULL */ #define ASN_CMS_ErrUnpackNoBlock (-8) /* ASN block pointer is NULL */ #define ASN_CMS_ErrUnpackOverrun (-9) #define ASN_CMS_ErrUnpackUnderrun (-10) #define ASN_CMS_ErrUnpackBooleanLth (-11) /* a boolean block with lth != 1 */ #define ASN_CMS_ErrUnpackTaggedLth (-12) /* a context tag lth failed to match the length of the contents */ #define ASN_CMS_ErrUnpackReqMissing (-13) /* a required substructure is missing */ #define ASN_CMS_ErrUnpackNullLth (-14) /* a NULL block with lth != 0 */ #define ASN_CMS_ErrPackSETOFArrayTooLong (-15) /* lth > MAX of that type */ #define ASN_CMS_ErrPackSETOFUnsortable (-16) /* SET OF with identical elements */ #define ASN_CMS_ErrOutOfMemory (-17) /* Out of memory */ #define ASN_CMS_ErrPackBufferTooShort (-18) /* provided buffer space too short */ #define ASN_CMS_ErrUnpackInvalidEncoding (-19) #define ASN_CMS_ErrBadContext (-20) #define ASN_CMS_ErrUnpackSetBadType (-21) #define ASN_CMS_ErrUnpackDuplicateField (-22) /* * Error code for choice when it has a bad type */ #define ASN_CMS_ErrChoiceBadType (-50) /* * Error codes for bad characters in strings */ #define ASN_CMS_ErrBadNumericString (-60) #define ASN_CMS_ErrBadPrintableString (-61) #define ASN_CMS_ErrNotFoundInDict (-70) /********************************************************************* * ASN_CMS_ERR macro * * This can be re-defined as exit(x) for debugging **********************************************************************/ #define ASN_CMS_ERR( x ) { *erret = x; ASN_CMS_ErrorHalt(x); } void ASN_CMS_ErrorHalt ( int x ); /********************************************************************* * Memory Mgmt Callbacks **********************************************************************/ typedef struct ASN_CMS_MemoryMgr ASN_CMS_MemoryMgr; extern ASN_CMS_MemoryMgr ASN_CMS_defaultMemoryMgrStruct; typedef void *(*ASN_CMS_MemoryMgrAllocationProc)( ASN_CMS_MemoryMgr *mgr, size_t requestSize); typedef int (*ASN_CMS_MemoryMgrReallocationProc)( ASN_CMS_MemoryMgr *mgr, void **allocation, size_t newAllocationSize); typedef int (*ASN_CMS_MemoryMgrDeallocationProc)( ASN_CMS_MemoryMgr *mgr, void *allocation); /* memory management structure */ struct ASN_CMS_MemoryMgr { void *customValue; ASN_CMS_MemoryMgrAllocationProc allocProc; ASN_CMS_MemoryMgrReallocationProc reallocProc; ASN_CMS_MemoryMgrDeallocationProc deallocProc; }; #define ASN_CMS_Alloc(mgr, size) (*(mgr)->allocProc)(mgr, size) #define ASN_CMS_Realloc(mgr, ptr, newsize) \ (*(mgr)->reallocProc)(mgr, ptr, newsize) #define ASN_CMS_Free(mgr, ptr) (*(mgr)->deallocProc)(mgr, ptr) struct ASN_CMS_CONTEXT { void *customValue; ASN_CMS_MemoryMgr *memMgr; }; typedef struct ASN_CMS_CONTEXT ASN_CMS_CONTEXT; /********************************************************************* * Utility routine definitions **********************************************************************/ size_t ASN_CMS_LengthSize(size_t x); size_t ASN_CMS_Tagged(size_t inner, int seqlike ); size_t ASN_CMS_PutByte(unsigned char *buf, unsigned char byte ); size_t ASN_CMS_PutLength(unsigned char *buf, size_t length ); size_t ASN_CMS_GetByte(const unsigned char *buf, unsigned char *byte); size_t ASN_CMS_GetLength(const unsigned char *buf, size_t *length); size_t ASN_CMS_PutTag(unsigned char *buf, unsigned char tagbyte, size_t length ); size_t ASN_CMS_TakeTag(const unsigned char *buf, unsigned char tag, size_t *length); int ASN_CMS_CompareElems(const void *a, const void *b); long ASN_CMS_GetIntVal (ASN_CMS_CONTEXT *ctx, ASN_CMS_INTEGER *b, int *error); int ASN_CMS_PutIntVal (ASN_CMS_CONTEXT *ctx, ASN_CMS_INTEGER *b, long v); int ASN_CMS_PutUIntBytes(ASN_CMS_CONTEXT *ctx, ASN_CMS_INTEGER *b, const unsigned char *v, size_t lth); int ASN_CMS_PutOctVal(ASN_CMS_CONTEXT *ctx, ASN_CMS_VariableBlock *b, const unsigned char *v, size_t lth); char *ASN_CMS_GetStrVal(ASN_CMS_CONTEXT *ctx, ASN_CMS_VariableBlock *b); int ASN_CMS_PutStrVal(ASN_CMS_CONTEXT *ctx, ASN_CMS_VariableBlock *b, const char *v); int ASN_CMS_PutBitString (ASN_CMS_CONTEXT *ctx, ASN_CMS_BIT_STRING *b, const unsigned char *str, size_t len, int nuub); int ASN_CMS_GetBoolVal(ASN_CMS_CONTEXT *ctx, ASN_CMS_BOOLEAN *b); int ASN_CMS_PutBoolVal(ASN_CMS_CONTEXT *ctx, ASN_CMS_BOOLEAN *b, int val); int ASN_CMS_AddOfElement(ASN_CMS_CONTEXT *ctx, void *element, void *seqofsetof); /********************************************************************* * For tracing ASN.1 processing via compiler-generated routines. **********************************************************************/ #ifdef ASN_CMS_TRACE extern int ASN_CMS_TRACE_LEVEL; int ASN_CMS_TRACE_trval(const unsigned char *enc, int len, int lev); #define ASN_CMS_TRACE_INCR_LEVEL \ ASN_CMS_TRACE_LEVEL++ #define ASN_CMS_TRACE_DECR_LEVEL \ ASN_CMS_TRACE_LEVEL-- #define ASN_CMS_TRACE_PRINT_LENGTH(n) \ fprintf(stderr, "<%d>", n) #define ASN_CMS_TRACE_PRINT_TAG(tag, rtag) \ { int j; fprintf(stderr, "\n"); \ for ( j=0 ; jmemMgr, sizeof(ASN_CMS_BOOLEAN) ); if (f != NULL) memset(f, 0, sizeof(ASN_CMS_BOOLEAN) ); return ((ASN_CMS_BOOLEAN *) f); } /* NewBOOLEAN */ void ASN_CMS_DropInPlaceBOOLEAN( ASN_CMS_CONTEXT *ctx, ASN_CMS_BOOLEAN *f) { (void)ctx; (void)f; return ; } /* ASN_CMS_DropInPlaceBOOLEAN */ void ASN_CMS_FreeBOOLEAN( ASN_CMS_CONTEXT *ctx, ASN_CMS_BOOLEAN *g ) { if (ctx == NULL) return; if (g != NULL) ASN_CMS_Free(ctx->memMgr, g); } /* ASN_CMS_FreeBOOLEAN */ size_t ASN_CMS_SizeofBOOLEAN( ASN_CMS_CONTEXT *ctx, ASN_CMS_BOOLEAN *boolblock, int outerSizeFlag) { (void)ctx; /* for future use */ return ASN_CMS_SizeofBOOLEANInternal(boolblock, outerSizeFlag, ASN_CMS_FALSE); } size_t ASN_CMS_SizeofBOOLEANInternal( ASN_CMS_BOOLEAN *boolblock, int outerSizeFlag, int expTaggedSize) { size_t length = 1; if (boolblock == NULL) return 0; if (outerSizeFlag == ASN_CMS_TRUE) length = 3; if (expTaggedSize == ASN_CMS_TRUE) length = ASN_CMS_Tagged(length, 0); return length; } /* ASN_CMS_SizeofBOOLEANInternal */ size_t ASN_CMS_PackBOOLEAN( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_BOOLEAN *boolblock, int *erret ) { return(ASN_CMS_PackBOOLEANInternal(ctx, buf, buflen, boolblock, ASN_CMS_ID_BOOLEAN, erret)); } /* ASN_CMS_PackBOOLEAN */ size_t ASN_CMS_PackBOOLEANInternal( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_BOOLEAN *boolblock, unsigned char tag, int *erret ) { unsigned char value = 0x00; size_t bytesused; (void)ctx; /* for future use */ if (boolblock == NULL) return 0; if (boolblock->val != 0) value = 0xff; bytesused = ASN_CMS_PutByte(buf, tag); /* this is a ASN_CMS_BOOLEAN */ bytesused += ASN_CMS_PutByte(buf+bytesused, 1); /* length = 1 byte */ bytesused += ASN_CMS_PutByte(buf+bytesused, value); /* the value */ if (bytesused > buflen) { ASN_CMS_ERR(ASN_CMS_ErrPackOverrun); /* note this error */ return 0; } return bytesused; } /* ASN_CMS_PackBOOLEANInternal */ size_t ASN_CMS_UnpkInPlaceBOOLEAN( ASN_CMS_CONTEXT *ctx, ASN_CMS_BOOLEAN *boolstruct, /* output block */ const unsigned char *buf, /* loc of input pointer */ size_t buflen, /* max end of my region */ unsigned char tag, int *erret) /* error return location */ { size_t bytesused; size_t datasize; (void)ctx; ASN_CMS_TRACE_PRINT_FM(tag, 0x01, "BOOLEAN"); if/******************************************************************* * * This file was generated by TIS/ASN1COMP Ver. 4.3 (mod 7), an ASN.1 compiler. * TIS/ASN1COMP is Copyright (c) 1998, TIS Labs at Network Associates, Inc. * * This file was AUTOMATICALLY GENERATED on Sun Apr 20 19:54:44 2003 * ******************************************************************/ /********************************************************************** * pgpASN_CMS_util.c * * Utility routines for ASN.1 coding ************************************************************************/ #include #include #include #include #include "pgpASN_CMS_util.h" #ifdef ASN_CMS_TRACE int ASN_CMS_TRACE_LEVEL = 0; #endif /*********************************************************************** * ASN_CMS_ErrorHalt * * a dummy routine, called if error, on which one can halt/ *************************************************************************/ void ASN_CMS_ErrorHalt(int x) { (void)x; /* not usted */ return; } /* err_halt */ /********************************************************************** * Default mem. mgmt callbacks * * These are defaults that the user can use if desired, or use them * as models for your own set of memory mgmt. callbacks. ***********************************************************************/ /* default memory allocator */ static void * ASN_CMS_DefaultMemoryAllocationProc( ASN_CMS_MemoryMgr *mgr, size_t requestSize) { (void)mgr; return ( malloc(requestSize) ); } /* ASN_CMS_DefaultMemoryAllocationProc */ /* default memory reallocator */ static int ASN_CMS_DefaultMemoryReallocationProc( ASN_CMS_MemoryMgr *mgr, void **allocation, size_t newAllocationSize) { int err; void *newPtr = NULL; void *oldPtr = *allocation; (void)mgr; newPtr = realloc(oldPtr, newAllocationSize); if (newPtr == NULL) { err = ASN_CMS_ErrOutOfMemory; } else { err = 0; *allocation = newPtr; } return err; } /* ASN_CMS_MemoryMgrReallocationProc */ /* default memory deallocation routine */ static int ASN_CMS_DefaultMemoryDeallocationProc( ASN_CMS_MemoryMgr *mgr, void *allocation) { (void)mgr; free(allocation); return 0; } /* ASN_CMS_MemoryMgrDeallocationProc */ /* the default ASN_CMS_MemoryMgr structure for the user */ ASN_CMS_MemoryMgr ASN_CMS_defaultMemoryMgrStruct = { NULL, ASN_CMS_DefaultMemoryAllocationProc, ASN_CMS_DefaultMemoryReallocationProc, ASN_CMS_DefaultMemoryDeallocationProc }; /*************************************************************************** * ASN_CMS_AddOfElement * A routine to add an element to a SEQUENCE OF or SET OF structure. * The routine will only allocate space for the pointer being added, * the user must allocate and fill in the element's data. ****************************************************************************/ struct seqsetofstruct { long n; void **elems; }; int ASN_CMS_AddOfElement( ASN_CMS_CONTEXT *ctx, void *element, void *seqofsetof) { struct seqsetofstruct *local; int err; if ( ctx == NULL ) return ASN_CMS_ErrBadContext; if ( seqofsetof == NULL ) return (-1); local = (struct seqsetofstruct *)seqofsetof; if (local->n == 0) { local->elems = (void **)ASN_CMS_Alloc(ctx->memMgr, sizeof(void *)); if (local->elems == NULL) return (-1); local->elems[0] = element; local->n = 1; } else { err = ASN_CMS_Realloc(ctx->memMgr, (void **)&(local->elems), ((local->n+1)*sizeof(void *)) ); if (local->elems == NULL || err != 0) return (-1); local->elems[local->n] = element; local->n++; } return 0; } /* ASN_CMS_AddOfElement */ /*************************************************************************** * ASN_CMS_CompareElems * A routine to provide to the qsort routine for comparing two * PrimVariableBlock blocks. This is used by the pack * routines for SET OF structures. This assumes the compare should * use the length of the longer element provided and for SET OF, then* provided elements should have 0's at the ends of shorter elements. ****************************************************************************/ int ASN_CMS_CompareElems(const void *a, const void *b) { int length; ASN_CMS_VariableBlock *locala = (ASN_CMS_VariableBlock *)a; ASN_CMS_VariableBlock *localb = (ASN_CMS_VariableBlock *)b; if (locala->len > localb->len) length = locala->len; else length = localb->len; return(memcmp(locala->val, localb->val, length)); } /* ASN_CMS_CompareElems */ /************************************************************************ * ASN_CMS_LengthSize -- for scanning the length of a basic integer * for the ASN.1 length field after the tag. *************************************************************************/ size_t ASN_CMS_LengthSize(size_t x) { if ( x <= 127 ) return 1; else if ( x < 0x100 ) return 2; else if ( x < 0x10000 ) return 3; else if ( x < 0x1000000 ) return 4; else return 5; } /* LengthSize */ /************************************************************************ * Tagged -- compute and return the size of a tagged ASN.1 object * whose size without the tag would be (inner). *************************************************************************/ size_t ASN_CMS_Tagged(size_t inner, int seqlike ) { if ( inner == 0 && ! seqlike ) return (0); return ( 1 + inner + ASN_CMS_LengthSize(inner) ); } /* Tagged */ /************************************************************************ * ASN_CMS_PutByte -- put an ASN.1 type byte to op *************************************************************************/ size_t ASN_CMS_PutByte( unsigned char *buf, unsigned char byte ) { *buf = byte; return 1; } /* ASN_CMS_PutByte */ /************************************************************************ * ASN_CMS_PutLength -- put a length field to opp ************************************************************************/ size_t ASN_CMS_PutLength( unsigned char *buf, size_t length ) { unsigned char *bufptr = buf; size_t size = ASN_CMS_LengthSize(length) - 1; unsigned char bytes[4] ; unsigned char *bp = &(bytes[3]) ; /* pointer for unpacking */ switch (size) { case 4: *(bp--) = (unsigned char)length & 0xff ; length >>= 8 ; case 3: *(bp--) = (unsigned char)length & 0xff ; length >>= 8 ; case 2: *(bp--) = (unsigned char)length & 0xff ; length >>= 8 ; case 1: *(bp--) = (unsigned char)length & 0xff ; length >>= 8 ; default: /* fall through */ ; } /* turn x into bytes */ /* only need one byte for length */ if (size == 0) *(bufptr++) = (unsigned char)(length & 0x7f); /* otherwise first byte is number of bytes needed for size */ else *(bufptr++) = (unsigned char)(0x80 | size) ; size = 4 - size; /* as an index into bytes[] */ while (size < 4) *(bufptr++) = bytes[size++] ; /* return the number of bytes used */ return (size_t)(bufptr-buf); } /* ASN_CMS_PutLength */ /************************************************************************ * ASN_CMS_GetByte -- get an ASN.1 type byte to op *************************************************************************/ size_t ASN_CMS_GetByte(const unsigned char *buf, unsigned char *byte) { *byte = *buf; return 1; } /* ASN_CMS_GetByte */ /************************************************************************ * ASN_CMS_GetLength -- fetch a length field from opp and return it * If this is indefinite length, then return -1 for the length. *************************************************************************/ size_t ASN_CMS_GetLength(const unsigned char *buf, size_t *length) { size_t bytesused; unsigned long x ; unsigned char c ; c = *buf; /* get the control byte (or length) */ bytesused = 1; if (c == 0x80) { /* this is indefinite length */ *length = -1; return bytesused; } if ((c & 0x80) == 0) { /* have the length already */ *length = (size_t)c; /* note the byte we used */ ASN_CMS_TRACE_PRINT_LENGTH(c); return bytesused; /* return the length */ } /* if */ c &= 0x7f ; /* get the number of bytes of length */ x = 0 ; /* clear x */ while ((c--) > 0) { x <<= 8 ; /* shift up the word */ x |= (unsigned long)*(buf + bytesused); /* gather the next byte */ bytesused++; } /* pack as integer */ ASN_CMS_TRACE_PRINT_LENGTH((int)x); *length = (size_t)x; /* note the bytes used */ return bytesused; /* return the length */ } /* ASN_CMS_GetLength */ /************************************************************************ * ASN_CMS_PutTag * * Put a tag field (tag + length) to the output block *************************************************************************/ size_t ASN_CMS_PutTag( unsigned char *buf, unsigned char tagbyte, size_t length ) { size_t bytesused; bytesused = ASN_CMS_PutByte(buf, tagbyte); bytesused += ASN_CMS_PutLength(buf+bytesused, length); return bytesused; } /* ASN_CMS_PutTag */ /************************************************************************ * ASN_CMS_TakeTag * * Get a tag field from the input block and return its length *************************************************************************/ size_t ASN_CMS_TakeTag(const unsigned char *buf, unsigned char tag, size_t *length) { size_t bytesused = 0; *length = 0; if (buf == NULL) return 0; if (*buf != tag) return 0; /* have that tag */ bytesused = 1; /* consume the tag byte */ bytesused += ASN_CMS_GetLength(buf+bytesused, length); return bytesused; } /* ASN_CMS_TakeTag */ /************************************************************************ * Basic variable block routines *************************************************************************/ void *ASN_CMS_NewVariableBlock(ASN_CMS_CONTEXT *ctx) { ASN_CMS_VariableBlock *block = NULL ; if (ctx == NULL) return NULL; block = (ASN_CMS_VariableBlock *) ASN_CMS_Alloc(ctx->memMgr, sizeof(ASN_CMS_VariableBlock) ); if (block != NULL) memset(block, 0, sizeof(ASN_CMS_VariableBlock)) ; return (void *)block; } /* ASN_CMS_NewVariableBlock */ size_t ASN_CMS_SizeofVariableBlock(ASN_CMS_CONTEXT *ctx, ASN_CMS_VariableBlock *block, int outerSizeFlag) { (void)ctx; /* for future use */ return ASN_CMS_SizeofVariableBlockInternal(block, outerSizeFlag, ASN_CMS_FALSE); } /***** * * internal ASN_CMS_SizeofVariableBlock * * This internal routine handles the case where there is an * explicitly tagged field in a constructed ASN block. The final length * returned will be increased by the explicit tag bits (using the tagged() * routine) only if the previous calculations don't result in zero. * * It is assumed that outerSizeFlag will not be FALSE when expTaggedSize * is TRUE. This is handled by the generated code. It does not call * _sizeof with this case. Also, the wrapper routine above calls this * routine with expTaggedSize as FALSE. So, this routine doesn't do any * error checking in that respect. * *****/ size_t ASN_CMS_SizeofVariableBlockInternal( ASN_CMS_VariableBlock *block, int outerSizeFlag, int expTaggedSize) { size_t length; if (block == NULL) return (0); length = (size_t)block->len; if (outerSizeFlag == ASN_CMS_TRUE) length = length + 1 + ASN_CMS_LengthSize(block->len); if (expTaggedSize == ASN_CMS_TRUE) length = ASN_CMS_Tagged(length, 0); return length; } /* ASN_CMS_SizeofVariableBlockInternal */ void ASN_CMS_DropInPlaceVariableBlock(ASN_CMS_CONTEXT *ctx, ASN_CMS_VariableBlock *f ) { if (ctx == NULL) return; if (f != NULL && f->val != NULL) { ASN_CMS_Free(ctx->memMgr, f->val); f->val = NULL; } } /* ASN_CMS_DropInPlaceVariableBlock */ void ASN_CMS_FreeVariableBlock(ASN_CMS_CONTEXT *ctx, ASN_CMS_VariableBlock *f) { if (ctx == NULL) return; ASN_CMS_DropInPlaceVariableBlock(ctx, f); if (f != NULL) ASN_CMS_Free(ctx->memMgr, f); return; } /* ASN_CMS_FreeVariableBlock */ /************************************************************************ * pack and unpack -- taking block type as a parameter/ *************************************************************************/ static size_t UnpkInPlaceSegments( ASN_CMS_CONTEXT *ctx, int indefFlag, /* is this an indefinite length block or not? */ unsigned char exptag, /* my expected block tag */ ASN_CMS_VariableBlock *asnblock, /* output block */ const unsigned char *buf, /* loc of input pointer */ size_t buflen, /* max end of my region */ int *erret) /* error return location */ { size_t bytesused = 0; size_t datasize; /* validity of ctx and erret checked in UnpkInPlaceVariableBlock */ if (buf == NULL) { ASN_CMS_ERR(ASN_CMS_ErrUnpackNoBlockPtr); return 0; } /* validity of asnblock checked in UnpkInPlaceVariableBlock */ asnblock->val = NULL; asnblock->len = 0; /* while there are segments */ while (1) { /* For indef length end-of-contents is 0x00 0x00 and we have to eat those two bytes, otherwise we see if we've used up all the available data yet */ if ( indefFlag == 1 && (*(buf+bytesused) == 0x00 && *(buf+bytesused+1) == 0x00) ) { bytesused += 2; break; } else if (indefFlag == 0 && bytesused == buflen) break; if (*buf != exptag) { ASN_CMS_ERR(ASN_CMS_ErrUnpackInvalidEncoding); return 0; } bytesused++; /* skip the tag byte */ datasize = 0; bytesused += ASN_CMS_GetLength(buf+bytesused, &datasize); /* no nested indef lengths for string types */ if ((int)datasize == -1) { ASN_CMS_ERR(ASN_CMS_ErrUnpackInvalidEncoding); return 0; } if (bytesused + datasize > buflen) { ASN_CMS_ERR(ASN_CMS_ErrUnpackOverrun); /* note this error */ return 0; } if (datasize == 0) continue; ASN_CMS_Realloc(ctx->memMgr, (void **)&asnblock->val, asnblock->len+datasize); if (asnblock->val == NULL) { ASN_CMS_ERR(ASN_CMS_ErrOutOfMemory); return 0; } memcpy(asnblock->val + asnblock->len, buf+bytesused, datasize); asnblock->len += datasize; bytesused += datasize; } /* while there are segments */ return bytesused; } /* UnpkInPlaceSegments */ static size_t UnpkInPlaceVariableBlock( ASN_CMS_CONTEXT *ctx, unsigned char exptag, /* my expected block tag */ const char *name, /* my block name */ unsigned char tag, /* my real tag */ ASN_CMS_VariableBlock *asnblock, /* output block */ const unsigned char *buf, /* loc of input pointer */ size_t buflen, /* max end of my region */ int *erret) /* error return location */ { size_t bytesused; size_t datasize; int constructed = 0; int indef = 0; ASN_CMS_TRACE_name(name); ASN_CMS_TRACE_PRINT_FM(exptag, tag, name); if (erret == NULL) return 0; /* can't report errors */ if (ctx == NULL) { ASN_CMS_ERR(ASN_CMS_ErrBadContext); return 0; } if (asnblock == NULL) { ASN_CMS_ERR(ASN_CMS_ErrUnpackNoStructure); return 0; } if (buf == NULL) { ASN_CMS_ERR(ASN_CMS_ErrUnpackNoBlockPtr); return 0; } if (buflen <= 0) return 0; /* no error -- no block */ /* we need to ignore the 6th bit for this check, if this is BER then it may be set, the checks below test for those cases */ if ( (*buf & 0xDF) != (exptag & 0xDF) ) return 0; /* no error code, just no block */ if ( (*buf & 0x20) == 0x20) constructed = 1; bytesused = 1; bytesused += ASN_CMS_GetLength(buf+bytesused, &datasize); if ((int)datasize == -1) { /* indef length */ datasize = 0; indef = 1; } if (bytesused+datasize > buflen) { ASN_CMS_ERR(ASN_CMS_ErrUnpackOverrun); /* note this error */ return 0; } if (indef == 1 && constructed != 1) { ASN_CMS_ERR(ASN_CMS_ErrUnpackInvalidEncoding); return 0; } if (asnblock->val != NULL) ASN_CMS_Free(ctx->memMgr, asnblock->val); /* about to carve it */ ASN_CMS_TRACE_PRINT_DATA(buf+bytesused,datasize); if (constructed == 0) { /* primitive */ asnblock->len = datasize; /* record the length */ asnblock->val = (unsigned char *)ASN_CMS_Alloc(ctx->memMgr, datasize); if (asnblock->val == NULL) { ASN_CMS_ERR(ASN_CMS_ErrOutOfMemory); return 0; } memcpy(asnblock->val, buf+bytesused, datasize); bytesused += datasize; } else if (indef == 1) { /* constructed, indefinite length */ bytesused += UnpkInPlaceSegments(ctx, indef, tag, asnblock, buf+bytesused, buflen-bytesused, erret); } else { /* constructed, definite length */ bytesused += UnpkInPlaceSegments(ctx, indef, (unsigned char)(exptag & 0xDF), asnblock, buf+bytesused, datasize, erret); } return bytesused; } /* UnpkInPlaceVariableBlock */ /************************************************************************ * PackVariableBlock * * Pack up an ASN_CMS_VariableBlock -- which could be an INTEGER, BIT STRING or * OCTET STRING. * * Those three differ in padding (or its inverse). * * For OCTET STRING, pad = 0 * For BIT STRING, pad = 1, padb = # unused bits in the LSByte * For INTEGER, pad = 0..-N, where N is the # of unnecesary leading * 0x00 or 0xff bytes * * pad and padb have to be filled in by the caller. *************************************************************************/ static size_t PackVariableBlock( ASN_CMS_CONTEXT *ctx, unsigned char blockType, /* my block type */ int pad, /* padding? (boolean) */ unsigned char padbyte, /* pad byte if (pad) */ unsigned char *buf, /* the output pointer pointer */ size_t buflen, ASN_CMS_VariableBlock *block, /* the block I'm packing */ int *erret) /* an error */ { size_t bytesused = 0; unsigned char *lastbyte; unsigned char mask = 0xFF; (void)ctx; /* for future use */ if (block == NULL) return 0; if (buf == NULL) { ASN_CMS_ERR(ASN_CMS_ErrPackNoBlock); return 0; } /* need room for tag + length bytes*/ if (buflen < (1 + ASN_CMS_LengthSize(block->len+pad)) ) { ASN_CMS_ERR(ASN_CMS_ErrPackOverrun); return 0; } bytesused = ASN_CMS_PutTag(buf, blockType, block->len+pad); if (pad) { /* error here if padbyte > 7??? */ if (buflen < (bytesused + 1 + block->len) ) { ASN_CMS_ERR(ASN_CMS_ErrPackOverrun); return 0; } /* add the pad byte before the data */ bytesused += ASN_CMS_PutByte( buf+bytesused, padbyte); memcpy(buf+bytesused, block->val, block->len); bytesused += block->len; /* for DER bit strings, the padding bits must be zeros */ if (padbyte != 0) { lastbyte = buf + bytesused - 1; mask = mask << padbyte; /* zeros are shifted in */ *lastbyte = *lastbyte & mask; } } else { if (buflen < (bytesused + block->len) ) { ASN_CMS_ERR(ASN_CMS_ErrPackOverrun); return 0; } /* just add the data */ memcpy(buf+bytesused, block->val, block->len); bytesused += block->len; } return bytesused; } /* PackVariableBlock */ /************************************************************************ * ASN_CMS_PutOctVal * * Put a octet buffer value away in a vbl block. *************************************************************************/ int ASN_CMS_PutOctVal( ASN_CMS_CONTEXT *ctx, ASN_CMS_VariableBlock *block, /* the block for the value */ const unsigned char *value, /* the value */ size_t lth) /* the length */ { if (ctx == NULL) return ASN_CMS_ErrBadContext; if (block == NULL) return (-1); if (block->val != NULL) ASN_CMS_Free(ctx->memMgr, block->val); memset (block, 0, sizeof(ASN_CMS_VariableBlock)); block->val = (unsigned char *)ASN_CMS_Alloc(ctx->memMgr, lth); if (block->val == NULL) return (-1); memcpy( block->val, value, lth ) ; block->len = lth ; return (0); } /* ASN_CMS_PutOctVal */ /************************************************************************ * ASN_CMS_PutStrVal * * Put a string value away in a vbl block. *************************************************************************/ int ASN_CMS_PutStrVal( ASN_CMS_CONTEXT *ctx, ASN_CMS_VariableBlock *block, /* the block for the value */ const char *value) /* the value */ { if (ctx == NULL) return ASN_CMS_ErrBadContext; if (block == NULL) return (-1); if (block->val != NULL) ASN_CMS_Free(ctx->memMgr, block->val); memset(block, 0, sizeof(ASN_CMS_VariableBlock)); block->len = strlen(value); block->val = (unsigned char *)ASN_CMS_Alloc(ctx->memMgr, block->len); if (block->val == NULL) return (-1); memcpy(block->val, value, block->len); return (0); } /* ASN_CMS_PutStrVal */ /************************************************************************ *ASN_CMS_GetStrVal * * Return a string value found in a vbl block. *************************************************************************/ char *ASN_CMS_GetStrVal( ASN_CMS_CONTEXT *ctx, ASN_CMS_VariableBlock *block) { char *string; if (ctx == NULL) return NULL; if (block == NULL) return NULL; if (block->val == NULL || block->len == 0) return NULL; /* '+1' for NULL char */ string = (char *)ASN_CMS_Alloc(ctx->memMgr, block->len + 1); if (string == NULL) return NULL; memcpy(string, block->val, block->len); string[block->len] = '\0'; return string; } /* ASN_CMS_GetStrVal */ /************************************************************************ * ASN_CMS_PutBitString * * Put a bit string value away in a bitstring block. ************************************************************************/ int ASN_CMS_PutBitString ( ASN_CMS_CONTEXT *ctx, ASN_CMS_BitstringBlock *block, /* the block for the value */ const unsigned char *string, /* the value */ size_t lth, /* the length */ int nuub) /* number of unused bits LSB */ { if (ctx == NULL) return ASN_CMS_ErrBadContext; if (block == NULL) return (-1); if ((block->val) != NULL) ASN_CMS_Free(ctx->memMgr, block->val); memset (block, 0, sizeof(ASN_CMS_BitstringBlock)); block->val = (unsigned char *)ASN_CMS_Alloc(ctx->memMgr, lth); if (block->val == NULL) return (-1); memcpy(block->val, string, lth); block->len = lth; block->nuub = nuub; return 0; } /************************************************************************ * ASN_CMS_PutBoolVal * * Put a boolean value in an ASN_CMS_BOOLEAN block. *************************************************************************/ int ASN_CMS_PutBoolVal( ASN_CMS_CONTEXT *ctx, ASN_CMS_BOOLEAN *block, /* the block for the value */ int val) /* */ { (void)ctx; /* for future use */ if (block == NULL) return (-1); if (val != 0) block->val = ASN_CMS_TRUE; else block->val = ASN_CMS_FALSE; block->len = 1; return 0; } /************************************************************************ * ASN_CMS_GetBoolVal * * Put a boolean value in an ASN_CMS_BOOLEAN block. *************************************************************************/ int ASN_CMS_GetBoolVal( ASN_CMS_CONTEXT *ctx, ASN_CMS_BOOLEAN *block) /* the block for the value */ { (void)ctx; /* for future use */ if (block == NULL) return (-1); if (block->val != 0) return ASN_CMS_TRUE; else return ASN_CMS_FALSE; } /************************************************************************ * NULL routines *************************************************************************/ ASN_CMS_NULL *ASN_CMS_NewNULL( ASN_CMS_CONTEXT *ctx) { ASN_CMS_NULL *f = NULL; if (ctx == NULL) return NULL; f = (ASN_CMS_NULL *)ASN_CMS_Alloc(ctx->memMgr, sizeof(ASN_CMS_NULL)); if (f != NULL) memset(f, 0, sizeof(ASN_CMS_NULL) ); return ((ASN_CMS_NULL *) f); } /* ASN_CMS_NewNULL */ void ASN_CMS_DropInPlaceNULL( ASN_CMS_CONTEXT *ctx, ASN_CMS_NULL *f) { (void)ctx; (void)f; return ; } /* ASN_CMS_DropInPlaceNULL */ void ASN_CMS_FreeNULL( ASN_CMS_CONTEXT *ctx, ASN_CMS_NULL *g) { if (ctx == NULL) return; if (g != NULL) ASN_CMS_Free(ctx->memMgr, g); } /* ASN_CMS_FreeNULL */ size_t ASN_CMS_SizeofNULL( ASN_CMS_CONTEXT *ctx, ASN_CMS_NULL *b, int outerSizeFlag) { (void)ctx; /* for future use */ return ASN_CMS_SizeofNULLInternal(b, outerSizeFlag, ASN_CMS_FALSE); } /* ASN_CMS_SizeofNULL */ size_t ASN_CMS_SizeofNULLInternal( ASN_CMS_NULL *b, int outerSizeFlag, int expTaggedFlag) { size_t length = 0; if (b == NULL) return 0; if (outerSizeFlag == ASN_CMS_TRUE) length = 2; if (expTaggedFlag == ASN_CMS_TRUE) length = ASN_CMS_Tagged(length, 0); return length; } /* ASN_CMS_SizeofNULLInternal */ size_t ASN_CMS_PackNULL( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_NULL *asnblock, int *erret) { return (ASN_CMS_PackNULLInternal(ctx, buf, buflen, asnblock, ASN_CMS_ID_NULL, erret)); } size_t ASN_CMS_PackNULLInternal( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_NULL *asnblock, unsigned char tag, int *erret) { size_t bytesused; (void)ctx; /* for future use */ if (erret == NULL) return 0; if (asnblock == NULL) return 0; bytesused = ASN_CMS_PutByte(buf, tag); bytesused += ASN_CMS_PutByte(buf+bytesused, 0x00); /* length = 0 bytes */ if (bytesused > buflen) { ASN_CMS_ERR(ASN_CMS_ErrPackOverrun); /* note this error */ return 0; } return bytesused; } /* ASN_CMS_PackNULLInternal */ size_t ASN_CMS_UnpkInPlaceNULL( ASN_CMS_CONTEXT *ctx, ASN_CMS_NULL *nullstruct, /* output block */ const unsigned char *buf, /* loc of input pointer */ size_t buflen, /* max end of my region */ unsigned char tag, /* tag to use */ int *erret /* error return location */ ) { size_t bytesused; size_t datasize; ASN_CMS_TRACE_PRINT_FM(tag, 0x05, "NULL"); (void)ctx; if (erret == NULL) return 0; /* can't report errors */ if (nullstruct == NULL) { ASN_CMS_ERR(ASN_CMS_ErrUnpackNoStructure); return 0; } if (buf == NULL) { ASN_CMS_ERR(ASN_CMS_ErrUnpackNoBlockPtr); return 0; } if (buflen <= 0) return 0; /* no error -- no block */ if (*buf != tag) return 0; /* no error, no block */ bytesused = 1; bytesused += ASN_CMS_GetLength(buf+bytesused, &datasize); if (datasize != 0) { ASN_CMS_ERR(ASN_CMS_ErrUnpackNullLth); return 0; } if (bytesused > buflen) { ASN_CMS_ERR(ASN_CMS_ErrUnpackOverrun); /* note this error */ return 0; } nullstruct->len = 0; return bytesused; } /* ASN_CMS_UnpkInPlaceNULL */ size_t ASN_CMS_UnpackNULL( ASN_CMS_CONTEXT *ctx, ASN_CMS_NULL **nullstruct, const unsigned char *buf, size_t buflen, int *erret) /* error return */ { return(ASN_CMS_UnpackNULLInternal(ctx, nullstruct, buf, buflen, ASN_CMS_ID_NULL, erret)); } /* ASN_CMS_UnpackNULL */ size_t ASN_CMS_UnpackNULLInternal( ASN_CMS_CONTEXT *ctx, ASN_CMS_NULL **nullstruct, const unsigned char *buf, size_t buflen, unsigned char tag, int *erret) /* error return */ { size_t bytesused; ASN_CMS_NULL *local = NULL; if (erret == NULL) return 0; *erret = 0; if (ctx == NULL) { ASN_CMS_ERR(ASN_CMS_ErrBadContext); return 0; } if (nullstruct == NULL) { ASN_CMS_ERR(ASN_CMS_ErrUnpackNoStructure); return 0; } *nullstruct = NULL; if (buflen <= 0) return 0; if (*buf != tag) return 0; local = ASN_CMS_NewNULL(ctx); /* carve a block for it */ bytesused = ASN_CMS_UnpkInPlaceNULL(ctx, local, buf, buflen, tag, erret); if (*erret != 0) { if (local != NULL) ASN_CMS_FreeNULL(ctx, local); return 0; } *nullstruct = local; return bytesused; } /* ASN_CMS_UnpackNULLInternal */ /************************************************************************ * ASN_CMS_BOOLEAN routines *************************************************************************/ ASN_CMS_BOOLEAN *ASN_CMS_NewBOOLEAN( ASN_CMS_CONTEXT *ctx) { ASN_CMS_BOOLEAN *f = NULL; if (ctx == NULL) return NULL; f = (ASN_CMS_BOOLEAN *)ASN_CMS_Alloc(ctx->memMgr, sizeof(ASN_CMS_BOOLEAN) ); if (f != NULL) memset(f, 0, sizeof(ASN_CMS_BOOLEAN) ); return ((ASN_CMS_BOOLEAN *) f); } /* NewBOOLEAN */ void ASN_CMS_DropInPlaceBOOLEAN( ASN_CMS_CONTEXT *ctx, ASN_CMS_BOOLEAN *f) { (void)ctx; (void)f; return ; } /* ASN_CMS_DropInPlaceBOOLEAN */ void ASN_CMS_FreeBOOLEAN( ASN_CMS_CONTEXT *ctx, ASN_CMS_BOOLEAN *g ) { if (ctx == NULL) return; if (g != NULL) ASN_CMS_Free(ctx->memMgr, g); } /* ASN_CMS_FreeBOOLEAN */ size_t ASN_CMS_SizeofBOOLEAN( ASN_CMS_CONTEXT *ctx, ASN_CMS_BOOLEAN *boolblock, int outerSizeFlag) { (void)ctx; /* for future use */ return ASN_CMS_SizeofBOOLEANInternal(boolblock, outerSizeFlag, ASN_CMS_FALSE); } size_t ASN_CMS_SizeofBOOLEANInternal( ASN_CMS_BOOLEAN *boolblock, int outerSizeFlag, int expTaggedSize) { size_t length = 1; if (boolblock == NULL) return 0; if (outerSizeFlag == ASN_CMS_TRUE) length = 3; if (expTaggedSize == ASN_CMS_TRUE) length = ASN_CMS_Tagged(length, 0); return length; } /* ASN_CMS_SizeofBOOLEANInternal */ size_t ASN_CMS_PackBOOLEAN( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_BOOLEAN *boolblock, int *erret ) { return(ASN_CMS_PackBOOLEANInternal(ctx, buf, buflen, boolblock, ASN_CMS_ID_BOOLEAN, erret)); } /* ASN_CMS_PackBOOLEAN */ size_t ASN_CMS_PackBOOLEANInternal( ASN_CMS_CONTEXT *ctx, unsigned char *buf, size_t buflen, ASN_CMS_BOOLEAN *boolblock, unsigned char tag, int *erret ) { unsigned char value = 0x00; size_t bytesused; (void)ctx; /* for future use */ if (boolblock == NULL) return 0; if (boolblock->val != 0) value = 0xff; bytesused = ASN_CMS_PutByte(buf, tag); /* this is a ASN_CMS_BOOLEAN */ bytesused += ASN_CMS_PutByte(buf+bytesused, 1); /* length = 1 byte */ bytesused += ASN_CMS_PutByte(buf+bytesused, value); /* the value */ if (bytesused > buflen) { ASN_CMS_ERR(ASN_CMS_ErrPackOverrun); /* note this error */ return 0; } return bytesused; } /* ASN_CMS_PackBOOLEANInternal */ size_t ASN_CMS_UnpkInPlaceBOOLEAN( ASN_CMS_CONTEXT *ctx, ASN_CMS_BOOLEAN *boolstruct, /* output block */ const unsigned char *buf, /* loc of input pointer */ size_t buflen, /* max end of my region */ unsigned char tag, int *erret) /* error return location */ { size_t bytesused; size_t datasize; (void)ctx; ASN_CMS_TRACE_PRINT_FM(tag, 0x01, "BOOLEAN"); if (erret == NULL) return 0; /* can't report errors */ if (boolstruct == NULL) { ASN_CMS_ERR(ASN_CMS_ErrUnpackNoStructure); return 0; } if (buf == NULL) { ASN_CMS_ERR(ASN_CMS_ErrUnpackNoBlockPtr); return 0; } if (buflen <= 0) return 0; /* no error -- no block */ if (*buf != tag) return 0; bytesused = 1; bytesused += ASN_CMS_GetLength(buf+bytesused, &datasize); if (datasize != 1) { ASN_CMS_ERR( ASN_CMS_ErrUnpackBooleanLth); return 0; } if (bytesused+datasize > buflen) { ASN_CMS_ERR(ASN_CMS_ErrUnpackOverrun); /* note this error */ return 0; } ASN_CMS_TRACE_PRINT_DATA(buf+bytesused,1); bytesused += ASN_CMS_GetByte(buf+bytesused, (unsigned char *)&(boolstruct->val)); if (boolstruct->val != 0) boolstruct->val = ASN_CMS_TRUE; return bytesused; } /* ASN_CMS_UnpkInPlaceBOOLEAN */ size_t ASN_CMS_UnpackBOOLEAN( ASN_CMS_CONTEXT *ctx, ASN_CMS_BOOLEAN **boolstruct, const unsigned char *buf, size_t buflen, int *erret) /* error return */ { return(ASN_CMS_UnpackBOOLEANInternal(ctx, boolstruct, buf, buflen, ASN_CMS_ID_BOOLEAN, erret)); } size_t ASN_CMS_UnpackBOOLEANInternal( ASN_CMS_CONTEXT *ctx, ASN_CMS_BOOLEAN **boolstruct, const unsigned char *buf, size_t buflen, unsigned char tag, int *erret) /* error return */ { size_t bytesused; ASN_CMS_BOOLEAN *local = NULL; if (erret == NULL) return 0; *erret = 0; if (ctx == NULL) { ASN_CMS_ERR(ASN_CMS_ErrBadContext); return 0; } if (boolstruct == NULL) { ASN_CMS_ERR(ASN_CMS_ErrUnpackNoStructure); return 0; } *boolstruct = NULL; if (buflen <= 0) return 0; if (*buf != tag) return 0; local = ASN_CMS_NewBOOLEAN(ctx); /* carve a block for it */ bytesused = ASN_CMS_UnpkInPlaceBOOLEAN(ctx, local, buf, buflen, tag, erret); if (*erret != 0) { if (local != NULL) ASN_CMS_FreeBOOLEAN(ctx, local); return 0; } *boolstruct = local; return bytesused; } /* ASN_CMS_UnpackBOOLEANInternal */ /************************************************************************ * Routines for ASN_CMS_BIT_STRING *************************************************************************/ ASN_CMS_BIT_STRING *ASN_CMS_NewBIT_STRING( ASN_CMS_CONTEXT *ctx) { ASN_CMS_BIT_STRING *f = NULL ; if (ctx == NULL) return NULL; f = (ASN_CMS_BIT_STRING *)ASN_CMS_Alloc(ctx->memMgr, sizeof(ASN_CMS_BIT_STRING) ); if (f != NULL) memset( f, 0, sizeof(ASN_CMS_BIT_STRING) ); return ((ASN_CMS_BIT_STRING *) f); } /* ASN_CMS_NewBIT_STRING */ void ASN_CMS_DropInPlaceBIT_STRING( ASN_CMS_CONTEXT *ctx, ASN_CMS_BIT_STRING *f ) { if (ctx == NULL) return; if (f != NULL) { if ((f->val) != NULL) { ASN_CMS_Free(ctx->memMgr, f->val); } f->val = NULL ; } return ; } /* ASN_CMS_DropInPlaceBIT_STRING */ void ASN_CMS_FreeBIT_STRING( ASN_CMS_CONTEXT *ctx, ASN_CMS_BIT_STRING *f ) { if (ctx == NULL) return; ASN_CMS_DropInPlaceBIT_STRING(ctx, f); if (f != NULL) ASN_CMS_Free(ctx->memMgr, f); } /* ASN_CMS_FreeBIT_STRING */ size_t ASN_CMS_SizeofBIT_STRING( ASN_CMS_CONTEXT *ctx, ASN_CMS_BIT_STRING *bitblock, int outerSizeFlag) { (void)ctx; /* for future use */ return ASN_CMS_SizeofBIT_STRINGInternal(bitblock, outerSizeFlag, ASN_CMS_FALSE); } size_t ASN_CMS_SizeofBIT_STRINGInternal( ASN_CMS_BIT_STRING *bitblock, int outerSizeFlag, int expTaggedSize) { size_t body_size; if (bitblock == NULL) return (0); body_size = 1 + bi