pkcs12_asn.c

vc环境下的pgp源码

void PKIFreeSafeBag(
    PKICONTEXT *ctx,
    PKISafeBag *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeSafeBag */

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

    return(PKISizeofSafeBagInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofSafeBag */

size_t PKIPackSafeBag(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKISafeBag *asnstruct,
    int *erret )
{
    return(PKIPackSafeBagInternal(ctx, buf, buflen, asnstruct, PKIID_SafeBag, erret));
} /* PKIPackSafeBag */

size_t PKIUnpackSafeBag(
    PKICONTEXT *ctx,
    PKISafeBag **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackSafeBagInternal(ctx, asnstruct, buf, buflen,
                      PKIID_SafeBag, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for SecretBag
 ******************************************************************/

PKISecretBag *PKINewSecretBag(
    PKICONTEXT *ctx)
{
    PKISecretBag *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewSecretBag */

void PKIFreeSecretBag(
    PKICONTEXT *ctx,
    PKISecretBag *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeSecretBag */

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

    return(PKISizeofSecretBagInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofSecretBag */

size_t PKIPackSecretBag(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKISecretBag *asnstruct,
    int *erret )
{
    return(PKIPackSecretBagInternal(ctx, buf, buflen, asnstruct, PKIID_SecretBag, erret));
} /* PKIPackSecretBag */

size_t PKIUnpackSecretBag(
    PKICONTEXT *ctx,
    PKISecretBag **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackSecretBagInternal(ctx, asnstruct, buf, buflen,
                      PKIID_SecretBag, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for pkcs_12PbeParams
 ******************************************************************/

PKIpkcs_12PbeParams *PKINewpkcs_12PbeParams(
    PKICONTEXT *ctx)
{
    PKIpkcs_12PbeParams *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewpkcs_12PbeParams */

void PKIFreepkcs_12PbeParams(
    PKICONTEXT *ctx,
    PKIpkcs_12PbeParams *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreepkcs_12PbeParams */

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

    return(PKISizeofpkcs_12PbeParamsInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofpkcs_12PbeParams */

size_t PKIPackpkcs_12PbeParams(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIpkcs_12PbeParams *asnstruct,
    int *erret )
{
    return(PKIPackpkcs_12PbeParamsInternal(ctx, buf, buflen, asnstruct, PKIID_pkcs_12PbeParams, erret));
} /* PKIPackpkcs_12PbeParams */

size_t PKIUnpackpkcs_12PbeParams(
    PKICONTEXT *ctx,
    PKIpkcs_12PbeParams **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackpkcs_12PbeParamsInternal(ctx, asnstruct, buf, buflen,
                      PKIID_pkcs_12PbeParams, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for PFX
 ******************************************************************/

PKIPFX *PKINewPFX(
    PKICONTEXT *ctx)
{
    PKIPFX *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewPFX */

void PKIFreePFX(
    PKICONTEXT *ctx,
    PKIPFX *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreePFX */

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

    return(PKISizeofPFXInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofPFX */

size_t PKIPackPFX(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIPFX *asnstruct,
    int *erret )
{
    return(PKIPackPFXInternal(ctx, buf, buflen, asnstruct, PKIID_PFX, erret));
} /* PKIPackPFX */

size_t PKIUnpackPFX(
    PKICONTEXT *ctx,
    PKIPFX **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackPFXInternal(ctx, asnstruct, buf, buflen,
                      PKIID_PFX, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for SafeContents
 ******************************************************************/

PKISafeContents *PKINewSafeContents(
    PKICONTEXT *ctx)
{
    PKISafeContents *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewSafeContents */

void PKIFreeSafeContents(
    PKICONTEXT *ctx,
    PKISafeContents *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeSafeContents */

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

    return(PKISizeofSafeContentsInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofSafeContents */

size_t PKIPackSafeContents(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKISafeContents *asnstruct,
    int *erret )
{
    return(PKIPackSafeContentsInternal(ctx, buf, buflen, asnstruct, PKIID_SafeContents, erret));
} /* PKIPackSafeContents */

size_t PKIUnpackSafeContents(
    PKICONTEXT *ctx,
    PKISafeContents **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackSafeContentsInternal(ctx, asnstruct, buf, buflen,
                      PKIID_SafeContents, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}