DistributionPointName.cpp

Go to the documentation of this file.

#include "DistributionPointName.h"
#include "GeneralName.h"
#include "GeneralNamesCompare.h"
#include "ASN1Helper.h"
#include "PKIX1Implicit88.h"
#include "PKIX1Explicit88.h"
#include "Name.h"
#include "ToolkitUtils.h"

#include <algorithm>


struct CPKIFDistributionPointNameImpl
{
  CPKIFGeneralNameList m_fullName;
  CACX509V3RDNSequence* m_relativeName;
  bool m_bNameRelativeToIssuerPresent;
};


CPKIFDistributionPointName::CPKIFDistributionPointName()
  :m_impl (new CPKIFDistributionPointNameImpl)
{
}
//CPKIFDistributionPointName::CPKIFDistributionPointName(
//  //! [in] Internal representation of the extension to use to construct the object
//  const CACX509V3DistributionPointName& name)
//  :m_impl (new CPKIFDistributionPointNameImpl)
//{
//  if(2 == name.t)
//  {
//      m_impl->m_bNameRelativeToIssuerPresent = true;
//      return;
//  }
//  else
//      m_impl->m_bNameRelativeToIssuerPresent = false;
//
//  DListNode* cur = name.u.fullName->head;
//  for(unsigned int ii = 0; ii < name.u.fullName->count; ++ii)
//  {
//      CPKIFGeneralNamePtr tmpGN(new CPKIFGeneralName(*(CACX509V3GeneralName*)cur->data));
//      m_impl->m_fullName.push_back(tmpGN);
//
//      cur = cur->next;
//  }
//}
CPKIFDistributionPointName::CPKIFDistributionPointName(
    const CPKIFBufferPtr& name)
  :m_impl (new CPKIFDistributionPointNameImpl)
{
    
    CACASNWRAPPER_CREATE(CACX509V3DistributionPointName, objPDU);
    objPDU.Decode(name->GetBuffer(), name->GetLength());

    if(2 == objPDU->t)
    {
        m_impl->m_bNameRelativeToIssuerPresent = true;

        m_impl->m_relativeName = new CACX509V3RDNSequence;
        m_impl->m_relativeName->head = NULL; m_impl->m_relativeName->tail = NULL;
        m_impl->m_relativeName->count = 0;

        DListNode* cur = NULL, *cur2 = objPDU->u.nameRelativeToCRLIssuer->head;
        ASN1OpenType* tmp = NULL, *tmp2 = NULL;
        
        //iterate over all of the RDN elements in the name passed as a parameter
        for(unsigned int ii = 0; ii < objPDU->u.nameRelativeToCRLIssuer->count; ++ii)
        {
            if(NULL == cur)
            {
                NEW_NODE(cur)
            }
            else
            {
                NEW_NEXT_AND_ADVANCE(cur)
            }

            //create an ASN1OpenType to hold the data
            //use tmp2 as a temporary pointer to the actual value to copy
            tmp = new ASN1OpenType;
            CACX509V3AttributeTypeAndValue* tmpATV = (CACX509V3AttributeTypeAndValue*)cur2->data;
            //CACASNWRAPPER_CREATE(CACX509V3AttributeTypeAndValue, atvEncoder);
            //tmp2 = atvEncoder.Encode(tmpATV);

            DList rdnList;
            DListNode rdnNode;
            rdnList.count = 1;
            rdnNode.data = tmpATV;
            rdnNode.next = NULL;
            rdnNode.prev = NULL;
            rdnList.head = &rdnNode;
            rdnList.tail = &rdnNode;
            CACASNWRAPPER_CREATE(CACX509V3RelativeDistinguishedName, rdnEncoder);
            tmp2 = rdnEncoder.Encode(&rdnList);

            //save the length, allocate a buffer and copy the data
            //throw bad_alloc
            tmp->numocts = tmp2->numocts;
            tmp->data = new unsigned char[tmp->numocts];
            memcpy((void*)tmp->data, tmp2->data, tmp->numocts);
            delete tmp2;

            cur->data = tmp;
            cur2 = cur2->next;

            //if(0 == m_impl->m_name->u.rdnSequence->count)
            
            //CHANGED FROM ABOVE 4/28/2004
            if(0 == m_impl->m_relativeName->head)
            {
                m_impl->m_relativeName->head = cur;
                m_impl->m_relativeName->tail = cur;
            }
            else
                m_impl->m_relativeName->tail = cur;
            ++m_impl->m_relativeName->count;
        }

        return;
    }
    else
    {
        m_impl->m_bNameRelativeToIssuerPresent = false;

        DListNode* cur = objPDU->u.fullName->head;
        for(unsigned int ii = 0; ii < objPDU->u.fullName->count; ++ii)
        {
            //CPKIFGeneralNamePtr tmpGN(new CPKIFGeneralName(*(CACX509V3GeneralName*)cur->data));
            //CPKIFBufferPtr tmpBuf(new CPKIFBuffer(((ASN1OpenType*)cur->data)->data, ((ASN1OpenType*)cur->data)->numocts));
            //CPKIFGeneralNamePtr tmpGN(new CPKIFGeneralName(tmpBuf));
            CACASNWRAPPER_CREATE(CACX509V3GeneralName, objPDU);
            ASN1OpenType* data1 = objPDU.Encode((CACX509V3GeneralName*)cur->data);
            CPKIFBufferPtr tmpBuf;
            if (data1 != NULL)
            {
                 tmpBuf = CPKIFBufferPtr(new CPKIFBuffer(data1->data, data1->numocts));
                delete data1;
            }
            CPKIFGeneralNamePtr tmpGN(new CPKIFGeneralName(tmpBuf));
                
            m_impl->m_fullName.push_back(tmpGN);

            cur = cur->next;
        }
    }
}
//commented out - 8/21/2004
//CPKIFDistributionPointName::CPKIFDistributionPointName(const CPKIFDistributionPointName& name)
//{
//}

CPKIFDistributionPointName::~CPKIFDistributionPointName()
{
    if(m_impl)
    {
        delete m_impl;
        m_impl = 0;
    }
}
bool CPKIFDistributionPointName::operator == (const CPKIFDistributionPointName& name)
{
    CPKIFGeneralNameList rhs;
    name.FullName(rhs);
    
    GeneralNamesCompare gnc;
    gnc.SetGeneralNames(&rhs);

    CPKIFGeneralNameList::iterator end = m_impl->m_fullName.end();
    if(end != std::find_if(m_impl->m_fullName.begin(), m_impl->m_fullName.end(), gnc))
        return true;
    else
        return false; //XXX-DEFER catch-all for failure to match relative to issuer
}
bool CPKIFDistributionPointName::NameRelativeToIssuerPresent() const 
{
    return m_impl->m_bNameRelativeToIssuerPresent;
}
void CPKIFDistributionPointName::FullName(
    CPKIFGeneralNameList& genNames) const
{
    genNames.clear();

    CPKIFGeneralNameList::const_iterator pos;
    CPKIFGeneralNameList::const_iterator end = m_impl->m_fullName.end();
    for(pos = m_impl->m_fullName.begin(); pos != end; ++pos)
    {
        genNames.push_back(*pos);
    }
}


struct CPKIFNameImpl
{
    CACX509V3Name* m_name;
    CPKIFStringPtr m_string;
    CPKIFBufferPtr m_encodedName; //added 8/26/2004
};


CPKIFNamePtr CPKIFDistributionPointName::GetRelativeNameAsFullName(CPKIFNamePtr& issuerName)
{
    CPKIFNamePtr newName(new CPKIFName(issuerName->Encoded()));

    DListNode* cur = newName->m_impl->m_name->u.rdnSequence->tail, *cur2 = m_impl->m_relativeName->head;
    ASN1OpenType* tmp = NULL, *tmp2 = NULL;

    for(unsigned int ii = 0; ii < m_impl->m_relativeName->count; ++ii)
    {
        if(NULL == cur)
        {
            NEW_NODE(cur)
        }
        else
        {
            NEW_NEXT_AND_ADVANCE(cur)
        }

        //create an ASN1OpenType to hold the data
        //use tmp2 as a temporary pointer to the actual value to copy
        tmp = new ASN1OpenType;
        tmp2 = (ASN1OpenType*)cur2->data;
        
        //save the length, allocate a buffer and copy the data
        //throw bad_alloc
        tmp->numocts = tmp2->numocts;
        tmp->data = new unsigned char[tmp->numocts];
        memcpy((void*)tmp->data, tmp2->data, tmp->numocts);

        cur->data = tmp;
        cur2 = cur2->next;

        //if(0 == m_impl->m_name->u.rdnSequence->count)
        
        //CHANGED FROM ABOVE 4/28/2004
        if(0 == newName->m_impl->m_name->u.rdnSequence->head)
        {
            newName->m_impl->m_name->u.rdnSequence->head = cur;
            newName->m_impl->m_name->u.rdnSequence->tail = cur;
        }
        else
            newName->m_impl->m_name->u.rdnSequence->tail = cur;
        ++newName->m_impl->m_name->u.rdnSequence->count;
    }

    return newName;
}