NetworkManager/src/contrib/nm-vpn-plugin-utils.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2016, 2018 Red Hat, Inc.
 */

#include "libnm-client-aux-extern/nm-default-client.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;
}