static int plibltpdl_open(const char *fname, bool use_ext, bool private_namespace,
pmix_pdl_handle_t **handle, char **err_msg)
{
assert(handle);
*handle = NULL;
if (NULL != err_msg) {
*err_msg = NULL;
}
lt_dlhandle local_handle;
#if PMIX_DL_LIBLTDL_HAVE_LT_DLADVISE
pmix_pdl_plibltpdl_component_t *c = &mca_pdl_plibltpdl_component;
if (use_ext && private_namespace) {
local_handle = lt_dlopenadvise(fname, c->advise_private_ext);
} else if (use_ext && !private_namespace) {
local_handle = lt_dlopenadvise(fname, c->advise_public_ext);
} else if (!use_ext && private_namespace) {
local_handle = lt_dlopenadvise(fname, c->advise_private_noext);
} else if (!use_ext && !private_namespace) {
local_handle = lt_dlopenadvise(fname, c->advise_public_noext);
}
#else
if (use_ext) {
local_handle = lt_dlopenext(fname);
} else {
local_handle = lt_dlopen(fname);
}
#endif
if (NULL != local_handle) {
*handle = calloc(1, sizeof(pmix_pdl_handle_t));
(*handle)->ltpdl_handle = local_handle;
#if PMIX_ENABLE_DEBUG
if( NULL != fname ) {
(*handle)->filename = strdup(fname);
}
else {
(*handle)->filename = strdup("(null)");
}
#endif
return PMIX_SUCCESS;
}
if (NULL != err_msg) {
*err_msg = (char*) lt_dlerror();
}
return PMIX_ERROR;
}
/*
* (Try to) load the shared object `file'. Won't complain if it isn't a shared
* object, but it will bitch about a shared object not having a
* ``module_register'' symbol..
*/
static int plugin_load_file (char *file, uint32_t flags)
{
lt_dlhandle dlh;
void (*reg_handle) (void);
lt_dlinit ();
lt_dlerror (); /* clear errors */
#if LIBTOOL_VERSION == 2
if (flags & PLUGIN_FLAGS_GLOBAL) {
lt_dladvise advise;
lt_dladvise_init(&advise);
lt_dladvise_global(&advise);
dlh = lt_dlopenadvise(file, advise);
lt_dladvise_destroy(&advise);
} else {
dlh = lt_dlopen (file);
}
#else /* if LIBTOOL_VERSION == 1 */
if (flags & PLUGIN_FLAGS_GLOBAL)
WARNING ("plugin_load_file: The global flag is not supported, "
"libtool 2 is required for this.");
dlh = lt_dlopen (file);
#endif
if (dlh == NULL)
{
char errbuf[1024] = "";
ssnprintf (errbuf, sizeof (errbuf),
"lt_dlopen (\"%s\") failed: %s. "
"The most common cause for this problem are "
"missing dependencies. Use ldd(1) to check "
"the dependencies of the plugin "
"/ shared object.",
file, lt_dlerror ());
ERROR ("%s", errbuf);
/* Make sure this is printed to STDERR in any case, but also
* make sure it's printed only once. */
if (list_log != NULL)
fprintf (stderr, "ERROR: %s\n", errbuf);
return (1);
}
if ((reg_handle = (void (*) (void)) lt_dlsym (dlh, "module_register")) == NULL)
{
WARNING ("Couldn't find symbol \"module_register\" in \"%s\": %s\n",
file, lt_dlerror ());
lt_dlclose (dlh);
return (-1);
}
(*reg_handle) ();
return (0);
}
lt_dlhandle sbncLoadLibrary(const char *Filename) {
lt_dlhandle handle = 0;
lt_dladvise advise;
if (!lt_dladvise_init(&advise) && !lt_dladvise_global(&advise)) {
handle = lt_dlopenadvise(Filename, advise);
}
lt_dladvise_destroy(&advise);
return handle;
}
static int
plugins_open_plugin(const char *filename, void *data)
{
struct plugin_class *plcl;
lt_dlhandle handle;
if (!(handle = lt_dlopenadvise(filename, *(lt_dladvise *)data))) {
VLOG_ERR("Failed loading %s: %s", filename, lt_dlerror());
return 0;
}
if (!(plcl = (struct plugin_class *)malloc(sizeof(struct plugin_class)))) {
VLOG_ERR("Couldn't allocate plugin class");
goto err_plugin_class;
}
if (!(plcl->init = lt_dlsym(handle, "init")) ||
!(plcl->run = lt_dlsym(handle, "run")) ||
!(plcl->wait = lt_dlsym(handle, "wait")) ||
!(plcl->destroy = lt_dlsym(handle, "destroy"))) {
VLOG_ERR("Couldn't initialize the interface for %s", filename);
goto err_dlsym;
}
// The following APIs are optional, so don't fail if they are missing.
plcl->netdev_register = lt_dlsym(handle, "netdev_register");
plcl->ofproto_register = lt_dlsym(handle, "ofproto_register");
plcl->bufmon_register = lt_dlsym(handle, "bufmon_register");
if (lt_dlcaller_set_data(interface_id, handle, plcl)) {
VLOG_ERR("plugin %s initialized twice? must be a bug", filename);
goto err_set_data;
}
plcl->init();
VLOG_INFO("Loaded plugin library %s", filename);
return 0;
err_set_data:
err_dlsym:
free(plcl);
err_plugin_class:
if (lt_dlclose(handle)) {
VLOG_ERR("Couldn't dlclose %s", filename);
}
return 0;
}
/*
* Load shared module using the equivalent of the RTLD_GLOBAL flag
*/
static lt_dlhandle
dlopenext_global (const char *filename)
{
lt_dlhandle handle = 0;
lt_dladvise advise;
if (!lt_dladvise_init (&advise)
&& !lt_dladvise_ext (&advise)
&& !lt_dladvise_global(&advise))
handle = lt_dlopenadvise (filename, advise);
lt_dladvise_destroy (&advise);
return handle;
}
static lt_dlhandle
my_dlopen(const char *filename)
{
lt_dlhandle handle = 0;
lt_dladvise advice[1];
if (!lt_dladvise_init(advice) &&
!lt_dladvise_ext(advice) &&
!lt_dladvise_global(advice)) {
handle = lt_dlopenadvise(filename, advice[0]);
}
lt_dladvise_destroy(advice);
return handle;
}
/*
* (Try to) load the shared object `file'. Won't complain if it isn't a shared
* object, but it will bitch about a shared object not having a
* ``module_register'' symbol..
*/
static int plugin_load_file (char *file, uint32_t flags)
{
lt_dlhandle dlh;
void (*reg_handle) (void);
DEBUG ("file = %s", file);
lt_dlinit ();
lt_dlerror (); /* clear errors */
#if LIBTOOL_VERSION == 2
if (flags & PLUGIN_FLAGS_GLOBAL) {
lt_dladvise advise;
lt_dladvise_init(&advise);
lt_dladvise_global(&advise);
dlh = lt_dlopenadvise(file, advise);
lt_dladvise_destroy(&advise);
} else {
dlh = lt_dlopen (file);
}
#else /* if LIBTOOL_VERSION == 1 */
if (flags & PLUGIN_FLAGS_GLOBAL)
ERROR ("plugin_load_file: The global flag is not supported, "
"libtool 2 is required for this.");
dlh = lt_dlopen (file);
#endif
if (dlh == NULL)
{
const char *error = lt_dlerror ();
ERROR ("lt_dlopen (%s) failed: %s", file, error);
fprintf (stderr, "lt_dlopen (%s) failed: %s\n", file, error);
return (1);
}
if ((reg_handle = (void (*) (void)) lt_dlsym (dlh, "module_register")) == NULL)
{
WARNING ("Couldn't find symbol `module_register' in `%s': %s\n",
file, lt_dlerror ());
lt_dlclose (dlh);
return (-1);
}
(*reg_handle) ();
return (0);
}
static int open_plugin(const char *filename,
lt_dlhandle * handle, cci_plugin_t ** plugin,
cci_plugins_framework_verify_fn_t verify)
{
char *p1, *p2, struct_name[BUFSIZ];
char *local = strdup(filename);
if (NULL == local) {
return CCI_ENOMEM;
}
/* Open the DSO */
*handle = lt_dlopenadvise(local, cci_plugins_dladvise);
if (NULL == *handle) {
fprintf(stderr, "Failed to open plugin %s: %s\n",
filename, lt_dlerror());
free(local);
return CCI_ERROR;
}
/* Make the struct symbol name */
p1 = strrchr(local, '/');
if (NULL == p1) {
p1 = local;
} else {
++p1;
}
p2 = strchr(p1, '.');
if (NULL != p2) {
*p2 = '\0';
}
/* Find the symbol name */
snprintf(struct_name, BUFSIZ - 1, "%s_plugin", p1);
free(local);
struct_name[BUFSIZ - 1] = '\0';
*plugin = lt_dlsym(*handle, struct_name);
if (NULL == *plugin) {
fprintf(stderr,
"Unable to find \"%s\" symbol in %s -- ignored\n",
struct_name, filename);
goto bad;
}
/* Version check */
if ((*plugin)->cci_abi_version != CCI_ABI_VERSION) {
fprintf(stderr,
"Plugin \"%s\" in %s supports ABI version %d; only version %d is supported -- ignored\n",
(*plugin)->plugin_name, filename,
(*plugin)->cci_abi_version, CCI_ABI_VERSION);
goto bad;
}
/* See if the framework likes it */
if (NULL != verify && CCI_SUCCESS != verify(*plugin)) {
goto bad;
}
/* Alles gut */
return CCI_SUCCESS;
bad:
lt_dlclose(*handle);
return CCI_ERROR;
}
void datasource_cache::register_datasources(const std::string& str)
{
#ifdef MAPNIK_THREADSAFE
mutex::scoped_lock lock(mapnik::singleton<mapnik::datasource_cache,
mapnik::CreateStatic>::mutex_);
#endif
boost::filesystem::path path(str);
plugin_directories_.push_back(str);
boost::filesystem::directory_iterator end_itr;
if (exists(path) && is_directory(path))
{
for (boost::filesystem::directory_iterator itr(path);itr!=end_itr;++itr )
{
#if BOOST_VERSION < 103400
if (!is_directory( *itr ) && is_input_plugin(itr->leaf()))
#else
#if (BOOST_FILESYSTEM_VERSION == 3)
if (!is_directory( *itr ) && is_input_plugin(itr->path().filename().string()))
#else // v2
if (!is_directory( *itr ) && is_input_plugin(itr->path().leaf()))
#endif
#endif
{
try
{
#ifdef LIBTOOL_SUPPORTS_ADVISE
/* Note: the below was added as a workaround pre http://trac.mapnik.org/ticket/790
It could now be removed, but also is not doing any harm AFAICT.
*/
// with ltdl >=2.2 we can actually pass RTDL_GLOBAL to dlopen via the
// ltdl advise trick which is required on linux unless plugins are directly
// linked to libmapnik (and deps) at build time. The only other approach is to
// set the dlopen flags in the calling process (like in the python bindings)
// clear errors
lt_dlerror();
lt_dlhandle module = 0;
lt_dladvise advise;
int ret;
ret = lt_dlinit();
if (ret != 0) {
std::clog << "Datasource loader: could not intialize dynamic loading: " << lt_dlerror() << "\n";
}
ret = lt_dladvise_init(&advise);
if (ret != 0) {
std::clog << "Datasource loader: could not intialize dynamic loading: " << lt_dlerror() << "\n";
}
ret = lt_dladvise_global(&advise);
if (ret != 0) {
std::clog << "Datasource loader: could not intialize dynamic loading of global symbols: " << lt_dlerror() << "\n";
}
#if (BOOST_FILESYSTEM_VERSION == 3)
module = lt_dlopenadvise (itr->path().string().c_str(), advise);
#else // v2
module = lt_dlopenadvise (itr->string().c_str(), advise);
#endif
lt_dladvise_destroy(&advise);
#else
#if (BOOST_FILESYSTEM_VERSION == 3)
lt_dlhandle module = lt_dlopen(itr->path().string().c_str());
#else // v2
lt_dlhandle module = lt_dlopen(itr->string().c_str());
#endif
#endif
if (module)
{
// http://www.mr-edd.co.uk/blog/supressing_gcc_warnings
#ifdef __GNUC__
__extension__
#endif
datasource_name* ds_name =
reinterpret_cast<datasource_name*>(lt_dlsym(module, "datasource_name"));
if (ds_name && insert(ds_name(),module))
{
#ifdef MAPNIK_DEBUG
std::clog << "Datasource loader: registered: " << ds_name() << std::endl;
#endif
registered_=true;
}
}
else
{
#if (BOOST_FILESYSTEM_VERSION == 3)
std::clog << "Problem loading plugin library: " << itr->path().string()
<< " (dlopen failed - plugin likely has an unsatisfied dependency or incompatible ABI)" << std::endl;
#else // v2
std::clog << "Problem loading plugin library: " << itr->string()
<< " (dlopen failed - plugin likely has an unsatisfied dependency or incompatible ABI)" << std::endl;
#endif
}
}
catch (...) {}
}
}
}
}
static int dso_load_module(char *name) {
int res;
char *symbol_name, *path, *tmp;
module *m;
lt_ptr mh = NULL;
lt_dladvise advise;
if (name == NULL) {
errno = EINVAL;
return -1;
}
if (strncmp(name, "mod_", 4) != 0 ||
name[strlen(name)-2] != '.' ||
name[strlen(name)-1] != 'c') {
errno = EINVAL;
return -1;
}
pr_log_debug(DEBUG7, "loading '%s'", name);
tmp = strrchr(name, '.');
if (tmp == NULL) {
errno = EINVAL;
return -1;
}
if (lt_dladvise_init(&advise) < 0) {
pr_log_pri(PR_LOG_NOTICE, MOD_DSO_VERSION
": unable to initialise advise: %s", lt_dlerror());
errno = EPERM;
return -1;
}
if (lt_dladvise_ext(&advise) < 0) {
pr_log_pri(PR_LOG_NOTICE, MOD_DSO_VERSION
": unable to setting 'ext' advise hint: %s", lt_dlerror());
lt_dladvise_destroy(&advise);
errno = EPERM;
return -1;
}
if (lt_dladvise_global(&advise) < 0) {
pr_log_pri(PR_LOG_NOTICE, MOD_DSO_VERSION
": unable to setting 'global' advise hint: %s", lt_dlerror());
lt_dladvise_destroy(&advise);
errno = EPERM;
return -1;
}
*tmp = '\0';
/* Load file: $prefix/libexec/<module> */
path = pdircat(dso_pool, dso_module_path, name, NULL);
pr_trace_msg(trace_channel, 5, "loading module '%s'", path);
mh = lt_dlopenadvise(path, advise);
if (mh == NULL) {
*tmp = '.';
pr_log_debug(DEBUG3, MOD_DSO_VERSION ": unable to dlopen '%s': %s (%s)",
name, lt_dlerror(), strerror(errno));
pr_log_debug(DEBUG3, MOD_DSO_VERSION
": defaulting to 'self' for symbol resolution");
lt_dladvise_destroy(&advise);
mh = lt_dlopen(NULL);
if (mh == NULL) {
pr_log_debug(DEBUG0, MOD_DSO_VERSION ": error loading 'self': %s",
lt_dlerror());
if (errno == ENOENT) {
pr_log_pri(PR_LOG_NOTICE, MOD_DSO_VERSION
": check to see if '%s.la' exists", path);
}
return -1;
}
}
lt_dladvise_destroy(&advise);
/* Tease name of the module structure out of the given name:
* <module>.<ext> --> <module>_module
*/
*tmp = '\0';
symbol_name = pstrcat(dso_pool, name+4, "_module", NULL);
/* Lookup module structure symbol by name. */
pr_trace_msg(trace_channel, 7, "looking for symbol '%s' in loaded module",
symbol_name);
m = (module *) lt_dlsym(mh, symbol_name);
if (m == NULL) {
*tmp = '.';
pr_log_debug(DEBUG1, MOD_DSO_VERSION
": unable to find module symbol '%s' in '%s'", symbol_name,
mh ? name : "self");
pr_trace_msg(trace_channel, 1, "unable to find module symbol '%s' in '%s'",
symbol_name, mh ? name : "self");
lt_dlclose(mh);
mh = NULL;
if (errno == ENOENT) {
pr_log_pri(PR_LOG_NOTICE,
MOD_DSO_VERSION ": check to see if '%s.la' exists", path);
}
return -1;
}
*tmp = '.';
m->handle = mh;
/* Add the module to the core structures */
res = pr_module_load(m);
if (res < 0) {
if (errno == EEXIST) {
pr_log_pri(PR_LOG_INFO, MOD_DSO_VERSION
": module 'mod_%s.c' already loaded", m->name);
pr_trace_msg(trace_channel, 1, "module 'mod_%s.c' already loaded",
m->name);
} else if (errno == EACCES) {
pr_log_pri(PR_LOG_ERR, MOD_DSO_VERSION
": module 'mod_%s.c' has wrong API version (0x%x), must be 0x%x",
m->name, m->api_version, PR_MODULE_API_VERSION);
pr_trace_msg(trace_channel, 1,
"module 'mod_%s.c' has wrong API version (0x%x), must be 0x%x",
m->name, m->api_version, PR_MODULE_API_VERSION);
} else if (errno == EPERM) {
pr_log_pri(PR_LOG_ERR, MOD_DSO_VERSION
": module 'mod_%s.c' failed to initialize", m->name);
pr_trace_msg(trace_channel, 1, "module 'mod_%s.c' failed to initialize",
m->name);
}
lt_dlclose(mh);
mh = NULL;
return -1;
}
pr_trace_msg(trace_channel, 8, "module '%s' successfully loaded", path);
return 0;
}
static int do_test(void)
{
FILE *fp;
char filename[] = "./libompi_dbg_msgq";
char full_filename[] = "./libompi_dbg_msgq.la";
char line[1024];
int happy;
lt_dlhandle dlhandle;
#if OPAL_HAVE_LTDL_ADVISE
lt_dladvise dladvise;
#endif
/* Double check that the .la file is there that we expect; if it's
not, skip this test. */
fp = fopen(full_filename, "r");
if (NULL == fp) {
fprintf(stderr,
"File %s.la doesn't seem to exist; skipping this test\n",
full_filename);
exit(77);
}
/* We know the .la file is there, so read it, looking for the
dlopen value. If the dlopen value is '' (i.e., empty), then
there's nothing to dlopen (i.e., OMPI was built with
--enable-static --disable-shared, so return 77 to skip this
test. This is horrible, but I can't think of a better way to
check it (since there is no good way to #define whether we have
built statically or not...). */
happy = 0;
while (1) {
if (0 == fgets(line, sizeof(line) - 1, fp)) {
break;
}
if (0 == strncmp(line, "dlname=", 7)) {
if (0 == strncmp(line + 7, "''", 2)) {
happy = 0;
} else {
happy = 1;
}
break;
}
}
fclose(fp);
if (!happy) {
fprintf(stderr, "No test file to dlopen (perhaps --enable-static?); skipping\n");
exit(77);
}
/* Startup LT */
if (lt_dlinit() != 0) {
fprintf(stderr, "Failed to lt_dlinit\n");
return 1;
}
printf("Trying to lt_dlopen file with dladvise_local: %s\n", filename);
#if OPAL_HAVE_LTDL_ADVISE
if (lt_dladvise_init(&dladvise) ||
lt_dladvise_ext(&dladvise) ||
lt_dladvise_local(&dladvise)) {
fprintf(stderr, "lt_dladvise failed to initialize properly\n");
return 1;
}
dlhandle = lt_dlopenadvise(filename, dladvise);
lt_dladvise_destroy(&dladvise);
#else
dlhandle = lt_dlopenext(filename);
#endif
if (NULL != dlhandle) {
lt_dlclose(dlhandle);
printf("File opened with dladvise_local, all passed\n");
return 0;
}
printf("Failed to open with dladvise_local: %s\n", lt_dlerror());
printf("Retrying with dladvise_global\n");
#if OPAL_HAVE_LTDL_ADVISE
if (lt_dladvise_init(&dladvise) ||
lt_dladvise_ext(&dladvise) ||
lt_dladvise_global(&dladvise)) {
fprintf(stderr, "lt_dladvise failed to initialize properly\n");
return 1;
}
dlhandle = lt_dlopenadvise(filename, dladvise);
lt_dladvise_destroy(&dladvise);
#else
dlhandle = lt_dlopenext(filename);
#endif
if (NULL != dlhandle) {
lt_dlclose(dlhandle);
printf("File opened with dladvise_global\n");
return 0;
}
fprintf(stderr, "File failed to open with dladvise_global: %s\n",
lt_dlerror());
return 2;
}
