New upstream version 1.29.90 upstream/1.29.90

4 files changed, 1233 insertions, 0 deletions

diff --git a/src/core/devices/team/meson.build b/src/core/devices/team/meson.build
new file mode 100644
index 00000000..d0ff4caa
--- /dev/null
+++ b/src/core/devices/team/meson.build
@@ -0,0 +1,30 @@
+# SPDX-License-Identifier: LGPL-2.1-or-later
+
+libnm_device_plugin_team = shared_module(
+  'nm-device-plugin-team',
+  sources: files(
+    'nm-device-team.c',
+    'nm-team-factory.c',
+  ),
+  dependencies: [
+    core_plugin_dep,
+    jansson_dep,
+    libteamdctl_dep,
+  ],
+  c_args: daemon_c_flags,
+  link_args: ldflags_linker_script_devices,
+  link_depends: linker_script_devices,
+  install: true,
+  install_dir: nm_plugindir,
+)
+
+core_plugins += libnm_device_plugin_team
+
+test(
+  'check-local-devices-team',
+  check_exports,
+  args: [
+    libnm_device_plugin_team.full_path(),
+    linker_script_devices,
+  ],
+)
diff --git a/src/core/devices/team/nm-device-team.c b/src/core/devices/team/nm-device-team.c
new file mode 100644
index 00000000..d2d71729
--- /dev/null
+++ b/src/core/devices/team/nm-device-team.c
@@ -0,0 +1,1096 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (C) 2013 Jiri Pirko <jiri@resnulli.us>
+ * Copyright (C) 2018 Red Hat, Inc.
+ */
+
+#include "src/core/nm-default-daemon.h"
+
+#include "nm-device-team.h"
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/wait.h>
+#include <teamdctl.h>
+#include <stdlib.h>
+
+#include "nm-glib-aux/nm-jansson.h"
+#include "NetworkManagerUtils.h"
+#include "devices/nm-device-private.h"
+#include "platform/nm-platform.h"
+#include "nm-config.h"
+#include "nm-core-internal.h"
+#include "nm-dbus-manager.h"
+#include "nm-ip4-config.h"
+#include "nm-std-aux/nm-dbus-compat.h"
+
+#define _NMLOG_DEVICE_TYPE NMDeviceTeam
+#include "devices/nm-device-logging.h"
+
+/*****************************************************************************/
+
+NM_GOBJECT_PROPERTIES_DEFINE(NMDeviceTeam, PROP_CONFIG, );
+
+typedef struct {
+    struct teamdctl *  tdc;
+    char *             config;
+    GPid               teamd_pid;
+    guint              teamd_process_watch;
+    guint              teamd_timeout;
+    guint              teamd_read_timeout;
+    guint              teamd_dbus_watch;
+    bool               kill_in_progress : 1;
+    GFileMonitor *     usock_monitor;
+    NMDeviceStageState stage1_state : 3;
+} NMDeviceTeamPrivate;
+
+struct _NMDeviceTeam {
+    NMDevice            parent;
+    NMDeviceTeamPrivate _priv;
+};
+
+struct _NMDeviceTeamClass {
+    NMDeviceClass parent;
+};
+
+G_DEFINE_TYPE(NMDeviceTeam, nm_device_team, NM_TYPE_DEVICE)
+
+#define NM_DEVICE_TEAM_GET_PRIVATE(self) \
+    _NM_GET_PRIVATE(self, NMDeviceTeam, NM_IS_DEVICE_TEAM, NMDevice)
+
+/*****************************************************************************/
+
+static gboolean teamd_start(NMDeviceTeam *self);
+
+/*****************************************************************************/
+
+static NMDeviceCapabilities
+get_generic_capabilities(NMDevice *device)
+{
+    return NM_DEVICE_CAP_CARRIER_DETECT | NM_DEVICE_CAP_IS_SOFTWARE;
+}
+
+static gboolean
+complete_connection(NMDevice *           device,
+                    NMConnection *       connection,
+                    const char *         specific_object,
+                    NMConnection *const *existing_connections,
+                    GError **            error)
+{
+    NMSettingTeam *s_team;
+
+    nm_utils_complete_generic(nm_device_get_platform(device),
+                              connection,
+                              NM_SETTING_TEAM_SETTING_NAME,
+                              existing_connections,
+                              NULL,
+                              _("Team connection"),
+                              "team",
+                              NULL,
+                              TRUE);
+
+    s_team = nm_connection_get_setting_team(connection);
+    if (!s_team) {
+        s_team = (NMSettingTeam *) nm_setting_team_new();
+        nm_connection_add_setting(connection, NM_SETTING(s_team));
+    }
+
+    return TRUE;
+}
+
+static gboolean
+ensure_teamd_connection(NMDevice *device)
+{
+    NMDeviceTeam *       self = NM_DEVICE_TEAM(device);
+    NMDeviceTeamPrivate *priv = NM_DEVICE_TEAM_GET_PRIVATE(self);
+    int                  err;
+
+    if (priv->tdc)
+        return TRUE;
+
+    priv->tdc = teamdctl_alloc();
+    g_assert(priv->tdc);
+    err = teamdctl_connect(priv->tdc, nm_device_get_iface(device), NULL, NULL);
+    if (err != 0) {
+        _LOGE(LOGD_TEAM, "failed to connect to teamd (err=%d)", err);
+        teamdctl_free(priv->tdc);
+        priv->tdc = NULL;
+    }
+
+    return !!priv->tdc;
+}
+
+static const char *
+_get_config(NMDeviceTeam *self)
+{
+    return nm_str_not_empty(NM_DEVICE_TEAM_GET_PRIVATE(self)->config);
+}
+
+static gboolean
+teamd_read_config(NMDeviceTeam *self)
+{
+    NMDeviceTeamPrivate *priv   = NM_DEVICE_TEAM_GET_PRIVATE(self);
+    const char *         config = NULL;
+    int                  err;
+
+    if (priv->tdc) {
+        err = teamdctl_config_actual_get_raw_direct(priv->tdc, (char **) &config);
+        if (err)
+            return FALSE;
+        if (!config) {
+            /* set "" to distinguish an empty result from no config at all. */
+            config = "";
+        }
+    }
+
+    if (!nm_streq0(config, priv->config)) {
+        g_free(priv->config);
+        priv->config = g_strdup(config);
+        _notify(self, PROP_CONFIG);
+    }
+
+    return TRUE;
+}
+
+static gboolean
+teamd_read_timeout_cb(gpointer user_data)
+{
+    NMDeviceTeam *       self = user_data;
+    NMDeviceTeamPrivate *priv = NM_DEVICE_TEAM_GET_PRIVATE(self);
+
+    priv->teamd_read_timeout = 0;
+    teamd_read_config(self);
+    return G_SOURCE_REMOVE;
+}
+
+static void
+update_connection(NMDevice *device, NMConnection *connection)
+{
+    NMDeviceTeam *       self   = NM_DEVICE_TEAM(device);
+    NMSettingTeam *      s_team = nm_connection_get_setting_team(connection);
+    NMDeviceTeamPrivate *priv   = NM_DEVICE_TEAM_GET_PRIVATE(self);
+    struct teamdctl *    tdc    = priv->tdc;
+
+    if (!s_team) {
+        s_team = (NMSettingTeam *) nm_setting_team_new();
+        nm_connection_add_setting(connection, (NMSetting *) s_team);
+    }
+
+    /* Read the configuration only if not already set */
+    if (!priv->config && ensure_teamd_connection(device))
+        teamd_read_config(self);
+
+    /* Restore previous tdc state */
+    if (priv->tdc && !tdc) {
+        teamdctl_disconnect(priv->tdc);
+        teamdctl_free(priv->tdc);
+        priv->tdc = NULL;
+    }
+
+    g_object_set(G_OBJECT(s_team), NM_SETTING_TEAM_CONFIG, _get_config(self), NULL);
+}
+
+/*****************************************************************************/
+
+static gboolean
+master_update_slave_connection(NMDevice *    self,
+                               NMDevice *    slave,
+                               NMConnection *connection,
+                               GError **     error)
+{
+    NMSettingTeamPort *s_port;
+    char *             port_config = NULL;
+    int                err         = 0;
+    struct teamdctl *  tdc;
+    const char *       team_port_config = NULL;
+    const char *       iface            = nm_device_get_iface(self);
+    const char *       iface_slave      = nm_device_get_iface(slave);
+
+    tdc = teamdctl_alloc();
+    if (!tdc) {
+        g_set_error(error,
+                    NM_DEVICE_ERROR,
+                    NM_DEVICE_ERROR_FAILED,
+                    "update slave connection for slave '%s' failed to connect to teamd for master "
+                    "%s (out of memory?)",
+                    iface_slave,
+                    iface);
+        g_return_val_if_reached(FALSE);
+    }
+
+    err = teamdctl_connect(tdc, iface, NULL, NULL);
+    if (err) {
+        teamdctl_free(tdc);
+        g_set_error(error,
+                    NM_DEVICE_ERROR,
+                    NM_DEVICE_ERROR_FAILED,
+                    "update slave connection for slave '%s' failed to connect to teamd for master "
+                    "%s (err=%d)",
+                    iface_slave,
+                    iface,
+                    err);
+        return FALSE;
+    }
+
+    err = teamdctl_port_config_get_raw_direct(tdc, iface_slave, (char **) &team_port_config);
+    port_config = g_strdup(team_port_config);
+    teamdctl_disconnect(tdc);
+    teamdctl_free(tdc);
+    if (err) {
+        g_set_error(error,
+                    NM_DEVICE_ERROR,
+                    NM_DEVICE_ERROR_FAILED,
+                    "update slave connection for slave '%s' failed to get configuration from teamd "
+                    "master %s (err=%d)",
+                    iface_slave,
+                    iface,
+                    err);
+        g_free(port_config);
+        return FALSE;
+    }
+
+    s_port = nm_connection_get_setting_team_port(connection);
+    if (!s_port) {
+        s_port = (NMSettingTeamPort *) nm_setting_team_port_new();
+        nm_connection_add_setting(connection, NM_SETTING(s_port));
+    }
+
+    g_object_set(G_OBJECT(s_port), NM_SETTING_TEAM_PORT_CONFIG, port_config, NULL);
+    g_free(port_config);
+
+    g_object_set(nm_connection_get_setting_connection(connection),
+                 NM_SETTING_CONNECTION_MASTER,
+                 iface,
+                 NM_SETTING_CONNECTION_SLAVE_TYPE,
+                 NM_SETTING_TEAM_SETTING_NAME,
+                 NULL);
+    return TRUE;
+}
+
+/*****************************************************************************/
+
+static void
+teamd_kill_cb(pid_t pid, gboolean success, int child_status, void *user_data)
+{
+    gs_unref_object NMDeviceTeam *self = user_data;
+    NMDeviceTeamPrivate *         priv = NM_DEVICE_TEAM_GET_PRIVATE(self);
+
+    priv->kill_in_progress = FALSE;
+
+    if (nm_device_get_state(NM_DEVICE(self)) != NM_DEVICE_STATE_PREPARE) {
+        _LOGT(LOGD_TEAM, "kill terminated");
+        return;
+    }
+
+    _LOGT(LOGD_TEAM, "kill terminated, starting teamd...");
+    if (!teamd_start(self)) {
+        nm_device_state_changed(NM_DEVICE(self),
+                                NM_DEVICE_STATE_FAILED,
+                                NM_DEVICE_STATE_REASON_TEAMD_CONTROL_FAILED);
+    }
+}
+
+static void
+teamd_cleanup(NMDeviceTeam *self, gboolean free_tdc)
+{
+    NMDeviceTeamPrivate *priv = NM_DEVICE_TEAM_GET_PRIVATE(self);
+
+    nm_clear_g_source(&priv->teamd_process_watch);
+    nm_clear_g_source(&priv->teamd_timeout);
+    nm_clear_g_source(&priv->teamd_read_timeout);
+
+    if (priv->teamd_pid > 0) {
+        priv->kill_in_progress = TRUE;
+        nm_utils_kill_child_async(priv->teamd_pid,
+                                  SIGTERM,
+                                  LOGD_TEAM,
+                                  "teamd",
+                                  2000,
+                                  teamd_kill_cb,
+                                  g_object_ref(self));
+        priv->teamd_pid = 0;
+    }
+
+    if (priv->tdc && free_tdc) {
+        teamdctl_disconnect(priv->tdc);
+        teamdctl_free(priv->tdc);
+        priv->tdc = NULL;
+    }
+}
+
+static gboolean
+teamd_timeout_cb(gpointer user_data)
+{
+    NMDeviceTeam *       self   = NM_DEVICE_TEAM(user_data);
+    NMDevice *           device = NM_DEVICE(self);
+    NMDeviceTeamPrivate *priv   = NM_DEVICE_TEAM_GET_PRIVATE(self);
+
+    g_return_val_if_fail(priv->teamd_timeout, FALSE);
+    priv->teamd_timeout = 0;
+
+    if (priv->teamd_pid && !priv->tdc) {
+        /* Timed out launching our own teamd process */
+        _LOGW(LOGD_TEAM, "teamd timed out");
+        teamd_cleanup(self, TRUE);
+
+        g_warn_if_fail(nm_device_is_activating(device));
+        nm_device_state_changed(device,
+                                NM_DEVICE_STATE_FAILED,
+                                NM_DEVICE_STATE_REASON_TEAMD_CONTROL_FAILED);
+    } else {
+        /* Read again the configuration after the timeout since it might
+         * have changed.
+         */
+        if (!teamd_read_config(self)) {
+            _LOGW(LOGD_TEAM, "failed to read teamd configuration");
+            nm_device_state_changed(device,
+                                    NM_DEVICE_STATE_FAILED,
+                                    NM_DEVICE_STATE_REASON_TEAMD_CONTROL_FAILED);
+        }
+    }
+
+    return G_SOURCE_REMOVE;
+}
+
+static void
+teamd_ready(NMDeviceTeam *self)
+{
+    NMDeviceTeamPrivate *priv   = NM_DEVICE_TEAM_GET_PRIVATE(self);
+    NMDevice *           device = NM_DEVICE(self);
+    gboolean             success;
+
+    if (priv->kill_in_progress) {
+        /* If we are currently killing teamd, we are not
+         * interested in knowing when it becomes ready. */
+        return;
+    }
+
+    nm_device_queue_recheck_assume(device);
+
+    /* Grab a teamd control handle even if we aren't going to use it
+     * immediately.  But if we are, and grabbing it failed, fail the
+     * device activation.
+     */
+    success = ensure_teamd_connection(device);
+
+    if (nm_device_get_state(device) != NM_DEVICE_STATE_PREPARE
+        || priv->stage1_state != NM_DEVICE_STAGE_STATE_PENDING)
+        return;
+
+    if (success)
+        success = teamd_read_config(self);
+
+    if (!success) {
+        teamd_cleanup(self, TRUE);
+        nm_device_state_changed(device,
+                                NM_DEVICE_STATE_FAILED,
+                                NM_DEVICE_STATE_REASON_TEAMD_CONTROL_FAILED);
+        return;
+    }
+
+    priv->stage1_state = NM_DEVICE_STAGE_STATE_COMPLETED;
+    nm_device_activate_schedule_stage1_device_prepare(device, FALSE);
+}
+
+static void
+teamd_gone(NMDeviceTeam *self)
+{
+    NMDevice *    device = NM_DEVICE(self);
+    NMDeviceState state;
+
+    teamd_cleanup(self, TRUE);
+    state = nm_device_get_state(device);
+
+    /* Attempt to respawn teamd */
+    if (state >= NM_DEVICE_STATE_PREPARE && state <= NM_DEVICE_STATE_ACTIVATED) {
+        if (!teamd_start(self)) {
+            nm_device_state_changed(device,
+                                    NM_DEVICE_STATE_FAILED,
+                                    NM_DEVICE_STATE_REASON_TEAMD_CONTROL_FAILED);
+        }
+    }
+}
+
+static void
+teamd_dbus_appeared(GDBusConnection *connection,
+                    const char *     name,
+                    const char *     name_owner,
+                    gpointer         user_data)
+{
+    NMDeviceTeam *       self = NM_DEVICE_TEAM(user_data);
+    NMDeviceTeamPrivate *priv = NM_DEVICE_TEAM_GET_PRIVATE(self);
+
+    g_return_if_fail(priv->teamd_dbus_watch);
+
+    _LOGI(LOGD_TEAM, "teamd appeared on D-Bus");
+
+    /* If another teamd grabbed the bus name while our teamd was starting,
+     * just ignore the death of our teamd and run with the existing one.
+     */
+    if (priv->teamd_process_watch) {
+        gs_unref_variant GVariant *ret = NULL;
+        guint32                    pid;
+
+        ret = g_dbus_connection_call_sync(connection,
+                                          DBUS_SERVICE_DBUS,
+                                          DBUS_PATH_DBUS,
+                                          DBUS_INTERFACE_DBUS,
+                                          "GetConnectionUnixProcessID",
+                                          g_variant_new("(s)", name_owner),
+                                          NULL,
+                                          G_DBUS_CALL_FLAGS_NO_AUTO_START,
+                                          2000,
+                                          NULL,
+                                          NULL);
+
+        if (ret) {
+            g_variant_get(ret, "(u)", &pid);
+            if (pid != priv->teamd_pid)
+                teamd_cleanup(self, FALSE);
+        } else {
+            /* The process that registered on the bus died. If it's
+             * the teamd instance we just started, ignore the event
+             * as we already detect the failure through the process
+             * watch. If it's a previous instance that got killed,
+             * also ignore that as our new instance will register
+             * again. */
+            _LOGD(LOGD_TEAM, "failed to determine D-Bus name owner, ignoring");
+            return;
+        }
+    }
+
+    teamd_ready(self);
+}
+
+static void
+teamd_dbus_vanished(GDBusConnection *dbus_connection, const char *name, gpointer user_data)
+{
+    NMDeviceTeam *       self = NM_DEVICE_TEAM(user_data);
+    NMDeviceTeamPrivate *priv = NM_DEVICE_TEAM_GET_PRIVATE(self);
+
+    g_return_if_fail(priv->teamd_dbus_watch);
+
+    if (!priv->tdc) {
+        /* g_bus_watch_name will always raise an initial signal, to indicate whether the
+         * name exists/not exists initially. Do not take this as a failure if it hadn't
+         * previously appeared.
+         */
+        _LOGD(LOGD_TEAM, "teamd not on D-Bus (ignored)");
+        return;
+    }
+
+    _LOGI(LOGD_TEAM, "teamd vanished from D-Bus");
+
+    teamd_gone(self);
+}
+
+static void
+monitor_changed_cb(GFileMonitor *    monitor,
+                   GFile *           file,
+                   GFile *           other_file,
+                   GFileMonitorEvent event_type,
+                   gpointer          user_data)
+{
+    NMDeviceTeam *self = NM_DEVICE_TEAM(user_data);
+
+    switch (event_type) {
+    case G_FILE_MONITOR_EVENT_CREATED:
+        _LOGI(LOGD_TEAM, "file %s was created", g_file_get_path(file));
+        teamd_ready(self);
+        break;
+    case G_FILE_MONITOR_EVENT_DELETED:
+        _LOGI(LOGD_TEAM, "file %s was deleted", g_file_get_path(file));
+        teamd_gone(self);
+        break;
+    default:;
+    }
+}
+
+static void
+teamd_process_watch_cb(GPid pid, int status, gpointer user_data)
+{
+    NMDeviceTeam *       self   = NM_DEVICE_TEAM(user_data);
+    NMDeviceTeamPrivate *priv   = NM_DEVICE_TEAM_GET_PRIVATE(self);
+    NMDevice *           device = NM_DEVICE(self);
+    NMDeviceState        state  = nm_device_get_state(device);
+
+    g_return_if_fail(priv->teamd_process_watch);
+
+    _LOGD(LOGD_TEAM, "teamd %lld died with status %d", (long long) pid, status);
+    priv->teamd_pid           = 0;
+    priv->teamd_process_watch = 0;
+
+    /* If teamd quit within 5 seconds of starting, it's probably hosed
+     * and will just die again, so fail the activation.
+     */
+    if (priv->teamd_timeout && (state >= NM_DEVICE_STATE_PREPARE)
+        && (state <= NM_DEVICE_STATE_ACTIVATED)) {
+        _LOGW(LOGD_TEAM,
+              "teamd process %lld quit unexpectedly; failing activation",
+              (long long) pid);
+        teamd_cleanup(self, TRUE);
+        nm_device_state_changed(device,
+                                NM_DEVICE_STATE_FAILED,
+                                NM_DEVICE_STATE_REASON_TEAMD_CONTROL_FAILED);
+    }
+}
+
+static void
+teamd_child_setup(gpointer user_data)
+{
+    nm_utils_setpgid(NULL);
+    signal(SIGPIPE, SIG_IGN);
+}
+
+static const char **
+teamd_env(void)
+{
+    const char **env = g_new0(const char *, 2);
+
+    if (nm_config_get_is_debug(nm_config_get()))
+        env[0] = "TEAM_LOG_OUTPUT=stderr";
+    else
+        env[0] = "TEAM_LOG_OUTPUT=syslog";
+
+    return env;
+}
+
+static gboolean
+teamd_kill(NMDeviceTeam *self, const char *teamd_binary, GError **error)
+{
+    gs_unref_ptrarray GPtrArray *argv    = NULL;
+    gs_free char *               tmp_str = NULL;
+    gs_free const char **        envp    = NULL;
+
+    if (!teamd_binary) {
+        teamd_binary = nm_utils_find_helper("teamd", NULL, error);
+        if (!teamd_binary) {
+            _LOGW(LOGD_TEAM, "Activation: (team) failed to start teamd: teamd binary not found");
+            return FALSE;
+        }
+    }
+
+    argv = g_ptr_array_new();
+    g_ptr_array_add(argv, (gpointer) teamd_binary);
+    g_ptr_array_add(argv, (gpointer) "-k");
+    g_ptr_array_add(argv, (gpointer) "-t");
+    g_ptr_array_add(argv, (gpointer) nm_device_get_iface(NM_DEVICE(self)));
+    g_ptr_array_add(argv, NULL);
+
+    envp = teamd_env();
+
+    _LOGD(LOGD_TEAM, "running: %s", (tmp_str = g_strjoinv(" ", (char **) argv->pdata)));
+    return g_spawn_sync("/",
+                        (char **) argv->pdata,
+                        (char **) envp,
+                        0,
+                        teamd_child_setup,
+                        NULL,
+                        NULL,
+                        NULL,
+                        NULL,
+                        error);
+}
+
+static gboolean
+teamd_start(NMDeviceTeam *self)
+{
+    NMDeviceTeamPrivate *priv  = NM_DEVICE_TEAM_GET_PRIVATE(self);
+    const char *         iface = nm_device_get_ip_iface(NM_DEVICE(self));
+    NMConnection *       connection;
+    gs_unref_ptrarray GPtrArray *argv = NULL;
+    gs_free_error GError *   error    = NULL;
+    gs_free char *           tmp_str  = NULL;
+    const char *             teamd_binary;
+    const char *             config;
+    nm_auto_free const char *config_free = NULL;
+    NMSettingTeam *          s_team;
+    gs_free char *           cloned_mac = NULL;
+    gs_free const char **    envp       = NULL;
+
+    connection = nm_device_get_applied_connection(NM_DEVICE(self));
+
+    s_team = nm_connection_get_setting_team(connection);
+    if (!s_team)
+        g_return_val_if_reached(FALSE);
+
+    nm_assert(iface);
+
+    teamd_binary = nm_utils_find_helper("teamd", NULL, NULL);
+    if (!teamd_binary) {
+        _LOGW(LOGD_TEAM, "Activation: (team) failed to start teamd: teamd binary not found");
+        return FALSE;
+    }
+
+    if (priv->teamd_process_watch || priv->teamd_pid > 0 || priv->tdc) {
+        g_warn_if_reached();
+        if (!priv->teamd_pid)
+            teamd_kill(self, teamd_binary, NULL);
+        teamd_cleanup(self, TRUE);
+    }
+
+    /* Start teamd now */
+    argv = g_ptr_array_new();
+    g_ptr_array_add(argv, (gpointer) teamd_binary);
+    g_ptr_array_add(argv, (gpointer) "-o");
+    g_ptr_array_add(argv, (gpointer) "-n");
+    g_ptr_array_add(argv, (gpointer) "-U");
+    if (priv->teamd_dbus_watch)
+        g_ptr_array_add(argv, (gpointer) "-D");
+    g_ptr_array_add(argv, (gpointer) "-N");
+    g_ptr_array_add(argv, (gpointer) "-t");
+    g_ptr_array_add(argv, (gpointer) iface);
+
+    config = nm_setting_team_get_config(s_team);
+    if (!nm_device_hw_addr_get_cloned(NM_DEVICE(self),
+                                      connection,
+                                      FALSE,
+                                      &cloned_mac,
+                                      NULL,
+                                      &error)) {
+        _LOGW(LOGD_DEVICE, "set-hw-addr: %s", error->message);
+        return FALSE;
+    }
+
+    if (cloned_mac) {
+        json_t *     json, *hwaddr;
+        json_error_t jerror;
+
+        /* Inject the hwaddr property into the JSON configuration.
+         * While doing so, detect potential conflicts */
+
+        json = json_loads(config ?: "{}", JSON_REJECT_DUPLICATES, &jerror);
+        g_return_val_if_fail(json, FALSE);
+
+        hwaddr = json_object_get(json, "hwaddr");
+        if (hwaddr) {
+            if (!json_is_string(hwaddr) || !nm_streq0(json_string_value(hwaddr), cloned_mac))
+                _LOGW(LOGD_TEAM,
+                      "set-hw-addr: can't set team cloned-mac-address as the JSON configuration "
+                      "already contains \"hwaddr\"");
+        } else {
+            hwaddr = json_string(cloned_mac);
+            json_object_set(json, "hwaddr", hwaddr);
+            config = config_free =
+                json_dumps(json, JSON_INDENT(0) | JSON_ENSURE_ASCII | JSON_SORT_KEYS);
+            _LOGD(LOGD_TEAM,
+                  "set-hw-addr: injected \"hwaddr\" \"%s\" into team configuration",
+                  cloned_mac);
+            json_decref(hwaddr);
+        }
+        json_decref(json);
+    }
+
+    if (config) {
+        g_ptr_array_add(argv, (gpointer) "-c");
+        g_ptr_array_add(argv, (gpointer) config);
+    }
+
+    if (nm_logging_enabled(LOGL_DEBUG, LOGD_TEAM))
+        g_ptr_array_add(argv, (gpointer) "-gg");
+    g_ptr_array_add(argv, NULL);
+
+    envp = teamd_env();
+
+    _LOGD(LOGD_TEAM, "running: %s", (tmp_str = g_strjoinv(" ", (char **) argv->pdata)));
+    if (!g_spawn_async("/",
+                       (char **) argv->pdata,
+                       (char **) envp,
+                       G_SPAWN_DO_NOT_REAP_CHILD,
+                       teamd_child_setup,
+                       NULL,
+                       &priv->teamd_pid,
+                       &error)) {
+        _LOGW(LOGD_TEAM, "Activation: (team) failed to start teamd: %s", error->message);
+        teamd_cleanup(self, TRUE);
+        return FALSE;
+    }
+
+    /* Start a timeout for teamd to appear at D-Bus */
+    if (!priv->teamd_timeout)
+        priv->teamd_timeout = g_timeout_add_seconds(5, teamd_timeout_cb, self);
+
+    /* Monitor the child process so we know when it dies */
+    priv->teamd_process_watch = g_child_watch_add(priv->teamd_pid, teamd_process_watch_cb, self);
+
+    _LOGI(LOGD_TEAM, "Activation: (team) started teamd [pid %u]...", (guint) priv->teamd_pid);
+    return TRUE;
+}
+
+static NMActStageReturn
+act_stage1_prepare(NMDevice *device, NMDeviceStateReason *out_failure_reason)
+{
+    NMDeviceTeam *       self   = NM_DEVICE_TEAM(device);
+    NMDeviceTeamPrivate *priv   = NM_DEVICE_TEAM_GET_PRIVATE(self);
+    gs_free_error GError *error = NULL;
+    NMSettingTeam *       s_team;
+    const char *          cfg;
+
+    if (nm_device_sys_iface_state_is_external(device))
+        return NM_ACT_STAGE_RETURN_SUCCESS;
+
+    if (nm_device_sys_iface_state_is_external_or_assume(device)) {
+        if (ensure_teamd_connection(device))
+            return NM_ACT_STAGE_RETURN_SUCCESS;
+    }
+
+    s_team = nm_device_get_applied_setting(device, NM_TYPE_SETTING_TEAM);
+    if (!s_team)
+        g_return_val_if_reached(NM_ACT_STAGE_RETURN_FAILURE);
+
+    if (priv->stage1_state == NM_DEVICE_STAGE_STATE_PENDING)
+        return NM_ACT_STAGE_RETURN_POSTPONE;
+
+    if (priv->stage1_state == NM_DEVICE_STAGE_STATE_COMPLETED)
+        return NM_ACT_STAGE_RETURN_SUCCESS;
+
+    priv->stage1_state = NM_DEVICE_STAGE_STATE_PENDING;
+
+    if (priv->tdc) {
+        /* If the existing teamd config is the same as we're about to use,
+         * then we can proceed.  If it's not the same, and we have a PID,
+         * kill it so we can respawn it with the right config.  If we don't
+         * have a PID, then we must fail.
+         */
+        cfg = teamdctl_config_get_raw(priv->tdc);
+        if (cfg && nm_streq0(cfg, nm_setting_team_get_config(s_team))) {
+            _LOGD(LOGD_TEAM, "using existing matching teamd config");
+            return NM_ACT_STAGE_RETURN_SUCCESS;
+        }
+
+        if (!priv->teamd_pid) {
+            _LOGD(LOGD_TEAM, "existing teamd config mismatch; killing existing via teamdctl");
+            if (!teamd_kill(self, NULL, &error)) {
+                _LOGW(LOGD_TEAM,
+                      "existing teamd config mismatch; failed to kill existing teamd: %s",
+                      error->message);
+                NM_SET_OUT(out_failure_reason, NM_DEVICE_STATE_REASON_TEAMD_CONTROL_FAILED);
+                return NM_ACT_STAGE_RETURN_FAILURE;
+            }
+        }
+
+        _LOGD(LOGD_TEAM, "existing teamd config mismatch; respawning...");
+        teamd_cleanup(self, TRUE);
+    }
+
+    if (priv->kill_in_progress) {
+        _LOGT(LOGD_TEAM, "kill in progress, wait before starting teamd");
+        return NM_ACT_STAGE_RETURN_POSTPONE;
+    }
+
+    if (!teamd_start(self))
+        return NM_ACT_STAGE_RETURN_FAILURE;
+
+    return NM_ACT_STAGE_RETURN_POSTPONE;
+}
+
+static void
+deactivate(NMDevice *device)
+{
+    NMDeviceTeam *       self = NM_DEVICE_TEAM(device);
+    NMDeviceTeamPrivate *priv = NM_DEVICE_TEAM_GET_PRIVATE(self);
+
+    priv->stage1_state = NM_DEVICE_STAGE_STATE_INIT;
+
+    if (nm_device_sys_iface_state_is_external(device))
+        return;
+
+    if (priv->teamd_pid || priv->tdc)
+        _LOGI(LOGD_TEAM, "deactivation: stopping teamd...");
+
+    if (!priv->teamd_pid)
+        teamd_kill(self, NULL, NULL);
+
+    teamd_cleanup(self, TRUE);
+}
+
+static gboolean
+enslave_slave(NMDevice *device, NMDevice *slave, NMConnection *connection, gboolean configure)
+{
+    NMDeviceTeam *       self        = NM_DEVICE_TEAM(device);
+    NMDeviceTeamPrivate *priv        = NM_DEVICE_TEAM_GET_PRIVATE(self);
+    gboolean             success     = TRUE;
+    const char *         slave_iface = nm_device_get_ip_iface(slave);
+    NMSettingTeamPort *  s_team_port;
+
+    nm_device_master_check_slave_physical_port(device, slave, LOGD_TEAM);
+
+    if (configure) {
+        nm_device_take_down(slave, TRUE);
+
+        s_team_port = nm_connection_get_setting_team_port(connection);
+        if (s_team_port) {
+            const char *config = nm_setting_team_port_get_config(s_team_port);
+
+            if (config) {
+                if (!priv->tdc) {
+                    _LOGW(LOGD_TEAM,
+                          "enslaved team port %s config not changed, not connected to teamd",
+                          slave_iface);
+                } else {
+                    int   err;
+                    char *sanitized_config;
+
+                    sanitized_config = g_strdelimit(g_strdup(config), "\r\n", ' ');
+                    err = teamdctl_port_config_update_raw(priv->tdc, slave_iface, sanitized_config);
+                    g_free(sanitized_config);
+                    if (err != 0) {
+                        _LOGE(LOGD_TEAM,
+                              "failed to update config for port %s (err=%d)",
+                              slave_iface,
+                              err);
+                        return FALSE;
+                    }
+                }
+            }
+        }
+        success = nm_platform_link_enslave(nm_device_get_platform(device),
+                                           nm_device_get_ip_ifindex(device),
+                                           nm_device_get_ip_ifindex(slave));
+        nm_device_bring_up(slave, TRUE, NULL);
+
+        if (!success)
+            return FALSE;
+
+        nm_clear_g_source(&priv->teamd_read_timeout);
+        priv->teamd_read_timeout = g_timeout_add_seconds(5, teamd_read_timeout_cb, self);
+
+        _LOGI(LOGD_TEAM, "enslaved team port %s", slave_iface);
+    } else
+        _LOGI(LOGD_TEAM, "team port %s was enslaved", slave_iface);
+
+    return TRUE;
+}
+
+static void
+release_slave(NMDevice *device, NMDevice *slave, gboolean configure)
+{
+    NMDeviceTeam *       self = NM_DEVICE_TEAM(device);
+    NMDeviceTeamPrivate *priv = NM_DEVICE_TEAM_GET_PRIVATE(self);
+    gboolean             do_release, success;
+    NMSettingTeamPort *  s_port;
+    int                  ifindex_slave;
+    int                  ifindex;
+
+    do_release = configure;
+    if (do_release) {
+        ifindex = nm_device_get_ifindex(device);
+        if (ifindex <= 0 || !nm_platform_link_get(nm_device_get_platform(device), ifindex))
+            do_release = FALSE;
+    }
+
+    ifindex_slave = nm_device_get_ip_ifindex(slave);
+
+    if (ifindex_slave <= 0) {
+        _LOGD(LOGD_TEAM, "team port %s is already released", nm_device_get_ip_iface(slave));
+    } else if (do_release) {
+        success = nm_platform_link_release(nm_device_get_platform(device),
+                                           nm_device_get_ip_ifindex(device),
+                                           ifindex_slave);
+        if (success)
+            _LOGI(LOGD_TEAM, "released team port %s", nm_device_get_ip_iface(slave));
+        else
+            _LOGW(LOGD_TEAM, "failed to release team port %s", nm_device_get_ip_iface(slave));
+
+        /* Kernel team code "closes" the port when releasing it, (which clears
+         * IFF_UP), so we must bring it back up here to ensure carrier changes and
+         * other state is noticed by the now-released port.
+         */
+        if (!nm_device_bring_up(slave, TRUE, NULL)) {
+            _LOGW(LOGD_TEAM,
+                  "released team port %s could not be brought up",
+                  nm_device_get_ip_iface(slave));
+        }
+
+        nm_clear_g_source(&priv->teamd_read_timeout);
+        priv->teamd_read_timeout = g_timeout_add_seconds(5, teamd_read_timeout_cb, self);
+    } else
+        _LOGI(LOGD_TEAM, "team port %s was released", nm_device_get_ip_iface(slave));
+
+    /* Delete any port configuration we previously set */
+    if (configure && priv->tdc
+        && (s_port = nm_device_get_applied_setting(slave, NM_TYPE_SETTING_TEAM_PORT))
+        && (nm_setting_team_port_get_config(s_port)))
+        teamdctl_port_config_update_raw(priv->tdc, nm_device_get_ip_iface(slave), "{}");
+}
+
+static gboolean
+create_and_realize(NMDevice *             device,
+                   NMConnection *         connection,
+                   NMDevice *             parent,
+                   const NMPlatformLink **out_plink,
+                   GError **              error)
+{
+    const char *iface = nm_device_get_iface(device);
+    int         r;
+
+    r = nm_platform_link_team_add(nm_device_get_platform(device), iface, out_plink);
+    if (r < 0) {
+        g_set_error(error,
+                    NM_DEVICE_ERROR,
+                    NM_DEVICE_ERROR_CREATION_FAILED,
+                    "Failed to create team master interface '%s' for '%s': %s",
+                    iface,
+                    nm_connection_get_id(connection),
+                    nm_strerror(r));
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/*****************************************************************************/
+
+static void
+get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+    NMDeviceTeam *self = NM_DEVICE_TEAM(object);
+
+    switch (prop_id) {
+    case PROP_CONFIG:
+        g_value_set_string(value, _get_config(self));
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+        break;
+    }
+}
+
+/*****************************************************************************/
+
+static void
+nm_device_team_init(NMDeviceTeam *self)
+{
+    nm_assert(nm_device_is_master(NM_DEVICE(self)));
+}
+
+static void
+constructed(GObject *object)
+{
+    NMDevice *           device  = NM_DEVICE(object);
+    NMDeviceTeamPrivate *priv    = NM_DEVICE_TEAM_GET_PRIVATE(device);
+    gs_free char *       tmp_str = NULL;
+    gs_unref_object GFile *file  = NULL;
+    GError *               error;
+
+    G_OBJECT_CLASS(nm_device_team_parent_class)->constructed(object);
+
+    if (nm_dbus_manager_get_dbus_connection(nm_dbus_manager_get())) {
+        /* Register D-Bus name watcher */
+        tmp_str = g_strdup_printf("org.libteam.teamd.%s", nm_device_get_ip_iface(device));
+        priv->teamd_dbus_watch = g_bus_watch_name(G_BUS_TYPE_SYSTEM,
+                                                  tmp_str,
+                                                  G_BUS_NAME_WATCHER_FLAGS_NONE,
+                                                  teamd_dbus_appeared,
+                                                  teamd_dbus_vanished,
+                                                  NM_DEVICE(device),
+                                                  NULL);
+        return;
+    }
+
+    /* No D-Bus, watch unix socket */
+    tmp_str             = g_strdup_printf("/run/teamd/%s.sock", nm_device_get_ip_iface(device));
+    file                = g_file_new_for_path(tmp_str);
+    priv->usock_monitor = g_file_monitor_file(file, G_FILE_MONITOR_NONE, NULL, &error);
+    if (!priv->usock_monitor) {
+        nm_log_warn(LOGD_TEAM, "error monitoring %s: %s", tmp_str, error->message);
+    } else {
+        g_signal_connect(priv->usock_monitor, "changed", G_CALLBACK(monitor_changed_cb), object);
+    }
+}
+
+NMDevice *
+nm_device_team_new(const char *iface)
+{
+    return g_object_new(NM_TYPE_DEVICE_TEAM,
+                        NM_DEVICE_IFACE,
+                        iface,
+                        NM_DEVICE_DRIVER,
+                        "team",
+                        NM_DEVICE_TYPE_DESC,
+                        "Team",
+                        NM_DEVICE_DEVICE_TYPE,
+                        NM_DEVICE_TYPE_TEAM,
+                        NM_DEVICE_LINK_TYPE,
+                        NM_LINK_TYPE_TEAM,
+                        NULL);
+}
+
+static void
+dispose(GObject *object)
+{
+    NMDeviceTeam *       self = NM_DEVICE_TEAM(object);
+    NMDeviceTeamPrivate *priv = NM_DEVICE_TEAM_GET_PRIVATE(self);
+
+    if (priv->teamd_dbus_watch) {
+        g_bus_unwatch_name(priv->teamd_dbus_watch);
+        priv->teamd_dbus_watch = 0;
+    }
+
+    if (priv->usock_monitor) {
+        g_signal_handlers_disconnect_by_data(priv->usock_monitor, object);
+        g_clear_object(&priv->usock_monitor);
+    }
+
+    teamd_cleanup(self, TRUE);
+    nm_clear_g_free(&priv->config);
+
+    G_OBJECT_CLASS(nm_device_team_parent_class)->dispose(object);
+}
+
+static const NMDBusInterfaceInfoExtended interface_info_device_team = {
+    .parent = NM_DEFINE_GDBUS_INTERFACE_INFO_INIT(
+        NM_DBUS_INTERFACE_DEVICE_TEAM,
+        .signals    = NM_DEFINE_GDBUS_SIGNAL_INFOS(&nm_signal_info_property_changed_legacy, ),
+        .properties = NM_DEFINE_GDBUS_PROPERTY_INFOS(
+            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE_L("HwAddress",
+                                                             "s",
+                                                             NM_DEVICE_HW_ADDRESS),
+            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE_L("Carrier", "b", NM_DEVICE_CARRIER),
+            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE_L("Slaves", "ao", NM_DEVICE_SLAVES),
+            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE_L("Config",
+                                                             "s",
+                                                             NM_DEVICE_TEAM_CONFIG), ), ),
+    .legacy_property_changed = TRUE,
+};
+
+static void
+nm_device_team_class_init(NMDeviceTeamClass *klass)
+{
+    GObjectClass *     object_class      = G_OBJECT_CLASS(klass);
+    NMDBusObjectClass *dbus_object_class = NM_DBUS_OBJECT_CLASS(klass);
+    NMDeviceClass *    device_class      = NM_DEVICE_CLASS(klass);
+
+    object_class->constructed  = constructed;
+    object_class->dispose      = dispose;
+    object_class->get_property = get_property;
+
+    dbus_object_class->interface_infos = NM_DBUS_INTERFACE_INFOS(&interface_info_device_team);
+
+    device_class->connection_type_supported        = NM_SETTING_TEAM_SETTING_NAME;
+    device_class->connection_type_check_compatible = NM_SETTING_TEAM_SETTING_NAME;
+    device_class->link_types                       = NM_DEVICE_DEFINE_LINK_TYPES(NM_LINK_TYPE_TEAM);
+
+    device_class->is_master                      = TRUE;
+    device_class->create_and_realize             = create_and_realize;
+    device_class->get_generic_capabilities       = get_generic_capabilities;
+    device_class->complete_connection            = complete_connection;
+    device_class->update_connection              = update_connection;
+    device_class->master_update_slave_connection = master_update_slave_connection;
+
+    device_class->act_stage1_prepare_also_for_external_or_assume = TRUE;
+    device_class->act_stage1_prepare                             = act_stage1_prepare;
+    device_class->get_configured_mtu = nm_device_get_configured_mtu_for_wired;
+    device_class->deactivate         = deactivate;
+    device_class->enslave_slave      = enslave_slave;
+    device_class->release_slave      = release_slave;
+
+    obj_properties[PROP_CONFIG] = g_param_spec_string(NM_DEVICE_TEAM_CONFIG,
+                                                      "",
+                                                      "",
+                                                      NULL,
+                                                      G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+
+    g_object_class_install_properties(object_class, _PROPERTY_ENUMS_LAST, obj_properties);
+}
diff --git a/src/core/devices/team/nm-device-team.h b/src/core/devices/team/nm-device-team.h
new file mode 100644
index 00000000..6f5cff93
--- /dev/null
+++ b/src/core/devices/team/nm-device-team.h
@@ -0,0 +1,30 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (C) 2013 Jiri Pirko <jiri@resnulli.us>
+ */
+
+#ifndef __NETWORKMANAGER_DEVICE_TEAM_H__
+#define __NETWORKMANAGER_DEVICE_TEAM_H__
+
+#include "devices/nm-device.h"
+
+#define NM_TYPE_DEVICE_TEAM (nm_device_team_get_type())
+#define NM_DEVICE_TEAM(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_DEVICE_TEAM, NMDeviceTeam))
+#define NM_DEVICE_TEAM_CLASS(klass) \
+    (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_DEVICE_TEAM, NMDeviceTeamClass))
+#define NM_IS_DEVICE_TEAM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_DEVICE_TEAM))
+#define NM_IS_DEVICE_TEAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_DEVICE_TEAM))
+#define NM_DEVICE_TEAM_GET_CLASS(obj) \
+    (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_DEVICE_TEAM, NMDeviceTeamClass))
+
+/* Properties */
+#define NM_DEVICE_TEAM_CONFIG "config"
+
+typedef struct _NMDeviceTeam      NMDeviceTeam;
+typedef struct _NMDeviceTeamClass NMDeviceTeamClass;
+
+GType nm_device_team_get_type(void);
+
+NMDevice *nm_device_team_new(const char *iface);
+
+#endif /* __NETWORKMANAGER_DEVICE_TEAM_H__ */
diff --git a/src/core/devices/team/nm-team-factory.c b/src/core/devices/team/nm-team-factory.c
new file mode 100644
index 00000000..57b51bf8
--- /dev/null
+++ b/src/core/devices/team/nm-team-factory.c
@@ -0,0 +1,77 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (C) 2014 Red Hat, Inc.
+ */
+
+#include "src/core/nm-default-daemon.h"
+
+#include <gmodule.h>
+
+#include "nm-manager.h"
+#include "devices/nm-device-factory.h"
+#include "nm-device-team.h"
+#include "platform/nm-platform.h"
+#include "nm-core-internal.h"
+
+/*****************************************************************************/
+
+#define NM_TYPE_TEAM_FACTORY (nm_team_factory_get_type())
+#define NM_TEAM_FACTORY(obj) \
+    (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_TEAM_FACTORY, NMTeamFactory))
+#define NM_TEAM_FACTORY_CLASS(klass) \
+    (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_TEAM_FACTORY, NMTeamFactoryClass))
+#define NM_IS_TEAM_FACTORY(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_TEAM_FACTORY))
+#define NM_IS_TEAM_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_TEAM_FACTORY))
+#define NM_TEAM_FACTORY_GET_CLASS(obj) \
+    (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_TEAM_FACTORY, NMTeamFactoryClass))
+
+typedef struct {
+    NMDeviceFactory parent;
+} NMTeamFactory;
+
+typedef struct {
+    NMDeviceFactoryClass parent;
+} NMTeamFactoryClass;
+
+static GType nm_team_factory_get_type(void);
+
+G_DEFINE_TYPE(NMTeamFactory, nm_team_factory, NM_TYPE_DEVICE_FACTORY)
+
+/*****************************************************************************/
+
+NM_DEVICE_FACTORY_DECLARE_TYPES(NM_DEVICE_FACTORY_DECLARE_LINK_TYPES(
+    NM_LINK_TYPE_TEAM) NM_DEVICE_FACTORY_DECLARE_SETTING_TYPES(NM_SETTING_TEAM_SETTING_NAME))
+
+G_MODULE_EXPORT NMDeviceFactory *
+                nm_device_factory_create(GError **error)
+{
+    nm_manager_set_capability(NM_MANAGER_GET, NM_CAPABILITY_TEAM);
+    return g_object_new(NM_TYPE_TEAM_FACTORY, NULL);
+}
+
+/*****************************************************************************/
+
+static NMDevice *
+create_device(NMDeviceFactory *     factory,
+              const char *          iface,
+              const NMPlatformLink *plink,
+              NMConnection *        connection,
+              gboolean *            out_ignore)
+{
+    return nm_device_team_new(iface);
+}
+
+/*****************************************************************************/
+
+static void
+nm_team_factory_init(NMTeamFactory *self)
+{}
+
+static void
+nm_team_factory_class_init(NMTeamFactoryClass *klass)
+{
+    NMDeviceFactoryClass *factory_class = NM_DEVICE_FACTORY_CLASS(klass);
+
+    factory_class->create_device       = create_device;
+    factory_class->get_supported_types = get_supported_types;
+}