ResponseData.cpp

Go to the documentation of this file.

#include "ResponseData.h"
#include "ResponderID.h"
#include "PKIFTime.h"
#include "SingleResponse.h"
#include "X509Extension.h"
#include "Buffer.h"
#include "OID.h"

#include "ASN1Helper.h"
#include "OCSP.h"

#include "PKIFX509Extensions2.h"
#include "ToolkitUtils.h"
#include "components.h"
#include "ExtensionsMatch.h"
#include "ASN1Helper.h"

#include <iterator>
using namespace std;

struct CPKIFResponseDataImpl
{
    CPKIFResponseDataImpl ();
    int m_version;
    CPKIFResponderIDPtr m_responderID;
    CPKIFTimePtr m_producedAt;
    CPKIFSingleResponseList m_responses;

    CPKIFASNWrapper<ResponseData> m_responseData;
    std::vector<CPKIFX509ExtensionPtr> m_exts;
    void populateExtensionsVector(CPKIFASNWrapper<ResponseData>& rd);

    CPKIFBufferPtr m_thatWhichWasSigned;

    CPKIFResponseData * m_this;
};


CPKIFResponseDataImpl::CPKIFResponseDataImpl ()
: m_responseData(BEREncResponseData, BERDecResponseData)
{
}

CPKIFResponseData::CPKIFResponseData(void)
    :m_impl (new CPKIFResponseDataImpl)
{
    LOG_STRING_DEBUG("CPKIFResponseData::CPKIFResponseData(void)", TOOLKIT_OCSP_ASN, 0, this);

    //added 7/25/2004
    m_impl->m_version = 0;
    m_impl->m_this = this;
}
CPKIFResponseData::CPKIFResponseData(
    const CPKIFBufferPtr& responseData)
    :m_impl (new CPKIFResponseDataImpl)
{
    LOG_STRING_DEBUG("CPKIFResponseData::CPKIFResponseData(const CPKIFBufferPtr& responseData)", TOOLKIT_OCSP_ASN, 0, this);

    CPKIFBufferPtr bp(new CPKIFBuffer(*responseData));
    m_impl->m_this = this;
    m_impl->m_thatWhichWasSigned = bp;

    m_impl->m_responseData.Decode(responseData->GetBuffer(), responseData->GetLength());

    m_impl->m_version = m_impl->m_responseData->version;

    CACASNWRAPPER_CREATE(ResponderID, objPDU);
    ASN1OpenType* data1 = objPDU.Encode(&(m_impl->m_responseData->responderID));
    CPKIFBufferPtr buffPtr;
    if(NULL != data1)
    {
        buffPtr = CPKIFBufferPtr(new CPKIFBuffer(data1->data, data1->numocts));
        delete data1;
    }
    CPKIFResponderIDPtr tmpRID(new CPKIFResponderID(buffPtr));
    m_impl->m_responderID = tmpRID;

    CPKIFTimePtr tmpStr(new CPKIFTime(m_impl->m_responseData->producedAt));
    m_impl->m_producedAt = tmpStr;

    m_impl->populateExtensionsVector(m_impl->m_responseData);

    if(m_impl->m_responseData->responses.count > 0)
    {
        DListNode* cur = m_impl->m_responseData->responses.head; 
        while(NULL != cur)
        {
            ASN1OpenType* openType = (ASN1OpenType*)cur->data;

            CPKIFBufferPtr tmpBuffer(new CPKIFBuffer(openType->data, openType->numocts));

            CPKIFSingleResponsePtr tmpReq(new CPKIFSingleResponse(tmpBuffer));

            m_impl->m_responses.push_back(tmpReq);
    
            cur = cur->next;
        }
    }
}
CPKIFResponseData::~CPKIFResponseData(void)
{
    LOG_STRING_DEBUG("CPKIFResponseData::~CPKIFResponseData(void)", TOOLKIT_OCSP_ASN, 0, this);

    delete m_impl;
    m_impl = NULL;
}
void CPKIFResponseDataImpl::populateExtensionsVector(
    CPKIFASNWrapper<ResponseData>& rd)
{
    LOG_STRING_DEBUG("CPKIFResponseData::populateExtensionsVector(CPKIFASNWrapper<ResponseData>& rd)", TOOLKIT_OCSP_ASN, 0, this);

    m_exts.clear();
    if(NULL == rd.data() || 0 == rd->m.responseExtensionsPresent)
        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 CPKIFResponseData::AreThereAnyUnprocessedCriticalExtensions(
    std::vector<CPKIFX509ExtensionPtr>& processedExts)
{
    LOG_STRING_DEBUG("CPKIFResponseData::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;
    size_t 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;
}

//@b Interface: External
//
//This function is used to get an extension contained by a ResponseData object.
//
//@return None
//*/
//void CPKIFResponseData::GetExtension(
//  //![in] Reference to a CPKIFOID containing the object identifier for the type of extension to retrieve
//  const CPKIFOID& oid, 
//  //![out] Reference to a smart pointer to a CPKIFX509Extension object to receive a pointer to the requested
//  //!extension object (or NULL if the requested extension is not present)
//  CPKIFX509ExtensionPtr& ref)
//{
//  LOG_STRING_DEBUG("CPKIFResponseData::GetExtension(const CPKIFOID& oid, CPKIFX509ExtensionPtr& ref)", TOOLKIT_OCSP_ASN, 0, this);
//
//  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;
//      }
//  }       
//}

//version
int CPKIFResponseData::GetVersion() const
{
    return m_impl->m_version;
}

//responderID

CPKIFResponderIDPtr CPKIFResponseData::GetResponderID() const
{
    return m_impl->m_responderID;
}
void CPKIFResponseData::SetResponderID(
    CPKIFResponderIDPtr& rid)
{
    m_impl->m_responderID = rid;
}

//producedAt
CPKIFTimePtr CPKIFResponseData::GetProducedAt() const
{
    return m_impl->m_producedAt;
}
void CPKIFResponseData::SetProducedAt(
    CPKIFTimePtr& pa)
{
    m_impl->m_producedAt = pa;
}

//responses
void CPKIFResponseData::GetResponses(
    CPKIFSingleResponseList& srs)
{
    copy(m_impl->m_responses.begin(), m_impl->m_responses.end(), back_inserter(srs));
}
void CPKIFResponseData::AddResponse(
    CPKIFSingleResponsePtr& sr)
{
    m_impl->m_responses.push_back(sr);
}
CPKIFBufferPtr CPKIFResponseData::toBeSigned()
{
    return m_impl->m_thatWhichWasSigned;
}

void CPKIFResponseData::GetEncodedExtensions (
    CPKIFBufferPtr& buf) 
{
    try 
    {
        if (m_impl->m_responseData->m.responseExtensionsPresent)
        {
            CACASNWRAPPER_CREATE(CACX509V3Extensions, extsWrapper);
            ASN1OpenType *data = extsWrapper.Encode (&m_impl->m_responseData->responseExtensions);
            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 CPKIFResponseData::GetExtensionByOID(
    const CPKIFOID& oid,
    CPKIFX509ExtensionPtr& ref)
{
    if(m_impl->m_exts.empty() && 0 != m_impl->m_responseData->responseExtensions.count)
        m_impl->populateExtensionsVector(m_impl->m_responseData);

    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;
        }
    }       
}