pgpx509cert_asn.c

vc环境下的pgp源码

/*******************************************************************
 *
 * This file was generated by TIS/ASN1COMP Ver. 4.2, an ASN.1 compiler.
 * TIS/ASN1COMP is Copyright (c) 1998, TIS Labs at Network Associates, Inc.
 *
 * This file was AUTOMATICALLY GENERATED on Tue May 18 17:09:45 1999
 *
 ******************************************************************/


#include <string.h>

#include "pgpX509Cert_asn.h"

/*******************************************************************
 *
 * Code for manipulating ASN.1 DER data and structure.
 *
 *  NewXXX: Allocate the top level of a structure.
 *
 *  FreeXXX: Release all the data of an ASN structure.
 *
 *  SizeofXXX: Return the size of the DER block that would
 *               be created from the structure.
 *
 *  PackXXX: Take an ASN structure and return the DER.
 *
 *  unPackXXX: Take the DER and return an ASN structure.
 *
 ******************************************************************/


size_t pgpasn_PackBMPString(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_BMPString *asnstruct,
    int *erret )
{
    return(pgpasn_PackBMPStringInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_BMPString, erret));
} /* pgpasn_PackBMPString */

size_t pgpasn_UnpackBMPString(
    PGPASN_CONTEXT *ctx,
    PGPASN_BMPString **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackBMPStringInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_BMPString, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

size_t pgpasn_PackUTF8String(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_UTF8String *asnstruct,
    int *erret )
{
    return(pgpasn_PackUTF8StringInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_UTF8String, erret));
} /* pgpasn_PackUTF8String */

size_t pgpasn_UnpackUTF8String(
    PGPASN_CONTEXT *ctx,
    PGPASN_UTF8String **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackUTF8StringInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_UTF8String, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

size_t pgpasn_PackUniversalString(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_UniversalString *asnstruct,
    int *erret )
{
    return(pgpasn_PackUniversalStringInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_UniversalString, erret));
} /* pgpasn_PackUniversalString */

size_t pgpasn_UnpackUniversalString(
    PGPASN_CONTEXT *ctx,
    PGPASN_UniversalString **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackUniversalStringInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_UniversalString, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for AlgorithmIdentifier
 ******************************************************************/

PGPASN_AlgorithmIdentifier *pgpasn_NewAlgorithmIdentifier(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_AlgorithmIdentifier *f;

    if (ctx == NULL)
        return NULL;

    f = (PGPASN_AlgorithmIdentifier *)PGPASN_Alloc(ctx->memMgr, sizeof(PGPASN_AlgorithmIdentifier));
    if (f != NULL)
        (void)memset(f, 0, sizeof(PGPASN_AlgorithmIdentifier));
    return (f);

} /* pgpasn_NewAlgorithmIdentifier */

void pgpasn_FreeAlgorithmIdentifier(
    PGPASN_CONTEXT *ctx,
    PGPASN_AlgorithmIdentifier *f)
{
    if (ctx == NULL)
        return;

    pgpasn_DropInPlaceAlgorithmIdentifier(ctx, f);
    if (f != NULL)
        PGPASN_Free(ctx->memMgr, f);

} /* pgpasn_FreeAlgorithmIdentifier */

size_t pgpasn_SizeofAlgorithmIdentifier(
    PGPASN_CONTEXT *ctx,
    PGPASN_AlgorithmIdentifier *asnstruct,
    int outerSizeFlag)
{
    (void)ctx; /* for future use */

    return(pgpasn_SizeofAlgorithmIdentifierInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofAlgorithmIdentifier */

size_t pgpasn_PackAlgorithmIdentifier(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_AlgorithmIdentifier *asnstruct,
    int *erret )
{
    return(pgpasn_PackAlgorithmIdentifierInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_AlgorithmIdentifier, erret));
} /* pgpasn_PackAlgorithmIdentifier */

size_t pgpasn_UnpackAlgorithmIdentifier(
    PGPASN_CONTEXT *ctx,
    PGPASN_AlgorithmIdentifier **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackAlgorithmIdentifierInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_AlgorithmIdentifier, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for AttributeTypeAndValue
 ******************************************************************/

PGPASN_AttributeTypeAndValue *pgpasn_NewAttributeTypeAndValue(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_AttributeTypeAndValue *f;

    if (ctx == NULL)
        return NULL;

    f = (PGPASN_AttributeTypeAndValue *)PGPASN_Alloc(ctx->memMgr, sizeof(PGPASN_AttributeTypeAndValue));
    if (f != NULL)
        (void)memset(f, 0, sizeof(PGPASN_AttributeTypeAndValue));
    return (f);

} /* pgpasn_NewAttributeTypeAndValue */

void pgpasn_FreeAttributeTypeAndValue(
    PGPASN_CONTEXT *ctx,
    PGPASN_AttributeTypeAndValue *f)
{
    if (ctx == NULL)
        return;

    pgpasn_DropInPlaceAttributeTypeAndValue(ctx, f);
    if (f != NULL)
        PGPASN_Free(ctx->memMgr, f);

} /* pgpasn_FreeAttributeTypeAndValue */

size_t pgpasn_SizeofAttributeTypeAndValue(
    PGPASN_CONTEXT *ctx,
    PGPASN_AttributeTypeAndValue *asnstruct,
    int outerSizeFlag)
{
    (void)ctx; /* for future use */

    return(pgpasn_SizeofAttributeTypeAndValueInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofAttributeTypeAndValue */

size_t pgpasn_PackAttributeTypeAndValue(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_AttributeTypeAndValue *asnstruct,
    int *erret )
{
    return(pgpasn_PackAttributeTypeAndValueInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_AttributeTypeAndValue, erret));
} /* pgpasn_PackAttributeTypeAndValue */

size_t pgpasn_UnpackAttributeTypeAndValue(
    PGPASN_CONTEXT *ctx,
    PGPASN_AttributeTypeAndValue **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackAttributeTypeAndValueInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_AttributeTypeAndValue, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for AttributeValues
 ******************************************************************/

PGPASN_AttributeValues *pgpasn_NewAttributeValues(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_AttributeValues *f;

    if (ctx == NULL)
        return NULL;

    f = (PGPASN_AttributeValues *)PGPASN_Alloc(ctx->memMgr, sizeof(PGPASN_AttributeValues));
    if (f != NULL)
        (void)memset(f, 0, sizeof(PGPASN_AttributeValues));
    return (f);

} /* pgpasn_NewAttributeValues */

void pgpasn_FreeAttributeValues(
    PGPASN_CONTEXT *ctx,
    PGPASN_AttributeValues *f)
{
    if (ctx == NULL)
        return;

    pgpasn_DropInPlaceAttributeValues(ctx, f);
    if (f != NULL)
        PGPASN_Free(ctx->memMgr, f);

} /* pgpasn_FreeAttributeValues */

size_t pgpasn_SizeofAttributeValues(
    PGPASN_CONTEXT *ctx,
    PGPASN_AttributeValues *asnstruct,
    int outerSizeFlag)
{
    (void)ctx; /* for future use */

    return(pgpasn_SizeofAttributeValuesInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofAttributeValues */

size_t pgpasn_PackAttributeValues(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_AttributeValues *asnstruct,
    int *erret )
{
    return(pgpasn_PackAttributeValuesInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_AttributeValues, erret));
} /* pgpasn_PackAttributeValues */

size_t pgpasn_UnpackAttributeValues(
    PGPASN_CONTEXT *ctx,
    PGPASN_AttributeValues **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackAttributeValuesInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_AttributeValues, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for BasicConstraints
 ******************************************************************/

PGPASN_BasicConstraints *pgpasn_NewBasicConstraints(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_BasicConstraints *f;

    if (ctx == NULL)
        return NULL;

    f = (PGPASN_BasicConstraints *)PGPASN_Alloc(ctx->memMgr, sizeof(PGPASN_BasicConstraints));
    if (f != NULL)
        (void)memset(f, 0, sizeof(PGPASN_BasicConstraints));
    return (f);

} /* pgpasn_NewBasicConstraints */

void pgpasn_FreeBasicConstraints(
    PGPASN_CONTEXT *ctx,
    PGPASN_BasicConstraints *f)
{
    if (ctx == NULL)
        return;

    pgpasn_DropInPlaceBasicConstraints(ctx, f);
    if (f != NULL)
        PGPASN_Free(ctx->memMgr, f);

} /* pgpasn_FreeBasicConstraints */

size_t pgpasn_SizeofBasicConstraints(
    PGPASN_CONTEXT *ctx,
    PGPASN_BasicConstraints *asnstruct,
    int outerSizeFlag)
{
    (void)ctx; /* for future use */

    return(pgpasn_SizeofBasicConstraintsInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofBasicConstraints */

size_t pgpasn_PackBasicConstraints(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_BasicConstraints *asnstruct,
    int *erret )
{
    return(pgpasn_PackBasicConstraintsInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_BasicConstraints, erret));
} /* pgpasn_PackBasicConstraints */

size_t pgpasn_UnpackBasicConstraints(
    PGPASN_CONTEXT *ctx,
    PGPASN_BasicConstraints **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackBasicConstraintsInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_BasicConstraints, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for CertificateValidityDate
 ******************************************************************/

PGPASN_CertificateValidityDate *pgpasn_NewCertificateValidityDate(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_CertificateValidityDate *f;

    if (ctx == NULL)
        return NULL;

    f = (PGPASN_CertificateValidityDate *)PGPASN_Alloc(ctx->memMgr, sizeof(PGPASN_CertificateValidityDate));
    if (f != NULL)
        (void)memset(f, 0, sizeof(PGPASN_CertificateValidityDate));
    return (f);

} /* pgpasn_NewCertificateValidityDate */

void pgpasn_FreeCertificateValidityDate(
    PGPASN_CONTEXT *ctx,
    PGPASN_CertificateValidityDate *f)
{
    if (ctx == NULL)
        return;

    pgpasn_DropInPlaceCertificateValidityDate(ctx, f);
    if (f != NULL)
        PGPASN_Free(ctx->memMgr, f);

} /* pgpasn_FreeCertificateValidityDate */

size_t pgpasn_SizeofCertificateValidityDate(
    PGPASN_CONTEXT *ctx,
    PGPASN_CertificateValidityDate *asnstruct,
    int outerSizeFlag)
{
    (void)ctx; /* for future use */

    return(pgpasn_SizeofCertificateValidityDateInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofCertificateValidityDate */

size_t pgpasn_PackCertificateValidityDate(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_CertificateValidityDate *asnstruct,
    int *erret )
{
    return(pgpasn_PackCertificateValidityDateInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_CertificateValidityDate, erret));
} /* pgpasn_PackCertificateValidityDate */

size_t pgpasn_UnpackCertificateValidityDate(
    PGPASN_CONTEXT *ctx,
    PGPASN_CertificateValidityDate **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackCertificateValidityDateInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_CertificateValidityDate, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for ContentInfo
 ******************************************************************/

PGPASN_ContentInfo *pgpasn_NewContentInfo(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_ContentInfo *f;

    if (ctx == NULL)
        return NULL;

    f = (PGPASN_ContentInfo *)PGPASN_Alloc(ctx->memMgr, sizeof(PGPASN_ContentInfo));
    if (f != NULL)
        (void)memset(f, 0, sizeof(PGPASN_ContentInfo));
    return (f);

} /* pgpasn_NewContentInfo */