cert_asn.c

PGP—Pretty Good Privacy

size_t PKIUnpackValidity(
    PKICONTEXT *ctx,
    PKIValidity **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackValidityInternal(ctx, asnstruct, buf, buflen,
                      PKIID_Validity, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

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

PKIXCertificate *PKINewXCertificate(
    PKICONTEXT *ctx)
{
    PKIXCertificate *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewXCertificate */

void PKIFreeXCertificate(
    PKICONTEXT *ctx,
    PKIXCertificate *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeXCertificate */

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

    return(PKISizeofXCertificateInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofXCertificate */

size_t PKIPackXCertificate(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIXCertificate *asnstruct,
    int *erret )
{
    return(PKIPackXCertificateInternal(ctx, buf, buflen, asnstruct, PKIID_XCertificate, erret));
} /* PKIPackXCertificate */

size_t PKIUnpackXCertificate(
    PKICONTEXT *ctx,
    PKIXCertificate **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackXCertificateInternal(ctx, asnstruct, buf, buflen,
                      PKIID_XCertificate, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for policyQualifiers_SEQ_OF
 ******************************************************************/

PKIpolicyQualifiers_SEQ_OF *PKINewpolicyQualifiers_SEQ_OF(
    PKICONTEXT *ctx)
{
    PKIpolicyQualifiers_SEQ_OF *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewpolicyQualifiers_SEQ_OF */

void PKIFreepolicyQualifiers_SEQ_OF(
    PKICONTEXT *ctx,
    PKIpolicyQualifiers_SEQ_OF *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreepolicyQualifiers_SEQ_OF */

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

    return(PKISizeofpolicyQualifiers_SEQ_OFInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofpolicyQualifiers_SEQ_OF */

size_t PKIPackpolicyQualifiers_SEQ_OF(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIpolicyQualifiers_SEQ_OF *asnstruct,
    int *erret )
{
    return(PKIPackpolicyQualifiers_SEQ_OFInternal(ctx, buf, buflen, asnstruct, PKIID_policyQualifiers_SEQ_OF, erret));
} /* PKIPackpolicyQualifiers_SEQ_OF */

size_t PKIUnpackpolicyQualifiers_SEQ_OF(
    PKICONTEXT *ctx,
    PKIpolicyQualifiers_SEQ_OF **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackpolicyQualifiers_SEQ_OFInternal(ctx, asnstruct, buf, buflen,
                      PKIID_policyQualifiers_SEQ_OF, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

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

PKIAttributes *PKINewAttributes(
    PKICONTEXT *ctx)
{
    PKIAttributes *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewAttributes */

void PKIFreeAttributes(
    PKICONTEXT *ctx,
    PKIAttributes *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeAttributes */

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

    return(PKISizeofAttributesInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofAttributes */

size_t PKIPackAttributes(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIAttributes *asnstruct,
    int *erret )
{
    return(PKIPackAttributesInternal(ctx, buf, buflen, asnstruct, PKIID_Attributes, erret));
} /* PKIPackAttributes */

size_t PKIUnpackAttributes(
    PKICONTEXT *ctx,
    PKIAttributes **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackAttributesInternal(ctx, asnstruct, buf, buflen,
                      PKIID_Attributes, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for PolicyInformation
 ******************************************************************/

PKIPolicyInformation *PKINewPolicyInformation(
    PKICONTEXT *ctx)
{
    PKIPolicyInformation *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewPolicyInformation */

void PKIFreePolicyInformation(
    PKICONTEXT *ctx,
    PKIPolicyInformation *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreePolicyInformation */

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

    return(PKISizeofPolicyInformationInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofPolicyInformation */

size_t PKIPackPolicyInformation(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIPolicyInformation *asnstruct,
    int *erret )
{
    return(PKIPackPolicyInformationInternal(ctx, buf, buflen, asnstruct, PKIID_PolicyInformation, erret));
} /* PKIPackPolicyInformation */

size_t PKIUnpackPolicyInformation(
    PKICONTEXT *ctx,
    PKIPolicyInformation **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackPolicyInformationInternal(ctx, asnstruct, buf, buflen,
                      PKIID_PolicyInformation, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

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

PKIRDNSequence *PKINewRDNSequence(
    PKICONTEXT *ctx)
{
    PKIRDNSequence *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewRDNSequence */

void PKIFreeRDNSequence(
    PKICONTEXT *ctx,
    PKIRDNSequence *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeRDNSequence */

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

    return(PKISizeofRDNSequenceInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofRDNSequence */

size_t PKIPackRDNSequence(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIRDNSequence *asnstruct,
    int *erret )
{
    return(PKIPackRDNSequenceInternal(ctx, buf, buflen, asnstruct, PKIID_RDNSequence, erret));
} /* PKIPackRDNSequence */

size_t PKIUnpackRDNSequence(
    PKICONTEXT *ctx,
    PKIRDNSequence **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackRDNSequenceInternal(ctx, asnstruct, buf, buflen,
                      PKIID_RDNSequence, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for RevokedCertificate
 ******************************************************************/

PKIRevokedCertificate *PKINewRevokedCertificate(
    PKICONTEXT *ctx)
{
    PKIRevokedCertificate *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewRevokedCertificate */

void PKIFreeRevokedCertificate(
    PKICONTEXT *ctx,
    PKIRevokedCertificate *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeRevokedCertificate */

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

    return(PKISizeofRevokedCertificateInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofRevokedCertificate */

size_t PKIPackRevokedCertificate(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIRevokedCertificate *asnstruct,
    int *erret )
{
    return(PKIPackRevokedCertificateInternal(ctx, buf, buflen, asnstruct, PKIID_RevokedCertificate, erret));
} /* PKIPackRevokedCertificate */

size_t PKIUnpackRevokedCertificate(
    PKICONTEXT *ctx,
    PKIRevokedCertificate **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackRevokedCertificateInternal(ctx, asnstruct, buf, buflen,
                      PKIID_RevokedCertificate, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for SubjectDirectoryAttributes
 ******************************************************************/

PKISubjectDirectoryAttributes *PKINewSubjectDirectoryAttributes(
    PKICONTEXT *ctx)
{
    PKISubjectDirectoryAttributes *f;

    if (ctx == NULL)
        return NULL;

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

} /* PKINewSubjectDirectoryAttributes */

void PKIFreeSubjectDirectoryAttributes(
    PKICONTEXT *ctx,
    PKISubjectDirectoryAttributes *f)
{
    if (ctx == NULL)
        return;

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

} /* PKIFreeSubjectDirectoryAttributes */

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

    return(PKISizeofSubjectDirectoryAttributesInternal(asnstruct, outerSizeFlag, PKIFALSE));
} /* PKISizeofSubjectDirectoryAttributes */

size_t PKIPackSubjectDirectoryAttributes(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKISubjectDirectoryAttributes *asnstruct,
    int *erret )
{
    return(PKIPackSubjectDirectoryAttributesInternal(ctx, buf, buflen, asnstruct, PKIID_SubjectDirectoryAttributes, erret));
} /* PKIPackSubjectDirectoryAttributes */

size_t PKIUnpackSubjectDirectoryAttributes(
    PKICONTEXT *ctx,
    PKISubjectDirectoryAttributes **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    int *erret)
{
    size_t bytesused;
    bytesused=PKIUnpackSubjectDirectoryAttributesInternal(ctx, asnstruct, buf, buflen,
                      PKIID_SubjectDirectoryAttributes, erret);
    if(*erret==0 && bytesused==0)
        PKIERR(PKIErrUnpackUnderrun);
    return bytesused;
}

/******************************************************************
 * Routines for UserNotice
 ******************************************************************/

PKIUserNotice *PKINewUserNotice(
    PKICONTEXT *ctx)
{
    PKIUserNotic