IssuingDistributionPoint.cpp

Go to the documentation of this file.

#include "IssuingDistributionPoint.h"
#include "DistributionPointName.h"
#include "OID.h"
#include "Buffer.h"
#include "PKIFException.h"

#include "ASN1Helper.h"
#include "PKIX1Implicit88.h"
#include "PKIX1Explicit88.h"


struct CPKIFIssuingDistributionPointImpl
{
    bool m_bOnlyUserCerts;
    bool m_bOnlyAuthCerts;
    bool m_bOnlySomeReasons;
    bool m_bIndirectCRL;
    bool m_bOnlyAttrCerts;
    CPKIFReasonFlagsPtr m_reasons;
    CPKIFDistributionPointNamePtr m_dp;
    CPKIFBufferPtr m_value;
    bool m_extModified;
};


char CPKIFIssuingDistributionPoint::extOID[] =  "2.5.29.28";

//DOCUMENT LATER
CPKIFIssuingDistributionPoint::CPKIFIssuingDistributionPoint()
  : m_impl (new CPKIFIssuingDistributionPointImpl)
{
    m_impl->m_bOnlyUserCerts = false;
    m_impl->m_bOnlyAuthCerts = false;
    m_impl->m_bOnlySomeReasons = false;
    m_impl->m_bIndirectCRL = false;
    m_impl->m_bOnlyAttrCerts = false;
}
//CPKIFIssuingDistributionPoint::CPKIFIssuingDistributionPoint(
//  //![in] Reference to an internal structure representation of the extension containing information used to construct the object
//  const CACX509V3Extension& ext) 
//  : CPKIFX509Extension(ext), m_impl (new CPKIFIssuingDistributionPointImpl)
//{
//  CACASNWRAPPER_CREATE(CACX509V3IssuingDistributionPoint, objPDU);
//  objPDU.Decode(ext.extnValue.data, ext.extnValue.numocts);
//
//  m_impl->m_bIndirectCRL = FALSE == objPDU->indirectCRL ? false : true;
//  m_impl->m_bOnlyUserCerts = FALSE == objPDU->onlyContainsUserCerts ? false : true;
//  m_impl->m_bOnlyAuthCerts = FALSE == objPDU->onlyContainsCACerts ? false : true;
//  m_impl->m_bOnlySomeReasons = objPDU->m.onlySomeReasonsPresent;
//
//  //updated 12/3/2003
//  m_impl->m_bOnlyAttrCerts = FALSE == objPDU->onlyContainsAttributeCerts ? false : true;
//
//  if(objPDU->m.distributionPointPresent)
//  {
//      CPKIFDistributionPointNamePtr tmp(new CPKIFDistributionPointName(objPDU->distributionPoint));
//      m_impl->m_dp = tmp;
//  }
//}

CPKIFIssuingDistributionPoint::CPKIFIssuingDistributionPoint(
    const bool& criticality,
    const CPKIFBufferPtr& ext) 
  : CPKIFX509Extension (criticality, ext), m_impl (new CPKIFIssuingDistributionPointImpl)
{
    CACASNWRAPPER_CREATE(CACX509V3IssuingDistributionPoint, objPDU);
    objPDU.Decode(ext->GetBuffer(), ext->GetLength());

    m_impl->m_bIndirectCRL = FALSE == objPDU->indirectCRL ? false : true;
    m_impl->m_bOnlyUserCerts = FALSE == objPDU->onlyContainsUserCerts ? false : true;
    m_impl->m_bOnlyAuthCerts = FALSE == objPDU->onlyContainsCACerts ? false : true;
    m_impl->m_bOnlySomeReasons = objPDU->m.onlySomeReasonsPresent;
    if(m_impl->m_bOnlySomeReasons)
    {
        CPKIFReasonFlagsPtr newRF(new CPKIFReasonFlags);
        if( objPDU->onlySomeReasons.data[BytXCACX509V3unused] & BitMCACX509V3unused ) 
            newRF->SetUnused();
        if( objPDU->onlySomeReasons.data[BytXCACX509V3keyCompromise ] & BitMCACX509V3keyCompromise) 
            newRF->SetKeyCompromise();
        if( objPDU->onlySomeReasons.data[BytXCACX509V3cACompromise ] & BitMCACX509V3cACompromise) 
            newRF->SetCACompromise();
        if( objPDU->onlySomeReasons.data[BytXCACX509V3affiliationChanged] &  BitMCACX509V3affiliationChanged) 
            newRF->SetAffiliationChanged();
        if( objPDU->onlySomeReasons.data[BytXCACX509V3superseded] & BitMCACX509V3superseded ) 
            newRF->SetSuperseded();
        if( objPDU->onlySomeReasons.data[BytXCACX509V3cessationOfOperation] & BitMCACX509V3cessationOfOperation ) 
            newRF->SetCessationOfOperation();
        if( objPDU->onlySomeReasons.data[BytXCACX509V3certificateHold] & BitMCACX509V3certificateHold ) 
            newRF->SetCertificateHold();
        if( objPDU->onlySomeReasons.data[BytXCACX509V3privilegeWithdrawn] & BitMCACX509V3privilegeWithdrawn ) 
            newRF->SetPrivilegeWithdrawn();
        if(objPDU->onlySomeReasons.numbits > 8)
        {
            if( objPDU->onlySomeReasons.data[BytXCACX509V3aACompromise] & BitMCACX509V3aACompromise ) 
                newRF->SetAACompromise();
        }

        m_impl->m_reasons = newRF;
    }

    //updated 12/3/2003
    m_impl->m_bOnlyAttrCerts = FALSE == objPDU->onlyContainsAttributeCerts ? false : true;

    if(objPDU->m.distributionPointPresent)
    {
        CPKIFBufferPtr tmpBuf(new CPKIFBuffer(objPDU->distributionPoint.data, objPDU->distributionPoint.numocts));
        CPKIFDistributionPointNamePtr tmp(new CPKIFDistributionPointName(tmpBuf));
        m_impl->m_dp = tmp;
    }

    m_impl->m_value = ext;
    m_impl->m_extModified = false;
}

CPKIFDistributionPointNamePtr CPKIFIssuingDistributionPoint::DistributionPoint() const {return m_impl->m_dp;}
bool CPKIFIssuingDistributionPoint::OnlyContainsUserCerts() const {return m_impl->m_bOnlyUserCerts;}
bool CPKIFIssuingDistributionPoint::OnlyContainsAuthorityCerts() const {return m_impl->m_bOnlyAuthCerts;}
bool CPKIFIssuingDistributionPoint::OnlySomeReasons() const {return m_impl->m_bOnlySomeReasons;}
bool CPKIFIssuingDistributionPoint::IndirectCRL() const {return m_impl->m_bIndirectCRL;}
bool CPKIFIssuingDistributionPoint::OnlyContainsAttributeCerts() const {return m_impl->m_bOnlyAttrCerts;}
bool CPKIFIssuingDistributionPoint::operator==(
    const CPKIFIssuingDistributionPoint& idp)
{
    if(OnlyContainsUserCerts() != idp.OnlyContainsUserCerts())
        return false;
    if(OnlyContainsAuthorityCerts() != idp.OnlyContainsAuthorityCerts())
        return false;
    if(OnlySomeReasons() != idp.OnlySomeReasons())
        return false;
    if(IndirectCRL() != idp.IndirectCRL())
        return false;
    if(OnlyContainsAttributeCerts() != idp.OnlyContainsAttributeCerts())
        return false;

    CPKIFDistributionPointNamePtr rhsDP = idp.DistributionPoint();
    if(m_impl->m_dp == (CPKIFDistributionPointName*)NULL && rhsDP != (CPKIFDistributionPointName*)NULL)
        return false;
    else if(m_impl->m_dp != (CPKIFDistributionPointName*)NULL && rhsDP == (CPKIFDistributionPointName*)NULL)
        return false;
    else if(m_impl->m_dp == (CPKIFDistributionPointName*)NULL && rhsDP == (CPKIFDistributionPointName*)NULL)//added 5/3/2004
        return true;
    else if(!(*m_impl->m_dp == *rhsDP))
        return false;

    return true;
}
CPKIFIssuingDistributionPoint::~CPKIFIssuingDistributionPoint()
{
    if(m_impl)
    {
        delete m_impl; m_impl = NULL;
    }
}
const CPKIFOIDPtr CPKIFIssuingDistributionPoint::oid() const
{
    //added static variable for copying instead of string creation each call
    static CPKIFOID staticOID(extOID);
    //CPKIFOIDPtr tmp(new CPKIFOID(new std::string(extOID)));
    static CPKIFOIDPtr tmp(new CPKIFOID(staticOID));
    return tmp;
}
CPKIFReasonFlagsPtr CPKIFIssuingDistributionPoint::GetReasons() const
{
    return m_impl->m_reasons;
}

CPKIFBufferPtr CPKIFIssuingDistributionPoint::value() const 
{
    CPKIFBufferPtr rv = m_impl->m_value;
    if(m_impl->m_value == (CPKIFBuffer*)NULL || m_impl->m_extModified)
    {
        //XXX ENCODE HERE and set rv if necessary 
    }

    return rv;
}