LibSCVPGuard.cpp

Go to the documentation of this file.

#include "pkif.h" // to get PKIF's windows includes with all the same
                    // macros, etc.
#include "LibSCVPGuard.h"

#if !defined(WIN32)
#include <ltdl.h>
#endif

#include <cstring>

using namespace std;
class CLibSCVPGuardImpl
{
    public:
        CLibSCVPGuardImpl()
            :m_hSCVP(0),m_bInited(false),m_lastError(0)
        {
#ifdef WIN32
#ifdef _DEBUG
            m_hSCVP = LoadLibrary("PKIFSCVPd");
#else //WIN32 _DEBUG
            m_hSCVP = LoadLibrary("PKIFSCVP");
#endif //WIN32 !_DEBUG
            if(m_hSCVP) m_bInited = true;
#else
            int rv = lt_dlinit();
            if(rv) {
                SetLastError(lt_dlerror());
                return;
            }
            m_bInited = true;
            m_hSCVP = lt_dlopenext("libPKIFSCVP");
            if(!m_hSCVP) {
                SetLastError(lt_dlerror());
            }
#endif 
        }
        ~CLibSCVPGuardImpl()
        {
            if(m_lastError)
            {
                free(m_lastError);
                m_lastError = 0;
            }
#if !defined(WIN32)
            if(m_bInited) {
                if(m_hSCVP) {
                    int rv = lt_dlclose(m_hSCVP);
                    // if it couldn't be closed, don't bother trying
                    // to shut down libltdl.
                    if(rv == 0) {
                        m_hSCVP = 0;
                        lt_dlexit();
                    }
                }
            }
#endif 
        }

        const char * GetLastError()
        {
            return m_lastError;
        }

        bool IsSCVPAvailable()
        {
            return(m_hSCVP != 0);
        }

    private:
        void SetLastError(const char * err)
        {
            if(m_lastError) {
                free(m_lastError);
                m_lastError = 0;
            }
            if(err) m_lastError = strdup(err);
        }
#ifdef WIN32
        HMODULE m_hSCVP;
#else
        lt_dlhandle m_hSCVP;
#endif
        char * m_lastError;
        bool m_bInited;
};


class SCVPGuardCleaner
{
    public:
        ~SCVPGuardCleaner()
        {
            CLibSCVPGuard::Shutdown();
        }
} SCVPGuardCleanerInstance;
CLibSCVPGuardImpl * CLibSCVPGuard::m_impl = 0;
CLibSCVPGuard::CLibSCVPGuard()
{
    if(!m_impl) {
        m_impl = new CLibSCVPGuardImpl();
    }
}
CLibSCVPGuard::~CLibSCVPGuard()
{
}
void CLibSCVPGuard::Shutdown()
{
    if(m_impl) {
        delete m_impl;
        m_impl = 0;
    }
}
bool CLibSCVPGuard::IsSCVPAvailable()
{
    if(m_impl) {
        return m_impl->IsSCVPAvailable();
    }
    return false;
}
const char * CLibSCVPGuard::GetLoaderError()
{
    if(m_impl) {
        return m_impl->GetLastError();
    }
    return 0;
}