QDll.cc

Go to the documentation of this file.

#include "QDll.hh"
#include <dlfcn.h>
#include <sstream>
#include <sys/utsname.h>
#include "QMessage.hh"
#include "QStringHandler.hh"
 
Q_BEGIN_NAMESPACE
 
QDLLManager::QDLLManager( const char *fname, const bool autoload )
{
    // Try to open the library now and get any error message.   
    if(autoload) {
        h=dlopen( fname, RTLD_GLOBAL | RTLD_NOW);
    } else {
        h=dlopen( fname, RTLD_NOW );
    }
    err=dlerror();
}
 
QDLLManager::~QDLLManager()
{
        // close the library if it isn't null
//      if( h!=0 )
//      dlclose(h);
}
 
QError QDLLManager::GetSymbol(void **v, const char *sym_name)
{
        // try extract a symbol from the library
        // get any error message is there is any
        if( h!=0 ) {
                *v = dlsym( h, sym_name );
        err=dlerror();
            if( err==0 )
          return QERR_SUCCESS;
        else
          return QError(QERR_UNKNOWN_ERR, std::string("Cannot find symbol: ") + std::string(sym_name));
        } else {        
        return QError(QERR_UNKNOWN_ERR, std::string("Library not open so no symbol found.."));
        }
}
 
QDLLLoader& QDLLLoader::GetInstance()
{
    static QDLLLoader loader;
 
    return loader;
}
 
QDLLLoader::QDLLLoader()
{
    fPluginLists.clear();
    fFirstLoadCall = true;
    fDoAutoLoad = false;
}
 
QError QDLLLoader::Init(const std::string& pluginlist, const std::string& pluginPrefix)
{
  if(fPluginLists.count(pluginlist) > 0) return QERR_SUCCESS;
    // open file with list of plugin for each library
    // and fill the [(prefix+plugin) - corrsponding library map
 
    // search for libraries path where the pluginList file should be...
    struct utsname system;
    uname(&system);
    char*  ldpath = NULL;
    if(std::string(system.sysname) == "Darwin")
      ldpath = getenv("DYLD_LIBRARY_PATH");
    else
      ldpath = getenv("LD_LIBRARY_PATH");
    std::stringstream path(ldpath);
    std::string libpath;
    std::string fullpath;
    std::ifstream file;
    while(std::getline(path,libpath,':')) {
      fullpath = libpath + "/" + pluginlist;
      file.open(fullpath.c_str());
      if(file.good()) break;
    }
    if(!file.good()) return QError(QERR_CANNOT_OPEN_FILE,std::string("Plugins: ") + fullpath  + " not loaded");
 
    
    std::string msg = std::string("Reading plugins from: ") + fullpath;
    QMessageHandler::Get()->Send(DebugMsg,"QDLLLoader",msg);
    // parse file
    std::string line;
    while(std::getline(file,line)) {
      // Remove anything after the first # character
      line=line.substr(0,line.find("#"));
      // Remove leading and trailing spaces
      line = QStringHandler::DoubleSwallowSpaces(line);
      // Skip empty lines
      if(line.length()==0) continue;
      
      std::stringstream sline(line);
      std::string word;
      std::string library;
      // The library name is first
      std::getline(sline,library,':');
      // Then handle all the modules listed on the line
      while(sline >> word){
          if(word == "autoload" && fDoAutoLoad) {
              AutoLoadPlugin aplugin;
              aplugin.library=library;
              aplugin.fullPathLibrary = libpath+"/"+library;
              bool overWritten = false;
              for (size_t i=0;i<fAutoPluginsLib.size();i++) {
                  if(fAutoPluginsLib[i].library == library) {
                      fAutoPluginsLib[i] = aplugin;
                      overWritten = true;
                  }
              }
              if(!overWritten)
                  fAutoPluginsLib.push_back(aplugin);
          }
          else
              fPluginsLib[word] = library;
      }
    }
 
    /*  
        std::map<std::string, std::string>::iterator plugLibIter;
        for(plugLibIter = fPluginsLib.begin(); plugLibIter != fPluginsLib.end(); plugLibIter++)
        std::cout<<plugLibIter->first<<" -- "<<plugLibIter->second<<std::endl;
        */
    fPluginPrefix = pluginPrefix;
    fPluginLists.insert(pluginlist);
    return QERR_SUCCESS;
}
 
QError QDLLLoader::LoadPlugin(const std::string& pluginName)
{
    QMessageHandler::Get()->Send(DebugMsg,"QDLLLoader",
            "LoadPlugin " + pluginName);
    if(fFirstLoadCall ) {
        std::vector<AutoLoadPlugin>::const_iterator iter = fAutoPluginsLib.begin();
        while(iter != fAutoPluginsLib.end()) {
            const AutoLoadPlugin& autoPlugin = *iter;
            QMessageHandler::Get()->Send(DebugMsg,"QDLLLoader",
                    "Autoloading: "
                    +autoPlugin.fullPathLibrary);
            QDLLManager dll(autoPlugin.fullPathLibrary.c_str(),true);
            const char* dllError = dll.LastError();
            if(dllError) {
                std::stringstream msg;
                msg << "While loading plugin " << pluginName 
                    << " attempt to autoload library " 
                    << autoPlugin.fullPathLibrary
                    << ". Load failed!" << std::endl
                    << "DLL Error: " << dllError;
                return QError(QERR_CANNOT_OPEN_FILE,msg.str());
            } else {
                std::string msg = "Autoloaded: " + autoPlugin.fullPathLibrary;
                QMessageHandler::Get()->Send(DebugMsg,"QDLLLoader",msg);
            }
 
 
            iter++;
        }
        fFirstLoadCall = false;
    }
    // look for the plugin's library
    std::map<std::string, std::string>::iterator plugLibIter = fPluginsLib.find(pluginName);
    if(plugLibIter==fPluginsLib.end()) {
        return QError(QERR_UNKNOWN_ERR,std::string("Plugin: ") + pluginName + " not found in libraries database");
    }
    else {
        std::stringstream msg;
        msg << "Found library\n\t" << pluginName << ":" <<
            plugLibIter->second;
        QMessageHandler::Get()->Send(DebugMsg,"QDLLLoader",msg.str());
    }
 
    // open library
    QDLLManager dll(plugLibIter->second.c_str());
    const char* dllError = dll.LastError();
    if(dllError) {
        return QError(QERR_CANNOT_OPEN_FILE,std::string(plugLibIter->second.c_str()) + " - " + dllError );
    }
    // get symbol
    void  (*factory_func)(void);
    std::string plugin = fPluginPrefix + pluginName;
    QError derr = dll.GetSymbol((void**)&factory_func, plugin.c_str());
    if(derr!=QERR_SUCCESS) return derr;
    // execute symbol
    (*factory_func)();
    return QError(QERR_SUCCESS);
}
 
Q_END_NAMESPACE