pgpx509cert_asn.c

vc环境下的pgp源码

PGPASN_SubjectPublicKeyInfo *pgpasn_NewSubjectPublicKeyInfo(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_SubjectPublicKeyInfo *f;

    if (ctx == NULL)
        return NULL;

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

} /* pgpasn_NewSubjectPublicKeyInfo */

void pgpasn_FreeSubjectPublicKeyInfo(
    PGPASN_CONTEXT *ctx,
    PGPASN_SubjectPublicKeyInfo *f)
{
    if (ctx == NULL)
        return;

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

} /* pgpasn_FreeSubjectPublicKeyInfo */

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

    return(pgpasn_SizeofSubjectPublicKeyInfoInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofSubjectPublicKeyInfo */

size_t pgpasn_PackSubjectPublicKeyInfo(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_SubjectPublicKeyInfo *asnstruct,
    int *erret )
{
    return(pgpasn_PackSubjectPublicKeyInfoInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_SubjectPublicKeyInfo, erret));
} /* pgpasn_PackSubjectPublicKeyInfo */

size_t pgpasn_UnpackSubjectPublicKeyInfo(
    PGPASN_CONTEXT *ctx,
    PGPASN_SubjectPublicKeyInfo **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackSubjectPublicKeyInfoInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_SubjectPublicKeyInfo, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for Validity
 ******************************************************************/

PGPASN_Validity *pgpasn_NewValidity(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_Validity *f;

    if (ctx == NULL)
        return NULL;

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

} /* pgpasn_NewValidity */

void pgpasn_FreeValidity(
    PGPASN_CONTEXT *ctx,
    PGPASN_Validity *f)
{
    if (ctx == NULL)
        return;

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

} /* pgpasn_FreeValidity */

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

    return(pgpasn_SizeofValidityInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofValidity */

size_t pgpasn_PackValidity(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_Validity *asnstruct,
    int *erret )
{
    return(pgpasn_PackValidityInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_Validity, erret));
} /* pgpasn_PackValidity */

size_t pgpasn_UnpackValidity(
    PGPASN_CONTEXT *ctx,
    PGPASN_Validity **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackValidityInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_Validity, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for XCertificate
 ******************************************************************/

PGPASN_XCertificate *pgpasn_NewXCertificate(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_XCertificate *f;

    if (ctx == NULL)
        return NULL;

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

} /* pgpasn_NewXCertificate */

void pgpasn_FreeXCertificate(
    PGPASN_CONTEXT *ctx,
    PGPASN_XCertificate *f)
{
    if (ctx == NULL)
        return;

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

} /* pgpasn_FreeXCertificate */

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

    return(pgpasn_SizeofXCertificateInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofXCertificate */

size_t pgpasn_PackXCertificate(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_XCertificate *asnstruct,
    int *erret )
{
    return(pgpasn_PackXCertificateInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_XCertificate, erret));
} /* pgpasn_PackXCertificate */

size_t pgpasn_UnpackXCertificate(
    PGPASN_CONTEXT *ctx,
    PGPASN_XCertificate **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackXCertificateInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_XCertificate, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for Attributes
 ******************************************************************/

PGPASN_Attributes *pgpasn_NewAttributes(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_Attributes *f;

    if (ctx == NULL)
        return NULL;

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

} /* pgpasn_NewAttributes */

void pgpasn_FreeAttributes(
    PGPASN_CONTEXT *ctx,
    PGPASN_Attributes *f)
{
    if (ctx == NULL)
        return;

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

} /* pgpasn_FreeAttributes */

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

    return(pgpasn_SizeofAttributesInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofAttributes */

size_t pgpasn_PackAttributes(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_Attributes *asnstruct,
    int *erret )
{
    return(pgpasn_PackAttributesInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_Attributes, erret));
} /* pgpasn_PackAttributes */

size_t pgpasn_UnpackAttributes(
    PGPASN_CONTEXT *ctx,
    PGPASN_Attributes **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackAttributesInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_Attributes, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for DigestAlgorithmIdentifiers
 ******************************************************************/

PGPASN_DigestAlgorithmIdentifiers *pgpasn_NewDigestAlgorithmIdentifiers(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_DigestAlgorithmIdentifiers *f;

    if (ctx == NULL)
        return NULL;

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

} /* pgpasn_NewDigestAlgorithmIdentifiers */

void pgpasn_FreeDigestAlgorithmIdentifiers(
    PGPASN_CONTEXT *ctx,
    PGPASN_DigestAlgorithmIdentifiers *f)
{
    if (ctx == NULL)
        return;

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

} /* pgpasn_FreeDigestAlgorithmIdentifiers */

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

    return(pgpasn_SizeofDigestAlgorithmIdentifiersInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofDigestAlgorithmIdentifiers */

size_t pgpasn_PackDigestAlgorithmIdentifiers(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_DigestAlgorithmIdentifiers *asnstruct,
    int *erret )
{
    return(pgpasn_PackDigestAlgorithmIdentifiersInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_DigestAlgorithmIdentifiers, erret));
} /* pgpasn_PackDigestAlgorithmIdentifiers */

size_t pgpasn_UnpackDigestAlgorithmIdentifiers(
    PGPASN_CONTEXT *ctx,
    PGPASN_DigestAlgorithmIdentifiers **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackDigestAlgorithmIdentifiersInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_DigestAlgorithmIdentifiers, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for PGPExtension
 ******************************************************************/

PGPASN_PGPExtension *pgpasn_NewPGPExtension(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_PGPExtension *f;

    if (ctx == NULL)
        return NULL;

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

} /* pgpasn_NewPGPExtension */

void pgpasn_FreePGPExtension(
    PGPASN_CONTEXT *ctx,
    PGPASN_PGPExtension *f)
{
    if (ctx == NULL)
        return;

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

} /* pgpasn_FreePGPExtension */

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

    return(pgpasn_SizeofPGPExtensionInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofPGPExtension */

size_t pgpasn_PackPGPExtension(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_PGPExtension *asnstruct,
    int *erret )
{
    return(pgpasn_PackPGPExtensionInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_PGPExtension, erret));
} /* pgpasn_PackPGPExtension */

size_t pgpasn_UnpackPGPExtension(
    PGPASN_CONTEXT *ctx,
    PGPASN_PGPExtension **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackPGPExtensionInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_PGPExtension, erret);
    if(*erret==0 && bytesused==0)
        PGPASN_ERR(kPGPASNError_ErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for RDNSequence
 ******************************************************************/

PGPASN_RDNSequence *pgpasn_NewRDNSequence(
    PGPASN_CONTEXT *ctx)
{
    PGPASN_RDNSequence *f;

    if (ctx == NULL)
        return NULL;

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

} /* pgpasn_NewRDNSequence */

void pgpasn_FreeRDNSequence(
    PGPASN_CONTEXT *ctx,
    PGPASN_RDNSequence *f)
{
    if (ctx == NULL)
        return;

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

} /* pgpasn_FreeRDNSequence */

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

    return(pgpasn_SizeofRDNSequenceInternal(asnstruct, outerSizeFlag, PGPASN_FALSE));
} /* pgpasn_SizeofRDNSequence */

size_t pgpasn_PackRDNSequence(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_RDNSequence *asnstruct,
    int *erret )
{
    return(pgpasn_PackRDNSequenceInternal(ctx, buf, buflen, asnstruct, PGPASN_ID_RDNSequence, erret));
} /* pgpasn_PackRDNSequence */

size_t pgpasn_UnpackRDNSequence(
    PGPASN_CONTEXT *ctx,
    PGPASN_RDNSequence **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=pgpasn_UnpackRDNSequenceInternal(ctx, asnstruct, buf, buflen,
                      PGPASN_ID_RDNSequence, erret);