pkcs12_asn.c

vc环境下的pgp源码

/*******************************************************************
 *
 * This file was generated by TIS/ASN1COMP Ver. 4.1, an ASN.1 compiler.
 * TIS/ASN1COMP is Copyright (c) 1998, TIS Labs at Network Associates, Inc.
 *
 * This file was AUTOMATICALLY GENERATED on Fri Apr  9 20:37:30 1999
 *
 ******************************************************************/


#include <string.h>

#include "pkcs12_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.
 *
 ******************************************************************/


/******************************************************************
 * Routines for AuthenticatedSafes
 ******************************************************************/

PKIAuthenticatedSafes *PKINewAuthenticatedSafes(
    PKICONTEXT *ctx)
{
    PKIAuthenticatedSafes *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewAuthenticatedSafes */

void PKIFreeAuthenticatedSafes(
    PKICONTEXT *ctx,
    PKIAuthenticatedSafes *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeAuthenticatedSafes */

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

    return(PKISizeofAuthenticatedSafesInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofAuthenticatedSafes */

size_t PKIPackAuthenticatedSafes(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIAuthenticatedSafes *asnstruct,
    int *erret )
{
    return(PKIPackAuthenticatedSafesInternal(ctx, buf, buflen, asnstruct, PKIID_AuthenticatedSafes, erret));
} /* PKIPackAuthenticatedSafes */

size_t PKIUnpackAuthenticatedSafes(
    PKICONTEXT *ctx,
    PKIAuthenticatedSafes **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackAuthenticatedSafesInternal(ctx, asnstruct, buf, buflen,
                      PKIID_AuthenticatedSafes, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for CRLBag
 ******************************************************************/

PKICRLBag *PKINewCRLBag(
    PKICONTEXT *ctx)
{
    PKICRLBag *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewCRLBag */

void PKIFreeCRLBag(
    PKICONTEXT *ctx,
    PKICRLBag *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeCRLBag */

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

    return(PKISizeofCRLBagInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofCRLBag */

size_t PKIPackCRLBag(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKICRLBag *asnstruct,
    int *erret )
{
    return(PKIPackCRLBagInternal(ctx, buf, buflen, asnstruct, PKIID_CRLBag, erret));
} /* PKIPackCRLBag */

size_t PKIUnpackCRLBag(
    PKICONTEXT *ctx,
    PKICRLBag **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackCRLBagInternal(ctx, asnstruct, buf, buflen,
                      PKIID_CRLBag, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for CertBag
 ******************************************************************/

PKICertBag *PKINewCertBag(
    PKICONTEXT *ctx)
{
    PKICertBag *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewCertBag */

void PKIFreeCertBag(
    PKICONTEXT *ctx,
    PKICertBag *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeCertBag */

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

    return(PKISizeofCertBagInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofCertBag */

size_t PKIPackCertBag(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKICertBag *asnstruct,
    int *erret )
{
    return(PKIPackCertBagInternal(ctx, buf, buflen, asnstruct, PKIID_CertBag, erret));
} /* PKIPackCertBag */

size_t PKIUnpackCertBag(
    PKICONTEXT *ctx,
    PKICertBag **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackCertBagInternal(ctx, asnstruct, buf, buflen,
                      PKIID_CertBag, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for MacData
 ******************************************************************/

PKIMacData *PKINewMacData(
    PKICONTEXT *ctx)
{
    PKIMacData *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewMacData */

void PKIFreeMacData(
    PKICONTEXT *ctx,
    PKIMacData *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeMacData */

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

    return(PKISizeofMacDataInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofMacData */

size_t PKIPackMacData(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIMacData *asnstruct,
    int *erret )
{
    return(PKIPackMacDataInternal(ctx, buf, buflen, asnstruct, PKIID_MacData, erret));
} /* PKIPackMacData */

size_t PKIUnpackMacData(
    PKICONTEXT *ctx,
    PKIMacData **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackMacDataInternal(ctx, asnstruct, buf, buflen,
                      PKIID_MacData, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for SafeBag
 ******************************************************************/

PKISafeBag *PKINewSafeBag(
    PKICONTEXT *ctx)
{
    PKISafeBag *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewSafeBag */