dynamic_loading.cpp

Go to the documentation of this file.

 
#include "dynamic_loading.h"
 
#include <dirent.h>
#include <cerrno>
 
namespace argos {
 
   /****************************************/
   /****************************************/
 
   CDynamicLoading::TDLHandleMap CDynamicLoading::m_tOpenLibs;
   const std::string CDynamicLoading::DEFAULT_PLUGIN_PATH = ARGOS_INSTALL_PREFIX "/lib/argos3/";
 
   /****************************************/
   /****************************************/
 
   /*
    * Tries to load the given library
    * 1. Tries to load the library as passed
    * 2. If that fails, it appends the shared library extension and tries again;
    * 3. If also that fails, it appends the module library extension and tries a last time.
    * If all fails, t_handle is set to NULL and str_lib is left as-is;
    * In case of success, it sets t_handle to the handle of the load library, and fixes str_lib to
    * match the extension of the loaded library.
    */
   static CDynamicLoading::TDLHandle LoadLibraryTryingExtensions(std::string& str_lib,
                                                                 std::string& str_msg) {
      /* Try loading without changes to the given path */
      CDynamicLoading::TDLHandle tHandle = ::dlopen(str_lib.c_str(), RTLD_GLOBAL | RTLD_LAZY);
      str_msg += "\n  " + str_lib + ": ";
      if(tHandle == nullptr) {
         str_msg += dlerror();
         /* Try adding the shared lib extension to the path */
         std::string strLibWExt = str_lib + "." + ARGOS_SHARED_LIBRARY_EXTENSION;
         tHandle = ::dlopen(strLibWExt.c_str(), RTLD_GLOBAL | RTLD_LAZY);
         str_msg += "\n\n  " + strLibWExt + ": ";
         if(tHandle != nullptr) {
            /* Success */
            str_lib = strLibWExt;
         }
         else {
            str_msg += dlerror();
            /* Try adding the module lib extension to the path */
            strLibWExt = str_lib + "." + ARGOS_MODULE_LIBRARY_EXTENSION;
            tHandle = ::dlopen(strLibWExt.c_str(), RTLD_GLOBAL | RTLD_LAZY);
            str_msg += "\n\n  " + strLibWExt + ": ";
            if(tHandle != nullptr) {
               /* Success */
               str_lib = strLibWExt;
            }
            else {
               str_msg += dlerror();
               str_msg += "\n";
            }
         }
      }
      if(tHandle != nullptr) {
         str_msg += "OK";
      }
      return tHandle;
   }
 
   /****************************************/
   /****************************************/
 
   CDynamicLoading::TDLHandle CDynamicLoading::LoadLibrary(const std::string& str_lib) {
      TDLHandle tHandle;
      /* Check if the provided path is absolute or relative */
      if(str_lib[0] == '/') {
         /*
          * Absolute path
          */
         /* First check if the library is already loaded */
         auto it = m_tOpenLibs.find(str_lib);
         if(it != m_tOpenLibs.end()) {
            /* Already loaded */
            return m_tOpenLibs[str_lib];
         }
         /* Not already loaded, load the library and bomb out in case of failure */
         std::string strLoadedLib = str_lib;
         std::string strMsg;
         tHandle = LoadLibraryTryingExtensions(strLoadedLib, strMsg);
         if(tHandle == nullptr) {
            THROW_ARGOSEXCEPTION("Can't load library \""
                                 << str_lib
                                 << "\" after trying the following: "
                                 << std::endl
                                 << strMsg);
         }
         /* Store the handle to the loaded library */
         m_tOpenLibs[strLoadedLib] = tHandle;
         LOG << "[INFO] Loaded library \"" << strLoadedLib << "\"" << std::endl;
         LOG.Flush();
         return tHandle;
      }
      else {
         /*
          * Relative path, go through the plugin directories
          */
         /* String to store the full path to a library */
         std::string strLibPath;
         /* String to store the list of paths to search */
         std::string strPluginPath = ".:" + DEFAULT_PLUGIN_PATH;
         /* Get variable ARGOS_PLUGIN_PATH from the environment */
         if(::getenv("ARGOS_PLUGIN_PATH") != nullptr) {
            /* Add value of the variable to list of paths to check */
            strPluginPath = std::string(::getenv("ARGOS_PLUGIN_PATH")) + ":" + strPluginPath;
         }
         /* Add : at the end to make parsing easier */
         if(strPluginPath[strPluginPath.length()-1] != ':') {
            strPluginPath.append(":");
         }
         /*
          * Go through paths and try to load the library
          */
         /* Parse the string */
         std::istringstream issPluginPath(strPluginPath);
         std::string strDir, strMsg;
         while(std::getline(issPluginPath, strDir, ':')) {
            /* Add '/' to dir if missing */
            if(strDir[strDir.length()-1] != '/') {
               strDir.append("/");
            }
            strLibPath = strDir + str_lib;
            /* First check if the library is already loaded */
            auto it = m_tOpenLibs.find(strLibPath);
            if(it != m_tOpenLibs.end()) {
               /* Already loaded */
               return m_tOpenLibs[strLibPath];
            }
            /* Not already loaded, try and load the library */
            tHandle = LoadLibraryTryingExtensions(strLibPath, strMsg);
            if(tHandle != nullptr) {
               /* Store the handle to the loaded library */
               m_tOpenLibs[strLibPath] = tHandle;
               LOG << "[INFO] Loaded library \"" << strLibPath << "\"" << std::endl;
               LOG.Flush();
               return tHandle;
            }
         }
         /* If we get here, it's because no directory worked */
         THROW_ARGOSEXCEPTION("Can't load library \""
                              << str_lib
                              << "\" after trying the following: "
                              << std::endl
                              << strMsg);
      }
   }
 
   /****************************************/
   /****************************************/
 
   void CDynamicLoading::UnloadLibrary(const std::string& str_lib) {
      auto it = m_tOpenLibs.find(str_lib);
      if(it != m_tOpenLibs.end()) {
         if(::dlclose(it->second) != 0) {
            LOGERR << "[WARNING] Can't unload library \""
                   << str_lib
                   << "\": "
                   << dlerror()
                   << std::endl;
            LOGERR.Flush();
         }
      }
      else {
         THROW_ARGOSEXCEPTION("Can't unload library \""
                              << str_lib
                              << "\": library does not appear to have been loaded.");
      }
   }
 
   /****************************************/
   /****************************************/
 
   void CDynamicLoading::LoadAllLibraries() {      
      /* String to store the full path to a library */
      std::string strLibPath;
      /* String to store the list of paths to search */
      std::string strPluginPath = DEFAULT_PLUGIN_PATH;
      /* Get variable ARGOS_PLUGIN_PATH from the environment */
      if(::getenv("ARGOS_PLUGIN_PATH") != nullptr) {
         /* Add value of the variable to list of paths to check */
         strPluginPath = std::string(::getenv("ARGOS_PLUGIN_PATH")) + ":" + strPluginPath;
      }
      /* Add : at the end to make parsing easier */
      if(strPluginPath[strPluginPath.length()-1] != ':') {
         strPluginPath.append(":");
      }
      /*
       * Go through paths and load all the libraries
       */
      /* Directory info */
      DIR* ptDir;
      struct dirent* ptDirData;
      /* Parse the string */
      std::istringstream issPluginPath(strPluginPath);
      std::string strDir;
      while(std::getline(issPluginPath, strDir, ':')) {
         /* Add '/' to dir if missing */
         if(strDir[strDir.length()-1] != '/') {
            strDir.append("/");
         }
         /* Try to open the directory */
         ptDir = ::opendir(strDir.c_str());
         if(ptDir != nullptr) {
            /* Directory open, now go through the files in the directory */
            while((ptDirData = ::readdir(ptDir)) != nullptr) {
               /* We have a file, check that it is a library file */
               if(strlen(ptDirData->d_name) > strlen(ARGOS_SHARED_LIBRARY_EXTENSION) &&
                  std::string(ptDirData->d_name).rfind("." ARGOS_SHARED_LIBRARY_EXTENSION) +
                  strlen(ARGOS_SHARED_LIBRARY_EXTENSION) + 1 == strlen(ptDirData->d_name)) {
                  /* It's a library file, load it */
                  LoadLibrary(strDir + ptDirData->d_name);
               }
               if(strcmp(ARGOS_SHARED_LIBRARY_EXTENSION, ARGOS_MODULE_LIBRARY_EXTENSION) != 0) {
                  if(strlen(ptDirData->d_name) > strlen(ARGOS_MODULE_LIBRARY_EXTENSION) &&
                     std::string(ptDirData->d_name).rfind("." ARGOS_MODULE_LIBRARY_EXTENSION) +
                     strlen(ARGOS_MODULE_LIBRARY_EXTENSION) + 1 == strlen(ptDirData->d_name)) {
                     /* It's a library file, load it */
                     LoadLibrary(strDir + ptDirData->d_name);
                  }
               }
            }
            /* Close directory */
            ::closedir(ptDir);
         }
         else {
            /* Error opening directory open, inform user without bombing out */
            LOGERR << "[WARNING] Error opening directory \""
                   << strDir
                   << "\": "
                   << ::strerror(errno)
                   << std::endl;
            LOGERR.Flush();
         }
      }
   }
 
   /****************************************/
   /****************************************/
 
   void CDynamicLoading::UnloadAllLibraries() {
      for(auto it = m_tOpenLibs.begin();
          it != m_tOpenLibs.end();
          ++it) {
         UnloadLibrary(it->first);
      }
      m_tOpenLibs.clear();
   }
 
   /****************************************/
   /****************************************/
 
}