mirror of
https://gitlab.freedesktop.org/NetworkManager/NetworkManager
synced 2024-07-21 02:04:17 +00:00
1200 lines
41 KiB
C
1200 lines
41 KiB
C
// SPDX-License-Identifier: LGPL-2.1+
|
|
/*
|
|
* Copyright (C) 2011 - 2013 Red Hat, Inc.
|
|
*/
|
|
|
|
#include "nm-default.h"
|
|
|
|
#include "nm-setting-bond.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
|
|
#include "nm-libnm-core-intern/nm-libnm-core-utils.h"
|
|
#include "nm-utils.h"
|
|
#include "nm-utils-private.h"
|
|
#include "nm-connection-private.h"
|
|
#include "nm-setting-infiniband.h"
|
|
#include "nm-core-internal.h"
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* SECTION:nm-setting-bond
|
|
* @short_description: Describes connection properties for bonds
|
|
*
|
|
* The #NMSettingBond object is a #NMSetting subclass that describes properties
|
|
* necessary for bond connections.
|
|
**/
|
|
|
|
/*****************************************************************************/
|
|
|
|
NM_GOBJECT_PROPERTIES_DEFINE (NMSettingBond,
|
|
PROP_OPTIONS,
|
|
);
|
|
|
|
typedef struct {
|
|
GHashTable *options;
|
|
NMUtilsNamedValue *options_idx_cache;
|
|
} NMSettingBondPrivate;
|
|
|
|
G_DEFINE_TYPE (NMSettingBond, nm_setting_bond, NM_TYPE_SETTING)
|
|
|
|
#define NM_SETTING_BOND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_SETTING_BOND, NMSettingBondPrivate))
|
|
|
|
/*****************************************************************************/
|
|
|
|
static const char *const valid_options_lst[] = {
|
|
/* mode must be the first element. nm-device-bond.c relies on that. */
|
|
NM_SETTING_BOND_OPTION_MODE,
|
|
NM_SETTING_BOND_OPTION_MIIMON,
|
|
NM_SETTING_BOND_OPTION_DOWNDELAY,
|
|
NM_SETTING_BOND_OPTION_UPDELAY,
|
|
NM_SETTING_BOND_OPTION_ARP_INTERVAL,
|
|
NM_SETTING_BOND_OPTION_ARP_IP_TARGET,
|
|
NM_SETTING_BOND_OPTION_ARP_VALIDATE,
|
|
NM_SETTING_BOND_OPTION_PRIMARY,
|
|
NM_SETTING_BOND_OPTION_PRIMARY_RESELECT,
|
|
NM_SETTING_BOND_OPTION_FAIL_OVER_MAC,
|
|
NM_SETTING_BOND_OPTION_USE_CARRIER,
|
|
NM_SETTING_BOND_OPTION_AD_SELECT,
|
|
NM_SETTING_BOND_OPTION_XMIT_HASH_POLICY,
|
|
NM_SETTING_BOND_OPTION_RESEND_IGMP,
|
|
NM_SETTING_BOND_OPTION_LACP_RATE,
|
|
NM_SETTING_BOND_OPTION_ACTIVE_SLAVE,
|
|
NM_SETTING_BOND_OPTION_AD_ACTOR_SYS_PRIO,
|
|
NM_SETTING_BOND_OPTION_AD_ACTOR_SYSTEM,
|
|
NM_SETTING_BOND_OPTION_AD_USER_PORT_KEY,
|
|
NM_SETTING_BOND_OPTION_ALL_SLAVES_ACTIVE,
|
|
NM_SETTING_BOND_OPTION_ARP_ALL_TARGETS,
|
|
NM_SETTING_BOND_OPTION_MIN_LINKS,
|
|
NM_SETTING_BOND_OPTION_NUM_GRAT_ARP,
|
|
NM_SETTING_BOND_OPTION_NUM_UNSOL_NA,
|
|
NM_SETTING_BOND_OPTION_PACKETS_PER_SLAVE,
|
|
NM_SETTING_BOND_OPTION_TLB_DYNAMIC_LB,
|
|
NM_SETTING_BOND_OPTION_LP_INTERVAL,
|
|
NULL,
|
|
};
|
|
|
|
typedef struct {
|
|
const char *val;
|
|
NMBondOptionType opt_type;
|
|
guint min;
|
|
guint max;
|
|
const char *const*list;
|
|
} OptionMeta;
|
|
|
|
static gboolean
|
|
_nm_assert_bond_meta (const OptionMeta *option_meta)
|
|
{
|
|
nm_assert (option_meta);
|
|
|
|
switch (option_meta->opt_type) {
|
|
case NM_BOND_OPTION_TYPE_BOTH:
|
|
nm_assert (option_meta->val);
|
|
nm_assert (option_meta->list);
|
|
nm_assert (option_meta->list[0]);
|
|
nm_assert (option_meta->min == 0);
|
|
nm_assert (option_meta->max == NM_PTRARRAY_LEN (option_meta->list) - 1);
|
|
nm_assert (g_strv_contains (option_meta->list, option_meta->val));
|
|
return TRUE;
|
|
case NM_BOND_OPTION_TYPE_INT:
|
|
nm_assert (option_meta->val);
|
|
nm_assert (!option_meta->list);
|
|
nm_assert (option_meta->min < option_meta->max);
|
|
nm_assert (NM_STRCHAR_ALL (option_meta->val, ch, g_ascii_isdigit (ch)));
|
|
nm_assert (NM_STRCHAR_ALL (option_meta->val, ch, g_ascii_isdigit (ch)));
|
|
nm_assert (({
|
|
_nm_utils_ascii_str_to_uint64 (option_meta->val, 10, option_meta->min, option_meta->max, 0);
|
|
errno == 0;
|
|
}));
|
|
return TRUE;
|
|
case NM_BOND_OPTION_TYPE_IP:
|
|
case NM_BOND_OPTION_TYPE_IFNAME:
|
|
nm_assert (option_meta->val);
|
|
/* fall-through */
|
|
case NM_BOND_OPTION_TYPE_MAC:
|
|
nm_assert (!option_meta->list);
|
|
nm_assert (option_meta->min == 0);
|
|
nm_assert (option_meta->max == 0);
|
|
return TRUE;
|
|
}
|
|
|
|
nm_assert_not_reached ();
|
|
return FALSE;
|
|
}
|
|
|
|
static char const *const _option_default_strv_ad_select[] = NM_MAKE_STRV ("stable", "bandwidth", "count");
|
|
static char const *const _option_default_strv_arp_all_targets[] = NM_MAKE_STRV ("any", "all");
|
|
static char const *const _option_default_strv_arp_validate[] = NM_MAKE_STRV ("none", "active", "backup", "all", "filter", "filter_active", "filter_backup");
|
|
static char const *const _option_default_strv_fail_over_mac[] = NM_MAKE_STRV ("none", "active", "follow");
|
|
static char const *const _option_default_strv_lacp_rate[] = NM_MAKE_STRV ("slow", "fast");
|
|
static char const *const _option_default_strv_mode[] = NM_MAKE_STRV ("balance-rr", "active-backup", "balance-xor", "broadcast", "802.3ad", "balance-tlb", "balance-alb");
|
|
static char const *const _option_default_strv_primary_reselect[] = NM_MAKE_STRV ("always", "better", "failure");
|
|
static char const *const _option_default_strv_xmit_hash_policy[] = NM_MAKE_STRV ("layer2", "layer3+4", "layer2+3", "encap2+3", "encap3+4");
|
|
|
|
static
|
|
NM_UTILS_STRING_TABLE_LOOKUP_STRUCT_DEFINE (
|
|
_get_option_meta,
|
|
OptionMeta,
|
|
{
|
|
G_STATIC_ASSERT_EXPR (G_N_ELEMENTS (LIST) == G_N_ELEMENTS (valid_options_lst) - 1);
|
|
|
|
if (NM_MORE_ASSERT_ONCE (5)) {
|
|
int i;
|
|
|
|
nm_assert (G_N_ELEMENTS (LIST) == NM_PTRARRAY_LEN (valid_options_lst));
|
|
for (i = 0; i < G_N_ELEMENTS (LIST); i++)
|
|
_nm_assert_bond_meta (&LIST[i].value);
|
|
nm_assert (nm_streq (valid_options_lst[0], NM_SETTING_BOND_OPTION_MODE));
|
|
}
|
|
},
|
|
{ return NULL; },
|
|
{ NM_SETTING_BOND_OPTION_ACTIVE_SLAVE, { "", NM_BOND_OPTION_TYPE_IFNAME } },
|
|
{ NM_SETTING_BOND_OPTION_AD_ACTOR_SYS_PRIO, { "65535", NM_BOND_OPTION_TYPE_INT, 1, 65535 } },
|
|
{ NM_SETTING_BOND_OPTION_AD_ACTOR_SYSTEM, { NULL, NM_BOND_OPTION_TYPE_MAC } },
|
|
{ NM_SETTING_BOND_OPTION_AD_SELECT, { "stable", NM_BOND_OPTION_TYPE_BOTH, 0, 2, _option_default_strv_ad_select } },
|
|
{ NM_SETTING_BOND_OPTION_AD_USER_PORT_KEY, { "0", NM_BOND_OPTION_TYPE_INT, 0, 1023 } },
|
|
{ NM_SETTING_BOND_OPTION_ALL_SLAVES_ACTIVE, { "0", NM_BOND_OPTION_TYPE_INT, 0, 1 } },
|
|
{ NM_SETTING_BOND_OPTION_ARP_ALL_TARGETS, { "any", NM_BOND_OPTION_TYPE_BOTH, 0, 1, _option_default_strv_arp_all_targets } },
|
|
{ NM_SETTING_BOND_OPTION_ARP_INTERVAL, { "0", NM_BOND_OPTION_TYPE_INT, 0, G_MAXINT } },
|
|
{ NM_SETTING_BOND_OPTION_ARP_IP_TARGET, { "", NM_BOND_OPTION_TYPE_IP } },
|
|
{ NM_SETTING_BOND_OPTION_ARP_VALIDATE, { "none", NM_BOND_OPTION_TYPE_BOTH, 0, 6, _option_default_strv_arp_validate } },
|
|
{ NM_SETTING_BOND_OPTION_DOWNDELAY, { "0", NM_BOND_OPTION_TYPE_INT, 0, G_MAXINT } },
|
|
{ NM_SETTING_BOND_OPTION_FAIL_OVER_MAC, { "none", NM_BOND_OPTION_TYPE_BOTH, 0, 2, _option_default_strv_fail_over_mac } },
|
|
{ NM_SETTING_BOND_OPTION_LACP_RATE, { "slow", NM_BOND_OPTION_TYPE_BOTH, 0, 1, _option_default_strv_lacp_rate } },
|
|
{ NM_SETTING_BOND_OPTION_LP_INTERVAL, { "1", NM_BOND_OPTION_TYPE_INT, 1, G_MAXINT } },
|
|
{ NM_SETTING_BOND_OPTION_MIIMON, { "100", NM_BOND_OPTION_TYPE_INT, 0, G_MAXINT } },
|
|
{ NM_SETTING_BOND_OPTION_MIN_LINKS, { "0", NM_BOND_OPTION_TYPE_INT, 0, G_MAXINT } },
|
|
{ NM_SETTING_BOND_OPTION_MODE, { "balance-rr", NM_BOND_OPTION_TYPE_BOTH, 0, 6, _option_default_strv_mode } },
|
|
{ NM_SETTING_BOND_OPTION_NUM_GRAT_ARP, { "1", NM_BOND_OPTION_TYPE_INT, 0, 255 } },
|
|
{ NM_SETTING_BOND_OPTION_NUM_UNSOL_NA, { "1", NM_BOND_OPTION_TYPE_INT, 0, 255 } },
|
|
{ NM_SETTING_BOND_OPTION_PACKETS_PER_SLAVE, { "1", NM_BOND_OPTION_TYPE_INT, 0, 65535 } },
|
|
{ NM_SETTING_BOND_OPTION_PRIMARY, { "", NM_BOND_OPTION_TYPE_IFNAME } },
|
|
{ NM_SETTING_BOND_OPTION_PRIMARY_RESELECT, { "always", NM_BOND_OPTION_TYPE_BOTH, 0, 2, _option_default_strv_primary_reselect } },
|
|
{ NM_SETTING_BOND_OPTION_RESEND_IGMP, { "1", NM_BOND_OPTION_TYPE_INT, 0, 255 } },
|
|
{ NM_SETTING_BOND_OPTION_TLB_DYNAMIC_LB, { "1", NM_BOND_OPTION_TYPE_INT, 0, 1 } },
|
|
{ NM_SETTING_BOND_OPTION_UPDELAY, { "0", NM_BOND_OPTION_TYPE_INT, 0, G_MAXINT } },
|
|
{ NM_SETTING_BOND_OPTION_USE_CARRIER, { "1", NM_BOND_OPTION_TYPE_INT, 0, 1 } },
|
|
{ NM_SETTING_BOND_OPTION_XMIT_HASH_POLICY, { "layer2", NM_BOND_OPTION_TYPE_BOTH, 0, 4, _option_default_strv_xmit_hash_policy } },
|
|
);
|
|
|
|
/*****************************************************************************/
|
|
|
|
#define BIT(x) (((guint32) 1) << (x))
|
|
|
|
static
|
|
NM_UTILS_STRING_TABLE_LOOKUP_DEFINE (
|
|
_bond_option_unsupp_mode,
|
|
guint32,
|
|
{ ; },
|
|
{ return 0; },
|
|
{ NM_SETTING_BOND_OPTION_ACTIVE_SLAVE, ~(BIT (NM_BOND_MODE_ACTIVEBACKUP) | BIT (NM_BOND_MODE_TLB) | BIT (NM_BOND_MODE_ALB)) },
|
|
{ NM_SETTING_BOND_OPTION_AD_ACTOR_SYS_PRIO, ~(BIT (NM_BOND_MODE_8023AD)) },
|
|
{ NM_SETTING_BOND_OPTION_AD_ACTOR_SYSTEM, ~(BIT (NM_BOND_MODE_8023AD)) },
|
|
{ NM_SETTING_BOND_OPTION_AD_USER_PORT_KEY, ~(BIT (NM_BOND_MODE_8023AD)) },
|
|
{ NM_SETTING_BOND_OPTION_ARP_INTERVAL, (BIT (NM_BOND_MODE_8023AD) | BIT (NM_BOND_MODE_TLB) | BIT (NM_BOND_MODE_ALB)) },
|
|
{ NM_SETTING_BOND_OPTION_ARP_IP_TARGET, (BIT (NM_BOND_MODE_8023AD) | BIT (NM_BOND_MODE_TLB) | BIT (NM_BOND_MODE_ALB)) },
|
|
{ NM_SETTING_BOND_OPTION_ARP_VALIDATE, (BIT (NM_BOND_MODE_8023AD) | BIT (NM_BOND_MODE_TLB) | BIT (NM_BOND_MODE_ALB)) },
|
|
{ NM_SETTING_BOND_OPTION_LACP_RATE, ~(BIT (NM_BOND_MODE_8023AD)) },
|
|
{ NM_SETTING_BOND_OPTION_PACKETS_PER_SLAVE, ~(BIT (NM_BOND_MODE_ROUNDROBIN)) },
|
|
{ NM_SETTING_BOND_OPTION_PRIMARY, ~(BIT (NM_BOND_MODE_ACTIVEBACKUP) | BIT (NM_BOND_MODE_TLB) | BIT (NM_BOND_MODE_ALB)) },
|
|
{ NM_SETTING_BOND_OPTION_TLB_DYNAMIC_LB, ~(BIT (NM_BOND_MODE_TLB)) },
|
|
)
|
|
|
|
gboolean
|
|
_nm_setting_bond_option_supported (const char *option, NMBondMode mode)
|
|
{
|
|
nm_assert (option);
|
|
nm_assert (mode != NM_BOND_MODE_UNKNOWN);
|
|
nm_assert (_NM_INT_NOT_NEGATIVE (mode) && mode < 32);
|
|
|
|
return !NM_FLAGS_ANY (_bond_option_unsupp_mode (option), BIT (mode));
|
|
}
|
|
|
|
static const char*
|
|
_bond_get_option (NMSettingBond *self,
|
|
const char *option)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_BOND (self), NULL);
|
|
g_return_val_if_fail (option, NULL);
|
|
|
|
return g_hash_table_lookup (NM_SETTING_BOND_GET_PRIVATE (self)->options, option);
|
|
}
|
|
|
|
static const char*
|
|
_bond_get_option_default (NMSettingBond *self,
|
|
const char *option)
|
|
{
|
|
const OptionMeta *option_meta;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_BOND (self), NULL);
|
|
|
|
option_meta = _get_option_meta (option);
|
|
|
|
g_return_val_if_fail (option_meta, NULL);
|
|
|
|
return option_meta->val;
|
|
}
|
|
|
|
static const char*
|
|
_bond_get_option_or_default (NMSettingBond *self,
|
|
const char *option)
|
|
{
|
|
return _bond_get_option (self, option)
|
|
?: _bond_get_option_default (self, option);
|
|
}
|
|
|
|
static const char*
|
|
_bond_get_option_normalized (NMSettingBond* self,
|
|
const char* option,
|
|
gboolean get_default_only)
|
|
{
|
|
const char *mode_str;
|
|
NMBondMode mode;
|
|
const char *value = NULL;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_BOND (self), NULL);
|
|
g_return_val_if_fail (option, NULL);
|
|
|
|
mode_str = _bond_get_option_or_default (self, NM_SETTING_BOND_OPTION_MODE);
|
|
mode = _nm_setting_bond_mode_from_string (mode_str);
|
|
|
|
if (mode == NM_BOND_MODE_UNKNOWN) {
|
|
/* the mode is unknown, consequently, there is no normalized/default
|
|
* value either. */
|
|
return NULL;
|
|
}
|
|
|
|
if (!_nm_setting_bond_option_supported (option, mode))
|
|
return NULL;
|
|
|
|
/* Apply custom NetworkManager policies here */
|
|
if (!get_default_only) {
|
|
if (NM_IN_STRSET (option,
|
|
NM_SETTING_BOND_OPTION_ARP_INTERVAL,
|
|
NM_SETTING_BOND_OPTION_ARP_IP_TARGET)) {
|
|
int miimon;
|
|
|
|
/* if arp_interval is explicitly set and miimon is not, then disable miimon
|
|
* (and related updelay and downdelay) as recommended by the kernel docs */
|
|
miimon = _nm_utils_ascii_str_to_int64 (_bond_get_option (self, NM_SETTING_BOND_OPTION_MIIMON),
|
|
10, 0, G_MAXINT, 0);
|
|
if (miimon != 0) {
|
|
/* miimon is enabled. arp_interval values are unset. */
|
|
if (nm_streq (option, NM_SETTING_BOND_OPTION_ARP_INTERVAL))
|
|
return "0";
|
|
return "";
|
|
}
|
|
value = _bond_get_option (self, option);
|
|
} else if (NM_IN_STRSET (option,
|
|
NM_SETTING_BOND_OPTION_NUM_GRAT_ARP,
|
|
NM_SETTING_BOND_OPTION_NUM_UNSOL_NA)) {
|
|
/* just get one of the 2, at kernel level they're the same bond option */
|
|
value = _bond_get_option (self, NM_SETTING_BOND_OPTION_NUM_GRAT_ARP);
|
|
if (!value)
|
|
value = _bond_get_option (self, NM_SETTING_BOND_OPTION_NUM_UNSOL_NA);
|
|
} else
|
|
value = _bond_get_option (self, option);
|
|
|
|
if (value)
|
|
return value;
|
|
}
|
|
|
|
/* Apply rules that change the default value of an option */
|
|
if (nm_streq (option, NM_SETTING_BOND_OPTION_AD_ACTOR_SYSTEM)) {
|
|
/* The default value depends on the current mode */
|
|
if (mode == NM_BOND_MODE_8023AD)
|
|
return "00:00:00:00:00:00";
|
|
return "";
|
|
}
|
|
|
|
return _bond_get_option_or_default (self, option);
|
|
}
|
|
|
|
const char*
|
|
nm_setting_bond_get_option_or_default (NMSettingBond *self,
|
|
const char *option)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_BOND (self), NULL);
|
|
g_return_val_if_fail (option, NULL);
|
|
|
|
return _bond_get_option_normalized (self,
|
|
option,
|
|
FALSE);
|
|
}
|
|
|
|
static int
|
|
_atoi (const char *value)
|
|
{
|
|
int v;
|
|
|
|
v = _nm_utils_ascii_str_to_int64 (value, 10, 0, G_MAXINT, -1);
|
|
nm_assert (v >= 0);
|
|
return v;
|
|
};
|
|
|
|
/**
|
|
* nm_setting_bond_get_num_options:
|
|
* @setting: the #NMSettingBond
|
|
*
|
|
* Returns the number of options that should be set for this bond when it
|
|
* is activated. This can be used to retrieve each option individually
|
|
* using nm_setting_bond_get_option().
|
|
*
|
|
* Returns: the number of bonding options
|
|
**/
|
|
guint32
|
|
nm_setting_bond_get_num_options (NMSettingBond *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_BOND (setting), 0);
|
|
|
|
return g_hash_table_size (NM_SETTING_BOND_GET_PRIVATE (setting)->options);
|
|
}
|
|
|
|
static int
|
|
_get_option_sort (gconstpointer p_a, gconstpointer p_b, gpointer _unused)
|
|
{
|
|
const char *a = *((const char *const*) p_a);
|
|
const char *b = *((const char *const*) p_b);
|
|
|
|
NM_CMP_DIRECT (nm_streq (b, NM_SETTING_BOND_OPTION_MODE),
|
|
nm_streq (a, NM_SETTING_BOND_OPTION_MODE));
|
|
NM_CMP_DIRECT_STRCMP (a, b);
|
|
nm_assert_not_reached ();
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
_ensure_options_idx_cache (NMSettingBondPrivate *priv)
|
|
{
|
|
if (!G_UNLIKELY (priv->options_idx_cache))
|
|
priv->options_idx_cache = nm_utils_named_values_from_strdict_full (priv->options, NULL, _get_option_sort, NULL, NULL, 0, NULL);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_bond_get_option:
|
|
* @setting: the #NMSettingBond
|
|
* @idx: index of the desired option, from 0 to
|
|
* nm_setting_bond_get_num_options() - 1
|
|
* @out_name: (out) (transfer none): on return, the name of the bonding option;
|
|
* this value is owned by the setting and should not be modified
|
|
* @out_value: (out) (transfer none): on return, the value of the name of the
|
|
* bonding option; this value is owned by the setting and should not be
|
|
* modified
|
|
*
|
|
* Given an index, return the value of the bonding option at that index. Indexes
|
|
* are *not* guaranteed to be static across modifications to options done by
|
|
* nm_setting_bond_add_option() and nm_setting_bond_remove_option(),
|
|
* and should not be used to refer to options except for short periods of time
|
|
* such as during option iteration.
|
|
*
|
|
* Returns: %TRUE on success if the index was valid and an option was found,
|
|
* %FALSE if the index was invalid (ie, greater than the number of options
|
|
* currently held by the setting)
|
|
**/
|
|
gboolean
|
|
nm_setting_bond_get_option (NMSettingBond *setting,
|
|
guint32 idx,
|
|
const char **out_name,
|
|
const char **out_value)
|
|
{
|
|
NMSettingBondPrivate *priv;
|
|
guint len;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_BOND (setting), FALSE);
|
|
|
|
priv = NM_SETTING_BOND_GET_PRIVATE (setting);
|
|
|
|
len = g_hash_table_size (priv->options);
|
|
if (idx >= len)
|
|
return FALSE;
|
|
|
|
_ensure_options_idx_cache (priv);
|
|
|
|
NM_SET_OUT (out_name, priv->options_idx_cache[idx].name);
|
|
NM_SET_OUT (out_value, priv->options_idx_cache[idx].value_str);
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_int (const char *name, const char *value, const OptionMeta *option_meta)
|
|
{
|
|
guint64 num;
|
|
|
|
if (!NM_STRCHAR_ALL (value, ch, g_ascii_isdigit (ch)))
|
|
return FALSE;
|
|
|
|
num = _nm_utils_ascii_str_to_uint64 (value, 10, option_meta->min, option_meta->max, G_MAXUINT64);
|
|
if ( num == G_MAXUINT64
|
|
&& errno != 0)
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_list (const char *name, const char *value, const OptionMeta *option_meta)
|
|
{
|
|
int i;
|
|
|
|
nm_assert (option_meta->list);
|
|
|
|
for (i = 0; option_meta->list[i]; i++) {
|
|
if (nm_streq (option_meta->list[i], value))
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_ip (const char *name, const char *value, GError **error)
|
|
{
|
|
gs_free const char **addrs = NULL;
|
|
gsize i;
|
|
|
|
addrs = nm_utils_bond_option_arp_ip_targets_split (value);
|
|
if (!addrs) {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("'%s' option is empty"),
|
|
name);
|
|
return FALSE;
|
|
}
|
|
for (i = 0; addrs[i]; i++) {
|
|
if (!nm_utils_parse_inaddr_bin (AF_INET, addrs[i], NULL, NULL)) {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("'%s' is not a valid IPv4 address for '%s' option"),
|
|
addrs[i],
|
|
name);
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
validate_ifname (const char *name, const char *value)
|
|
{
|
|
return nm_utils_ifname_valid_kernel (value, NULL);
|
|
}
|
|
|
|
static gboolean
|
|
_setting_bond_validate_option (const char *name,
|
|
const char *value,
|
|
GError **error)
|
|
{
|
|
const OptionMeta *option_meta;
|
|
gboolean success;
|
|
|
|
option_meta = _get_option_meta (name);
|
|
if (!option_meta) {
|
|
if (!name) {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("missing option name"));
|
|
} else {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("invalid option '%s'"),
|
|
name);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
if (!value)
|
|
return TRUE;
|
|
|
|
switch (option_meta->opt_type) {
|
|
case NM_BOND_OPTION_TYPE_INT:
|
|
success = validate_int (name, value, option_meta);
|
|
goto handle_error;
|
|
case NM_BOND_OPTION_TYPE_BOTH:
|
|
success = ( validate_int (name, value, option_meta)
|
|
|| validate_list (name, value, option_meta));
|
|
goto handle_error;
|
|
case NM_BOND_OPTION_TYPE_IP:
|
|
nm_assert (nm_streq0 (name, NM_SETTING_BOND_OPTION_ARP_IP_TARGET));
|
|
return validate_ip (name, value, error);
|
|
case NM_BOND_OPTION_TYPE_MAC:
|
|
success = nm_utils_hwaddr_valid (value, ETH_ALEN);
|
|
goto handle_error;
|
|
case NM_BOND_OPTION_TYPE_IFNAME:
|
|
success = validate_ifname (name, value);
|
|
goto handle_error;
|
|
}
|
|
|
|
nm_assert_not_reached ();
|
|
success = FALSE;
|
|
|
|
handle_error:
|
|
if (!success) {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("invalid value '%s' for option '%s'"),
|
|
value, name);
|
|
}
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_bond_validate_option:
|
|
* @name: the name of the option to validate
|
|
* @value: the value of the option to validate
|
|
*
|
|
* Checks whether @name is a valid bond option and @value is a valid value for
|
|
* the @name. If @value is %NULL, the function only validates the option name.
|
|
*
|
|
* Returns: %TRUE, if the @value is valid for the given name.
|
|
* If the @name is not a valid option, %FALSE will be returned.
|
|
**/
|
|
gboolean
|
|
nm_setting_bond_validate_option (const char *name,
|
|
const char *value)
|
|
{
|
|
return _setting_bond_validate_option (name, value, NULL);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_bond_get_option_by_name:
|
|
* @setting: the #NMSettingBond
|
|
* @name: the option name for which to retrieve the value
|
|
*
|
|
* Returns the value associated with the bonding option specified by
|
|
* @name, if it exists.
|
|
*
|
|
* Returns: the value, or %NULL if the key/value pair was never added to the
|
|
* setting; the value is owned by the setting and must not be modified
|
|
**/
|
|
const char *
|
|
nm_setting_bond_get_option_by_name (NMSettingBond *setting,
|
|
const char *name)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_BOND (setting), NULL);
|
|
|
|
if (!nm_setting_bond_validate_option (name, NULL))
|
|
return NULL;
|
|
|
|
return _bond_get_option (setting, name);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_bond_add_option:
|
|
* @setting: the #NMSettingBond
|
|
* @name: name for the option
|
|
* @value: value for the option
|
|
*
|
|
* Add an option to the table. The option is compared to an internal list
|
|
* of allowed options. Option names may contain only alphanumeric characters
|
|
* (ie [a-zA-Z0-9]). Adding a new name replaces any existing name/value pair
|
|
* that may already exist.
|
|
*
|
|
* The order of how to set several options is relevant because there are options
|
|
* that conflict with each other.
|
|
*
|
|
* Returns: %TRUE if the option was valid and was added to the internal option
|
|
* list, %FALSE if it was not.
|
|
**/
|
|
gboolean
|
|
nm_setting_bond_add_option (NMSettingBond *setting,
|
|
const char *name,
|
|
const char *value)
|
|
{
|
|
NMSettingBondPrivate *priv;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_BOND (setting), FALSE);
|
|
|
|
if ( !value
|
|
|| !nm_setting_bond_validate_option (name, value))
|
|
return FALSE;
|
|
|
|
priv = NM_SETTING_BOND_GET_PRIVATE (setting);
|
|
|
|
nm_clear_g_free (&priv->options_idx_cache);
|
|
g_hash_table_insert (priv->options, g_strdup (name), g_strdup (value));
|
|
|
|
_notify (setting, PROP_OPTIONS);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_bond_remove_option:
|
|
* @setting: the #NMSettingBond
|
|
* @name: name of the option to remove
|
|
*
|
|
* Remove the bonding option referenced by @name from the internal option
|
|
* list.
|
|
*
|
|
* Returns: %TRUE if the option was found and removed from the internal option
|
|
* list, %FALSE if it was not.
|
|
**/
|
|
gboolean
|
|
nm_setting_bond_remove_option (NMSettingBond *setting,
|
|
const char *name)
|
|
{
|
|
NMSettingBondPrivate *priv;
|
|
gboolean found;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_BOND (setting), FALSE);
|
|
|
|
if (!nm_setting_bond_validate_option (name, NULL))
|
|
return FALSE;
|
|
|
|
priv = NM_SETTING_BOND_GET_PRIVATE (setting);
|
|
|
|
nm_clear_g_free (&priv->options_idx_cache);
|
|
found = g_hash_table_remove (priv->options, name);
|
|
if (found)
|
|
_notify (setting, PROP_OPTIONS);
|
|
return found;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_bond_get_valid_options:
|
|
* @setting: (allow-none): the #NMSettingBond
|
|
*
|
|
* Returns a list of valid bond options.
|
|
*
|
|
* The @setting argument is unused and may be passed as %NULL.
|
|
*
|
|
* Returns: (transfer none): a %NULL-terminated array of strings of valid bond options.
|
|
**/
|
|
const char **
|
|
nm_setting_bond_get_valid_options (NMSettingBond *setting)
|
|
{
|
|
return (const char **) valid_options_lst;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_bond_get_option_default:
|
|
* @setting: the #NMSettingBond
|
|
* @name: the name of the option
|
|
*
|
|
* Returns: the value of the bond option if not overridden by an entry in
|
|
* the #NMSettingBond:options property.
|
|
**/
|
|
const char *
|
|
nm_setting_bond_get_option_default (NMSettingBond *setting, const char *name)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_BOND (setting), NULL);
|
|
|
|
if (!name)
|
|
return NULL;
|
|
|
|
return _bond_get_option_normalized (setting,
|
|
name,
|
|
TRUE);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_bond_get_option_normalized:
|
|
* @setting: the #NMSettingBond
|
|
* @name: the name of the option
|
|
*
|
|
* Since: 1.24
|
|
*
|
|
* Returns: the value of the bond option after normalization, which is what NetworkManager
|
|
* will actually apply when activating the connection. %NULL if the option won't be applied
|
|
* to the connection.
|
|
**/
|
|
const char *
|
|
nm_setting_bond_get_option_normalized (NMSettingBond *setting,
|
|
const char *name)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_BOND (setting), NULL);
|
|
g_return_val_if_fail (name, NULL);
|
|
|
|
return _bond_get_option_normalized (setting,
|
|
name,
|
|
FALSE);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_bond_get_option_type:
|
|
* @setting: the #NMSettingBond
|
|
* @name: the name of the option
|
|
*
|
|
* Returns: the type of the bond option.
|
|
**/
|
|
NMBondOptionType
|
|
_nm_setting_bond_get_option_type (NMSettingBond *setting, const char *name)
|
|
{
|
|
const OptionMeta *option_meta;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_BOND (setting), NM_BOND_OPTION_TYPE_INT);
|
|
|
|
option_meta = _get_option_meta (name);
|
|
|
|
g_return_val_if_fail (option_meta, NM_BOND_OPTION_TYPE_INT);
|
|
|
|
return option_meta->opt_type;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static gboolean
|
|
verify (NMSetting *setting, NMConnection *connection, GError **error)
|
|
{
|
|
NMSettingBond *self = NM_SETTING_BOND (setting);
|
|
NMSettingBondPrivate *priv = NM_SETTING_BOND_GET_PRIVATE (setting);
|
|
int miimon;
|
|
int arp_interval;
|
|
int num_grat_arp;
|
|
int num_unsol_na;
|
|
const char *mode_str;
|
|
const char *arp_ip_target = NULL;
|
|
const char *lacp_rate;
|
|
const char *primary;
|
|
NMBondMode bond_mode;
|
|
guint i;
|
|
const NMUtilsNamedValue *n;
|
|
|
|
_ensure_options_idx_cache (priv);
|
|
|
|
if (priv->options_idx_cache) {
|
|
for (i = 0; priv->options_idx_cache[i].name; i++) {
|
|
n = &priv->options_idx_cache[i];
|
|
|
|
if ( !n->value_str
|
|
|| !_setting_bond_validate_option (n->name, n->value_str, error)) {
|
|
g_prefix_error (error,
|
|
"%s.%s: ",
|
|
NM_SETTING_BOND_SETTING_NAME,
|
|
NM_SETTING_BOND_OPTIONS);
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
miimon = _atoi (_bond_get_option_or_default (self, NM_SETTING_BOND_OPTION_MIIMON));
|
|
arp_interval = _atoi (_bond_get_option_or_default (self, NM_SETTING_BOND_OPTION_ARP_INTERVAL));
|
|
num_grat_arp = _atoi (_bond_get_option_or_default (self, NM_SETTING_BOND_OPTION_NUM_GRAT_ARP));
|
|
num_unsol_na = _atoi (_bond_get_option_or_default (self, NM_SETTING_BOND_OPTION_NUM_UNSOL_NA));
|
|
|
|
/* Option restrictions:
|
|
*
|
|
* arp_interval conflicts [ alb, tlb ]
|
|
* arp_interval needs arp_ip_target
|
|
* arp_validate does not work with [ BOND_MODE_8023AD, BOND_MODE_TLB, BOND_MODE_ALB ]
|
|
* downdelay needs miimon
|
|
* updelay needs miimon
|
|
* primary needs [ active-backup, tlb, alb ]
|
|
*/
|
|
|
|
/* Verify bond mode */
|
|
mode_str = _bond_get_option (self, NM_SETTING_BOND_OPTION_MODE);
|
|
if (!mode_str) {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("mandatory option '%s' is missing"),
|
|
NM_SETTING_BOND_OPTION_MODE);
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_BOND_SETTING_NAME, NM_SETTING_BOND_OPTIONS);
|
|
return FALSE;
|
|
}
|
|
bond_mode = _nm_setting_bond_mode_from_string (mode_str);
|
|
if (bond_mode == NM_BOND_MODE_UNKNOWN) {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("'%s' is not a valid value for '%s'"),
|
|
mode_str,
|
|
NM_SETTING_BOND_OPTION_MODE);
|
|
g_prefix_error (error,
|
|
"%s.%s: ",
|
|
NM_SETTING_BOND_SETTING_NAME,
|
|
NM_SETTING_BOND_OPTIONS);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Make sure mode is compatible with other settings */
|
|
if (NM_IN_SET (bond_mode, NM_BOND_MODE_TLB,
|
|
NM_BOND_MODE_ALB)) {
|
|
if (arp_interval > 0) {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("'%s=%s' is incompatible with '%s > 0'"),
|
|
NM_SETTING_BOND_OPTION_MODE,
|
|
mode_str,
|
|
NM_SETTING_BOND_OPTION_ARP_INTERVAL);
|
|
g_prefix_error (error,
|
|
"%s.%s: ",
|
|
NM_SETTING_BOND_SETTING_NAME,
|
|
NM_SETTING_BOND_OPTIONS);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
primary = _bond_get_option (self, NM_SETTING_BOND_OPTION_PRIMARY);
|
|
if (bond_mode == NM_BOND_MODE_ACTIVEBACKUP) {
|
|
GError *tmp_error = NULL;
|
|
|
|
if (primary && !nm_utils_ifname_valid_kernel (primary, &tmp_error)) {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("'%s' is not valid for the '%s' option: %s"),
|
|
primary, NM_SETTING_BOND_OPTION_PRIMARY, tmp_error->message);
|
|
g_prefix_error (error,
|
|
"%s.%s: ",
|
|
NM_SETTING_BOND_SETTING_NAME,
|
|
NM_SETTING_BOND_OPTIONS);
|
|
g_error_free (tmp_error);
|
|
return FALSE;
|
|
}
|
|
} else if (primary) {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("'%s' option is only valid for '%s=%s'"),
|
|
NM_SETTING_BOND_OPTION_PRIMARY,
|
|
NM_SETTING_BOND_OPTION_MODE, "active-backup");
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_BOND_SETTING_NAME, NM_SETTING_BOND_OPTIONS);
|
|
return FALSE;
|
|
}
|
|
|
|
if ( connection
|
|
&& nm_connection_get_setting_infiniband (connection)) {
|
|
if (bond_mode != NM_BOND_MODE_ACTIVEBACKUP) {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("'%s=%s' is not a valid configuration for '%s'"),
|
|
NM_SETTING_BOND_OPTION_MODE, mode_str, NM_SETTING_INFINIBAND_SETTING_NAME);
|
|
g_prefix_error (error,
|
|
"%s.%s: ",
|
|
NM_SETTING_BOND_SETTING_NAME, NM_SETTING_BOND_OPTIONS);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (miimon == 0) {
|
|
/* updelay and downdelay need miimon to be enabled to be valid */
|
|
if (_atoi (_bond_get_option_or_default (self, NM_SETTING_BOND_OPTION_UPDELAY))) {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("'%s' option requires '%s' option to be enabled"),
|
|
NM_SETTING_BOND_OPTION_UPDELAY, NM_SETTING_BOND_OPTION_MIIMON);
|
|
g_prefix_error (error,
|
|
"%s.%s: ",
|
|
NM_SETTING_BOND_SETTING_NAME,
|
|
NM_SETTING_BOND_OPTIONS);
|
|
return FALSE;
|
|
}
|
|
|
|
if (_atoi (_bond_get_option_or_default (self, NM_SETTING_BOND_OPTION_DOWNDELAY))) {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("'%s' option requires '%s' option to be enabled"),
|
|
NM_SETTING_BOND_OPTION_DOWNDELAY, NM_SETTING_BOND_OPTION_MIIMON);
|
|
g_prefix_error (error,
|
|
"%s.%s: ",
|
|
NM_SETTING_BOND_SETTING_NAME,
|
|
NM_SETTING_BOND_OPTIONS);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/* arp_ip_target can only be used with arp_interval, and must
|
|
* contain a comma-separated list of IPv4 addresses.
|
|
*/
|
|
arp_ip_target = _bond_get_option (self, NM_SETTING_BOND_OPTION_ARP_IP_TARGET);
|
|
if (arp_interval > 0) {
|
|
if (!arp_ip_target) {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("'%s' option requires '%s' option to be set"),
|
|
NM_SETTING_BOND_OPTION_ARP_INTERVAL,
|
|
NM_SETTING_BOND_OPTION_ARP_IP_TARGET);
|
|
g_prefix_error (error,
|
|
"%s.%s: ",
|
|
NM_SETTING_BOND_SETTING_NAME,
|
|
NM_SETTING_BOND_OPTIONS);
|
|
return FALSE;
|
|
}
|
|
} else {
|
|
if (arp_ip_target) {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("'%s' option requires '%s' option to be set"),
|
|
NM_SETTING_BOND_OPTION_ARP_IP_TARGET,
|
|
NM_SETTING_BOND_OPTION_ARP_INTERVAL);
|
|
g_prefix_error (error, "%s.%s: ",
|
|
NM_SETTING_BOND_SETTING_NAME,
|
|
NM_SETTING_BOND_OPTIONS);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
lacp_rate = _bond_get_option (self, NM_SETTING_BOND_OPTION_LACP_RATE);
|
|
if ( lacp_rate
|
|
&& bond_mode != NM_BOND_MODE_8023AD
|
|
&& !NM_IN_STRSET (lacp_rate, "0", "slow")) {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("'%s' option is only valid with mode '%s'"),
|
|
NM_SETTING_BOND_OPTION_LACP_RATE, "802.3ad");
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_BOND_SETTING_NAME, NM_SETTING_BOND_OPTIONS);
|
|
return FALSE;
|
|
}
|
|
|
|
if ( _bond_get_option (self, NM_SETTING_BOND_OPTION_NUM_GRAT_ARP)
|
|
&& _bond_get_option (self, NM_SETTING_BOND_OPTION_NUM_UNSOL_NA)
|
|
&& num_grat_arp != num_unsol_na) {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("'%s' and '%s' cannot have different values"),
|
|
NM_SETTING_BOND_OPTION_NUM_GRAT_ARP,
|
|
NM_SETTING_BOND_OPTION_NUM_UNSOL_NA);
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_BOND_SETTING_NAME, NM_SETTING_BOND_OPTIONS);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!_nm_connection_verify_required_interface_name (connection, error))
|
|
return FALSE;
|
|
|
|
/* *** errors above here should be always fatal, below NORMALIZABLE_ERROR *** */
|
|
|
|
if (!NM_IN_STRSET (mode_str,
|
|
"802.3ad",
|
|
"active-backup",
|
|
"balance-rr",
|
|
"balance-alb",
|
|
"balance-tlb",
|
|
"balance-xor",
|
|
"broadcast")) {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("'%s' option should be string"),
|
|
NM_SETTING_BOND_OPTION_MODE);
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_BOND_SETTING_NAME, NM_SETTING_BOND_OPTIONS);
|
|
return NM_SETTING_VERIFY_NORMALIZABLE;
|
|
}
|
|
|
|
/* normalize unsupported options for the current mode */
|
|
for (i = 0; priv->options_idx_cache[i].name; i++) {
|
|
n = &priv->options_idx_cache[i];
|
|
if (!_nm_setting_bond_option_supported (n->name, bond_mode)) {
|
|
g_set_error (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("'%s' option is not valid with mode '%s'"),
|
|
n->name, mode_str);
|
|
g_prefix_error (error,
|
|
"%s.%s: ",
|
|
NM_SETTING_BOND_SETTING_NAME,
|
|
NM_SETTING_BOND_OPTIONS);
|
|
return NM_SETTING_VERIFY_NORMALIZABLE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static gboolean
|
|
options_equal_asym (NMSettingBond *s_bond,
|
|
NMSettingBond *s_bond2,
|
|
NMSettingCompareFlags flags)
|
|
{
|
|
GHashTableIter iter;
|
|
const char *key, *value;
|
|
|
|
g_hash_table_iter_init (&iter, NM_SETTING_BOND_GET_PRIVATE (s_bond)->options);
|
|
while (g_hash_table_iter_next (&iter, (gpointer *) &key, (gpointer *) &value)) {
|
|
|
|
if (NM_FLAGS_HAS (flags, NM_SETTING_COMPARE_FLAG_INFERRABLE)) {
|
|
/* when doing an inferrable match, the active-slave should be ignored
|
|
* as it might be differ from the setting in the connection.
|
|
*
|
|
* Also, the fail_over_mac setting can change, see for example
|
|
* https://bugzilla.redhat.com/show_bug.cgi?id=1375558#c8 */
|
|
if (NM_IN_STRSET (key, "fail_over_mac", "active_slave"))
|
|
continue;
|
|
}
|
|
|
|
if (!nm_streq0 (value, _bond_get_option (s_bond2, key)))
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
options_equal (NMSettingBond *s_bond,
|
|
NMSettingBond *s_bond2,
|
|
NMSettingCompareFlags flags)
|
|
{
|
|
return options_equal_asym (s_bond, s_bond2, flags)
|
|
&& options_equal_asym (s_bond2, s_bond, flags);
|
|
}
|
|
|
|
static NMTernary
|
|
compare_property (const NMSettInfoSetting *sett_info,
|
|
guint property_idx,
|
|
NMConnection *con_a,
|
|
NMSetting *set_a,
|
|
NMConnection *con_b,
|
|
NMSetting *set_b,
|
|
NMSettingCompareFlags flags)
|
|
{
|
|
if (nm_streq (sett_info->property_infos[property_idx].name, NM_SETTING_BOND_OPTIONS)) {
|
|
return ( !set_b
|
|
|| options_equal (NM_SETTING_BOND (set_a),
|
|
NM_SETTING_BOND (set_b),
|
|
flags));
|
|
}
|
|
|
|
return NM_SETTING_CLASS (nm_setting_bond_parent_class)->compare_property (sett_info,
|
|
property_idx,
|
|
con_a,
|
|
set_a,
|
|
con_b,
|
|
set_b,
|
|
flags);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
get_property (GObject *object, guint prop_id,
|
|
GValue *value, GParamSpec *pspec)
|
|
{
|
|
NMSettingBondPrivate *priv = NM_SETTING_BOND_GET_PRIVATE (object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_OPTIONS:
|
|
g_value_take_boxed (value, _nm_utils_copy_strdict (priv->options));
|
|
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)
|
|
{
|
|
NMSettingBondPrivate *priv = NM_SETTING_BOND_GET_PRIVATE (object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_OPTIONS:
|
|
nm_clear_g_free (&priv->options_idx_cache);
|
|
g_hash_table_unref (priv->options);
|
|
priv->options = _nm_utils_copy_strdict (g_value_get_boxed (value));
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
nm_setting_bond_init (NMSettingBond *setting)
|
|
{
|
|
NMSettingBondPrivate *priv = NM_SETTING_BOND_GET_PRIVATE (setting);
|
|
|
|
priv->options = g_hash_table_new_full (nm_str_hash, g_str_equal, g_free, g_free);
|
|
|
|
/* Default values: */
|
|
nm_setting_bond_add_option (setting, NM_SETTING_BOND_OPTION_MODE, "balance-rr");
|
|
}
|
|
|
|
/**
|
|
* nm_setting_bond_new:
|
|
*
|
|
* Creates a new #NMSettingBond object with default values.
|
|
*
|
|
* Returns: (transfer full): the new empty #NMSettingBond object
|
|
**/
|
|
NMSetting *
|
|
nm_setting_bond_new (void)
|
|
{
|
|
return (NMSetting *) g_object_new (NM_TYPE_SETTING_BOND, NULL);
|
|
}
|
|
|
|
static void
|
|
finalize (GObject *object)
|
|
{
|
|
NMSettingBondPrivate *priv = NM_SETTING_BOND_GET_PRIVATE (object);
|
|
|
|
nm_clear_g_free (&priv->options_idx_cache);
|
|
g_hash_table_destroy (priv->options);
|
|
|
|
G_OBJECT_CLASS (nm_setting_bond_parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
nm_setting_bond_class_init (NMSettingBondClass *klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
NMSettingClass *setting_class = NM_SETTING_CLASS (klass);
|
|
GArray *properties_override = _nm_sett_info_property_override_create_array ();
|
|
|
|
g_type_class_add_private (klass, sizeof (NMSettingBondPrivate));
|
|
|
|
object_class->get_property = get_property;
|
|
object_class->set_property = set_property;
|
|
object_class->finalize = finalize;
|
|
|
|
setting_class->verify = verify;
|
|
setting_class->compare_property = compare_property;
|
|
|
|
/**
|
|
* NMSettingBond:options: (type GHashTable(utf8,utf8)):
|
|
*
|
|
* Dictionary of key/value pairs of bonding options. Both keys and values
|
|
* must be strings. Option names must contain only alphanumeric characters
|
|
* (ie, [a-zA-Z0-9]).
|
|
**/
|
|
/* ---ifcfg-rh---
|
|
* property: options
|
|
* variable: BONDING_OPTS
|
|
* description: Bonding options.
|
|
* example: BONDING_OPTS="miimon=100 mode=broadcast"
|
|
* ---end---
|
|
*/
|
|
obj_properties[PROP_OPTIONS] =
|
|
g_param_spec_boxed (NM_SETTING_BOND_OPTIONS, "", "",
|
|
G_TYPE_HASH_TABLE,
|
|
G_PARAM_READWRITE |
|
|
NM_SETTING_PARAM_INFERRABLE |
|
|
G_PARAM_STATIC_STRINGS);
|
|
_nm_properties_override_gobj (properties_override, obj_properties[PROP_OPTIONS], &nm_sett_info_propert_type_strdict);
|
|
|
|
/* ---dbus---
|
|
* property: interface-name
|
|
* format: string
|
|
* description: Deprecated in favor of connection.interface-name, but can
|
|
* be used for backward-compatibility with older daemons, to set the
|
|
* bond's interface name.
|
|
* ---end---
|
|
*/
|
|
_nm_properties_override_dbus (properties_override, "interface-name", &nm_sett_info_propert_type_deprecated_interface_name);
|
|
|
|
g_object_class_install_properties (object_class, _PROPERTY_ENUMS_LAST, obj_properties);
|
|
|
|
_nm_setting_class_commit_full (setting_class, NM_META_SETTING_TYPE_BOND,
|
|
NULL, properties_override);
|
|
}
|