cert_asn.c

vc环境下的pgp源码

} /* PKIPackDirectoryString */

size_t PKIUnpackDirectoryString(
    PKICONTEXT *ctx,
    PKIDirectoryString **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackDirectoryStringInternal(ctx, asnstruct, buf, buflen,
                      PKIID_DirectoryString, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for DisplayText
 ******************************************************************/

PKIDisplayText *PKINewDisplayText(
    PKICONTEXT *ctx)
{
    PKIDisplayText *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewDisplayText */

void PKIFreeDisplayText(
    PKICONTEXT *ctx,
    PKIDisplayText *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeDisplayText */

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

    return(PKISizeofDisplayTextInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofDisplayText */

size_t PKIPackDisplayText(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIDisplayText *asnstruct,
    int *erret )
{
    return(PKIPackDisplayTextInternal(ctx, buf, buflen, asnstruct, PKIID_DisplayText, erret));
} /* PKIPackDisplayText */

size_t PKIUnpackDisplayText(
    PKICONTEXT *ctx,
    PKIDisplayText **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackDisplayTextInternal(ctx, asnstruct, buf, buflen,
                      PKIID_DisplayText, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for Dss_Parms
 ******************************************************************/

PKIDss_Parms *PKINewDss_Parms(
    PKICONTEXT *ctx)
{
    PKIDss_Parms *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewDss_Parms */

void PKIFreeDss_Parms(
    PKICONTEXT *ctx,
    PKIDss_Parms *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeDss_Parms */

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

    return(PKISizeofDss_ParmsInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofDss_Parms */

size_t PKIPackDss_Parms(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIDss_Parms *asnstruct,
    int *erret )
{
    return(PKIPackDss_ParmsInternal(ctx, buf, buflen, asnstruct, PKIID_Dss_Parms, erret));
} /* PKIPackDss_Parms */

size_t PKIUnpackDss_Parms(
    PKICONTEXT *ctx,
    PKIDss_Parms **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackDss_ParmsInternal(ctx, asnstruct, buf, buflen,
                      PKIID_Dss_Parms, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for Dss_Sig_Value
 ******************************************************************/

PKIDss_Sig_Value *PKINewDss_Sig_Value(
    PKICONTEXT *ctx)
{
    PKIDss_Sig_Value *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewDss_Sig_Value */

void PKIFreeDss_Sig_Value(
    PKICONTEXT *ctx,
    PKIDss_Sig_Value *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeDss_Sig_Value */

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

    return(PKISizeofDss_Sig_ValueInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofDss_Sig_Value */

size_t PKIPackDss_Sig_Value(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIDss_Sig_Value *asnstruct,
    int *erret )
{
    return(PKIPackDss_Sig_ValueInternal(ctx, buf, buflen, asnstruct, PKIID_Dss_Sig_Value, erret));
} /* PKIPackDss_Sig_Value */

size_t PKIUnpackDss_Sig_Value(
    PKICONTEXT *ctx,
    PKIDss_Sig_Value **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackDss_Sig_ValueInternal(ctx, asnstruct, buf, buflen,
                      PKIID_Dss_Sig_Value, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for ExtKeyUsageSyntax
 ******************************************************************/

PKIExtKeyUsageSyntax *PKINewExtKeyUsageSyntax(
    PKICONTEXT *ctx)
{
    PKIExtKeyUsageSyntax *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewExtKeyUsageSyntax */

void PKIFreeExtKeyUsageSyntax(
    PKICONTEXT *ctx,
    PKIExtKeyUsageSyntax *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeExtKeyUsageSyntax */

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

    return(PKISizeofExtKeyUsageSyntaxInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofExtKeyUsageSyntax */

size_t PKIPackExtKeyUsageSyntax(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIExtKeyUsageSyntax *asnstruct,
    int *erret )
{
    return(PKIPackExtKeyUsageSyntaxInternal(ctx, buf, buflen, asnstruct, PKIID_ExtKeyUsageSyntax, erret));
} /* PKIPackExtKeyUsageSyntax */

size_t PKIUnpackExtKeyUsageSyntax(
    PKICONTEXT *ctx,
    PKIExtKeyUsageSyntax **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackExtKeyUsageSyntaxInternal(ctx, asnstruct, buf, buflen,
                      PKIID_ExtKeyUsageSyntax, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for Extension
 ******************************************************************/

PKIExtension *PKINewExtension(
    PKICONTEXT *ctx)
{
    PKIExtension *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewExtension */

void PKIFreeExtension(
    PKICONTEXT *ctx,
    PKIExtension *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeExtension */

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

    return(PKISizeofExtensionInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofExtension */

size_t PKIPackExtension(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIExtension *asnstruct,
    int *erret )
{
    return(PKIPackExtensionInternal(ctx, buf, buflen, asnstruct, PKIID_Extension, erret));
} /* PKIPackExtension */

size_t PKIUnpackExtension(
    PKICONTEXT *ctx,
    PKIExtension **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackExtensionInternal(ctx, asnstruct, buf, buflen,
                      PKIID_Extension, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for PolicyConstraints
 ******************************************************************/

PKIPolicyConstraints *PKINewPolicyConstraints(
    PKICONTEXT *ctx)
{
    PKIPolicyConstraints *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewPolicyConstraints */

void PKIFreePolicyConstraints(
    PKICONTEXT *ctx,
    PKIPolicyConstraints *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreePolicyConstraints */

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

    return(PKISizeofPolicyConstraintsInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofPolicyConstraints */

size_t PKIPackPolicyConstraints(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIPolicyConstraints *asnstruct,
    int *erret )
{
    return(PKIPackPolicyConstraintsInternal(ctx, buf, buflen, asnstruct, PKIID_PolicyConstraints, erret));
} /* PKIPackPolicyConstraints */

size_t PKIUnpackPolicyConstraints(
    PKICONTEXT *ctx,
    PKIPolicyConstraints **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackPolicyConstraintsInternal(ctx, asnstruct, buf, buflen,
                      PKIID_PolicyConstraints, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for PolicyMappings_SEQUENCE
 ******************************************************************/

PKIPolicyMappings_SEQUENCE *PKINewPolicyMappings_SEQUENCE(
    PKICONTEXT *ctx)
{
    PKIPolicyMappings_SEQUENCE *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewPolicyMappings_SEQUENCE */

void PKIFreePolicyMappings_SEQUENCE(
    PKICONTEXT *ctx,
    PKIPolicyMappings_SEQUENCE *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreePolicyMappings_SEQUENCE */

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

    return(PKISizeofPolicyMappings_SEQUENCEInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofPolicyMappings_SEQUENCE */

size_t PKIPackPolicyMappings_SEQUENCE(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIPolicyMappings_SEQUENCE *asnstruct,
    int *erret )
{
    return(PKIPackPolicyMappings_SEQUENCEInternal(ctx, buf, buflen, asnstruct, PKIID_PolicyMappings_SEQUENCE, erret));
} /* PKIPackPolicyMappings_SEQUENCE */

size_t PKIUnpackPolicyMappings_SEQUENCE(
    PKICONTEXT *ctx,
    PKIPolicyMappings_SEQUENCE **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackPolicyMappings_SEQUENCEInternal(ctx, asnstruct, buf, buflen,
                      PKIID_PolicyMappings_SEQUENCE, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for PolicyQualifierInfo
 ******************************************************************/

PKIPolicyQualifierInfo *PKINewPolicyQualifierInfo(
    PKICONTEXT *ctx)