/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
* Copyright (C) 2016, 2018 Red Hat, Inc.
*/
#include "nm-default.h"
#include "nm-vpn-plugin-utils.h"
#include <dlfcn.h>
/*****************************************************************************/
NMVpnEditor *
nm_vpn_plugin_utils_load_editor(const char * module_name,
const char * factory_name,
NMVpnPluginUtilsEditorFactory editor_factory,
NMVpnEditorPlugin * editor_plugin,
NMConnection * connection,
gpointer user_data,
GError ** error)
{
static struct {
gpointer factory;
void * dl_module;
char * module_name;
char * factory_name;
} cached = {0};
NMVpnEditor * editor;
gs_free char *module_path = NULL;
gs_free char *dirname = NULL;
Dl_info plugin_info;
g_return_val_if_fail(module_name, NULL);
g_return_val_if_fail(factory_name && factory_name[0], NULL);
g_return_val_if_fail(editor_factory, NULL);
g_return_val_if_fail(NM_IS_VPN_EDITOR_PLUGIN(editor_plugin), NULL);
g_return_val_if_fail(NM_IS_CONNECTION(connection), NULL);
g_return_val_if_fail(!error || !*error, NULL);
if (!g_path_is_absolute(module_name)) {
/*
* Load an editor from the same directory this plugin is in.
* Ideally, we'd get our .so name from the NMVpnEditorPlugin if it
* would just have a property with it...
*/
if (!dladdr(nm_vpn_plugin_utils_load_editor, &plugin_info)) {
/* Really a "can not happen" scenario. */
g_set_error(error,
NM_VPN_PLUGIN_ERROR,
NM_VPN_PLUGIN_ERROR_FAILED,
_("unable to get editor plugin name: %s"),
dlerror());
}
dirname = g_path_get_dirname(plugin_info.dli_fname);
module_path = g_build_filename(dirname, module_name, NULL);
} else {
module_path = g_strdup(module_name);
}
/* we really expect this function to be called with unchanging @module_name
* and @factory_name. And we only want to load the module once, hence it would
* be more complicated to accept changing @module_name/@factory_name arguments.
*
* The reason for only loading once is that due to glib types, we cannot create a
* certain type-name more then once, so loading the same module or another version
* of the same module will fail horribly as both try to create a GType with the same
* name.
*
* Only support loading once, any future calls will reuse the handle. To simplify
* that, we enforce that the @factory_name and @module_name is the same. */
if (cached.factory) {
g_return_val_if_fail(cached.dl_module, NULL);
g_return_val_if_fail(cached.factory_name && nm_streq0(cached.factory_name, factory_name),
NULL);
g_return_val_if_fail(cached.module_name && nm_streq0(cached.module_name, module_name),
NULL);
} else {
gpointer factory;
void * dl_module;
dl_module = dlopen(module_path, RTLD_LAZY | RTLD_LOCAL);
if (!dl_module) {
if (!g_file_test(module_path, G_FILE_TEST_EXISTS)) {
g_set_error(error,
G_FILE_ERROR,
G_FILE_ERROR_NOENT,
_("missing plugin file \"%s\""),
module_path);
return NULL;
}
g_set_error(error,
NM_VPN_PLUGIN_ERROR,
NM_VPN_PLUGIN_ERROR_FAILED,
_("cannot load editor plugin: %s"),
dlerror());
return NULL;
}
factory = dlsym(dl_module, factory_name);
if (!factory) {
g_set_error(error,
NM_VPN_PLUGIN_ERROR,
NM_VPN_PLUGIN_ERROR_FAILED,
_("cannot load factory %s from plugin: %s"),
factory_name,
dlerror());
dlclose(dl_module);
return NULL;
}
/* we cannot ever unload the module because it creates glib types, which
* cannot be unregistered.
*
* Thus we just leak the dl_module handle indefinitely. */
cached.factory = factory;
cached.dl_module = dl_module;
cached.module_name = g_strdup(module_name);
cached.factory_name = g_strdup(factory_name);
}
editor = editor_factory(cached.factory, editor_plugin, connection, user_data, error);
if (!editor) {
if (error && !*error) {
g_set_error_literal(error,
NM_VPN_PLUGIN_ERROR,
NM_VPN_PLUGIN_ERROR_FAILED,
_("unknown error creating editor instance"));
g_return_val_if_reached(NULL);
}
return NULL;
}
g_return_val_if_fail(NM_IS_VPN_EDITOR(editor), NULL);
return editor;
}