virtual Boolean add_plugins (PluginContainer &container) {
Boolean result (True);
HandleContainer pluginList;
container.get_plugin_list (pluginList);
Handle plugin = pluginList.get_first ();
while (plugin) {
PluginInfo *infoPtr = container.lookup_plugin_info (plugin);
Plugin *pluginPtr = container.lookup_plugin (plugin);
if (container.release_plugin (plugin)) {
if (!add_plugin (infoPtr, pluginPtr)) {
result = False;
if (container.add_plugin (infoPtr, pluginPtr)) {
container.remove_plugin (plugin);
}
}
}
plugin = pluginList.get_next ();
}
return result;
}
plugins_manager::plugins_manager(application_lua_kernel * kernel)
: plugins_()
, playing_()
, kernel_(kernel)
{
assert(!singleton);
singleton = this;
add_plugin("Null Plugin", "return function() end");
start_plugin(0);
}
AnimationTreeEditor::AnimationTreeEditor() {
AnimationNodeAnimation::get_editable_animation_list = get_animation_list;
path_edit = memnew(ScrollContainer);
add_child(path_edit);
path_edit->set_enable_h_scroll(true);
path_edit->set_enable_v_scroll(false);
path_hb = memnew(HBoxContainer);
path_edit->add_child(path_hb);
path_hb->add_child(memnew(Label(TTR("Path:"))));
add_child(memnew(HSeparator));
current_root = 0;
singleton = this;
editor_base = memnew(PanelContainer);
editor_base->set_v_size_flags(SIZE_EXPAND_FILL);
add_child(editor_base);
add_plugin(memnew(AnimationNodeBlendTreeEditor));
add_plugin(memnew(AnimationNodeBlendSpace1DEditor));
add_plugin(memnew(AnimationNodeBlendSpace2DEditor));
add_plugin(memnew(AnimationNodeStateMachineEditor));
}
static int _sasl_plugin_load(char *plugin, void *library,
const char *entryname,
int (*add_plugin)(const char *, void *))
{
void *entry_point;
int result;
result = _sasl_locate_entry(library, entryname, &entry_point);
if(result == SASL_OK) {
result = add_plugin(plugin, entry_point);
if(result != SASL_OK)
_sasl_log(NULL, SASL_LOG_DEBUG,
"_sasl_plugin_load failed on %s for plugin: %s\n",
entryname, plugin);
}
return result;
}
/* Load a plugin + append to list */
static struct PluginMeta *
load_plugin ( char * name )
{
void * p, * t;
/* Open */
if( !(p = g_module_open(name, G_MODULE_BIND_LOCAL)) )
return NULL;
/* Check if there is plugin metadata */
if( !g_module_symbol(p, PLUGIN_META_NAME, &t) )
return NULL;
/* Loaded - append to list */
add_plugin( name, p, t );
/* Success */
return t;
}
void
read_plugin_dir ( char *dir,
KTPluginInfoList *plugin_list )
/*
Input:
dir - The directory to read the plugins from.
Output:
plugin_list - The plugins in dir are added to this list.
Returns:
-
Description:
This function reads the plugins from the directory which path is dir and
adds them to plugin_list.
*/
{
struct dirent **file_list;
int num_files,
count;
KTPluginInfoEntry *plugin;
num_files = scandir (dir, &file_list, always_true, alphasort);
if (num_files >= 0)
{
for (count = 0; count < num_files; count++)
{
plugin = load_plugin_info (dir, file_list[count]->d_name);
if (plugin != NULL && !find_plugin (plugin->info.name, plugin_list))
{
add_plugin (plugin, plugin_list);
}
}
}
else if (mkdir(dir, S_IWUSR | S_IRUSR | S_IXUSR) == -1)
{
KTError (_("Plugin directory '%s' does not exist and "
"creating the directory failed. This program "
"will continue without loading the plugins "
"in this directory."), dir);
}
}
int __near_plugin_init(const char *pattern, const char *exclude)
{
gchar **patterns = NULL;
gchar **excludes = NULL;
GSList *list;
GDir *dir;
const gchar *file;
gchar *filename;
unsigned int i;
DBG("");
if (pattern)
patterns = g_strsplit_set(pattern, ":, ", -1);
if (exclude)
excludes = g_strsplit_set(exclude, ":, ", -1);
for (i = 0; __near_builtin[i]; i++) {
if (!check_plugin(__near_builtin[i], patterns, excludes))
continue;
add_plugin(NULL, __near_builtin[i]);
}
dir = g_dir_open(PLUGINDIR, 0, NULL);
if (dir) {
while ((file = g_dir_read_name(dir))) {
void *handle;
struct near_plugin_desc *desc;
if (g_str_has_prefix(file, "lib") ||
!g_str_has_suffix(file, ".so"))
continue;
filename = g_build_filename(PLUGINDIR, file, NULL);
handle = dlopen(filename, RTLD_NOW);
if (!handle) {
near_error("Can't load %s: %s",
filename, dlerror());
g_free(filename);
continue;
}
g_free(filename);
desc = dlsym(handle, "near_plugin_desc");
if (!desc) {
near_error("Can't load symbol: %s",
dlerror());
dlclose(handle);
continue;
}
if (!check_plugin(desc, patterns, excludes)) {
dlclose(handle);
continue;
}
if (!add_plugin(handle, desc))
dlclose(handle);
}
g_dir_close(dir);
}
for (list = plugins; list; list = list->next) {
struct near_plugin *plugin = list->data;
if (plugin->desc->init() < 0)
continue;
plugin->active = true;
}
g_strfreev(patterns);
g_strfreev(excludes);
return 0;
}
gboolean plugin_init(GKeyFile *config, const char *enable, const char *disable)
{
GSList *list;
GDir *dir;
const gchar *file;
char **conf_disabled, **cli_disabled, **cli_enabled;
unsigned int i;
/* Make a call to BtIO API so its symbols got resolved before the
* plugins are loaded. */
bt_io_error_quark();
if (config)
conf_disabled = g_key_file_get_string_list(config, "General",
"DisablePlugins",
NULL, NULL);
else
conf_disabled = NULL;
if (enable)
cli_enabled = g_strsplit_set(enable, ", ", -1);
else
cli_enabled = NULL;
if (disable)
cli_disabled = g_strsplit_set(disable, ", ", -1);
else
cli_disabled = NULL;
DBG("Loading builtin plugins");
for (i = 0; __bluetooth_builtin[i]; i++) {
if (!enable_plugin(__bluetooth_builtin[i]->name, conf_disabled,
cli_enabled, cli_disabled))
continue;
add_plugin(NULL, __bluetooth_builtin[i]);
}
if (strlen(PLUGINDIR) == 0)
goto start;
DBG("Loading plugins %s", PLUGINDIR);
dir = g_dir_open(PLUGINDIR, 0, NULL);
if (!dir)
goto start;
while ((file = g_dir_read_name(dir)) != NULL) {
struct bluetooth_plugin_desc *desc;
void *handle;
gchar *filename;
if (g_str_has_prefix(file, "lib") == TRUE ||
g_str_has_suffix(file, ".so") == FALSE)
continue;
filename = g_build_filename(PLUGINDIR, file, NULL);
handle = dlopen(filename, RTLD_NOW);
if (handle == NULL) {
error("Can't load plugin %s: %s", filename,
dlerror());
g_free(filename);
continue;
}
g_free(filename);
desc = dlsym(handle, "bluetooth_plugin_desc");
if (desc == NULL) {
error("Can't load plugin description: %s", dlerror());
dlclose(handle);
continue;
}
if (!enable_plugin(desc->name, conf_disabled,
cli_enabled, cli_disabled)) {
dlclose(handle);
continue;
}
if (add_plugin(handle, desc) == FALSE)
dlclose(handle);
}
g_dir_close(dir);
start:
for (list = plugins; list; list = list->next) {
struct bluetooth_plugin *plugin = list->data;
if (plugin->desc->init() < 0) {
error("Failed to init %s plugin", plugin->desc->name);
continue;
}
plugin->active = TRUE;
}
g_strfreev(conf_disabled);
g_strfreev(cli_enabled);
g_strfreev(cli_disabled);
return TRUE;
}
/*
* XXX - when we remove support for old-style plugins (which we should
* probably do eventually, as all plugins should be written as new-style
* ones), we may want to have "init_plugins()" merely save a pointer
* to the plugin's "init" routine, just as we save a pointer to its
* "reg_handoff" routine, and have a "register_all_plugins()" routine
* to go through the list of plugins and call all of them.
*
* Then we'd have "epan_init()", or perhaps even something higher up
* in the call tree, call "init_plugins()", and have "proto_init()"
* call "register_all_plugins()" right after calling "register_all_protocols()";
* this might be a bit cleaner.
*/
static void
plugins_scan_dir(const char *dirname)
{
#define FILENAME_LEN 1024
WS_DIR *dir; /* scanned directory */
WS_DIRENT *file; /* current file */
const char *name;
gchar filename[FILENAME_LEN]; /* current file name */
GModule *handle; /* handle returned by g_module_open */
gchar *version;
gpointer gp;
void (*register_protoinfo)(void);
void (*reg_handoff)(void);
void (*register_tap_listener)(void);
void (*register_wtap_module)(void);
void (*register_codec_module)(void);
gchar *dot;
int cr;
if ((dir = ws_dir_open(dirname, 0, NULL)) != NULL)
{
while ((file = ws_dir_read_name(dir)) != NULL)
{
name = ws_dir_get_name(file);
/*
* GLib 2.x defines G_MODULE_SUFFIX as the extension used on
* this platform for loadable modules.
*/
/* skip anything but files with G_MODULE_SUFFIX */
dot = strrchr(name, '.');
if (dot == NULL || strcmp(dot+1, G_MODULE_SUFFIX) != 0)
continue;
g_snprintf(filename, FILENAME_LEN, "%s" G_DIR_SEPARATOR_S "%s",
dirname, name);
if ((handle = g_module_open(filename, 0)) == NULL)
{
report_failure("Couldn't load module %s: %s", filename,
g_module_error());
continue;
}
if (!g_module_symbol(handle, "version", &gp))
{
report_failure("The plugin %s has no version symbol", name);
g_module_close(handle);
continue;
}
version = gp;
/*
* Do we have a register routine?
*/
if (g_module_symbol(handle, "plugin_register", &gp))
{
/*
* Yes - this plugin includes one or more dissectors.
*/
register_protoinfo = gp;
}
else
{
/*
* No - no dissectors.
*/
register_protoinfo = NULL;
}
/*
* Do we have a reg_handoff routine?
*/
if (g_module_symbol(handle, "plugin_reg_handoff", &gp))
{
/*
* Yes.
*/
reg_handoff = gp;
}
else
{
/*
* No - that's OK even if we have dissectors, as long
* as the plugin registers by name *and* there's
* a caller looking for that name.
*/
reg_handoff = NULL;
}
/*
* Do we have a register_tap_listener routine?
*/
if (g_module_symbol(handle, "plugin_register_tap_listener", &gp))
{
/*
* Yes - this plugin includes one or more taps.
*/
register_tap_listener = gp;
}
else
{
/*
* No - no taps here.
*/
register_tap_listener = NULL;
}
/*
* Do we have an old-style init routine?
*/
if (g_module_symbol(handle, "plugin_init", &gp))
{
/*
* Yes - do we also have a register routine or a
* register_tap_listener routine? If so, this is a bogus
* hybrid of an old-style and new-style plugin.
*/
if (register_protoinfo != NULL || register_tap_listener != NULL)
{
report_failure("The plugin '%s' has an old plugin init routine\nand a new register or register_tap_listener routine.",
name);
g_module_close(handle);
continue;
}
/*
* It's just an unsupported old-style plugin;
*/
report_failure("The plugin '%s' has an old plugin init routine. Support has been dropped.\n Information on how to update your plugin is available at \nhttp://anonsvn.wireshark.org/wireshark/trunk/doc/README.plugins",
name);
g_module_close(handle);
continue;
}
/*
* Do we have a register_wtap_module routine?
*/
if (g_module_symbol(handle, "register_wtap_module", &gp))
{
register_wtap_module = gp;
}
else
{
register_wtap_module = NULL;
}
/*
* Do we have a register_codec_module routine?
*/
if (g_module_symbol(handle, "register_codec_module", &gp))
{
register_codec_module = gp;
}
else
{
register_codec_module = NULL;
}
/*
* Does this dissector do anything useful?
*/
if (register_protoinfo == NULL &&
register_tap_listener == NULL &&
register_wtap_module == NULL &&
register_codec_module == NULL )
{
/*
* No.
*/
report_failure("The plugin '%s' has neither a register routine, "
"a register_tap_listener or a register_wtap_module or a register_codec_module routine",
name);
g_module_close(handle);
continue;
}
/*
* OK, attempt to add it to the list of plugins.
*/
if ((cr = add_plugin(handle, g_strdup(name), version,
register_protoinfo, reg_handoff,
register_tap_listener,register_wtap_module,register_codec_module)))
{
if (cr == EEXIST)
fprintf(stderr, "The plugin %s, version %s\n"
"was found in multiple directories\n", name, version);
else
fprintf(stderr, "Memory allocation problem\n"
"when processing plugin %s, version %s\n",
name, version);
g_module_close(handle);
continue;
}
}
ws_dir_close(dir);
}
}
static void add_to_output_plugins(hs_output_plugins* plugins,
hs_output_plugin* p)
{
bool added = false;
int idx = -1;
pthread_mutex_lock(&plugins->list_lock);
for (int i = 0; i < plugins->list_cap; ++i) {
if (!plugins->list[i]) {
idx = i;
} else if (strcmp(plugins->list[i]->sb->name, p->sb->name) == 0) {
idx = i;
remove_plugin(plugins, idx);
add_plugin(plugins, p, idx);
added = true;
break;
}
}
if (!added && idx != -1) add_plugin(plugins, p, idx);
if (idx == -1) {
// todo probably don't want to grow it by 1
++plugins->list_cap;
hs_output_plugin** tmp = realloc(plugins->list,
sizeof(hs_output_plugin*)
* plugins->list_cap);
idx = plugins->list_cap - 1;
if (tmp) {
plugins->list = tmp;
add_plugin(plugins, p, idx);
} else {
hs_log(g_module, 0, "plugins realloc failed");
exit(EXIT_FAILURE);
}
}
pthread_mutex_unlock(&plugins->list_lock);
assert(p->list_index >= 0);
hs_config* cfg = p->plugins->cfg;
// sync the output and read checkpoints
// the read and output checkpoints can differ to allow for batching
hs_lookup_input_checkpoint(&cfg->cp_reader,
hs_input_dir,
p->sb->name,
cfg->output_path,
&p->input.ib.cp);
p->cur.input.id = p->cp.input.id = p->input.ib.cp.id;
p->cur.input.offset = p->cp.input.offset = p->input.ib.cp.offset;
hs_lookup_input_checkpoint(&cfg->cp_reader,
hs_analysis_dir,
p->sb->name,
cfg->output_path,
&p->analysis.ib.cp);
p->cur.analysis.id = p->cp.analysis.id = p->analysis.ib.cp.id;
p->cur.analysis.offset = p->cp.analysis.offset = p->analysis.ib.cp.offset;
int ret = pthread_create(&p->thread, NULL, input_thread, (void*)p);
if (ret) {
perror("pthread_create failed");
exit(EXIT_FAILURE);
}
}
/* gets the list of mechanisms */
int _sasl_load_plugins(const add_plugin_list_t *entrypoints,
const sasl_callback_t *getpath_cb,
const sasl_callback_t *verifyfile_cb)
{
int result;
const add_plugin_list_t *cur_ep;
#ifdef DO_DLOPEN
char str[PATH_MAX], tmp[PATH_MAX+2], prefix[PATH_MAX+2];
/* 1 for '/' 1 for trailing '\0' */
char c;
int pos;
const char *path=NULL;
int position;
DIR *dp;
struct dirent *dir;
#endif
#ifndef PIC
add_plugin_t *add_plugin;
_sasl_plug_type type;
_sasl_plug_rec *p;
#endif
if (! entrypoints
|| ! getpath_cb
|| getpath_cb->id != SASL_CB_GETPATH
|| ! getpath_cb->proc
|| ! verifyfile_cb
|| verifyfile_cb->id != SASL_CB_VERIFYFILE
|| ! verifyfile_cb->proc)
return SASL_BADPARAM;
#ifndef PIC
/* do all the static plugins first */
for(cur_ep = entrypoints; cur_ep->entryname; cur_ep++) {
/* What type of plugin are we looking for? */
if(!strcmp(cur_ep->entryname, "sasl_server_plug_init")) {
type = SERVER;
add_plugin = (add_plugin_t *)sasl_server_add_plugin;
} else if (!strcmp(cur_ep->entryname, "sasl_client_plug_init")) {
type = CLIENT;
add_plugin = (add_plugin_t *)sasl_client_add_plugin;
} else if (!strcmp(cur_ep->entryname, "sasl_auxprop_plug_init")) {
type = AUXPROP;
add_plugin = (add_plugin_t *)sasl_auxprop_add_plugin;
} else if (!strcmp(cur_ep->entryname, "sasl_canonuser_init")) {
type = CANONUSER;
add_plugin = (add_plugin_t *)sasl_canonuser_add_plugin;
} else {
/* What are we looking for then? */
return SASL_FAIL;
}
for (p=_sasl_static_plugins; p->type; p++) {
if(type == p->type)
result = add_plugin(p->name, p->plug);
}
}
#endif /* !PIC */
/* only do the following if:
*
* we support dlopen()
* AND we are not staticly compiled
* OR we are staticly compiled and TRY_DLOPEN_WHEN_STATIC is defined
*/
#if defined(DO_DLOPEN) && (defined(PIC) || (!defined(PIC) && defined(TRY_DLOPEN_WHEN_STATIC)))
/* get the path to the plugins */
result = ((sasl_getpath_t *)(getpath_cb->proc))(getpath_cb->context,
&path);
if (result != SASL_OK) return result;
if (! path) return SASL_FAIL;
if (strlen(path) >= PATH_MAX) { /* no you can't buffer overrun */
return SASL_FAIL;
}
position=0;
do {
pos=0;
do {
c=path[position];
position++;
str[pos]=c;
pos++;
} while ((c!=':') && (c!='=') && (c!=0));
str[pos-1]='\0';
strcpy(prefix,str);
strcat(prefix,"/");
if ((dp=opendir(str)) !=NULL) /* ignore errors */
{
while ((dir=readdir(dp)) != NULL)
{
size_t length;
void *library;
char *c;
char plugname[PATH_MAX];
char name[PATH_MAX];
length = NAMLEN(dir);
if (length < 4)
continue; /* can not possibly be what we're looking for */
if (length + pos>=PATH_MAX) continue; /* too big */
if (strcmp(dir->d_name + (length - strlen(SO_SUFFIX)),
SO_SUFFIX)
&& strcmp(dir->d_name + (length - strlen(LA_SUFFIX)),
LA_SUFFIX))
continue;
memcpy(name,dir->d_name,length);
name[length]='\0';
result = _parse_la(prefix, name, tmp);
if(result != SASL_OK)
continue;
/* skip "lib" and cut off suffix --
this only need be approximate */
strcpy(plugname, name + 3);
c = strchr(plugname, (int)'.');
if(c) *c = '\0';
result = _sasl_get_plugin(tmp, verifyfile_cb, &library);
if(result != SASL_OK)
continue;
for(cur_ep = entrypoints; cur_ep->entryname; cur_ep++) {
_sasl_plugin_load(plugname, library, cur_ep->entryname,
cur_ep->add_plugin);
/* If this fails, it's not the end of the world */
}
}
closedir(dp);
} else {
_sasl_log(NULL, SASL_LOG_DEBUG,
"looking for plugins in '%s', failed to open directory, error: %s",
str,
strerror(errno));
}
} while ((c!='=') && (c!=0));
#endif /* defined(DO_DLOPEN) && (!defined(PIC) || (defined(PIC) && defined(TRY_DLOPEN_WHEN_STATIC))) */
return SASL_OK;
}
int main(int argc, char *argv[])
{
int c, cmd, ret;
conf_info_t info = {0};
char *config = DEFAULT_INTERNAL;
xmlKeepBlanksDefault(0);
xmlTreeIndentString = "\t";
if (argc < 2) {
usage(argv[0]);
return 1;
}
cmd = command_decode(argv[1]);
/* parse params */
while ((c = getopt_long(argc, argv, OPTSTRING, long_opts, NULL)) != -1) {
switch (c) {
case 'h':
usage(argv[0]);
return 0;
case 'c':
config = optarg;
break;
case 'p':
switch (optarg[0]) {
case 'i': case 'I':
info.type = PL_INPUT;
break;
case 'm': case 'M':
info.type = PL_INTERMEDIATE;
break;
case 'o': case 'O':
info.type = PL_OUTPUT;
break;
default:
fprintf(stderr, "Unknown plugin type '%c'\n", optarg[0]);
return 1;
}
break;
case 'n':
info.name = optarg;
break;
case 's':
info.sofile = optarg;
break;
case 't':
info.thread = optarg;
break;
case 'f':
info.force = 1;
break;
default:
return 1;
}
}
ret = open_xml(&info, config);
if (ret != 0) {
return 1;
}
switch (cmd) {
case CMD_ADD:
ret = add_plugin(&info);
break;
case CMD_REMOVE:
ret = remove_plugin(&info);
break;
case CMD_LIST:
ret = list_plugins(&info);
break;
default:
fprintf(stderr, "Unknown command '%s'\n", argv[1]);
ret = 1;
break;
}
if (ret == 0 && cmd != CMD_LIST) {
save_xml(&info, config);
}
close_xml(&info);
return ret;
}
int __connman_plugin_init(const char *pattern, const char *exclude)
{
GSList *list;
GDir *dir;
const gchar *file;
gchar *filename;
unsigned int i;
_DBG_PLUGIN("");
for (i = 0; __connman_builtin[i]; i++) {
if (check_plugin(__connman_builtin[i],
pattern, exclude) == FALSE)
continue;
add_plugin(NULL, __connman_builtin[i]);
}
dir = g_dir_open(PLUGINDIR, 0, NULL);
if (dir != NULL) {
while ((file = g_dir_read_name(dir)) != NULL) {
void *handle;
struct connman_plugin_desc *desc;
if (g_str_has_prefix(file, "lib") == TRUE ||
g_str_has_suffix(file, ".so") == FALSE)
continue;
filename = g_build_filename(PLUGINDIR, file, NULL);
handle = dlopen(filename, PLUGINFLAG);
if (handle == NULL) {
connman_error("Can't load %s: %s",
filename, dlerror());
g_free(filename);
continue;
}
g_free(filename);
desc = dlsym(handle, "connman_plugin_desc");
if (desc == NULL) {
connman_error("Can't load symbol: %s",
dlerror());
dlclose(handle);
continue;
}
if (check_plugin(desc, pattern, exclude) == FALSE) {
dlclose(handle);
continue;
}
if (add_plugin(handle, desc) == FALSE)
dlclose(handle);
}
g_dir_close(dir);
}
for (list = plugins; list; list = list->next) {
struct connman_plugin *plugin = list->data;
if (plugin->desc->init() < 0)
continue;
plugin->active = TRUE;
}
return 0;
}
/* gets the list of mechanisms */
int _sasl_load_plugins(const add_plugin_list_t *entrypoints,
const sasl_callback_t *getpath_cb,
const sasl_callback_t *verifyfile_cb)
{
int result;
TCHAR cur_dir[PATH_MAX], full_name[PATH_MAX+2], prefix[PATH_MAX+2];
/* 1 for '\\' 1 for trailing '\0' */
TCHAR * pattern;
TCHAR c;
int pos;
int retCode = SASL_OK;
char *utf8path = NULL;
TCHAR *path=NULL;
int position;
const add_plugin_list_t *cur_ep;
struct _stat statbuf; /* filesystem entry information */
intptr_t fhandle; /* file handle for _findnext function */
struct _tfinddata_t finddata; /* data returned by _findnext() */
size_t prefix_len;
/* for static plugins */
add_plugin_t *add_plugin;
_sasl_plug_type type;
_sasl_plug_rec *p;
if (! entrypoints
|| ! getpath_cb
|| getpath_cb->id != SASL_CB_GETPATH
|| ! getpath_cb->proc
|| ! verifyfile_cb
|| verifyfile_cb->id != SASL_CB_VERIFYFILE
|| ! verifyfile_cb->proc)
return SASL_BADPARAM;
/* do all the static plugins first */
for (cur_ep = entrypoints; cur_ep->entryname; cur_ep++) {
/* What type of plugin are we looking for? */
if (!strcmp(cur_ep->entryname, "sasl_server_plug_init")) {
type = SERVER;
add_plugin = (add_plugin_t *)sasl_server_add_plugin;
}
else if (!strcmp(cur_ep->entryname, "sasl_client_plug_init")) {
type = CLIENT;
add_plugin = (add_plugin_t *)sasl_client_add_plugin;
}
else if (!strcmp(cur_ep->entryname, "sasl_auxprop_plug_init")) {
type = AUXPROP;
add_plugin = (add_plugin_t *)sasl_auxprop_add_plugin;
}
else if (!strcmp(cur_ep->entryname, "sasl_canonuser_init")) {
type = CANONUSER;
add_plugin = (add_plugin_t *)sasl_canonuser_add_plugin;
}
else {
/* What are we looking for then? */
return SASL_FAIL;
}
for (p = _sasl_static_plugins; p->type; p++) {
if (type == p->type)
result = add_plugin(p->name, p->plug);
}
}
/* get the path to the plugins */
result = ((sasl_getpath_t *)(getpath_cb->proc))(getpath_cb->context,
&utf8path);
if (result != SASL_OK) return result;
if (!utf8path) return SASL_FAIL;
if (sizeof(TCHAR) == sizeof(char)) {
path = (TCHAR*)utf8path;
}
else {
path = _sasl_utf8_to_wchar(utf8path);
if (!path) return SASL_FAIL;
}
if (_tcslen(path) >= PATH_MAX) { /* no you can't buffer overrun */
retCode = SASL_FAIL;
goto cleanup;
}
position=0;
do {
pos=0;
do {
c=path[position];
position++;
cur_dir[pos]=c;
pos++;
} while ((c!=PATHS_DELIMITER) && (c!=0));
cur_dir[pos-1]='\0';
/* : check to make sure that a valid directory name was passed in */
if (_tstat (cur_dir, &statbuf) < 0) {
continue;
}
if ((statbuf.st_mode & S_IFDIR) == 0) {
continue;
}
_tcscpy(prefix, cur_dir);
prefix_len = _tcslen (prefix);
/* : Don't append trailing \ unless required */
if (prefix[prefix_len-1] != '\\') {
_tcscat(prefix,_T("\\"));
prefix_len++;
}
pattern = prefix;
/* : Check that we have enough space for "*.dll" */
if ((prefix_len + DLL_MASK_LEN) > (sizeof(prefix) / sizeof(TCHAR) - 1)) {
_sasl_log(NULL, SASL_LOG_WARN, "plugin search mask is too big");
continue;
}
_tcscat (prefix + prefix_len, _T("*") DLL_SUFFIX);
fhandle = _tfindfirst (pattern, &finddata);
if (fhandle == -1) { /* no matching files */
continue;
}
/* : Truncate "*.dll" */
prefix[prefix_len] = '\0';
do {
size_t length;
void *library;
char *c;
char plugname[PATH_MAX];
int entries;
length = _tcslen(finddata.name);
if (length < 5) { /* At least <Ch>.dll */
continue; /* can not possibly be what we're looking for */
}
/* : Check for overflow */
if (length + prefix_len >= PATH_MAX) continue; /* too big */
if (_tcscmp(finddata.name + (length - _tcslen(DLL_SUFFIX)), DLL_SUFFIX) != 0) {
continue;
}
/* : Check that it is not a directory */
if ((finddata.attrib & _A_SUBDIR) == _A_SUBDIR) {
continue;
}
/* : Construct full name from prefix and name */
_tcscpy (full_name, prefix);
_tcscat (full_name, finddata.name);
/* cut off .dll suffix -- this only need be approximate */
if (sizeof(TCHAR) != sizeof(char)) {
if (WideCharToMultiByte(CP_UTF8, 0, finddata.name, -1, plugname, sizeof(plugname), NULL, NULL) == 0) { // in case of unicode use utf8
continue;
}
}
else {
_tcscpy((TCHAR*)plugname, finddata.name); // w/o unicode local enconding is fine
}
c = strchr(plugname, '.');
if (c != NULL) *c = '\0';
result = _tsasl_get_plugin (full_name, verifyfile_cb, &library);
if (result != SASL_OK) {
continue;
}
entries = 0;
for (cur_ep = entrypoints; cur_ep->entryname; cur_ep++) {
result = _sasl_plugin_load(plugname,
library,
cur_ep->entryname,
cur_ep->add_plugin);
if (result == SASL_OK) {
++entries;
}
/* If this fails, it's not the end of the world */
}
if (entries == 0) {
_sasl_remove_last_plugin();
}
} while (_tfindnext (fhandle, &finddata) == 0);
_findclose (fhandle);
} while ((c!='=') && (c!=0));
cleanup:
if (sizeof(TCHAR) != sizeof(char)) {
sasl_FREE(path); /* It's always allocated in coversion to wchar */
}
return retCode;
}
VisualShaderEditor::VisualShaderEditor() {
singleton = this;
updating = false;
graph = memnew(GraphEdit);
add_child(graph);
graph->add_valid_right_disconnect_type(VisualShaderNode::PORT_TYPE_SCALAR);
graph->add_valid_right_disconnect_type(VisualShaderNode::PORT_TYPE_VECTOR);
graph->add_valid_right_disconnect_type(VisualShaderNode::PORT_TYPE_TRANSFORM);
//graph->add_valid_left_disconnect_type(0);
graph->set_v_size_flags(SIZE_EXPAND_FILL);
graph->connect("connection_request", this, "_connection_request", varray(), CONNECT_DEFERRED);
graph->connect("disconnection_request", this, "_disconnection_request", varray(), CONNECT_DEFERRED);
graph->connect("node_selected", this, "_node_selected");
graph->connect("scroll_offset_changed", this, "_scroll_changed");
graph->connect("duplicate_nodes_request", this, "_duplicate_nodes");
graph->add_valid_connection_type(VisualShaderNode::PORT_TYPE_SCALAR, VisualShaderNode::PORT_TYPE_SCALAR);
graph->add_valid_connection_type(VisualShaderNode::PORT_TYPE_SCALAR, VisualShaderNode::PORT_TYPE_VECTOR);
graph->add_valid_connection_type(VisualShaderNode::PORT_TYPE_VECTOR, VisualShaderNode::PORT_TYPE_SCALAR);
graph->add_valid_connection_type(VisualShaderNode::PORT_TYPE_VECTOR, VisualShaderNode::PORT_TYPE_VECTOR);
graph->add_valid_connection_type(VisualShaderNode::PORT_TYPE_TRANSFORM, VisualShaderNode::PORT_TYPE_TRANSFORM);
VSeparator *vs = memnew(VSeparator);
graph->get_zoom_hbox()->add_child(vs);
graph->get_zoom_hbox()->move_child(vs, 0);
edit_type = memnew(OptionButton);
edit_type->add_item(TTR("Vertex"));
edit_type->add_item(TTR("Fragment"));
edit_type->add_item(TTR("Light"));
edit_type->select(1);
edit_type->connect("item_selected", this, "_mode_selected");
graph->get_zoom_hbox()->add_child(edit_type);
graph->get_zoom_hbox()->move_child(edit_type, 0);
add_node = memnew(MenuButton);
graph->get_zoom_hbox()->add_child(add_node);
add_node->set_text(TTR("Add Node..."));
graph->get_zoom_hbox()->move_child(add_node, 0);
add_node->get_popup()->connect("id_pressed", this, "_add_node");
add_options.push_back(AddOption("Scalar", "Constants", "VisualShaderNodeScalarConstant"));
add_options.push_back(AddOption("Vector", "Constants", "VisualShaderNodeVec3Constant"));
add_options.push_back(AddOption("Color", "Constants", "VisualShaderNodeColorConstant"));
add_options.push_back(AddOption("Transform", "Constants", "VisualShaderNodeTransformConstant"));
add_options.push_back(AddOption("Texture", "Constants", "VisualShaderNodeTexture"));
add_options.push_back(AddOption("CubeMap", "Constants", "VisualShaderNodeCubeMap"));
add_options.push_back(AddOption("ScalarOp", "Operators", "VisualShaderNodeScalarOp"));
add_options.push_back(AddOption("VectorOp", "Operators", "VisualShaderNodeVectorOp"));
add_options.push_back(AddOption("ColorOp", "Operators", "VisualShaderNodeColorOp"));
add_options.push_back(AddOption("TransformMult", "Operators", "VisualShaderNodeTransformMult"));
add_options.push_back(AddOption("TransformVectorMult", "Operators", "VisualShaderNodeTransformVecMult"));
add_options.push_back(AddOption("ScalarFunc", "Functions", "VisualShaderNodeScalarFunc"));
add_options.push_back(AddOption("VectorFunc", "Functions", "VisualShaderNodeVectorFunc"));
add_options.push_back(AddOption("DotProduct", "Functions", "VisualShaderNodeDotProduct"));
add_options.push_back(AddOption("VectorLen", "Functions", "VisualShaderNodeVectorLen"));
add_options.push_back(AddOption("ScalarInterp", "Interpolation", "VisualShaderNodeScalarInterp"));
add_options.push_back(AddOption("VectorInterp", "Interpolation", "VisualShaderNodeVectorInterp"));
add_options.push_back(AddOption("VectorCompose", "Compose", "VisualShaderNodeVectorCompose"));
add_options.push_back(AddOption("TransformCompose", "Compose", "VisualShaderNodeTransformCompose"));
add_options.push_back(AddOption("VectorDecompose", "Decompose", "VisualShaderNodeVectorDecompose"));
add_options.push_back(AddOption("TransformDecompose", "Decompose", "VisualShaderNodeTransformDecompose"));
add_options.push_back(AddOption("Scalar", "Uniforms", "VisualShaderNodeScalarUniform"));
add_options.push_back(AddOption("Vector", "Uniforms", "VisualShaderNodeVec3Uniform"));
add_options.push_back(AddOption("Color", "Uniforms", "VisualShaderNodeColorUniform"));
add_options.push_back(AddOption("Transform", "Uniforms", "VisualShaderNodeTransformUniform"));
add_options.push_back(AddOption("Texture", "Uniforms", "VisualShaderNodeTextureUniform"));
add_options.push_back(AddOption("CubeMap", "Uniforms", "VisualShaderNodeCubeMapUniform"));
add_options.push_back(AddOption("Input", "Inputs", "VisualShaderNodeInput"));
_update_options_menu();
error_panel = memnew(PanelContainer);
add_child(error_panel);
error_label = memnew(Label);
error_panel->add_child(error_label);
error_label->set_text("eh");
error_panel->hide();
undo_redo = EditorNode::get_singleton()->get_undo_redo();
Ref<VisualShaderNodePluginDefault> default_plugin;
default_plugin.instance();
add_plugin(default_plugin);
property_editor = memnew(CustomPropertyEditor);
add_child(property_editor);
property_editor->connect("variant_changed", this, "_port_edited");
}
static void
plugins_scan_dir(const char *dirname)
{
#define FILENAME_LEN 1024
WS_DIR *dir; /* scanned directory */
WS_DIRENT *file; /* current file */
const char *name;
gchar filename[FILENAME_LEN]; /* current file name */
GModule *handle; /* handle returned by g_module_open */
gpointer gp;
plugin *new_plug;
gchar *dot;
int cr;
if ((dir = ws_dir_open(dirname, 0, NULL)) != NULL)
{
while ((file = ws_dir_read_name(dir)) != NULL)
{
name = ws_dir_get_name(file);
/*
* GLib 2.x defines G_MODULE_SUFFIX as the extension used on
* this platform for loadable modules.
*/
/* skip anything but files with G_MODULE_SUFFIX */
dot = strrchr(name, '.');
if (dot == NULL || strcmp(dot+1, G_MODULE_SUFFIX) != 0)
continue;
g_snprintf(filename, FILENAME_LEN, "%s" G_DIR_SEPARATOR_S "%s",
dirname, name);
if ((handle = g_module_open(filename, (GModuleFlags)0)) == NULL)
{
report_failure("Couldn't load module %s: %s", filename,
g_module_error());
continue;
}
if (!g_module_symbol(handle, "version", &gp))
{
report_failure("The plugin %s has no version symbol", name);
g_module_close(handle);
continue;
}
new_plug = (plugin *)g_malloc(sizeof(plugin));
new_plug->handle = handle;
new_plug->name = g_strdup(name);
new_plug->version = (char *)gp;
new_plug->types = 0;
new_plug->next = NULL;
/*
* Hand the plugin to each of the plugin type callbacks.
*/
g_slist_foreach(plugin_types, call_plugin_callback, new_plug);
/*
* Does this dissector do anything useful?
*/
if (new_plug->types == 0)
{
/*
* No.
*/
report_failure("The plugin '%s' has no registration routines",
name);
g_module_close(handle);
g_free(new_plug->name);
g_free(new_plug);
continue;
}
/*
* OK, attempt to add it to the list of plugins.
*/
if ((cr = add_plugin(new_plug)))
{
if (cr == EEXIST)
fprintf(stderr, "The plugin %s, version %s\n"
"was found in multiple directories\n",
new_plug->name, new_plug->version);
else
fprintf(stderr, "Memory allocation problem\n"
"when processing plugin %s, version %s\n",
new_plug->name, new_plug->version);
g_module_close(handle);
g_free(new_plug->name);
g_free(new_plug);
continue;
}
}
ws_dir_close(dir);
}
}
static void
plugins_scan_dir(const char *dirname, plugin_load_failure_mode mode)
{
#define FILENAME_LEN 1024
WS_DIR *dir; /* scanned directory */
WS_DIRENT *file; /* current file */
const char *name;
gchar filename[FILENAME_LEN]; /* current file name */
GModule *handle; /* handle returned by g_module_open */
gpointer gp;
plugin *new_plug;
gchar *dot;
int cr;
if ((dir = ws_dir_open(dirname, 0, NULL)) != NULL)
{
while ((file = ws_dir_read_name(dir)) != NULL)
{
name = ws_dir_get_name(file);
/*
* GLib 2.x defines G_MODULE_SUFFIX as the extension used on
* this platform for loadable modules.
*/
/* skip anything but files with G_MODULE_SUFFIX */
dot = strrchr(name, '.');
if (dot == NULL || strcmp(dot+1, G_MODULE_SUFFIX) != 0)
continue;
g_snprintf(filename, FILENAME_LEN, "%s" G_DIR_SEPARATOR_S "%s",
dirname, name);
if ((handle = g_module_open(filename, G_MODULE_BIND_LOCAL)) == NULL)
{
/*
* Only report load failures if we were asked to.
*
* XXX - we really should put different types of plugins
* (libwiretap, libwireshark) in different subdirectories,
* give libwiretap and libwireshark init routines that
* load the plugins, and have them scan the appropriate
* subdirectories so tha we don't even *try* to, for
* example, load libwireshark plugins in programs that
* only use libwiretap.
*/
if (mode == REPORT_LOAD_FAILURE) {
report_failure("Couldn't load module %s: %s", filename,
g_module_error());
}
continue;
}
if (!g_module_symbol(handle, "version", &gp))
{
report_failure("The plugin %s has no version symbol", name);
g_module_close(handle);
continue;
}
new_plug = (plugin *)g_malloc(sizeof(plugin));
new_plug->handle = handle;
new_plug->name = g_strdup(name);
new_plug->version = (char *)gp;
new_plug->types = 0;
new_plug->next = NULL;
/*
* Hand the plugin to each of the plugin type callbacks.
*/
g_slist_foreach(plugin_types, call_plugin_callback, new_plug);
/*
* Does this dissector do anything useful?
*/
if (new_plug->types == 0)
{
/*
* No.
*
* Only report this failure if we were asked to; it might
* just mean that it's a plugin type that this program
* doesn't support, such as a libwireshark plugin in
* a program that doesn't use libwireshark.
*
* XXX - we really should put different types of plugins
* (libwiretap, libwireshark) in different subdirectories,
* give libwiretap and libwireshark init routines that
* load the plugins, and have them scan the appropriate
* subdirectories so tha we don't even *try* to, for
* example, load libwireshark plugins in programs that
* only use libwiretap.
*/
if (mode == REPORT_LOAD_FAILURE) {
report_failure("The plugin '%s' has no registration routines",
name);
}
g_module_close(handle);
g_free(new_plug->name);
g_free(new_plug);
continue;
}
/*
* OK, attempt to add it to the list of plugins.
*/
cr = add_plugin(new_plug);
if (cr != 0)
{
g_assert(cr == EEXIST);
fprintf(stderr, "The plugin '%s' version %s "
"was found in multiple directories.\n",
new_plug->name, new_plug->version);
g_module_close(handle);
g_free(new_plug->name);
g_free(new_plug);
continue;
}
}
ws_dir_close(dir);
}
}
