CPKIFPathProcessingMediator2.cpp

Go to the documentation of this file.

#include "CPKIFPathProcessingMediator2.h"

#include "boost/thread/recursive_mutex.hpp"

#include "ToolkitUtils.h"

#include "PKIFException.h"
#include "PKIFPathException.h"
#include "PKIFPathLogger.h"
#include "PKIFErrors.h"
//#include "PKIFPathErrors.h"
#include "PKIFPathValidator2.h"
#include "PKIFPathBuilder2.h"
#include "PKIFPathBuildAndValidate.h"
#include "ScopeGuard.h"
#include "PKIFLog.h"
#include "PKIFPathSettings.h"
#include "PKIFCertificatePath.h"
#include <vector>
using namespace std;
using namespace boost;
struct CPKIFPathProcessingMediator2Impl {

    CPKIFPathProcessingMediator2Impl ():m_me() 
    {
    };

    //CACMonitorDataPtr m_md;
    boost::recursive_mutex m_me;

    CPKIFPathSettingsPtr m_defPathSettings;
    //Every interface has its own vector for easy managment.
    std::vector<IPKIFColleaguePtr> m_vModules;
    //std::vector<IPKIFColleague*> m_vModulesToDelete;
    std::vector<IPKIFPathBuildPtr> m_vPathBuildModules;
    std::vector<IPKIFPathValidatePtr> m_vPathValidateModules;
    std::vector<IPKIFPathBuildAndValidatePtr> m_vPathBuildandValidateModules;

    bool m_addDefaultColleagues;
};

 CPKIFPathProcessingMediator2::CPKIFPathProcessingMediator2(
     bool addDefaultColleagues)
   : m_impl (new CPKIFPathProcessingMediator2Impl)
{
    LOG_STRING_DEBUG("CPKIFPathProcessingMediator2::CPKIFPathProcessingMediator2(void)", TOOLKIT_PATH_MEDIATOR, 0, this);
    m_impl->m_addDefaultColleagues = addDefaultColleagues;
}
 CPKIFPathProcessingMediator2::~CPKIFPathProcessingMediator2(void)
{
    LOG_STRING_DEBUG("CPKIFPathProcessingMediator2::~CPKIFPathProcessingMediator2(void)", TOOLKIT_PATH_MEDIATOR, 0, this);

    Terminate();

    delete m_impl;
    m_impl = '\0';
}

void CPKIFPathProcessingMediator2::Terminate()
{
    LOG_STRING_DEBUG("CPKIFPathProcessingMediator2::Terminate()", TOOLKIT_PATH_MEDIATOR, 0, this);

    //CCACSynchronizedObject so(m_impl->m_md);
    boost::recursive_mutex::scoped_lock(m_impl->m_me);
    try
    {
        //inform our children that we are dying
        RemoveParentRelationships(m_impl->m_vModules, this);

        RemoveMediatorAssociations();

        //clean up any modules that were added using AddColleague
//      FreeAdditionalModules(m_impl->m_vModulesToDelete, this);

        //added 7/17/2004
        IPKIFMediator::Terminate();

        m_impl->m_vModules.clear();
        m_impl->m_vPathBuildandValidateModules.clear();
        m_impl->m_vPathBuildModules.clear();
        m_impl->m_vPathValidateModules.clear();
    }
    catch(CPKIFException& )
    {
        //EXCEPTION DELETION
        //no purpose is served by passing on this exception - log it and forget it
        LOG_STRING_ERROR("CPKIFException encountered during CPKIFPathProcessingMediator2 mediator termination", thisComponent, COMMON_TERMINATION_ERROR, this);
        //delete e;
        _ASSERT(false);
    }
    catch(...)
    {
        LOG_STRING_ERROR("Unknown exception encountered during CPKIFPathProcessingMediator2 mediator termination", thisComponent, COMMON_TERMINATION_ERROR, this);
        _ASSERT(false);
    }
}

void CPKIFPathProcessingMediator2::Initialize()
{
    InitializeMediator(NULL);
}

void CPKIFPathProcessingMediator2::InitializeMediator(
    std::vector<CPKIFException*>* errorInfo)
{
    LOG_STRING_DEBUG("CPKIFPathProcessingMediator2::InitializeMediator(std::vector<CPKIFException*>* errorInfo)", TOOLKIT_PATH_MEDIATOR, 0, this);

    //CCACSynchronizedObject so(m_impl->m_md);
    boost::recursive_mutex::scoped_lock(m_impl->m_me);

    LOG_STRING_DEBUG("Initializing CPKIFPathProcessingMediator2 mediator", thisComponent, 0, this);

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

    if(m_impl->m_addDefaultColleagues)
    {
        CPKIFPathValidator2Ptr x1(new CPKIFPathValidator2);
        CPKIFPathBuilder2Ptr x2(new CPKIFPathBuilder2);
        CPKIFPathBuildAndValidatePtr x3(new CPKIFPathBuildAndValidate);
        // GCC doesn't see the result of the dynamic_pointer_cast as a reference when used
        // inside the function call
        IPKIFColleaguePtr cp = dynamic_pointer_cast<IPKIFColleague,CPKIFPathValidator2>(x1); 
        AddColleague(cp);
        cp = dynamic_pointer_cast<IPKIFColleague,CPKIFPathBuilder2>(x2);
        AddColleague(cp); 
        cp = dynamic_pointer_cast<IPKIFColleague,CPKIFPathBuildAndValidate>(x3);
        AddColleague(cp);  //changed x2 to x3 (there were two x2 objects added) 7/17/2004
    }
}

void CPKIFPathProcessingMediator2::AddColleague(
    IPKIFColleaguePtr& module)
{
    LOG_STRING_DEBUG("CPKIFPathProcessingMediator2::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(!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);
        if(dynamic_pointer_cast<IPKIFPathBuild, IPKIFColleague>(module))
            m_impl->m_vPathBuildModules.push_back(dynamic_pointer_cast<IPKIFPathBuild, IPKIFColleague>(module));
        if(dynamic_pointer_cast<IPKIFPathValidate, IPKIFColleague>(module))
            m_impl->m_vPathValidateModules.push_back(dynamic_pointer_cast<IPKIFPathValidate, IPKIFColleague>(module));
        if(dynamic_pointer_cast<IPKIFPathBuildAndValidate, IPKIFColleague>(module))
            m_impl->m_vPathBuildandValidateModules.push_back(dynamic_pointer_cast<IPKIFPathBuildAndValidate, IPKIFColleague>(module));
//      guard.Dismiss();
    }
    catch(...)
    {
        throw;
    }
}

void CPKIFPathProcessingMediator2::SetDefaultPathSettings(
    CPKIFPathSettingsPtr& pathSettings)
{
    LOG_STRING_DEBUG("CPKIFPathProcessingMediator2::SetDefaultPathSettings(CPKIFPathSettingsPtr& pathSettings)", TOOLKIT_PATH_MEDIATOR, 0, this);

    //CCACSynchronizedObject so(m_impl->m_md);
    boost::recursive_mutex::scoped_lock(m_impl->m_me);
    m_impl->m_defPathSettings = pathSettings;
}

CPKIFPathSettingsPtr CPKIFPathProcessingMediator2::GetDefaultPathSettings()
{
    LOG_STRING_DEBUG("CPKIFPathProcessingMediator2::GetDefaultPathSettings", TOOLKIT_PATH_MEDIATOR, 0, this);

    //CCACSynchronizedObject so(m_impl->m_md);
    boost::recursive_mutex::scoped_lock(m_impl->m_me);
    //always hand back copies
    if(m_impl->m_defPathSettings != (CPKIFPathSettings*)NULL)
    {
        CPKIFPathSettingsPtr ps(new CPKIFPathSettings(*m_impl->m_defPathSettings));
        return ps;
    }
    else
    {
        //return a permissive set
        CPKIFPathSettingsPtr tmp(new CPKIFPathSettings);
        return tmp;
    }
}

//GENERAL PHILOSOPHY OF FOLLOWING FUNCTIONS
//  This mediator catches all exceptions that emanate from lower-level PKIF objects.  Exception
//contents are recorded in the audit log but the exceptions are NOT throw to the application.  The
//application will remain unaware of the exception.  This allows other colleagues an opportunity to
//satisfy the request.  In the event that an unsatisfied request results in the failure of
//a higher level operation, the application will be notified of the higher level failure, possibly
//by an exception.  If no colleague supports the requested operation an exception is thrown indicating
//that the operation was not handled.

bool CPKIFPathProcessingMediator2::ValidatePath(
    CPKIFCertificatePath& path, 
    CPKIFPathValidationResults& results,
    CPKIFFuncStoragePtr& thisCallOnlyFuncs)
{
    LOG_STRING_DEBUG("CPKIFPathProcessingMediator2::ValidatePath", TOOLKIT_PATH_MEDIATOR, 0, this);

    //CCACSynchronizedObject so(m_impl->m_md);
    boost::recursive_mutex::scoped_lock(m_impl->m_me);
    //if there has been no path settings directly associated with the path that was passed in then
    //use the default settings associated with this instance.  if there are no settings associated with
    //this instance use a very permissive default collection of settings (created by GetDefaultPathSettings).
    CPKIFPathSettingsPtr settings;
    path.GetPathSettings(settings);
    if(settings == (CPKIFPathSettings*)NULL)
        path.SetPathSettings(GetDefaultPathSettings());

    bool retVal = false;
    vector<IPKIFPathValidatePtr>::iterator pos;
    vector<IPKIFPathValidatePtr>::iterator end = m_impl->m_vPathValidateModules.end();
    bool opAttempted = false;
    for(pos = m_impl->m_vPathValidateModules.begin(); pos != end; ++pos)
    {
            try
            {
                opAttempted = true;
                retVal = (*pos)->ValidatePath(path, results, thisCallOnlyFuncs);
                CPKIFPathLogger::LogValidationResults(results, path, "Logging path following completion of validation operation");
                AuditPathEvent(PO_VALIDATE, retVal, path);

                //if we get here then the colleague reached a decision (lack of determination should
                //be indicated by an exception. This may need some tweaking when SCVP rolls around.)
                return retVal;
            }
            catch(CPKIFException& e)
            {
                CPKIFPathLogger::LogPath(path, "Logging path following unexpected exception during validation operation");

                std::string reason = "A path processing-related exception was thrown.  ";
                reason.append(*e.print());
                AuditString(EVENTLOG_WARNING_TYPE, CAT_PKIF_PATH, PKIF_UNEXPECTED_EXCEPTION, reason.c_str(), thisComponent, COMMON_UNKNOWN_ERROR, this);
                //delete e;
            }
    }

    if(!opAttempted)
        throw CPKIFPathException(thisComponent, COMMON_OPERATION_NOT_HANDLED);

    return retVal;
}

void CPKIFPathProcessingMediator2::SetAdditionalCertificateChecks(
    CPKIFFuncStoragePtr& funcs)
{
    LOG_STRING_DEBUG("CPKIFPathProcessingMediator2::SetAdditionalCertificateChecks", TOOLKIT_PATH_MEDIATOR, 0, this);

    //CCACSynchronizedObject so(m_impl->m_md);
    boost::recursive_mutex::scoped_lock(m_impl->m_me);
    bool retVal = false;
    vector<IPKIFPathValidatePtr>::iterator pos;
    vector<IPKIFPathValidatePtr>::iterator end = m_impl->m_vPathValidateModules.end();
    bool opAttempted = false, opSucceeded = false;
    for(pos = m_impl->m_vPathValidateModules.begin(); pos != end; ++pos)
    {
            try
            {
                opAttempted = true;
                (*pos)->SetAdditionalCertificateChecks(funcs);
                opSucceeded = true;
            }
            catch(CPKIFException& e)
            {
                std::string reason = "A path processing-related exception was thrown.  ";
                reason.append(*e.print());
                AuditString(EVENTLOG_WARNING_TYPE, CAT_PKIF_PATH, PKIF_UNEXPECTED_EXCEPTION, reason.c_str(), thisComponent, COMMON_UNKNOWN_ERROR, this);
                //delete e;
            }
    }

    if(!opAttempted)
        throw CPKIFPathException(thisComponent, COMMON_OPERATION_NOT_HANDLED);

    if(!opSucceeded)
        throw CPKIFPathException(thisComponent, COMMON_OPERATION_NOT_SUCCESSFUL);//changed from Cache exception 2/17/2004
}

bool CPKIFPathProcessingMediator2::BuildPath(
    CPKIFCertificatePath& path)
{
    LOG_STRING_DEBUG("CPKIFPathProcessingMediator2::BuildPath", TOOLKIT_PATH_MEDIATOR, 0, this);

    //CCACSynchronizedObject so(m_impl->m_md);
    boost::recursive_mutex::scoped_lock(m_impl->m_me);
    //if there has been no path settings directly associated with the path that was passed in then
    //use the default settings associated with this instance.  if there are no settings associated with
    //this instance use a very permissive default collection of settings (created by GetDefaultPathSettings).
    CPKIFPathSettingsPtr settings;
    path.GetPathSettings(settings);
    if(settings == (CPKIFPathSettings*)NULL)
        path.SetPathSettings(GetDefaultPathSettings());

    bool retVal = false;
    vector<IPKIFPathBuildPtr>::iterator pos;
    vector<IPKIFPathBuildPtr>::iterator end = m_impl->m_vPathBuildModules.end();
    bool opAttempted = false, opSucceeded = false;
    for(pos = m_impl->m_vPathBuildModules.begin(); pos != end; ++pos)
    {
            try
            {
                opAttempted = true;
                retVal = (*pos)->BuildPath(path);
                opSucceeded = true;
                AuditPathEvent(PO_BUILD, retVal, path);

                //unlike validation operations - when builders return false we keep looking
                if(retVal)
                    return retVal;
            }
            catch(CPKIFException& e)
            {
                std::string reason = "A path processing-related exception was thrown.  ";
                reason.append(*e.print());
                AuditString(EVENTLOG_WARNING_TYPE, CAT_PKIF_PATH, PKIF_UNEXPECTED_EXCEPTION, reason.c_str(), thisComponent, COMMON_UNKNOWN_ERROR, this);
                //delete e;
            }
    }

    if(!opAttempted)
        throw CPKIFPathException(thisComponent, COMMON_OPERATION_NOT_HANDLED);

    if(!opSucceeded)
        throw CPKIFPathException(thisComponent, COMMON_OPERATION_NOT_SUCCESSFUL); //changed from Cache - 2/17/2004

    return retVal;
}

bool CPKIFPathProcessingMediator2::BuildAndValidatePath(
    CPKIFCertificatePath& path, 
    CPKIFPathValidationResults& results)
{
    LOG_STRING_DEBUG("CPKIFPathProcessingMediator2::BuildAndValidatePath", TOOLKIT_PATH_MEDIATOR, 0, this);

    //CCACSynchronizedObject so(m_impl->m_md);
    boost::recursive_mutex::scoped_lock(m_impl->m_me);
    //if there has been no path settings directly associated with the path that was passed in then
    //use the default settings associated with this instance.  if there are no settings associated with
    //this instance use a very permissive default collection of settings (created by GetDefaultPathSettings).
    CPKIFPathSettingsPtr settings;
    path.GetPathSettings(settings);
    if(settings == (CPKIFPathSettings*)NULL)
        path.SetPathSettings(GetDefaultPathSettings());

    bool retVal = false;
    vector<IPKIFPathBuildAndValidatePtr>::iterator pos;
    vector<IPKIFPathBuildAndValidatePtr>::iterator end = m_impl->m_vPathBuildandValidateModules.end();
    bool opAttempted = false;
    for(pos = m_impl->m_vPathBuildandValidateModules.begin(); pos != end; ++pos)
    {
            try
            {
                opAttempted = true;
                if((*pos)->BuildAndValidatePath(path, results))
                {
                    retVal = true;
                    break;
                }
            }
            catch(CPKIFException& e)
            {
                CPKIFPathLogger::LogPath(path, "Logging path following unexpected exception during build and validation operation");

                std::string reason = "A path processing-related exception was thrown.  ";
                reason.append(*e.print());
                AuditString(EVENTLOG_WARNING_TYPE, CAT_PKIF_PATH, PKIF_UNEXPECTED_EXCEPTION, reason.c_str(), thisComponent, COMMON_UNKNOWN_ERROR, this);
                //delete e;
            }
    
    }

    if(!opAttempted)
        throw CPKIFPathException(thisComponent, COMMON_OPERATION_NOT_HANDLED);

    return retVal;
}
void CPKIFPathProcessingMediator2::GetColleagues(
    std::vector<IPKIFColleaguePtr>& v) const
{
    copy(m_impl->m_vModules.begin(),m_impl->m_vModules.end(), back_inserter(v));
}