pgpx509cert_asn.c

vc环境下的pgp源码

void pgpasn_FreeContentInfo(
    PGPASN_CONTEXT *ctx,
    PGPASN_ContentInfo *f)
{
    if (ctx == NULL)
        return;

    pgpasn_DropInPlaceContentInfo(ctx, f);
    if (f != NULL)
        PGPASN_Free(ctx->memMgr, f);

} /* pgpasn_FreeContentInfo */

size_t pgpasn_SizeofContentInfo(
    PGPASN_CONTEXT *ctx,
    PGPASN_ContentInfo *asnstruct,
    int outerSizeFlag)
{
    (void)ctx; /* for future use */

    return(pgpasn_SizeofContentInfoInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofContentInfo */

size_t pgpasn_PackContentInfo(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_ContentInfo *asnstruct,
    int *erret )
{
    return(pgpasn_PackContentInfoInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_ContentInfo, erret));
} /* pgpasn_PackContentInfo */

size_t pgpasn_UnpackContentInfo(
    PGPASN_CONTEXT *ctx,
    PGPASN_ContentInfo **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackContentInfoInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_ContentInfo, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

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

PGPASN_DirectoryString *pgpasn_NewDirectoryString(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_DirectoryString *f;

    if (ctx == NULL)
        return NULL;

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

} /* pgpasn_NewDirectoryString */

void pgpasn_FreeDirectoryString(
    PGPASN_CONTEXT *ctx,
    PGPASN_DirectoryString *f)
{
    if (ctx == NULL)
        return;

    pgpasn_DropInPlaceDirectoryString(ctx, f);
    if (f != NULL)
        PGPASN_Free(ctx->memMgr, f);

} /* pgpasn_FreeDirectoryString */

size_t pgpasn_SizeofDirectoryString(
    PGPASN_CONTEXT *ctx,
    PGPASN_DirectoryString *asnstruct,
    int outerSizeFlag)
{
    (void)ctx; /* for future use */

    return(pgpasn_SizeofDirectoryStringInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofDirectoryString */

size_t pgpasn_PackDirectoryString(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_DirectoryString *asnstruct,
    int *erret )
{
    return(pgpasn_PackDirectoryStringInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_DirectoryString, erret));
} /* pgpasn_PackDirectoryString */

size_t pgpasn_UnpackDirectoryString(
    PGPASN_CONTEXT *ctx,
    PGPASN_DirectoryString **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackDirectoryStringInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_DirectoryString, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for DssParms
 ******************************************************************/

PGPASN_DssParms *pgpasn_NewDssParms(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_DssParms *f;

    if (ctx == NULL)
        return NULL;

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

} /* pgpasn_NewDssParms */

void pgpasn_FreeDssParms(
    PGPASN_CONTEXT *ctx,
    PGPASN_DssParms *f)
{
    if (ctx == NULL)
        return;

    pgpasn_DropInPlaceDssParms(ctx, f);
    if (f != NULL)
        PGPASN_Free(ctx->memMgr, f);

} /* pgpasn_FreeDssParms */

size_t pgpasn_SizeofDssParms(
    PGPASN_CONTEXT *ctx,
    PGPASN_DssParms *asnstruct,
    int outerSizeFlag)
{
    (void)ctx; /* for future use */

    return(pgpasn_SizeofDssParmsInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofDssParms */

size_t pgpasn_PackDssParms(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_DssParms *asnstruct,
    int *erret )
{
    return(pgpasn_PackDssParmsInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_DssParms, erret));
} /* pgpasn_PackDssParms */

size_t pgpasn_UnpackDssParms(
    PGPASN_CONTEXT *ctx,
    PGPASN_DssParms **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackDssParmsInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_DssParms, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for DssSigValue
 ******************************************************************/

PGPASN_DssSigValue *pgpasn_NewDssSigValue(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_DssSigValue *f;

    if (ctx == NULL)
        return NULL;

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

} /* pgpasn_NewDssSigValue */

void pgpasn_FreeDssSigValue(
    PGPASN_CONTEXT *ctx,
    PGPASN_DssSigValue *f)
{
    if (ctx == NULL)
        return;

    pgpasn_DropInPlaceDssSigValue(ctx, f);
    if (f != NULL)
        PGPASN_Free(ctx->memMgr, f);

} /* pgpasn_FreeDssSigValue */

size_t pgpasn_SizeofDssSigValue(
    PGPASN_CONTEXT *ctx,
    PGPASN_DssSigValue *asnstruct,
    int outerSizeFlag)
{
    (void)ctx; /* for future use */

    return(pgpasn_SizeofDssSigValueInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofDssSigValue */

size_t pgpasn_PackDssSigValue(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_DssSigValue *asnstruct,
    int *erret )
{
    return(pgpasn_PackDssSigValueInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_DssSigValue, erret));
} /* pgpasn_PackDssSigValue */

size_t pgpasn_UnpackDssSigValue(
    PGPASN_CONTEXT *ctx,
    PGPASN_DssSigValue **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackDssSigValueInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_DssSigValue, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for ELGParms
 ******************************************************************/

PGPASN_ELGParms *pgpasn_NewELGParms(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_ELGParms *f;

    if (ctx == NULL)
        return NULL;

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

} /* pgpasn_NewELGParms */

void pgpasn_FreeELGParms(
    PGPASN_CONTEXT *ctx,
    PGPASN_ELGParms *f)
{
    if (ctx == NULL)
        return;

    pgpasn_DropInPlaceELGParms(ctx, f);
    if (f != NULL)
        PGPASN_Free(ctx->memMgr, f);

} /* pgpasn_FreeELGParms */

size_t pgpasn_SizeofELGParms(
    PGPASN_CONTEXT *ctx,
    PGPASN_ELGParms *asnstruct,
    int outerSizeFlag)
{
    (void)ctx; /* for future use */

    return(pgpasn_SizeofELGParmsInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofELGParms */

size_t pgpasn_PackELGParms(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_ELGParms *asnstruct,
    int *erret )
{
    return(pgpasn_PackELGParmsInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_ELGParms, erret));
} /* pgpasn_PackELGParms */

size_t pgpasn_UnpackELGParms(
    PGPASN_CONTEXT *ctx,
    PGPASN_ELGParms **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackELGParmsInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_ELGParms, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

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

PGPASN_Extension *pgpasn_NewExtension(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_Extension *f;

    if (ctx == NULL)
        return NULL;

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

} /* pgpasn_NewExtension */

void pgpasn_FreeExtension(
    PGPASN_CONTEXT *ctx,
    PGPASN_Extension *f)
{
    if (ctx == NULL)
        return;

    pgpasn_DropInPlaceExtension(ctx, f);
    if (f != NULL)
        PGPASN_Free(ctx->memMgr, f);

} /* pgpasn_FreeExtension */

size_t pgpasn_SizeofExtension(
    PGPASN_CONTEXT *ctx,
    PGPASN_Extension *asnstruct,
    int outerSizeFlag)
{
    (void)ctx; /* for future use */

    return(pgpasn_SizeofExtensionInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofExtension */

size_t pgpasn_PackExtension(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_Extension *asnstruct,
    int *erret )
{
    return(pgpasn_PackExtensionInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_Extension, erret));
} /* pgpasn_PackExtension */

size_t pgpasn_UnpackExtension(
    PGPASN_CONTEXT *ctx,
    PGPASN_Extension **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackExtensionInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_Extension, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for OtherName
 ******************************************************************/

PGPASN_OtherName *pgpasn_NewOtherName(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_OtherName *f;

    if (ctx == NULL)
        return NULL;

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

} /* pgpasn_NewOtherName */

void pgpasn_FreeOtherName(
    PGPASN_CONTEXT *ctx,
    PGPASN_OtherName *f)
{
    if (ctx == NULL)
        return;

    pgpasn_DropInPlaceOtherName(ctx, f);
    if (f != NULL)
        PGPASN_Free(ctx->memMgr, f);

} /* pgpasn_FreeOtherName */

size_t pgpasn_SizeofOtherName(
    PGPASN_CONTEXT *ctx,
    PGPASN_OtherName *asnstruct,
    int outerSizeFlag)
{
    (void)ctx; /* for future use */

    return(pgpasn_SizeofOtherNameInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofOtherName */

size_t pgpasn_PackOtherName(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_OtherName *asnstruct,
    int *erret )
{
    return(pgpasn_PackOtherNameInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_OtherName, erret));
} /* pgpasn_PackOtherName */

size_t pgpasn_UnpackOtherName(
    PGPASN_CONTEXT *ctx,
    PGPASN_OtherName **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackOtherNameInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_OtherName, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

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

PGPASN_RSAKey *pgpasn_NewRSAKey(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_RSAKey *f;

    if (ctx == NULL)
        return NULL;