TimeStampResponse.cpp

Go to the documentation of this file.

#include "TimeStampResponse.h"
#include "PKIFTSP.h"
#include "Buffer.h"
#include "PKIStatusInfo.h"
#include "ContentInfo.h"
#include "ASN1Helper.h"
#include "ToolkitUtils.h"
#include "TSPException.h"
#include "private/PKIFTSPMemoryHelper.h"
#include "pkiftsperrors.h"
#include "OID.h"

#include "PKIXTSP.h"


struct CPKIFTimeStampResponseImpl
{
    CPKIFTimeStampResponse *m_parent;

    CPKIFPKIStatusInfoPtr m_status;
    CPKIFContentInfoPtr m_timeStampToken;

    CPKIFASNWrapper<PKIFTSPTimeStampResp>* m_tsr;

    void ClearAllMembers();
    void MakeTSR();
    void FreeTSR();

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

void CPKIFTimeStampResponseImpl::ClearAllMembers()
{
    LOG_STRING_DEBUG("CPKIFTimeStampResponse::ClearAllMembers()", TOOLKIT_TSP_ASN, 0, this);

    FreeTSR();
}
void CPKIFTimeStampResponseImpl::CallingAllGets()
{
    LOG_STRING_DEBUG("CPKIFTimeStampResponse::CallingAllGets()", TOOLKIT_TSP_ASN, 0, this);

    m_parent->GetStatus();
    m_parent->GetTimeStampToken();
    FreeTSR();
}
void CPKIFTimeStampResponseImpl::MakeTSR()
{
    LOG_STRING_DEBUG("CPKIFTimeStampResponse::MakeTSR()", TOOLKIT_TSP_ASN, 0, this);

    FreeTSR();
    m_tsr = new CPKIFASNWrapper<PKIFTSPTimeStampResp>( BEREncPKIFTSPTimeStampResp, BERDecPKIFTSPTimeStampResp );
}
void CPKIFTimeStampResponseImpl::FreeTSR()
{
    LOG_STRING_DEBUG("CPKIFTimeStampResponse::FreeTSR()", TOOLKIT_TSP_ASN, 0, this);

    if(NULL != m_tsr)
        delete m_tsr;
    m_tsr = NULL;
}


CPKIFTimeStampResponse::CPKIFTimeStampResponse()
  :m_impl(new CPKIFTimeStampResponseImpl)
{
    LOG_STRING_DEBUG("CPKIFTimeStampResponse::CPKIFTimeStampResponse()", TOOLKIT_TSP_ASN, 0, this);

    m_impl->m_parent = this;
    m_impl->m_tsr = NULL;
}
CPKIFTimeStampResponse::~CPKIFTimeStampResponse()
{
    LOG_STRING_DEBUG("CPKIFTimeStampResponse::~CPKIFTimeStampResponse()", TOOLKIT_TSP_ASN, 0, this);

    m_impl->FreeTSR();

    if (m_impl)
    {
      delete m_impl;
    }
}
void CPKIFTimeStampResponse::SetStatus(
    CPKIFPKIStatusInfoPtr& status)
{
    LOG_STRING_DEBUG("CPKIFTimeStampResponse::SetStatus(CPKIFPKIStatusInfoPtr& status)", TOOLKIT_TSP_ASN, 0, this);

    m_impl->CallingAllGets();
    m_impl->m_status = status;
}
CPKIFPKIStatusInfoPtr CPKIFTimeStampResponse::GetStatus() const
{
    if(m_impl->m_status == (CPKIFPKIStatusInfo*)NULL && NULL != m_impl->m_tsr && NULL != (*m_impl->m_tsr).data())
    {
        LOG_STRING_DEBUG("CPKIFTimeStampResponse::GetStatus()", TOOLKIT_TSP_ASN, 0, this);

        CACASNWRAPPER_CREATE(PKIFTSPPKIStatusInfo, siWrapper);
        ASN1OpenType *data  = siWrapper.Encode(&(*m_impl->m_tsr)->status);
        CPKIFBufferPtr siBuf(new CPKIFBuffer(data->data, data->numocts));

        CPKIFPKIStatusInfoPtr tmpRef(new CPKIFPKIStatusInfo(siBuf)); 
        //CPKIFPKIStatusInfoPtr tmpRef(new CPKIFPKIStatusInfo((*m_impl->m_tsr)->status)); 

        CPKIFTimeStampResponse* nonConst = const_cast<CPKIFTimeStampResponse*>(this);
        nonConst->m_impl->m_status = tmpRef;
    }

    return m_impl->m_status;
}
void CPKIFTimeStampResponse::SetTimeStampToken(
    CPKIFContentInfoPtr& timeStampToken)
{
    LOG_STRING_DEBUG("CPKIFTimeStampResponse::SetTimeStampToken(CPKIFContentInfoPtr& timeStampToken)", TOOLKIT_TSP_ASN, 0, this);

    m_impl->CallingAllGets();
    m_impl->m_timeStampToken = timeStampToken;
}
CPKIFContentInfoPtr CPKIFTimeStampResponse::GetTimeStampToken() const
{
    if(m_impl->m_timeStampToken == (CPKIFContentInfo*)NULL && NULL != m_impl->m_tsr && (*m_impl->m_tsr)->m.timeStampTokenPresent)
    {
        LOG_STRING_DEBUG("CPKIFTimeStampResponse::GetTimeStampToken()", TOOLKIT_TSP_ASN, 0, this);

        CPKIFOIDPtr oid(new CPKIFOID((*m_impl->m_tsr)->timeStampToken.contentType.subid, (*m_impl->m_tsr)->timeStampToken.contentType.numids));
        CPKIFBufferPtr buffer(new CPKIFBuffer((*m_impl->m_tsr)->timeStampToken.content.data, 
                                              (*m_impl->m_tsr)->timeStampToken.content.numocts));

        CPKIFContentInfoPtr tmpRef(new CPKIFContentInfo(oid, buffer));
        //CPKIFContentInfoPtr tmpRef(new CPKIFContentInfo((*m_impl->m_tsr)->timeStampToken));

        CPKIFTimeStampResponse* nonConst = const_cast<CPKIFTimeStampResponse*>(this);
        nonConst->m_impl->m_timeStampToken = tmpRef;
    }

    return m_impl->m_timeStampToken;
}
CPKIFBufferPtr CPKIFTimeStampResponse::Encode() const
{
    LOG_STRING_DEBUG("CPKIFTimeStampResponse::Encode()", TOOLKIT_TSP_ASN, 0, this);

    PKIFTSPMemoryHelper mhTSPResponse;
    mhTSPResponse.pResponse = new PKIFTSPTimeStampResp;
    memset(mhTSPResponse.pResponse, 0, sizeof(PKIFTSPTimeStampResp));

    CPKIFPKIStatusInfoPtr si = GetStatus();
    if(si == (CPKIFPKIStatusInfo*)NULL)
    {
        throw CPKIFTSPException(TOOLKIT_TSP_ASN, TSP_MISSING_REQUIRED_FIELD, "Status field not present.");
    }
    else
    {
        PKIStatus status = si->GetStatus();
        mhTSPResponse.pResponse->status.status = (PKIFTSPPKIStatus_Root)status;

        //get fail info
        std::bitset<8> failInfo;
        si->GetFailInfo(failInfo);

        CPKIFStringArray strs;
        si->GetStatusStrings(strs);

        if(!strs.empty())
            mhTSPResponse.pResponse->status.m.statusStringPresent = 1;

        DListNode* cur = NULL;
        CPKIFStringArray::iterator pos;
        CPKIFStringArray::iterator end = strs.end();
        for(pos = strs.begin(); pos != end; ++pos)
        {
            if(NULL == cur)
            {
                NEW_NODE(cur)
            }
            else
            {
                NEW_NEXT_AND_ADVANCE(cur)
            }

            const char* pStr = (*pos)->c_str();
            cur->data = (void*)&pStr;

            SET_HEAD_TAIL_INCREMENT(mhTSPResponse.pResponse->status.statusString, cur)
        }
    }

    CPKIFContentInfoPtr tst = GetTimeStampToken();
    if(tst != (CPKIFContentInfo*)NULL)
    {
        mhTSPResponse.pResponse->m.timeStampTokenPresent = 1;
        CPKIFStringPtr str(new std::string(tst->GetContentType()->ToString())); 
        ASN1OBJID* tmpOid = ConvertStringToASN1OBJID(str);
        CopyOID(&mhTSPResponse.pResponse->timeStampToken.contentType, tmpOid);

        if( NULL != tmpOid)
            delete tmpOid;
        //mhTSPResponse.pResponse->timeStampToken.contentType = *tst->GetContentType()->raw();
        mhTSPResponse.pResponse->timeStampToken.content.data = tst->GetContent()->GetBuffer();
        mhTSPResponse.pResponse->timeStampToken.content.numocts = tst->GetContent()->GetLength();
    }

    CACASNWRAPPER_CREATE(PKIFTSPTimeStampResp, objPDU);
    ASN1OpenType* data1 = objPDU.Encode(mhTSPResponse.pResponse);
    CPKIFBufferPtr tmp(new CPKIFBuffer(data1->data, data1->numocts));
    delete data1;
    return tmp;
}
void CPKIFTimeStampResponse::Decode(
    CPKIFBufferPtr& buf)
{
    LOG_STRING_DEBUG("CPKIFTimeStampResponse::Decode(CPKIFBufferPtr& buf)", TOOLKIT_TSP_ASN, 0, this);
    m_impl->ClearAllMembers();

    //if the input is empty - fail now
    if(buf == (CPKIFBuffer*)NULL || 0 == buf->GetLength())
    {
        throw CPKIFTSPException(TOOLKIT_TSP_ASN, COMMON_INVALID_INPUT);
    }

    m_impl->MakeTSR();

    try
    {
        //otherwise try to parse it into the m_asr member
        (*m_impl->m_tsr).Decode(buf->GetBuffer(), buf->GetLength());
    }
    catch(CPKIFException&)
    {
        //delete e;
        //changed error code 3/2/2004
        throw CPKIFTSPException(TOOLKIT_TSP_ASN, ASN1_DECODE_ERROR);
    }
}