// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (C) 2014 - 2018 Red Hat, Inc.
*/
#include "nm-default.h"
#include "nm-device-factory.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <gmodule.h>
#include "platform/nm-platform.h"
#include "nm-utils.h"
#include "nm-core-internal.h"
#include "nm-setting-bluetooth.h"
#define PLUGIN_PREFIX "libnm-device-plugin-"
/*****************************************************************************/
enum {
DEVICE_ADDED,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0 };
G_DEFINE_ABSTRACT_TYPE (NMDeviceFactory, nm_device_factory, G_TYPE_OBJECT)
/*****************************************************************************/
static void
nm_device_factory_get_supported_types (NMDeviceFactory *factory,
const NMLinkType **out_link_types,
const char *const**out_setting_types)
{
g_return_if_fail (NM_IS_DEVICE_FACTORY (factory));
NM_DEVICE_FACTORY_GET_CLASS (factory)->get_supported_types (factory,
out_link_types,
out_setting_types);
}
void
nm_device_factory_start (NMDeviceFactory *factory)
{
g_return_if_fail (factory != NULL);
if (NM_DEVICE_FACTORY_GET_CLASS (factory)->start)
NM_DEVICE_FACTORY_GET_CLASS (factory)->start (factory);
}
NMDevice *
nm_device_factory_create_device (NMDeviceFactory *factory,
const char *iface,
const NMPlatformLink *plink,
NMConnection *connection,
gboolean *out_ignore,
GError **error)
{
NMDeviceFactoryClass *klass;
NMDevice *device;
gboolean ignore = FALSE;
g_return_val_if_fail (factory, NULL);
g_return_val_if_fail (iface && *iface, NULL);
if (plink) {
g_return_val_if_fail (!connection, NULL);
g_return_val_if_fail (strcmp (iface, plink->name) == 0, NULL);
nm_assert (factory == nm_device_factory_manager_find_factory_for_link_type (plink->type));
} else if (connection)
nm_assert (factory == nm_device_factory_manager_find_factory_for_connection (connection));
else
g_return_val_if_reached (NULL);
klass = NM_DEVICE_FACTORY_GET_CLASS (factory);
if (!klass->create_device) {
g_set_error (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_FAILED,
"Device factory %s cannot manage new devices",
G_OBJECT_TYPE_NAME (factory));
NM_SET_OUT (out_ignore, FALSE);
return NULL;
}
device = klass->create_device (factory, iface, plink, connection, &ignore);
NM_SET_OUT (out_ignore, ignore);
if (!device) {
if (ignore) {
g_set_error (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_FAILED,
"Device factory %s ignores device %s",
G_OBJECT_TYPE_NAME (factory), iface);
} else {
g_set_error (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_FAILED,
"Device factory %s failed to create device %s",
G_OBJECT_TYPE_NAME (factory), iface);
}
}
return device;
}
const char *
nm_device_factory_get_connection_parent (NMDeviceFactory *factory,
NMConnection *connection)
{
g_return_val_if_fail (factory != NULL, NULL);
g_return_val_if_fail (connection != NULL, NULL);
if (!nm_connection_is_virtual (connection))
return NULL;
if (NM_DEVICE_FACTORY_GET_CLASS (factory)->get_connection_parent)
return NM_DEVICE_FACTORY_GET_CLASS (factory)->get_connection_parent (factory, connection);
return NULL;
}
char *
nm_device_factory_get_connection_iface (NMDeviceFactory *factory,
NMConnection *connection,
const char *parent_iface,
GError **error)
{
NMDeviceFactoryClass *klass;
char *ifname;
g_return_val_if_fail (factory != NULL, NULL);
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (!error || !*error, NULL);
klass = NM_DEVICE_FACTORY_GET_CLASS (factory);
ifname = g_strdup (nm_connection_get_interface_name (connection));
if (!ifname && klass->get_connection_iface)
ifname = klass->get_connection_iface (factory, connection, parent_iface);
if (!ifname) {
g_set_error (error,
NM_MANAGER_ERROR,
NM_MANAGER_ERROR_FAILED,
"failed to determine interface name: error determine name for %s",
nm_connection_get_connection_type (connection));
return NULL;
}
return ifname;
}
/*****************************************************************************/
static void
nm_device_factory_init (NMDeviceFactory *self)
{
}
static void
nm_device_factory_class_init (NMDeviceFactoryClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
signals[DEVICE_ADDED] = g_signal_new (NM_DEVICE_FACTORY_DEVICE_ADDED,
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
0, NULL, NULL, NULL,
G_TYPE_NONE, 1, NM_TYPE_DEVICE);
}
/*****************************************************************************/
static GHashTable *factories_by_link = NULL;
static GHashTable *factories_by_setting = NULL;
static void __attribute__((destructor))
_cleanup (void)
{
nm_clear_pointer (&factories_by_link, g_hash_table_unref);
nm_clear_pointer (&factories_by_setting, g_hash_table_unref);
}
NMDeviceFactory *
nm_device_factory_manager_find_factory_for_link_type (NMLinkType link_type)
{
g_return_val_if_fail (factories_by_link, NULL);
return g_hash_table_lookup (factories_by_link, GUINT_TO_POINTER (link_type));
}
NMDeviceFactory *
nm_device_factory_manager_find_factory_for_connection (NMConnection *connection)
{
NMDeviceFactoryClass *klass;
NMDeviceFactory *factory;
const char *type;
GSList *list;
g_return_val_if_fail (factories_by_setting, NULL);
type = nm_connection_get_connection_type (connection);
list = g_hash_table_lookup (factories_by_setting, type);
for (; list; list = g_slist_next (list)) {
factory = list->data;
klass = NM_DEVICE_FACTORY_GET_CLASS (factory);
if (!klass->match_connection || klass->match_connection (factory, connection))
return factory;
}
return NULL;
}
void
nm_device_factory_manager_for_each_factory (NMDeviceFactoryManagerFactoryFunc callback,
gpointer user_data)
{
GHashTableIter iter;
NMDeviceFactory *factory;
GSList *list_iter, *list = NULL;
if (factories_by_link) {
g_hash_table_iter_init (&iter, factories_by_link);
while (g_hash_table_iter_next (&iter, NULL, (gpointer) &factory)) {
if (!g_slist_find (list, factory))
list = g_slist_prepend (list, factory);
}
}
if (factories_by_setting) {
g_hash_table_iter_init (&iter, factories_by_setting);
while (g_hash_table_iter_next (&iter, NULL, (gpointer) &list_iter)) {
for (; list_iter; list_iter = g_slist_next (list_iter)) {
if (!g_slist_find (list, list_iter->data))
list = g_slist_prepend (list, list_iter->data);
}
}
}
for (list_iter = list; list_iter; list_iter = list_iter->next)
callback (list_iter->data, user_data);
g_slist_free (list);
}
static gboolean
_add_factory (NMDeviceFactory *factory,
const char *path,
NMDeviceFactoryManagerFactoryFunc callback,
gpointer user_data)
{
const NMLinkType *link_types = NULL;
const char *const*setting_types = NULL;
GSList *list, *list2;
int i;
g_return_val_if_fail (factories_by_link, FALSE);
g_return_val_if_fail (factories_by_setting, FALSE);
nm_device_factory_get_supported_types (factory, &link_types, &setting_types);
g_return_val_if_fail ( (link_types && link_types[0] > NM_LINK_TYPE_UNKNOWN)
|| (setting_types && setting_types[0]),
FALSE);
for (i = 0; link_types && link_types[i] > NM_LINK_TYPE_UNKNOWN; i++)
g_hash_table_insert (factories_by_link, GUINT_TO_POINTER (link_types[i]), g_object_ref (factory));
for (i = 0; setting_types && setting_types[i]; i++) {
list = g_hash_table_lookup (factories_by_setting, (char *) setting_types[i]);
if (list) {
list2 = g_slist_append (list, g_object_ref (factory));
nm_assert (list == list2);
} else {
list = g_slist_append (list, g_object_ref (factory));
g_hash_table_insert (factories_by_setting, (char *) setting_types[i], list);
}
}
callback (factory, user_data);
nm_log (path ? LOGL_INFO : LOGL_DEBUG,
LOGD_PLATFORM,
NULL, NULL,
"Loaded device plugin: %s (%s)",
G_OBJECT_TYPE_NAME (factory),
path ?: "internal");
return TRUE;
}
static void
_load_internal_factory (GType factory_gtype,
NMDeviceFactoryManagerFactoryFunc callback,
gpointer user_data)
{
gs_unref_object NMDeviceFactory *factory = NULL;
factory = (NMDeviceFactory *) g_object_new (factory_gtype, NULL);
_add_factory (factory, NULL, callback, user_data);
}
static void
factories_list_unref (GSList *list)
{
g_slist_free_full (list, g_object_unref);
}
static void
load_factories_from_dir (const char *dirname,
NMDeviceFactoryManagerFactoryFunc callback,
gpointer user_data)
{
NMDeviceFactory *factory;
GError *error = NULL;
char **path, **paths;
paths = nm_utils_read_plugin_paths (dirname, PLUGIN_PREFIX);
if (!paths)
return;
for (path = paths; *path; path++) {
GModule *plugin;
NMDeviceFactoryCreateFunc create_func;
const char *item;
item = strrchr (*path, '/');
g_assert (item);
plugin = g_module_open (*path, G_MODULE_BIND_LOCAL);
if (!plugin) {
nm_log_warn (LOGD_PLATFORM, "(%s): failed to load plugin: %s", item, g_module_error ());
continue;
}
if (!g_module_symbol (plugin, "nm_device_factory_create", (gpointer) &create_func)) {
nm_log_warn (LOGD_PLATFORM, "(%s): failed to find device factory creator: %s", item, g_module_error ());
g_module_close (plugin);
continue;
}
/* after loading glib types from the plugin, we cannot unload the library anymore.
* Make it resident. */
g_module_make_resident (plugin);
factory = create_func (&error);
if (!factory) {
nm_log_warn (LOGD_PLATFORM, "(%s): failed to initialize device factory: %s",
item, NM_G_ERROR_MSG (error));
g_clear_error (&error);
continue;
}
g_clear_error (&error);
_add_factory (factory, g_module_name (plugin), callback, user_data);
g_object_unref (factory);
}
g_strfreev (paths);
}
void
nm_device_factory_manager_load_factories (NMDeviceFactoryManagerFactoryFunc callback,
gpointer user_data)
{
g_return_if_fail (factories_by_link == NULL);
g_return_if_fail (factories_by_setting == NULL);
factories_by_link = g_hash_table_new_full (nm_direct_hash, NULL, NULL, g_object_unref);
factories_by_setting = g_hash_table_new_full (nm_str_hash, g_str_equal, NULL, (GDestroyNotify) factories_list_unref);
#define _ADD_INTERNAL(get_type_fcn) \
G_STMT_START { \
GType get_type_fcn (void); \
_load_internal_factory (get_type_fcn (), \
callback, user_data); \
} G_STMT_END
_ADD_INTERNAL (nm_6lowpan_device_factory_get_type);
_ADD_INTERNAL (nm_bond_device_factory_get_type);
_ADD_INTERNAL (nm_bridge_device_factory_get_type);
_ADD_INTERNAL (nm_dummy_device_factory_get_type);
_ADD_INTERNAL (nm_ethernet_device_factory_get_type);
_ADD_INTERNAL (nm_infiniband_device_factory_get_type);
_ADD_INTERNAL (nm_ip_tunnel_device_factory_get_type);
_ADD_INTERNAL (nm_macsec_device_factory_get_type);
_ADD_INTERNAL (nm_macvlan_device_factory_get_type);
_ADD_INTERNAL (nm_ppp_device_factory_get_type);
_ADD_INTERNAL (nm_tun_device_factory_get_type);
_ADD_INTERNAL (nm_veth_device_factory_get_type);
_ADD_INTERNAL (nm_vlan_device_factory_get_type);
_ADD_INTERNAL (nm_vrf_device_factory_get_type);
_ADD_INTERNAL (nm_vxlan_device_factory_get_type);
_ADD_INTERNAL (nm_wireguard_device_factory_get_type);
_ADD_INTERNAL (nm_wpan_device_factory_get_type);
load_factories_from_dir (NMPLUGINDIR, callback, user_data);
}