You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
winix/winixd/core/plugin.cpp

602 lines
11 KiB

/*
* This file is a part of Winix
* and is distributed under the 2-Clause BSD licence.
* Author: Tomasz Sowa <t.sowa@ttmath.org>
*/
/*
* Copyright (c) 2008-2018, Tomasz Sowa
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <dlfcn.h>
#include <string.h>
#include "plugin.h"
#include "misc.h"
#include "system.h"
#include "sessionmanager.h"
#include "functions/functions.h"
#include "templates/templates.h"
#include "winixrequest.h"
namespace Winix
{
/*
*
* PluginInfo
*
*
*/
void PluginInfo::set_dependency_for(WinixBase * winix_base)
{
plugin->SetDependencyFor(winix_base);
}
void PluginInfo::set_dependency_for(WinixBase & winix_base)
{
set_dependency_for(&winix_base);
}
void PluginInfo::set_dependency_for(WinixModelDeprecated * winix_model)
{
plugin->SetDependencyFor(winix_model);
//model_connector = winix_model->get_model_connector();
// CHECKME what about model_connector here?
}
void PluginInfo::set_dependency_for(WinixModelDeprecated & winix_model)
{
set_dependency_for(&winix_model);
}
/*
*
* Plugin
*
*
*/
void Plugin::UnloadPlugins()
{
size_t i;
slots.clear();
for(i=0 ; i<plugins.size() ; ++i)
dlclose(plugins[i].handle);
plugins.clear();
}
Plugin::Plugin()
{
current_plugin = -1;
db = nullptr;
cur = nullptr;
system = nullptr;
functions = nullptr;
templates = nullptr;
session_manager = nullptr;
winix_request = nullptr;
}
Plugin::~Plugin()
{
UnloadPlugins();
}
void Plugin::SetDb(Db * pdb)
{
db = pdb;
}
//void Plugin::SetConfig(Config * pconfig)
//{
// config = pconfig;
//}
void Plugin::SetCur(Cur * pcur)
{
cur = pcur;
}
void Plugin::SetSystem(System * psystem)
{
system = psystem;
}
void Plugin::SetFunctions(Functions * pfunctions)
{
functions = pfunctions;
}
void Plugin::SetTemplates(Templates * ptemplates)
{
templates = ptemplates;
}
//void Plugin::SetSynchro(Synchro * psynchro)
//{
// synchro = psynchro;
//}
void Plugin::SetSessionManager(SessionManager * psession_manager)
{
session_manager = psession_manager;
}
void Plugin::SetWinixRequest(WinixRequest * winix_request)
{
this->winix_request = winix_request;
}
void Plugin::Lock()
{
if( synchro )
synchro->Lock();
}
void Plugin::Unlock()
{
if( synchro )
synchro->Unlock();
}
bool Plugin::SetDependency(PluginInfo & info)
{
// for safety we call a plugin function only when all our pointers are not null
bool res = (db && config && cur && system && functions && templates && synchro && session_manager && winix_request);
if( !res )
{
log << log1 << "Plugin: cannot call a function - some of the winix pointers are null" << logend;
}
info.db = db;
info.config = config;
info.cur = cur;
info.system = system;
info.functions = functions;
info.templates = templates;
info.synchro = synchro;
info.session_manager = session_manager;
info.plugin = this;
/*
* FIXME
* if we call a message from a different thread then a different model connector is needed
* (each thread should have its own model connector)
*
*/
info.model_connector = system->get_model_connector();
info.log.SetDependency(&log);
return res;
}
void Plugin::SetDependencyFor(WinixBase * winix_base)
{
winix_base->set_dependency(winix_request);
}
void Plugin::SetDependencyFor(WinixModelDeprecated * winix_model)
{
winix_model->set_dependency(winix_request);
}
void Plugin::LoadPlugins(const std::wstring & plugins_dir, const std::vector<std::wstring> & plugins)
{
for(size_t i=0 ; i<plugins.size() ; ++i)
{
if( !plugins[i].empty() && plugins[i][0] == '/' )
{
LoadPlugin(plugins[i]);
}
else
{
temp_path = plugins_dir;
temp_path += '/';
temp_path += plugins[i];
LoadPlugin(temp_path);
}
}
}
// we don't have to use Lock() here because plugins are read
// before threads are started
void * Plugin::LoadInitFun(const wchar_t * filename, Fun1 & fun_init)
{
char file[WINIX_OS_PATH_SIZE];
if( !wide_to_utf8(filename, file, WINIX_OS_PATH_SIZE) )
return 0;
void * p = dlopen(file, RTLD_NOW | RTLD_LOCAL);
if( !p )
{
log << log1 << "Plugin: cannot load a plugin: \"" << filename << "\"" << logend;
log << log1 << "Plugin: dlerror: " << dlerror() << logend;
return 0;
}
fun_init = (Fun1)dlsym(p, "Init");
if( !fun_init )
{
log << log1 << "Plugin: cannot load a plugin: " << filename
<< " (there is no Init() function)" << logend;
dlclose(p);
return 0;
}
log << log2 << "Plugin: plugin loaded"
<< ", file: " << filename
<< ", index: " << plugins.size() << logend;
return p;
}
void Plugin::LoadPlugin(const wchar_t * filename)
{
Fun1 fun_init;
void * plugin_handle;
int old_current_plugin;
PluginInfo info;
if( !SetDependency(info) )
return;
if( !(plugin_handle = LoadInitFun(filename, fun_init)) )
return;
info.Clear();
old_current_plugin = current_plugin;
current_plugin = (int)plugins.size();
info.plugin_id = current_plugin;
fun_init(info);
PluginsItem item;
item.handle = plugin_handle;
item.plugin_name = reinterpret_cast<const wchar_t *>(info.p1);
plugins.push_back(item);
current_plugin = old_current_plugin;
}
void Plugin::LoadPlugin(const std::wstring & filename)
{
LoadPlugin(filename.c_str());
}
bool Plugin::HasPlugin(const wchar_t * name)
{
if( *name == 0 )
return false;
for(size_t i=0 ; i<plugins.size() ; ++i)
{
if( plugins[i].plugin_name && Equal(plugins[i].plugin_name, name) )
return true;
}
return false;
}
bool Plugin::HasPlugin(const std::wstring & name)
{
return HasPlugin(name.c_str());
}
bool Plugin::HasMessage(int message)
{
return (slots.find(message) != slots.end());
}
void Plugin::Call(Session * ses, int message, Slots::iterator & slot, PluginInfo & info)
{
if( !SetDependency(info) )
return;
current_plugin = slot->second.index;
info.plugin_id = current_plugin;
info.session = ses;
if( current_plugin != -1 && ses )
info.plugin_data_base = ses->plugin_data.Get(current_plugin);
else
info.plugin_data_base = 0;
if( !slot->second.is_running )
{
if( config->log_plugin_call )
{
log << log1 << "Plugin: calling plugin id: " << slot->second.index << ", message: " << message << logend;
}
slot->second.is_running = true;
if( slot->second.fun1 )
slot->second.fun1(info);
if( slot->second.fun2 )
slot->second.fun2();
slot->second.is_running = false;
if( config->log_plugin_call )
{
log << log1 << "Plugin: returning from plugin id: " << slot->second.index << ", message: " << message
<< ", result: " << (info.res? "true" : "false") << logend;
}
}
else
{
log << log1 << "Plugin: id: " << slot->second.index
<< ", message: " << message
<< ", recurrences are not allowed" << logend;
}
}
PluginRes Plugin::Call(Session * ses, int message, void * p1_, void * p2_, long l1_, long l2_)
{
PluginRes res;
int old_current_plugin = current_plugin;
PluginInfo info;
Slots::iterator i = slots.lower_bound(message);
for( ; i!=slots.end() && i->first==message ; ++i )
{
info.Clear();
info.p1 = p1_;
info.p2 = p2_;
info.l1 = l1_;
info.l2 = l2_;
Call(ses, message, i, info);
if( info.res )
++res.res_true;
else
++res.res_false;
}
current_plugin = old_current_plugin;
return res;
}
PluginRes Plugin::Call(int message)
{
return Call(cur->session, message, 0, 0, 0, 0);
}
PluginRes Plugin::Call(int message, void * p1_)
{
return Call(cur->session, message, p1_, 0, 0, 0);
}
PluginRes Plugin::Call(int message, void * p1_, void * p2_)
{
return Call(cur->session, message, p1_, p2_, 0, 0);
}
PluginRes Plugin::Call(int message, long l1_)
{
return Call(cur->session, message, 0, 0, l1_, 0);
}
PluginRes Plugin::Call(int message, long l1_, long l2_)
{
return Call(cur->session, message, 0, 0, l1_, l2_);
}
PluginRes Plugin::Call(int message, void * p1_, long l1_)
{
return Call(cur->session, message, p1_, 0, l1_, 0);
}
PluginRes Plugin::Call(int message, void * p1_, long l1_, long l2_)
{
return Call(cur->session, message, p1_, 0, l1_, l2_);
}
PluginRes Plugin::Call(int message, void * p1_, void * p2_, long l1_)
{
return Call(cur->session, message, p1_, p2_, l1_, 0);
}
PluginRes Plugin::Call(Session * ses, int message)
{
return Call(ses, message, 0, 0, 0, 0);
}
PluginRes Plugin::Call(Session * ses, int message, void * p1_)
{
return Call(ses, message, p1_, 0, 0, 0);
}
PluginRes Plugin::Call(Session * ses, int message, void * p1_, void * p2_)
{
return Call(ses, message, p1_, p2_, 0, 0);
}
PluginRes Plugin::Call(Session * ses, int message, long l1_)
{
return Call(ses, message, 0, 0, l1_, 0);
}
PluginRes Plugin::Call(Session * ses, int message, long l1_, long l2_)
{
return Call(ses, message, 0, 0, l1_, l2_);
}
PluginRes Plugin::Call(Session * ses, int message, void * p1_, long l1_)
{
return Call(ses, message, p1_, 0, l1_, 0);
}
PluginRes Plugin::Call(Session * ses, int message, void * p1_, long l1_, long l2_)
{
return Call(ses, message, p1_, 0, l1_, l2_);
}
PluginRes Plugin::Call(Session * ses, int message, void * p1_, void * p2_, long l1_)
{
return Call(ses, message, p1_, p2_, l1_, 0);
}
size_t Plugin::Size()
{
return plugins.size();
}
/*
!! IMPROVE ME
Assign() can work only if other threads are not started
we can add some barrier/flag so when other threads starts
then we cannot use Assign() method
*/
void Plugin::Assign(int message, Fun1 fun1)
{
Slot s;
if( current_plugin == -1 )
return;
s.fun1 = fun1;
s.index = current_plugin;
slots.insert( std::make_pair(message, s) );
log << log3 << "Plugin: added function for message: " << message << ", plugin index: " << s.index << logend;
}
void Plugin::Assign(int message, Fun2 fun2)
{
Slot s;
if( current_plugin == -1 )
return;
s.fun2 = fun2;
s.index = current_plugin;
slots.insert( std::make_pair(message, s) );
log << log3 << "Plugin: added function for message: " << message << ", plugin index: " << s.index << logend;
}
const Plugin::Plugins * Plugin::GetPlugins()
{
return &plugins;
}
} // namespace Winix