PKIFCMSAttributeMediator2.cpp

Go to the documentation of this file.

#include "PKIFCMSAttributeMediator2.h"
#include "ToolkitUtils.h"
#include "PKIFMessageException.h"
#include "ASN1Helper.h"
#include "ContentTypeAttributeFactory.h"
#include "MessageDigestAttributeFactory.h"
#include "SigningTimeAttributeFactory.h"
#include "CountersignatureAttributeFactory.h"
#include "TimestampAttributeFactory.h"
#include "BinarySigningTimeAttributeFactory.h"
#include "SigningCertificateAttributeFactory.h"
#include "OID.h"
#include "Buffer.h"
#include <map>
#include "ScopeGuard.h"
#include "boost/thread/recursive_mutex.hpp"

#include "CryptographicMessageSyntax2004.h"
#include "ContentCollectionModule.h"

using namespace std;

static void CMSFreeAdditionalModules(
    std::vector<IPKIFColleague*>& modules, 
    IPKIFMediator* mediator)
{
    vector<IPKIFColleague*>::iterator pos;
    vector<IPKIFColleague*>::iterator end = modules.end();
    for(pos = modules.begin(); pos != end; ++pos)
    {
        try
        {
            (*pos)->RemoveParent(mediator);
            delete (*pos);
        }
        catch(...)
        {
//          _ASSERT(false);
        }
    }

    modules.clear();//added 04/21/2003 CRW
}

CPKIFCMSAttributeMediator2 * CPKIFCMSAttributeMediator2::m_hInstance = 0;
struct CPKIFCMSAttributeMediator2Impl
{
    enum {thisComponent=TOOLKIT_MESSAGE_ATTR_MEDIATOR};

    //T m_modules;
    std::vector<IPKIFColleague*> m_vModules;
    std::vector<IPKIFColleague*> m_vModulesToDelete;
    boost::recursive_mutex m_me;
};

CPKIFCMSAttributeMediator2 * CPKIFCMSAttributeMediator2::GetInstance(void)
{
    if(m_hInstance) return m_hInstance;
    m_hInstance = new CPKIFCMSAttributeMediator2();
    m_hInstance->InitializeMediator(0);
    m_hInstance->Initialize(0);
    return m_hInstance;
}

CPKIFCMSAttributeMediator2::CPKIFCMSAttributeMediator2(void)
    :m_impl (new CPKIFCMSAttributeMediator2Impl)
{
    LOG_STRING_DEBUG("CPKIFCMSAttributeMediator2::CPKIFCMSAttributeMediator2", TOOLKIT_CRYPTO_MISC, 0, this);
}

CPKIFCMSAttributeMediator2::~CPKIFCMSAttributeMediator2(void)
{
    LOG_STRING_DEBUG("CPKIFCMSAttributeMediator2::~CPKIFCMSAttributeMediator2", TOOLKIT_CRYPTO_MISC, 0, this);
    try
    {
        //clean up any modules that were added using AddColleague
        Terminate();
    }
    catch(...)
    {
        _ASSERT(false);
    }

    delete m_impl;
    m_impl = NULL;
}

void CPKIFCMSAttributeMediator2::Terminate()
{
    m_impl->m_vModules.clear();
    CMSFreeAdditionalModules(m_impl->m_vModulesToDelete, this);
}

#define CMS_ATTRIBUTE_MEDIATOR_ALREADY_INITIALIZED 1

void CPKIFCMSAttributeMediator2::Initialize(
    std::vector<CPKIFException*>* errorInfo)
{
    LOG_STRING_DEBUG("CPKIFCMSAttributeMediator2::Initialize", TOOLKIT_CRYPTO_MISC, 0, this);

    if(!m_impl->m_vModules.empty())
        throw CPKIFMessageException(TOOLKIT_MESSAGE_ATTR_MEDIATOR, COMMON_ALREADY_INITIALIZED, "This instance has already been initialized.  Call Terminate prior to re-initializing.");

    //populate the m_vModules vector with any modules that were configured at compile-time
    //error information will be collected in the errorInfo parameter if desired
    /*if(NULL != errorInfo)
        PopulateVectorFunc(m_modules, this, m_vModules, *errorInfo);
    else
    {
        std::vector<CPKIFException*> ei;
        PopulateVectorFunc(m_modules, this, m_vModules, ei);
    }*/

    IPKIFColleague* x1 = new CPKIFContentTypeAttributeFactory();
    x1->Initialize();
    x1->AddParent(this);
    m_impl->m_vModules.push_back(x1);
    m_impl->m_vModulesToDelete.push_back(x1);

    IPKIFColleague* x2 = new CPKIFMessageDigestAttributeFactory();
    x2->Initialize();
    x2->AddParent(this);
    m_impl->m_vModules.push_back(x2);
    m_impl->m_vModulesToDelete.push_back(x2);

    IPKIFColleague* x3 = new CPKIFSigningTimeAttributeFactory();
    x3->Initialize();
    x3->AddParent(this);
    m_impl->m_vModules.push_back(x3);
    m_impl->m_vModulesToDelete.push_back(x3);

    IPKIFColleague* x4 = new CPKIFCountersignatureAttributeFactory();
    x4->Initialize();
    x4->AddParent(this);
    m_impl->m_vModules.push_back(x4);
    m_impl->m_vModulesToDelete.push_back(x4);

    IPKIFColleague* x5 = new CPKIFTimestampAttributeFactory();
    x5->Initialize();
    x5->AddParent(this);
    m_impl->m_vModules.push_back(x5);
    m_impl->m_vModulesToDelete.push_back(x5);

    IPKIFColleague* x6 = new CPKIFBinarySigningTimeAttributeFactory();
    x6->Initialize();
    x6->AddParent(this);
    m_impl->m_vModules.push_back(x6);
    m_impl->m_vModulesToDelete.push_back(x6);

    IPKIFColleague* x7 = new CPKIFSigningCertificateAttributeFactory();
    x7->Initialize();
    x7->AddParent(this);
    m_impl->m_vModules.push_back(x7);
    m_impl->m_vModulesToDelete.push_back(x7);
}


/*

CPKIFAttributePtr CPKIFCMSAttributeMediator2::getAttribute(
    CACCMSAttribute& refAttribute)
{
    LOG_STRING_DEBUG("CPKIFCMSAttributeMediator2::getAttribute", TOOLKIT_CRYPTO_MISC, 0, this);

    CPKIFOID oid(refAttribute.attrType);

    vector<IPKIFColleague*>::iterator pos;
    vector<IPKIFColleague*>::iterator end = m_impl->m_vModules.end();
    IPKIFCMSAttributeFactory* ext = NULL;
    for(pos = m_impl->m_vModules.begin(); pos != end; ++pos)
    {
        ext = dynamic_cast<IPKIFCMSAttributeFactory*>(*pos);
        if(NULL != ext && oid == ext->refOID())
        {
            try
            {
                CPKIFAttributePtr tmp = ext->create(refAttribute); 
                return tmp;
            }
            catch(...)
            {
                //break out and try to create the attribute in a plain empty shell
                //if that fails let the exception get thrown to the caller
                break;
            }
        }
    }

    CPKIFAttributePtr tmpAttrPtr(new CPKIFAttribute(refAttribute));
    return tmpAttrPtr;
}
*/

CPKIFAttributePtr CPKIFCMSAttributeMediator2::getAttribute(
    CPKIFOIDPtr oid,
    CPKIFBufferPtr buf)
{
    LOG_STRING_DEBUG("CPKIFCMSAttributeMediator2::getAttribute", TOOLKIT_CRYPTO_MISC, 0, this);

    //CPKIFOID oid(refAttribute.attrType);

    vector<IPKIFColleague*>::iterator pos;
    vector<IPKIFColleague*>::iterator end = m_impl->m_vModules.end();
    IPKIFCMSAttributeFactory* ext = NULL;
    for(pos = m_impl->m_vModules.begin(); pos != end; ++pos)
    {
        ext = dynamic_cast<IPKIFCMSAttributeFactory*>(*pos);
        if(NULL != ext && *oid == ext->refOID()) //oid == ext->refOID())
        {
            try
            {
                CPKIFAttributePtr tmp = ext->create(buf); 
                return tmp;
            }
            catch(...)
            {
                //break out and try to create the attribute in a plain empty shell
                //if that fails let the exception get thrown to the caller
                break;
            }
        }
    }

    CPKIFAttributePtr tmpAttrPtr(new CPKIFAttribute(oid, buf));
    return tmpAttrPtr;
}


void CPKIFCMSAttributeMediator2::ParseAttributes (
     CPKIFBufferPtr& buf, 
     std::vector<CPKIFAttributePtr>& attrVector)
{
  if (!buf || buf->GetLength() == 0)
    return;

  // Signed, unsigned, auth, unauthed, unprotected attributes
  // are typedef as DLists of CACCMSAttribute, so we should
  // be able to use the following wrapper object for all attribute types.
  CACASNWRAPPER_CREATE(CACCMSSignedAttributes, attrWrapper);
  CACCMSSignedAttributes *attrList = attrWrapper.Decode(buf->GetBuffer(), buf->GetLength());

  if (attrList->count == 0)
    return;
  
  // Build a colleague look-up table using OIDs as keys
  std::map<std::string, IPKIFCMSAttributeFactory*> OIDMap;
  std::string *OIDStrings = new std::string[m_impl->m_vModules.size ()];    
  int index = 0;

  vector<IPKIFColleague*>::iterator pos;
  vector<IPKIFColleague*>::iterator end = m_impl->m_vModules.end();
  for(pos = m_impl->m_vModules.begin(); pos != end; ++pos)
  {
    IPKIFCMSAttributeFactory *attrFactory = dynamic_cast<IPKIFCMSAttributeFactory*>(*pos);
    
    if (attrFactory)
    {
      OIDStrings[index] = attrFactory->refOID();
      OIDMap[OIDStrings[index]] = attrFactory;
      ++index;
    }
  }
 
  //iterate over the list of attributes and populate the attributes vector
  DListNode* cur = attrList->head;
  for(unsigned int i = 0; i < attrList->count; ++i)
  {
    CACCMSAttribute *attr = static_cast<CACCMSAttribute*>(cur->data);
    CPKIFOIDPtr cpkifOIDPtr (new CPKIFOID (attr->attrType.subid, attr->attrType.numids));
    std::string OID = cpkifOIDPtr->ToString();
    std::map<std::string, IPKIFCMSAttributeFactory*>::iterator itr = OIDMap.find (OID);

    CPKIFBufferPtr anAttrBuf (new CPKIFBuffer (attr->attrValues.data, attr->attrValues.numocts));

    if (itr != OIDMap.end ()) 
    {
      // Use the colleague to parse the extension
      CPKIFAttributePtr anAttrPtr = (*itr).second->create (anAttrBuf);
      attrVector.push_back (anAttrPtr);
    } 
    else 
    { 
      // instantiate default Attribute
      CPKIFAttributePtr anAttrPtr(new CPKIFAttribute(anAttrBuf));
      anAttrPtr->SetOID(cpkifOIDPtr);
      attrVector.push_back (anAttrPtr); 
    }

    cur = cur->next;
  }

  delete [] OIDStrings;
}
void CPKIFCMSAttributeMediator2::ParseAttributes2 (
     CPKIFBufferPtr& buf, 
     std::vector<CPKIFAttributePtr>& attrVector)
{
  if (!buf || buf->GetLength() == 0)
    return;

  // Signed, unsigned, auth, unauthed, unprotected attributes
  // are typedef as DLists of CACCMSAttribute, so we should
  // be able to use the following wrapper object for all attribute types.
  CACASNWRAPPER_CREATE(ContentWithAttributes_attrs, attrWrapper);
  ContentWithAttributes_attrs *attrList = attrWrapper.Decode(buf->GetBuffer(), buf->GetLength());

  if (attrList->count == 0)
    return;
  
  // Build a colleague look-up table using OIDs as keys
  std::map<std::string, IPKIFCMSAttributeFactory*> OIDMap;
  std::string *OIDStrings = new std::string[m_impl->m_vModules.size ()];    
  int index = 0;

  vector<IPKIFColleague*>::iterator pos;
  vector<IPKIFColleague*>::iterator end = m_impl->m_vModules.end();
  for(pos = m_impl->m_vModules.begin(); pos != end; ++pos)
  {
    IPKIFCMSAttributeFactory *attrFactory = dynamic_cast<IPKIFCMSAttributeFactory*>(*pos);
    
    if (attrFactory)
    {
      OIDStrings[index] = attrFactory->refOID();
      OIDMap[OIDStrings[index]] = attrFactory;
      ++index;
    }
  }
 
  //iterate over the list of attributes and populate the attributes vector
  DListNode* cur = attrList->head;
  for(unsigned int i = 0; i < attrList->count; ++i)
  {
    CACCMSAttribute *attr = static_cast<CACCMSAttribute*>(cur->data);
    CPKIFOIDPtr cpkifOIDPtr (new CPKIFOID (attr->attrType.subid, attr->attrType.numids));
    std::string OID = cpkifOIDPtr->ToString();
    std::map<std::string, IPKIFCMSAttributeFactory*>::iterator itr = OIDMap.find (OID);

    CPKIFBufferPtr anAttrBuf (new CPKIFBuffer (attr->attrValues.data, attr->attrValues.numocts));

    if (itr != OIDMap.end ()) 
    {
      // Use the colleague to parse the extension
      CPKIFAttributePtr anAttrPtr = (*itr).second->create (anAttrBuf);
      attrVector.push_back (anAttrPtr);
    } 
    else 
    { 
      // instantiate default Attribute
      CPKIFAttributePtr anAttrPtr(new CPKIFAttribute(anAttrBuf));
      anAttrPtr->SetOID(cpkifOIDPtr);
      attrVector.push_back (anAttrPtr); 
    }

    cur = cur->next;
  }

  delete [] OIDStrings;
}
void CPKIFCMSAttributeMediator2::AddColleague(
    IPKIFColleague* module,
    bool transferOwnership)
{
    LOG_STRING_DEBUG("CPKIFX509ExtensionMediator2::AddColleague(IPKIFColleague* module, bool transferOwnership)", TOOLKIT_PATH_MEDIATOR, 0, this);

    //CCACSynchronizedObject so(m_impl->m_md);
    boost::recursive_mutex::scoped_lock(m_impl->m_me);
    if(NULL == module)
        return;

    //if the module throws an exception let the caller catch it
    module->Initialize();
    module->AddParent(this);//added 3/12/2003 CRW

    try
    {
        //set upa n array of pointers that we will need to delete
        if(transferOwnership)
            m_impl->m_vModulesToDelete.push_back(module);

        //create a guard on the vector so if the push onto the primary vector fails we can
        //pop the one off of m_impl->m_vModulesToDelete
        ScopeGuard guard = MakeObjGuard(m_impl->m_vModulesToDelete, &vector<IPKIFColleague*>::pop_back);
        m_impl->m_vModules.push_back(module);
        guard.Dismiss();
    }
    catch(...)
    {
        throw;
    }
}