mirror of
https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git
synced 2026-05-21 16:38:11 +02:00
44ecb41593
Keep the include paths clean and separate. We use directories to group source files together. That makes sense (I guess), but then we should use this grouping also when including files. Thus require to #include files with their path relative to "src/". Also, we build various artifacts from the "src/" tree. Instead of having individual CFLAGS for each artifact in Makefile.am, the CFLAGS should be unified. Previously, the CFLAGS for each artifact differ and are inconsistent in which paths they add to the search path. Fix the inconsistency by just don't add the paths at all.
745 lines
23 KiB
C
745 lines
23 KiB
C
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
|
|
/* NetworkManager -- Network link manager
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Copyright 2013 - 2015 Red Hat, Inc.
|
|
*/
|
|
|
|
#include "nm-default.h"
|
|
|
|
#include "nm-device-macvlan.h"
|
|
|
|
#include <string.h>
|
|
|
|
#include "nm-device-private.h"
|
|
#include "settings/nm-settings.h"
|
|
#include "nm-act-request.h"
|
|
#include "nm-manager.h"
|
|
#include "platform/nm-platform.h"
|
|
#include "nm-device-factory.h"
|
|
#include "nm-setting-macvlan.h"
|
|
#include "nm-setting-wired.h"
|
|
#include "nm-active-connection.h"
|
|
#include "nm-ip4-config.h"
|
|
#include "nm-utils.h"
|
|
|
|
#include "nmdbus-device-macvlan.h"
|
|
|
|
#include "nm-device-logging.h"
|
|
_LOG_DECLARE_SELF(NMDeviceMacvlan);
|
|
|
|
/*****************************************************************************/
|
|
|
|
NM_GOBJECT_PROPERTIES_DEFINE (NMDeviceMacvlan,
|
|
PROP_PARENT,
|
|
PROP_MODE,
|
|
PROP_NO_PROMISC,
|
|
PROP_TAP,
|
|
);
|
|
|
|
typedef struct {
|
|
int parent_ifindex;
|
|
gulong parent_state_id;
|
|
NMDevice *parent;
|
|
NMPlatformLnkMacvlan props;
|
|
} NMDeviceMacvlanPrivate;
|
|
|
|
struct _NMDeviceMacvlan {
|
|
NMDevice parent;
|
|
NMDeviceMacvlanPrivate _priv;
|
|
};
|
|
|
|
struct _NMDeviceMacvlanClass {
|
|
NMDeviceClass parent;
|
|
};
|
|
|
|
G_DEFINE_TYPE (NMDeviceMacvlan, nm_device_macvlan, NM_TYPE_DEVICE)
|
|
|
|
#define NM_DEVICE_MACVLAN_GET_PRIVATE(self) _NM_GET_PRIVATE (self, NMDeviceMacvlan, NM_IS_DEVICE_MACVLAN)
|
|
|
|
/*****************************************************************************/
|
|
|
|
static int modes[][2] = {
|
|
{ NM_SETTING_MACVLAN_MODE_VEPA, MACVLAN_MODE_VEPA },
|
|
{ NM_SETTING_MACVLAN_MODE_BRIDGE, MACVLAN_MODE_BRIDGE },
|
|
{ NM_SETTING_MACVLAN_MODE_PRIVATE, MACVLAN_MODE_PRIVATE },
|
|
{ NM_SETTING_MACVLAN_MODE_PASSTHRU, MACVLAN_MODE_PASSTHRU },
|
|
};
|
|
|
|
static int
|
|
setting_mode_to_platform (int mode)
|
|
{
|
|
guint i;
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (modes); i++) {
|
|
if (modes[i][0] == mode)
|
|
return modes[i][1];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
platform_mode_to_setting (int mode)
|
|
{
|
|
guint i;
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (modes); i++) {
|
|
if (modes[i][1] == mode)
|
|
return modes[i][0];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const char *
|
|
platform_mode_to_string (guint mode)
|
|
{
|
|
switch (mode) {
|
|
case MACVLAN_MODE_PRIVATE:
|
|
return "private";
|
|
case MACVLAN_MODE_VEPA:
|
|
return "vepa";
|
|
case MACVLAN_MODE_BRIDGE:
|
|
return "bridge";
|
|
case MACVLAN_MODE_PASSTHRU:
|
|
return "passthru";
|
|
default:
|
|
return "unknown";
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
parent_state_changed (NMDevice *parent,
|
|
NMDeviceState new_state,
|
|
NMDeviceState old_state,
|
|
NMDeviceStateReason reason,
|
|
gpointer user_data)
|
|
{
|
|
NMDeviceMacvlan *self = NM_DEVICE_MACVLAN (user_data);
|
|
|
|
/* We'll react to our own carrier state notifications. Ignore the parent's. */
|
|
if (reason == NM_DEVICE_STATE_REASON_CARRIER)
|
|
return;
|
|
|
|
nm_device_set_unmanaged_by_flags (NM_DEVICE (self), NM_UNMANAGED_PARENT, !nm_device_get_managed (parent, FALSE), reason);
|
|
}
|
|
|
|
static void
|
|
nm_device_macvlan_set_parent (NMDeviceMacvlan *self, NMDevice *parent)
|
|
{
|
|
NMDeviceMacvlanPrivate *priv = NM_DEVICE_MACVLAN_GET_PRIVATE (self);
|
|
NMDevice *device = NM_DEVICE (self);
|
|
|
|
if (parent == priv->parent)
|
|
return;
|
|
|
|
nm_clear_g_signal_handler (priv->parent, &priv->parent_state_id);
|
|
|
|
g_clear_object (&priv->parent);
|
|
|
|
if (parent) {
|
|
priv->parent = g_object_ref (parent);
|
|
priv->parent_state_id = g_signal_connect (priv->parent,
|
|
"state-changed",
|
|
G_CALLBACK (parent_state_changed),
|
|
device);
|
|
|
|
/* Set parent-dependent unmanaged flag */
|
|
nm_device_set_unmanaged_by_flags (device,
|
|
NM_UNMANAGED_PARENT,
|
|
!nm_device_get_managed (parent, FALSE),
|
|
NM_DEVICE_STATE_REASON_PARENT_MANAGED_CHANGED);
|
|
}
|
|
|
|
/* Recheck availability now that the parent has changed */
|
|
nm_device_queue_recheck_available (device,
|
|
NM_DEVICE_STATE_REASON_PARENT_CHANGED,
|
|
NM_DEVICE_STATE_REASON_PARENT_CHANGED);
|
|
_notify (self, PROP_PARENT);
|
|
}
|
|
|
|
static void
|
|
update_properties (NMDevice *device)
|
|
{
|
|
NMDeviceMacvlan *self = NM_DEVICE_MACVLAN (device);
|
|
NMDeviceMacvlanPrivate *priv = NM_DEVICE_MACVLAN_GET_PRIVATE (self);
|
|
GObject *object = G_OBJECT (device);
|
|
const NMPlatformLnkMacvlan *props;
|
|
const NMPlatformLink *plink;
|
|
NMDevice *parent = NULL;
|
|
|
|
if (priv->props.tap)
|
|
props = nm_platform_link_get_lnk_macvtap (NM_PLATFORM_GET, nm_device_get_ifindex (device), &plink);
|
|
else
|
|
props = nm_platform_link_get_lnk_macvlan (NM_PLATFORM_GET, nm_device_get_ifindex (device), &plink);
|
|
|
|
if (!props) {
|
|
_LOGW (LOGD_PLATFORM, "could not get %s properties", priv->props.tap ? "macvtap" : "macvlan");
|
|
return;
|
|
}
|
|
|
|
g_object_freeze_notify (object);
|
|
|
|
if (priv->parent_ifindex != plink->parent) {
|
|
parent = nm_manager_get_device_by_ifindex (nm_manager_get (), plink->parent);
|
|
nm_device_macvlan_set_parent (self, parent);
|
|
}
|
|
if (priv->props.mode != props->mode)
|
|
_notify (self, PROP_MODE);
|
|
if (priv->props.no_promisc != props->no_promisc)
|
|
_notify (self, PROP_NO_PROMISC);
|
|
|
|
priv->parent_ifindex = plink->parent;
|
|
priv->props = *props;
|
|
|
|
g_object_thaw_notify (object);
|
|
}
|
|
|
|
static void
|
|
link_changed (NMDevice *device, NMPlatformLink *info)
|
|
{
|
|
NM_DEVICE_CLASS (nm_device_macvlan_parent_class)->link_changed (device, info);
|
|
update_properties (device);
|
|
}
|
|
|
|
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);
|
|
NMPlatformError plerr;
|
|
NMSettingMacvlan *s_macvlan;
|
|
NMPlatformLnkMacvlan lnk = { };
|
|
int parent_ifindex;
|
|
|
|
s_macvlan = nm_connection_get_setting_macvlan (connection);
|
|
g_assert (s_macvlan);
|
|
|
|
if (!parent) {
|
|
g_set_error (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_FAILED,
|
|
"MACVLAN devices can not be created without a parent interface");
|
|
return FALSE;
|
|
}
|
|
|
|
parent_ifindex = nm_device_get_ifindex (parent);
|
|
g_warn_if_fail (parent_ifindex > 0);
|
|
|
|
lnk.mode = setting_mode_to_platform (nm_setting_macvlan_get_mode (s_macvlan));
|
|
if (!lnk.mode) {
|
|
g_set_error (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_FAILED,
|
|
"unsupported MACVLAN mode %u in connection %s",
|
|
nm_setting_macvlan_get_mode (s_macvlan),
|
|
nm_connection_get_uuid (connection));
|
|
return FALSE;
|
|
}
|
|
lnk.no_promisc = !nm_setting_macvlan_get_promiscuous (s_macvlan);
|
|
lnk.tap = nm_setting_macvlan_get_tap (s_macvlan);
|
|
|
|
plerr = nm_platform_link_macvlan_add (NM_PLATFORM_GET, iface, parent_ifindex, &lnk, out_plink);
|
|
if (plerr != NM_PLATFORM_ERROR_SUCCESS) {
|
|
g_set_error (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_CREATION_FAILED,
|
|
"Failed to create %s interface '%s' for '%s': %s",
|
|
lnk.tap ? "macvtap" : "macvlan",
|
|
iface,
|
|
nm_connection_get_id (connection),
|
|
nm_platform_error_to_string (plerr));
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static NMDeviceCapabilities
|
|
get_generic_capabilities (NMDevice *dev)
|
|
{
|
|
/* We assume MACVLAN interfaces always support carrier detect */
|
|
return NM_DEVICE_CAP_CARRIER_DETECT | NM_DEVICE_CAP_IS_SOFTWARE;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static gboolean
|
|
is_available (NMDevice *device, NMDeviceCheckDevAvailableFlags flags)
|
|
{
|
|
if (!NM_DEVICE_MACVLAN_GET_PRIVATE ((NMDeviceMacvlan *) device)->parent)
|
|
return FALSE;
|
|
|
|
return NM_DEVICE_CLASS (nm_device_macvlan_parent_class)->is_available (device, flags);
|
|
}
|
|
|
|
static void
|
|
notify_new_device_added (NMDevice *device, NMDevice *new_device)
|
|
{
|
|
NMDeviceMacvlan *self = NM_DEVICE_MACVLAN (device);
|
|
NMDeviceMacvlanPrivate *priv = NM_DEVICE_MACVLAN_GET_PRIVATE (self);
|
|
|
|
if (priv->parent)
|
|
return;
|
|
|
|
if (!nm_device_is_real (device))
|
|
return;
|
|
|
|
update_properties (device);
|
|
|
|
if ( priv->parent_ifindex <= 0
|
|
|| nm_device_get_ifindex (new_device) != priv->parent_ifindex)
|
|
return;
|
|
|
|
priv->parent_ifindex = nm_device_get_ifindex (new_device);
|
|
nm_device_macvlan_set_parent (self, new_device);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
|
|
static gboolean
|
|
match_parent (NMDeviceMacvlan *self, const char *parent)
|
|
{
|
|
NMDeviceMacvlanPrivate *priv = NM_DEVICE_MACVLAN_GET_PRIVATE (self);
|
|
|
|
g_return_val_if_fail (parent != NULL, FALSE);
|
|
|
|
if (!priv->parent)
|
|
return FALSE;
|
|
|
|
if (nm_utils_is_uuid (parent)) {
|
|
NMActRequest *parent_req;
|
|
NMConnection *parent_connection;
|
|
|
|
/* If the parent is a UUID, the connection matches if our parent
|
|
* device has that connection activated.
|
|
*/
|
|
|
|
parent_req = nm_device_get_act_request (priv->parent);
|
|
if (!parent_req)
|
|
return FALSE;
|
|
|
|
parent_connection = nm_active_connection_get_applied_connection (NM_ACTIVE_CONNECTION (parent_req));
|
|
if (!parent_connection)
|
|
return FALSE;
|
|
|
|
if (g_strcmp0 (parent, nm_connection_get_uuid (parent_connection)) != 0)
|
|
return FALSE;
|
|
} else {
|
|
/* interface name */
|
|
if (g_strcmp0 (parent, nm_device_get_ip_iface (priv->parent)) != 0)
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
match_hwaddr (NMDevice *device, NMConnection *connection, gboolean fail_if_no_hwaddr)
|
|
{
|
|
NMDeviceMacvlanPrivate *priv = NM_DEVICE_MACVLAN_GET_PRIVATE ((NMDeviceMacvlan *) device);
|
|
NMSettingWired *s_wired;
|
|
const char *setting_mac;
|
|
const char *parent_mac;
|
|
|
|
s_wired = nm_connection_get_setting_wired (connection);
|
|
if (!s_wired)
|
|
return !fail_if_no_hwaddr;
|
|
|
|
setting_mac = nm_setting_wired_get_mac_address (s_wired);
|
|
if (!setting_mac)
|
|
return !fail_if_no_hwaddr;
|
|
|
|
if (!priv->parent)
|
|
return !fail_if_no_hwaddr;
|
|
|
|
parent_mac = nm_device_get_permanent_hw_address (priv->parent);
|
|
return parent_mac && nm_utils_hwaddr_matches (setting_mac, -1, parent_mac, -1);
|
|
}
|
|
|
|
static gboolean
|
|
check_connection_compatible (NMDevice *device, NMConnection *connection)
|
|
{
|
|
NMDeviceMacvlanPrivate *priv = NM_DEVICE_MACVLAN_GET_PRIVATE ((NMDeviceMacvlan *) device);
|
|
NMSettingMacvlan *s_macvlan;
|
|
const char *parent = NULL;
|
|
|
|
if (!NM_DEVICE_CLASS (nm_device_macvlan_parent_class)->check_connection_compatible (device, connection))
|
|
return FALSE;
|
|
|
|
s_macvlan = nm_connection_get_setting_macvlan (connection);
|
|
if (!s_macvlan)
|
|
return FALSE;
|
|
|
|
if (nm_setting_macvlan_get_tap (s_macvlan) != priv->props.tap)
|
|
return FALSE;
|
|
|
|
/* Before the device is realized some properties will not be set */
|
|
if (nm_device_is_real (device)) {
|
|
|
|
if (setting_mode_to_platform (nm_setting_macvlan_get_mode (s_macvlan)) != priv->props.mode)
|
|
return FALSE;
|
|
|
|
if (nm_setting_macvlan_get_promiscuous (s_macvlan) == priv->props.no_promisc)
|
|
return FALSE;
|
|
|
|
/* Check parent interface; could be an interface name or a UUID */
|
|
parent = nm_setting_macvlan_get_parent (s_macvlan);
|
|
if (parent) {
|
|
if (!match_parent (NM_DEVICE_MACVLAN (device), parent))
|
|
return FALSE;
|
|
} else {
|
|
/* Parent could be a MAC address in an NMSettingWired */
|
|
if (!match_hwaddr (device, connection, TRUE))
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
complete_connection (NMDevice *device,
|
|
NMConnection *connection,
|
|
const char *specific_object,
|
|
const GSList *existing_connections,
|
|
GError **error)
|
|
{
|
|
NMSettingMacvlan *s_macvlan;
|
|
|
|
nm_utils_complete_generic (NM_PLATFORM_GET,
|
|
connection,
|
|
NM_SETTING_MACVLAN_SETTING_NAME,
|
|
existing_connections,
|
|
NULL,
|
|
_("MACVLAN connection"),
|
|
NULL,
|
|
TRUE);
|
|
|
|
s_macvlan = nm_connection_get_setting_macvlan (connection);
|
|
if (!s_macvlan) {
|
|
g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INVALID_CONNECTION,
|
|
"A 'macvlan' setting is required.");
|
|
return FALSE;
|
|
}
|
|
|
|
/* If there's no MACVLAN interface, no parent, and no hardware address in the
|
|
* settings, then there's not enough information to complete the setting.
|
|
*/
|
|
if ( !nm_setting_macvlan_get_parent (s_macvlan)
|
|
&& !match_hwaddr (device, connection, TRUE)) {
|
|
g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INVALID_CONNECTION,
|
|
"The 'macvlan' setting had no interface name, parent, or hardware address.");
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
update_connection (NMDevice *device, NMConnection *connection)
|
|
{
|
|
NMDeviceMacvlanPrivate *priv = NM_DEVICE_MACVLAN_GET_PRIVATE ((NMDeviceMacvlan *) device);
|
|
NMSettingMacvlan *s_macvlan = nm_connection_get_setting_macvlan (connection);
|
|
const char *setting_parent, *new_parent;
|
|
int new_mode;
|
|
|
|
if (!s_macvlan) {
|
|
s_macvlan = (NMSettingMacvlan *) nm_setting_macvlan_new ();
|
|
nm_connection_add_setting (connection, (NMSetting *) s_macvlan);
|
|
}
|
|
|
|
new_mode = platform_mode_to_setting (priv->props.mode);
|
|
if (new_mode != nm_setting_macvlan_get_mode (s_macvlan))
|
|
g_object_set (s_macvlan, NM_SETTING_MACVLAN_MODE, new_mode, NULL);
|
|
|
|
if (priv->props.no_promisc == nm_setting_macvlan_get_promiscuous (s_macvlan))
|
|
g_object_set (s_macvlan, NM_SETTING_MACVLAN_PROMISCUOUS, !priv->props.no_promisc, NULL);
|
|
|
|
|
|
if (priv->props.tap != nm_setting_macvlan_get_tap (s_macvlan))
|
|
g_object_set (s_macvlan, NM_SETTING_MACVLAN_TAP, !!priv->props.tap, NULL);
|
|
|
|
/* Update parent in the connection; default to parent's interface name */
|
|
if (priv->parent) {
|
|
new_parent = nm_device_get_iface (priv->parent);
|
|
setting_parent = nm_setting_macvlan_get_parent (s_macvlan);
|
|
if (setting_parent && nm_utils_is_uuid (setting_parent)) {
|
|
NMConnection *parent_connection;
|
|
|
|
/* Don't change a parent specified by UUID if it's still valid */
|
|
parent_connection = (NMConnection *) nm_settings_get_connection_by_uuid (nm_device_get_settings (device), setting_parent);
|
|
if (parent_connection && nm_device_check_connection_compatible (priv->parent, parent_connection))
|
|
new_parent = NULL;
|
|
}
|
|
if (new_parent)
|
|
g_object_set (s_macvlan, NM_SETTING_MACVLAN_PARENT, new_parent, NULL);
|
|
} else
|
|
g_object_set (s_macvlan, NM_SETTING_MACVLAN_PARENT, NULL, NULL);
|
|
|
|
}
|
|
|
|
static NMActStageReturn
|
|
act_stage1_prepare (NMDevice *dev, NMDeviceStateReason *reason)
|
|
{
|
|
NMActStageReturn ret;
|
|
|
|
g_return_val_if_fail (reason != NULL, NM_ACT_STAGE_RETURN_FAILURE);
|
|
|
|
ret = NM_DEVICE_CLASS (nm_device_macvlan_parent_class)->act_stage1_prepare (dev, reason);
|
|
if (ret != NM_ACT_STAGE_RETURN_SUCCESS)
|
|
return ret;
|
|
|
|
if (!nm_device_hw_addr_set_cloned (dev, nm_device_get_applied_connection (dev), FALSE))
|
|
return NM_ACT_STAGE_RETURN_FAILURE;
|
|
return NM_ACT_STAGE_RETURN_SUCCESS;
|
|
}
|
|
|
|
static void
|
|
ip4_config_pre_commit (NMDevice *device, NMIP4Config *config)
|
|
{
|
|
NMConnection *connection;
|
|
NMSettingWired *s_wired;
|
|
guint32 mtu;
|
|
|
|
connection = nm_device_get_applied_connection (device);
|
|
g_assert (connection);
|
|
|
|
s_wired = nm_connection_get_setting_wired (connection);
|
|
if (s_wired) {
|
|
mtu = nm_setting_wired_get_mtu (s_wired);
|
|
if (mtu)
|
|
nm_ip4_config_set_mtu (config, mtu, NM_IP_CONFIG_SOURCE_USER);
|
|
}
|
|
}
|
|
|
|
static void
|
|
realize_start_notify (NMDevice *device, const NMPlatformLink *plink)
|
|
{
|
|
NM_DEVICE_CLASS (nm_device_macvlan_parent_class)->realize_start_notify (device, plink);
|
|
|
|
update_properties (device);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
get_property (GObject *object, guint prop_id,
|
|
GValue *value, GParamSpec *pspec)
|
|
{
|
|
NMDeviceMacvlanPrivate *priv = NM_DEVICE_MACVLAN_GET_PRIVATE ((NMDeviceMacvlan *) object);
|
|
NMDevice *parent;
|
|
|
|
switch (prop_id) {
|
|
case PROP_PARENT:
|
|
if (priv->parent_ifindex > 0)
|
|
parent = nm_manager_get_device_by_ifindex (nm_manager_get (), priv->parent_ifindex);
|
|
else
|
|
parent = NULL;
|
|
nm_utils_g_value_set_object_path (value, parent);
|
|
break;
|
|
case PROP_MODE:
|
|
g_value_set_string (value, platform_mode_to_string (priv->props.mode));
|
|
break;
|
|
case PROP_NO_PROMISC:
|
|
g_value_set_boolean (value, priv->props.no_promisc);
|
|
break;
|
|
case PROP_TAP:
|
|
g_value_set_boolean (value, priv->props.tap);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
set_property (GObject *object, guint prop_id,
|
|
const GValue *value, GParamSpec *pspec)
|
|
{
|
|
NMDeviceMacvlanPrivate *priv = NM_DEVICE_MACVLAN_GET_PRIVATE ((NMDeviceMacvlan *) object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_TAP:
|
|
priv->props.tap = g_value_get_boolean (value);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
nm_device_macvlan_init (NMDeviceMacvlan *self)
|
|
{
|
|
}
|
|
|
|
static void
|
|
dispose (GObject *object)
|
|
{
|
|
nm_device_macvlan_set_parent (NM_DEVICE_MACVLAN (object), NULL);
|
|
|
|
G_OBJECT_CLASS (nm_device_macvlan_parent_class)->dispose (object);
|
|
}
|
|
|
|
static void
|
|
nm_device_macvlan_class_init (NMDeviceMacvlanClass *klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
NMDeviceClass *device_class = NM_DEVICE_CLASS (klass);
|
|
|
|
NM_DEVICE_CLASS_DECLARE_TYPES (klass, NULL, NM_LINK_TYPE_MACVLAN, NM_LINK_TYPE_MACVTAP)
|
|
|
|
object_class->dispose = dispose;
|
|
object_class->get_property = get_property;
|
|
object_class->set_property = set_property;
|
|
|
|
device_class->act_stage1_prepare = act_stage1_prepare;
|
|
device_class->check_connection_compatible = check_connection_compatible;
|
|
device_class->complete_connection = complete_connection;
|
|
device_class->connection_type = NM_SETTING_MACVLAN_SETTING_NAME;
|
|
device_class->create_and_realize = create_and_realize;
|
|
device_class->get_generic_capabilities = get_generic_capabilities;
|
|
device_class->ip4_config_pre_commit = ip4_config_pre_commit;
|
|
device_class->is_available = is_available;
|
|
device_class->link_changed = link_changed;
|
|
device_class->notify_new_device_added = notify_new_device_added;
|
|
device_class->realize_start_notify = realize_start_notify;
|
|
device_class->update_connection = update_connection;
|
|
|
|
obj_properties[PROP_PARENT] =
|
|
g_param_spec_string (NM_DEVICE_MACVLAN_PARENT, "", "",
|
|
NULL,
|
|
G_PARAM_READABLE |
|
|
G_PARAM_STATIC_STRINGS);
|
|
|
|
obj_properties[PROP_MODE] =
|
|
g_param_spec_string (NM_DEVICE_MACVLAN_MODE, "", "",
|
|
NULL,
|
|
G_PARAM_READABLE |
|
|
G_PARAM_STATIC_STRINGS);
|
|
|
|
obj_properties[PROP_NO_PROMISC] =
|
|
g_param_spec_boolean (NM_DEVICE_MACVLAN_NO_PROMISC, "", "",
|
|
FALSE,
|
|
G_PARAM_READABLE |
|
|
G_PARAM_STATIC_STRINGS);
|
|
|
|
obj_properties[PROP_TAP] =
|
|
g_param_spec_boolean (NM_DEVICE_MACVLAN_TAP, "", "",
|
|
FALSE,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT_ONLY |
|
|
G_PARAM_STATIC_STRINGS);
|
|
|
|
g_object_class_install_properties (object_class, _PROPERTY_ENUMS_LAST, obj_properties);
|
|
|
|
nm_exported_object_class_add_interface (NM_EXPORTED_OBJECT_CLASS (klass),
|
|
NMDBUS_TYPE_DEVICE_MACVLAN_SKELETON,
|
|
NULL);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
#define NM_TYPE_MACVLAN_DEVICE_FACTORY (nm_macvlan_device_factory_get_type ())
|
|
#define NM_MACVLAN_DEVICE_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NM_TYPE_MACVLAN_DEVICE_FACTORY, NMMacvlanDeviceFactory))
|
|
|
|
static NMDevice *
|
|
create_device (NMDeviceFactory *factory,
|
|
const char *iface,
|
|
const NMPlatformLink *plink,
|
|
NMConnection *connection,
|
|
gboolean *out_ignore)
|
|
{
|
|
NMSettingMacvlan *s_macvlan;
|
|
NMLinkType link_type;
|
|
gboolean tap;
|
|
|
|
if (connection) {
|
|
s_macvlan = nm_connection_get_setting_macvlan (connection);
|
|
g_assert (s_macvlan);
|
|
tap = nm_setting_macvlan_get_tap (s_macvlan);
|
|
} else {
|
|
g_assert (plink);
|
|
tap = plink->type == NM_LINK_TYPE_MACVTAP;
|
|
}
|
|
|
|
link_type = tap ? NM_LINK_TYPE_MACVTAP : NM_LINK_TYPE_MACVLAN;
|
|
|
|
return (NMDevice *) g_object_new (NM_TYPE_DEVICE_MACVLAN,
|
|
NM_DEVICE_IFACE, iface,
|
|
NM_DEVICE_TYPE_DESC, "Macvlan",
|
|
NM_DEVICE_DEVICE_TYPE, NM_DEVICE_TYPE_MACVLAN,
|
|
NM_DEVICE_LINK_TYPE, link_type,
|
|
NM_DEVICE_MACVLAN_TAP, tap,
|
|
NULL);
|
|
}
|
|
|
|
static const char *
|
|
get_connection_parent (NMDeviceFactory *factory, NMConnection *connection)
|
|
{
|
|
NMSettingMacvlan *s_macvlan;
|
|
NMSettingWired *s_wired;
|
|
const char *parent = NULL;
|
|
|
|
g_return_val_if_fail (nm_connection_is_type (connection, NM_SETTING_MACVLAN_SETTING_NAME), NULL);
|
|
|
|
s_macvlan = nm_connection_get_setting_macvlan (connection);
|
|
g_assert (s_macvlan);
|
|
|
|
parent = nm_setting_macvlan_get_parent (s_macvlan);
|
|
if (parent)
|
|
return parent;
|
|
|
|
/* Try the hardware address from the MACVLAN connection's hardware setting */
|
|
s_wired = nm_connection_get_setting_wired (connection);
|
|
if (s_wired)
|
|
return nm_setting_wired_get_mac_address (s_wired);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static char *
|
|
get_connection_iface (NMDeviceFactory *factory,
|
|
NMConnection *connection,
|
|
const char *parent_iface)
|
|
{
|
|
NMSettingMacvlan *s_macvlan;
|
|
const char *ifname;
|
|
|
|
g_return_val_if_fail (nm_connection_is_type (connection, NM_SETTING_MACVLAN_SETTING_NAME), NULL);
|
|
|
|
s_macvlan = nm_connection_get_setting_macvlan (connection);
|
|
g_assert (s_macvlan);
|
|
|
|
if (!parent_iface)
|
|
return NULL;
|
|
|
|
ifname = nm_connection_get_interface_name (connection);
|
|
return g_strdup (ifname);
|
|
}
|
|
|
|
NM_DEVICE_FACTORY_DEFINE_INTERNAL (MACVLAN, Macvlan, macvlan,
|
|
NM_DEVICE_FACTORY_DECLARE_LINK_TYPES (NM_LINK_TYPE_MACVLAN, NM_LINK_TYPE_MACVTAP)
|
|
NM_DEVICE_FACTORY_DECLARE_SETTING_TYPES (NM_SETTING_MACVLAN_SETTING_NAME),
|
|
factory_class->create_device = create_device;
|
|
factory_class->get_connection_parent = get_connection_parent;
|
|
factory_class->get_connection_iface = get_connection_iface;
|
|
);
|