RevInfoWantBack.cpp

Go to the documentation of this file.

#include "RevInfoWantBack.h"
#include "components.h"
#include "ToolkitUtils.h"
#include "Buffer.h"
#include "PKIFSCVPErrors.h"
#include "SCVPException.h"
#include "ASN1Helper.h"
#include "SCVP.h"
#include "CertBundle.h"
#include "RevocationInfo.h"
#include "Certificate.h"
#include "CRL.h"


struct CPKIFRevInfoWantBackImpl 
{

    void FreeRevInfoWantBack(RevInfoWantBack* revInfoWantBack);

    CPKIFRevocationInfoListPtr m_RevInfos;
    CPKIFCertBundlePtr m_certBundle;
};


CPKIFRevInfoWantBack::CPKIFRevInfoWantBack() :m_impl(new CPKIFRevInfoWantBackImpl)
{
    LOG_STRING_DEBUG("CPKIFRevInfoWantBack::CPKIFRevInfoWantBack()", TOOLKIT_SCVP_ASN, 0, this);

}
CPKIFRevInfoWantBack::CPKIFRevInfoWantBack(
    const CPKIFBufferPtr& revInfoWantBack)
  :m_impl (new CPKIFRevInfoWantBackImpl)
{
    if(revInfoWantBack == (CPKIFBuffer*)NULL || 0 == revInfoWantBack->GetLength())
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP_ASN, COMMON_INVALID_INPUT);
    }

    CACASNWRAPPER_CREATE(RevInfoWantBack, objPDU);
    objPDU.Decode(revInfoWantBack->GetBuffer(), revInfoWantBack->GetLength());

    if(objPDU->m.extraCertsPresent == 1) {
        CACASNWRAPPER_CREATE(CertBundle, objPDU2);  
        ASN1OpenType* data1 = objPDU2.Encode(&objPDU->extraCerts);  

        CPKIFBufferPtr tmpBuf(new CPKIFBuffer(data1->data, data1->numocts));
        CPKIFCertBundlePtr tmpBundle(new CPKIFCertBundle());
        tmpBundle->Decode(tmpBuf);
        if(NULL != data1)
            delete data1;


        m_impl->m_certBundle = tmpBundle;
    }

    CPKIFRevocationInfoListPtr revInfoList(new CPKIFRevocationInfoList());
    DListNode* cur = objPDU->revocationInfo.head;
    while(NULL != cur)
    {
        RevocationInfo* tmp = (RevocationInfo*)cur->data;
        CACASNWRAPPER_CREATE(RevocationInfo, objPDU3);
        ASN1OpenType* data2 = objPDU3.Encode(tmp);          
        CPKIFBufferPtr tmpBuf(new CPKIFBuffer(data2->data, data2->numocts));
        CPKIFRevocationInfoPtr tmpRevocationInfo(new CPKIFRevocationInfo(tmpBuf));

        if(NULL != data2)
            delete data2;


        revInfoList->push_back(tmpRevocationInfo);

        cur = cur->next;
    }
    m_impl->m_RevInfos = revInfoList;
}
CPKIFBufferPtr CPKIFRevInfoWantBack::Encode()
{
    RevInfoWantBack revInfoWantBack;
    memset(&revInfoWantBack,0x00,sizeof(RevInfoWantBack));

    OOCTXT ctxt;
    initContext (&ctxt);

    CACASNWRAPPER_CREATE(RevInfoWantBack, objPDU);  

    if(m_impl->m_certBundle != (CPKIFCertBundle*)NULL)
    {
        revInfoWantBack.m.extraCertsPresent = 1;

        CPKIFCertificateListPtr certList;
        m_impl->m_certBundle->GetCertList(certList);

        DListNode* curCert = NULL;
        CPKIFCertificateList::iterator certPos; 
        CPKIFCertificateList::iterator certEnd = certList->end();
        for(certPos = certList->begin(); certPos != certEnd; ++certPos)
        {
            if(NULL == curCert)
            {
                NEW_NODE(curCert)
            }
            else
            {
                NEW_NEXT_AND_ADVANCE(curCert)
            }

            ASN1OpenType* tmpCert = new ASN1OpenType;
            memset(tmpCert, 0, sizeof(ASN1OpenType));
            
            //certs were screened when added to make sure the encoded buffer existed
            tmpCert->data = (*certPos)->Encoded()->GetBuffer();
            tmpCert->numocts = (*certPos)->Encoded()->GetLength();
            
            curCert->data = tmpCert;

            SET_HEAD_TAIL_INCREMENT(revInfoWantBack.extraCerts, curCert)
        }
    }

    if(m_impl->m_RevInfos != (CPKIFRevocationInfoList*)NULL && !m_impl->m_RevInfos->empty())
    {
        DListNode* curRevInfo = NULL;
        CPKIFRevocationInfoList::iterator revInfoPos;   
        CPKIFRevocationInfoList::iterator revInfoEnd = m_impl->m_RevInfos->end();
        for(revInfoPos = m_impl->m_RevInfos->begin(); revInfoPos != revInfoEnd; ++revInfoPos)
        {
            if(NULL == curRevInfo)
            {
                NEW_NODE(curRevInfo)
            }
            else
            {
                NEW_NEXT_AND_ADVANCE(curRevInfo)
            }

            if((*revInfoPos)->GetCRL() != (CPKIFCRL*)NULL)
            {
                RevocationInfo* tmpCRL = new RevocationInfo;
                memset(tmpCRL, 0, sizeof(RevocationInfo));

                tmpCRL->t = T_RevocationInfo_crl;

                tmpCRL->u.crl = new CACX509V3CertificateList;
                memset(tmpCRL->u.crl, 0, sizeof(CACX509V3CertificateList));

                setBERDecBufPtr(&ctxt, (unsigned char*)(*revInfoPos)->GetCRL()->Encoded()->GetBuffer(), (*revInfoPos)->GetCRL()->Encoded()->GetLength(), NULL, NULL);
                BERDecCACX509V3CertificateList(&ctxt, tmpCRL->u.crl, ASN1EXPL, NULL);
            
                curRevInfo->data = tmpCRL;
            }
            else if((*revInfoPos)->GetDeltaCRL() != (CPKIFCRL*)NULL)
            {
                RevocationInfo* tmpDeltaCRL = new RevocationInfo;
                memset(tmpDeltaCRL, 0, sizeof(RevocationInfo));

                tmpDeltaCRL->t = T_RevocationInfo_delta_crl;

                tmpDeltaCRL->u.delta_crl = new CACX509V3CertificateList;
                memset(tmpDeltaCRL->u.delta_crl, 0, sizeof(CACX509V3CertificateList));

                setBERDecBufPtr(&ctxt, (unsigned char*)(*revInfoPos)->GetDeltaCRL()->Encoded()->GetBuffer(), (*revInfoPos)->GetDeltaCRL()->Encoded()->GetLength(), NULL, NULL);
                BERDecCACX509V3CertificateList(&ctxt, tmpDeltaCRL->u.delta_crl, ASN1EXPL, NULL);
                        
                curRevInfo->data = tmpDeltaCRL;
            }
            else if((*revInfoPos)->GetOCSPResp() != (CPKIFBuffer*)NULL)
            {
                RevocationInfo* tmpOCSPResp = new RevocationInfo;
                memset(tmpOCSPResp, 0, sizeof(RevocationInfo));

                tmpOCSPResp->t = T_RevocationInfo_ocsp;

                tmpOCSPResp->u.ocsp = new OCSPResponse;
                memset(tmpOCSPResp->u.ocsp, 0, sizeof(OCSPResponse));
                
                setBERDecBufPtr(&ctxt, (unsigned char*)(*revInfoPos)->GetOCSPResp()->GetBuffer(), (*revInfoPos)->GetOCSPResp()->GetLength(), NULL, NULL);
                BERDecOCSPResponse(&ctxt, tmpOCSPResp->u.ocsp, ASN1EXPL, NULL);
                
                curRevInfo->data = tmpOCSPResp;
            }
            else
            {
                RevocationInfo* tmpOther = new RevocationInfo;
                memset(tmpOther, 0, sizeof(RevocationInfo));

                tmpOther->t = T_RevocationInfo_other;
                tmpOther->u.other = new OtherRevInfo;

                CPKIFOIDPtr oid;
                CPKIFBufferPtr buf;
                (*revInfoPos)->GetOtherRevInfo(oid, buf);

                CPKIFStringPtr str(new std::string(oid->ToString())); 
                ASN1OBJID* tmpOid2 = ConvertStringToASN1OBJID(str);
                CopyOID(&tmpOther->u.other->riType, tmpOid2);

                if(NULL != tmpOid2)
                    delete tmpOid2;

                tmpOther->u.other->riValue.data = buf->GetBuffer();
                tmpOther->u.other->riValue.numocts = buf->GetLength();

                curRevInfo->data = tmpOther;
                
            }


            SET_HEAD_TAIL_INCREMENT(revInfoWantBack.revocationInfo, curRevInfo)
        }

    }
    ASN1OpenType* data1 = objPDU.Encode(&revInfoWantBack);

    CPKIFBufferPtr rv(new CPKIFBuffer(data1->data, data1->numocts));

    m_impl->FreeRevInfoWantBack(&revInfoWantBack);

    if(NULL != data1)
        delete data1;

    freeEncodeBuffer(&ctxt);
    memFreeAll(&ctxt);


    return rv;
}
CPKIFRevInfoWantBack::~CPKIFRevInfoWantBack()
{
    LOG_STRING_DEBUG("CPKIFRevInfoWantBack::~CPKIFRevInfoWantBack()", TOOLKIT_SCVP_ASN, 0, this);

    if (m_impl) {
      delete m_impl;
    }   
}
void CPKIFRevInfoWantBack::SetRevInfos(
    CPKIFRevocationInfoListPtr& revInfoList)
{
    m_impl->m_RevInfos = revInfoList;
}
void CPKIFRevInfoWantBack::GetRevInfos(
    CPKIFRevocationInfoListPtr& revInfoList) const
{
    revInfoList = m_impl->m_RevInfos;
}

void CPKIFRevInfoWantBack::SetExtraCerts(
    CPKIFCertBundlePtr& bundle)
{
    m_impl->m_certBundle = bundle;
}
const CPKIFCertBundlePtr CPKIFRevInfoWantBack::GetExtraCerts() const{
    return m_impl->m_certBundle;
}


void CPKIFRevInfoWantBackImpl::FreeRevInfoWantBack(RevInfoWantBack* revInfoWantBack) 
{
    
    DListNode* cur = NULL, *tmp = NULL;
    if(revInfoWantBack->m.extraCertsPresent)
    {
        cur = revInfoWantBack->extraCerts.head;
        while(NULL != cur)
        {
            tmp = cur->next;

            delete cur;
            cur = tmp;
        }
    }


    cur = NULL;
    tmp = NULL;
    cur = revInfoWantBack->revocationInfo.head;
    while(NULL != cur)
    {
        tmp = cur->next;

        RevocationInfo* tmpOther = (RevocationInfo*)cur->data;

        if(tmpOther->t == T_RevocationInfo_crl)
        {
            if(tmpOther->u.crl != NULL)
                delete tmpOther->u.crl;
        }
        else if(tmpOther->t == T_RevocationInfo_delta_crl)
        {
            if(tmpOther->u.delta_crl != NULL)
                delete tmpOther->u.delta_crl;
        }
        else if(tmpOther->t == T_RevocationInfo_ocsp)
        {
            if(tmpOther->u.ocsp != NULL)
                delete tmpOther->u.ocsp;
        }
        else if(tmpOther->t == T_RevocationInfo_other)
        {
        }

        if(NULL != cur && NULL != cur->data)
            delete cur->data;
        delete cur;
        cur = tmp;
    }
}