RetroShare/libretroshare/src/plugins/pluginmanager.cc

373 lines
11 KiB
C++
Raw Normal View History

#include <string.h>
#include "pluginmanager.h"
#include <dirent.h>
#include <serialiser/rsserial.h>
#include <serialiser/rstlvbase.h>
#include <serialiser/rstlvtypes.h>
#include <serialiser/rspluginitems.h>
#include <util/rsdir.h>
#include <util/folderiterator.h>
#include <ft/ftserver.h>
#include <dbase/cachestrapper.h>
#include <retroshare/rsplugin.h>
#include <retroshare/rsfiles.h>
#include <pqi/pqiservice.h>
#include <plugins/rscacheservice.h>
#include <plugins/rspqiservice.h>
// lets disable the plugin system for now, as it's unfinished.
#ifdef WINDOWS_SYS
#include "dlfcn_win32.h"
#else
#include <dlfcn.h>
#endif
std::string RsPluginManager::_plugin_entry_symbol ;
std::string RsPluginManager::_local_cache_dir ;
std::string RsPluginManager::_remote_cache_dir ;
std::vector<std::string> RsPluginManager::_plugin_directories ;
ftServer *RsPluginManager::_ftserver = NULL ;
p3LinkMgr *RsPluginManager::_linkmgr = NULL ;
typedef RsPlugin *(*RetroSharePluginEntry)(void) ;
RsPluginHandler *rsPlugins ;
RsPluginManager::RsPluginManager() : p3Config(CONFIG_TYPE_PLUGINS)
{
}
void RsPluginManager::loadConfiguration()
{
std::string dummyHash = "dummyHash";
p3Config::loadConfiguration(dummyHash);
}
void RsPluginManager::setInterfaces(RsPlugInInterfaces &interfaces)
{
std::cerr << "RsPluginManager::setInterfaces() " << std::endl;
for(uint32_t i=0;i<_plugins.size();++i)
if(_plugins[i].plugin != NULL && _plugins[i].plugin->rs_cache_service() != NULL)
{
_plugins[i].plugin->setInterfaces(interfaces);
std::cerr << " setting iterface for plugin " << _plugins[i].plugin->getPluginName() << ", with RS_ID " << _plugins[i].plugin->rs_service_id() << std::endl ;
}
}
void RsPluginManager::setCacheDirectories(const std::string& local_cache, const std::string& remote_cache)
{
_local_cache_dir = local_cache ;
_remote_cache_dir = remote_cache ;
}
bool RsPluginManager::acceptablePluginName(const std::string& name)
{
// Needs some windows specific code here
//
#ifdef WINDOWS_SYS
return name.size() > 4 && name.substr(name.size() - 4) == ".dll";
#else
return name.size() > 3 && !strcmp(name.c_str()+name.size()-3,".so") ;
#endif
}
void RsPluginManager::disablePlugin(const std::string& hash)
{
std::set<std::string>::iterator it = _accepted_hashes.find(hash) ;
if(it != _accepted_hashes.end())
{
std::cerr << "RsPluginManager::disablePlugin(): removing hash " << hash << " from white list" << std::endl;
_accepted_hashes.erase(it) ;
IndicateConfigChanged() ;
}
}
void RsPluginManager::enablePlugin(const std::string& hash)
{
if(_accepted_hashes.find(hash) == _accepted_hashes.end())
{
std::cerr << "RsPluginManager::enablePlugin(): inserting hash " << hash << " in white list" << std::endl;
_accepted_hashes.insert(hash) ;
IndicateConfigChanged() ;
}
}
void RsPluginManager::loadPlugins(const std::vector<std::string>& plugin_directories)
{
_plugin_directories = plugin_directories ;
_plugin_entry_symbol = "RETROSHARE_PLUGIN_provide" ;
// 0 - get the list of files to read
for(uint32_t i=0;i<plugin_directories.size();++i)
{
librs::util::FolderIterator dirIt(plugin_directories[i]);
if(!dirIt.isValid())
{
std::cerr << "Plugin directory : " << plugin_directories[i] << " does not exist." << std::endl ;
continue ;
}
while(dirIt.readdir())
{
std::string fname;
dirIt.d_name(fname);
std::string fullname = plugin_directories[i] + "/" + fname;
if(!acceptablePluginName(fullname))
continue ;
std::cerr << "Found plugin " << fullname << std::endl;
std::cerr << " Loading plugin..." << std::endl;
loadPlugin(fullname) ;
}
dirIt.closedir();
}
std::cerr << "Loaded a total of " << _plugins.size() << " plugins." << std::endl;
}
void RsPluginManager::getPluginStatus(int i,uint32_t& status,std::string& file_name,std::string& hash,std::string& error_string) const
{
if((uint32_t)i >= _plugins.size())
return ;
status = _plugins[i].status ;
error_string = _plugins[i].info_string ;
hash = _plugins[i].file_hash ;
file_name = _plugins[i].file_name ;
}
RsSerialiser *RsPluginManager::setupSerialiser()
{
RsSerialiser *rss = new RsSerialiser ;
rss->addSerialType(new RsPluginSerialiser()) ;
return rss ;
}
void RsPluginManager::loadPlugins(const std::vector<RsPlugin *>& plugins)
{
for(uint32_t i=0;i<plugins.size();++i)
loadPlugin(plugins[i]) ;
}
bool RsPluginManager::loadPlugin(RsPlugin *p)
{
std::cerr << " Loading programmatically inserted plugin " << std::endl;
PluginInfo pinfo ;
pinfo.plugin = p ;
pinfo.file_name = "No file" ;
pinfo.file_hash = "No hash" ;
pinfo.info_string = "" ;
p->setPlugInHandler(this); // WIN fix, cannot share global space with shared libraries
// The following choice is conservative by forcing RS to resolve all dependencies at
// the time of loading the plugin.
pinfo.status = PLUGIN_STATUS_LOADED ;
_plugins.push_back(pinfo) ;
return true;
}
bool RsPluginManager::loadPlugin(const std::string& plugin_name)
{
std::cerr << " Loading plugin " << plugin_name << std::endl;
PluginInfo pf ;
pf.plugin = NULL ;
pf.file_name = plugin_name ;
std::cerr << " -> hashing." << std::endl;
uint64_t size ;
if(!RsDirUtil::getFileHash(plugin_name,pf.file_hash,size))
{
std::cerr << " -> cannot hash file. Plugin read canceled." << std::endl;
return false;
}
// This file can be loaded. Insert an entry into the list of detected plugins.
//
_plugins.push_back(pf) ;
PluginInfo& pinfo(_plugins.back()) ;
std::cerr << " -> hash = " << pinfo.file_hash << std::endl;
if(_accepted_hashes.find(pinfo.file_hash) == _accepted_hashes.end())
{
std::cerr << " -> hash is not in white list. Plugin is rejected. Go to config->plugins to authorise this plugin." << std::endl;
pinfo.status = PLUGIN_STATUS_UNKNOWN_HASH ;
pinfo.info_string = "" ;
return false ;
}
else
{
// The following choice is conservative by forcing RS to resolve all dependencies at
// the time of loading the plugin.
int link_mode = RTLD_NOW | RTLD_GLOBAL ;
void *handle = dlopen(plugin_name.c_str(),link_mode) ;
if(handle == NULL)
{
std::cerr << " Cannot open plugin: " << dlerror() << std::endl ;
pinfo.status = PLUGIN_STATUS_DLOPEN_ERROR ;
pinfo.info_string = dlerror() ;
return false ;
}
void *pf = dlsym(handle,_plugin_entry_symbol.c_str()) ;
if(pf == NULL)
{
std::cerr << dlerror() << std::endl ;
pinfo.status = PLUGIN_STATUS_MISSING_SYMBOL ;
pinfo.info_string = "Symbol " + _plugin_entry_symbol + " is missing." ;
return false ;
}
std::cerr << " Added function entry for symbol " << _plugin_entry_symbol << std::endl ;
RsPlugin *p = ( (*(RetroSharePluginEntry)pf)() ) ;
if(p == NULL)
{
std::cerr << " Plugin entry function " << _plugin_entry_symbol << " returns NULL ! It should return an object of type RsPlugin* " << std::endl;
pinfo.status = PLUGIN_STATUS_NULL_PLUGIN ;
pinfo.info_string = "Plugin entry " + _plugin_entry_symbol + "() return NULL" ;
return false ;
}
pinfo.status = PLUGIN_STATUS_LOADED ;
pinfo.plugin = p ;
p->setPlugInHandler(this); // WIN fix, cannot share global space with shared libraries
pinfo.info_string = "" ;
return true;
}
}
p3LinkMgr *RsPluginManager::getLinkMgr() const
{
assert(_linkmgr != NULL) ;
return _linkmgr ;
}
ftServer *RsPluginManager::getFileServer() const
{
assert(_ftserver != NULL) ;
return _ftserver ;
}
const std::string& RsPluginManager::getLocalCacheDir() const
{
assert(!_local_cache_dir.empty()) ;
return _local_cache_dir ;
}
const std::string& RsPluginManager::getRemoteCacheDir() const
{
assert(!_remote_cache_dir.empty()) ;
return _remote_cache_dir ;
}
void RsPluginManager::slowTickPlugins(time_t seconds)
{
for(uint32_t i=0;i<_plugins.size();++i)
if(_plugins[i].plugin != NULL && _plugins[i].plugin->rs_cache_service() != NULL && (seconds % _plugins[i].plugin->rs_cache_service()->tickDelay() ))
{
std::cerr << " ticking plugin " << _plugins[i].plugin->getPluginName() << std::endl;
_plugins[i].plugin->rs_cache_service()->tick() ;
}
}
void RsPluginManager::registerCacheServices()
{
std::cerr << " Registering cache services." << std::endl;
for(uint32_t i=0;i<_plugins.size();++i)
if(_plugins[i].plugin != NULL && _plugins[i].plugin->rs_cache_service() != NULL)
{
rsFiles->getCacheStrapper()->addCachePair(CachePair(_plugins[i].plugin->rs_cache_service(),_plugins[i].plugin->rs_cache_service(),CacheId(_plugins[i].plugin->rs_service_id(), 0))) ;
std::cerr << " adding new cache pair for plugin " << _plugins[i].plugin->getPluginName() << ", with RS_ID " << _plugins[i].plugin->rs_service_id() << std::endl ;
}
}
void RsPluginManager::registerClientServices(p3ServiceServer *pqih)
{
std::cerr << " Registering pqi services." << std::endl;
for(uint32_t i=0;i<_plugins.size();++i)
if(_plugins[i].plugin != NULL && _plugins[i].plugin->rs_pqi_service() != NULL)
{
pqih->addService(_plugins[i].plugin->rs_pqi_service()) ;
std::cerr << " Added pqi service for plugin " << _plugins[i].plugin->getPluginName() << std::endl;
}
}
void RsPluginManager::addConfigurations(p3ConfigMgr *ConfigMgr)
{
std::cerr << " Registering configuration files." << std::endl;
for(uint32_t i=0;i<_plugins.size();++i)
if(_plugins[i].plugin != NULL && _plugins[i].plugin->configurationFileName().length() > 0)
{
ConfigMgr->addConfiguration(_plugins[i].plugin->configurationFileName(), _plugins[i].plugin->rs_cache_service());
std::cerr << " Added configuration for plugin " << _plugins[i].plugin->getPluginName() << ", with file " << _plugins[i].plugin->configurationFileName() << std::endl;
}
}
bool RsPluginManager::loadList(std::list<RsItem*>& list)
{
_accepted_hashes.clear() ;
std::cerr << "RsPluginManager::loadList(): " << std::endl;
std::list<RsItem *>::iterator it;
for(it = list.begin(); it != list.end(); it++)
{
RsPluginHashSetItem *vitem = dynamic_cast<RsPluginHashSetItem*>(*it);
if(vitem)
for(std::list<std::string>::const_iterator it(vitem->hashes.ids.begin());it!=vitem->hashes.ids.end();++it)
{
_accepted_hashes.insert(*it) ;
std::cerr << " loaded hash " << *it << std::endl;
}
delete (*it);
}
return true;
}
bool RsPluginManager::saveList(bool& cleanup, std::list<RsItem*>& list)
{
cleanup = true ;
RsPluginHashSetItem *vitem = new RsPluginHashSetItem() ;
for(std::set<std::string>::const_iterator it(_accepted_hashes.begin());it!=_accepted_hashes.end();++it)
vitem->hashes.ids.push_back(*it) ;
list.push_back(vitem) ;
return true;
}
RsCacheService::RsCacheService(uint16_t service_type,uint32_t config_type,uint32_t tick_delay, RsPluginHandler* pgHandler)
: CacheSource(service_type, true, pgHandler->getFileServer()->getCacheStrapper(), pgHandler->getLocalCacheDir()),
CacheStore (service_type, true, pgHandler->getFileServer()->getCacheStrapper(), pgHandler->getFileServer()->getCacheTransfer(), pgHandler->getRemoteCacheDir()),
p3Config(config_type), // CONFIG_TYPE_RANK_LINK
_tick_delay_in_seconds(tick_delay)
{
}