CertReply.cpp

Go to the documentation of this file.

#include "PKIFSCVP.h"

#include "ASN1Helper.h"
#include "ToolkitUtils.h"
#include "SCVP.h"
#include "Buffer.h"
#include "PKIFTime.h"
#include "PKIFX509Extensions2.h"
#include "Certificate.h"


struct CPKIFCertReplyImpl 
{
    CPKIFCertReplyImpl()
    {
        m_this = NULL;
        m_certReply = NULL;
        m_scvpCertReply = NULL;
    }

    //function to process extensions
    void populateExtensionsVector();

    CPKIFTimePtr m_replyValTime;
    CPKIFTimePtr m_nextUpdate;
    CPKIFCertReferencePtr m_certRef;
    int m_replyStatus;
    CPKIFReplyCheckListPtr m_replyChecks;
    CPKIFReplyWantBackListPtr m_replyWantBacks;
    CPKIFOIDListPtr m_validationErros;
    
    CPKIFASNWrapper<CertReply>* m_certReply;
    std::vector<CPKIFX509ExtensionPtr> m_exts;

    //member for decoding
    CPKIFASNWrapper<CertReply>* m_scvpCertReply;

    void ClearAllMembers();
    void MakeSCVPCertReply();
    void FreeSCVPCertReply();

    //member to maintain state when calling Set functions
    void CallingAllGets();
    
    CPKIFCertReply * m_this;
};


void CPKIFCertReplyImpl::CallingAllGets()
{
    LOG_STRING_DEBUG("CPKIFCVRequestImpl::CallingAllGets()", TOOLKIT_SCVP_ASN, 0, this);

    populateExtensionsVector();
    FreeSCVPCertReply();
}

void CPKIFCertReplyImpl::MakeSCVPCertReply()
{
    LOG_STRING_DEBUG("CPKIFCVRequest::MakeSCVPR()", TOOLKIT_SCVP_ASN, 0, this);

    FreeSCVPCertReply();
    m_certReply = new CPKIFASNWrapper<CertReply>( BEREncCertReply, BERDecCertReply);
}
void CPKIFCertReplyImpl::FreeSCVPCertReply()
{
    LOG_STRING_DEBUG("CPKIFCertReplyImpl::MakeSCVPR()", TOOLKIT_SCVP_ASN, 0, this);
    if(NULL != m_certReply)
        delete m_certReply;
    if(NULL != m_scvpCertReply)
        delete m_scvpCertReply;
    m_certReply = NULL;
}

void CPKIFCertReplyImpl::ClearAllMembers()
{
    LOG_STRING_DEBUG("CPKIFCertReplyImpl::ClearAllMembers()", TOOLKIT_SCVP_ASN, 0, this);

    FreeSCVPCertReply();
}

void CPKIFCertReplyImpl::populateExtensionsVector()
{
    LOG_STRING_DEBUG("CPKIFCertReplyImpl::populateExtensionsVector()", TOOLKIT_SCVP_ASN, 0, this);

    if(NULL == m_certReply || NULL == m_certReply->data())
        return;

    //if we've already populated the extensions vector then return
    if(!m_exts.empty())
        return;

    //if there are no extensions then return
    if(0 == (*m_scvpCertReply)->m.certReplyExtensionsPresent)
    {
        m_exts.clear();
        return;
    }

    // get the one and only extension mediator, with any additions an app might
    // have made
    CPKIFX509ExtensionMediator2 * mediator = CPKIFX509ExtensionMediator2::GetInstance();

    m_this->IPKIFHasExtensions::GetExtensions (mediator, m_exts);
}



CPKIFCertReply::CPKIFCertReply() :m_impl(new CPKIFCertReplyImpl)
{
    LOG_STRING_DEBUG("CPKIFCertReply::CPKIFCertReply()", TOOLKIT_SCVP_ASN, 0, this);

    m_impl->m_certReply = NULL;
    m_impl->m_scvpCertReply = NULL;
    m_impl->m_replyStatus = -1;
}
CPKIFCertReply::CPKIFCertReply(
    const CPKIFBufferPtr& hashValue)
  :m_impl (new CPKIFCertReplyImpl)
{
    if(hashValue == (CPKIFBuffer*)NULL || 0 == hashValue->GetLength())
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP_ASN, COMMON_INVALID_INPUT);
    }

    CACASNWRAPPER_CREATE(CertReply, objPDU);
    objPDU.Decode(hashValue->GetBuffer(), hashValue->GetLength());

    //CertReference
    CACASNWRAPPER_CREATE(CertReference, objPDU2);
    ASN1OpenType* data1 = objPDU2.Encode(&objPDU->cert);
    CPKIFBufferPtr tmpBuf(new CPKIFBuffer(data1->data, data1->numocts));
    CPKIFCertReferencePtr tmpCertReference(new CPKIFCertReference(tmpBuf));
    m_impl->m_certRef = tmpCertReference;


    //replyValTime
    CPKIFTimePtr tmpTime(new CPKIFTime(objPDU->replyValTime));
    m_impl->m_replyValTime = tmpTime;

    //ReplyChecks
    CPKIFReplyCheckListPtr tmpReplyChecks(new CPKIFReplyCheckList());
    DListNode* cur = objPDU->replyChecks.head;
    while(NULL != cur)
    {
        ReplyCheck* tmp = (ReplyCheck*)cur->data;
        CACASNWRAPPER_CREATE(ReplyCheck, objPDU);
        ASN1OpenType* data1 = objPDU.Encode(tmp);
        CPKIFBufferPtr tmpBuf(new CPKIFBuffer(data1->data, data1->numocts));
        CPKIFReplyCheckPtr tmpReplyCheck(new CPKIFReplyCheck(tmpBuf));

        tmpReplyChecks->push_back(tmpReplyCheck);

        cur = cur->next;
    }
    m_impl->m_replyChecks = tmpReplyChecks;

    //ReplyWantBacks
    CPKIFReplyWantBackListPtr tmpReplyWantBacks(new CPKIFReplyWantBackList());
    DListNode* cur2 = objPDU->replyWantBacks.head;
    while(NULL != cur2)
    {
        ReplyWantBack* tmp = (ReplyWantBack*)cur2->data;
        CACASNWRAPPER_CREATE(ReplyWantBack, objPDU);
        ASN1OpenType* data1 = objPDU.Encode(tmp);
        CPKIFBufferPtr tmpBuf(new CPKIFBuffer(data1->data, data1->numocts));
        CPKIFReplyWantBackPtr tmpReplyWantBack(new CPKIFReplyWantBack(tmpBuf));

        tmpReplyWantBacks->push_back(tmpReplyWantBack);

        cur2 = cur2->next;
    }
    m_impl->m_replyWantBacks = tmpReplyWantBacks;

    if(0 < objPDU->m.nextUpdatePresent)
    {
        CPKIFTimePtr tmpTime(new CPKIFTime(objPDU->nextUpdate));
        m_impl->m_nextUpdate = tmpTime;
    }
    if(0 < objPDU->m.replyStatusPresent)
    {
        m_impl->m_replyStatus = objPDU->replyStatus;
    }
    if(0 < objPDU->m.validationErrorsPresent)
    {
        CPKIFOIDListPtr tmpErrors(new CPKIFOIDList());
        DListNode* cur = objPDU->validationErrors.head;
        while(NULL != cur)
        {
            ASN1OBJID* tmp = (ASN1OBJID*)cur->data;
            CPKIFOIDPtr tmpOID(new CPKIFOID(tmp->subid, tmp->numids));

            tmpErrors->push_back(tmpOID);

            cur = cur->next;
        }
        m_impl->m_validationErros = tmpErrors;
    }

}
CPKIFCertReply::~CPKIFCertReply()
{
    LOG_STRING_DEBUG("CPKIFCertReply::~CPKIFCertReply()", TOOLKIT_SCVP_ASN, 0, this);

    m_impl->FreeSCVPCertReply();
    if (m_impl) {
      delete m_impl;
    }   
}

void CPKIFCertReply::GetEncodedExtensions (
    CPKIFBufferPtr& buf) 
{
    try 
    {
        if ((*m_impl->m_certReply)->m.certReplyExtensionsPresent)
        {
            CACASNWRAPPER_CREATE(CACX509V3Extensions, extsWrapper);
            ASN1OpenType *data = extsWrapper.Encode (&(*m_impl->m_certReply)->certReplyExtensions);
            CPKIFBufferPtr tmp(new CPKIFBuffer(data->data, data->numocts));
            buf = tmp;
            delete data;
            return;
        }
    }
    catch (... /*CPKIFException& e*/)
    {
        // How do we want to handle the exception?
    }

    CPKIFBufferPtr nullExt;
    buf = nullExt;
}


void CPKIFCertReply::GetExtensionByOID(
    const CPKIFOID& oid,    
    CPKIFX509ExtensionPtr& ref)
{
    if(m_impl->m_exts.empty() && 0 != (*m_impl->m_certReply)->m.certReplyExtensionsPresent)
    m_impl->populateExtensionsVector();
    
    std::vector<CPKIFX509ExtensionPtr>::iterator pos;
    std::vector<CPKIFX509ExtensionPtr>::iterator end = m_impl->m_exts.end();
    for(pos = m_impl->m_exts.begin(); pos != end; ++pos)
    {
    if(oid == (*pos)->oid())
    {
        ref = *pos;
        return;
    }
    }       
}

bool CPKIFCertReply::ExtensionsPresent() const
{
    LOG_STRING_DEBUG("CPKIFCertReply::ExtensionsPresent()", TOOLKIT_SCVP_ASN, 0, this);

    if(NULL != m_impl->m_certReply && (*m_impl->m_certReply)->m.certReplyExtensionsPresent)
        return true;
    else
        return false;
}

void CPKIFCertReply::SetReplyValTime(
    CPKIFTimePtr& validationTime)
{
    m_impl->m_replyValTime = validationTime;
}
const CPKIFTimePtr CPKIFCertReply::GetReplyValTime() const
{
    return m_impl->m_replyValTime;
}

void CPKIFCertReply::SetNextUpdate(
    CPKIFTimePtr& nextUpdate)
{
    m_impl->m_nextUpdate = nextUpdate;
}
const CPKIFTimePtr CPKIFCertReply::GetNextUpdate() const
{
    return m_impl->m_nextUpdate;
}

void CPKIFCertReply::SetValErrors(
    CPKIFOIDListPtr& errors) 
{
    m_impl->m_validationErros = errors;
}

void CPKIFCertReply::GetValErrors(
    CPKIFOIDListPtr& errors) const 
{
    errors = m_impl->m_validationErros;
}

void CPKIFCertReply::SetReplyStatus(
    int replyStatus)
{
    m_impl->m_replyStatus = replyStatus;
}

const int CPKIFCertReply::GetReplyStatus() const
{
    return m_impl->m_replyStatus;
}

void CPKIFCertReply::SetReplyChecks(
    CPKIFReplyCheckListPtr& replyChecks) 
{
    m_impl->m_replyChecks = replyChecks;
}

void CPKIFCertReply::GetReplyChecks(
    CPKIFReplyCheckListPtr& replyChecks) const 
{
    replyChecks = m_impl->m_replyChecks;
}


void CPKIFCertReply::SetReplyWantBacks(
    CPKIFReplyWantBackListPtr& replyWantBacks) 
{
    m_impl->m_replyWantBacks = replyWantBacks;
}

void CPKIFCertReply::GetReplyWantBacks(
    CPKIFReplyWantBackListPtr& replyWantBacks) const 
{
    replyWantBacks = m_impl->m_replyWantBacks;
}
void CPKIFCertReply::SetCertRef(
    CPKIFCertReferencePtr& certRef)
{
    m_impl->m_certRef = certRef;
}
const CPKIFCertReferencePtr CPKIFCertReply::GetCertRef() const
{
    return m_impl->m_certRef;
}