cert_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 Mon May 17 09:25:53 1999
 *
 ******************************************************************/


#include <string.h>

#include "cert_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 PKIPackBMPString(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIBMPString *asnstruct,
    int *erret )
{
    return(PKIPackBMPStringInternal(ctx, buf, buflen, asnstruct, PKIID_BMPString, erret));
} /* PKIPackBMPString */

size_t PKIUnpackBMPString(
    PKICONTEXT *ctx,
    PKIBMPString **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackBMPStringInternal(ctx, asnstruct, buf, buflen,
                      PKIID_BMPString, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

size_t PKIPackUTF8String(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIUTF8String *asnstruct,
    int *erret )
{
    return(PKIPackUTF8StringInternal(ctx, buf, buflen, asnstruct, PKIID_UTF8String, erret));
} /* PKIPackUTF8String */

size_t PKIUnpackUTF8String(
    PKICONTEXT *ctx,
    PKIUTF8String **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackUTF8StringInternal(ctx, asnstruct, buf, buflen,
                      PKIID_UTF8String, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

size_t PKIPackUniversalString(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIUniversalString *asnstruct,
    int *erret )
{
    return(PKIPackUniversalStringInternal(ctx, buf, buflen, asnstruct, PKIID_UniversalString, erret));
} /* PKIPackUniversalString */

size_t PKIUnpackUniversalString(
    PKICONTEXT *ctx,
    PKIUniversalString **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackUniversalStringInternal(ctx, asnstruct, buf, buflen,
                      PKIID_UniversalString, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for noticeNumbers_SEQ_OF
 ******************************************************************/

PKInoticeNumbers_SEQ_OF *PKINewnoticeNumbers_SEQ_OF(
    PKICONTEXT *ctx)
{
    PKInoticeNumbers_SEQ_OF *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewnoticeNumbers_SEQ_OF */

void PKIFreenoticeNumbers_SEQ_OF(
    PKICONTEXT *ctx,
    PKInoticeNumbers_SEQ_OF *f)
{
    if (ctx == NULL)
        return;

    PKIDropInPlacenoticeNumbers_SEQ_OF(ctx, f);
    if (f != NULL)
        PKIFree(ctx->memMgr, f);

} /* PKIFreenoticeNumbers_SEQ_OF */

size_t PKISizeofnoticeNumbers_SEQ_OF(
    PKICONTEXT *ctx,
    PKInoticeNumbers_SEQ_OF *asnstruct,
    int outerSizeFlag)
{
    (void)ctx; /* for future use */

    return(PKISizeofnoticeNumbers_SEQ_OFInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofnoticeNumbers_SEQ_OF */

size_t PKIPacknoticeNumbers_SEQ_OF(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKInoticeNumbers_SEQ_OF *asnstruct,
    int *erret )
{
    return(PKIPacknoticeNumbers_SEQ_OFInternal(ctx, buf, buflen, asnstruct, PKIID_noticeNumbers_SEQ_OF, erret));
} /* PKIPacknoticeNumbers_SEQ_OF */

size_t PKIUnpacknoticeNumbers_SEQ_OF(
    PKICONTEXT *ctx,
    PKInoticeNumbers_SEQ_OF **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpacknoticeNumbers_SEQ_OFInternal(ctx, asnstruct, buf, buflen,
                      PKIID_noticeNumbers_SEQ_OF, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

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

PKIAlgorithmIdentifier *PKINewAlgorithmIdentifier(
    PKICONTEXT *ctx)
{
    PKIAlgorithmIdentifier *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewAlgorithmIdentifier */

void PKIFreeAlgorithmIdentifier(
    PKICONTEXT *ctx,
    PKIAlgorithmIdentifier *f)
{
    if (ctx == NULL)
        return;

    PKIDropInPlaceAlgorithmIdentifier(ctx, f);
    if (f != NULL)
        PKIFree(ctx->memMgr, f);

} /* PKIFreeAlgorithmIdentifier */

size_t PKISizeofAlgorithmIdentifier(
    PKICONTEXT *ctx,
    PKIAlgorithmIdentifier *asnstruct,
    int outerSizeFlag)
{
    (void)ctx; /* for future use */

    return(PKISizeofAlgorithmIdentifierInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofAlgorithmIdentifier */

size_t PKIPackAlgorithmIdentifier(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIAlgorithmIdentifier *asnstruct,
    int *erret )
{
    return(PKIPackAlgorithmIdentifierInternal(ctx, buf, buflen, asnstruct, PKIID_AlgorithmIdentifier, erret));
} /* PKIPackAlgorithmIdentifier */

size_t PKIUnpackAlgorithmIdentifier(
    PKICONTEXT *ctx,
    PKIAlgorithmIdentifier **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackAlgorithmIdentifierInternal(ctx, asnstruct, buf, buflen,
                      PKIID_AlgorithmIdentifier, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for AnotherName
 ******************************************************************/

PKIAnotherName *PKINewAnotherName(
    PKICONTEXT *ctx)
{
    PKIAnotherName *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewAnotherName */

void PKIFreeAnotherName(
    PKICONTEXT *ctx,
    PKIAnotherName *f)
{
    if (ctx == NULL)
        return;

    PKIDropInPlaceAnotherName(ctx, f);
    if (f != NULL)
        PKIFree(ctx->memMgr, f);

} /* PKIFreeAnotherName */

size_t PKISizeofAnotherName(
    PKICONTEXT *ctx,
    PKIAnotherName *asnstruct,
    int outerSizeFlag)
{
    (void)ctx; /* for future use */

    return(PKISizeofAnotherNameInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofAnotherName */

size_t PKIPackAnotherName(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIAnotherName *asnstruct,
    int *erret )
{
    return(PKIPackAnotherNameInternal(ctx, buf, buflen, asnstruct, PKIID_AnotherName, erret));
} /* PKIPackAnotherName */

size_t PKIUnpackAnotherName(
    PKICONTEXT *ctx,
    PKIAnotherName **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackAnotherNameInternal(ctx, asnstruct, buf, buflen,
                      PKIID_AnotherName, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

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

PKIAttributeTypeAndValue *PKINewAttributeTypeAndValue(
    PKICONTEXT *ctx)
{
    PKIAttributeTypeAndValue *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewAttributeTypeAndValue */

void PKIFreeAttributeTypeAndValue(
    PKICONTEXT *ctx,
    PKIAttributeTypeAndValue *f)
{
    if (ctx == NULL)
        return;

    PKIDropInPlaceAttributeTypeAndValue(ctx, f);
    if (f != NULL)
        PKIFree(ctx->memMgr, f);

} /* PKIFreeAttributeTypeAndValue */

size_t PKISizeofAttributeTypeAndValue(
    PKICONTEXT *ctx,
    PKIAttributeTypeAndValue *asnstruct,
    int outerSizeFlag)
{
    (void)ctx; /* for future use */

    return(PKISizeofAttributeTypeAndValueInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofAttributeTypeAndValue */

size_t PKIPackAttributeTypeAndValue(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIAttributeTypeAndValue *asnstruct,
    int *erret )
{
    return(PKIPackAttributeTypeAndValueInternal(ctx, buf, buflen, asnstruct, PKIID_AttributeTypeAndValue, erret));
} /* PKIPackAttributeTypeAndValue */

size_t PKIUnpackAttributeTypeAndValue(
    PKICONTEXT *ctx,
    PKIAttributeTypeAndValue **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackAttributeTypeAndValueInternal(ctx, asnstruct, buf, buflen,
                      PKIID_AttributeTypeAndValue, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

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

PKIBasicConstraints *PKINewBasicConstraints(
    PKICONTEXT *ctx)
{
    PKIBasicConstraints *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewBasicConstraints */

void PKIFreeBasicConstraints(
    PKICONTEXT *ctx,
    PKIBasicConstraints *f)
{
    if (ctx == NULL)
        return;

    PKIDropInPlaceBasicConstraints(ctx, f);
    if (f != NULL)
        PKIFree(ctx->memMgr, f);

} /* PKIFreeBasicConstraints */

size_t PKISizeofBasicConstraints(
    PKICONTEXT *ctx,
    PKIBasicConstraints *asnstruct,
    int outerSizeFlag)
{
    (void)ctx; /* for future use */

    return(PKISizeofBasicConstraintsInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofBasicConstraints */

size_t PKIPackBasicConstraints(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIBasicConstraints *asnstruct,
    int *erret )
{
    return(PKIPackBasicConstraintsInternal(ctx, buf, buflen, asnstruct, PKIID_BasicConstraints, erret));
} /* PKIPackBasicConstraints */

size_t PKIUnpackBasicConstraints(
    PKICONTEXT *ctx,
    PKIBasicConstraints **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackBasicConstraintsInternal(ctx, asnstruct, buf, buflen,
                      PKIID_BasicConstraints, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for DirectoryString
 ******************************************************************/

PKIDirectoryString *PKINewDirectoryString(
    PKICONTEXT *ctx)
{
    PKIDirectoryString *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewDirectoryString */

void PKIFreeDirectoryString(
    PKICONTEXT *ctx,
    PKIDirectoryString *f)
{
    if (ctx == NULL)
        return;

    PKIDropInPlaceDirectoryString(ctx, f);
    if (f != NULL)
        PKIFree(ctx->memMgr, f);

} /* PKIFreeDirectoryString */

size_t PKISizeofDirectoryString(
    PKICONTEXT *ctx,
    PKIDirectoryString *asnstruct,
    int outerSizeFlag)
{
    (void)ctx; /* for future use */

    return(PKISizeofDirectoryStringInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofDirectoryString */

size_t PKIPackDirectoryString(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIDirectoryString *asnstruct,
    int *erret )
{
    return(PKIPackDirectoryStringInternal(ctx, buf, buflen, asnstruct, PKIID_DirectoryString, erret));