SingleResponse.cpp

Go to the documentation of this file.

#include "SingleResponse.h"
#include "CertID.h"
#include "OCSPCertStatus.h"
#include "PKIFTime.h"
#include "X509Extension.h"
#include "ASN1Helper.h"
#include "OID.h"
#include "Buffer.h"

#include "OCSP.h"

#include "ToolkitUtils.h"
#include "PKIFX509Extensions2.h"
#include "ExtensionsMatch.h"
using namespace std;

struct CPKIFSingleResponseImpl
{
    CPKIFSingleResponseImpl();
    void populateExtensionsVector(CPKIFASNWrapper<SingleResponse>& sr);
    std::vector<CPKIFX509ExtensionPtr> m_exts;
    CPKIFASNWrapper<SingleResponse> m_singleResponse;

    CPKIFCertIDPtr m_certID;
    CPKIFOCSPCertStatusPtr m_certStatus;
    CPKIFTimePtr m_thisUpdate;
    CPKIFTimePtr m_nextUpdate;

    CPKIFSingleResponse * m_this;
};


CPKIFSingleResponseImpl::CPKIFSingleResponseImpl ()
: m_singleResponse(BEREncSingleResponse, BERDecSingleResponse)
{
}

CPKIFSingleResponse::CPKIFSingleResponse(void)
    :m_impl (new CPKIFSingleResponseImpl)
{
    LOG_STRING_DEBUG("CPKIFSingleResponse::CPKIFSingleResponse(void)", TOOLKIT_OCSP_ASN, 0, this);

    m_impl->m_this = this;
}
CPKIFSingleResponse::CPKIFSingleResponse(
    const CPKIFBufferPtr& singleResponse)
    :m_impl (new CPKIFSingleResponseImpl)
{
    LOG_STRING_DEBUG("CPKIFSingleResponse::CPKIFSingleResponse(SingleResponse& sr)", TOOLKIT_OCSP_ASN, 0, this);

    m_impl->m_this = this;
    m_impl->m_singleResponse.Decode(singleResponse->GetBuffer(), singleResponse->GetLength());

    CACASNWRAPPER_CREATE(CertID, objPDU);
    ASN1OpenType* data1 = objPDU.Encode(&(m_impl->m_singleResponse->certID));
    CPKIFBufferPtr buffPtr;
    if(NULL != data1)
    {
        buffPtr = CPKIFBufferPtr(new CPKIFBuffer(data1->data, data1->numocts));
        delete data1;
    }

    //CPKIFCertIDPtr tmpCID(new CPKIFCertID(m_impl->m_singleResponse->certID));
    CPKIFCertIDPtr tmpCID(new CPKIFCertID(buffPtr));
    m_impl->m_certID = tmpCID;

    CACASNWRAPPER_CREATE(CertStatus, objPDU2);
    data1 = objPDU2.Encode(&(m_impl->m_singleResponse->certStatus));
    CPKIFBufferPtr buffPtr2;
    if(NULL != data1)
    {
        buffPtr2 = CPKIFBufferPtr(new CPKIFBuffer(data1->data, data1->numocts));
        delete data1;
    }
    //CPKIFOCSPCertStatusPtr tmpCS(new CPKIFOCSPCertStatus(m_impl->m_singleResponse->certStatus));
    CPKIFOCSPCertStatusPtr tmpCS(new CPKIFOCSPCertStatus(buffPtr2));
    m_impl->m_certStatus = tmpCS;

    CPKIFTimePtr tmpTU(new CPKIFTime(m_impl->m_singleResponse->thisUpdate));
    m_impl->m_thisUpdate = tmpTU;

    if(m_impl->m_singleResponse->m.nextUpdatePresent)
    {
        CPKIFTimePtr tmpNU(new CPKIFTime(m_impl->m_singleResponse->nextUpdate));
        m_impl->m_nextUpdate = tmpNU;
    }
    
    if(m_impl->m_singleResponse->m.singleExtensionsPresent)
    {
        m_impl->populateExtensionsVector(m_impl->m_singleResponse);
    }

    
}
CPKIFSingleResponse::~CPKIFSingleResponse(void)
{
    LOG_STRING_DEBUG("CPKIFSingleResponse::~CPKIFSingleResponse(void)", TOOLKIT_OCSP_ASN, 0, this);

    delete m_impl;
    m_impl = NULL;
}
void CPKIFSingleResponseImpl::populateExtensionsVector(
    CPKIFASNWrapper<SingleResponse>& sr)
{
    LOG_STRING_DEBUG("CPKIFSingleResponse::populateExtensionsVector(SingleResponse& sr)", TOOLKIT_OCSP_ASN, 0, this);

    m_exts.clear();

    if(0 == sr->m.singleExtensionsPresent)
        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);
}

bool CPKIFSingleResponse::AreThereAnyUnprocessedCriticalExtensions(
    std::vector<CPKIFX509ExtensionPtr>& processedExts)
{
    LOG_STRING_DEBUG("CPKIFSingleResponse::AreThereAnyUnprocessedCriticalExtensions(std::vector<CPKIFX509ExtensionPtr>& processedExts)", TOOLKIT_OCSP_ASN, 0, this);

    std::vector<CPKIFX509ExtensionPtr>::iterator pos;
    std::vector<CPKIFX509ExtensionPtr>::iterator end = m_impl->m_exts.end();
    std::vector<CPKIFX509ExtensionPtr>::iterator processedEnd = processedExts.end();
    ExtensionsMatch em;
//  int count = processedExts.size();
    for(pos = m_impl->m_exts.begin(); pos != end; ++pos)
    {
        em.SetRHS(*pos);
        if((*pos)->isCritical() && processedEnd == find_if(processedExts.begin(), processedExts.end(), em))
            return true;
    }

    return false;
}

//certID
CPKIFCertIDPtr CPKIFSingleResponse::GetCertID() const
{
    return m_impl->m_certID;
}
void CPKIFSingleResponse::SetCertID(
    CPKIFCertIDPtr& ci)
{
    m_impl->m_certID = ci;
}

//certStatus
CPKIFOCSPCertStatusPtr CPKIFSingleResponse::GetCertStatus() const
{
    return m_impl->m_certStatus;
}
void CPKIFSingleResponse::SetCertStatus(
    CPKIFOCSPCertStatusPtr& cs)
{
    m_impl->m_certStatus = cs;
}

//thisUpdate
CPKIFTimePtr CPKIFSingleResponse::GetThisUpdate() const
{
    return m_impl->m_thisUpdate;
}
void CPKIFSingleResponse::SetThisUpdate(
    CPKIFTimePtr& str)
{
    m_impl->m_thisUpdate = str;
}

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

void CPKIFSingleResponse::GetEncodedExtensions (
    CPKIFBufferPtr& buf) 
{
    try 
    {
        if (m_impl->m_singleResponse->m.singleExtensionsPresent)
        {
            CACASNWRAPPER_CREATE(CACX509V3Extensions, extsWrapper);
            ASN1OpenType *data = extsWrapper.Encode (&m_impl->m_singleResponse->singleExtensions);
            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;
}

//this function is for use when retrieving an extension for which no proper class exists
void CPKIFSingleResponse::GetExtensionByOID(
    const CPKIFOID& oid,
    CPKIFX509ExtensionPtr& ref)
{
    if(m_impl->m_exts.empty() && 0 != m_impl->m_singleResponse->singleExtensions.count)
        m_impl->populateExtensionsVector(m_impl->m_singleResponse);

    vector<CPKIFX509ExtensionPtr>::iterator pos;
    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;
        }
    }       
}