cert_asn.c

vc环境下的pgp源码

{
    PKIPolicyQualifierInfo *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewPolicyQualifierInfo */

void PKIFreePolicyQualifierInfo(
    PKICONTEXT *ctx,
    PKIPolicyQualifierInfo *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreePolicyQualifierInfo */

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

    return(PKISizeofPolicyQualifierInfoInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofPolicyQualifierInfo */

size_t PKIPackPolicyQualifierInfo(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIPolicyQualifierInfo *asnstruct,
    int *erret )
{
    return(PKIPackPolicyQualifierInfoInternal(ctx, buf, buflen, asnstruct, PKIID_PolicyQualifierInfo, erret));
} /* PKIPackPolicyQualifierInfo */

size_t PKIUnpackPolicyQualifierInfo(
    PKICONTEXT *ctx,
    PKIPolicyQualifierInfo **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackPolicyQualifierInfoInternal(ctx, asnstruct, buf, buflen,
                      PKIID_PolicyQualifierInfo, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for PrivateKeyUsagePeriod
 ******************************************************************/

PKIPrivateKeyUsagePeriod *PKINewPrivateKeyUsagePeriod(
    PKICONTEXT *ctx)
{
    PKIPrivateKeyUsagePeriod *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewPrivateKeyUsagePeriod */

void PKIFreePrivateKeyUsagePeriod(
    PKICONTEXT *ctx,
    PKIPrivateKeyUsagePeriod *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreePrivateKeyUsagePeriod */

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

    return(PKISizeofPrivateKeyUsagePeriodInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofPrivateKeyUsagePeriod */

size_t PKIPackPrivateKeyUsagePeriod(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIPrivateKeyUsagePeriod *asnstruct,
    int *erret )
{
    return(PKIPackPrivateKeyUsagePeriodInternal(ctx, buf, buflen, asnstruct, PKIID_PrivateKeyUsagePeriod, erret));
} /* PKIPackPrivateKeyUsagePeriod */

size_t PKIUnpackPrivateKeyUsagePeriod(
    PKICONTEXT *ctx,
    PKIPrivateKeyUsagePeriod **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackPrivateKeyUsagePeriodInternal(ctx, asnstruct, buf, buflen,
                      PKIID_PrivateKeyUsagePeriod, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for RSAKey
 ******************************************************************/

PKIRSAKey *PKINewRSAKey(
    PKICONTEXT *ctx)
{
    PKIRSAKey *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewRSAKey */

void PKIFreeRSAKey(
    PKICONTEXT *ctx,
    PKIRSAKey *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeRSAKey */

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

    return(PKISizeofRSAKeyInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofRSAKey */

size_t PKIPackRSAKey(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIRSAKey *asnstruct,
    int *erret )
{
    return(PKIPackRSAKeyInternal(ctx, buf, buflen, asnstruct, PKIID_RSAKey, erret));
} /* PKIPackRSAKey */

size_t PKIUnpackRSAKey(
    PKICONTEXT *ctx,
    PKIRSAKey **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackRSAKeyInternal(ctx, asnstruct, buf, buflen,
                      PKIID_RSAKey, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for Time
 ******************************************************************/

PKITime *PKINewTime(
    PKICONTEXT *ctx)
{
    PKITime *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewTime */

void PKIFreeTime(
    PKICONTEXT *ctx,
    PKITime *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeTime */

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

    return(PKISizeofTimeInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofTime */

size_t PKIPackTime(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKITime *asnstruct,
    int *erret )
{
    return(PKIPackTimeInternal(ctx, buf, buflen, asnstruct, PKIID_Time, erret));
} /* PKIPackTime */

size_t PKIUnpackTime(
    PKICONTEXT *ctx,
    PKITime **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackTimeInternal(ctx, asnstruct, buf, buflen,
                      PKIID_Time, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for ValidationParms
 ******************************************************************/

PKIValidationParms *PKINewValidationParms(
    PKICONTEXT *ctx)
{
    PKIValidationParms *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewValidationParms */

void PKIFreeValidationParms(
    PKICONTEXT *ctx,
    PKIValidationParms *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeValidationParms */

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

    return(PKISizeofValidationParmsInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofValidationParms */

size_t PKIPackValidationParms(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIValidationParms *asnstruct,
    int *erret )
{
    return(PKIPackValidationParmsInternal(ctx, buf, buflen, asnstruct, PKIID_ValidationParms, erret));
} /* PKIPackValidationParms */

size_t PKIUnpackValidationParms(
    PKICONTEXT *ctx,
    PKIValidationParms **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackValidationParmsInternal(ctx, asnstruct, buf, buflen,
                      PKIID_ValidationParms, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for values_SET_OF
 ******************************************************************/

PKIvalues_SET_OF *PKINewvalues_SET_OF(
    PKICONTEXT *ctx)
{
    PKIvalues_SET_OF *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewvalues_SET_OF */

void PKIFreevalues_SET_OF(
    PKICONTEXT *ctx,
    PKIvalues_SET_OF *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreevalues_SET_OF */

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

    return(PKISizeofvalues_SET_OFInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofvalues_SET_OF */

size_t PKIPackvalues_SET_OF(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIvalues_SET_OF *asnstruct,
    int *erret )
{
    return(PKIPackvalues_SET_OFInternal(ctx, buf, buflen, asnstruct, PKIID_values_SET_OF, erret));
} /* PKIPackvalues_SET_OF */

size_t PKIUnpackvalues_SET_OF(
    PKICONTEXT *ctx,
    PKIvalues_SET_OF **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackvalues_SET_OFInternal(ctx, asnstruct, buf, buflen,
                      PKIID_values_SET_OF, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for Attribute
 ******************************************************************/

PKIAttribute *PKINewAttribute(
    PKICONTEXT *ctx)
{
    PKIAttribute *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewAttribute */

void PKIFreeAttribute(
    PKICONTEXT *ctx,
    PKIAttribute *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeAttribute */

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

    return(PKISizeofAttributeInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofAttribute */

size_t PKIPackAttribute(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIAttribute *asnstruct,
    int *erret )
{
    return(PKIPackAttributeInternal(ctx, buf, buflen, asnstruct, PKIID_Attribute, erret));
} /* PKIPackAttribute */

size_t PKIUnpackAttribute(
    PKICONTEXT *ctx,
    PKIAttribute **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackAttributeInternal(ctx, asnstruct, buf, buflen,
                      PKIID_Attribute, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for DomainParameters
 ******************************************************************/

PKIDomainParameters *PKINewDomainParameters(
    PKICONTEXT *ctx)
{
    PKIDomainParameters *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewDomainParameters */

void PKIFreeDomainParameters(
    PKICONTEXT *ctx,
    PKIDomainParameters *f)
{
    if (ctx == NULL)
        return;

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