OBTPlugin.cpp

Go to the documentation of this file.

#include "OBTPlugin.h"
#include "OBTPluginInformation.h"
#include "OBT_ASSERT.h"

#include <sys/stat.h>
#ifndef _MSC_VER
#include "dlfcn.h"
#endif

using namespace OBT ;

//-------------------------------------------------------------------------
// Plugin()
//-------------------------------------------------------------------------
Plugin::Plugin( const char* path, const char* name, const char* configurationFile )
:
_pluginHandle( 0 ),
_initialised( false )
{
  OBT_ASSERT( path != NULL ) ;
  _path = path ;
  if( name )
  {
#ifdef _MSC_VER
#  ifndef NDEBUG
    // first try in _path
    _path += "/" + std::string( name ) + "_d.dll" ;
    struct stat buffer ;
    if( stat( _path.c_str(), &buffer ) )
    { // The file doesn't exist => search in sub-directory according to the debug/release flag
      _path = std::string( path ) + "/debug/" + std::string( name ) + "_d.dll" ;
    }
#  else
    // first try in _path
    _path += "/" + std::string( name ) + ".dll" ;
    struct stat buffer ;
    if( stat( _path.c_str(), &buffer ) )
    { // The file doesn't exist => search in sub-directory according to the debug/release flag
      _path = std::string( path ) + "/release/" + std::string( name ) + ".dll" ;
    }
#  endif
#else
    // first try in _path
    _path += ( ( "" == _path ) ? "lib" : "/lib" ) + std::string( name ) + ".so" ;
#endif
  }
  
  if ( configurationFile != NULL )
  {
    _configurationFile = configurationFile ;
  }
  else
  {
    _configurationFile = "" ;
  }
}

//-------------------------------------------------------------------------
// ~Plugin()
//-------------------------------------------------------------------------
Plugin::~Plugin()
{
  unload( ) ;
}

//-------------------------------------------------------------------------
// Load
//-------------------------------------------------------------------------
bool 
Plugin::load() 
{
  if ( _pluginHandle == NULL )
  {
    // load the plugin
  #ifdef _MSC_VER
    _pluginHandle = LoadLibrary( _path.c_str() ) ;
  #else
    _pluginHandle = dlopen( _path.c_str(), RTLD_LAZY | RTLD_GLOBAL ) ;
  #endif
    if ( _pluginHandle == NULL )
    {
      TRACE_ERROR( "Unable to load plugin: " << _path.c_str() ) ;
  #ifndef _MSC_VER
      char *s = dlerror() ;
      if (s)
      {
        TRACE_ERROR( "Error message from plugin loading: " << s ) ;
        free( s ) ;
      }
  #endif
      _initialised = false ;
    }
    // call the initPlugin function of the plugin
    else
    {
      _initialised = true ;
      void* functionPointer( NULL ) ;
  #ifdef _MSC_VER
      functionPointer = GetProcAddress( _pluginHandle, "initPlugin" ) ;
  #else
      functionPointer = dlsym( _pluginHandle, "initPlugin" ) ;
  #endif
      InitFunc initFunc( reinterpret_cast<InitFunc>( functionPointer ) ) ;
      if( initFunc == NULL )
      {
        TRACE_ERROR( "Unable to call the initPlugin function of the plugin: " << _path.c_str() ) ;
        _initialised = false ;
      }
      else 
      {
        _initialised = initFunc( getConfigurationFile() ) ;
      }
    }
  }

  return _initialised ;
}

//-------------------------------------------------------------------------
// unload
//-------------------------------------------------------------------------
bool 
Plugin::unload() 
{
  bool returnCode( true ) ;
  if( _pluginHandle != NULL )
  {  
    // call the finishPlugin function of the plugin
    void* functionPointer( NULL ) ;
#ifdef _MSC_VER
    functionPointer = GetProcAddress( _pluginHandle, "finishPlugin" ) ;
#else
    functionPointer = dlsym( _pluginHandle, "finishPlugin" ) ;
#endif
    DeInitFunc deInitFunc( reinterpret_cast<DeInitFunc>( functionPointer ) ) ;
    if( deInitFunc == NULL )
    {
      TRACE_ERROR( "Unable to call the finishPlugin function of the plugin: " << _path.c_str() ) ;
      returnCode = false ;
    }
    else 
    {
      returnCode = deInitFunc() ;
    }

    // unload the plugin
#ifdef _MSC_VER
    FreeLibrary( _pluginHandle ) ;
#else
    dlclose( _pluginHandle ) ;
#endif
    _pluginHandle = NULL ;
    _path = "" ;
  }
  _initialised = false ;

  return returnCode ;
}

//-------------------------------------------------------------------------
// GetPluginInformation
//-------------------------------------------------------------------------
const PluginInformation& 
Plugin::getInformation() const 
{
  if( _pluginHandle != NULL )
  {
    void* functionPointer( NULL ) ;
#ifdef _MSC_VER
    functionPointer = GetProcAddress( _pluginHandle, "getPluginInformation" ) ;
#else
    functionPointer = dlsym( _pluginHandle, "getPluginInformation" ) ;
#endif
    PluginInformationFunc pluginInformationFunc( reinterpret_cast<PluginInformationFunc>( functionPointer ) ) ;
    if( pluginInformationFunc != NULL )
    {
      return pluginInformationFunc() ;
    }
    else
    {
      TRACE_ERROR( "Unable to call the getPluginInformation function of the plugin: " << _path.c_str() ) ;
    }
  }

  return PluginInformation::Unknown ;
}

---