static gboolean
check_connection_cloned_mac_address (NMConnection *orig,
NMConnection *candidate,
GHashTable *settings)
{
GHashTable *props;
const char *orig_mac = NULL, *cand_mac = NULL;
NMSettingWired *s_wired_orig, *s_wired_cand;
props = check_property_in_hash (settings,
NM_SETTING_WIRED_SETTING_NAME,
NM_SETTING_WIRED_CLONED_MAC_ADDRESS);
if (!props)
return TRUE;
/* If one of the MAC addresses is NULL, we accept that connection */
s_wired_orig = nm_connection_get_setting_wired (orig);
if (s_wired_orig)
orig_mac = nm_setting_wired_get_cloned_mac_address (s_wired_orig);
s_wired_cand = nm_connection_get_setting_wired (candidate);
if (s_wired_cand)
cand_mac = nm_setting_wired_get_cloned_mac_address (s_wired_cand);
if (!orig_mac || !cand_mac) {
remove_from_hash (settings, props,
NM_SETTING_WIRED_SETTING_NAME,
NM_SETTING_WIRED_CLONED_MAC_ADDRESS);
return TRUE;
}
return FALSE;
}
static NMActStageReturn
act_stage1_prepare (NMDevice *device, NMDeviceStateReason *reason)
{
NMDeviceTun *self = NM_DEVICE_TUN (device);
NMDeviceTunPrivate *priv = NM_DEVICE_TUN_GET_PRIVATE (self);
NMSettingWired *s_wired;
const char *cloned_mac;
NMActStageReturn ret;
g_return_val_if_fail (reason != NULL, NM_ACT_STAGE_RETURN_FAILURE);
ret = NM_DEVICE_CLASS (nm_device_tun_parent_class)->act_stage1_prepare (device, reason);
if (ret != NM_ACT_STAGE_RETURN_SUCCESS)
return ret;
/* Nothing to do for TUN devices */
if (g_strcmp0 (priv->mode, "tap"))
return NM_ACT_STAGE_RETURN_SUCCESS;
s_wired = (NMSettingWired *) nm_device_get_applied_setting (device, NM_TYPE_SETTING_WIRED);
if (s_wired) {
/* Set device MAC address if the connection wants to change it */
cloned_mac = nm_setting_wired_get_cloned_mac_address (s_wired);
nm_device_set_hw_addr (device, cloned_mac, "set", LOGD_DEVICE);
}
return NM_ACT_STAGE_RETURN_SUCCESS;
}
static NMActStageReturn
act_stage1_prepare (NMDevice *dev, NMDeviceStateReason *reason)
{
NMActRequest *req;
NMConnection *connection;
NMSettingVlan *s_vlan;
NMSettingWired *s_wired;
const char *cloned_mac;
NMActStageReturn ret;
g_return_val_if_fail (reason != NULL, NM_ACT_STAGE_RETURN_FAILURE);
ret = NM_DEVICE_CLASS (nm_device_vlan_parent_class)->act_stage1_prepare (dev, reason);
if (ret != NM_ACT_STAGE_RETURN_SUCCESS)
return ret;
req = nm_device_get_act_request (dev);
g_return_val_if_fail (req != NULL, NM_ACT_STAGE_RETURN_FAILURE);
connection = nm_act_request_get_connection (req);
g_return_val_if_fail (connection != NULL, NM_ACT_STAGE_RETURN_FAILURE);
s_wired = nm_connection_get_setting_wired (connection);
if (s_wired) {
/* Set device MAC address if the connection wants to change it */
cloned_mac = nm_setting_wired_get_cloned_mac_address (s_wired);
if (cloned_mac)
nm_device_set_hw_addr (dev, cloned_mac, "set", LOGD_VLAN);
}
s_vlan = nm_connection_get_setting_vlan (connection);
if (s_vlan) {
int ifindex = nm_device_get_ifindex (dev);
int num, i;
guint32 from, to;
num = nm_setting_vlan_get_num_priorities (s_vlan, NM_VLAN_INGRESS_MAP);
for (i = 0; i < num; i++) {
if (nm_setting_vlan_get_priority (s_vlan, NM_VLAN_INGRESS_MAP, i, &from, &to))
nm_platform_vlan_set_ingress_map (ifindex, from, to);
}
num = nm_setting_vlan_get_num_priorities (s_vlan, NM_VLAN_EGRESS_MAP);
for (i = 0; i < num; i++) {
if (nm_setting_vlan_get_priority (s_vlan, NM_VLAN_EGRESS_MAP, i, &from, &to))
nm_platform_vlan_set_egress_map (ifindex, from, to);
}
}
return ret;
}
static void
get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
NMSettingWired *setting = NM_SETTING_WIRED (object);
NMSettingWiredPrivate *priv = NM_SETTING_WIRED_GET_PRIVATE (setting);
switch (prop_id) {
case PROP_PORT:
g_value_set_string (value, nm_setting_wired_get_port (setting));
break;
case PROP_SPEED:
g_value_set_uint (value, nm_setting_wired_get_speed (setting));
break;
case PROP_DUPLEX:
g_value_set_string (value, nm_setting_wired_get_duplex (setting));
break;
case PROP_AUTO_NEGOTIATE:
g_value_set_boolean (value, nm_setting_wired_get_auto_negotiate (setting));
break;
case PROP_MAC_ADDRESS:
g_value_set_boxed (value, nm_setting_wired_get_mac_address (setting));
break;
case PROP_CLONED_MAC_ADDRESS:
g_value_set_boxed (value, nm_setting_wired_get_cloned_mac_address (setting));
break;
case PROP_MAC_ADDRESS_BLACKLIST:
g_value_set_boxed (value, nm_setting_wired_get_mac_address_blacklist (setting));
break;
case PROP_MTU:
g_value_set_uint (value, nm_setting_wired_get_mtu (setting));
break;
case PROP_S390_SUBCHANNELS:
g_value_set_boxed (value, nm_setting_wired_get_s390_subchannels (setting));
break;
case PROP_S390_NETTYPE:
g_value_set_string (value, nm_setting_wired_get_s390_nettype (setting));
break;
case PROP_S390_OPTIONS:
g_value_set_boxed (value, priv->s390_options);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static NMActStageReturn
act_stage1_prepare (NMDevice *device, NMDeviceStateReason *reason)
{
NMSettingWired *s_wired;
const char *cloned_mac;
NMActStageReturn ret;
g_return_val_if_fail (reason != NULL, NM_ACT_STAGE_RETURN_FAILURE);
ret = NM_DEVICE_CLASS (nm_device_vxlan_parent_class)->act_stage1_prepare (device, reason);
if (ret != NM_ACT_STAGE_RETURN_SUCCESS)
return ret;
s_wired = (NMSettingWired *) nm_device_get_applied_setting (device, NM_TYPE_SETTING_WIRED);
if (s_wired) {
/* Set device MAC address if the connection wants to change it */
cloned_mac = nm_setting_wired_get_cloned_mac_address (s_wired);
nm_device_set_hw_addr (device, cloned_mac, "set", LOGD_DEVICE);
}
return NM_ACT_STAGE_RETURN_SUCCESS;
}
static void
populate_ui (CEPageWired *self)
{
CEPageWiredPrivate *priv = CE_PAGE_WIRED_GET_PRIVATE (self);
NMSettingWired *setting = priv->setting;
const char *port;
const char *duplex;
int port_idx = PORT_DEFAULT;
int speed_idx;
int mtu_def;
char **mac_list, **iter;
const GByteArray *s_mac;
char *s_mac_str;
char *active_mac = NULL;
GtkWidget *entry;
/* Port */
port = nm_setting_wired_get_port (setting);
if (port) {
if (!strcmp (port, "tp"))
port_idx = PORT_TP;
else if (!strcmp (port, "aui"))
port_idx = PORT_AUI;
else if (!strcmp (port, "bnc"))
port_idx = PORT_BNC;
else if (!strcmp (port, "mii"))
port_idx = PORT_MII;
}
gtk_combo_box_set_active (priv->port, port_idx);
/* Speed */
switch (nm_setting_wired_get_speed (setting)) {
case 10:
speed_idx = SPEED_10;
break;
case 100:
speed_idx = SPEED_100;
break;
case 1000:
speed_idx = SPEED_1000;
break;
case 10000:
speed_idx = SPEED_10000;
break;
default:
speed_idx = SPEED_DEFAULT;
break;
}
gtk_combo_box_set_active (priv->speed, speed_idx);
/* Duplex */
duplex = nm_setting_wired_get_duplex (setting);
if (duplex && !strcmp (duplex, "half"))
gtk_toggle_button_set_active (priv->duplex, FALSE);
else
gtk_toggle_button_set_active (priv->duplex, TRUE);
/* Autonegotiate */
gtk_toggle_button_set_active (priv->autonegotiate,
nm_setting_wired_get_auto_negotiate (setting));
/* Device MAC address */
mac_list = ce_page_get_mac_list (CE_PAGE (self));
s_mac = nm_setting_wired_get_mac_address (setting);
s_mac_str = s_mac ? g_strdup_printf ("%02X:%02X:%02X:%02X:%02X:%02X",
s_mac->data[0], s_mac->data[1], s_mac->data[2],
s_mac->data[3], s_mac->data[4], s_mac->data[5]):
NULL;
for (iter = mac_list; iter && *iter; iter++) {
#if GTK_CHECK_VERSION (2,24,0)
gtk_combo_box_text_append_text (priv->device_mac, *iter);
#else
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->device_mac), *iter);
#endif
if (s_mac_str && g_ascii_strncasecmp (*iter, s_mac_str, 17) == 0)
active_mac = *iter;
}
if (s_mac_str) {
if (!active_mac) {
#if GTK_CHECK_VERSION (2,24,0)
gtk_combo_box_text_prepend_text (priv->device_mac, s_mac_str);
#else
gtk_combo_box_prepend_text (GTK_COMBO_BOX (priv->device_mac), s_mac_str);
#endif
}
entry = gtk_bin_get_child (GTK_BIN (priv->device_mac));
if (entry)
gtk_entry_set_text (GTK_ENTRY (entry), active_mac ? active_mac : s_mac_str);
}
g_strfreev (mac_list);
g_signal_connect (priv->device_mac, "changed", G_CALLBACK (stuff_changed), self);
/* Cloned MAC address */
ce_page_mac_to_entry (nm_setting_wired_get_cloned_mac_address (setting), priv->cloned_mac);
g_signal_connect (priv->cloned_mac, "changed", G_CALLBACK (stuff_changed), self);
/* MTU */
mtu_def = ce_get_property_default (NM_SETTING (setting), NM_SETTING_WIRED_MTU);
g_signal_connect (priv->mtu, "output",
G_CALLBACK (ce_spin_output_with_default),
GINT_TO_POINTER (mtu_def));
gtk_spin_button_set_value (priv->mtu, (gdouble) nm_setting_wired_get_mtu (setting));
}
static void
populate_ui (CEPageEthernet *self)
{
CEPageEthernetPrivate *priv = CE_PAGE_ETHERNET_GET_PRIVATE (self);
NMSettingWired *setting = priv->setting;
const char *port;
const char *duplex;
int port_idx = PORT_DEFAULT;
int speed_idx;
int mtu_def;
char **mac_list;
const GByteArray *s_mac;
char *s_mac_str;
/* Port */
port = nm_setting_wired_get_port (setting);
if (port) {
if (!strcmp (port, "tp"))
port_idx = PORT_TP;
else if (!strcmp (port, "aui"))
port_idx = PORT_AUI;
else if (!strcmp (port, "bnc"))
port_idx = PORT_BNC;
else if (!strcmp (port, "mii"))
port_idx = PORT_MII;
}
gtk_combo_box_set_active (priv->port, port_idx);
/* Speed */
switch (nm_setting_wired_get_speed (setting)) {
case 10:
speed_idx = SPEED_10;
break;
case 100:
speed_idx = SPEED_100;
break;
case 1000:
speed_idx = SPEED_1000;
break;
case 10000:
speed_idx = SPEED_10000;
break;
default:
speed_idx = SPEED_DEFAULT;
break;
}
gtk_combo_box_set_active (priv->speed, speed_idx);
/* Duplex */
duplex = nm_setting_wired_get_duplex (setting);
if (duplex && !strcmp (duplex, "half"))
gtk_toggle_button_set_active (priv->duplex, FALSE);
else
gtk_toggle_button_set_active (priv->duplex, TRUE);
/* Autonegotiate */
gtk_toggle_button_set_active (priv->autonegotiate,
nm_setting_wired_get_auto_negotiate (setting));
/* Device MAC address */
mac_list = ce_page_get_mac_list (CE_PAGE (self), NM_TYPE_DEVICE_ETHERNET,
NM_DEVICE_ETHERNET_PERMANENT_HW_ADDRESS);
s_mac = nm_setting_wired_get_mac_address (setting);
s_mac_str = s_mac ? nm_utils_hwaddr_ntoa (s_mac->data, ARPHRD_ETHER) : NULL;
ce_page_setup_mac_combo (CE_PAGE (self), GTK_COMBO_BOX (priv->device_mac),
s_mac_str, mac_list);
g_free (s_mac_str);
g_strfreev (mac_list);
g_signal_connect (priv->device_mac, "changed", G_CALLBACK (stuff_changed), self);
/* Cloned MAC address */
ce_page_mac_to_entry (nm_setting_wired_get_cloned_mac_address (setting),
ARPHRD_ETHER, priv->cloned_mac);
g_signal_connect (priv->cloned_mac, "changed", G_CALLBACK (stuff_changed), self);
/* MTU */
mtu_def = ce_get_property_default (NM_SETTING (setting), NM_SETTING_WIRED_MTU);
g_signal_connect (priv->mtu, "output",
G_CALLBACK (ce_spin_output_with_default),
GINT_TO_POINTER (mtu_def));
gtk_spin_button_set_value (priv->mtu, (gdouble) nm_setting_wired_get_mtu (setting));
}
static void
populate_ui (CEPageVlan *self)
{
CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self);
GSList *devices, *d_iter;
NMConnection *parent_connection = NULL;
NMDevice *device, *parent_device = NULL;
const char *parent, *iface, *current_parent;
int i, mtu_def, mtu_val;
devices = get_vlan_devices (self);
/* Parent */
build_vlan_parent_list (self, devices);
parent = nm_setting_vlan_get_parent (priv->setting);
if (parent) {
/* UUID? */
parent_connection = (NMConnection *)nm_remote_settings_get_connection_by_uuid (CE_PAGE (self)->settings, parent);
if (!parent_connection) {
/* Interface name? */
for (d_iter = devices; d_iter; d_iter = d_iter->next) {
device = d_iter->data;
if (!g_strcmp0 (parent, nm_device_get_iface (device))) {
parent_device = device;
break;
}
}
}
}
/* If NMSettingVlan:parent didn't indicate a device, but we have a
* wired setting, figure out the device from that.
*/
if (priv->s_hw && !parent_device) {
const GByteArray *mac;
const char *device_mac_str;
char *mac_str;
if (NM_IS_SETTING_WIRED (priv->s_hw))
mac = nm_setting_wired_get_mac_address (NM_SETTING_WIRED (priv->s_hw));
else
mac = NULL;
if (mac) {
mac_str = nm_utils_hwaddr_ntoa (mac->data, ARPHRD_ETHER);
for (d_iter = devices; d_iter; d_iter = d_iter->next) {
device = d_iter->data;
if (NM_IS_DEVICE_ETHERNET (device))
device_mac_str = nm_device_ethernet_get_permanent_hw_address (NM_DEVICE_ETHERNET (device));
else
device_mac_str = NULL;
if (!g_strcmp0 (mac_str, device_mac_str)) {
parent_device = device;
break;
}
}
}
}
current_parent = parent;
if (parent_device || parent_connection) {
for (i = 0; priv->parents[i]; i++) {
if (parent_device && parent_device != priv->parents[i]->device)
continue;
if (parent_connection != priv->parents[i]->connection)
continue;
current_parent = priv->parents[i]->label;
break;
}
}
ce_page_setup_mac_combo (CE_PAGE (self), priv->parent, current_parent, priv->parent_labels);
g_signal_connect (priv->parent, "changed", G_CALLBACK (parent_changed), self);
if (current_parent)
priv->last_parent = g_strndup (current_parent, strcspn (current_parent, " "));
/* Name */
iface = nm_setting_vlan_get_interface_name (priv->setting);
if (iface)
gtk_entry_set_text (priv->name_entry, iface);
g_signal_connect (priv->name_entry, "changed", G_CALLBACK (name_changed), self);
/* ID */
priv->last_id = nm_setting_vlan_get_id (priv->setting);
gtk_spin_button_set_value (priv->id_entry, priv->last_id);
g_signal_connect (priv->id_entry, "value-changed", G_CALLBACK (id_changed), self);
/* Cloned MAC address */
if (NM_IS_SETTING_WIRED (priv->s_hw)) {
ce_page_mac_to_entry (nm_setting_wired_get_cloned_mac_address (NM_SETTING_WIRED (priv->s_hw)),
ARPHRD_ETHER, priv->cloned_mac);
}
g_signal_connect (priv->cloned_mac, "changed", G_CALLBACK (stuff_changed), self);
/* MTU */
if (NM_IS_SETTING_WIRED (priv->s_hw)) {
mtu_def = ce_get_property_default (priv->s_hw, NM_SETTING_WIRED_MTU);
mtu_val = nm_setting_wired_get_mtu (NM_SETTING_WIRED (priv->s_hw));
} else {
mtu_def = mtu_val = 1500;
}
g_signal_connect (priv->mtu, "output",
G_CALLBACK (ce_spin_output_with_default),
GINT_TO_POINTER (mtu_def));
gtk_spin_button_set_value (priv->mtu, (gdouble) mtu_val);
g_signal_connect (priv->mtu, "value-changed", G_CALLBACK (stuff_changed), self);
g_slist_free (devices);
}
static void
connect_ethernet_page (CEPageEthernet *page)
{
NMSettingWired *setting = page->setting_wired;
NMSettingConnection *sc;
int mtu_def;
char **mac_list;
const GByteArray *s_mac;
char *s_mac_str;
GtkWidget *widget;
const gchar *name;
name = nm_setting_connection_get_id (page->setting_connection);
gtk_entry_set_text (page->name, name);
/* Device MAC address */
mac_list = ce_page_get_mac_list (CE_PAGE (page)->client, NM_TYPE_DEVICE_ETHERNET,
NM_DEVICE_ETHERNET_PERMANENT_HW_ADDRESS);
s_mac = nm_setting_wired_get_mac_address (setting);
s_mac_str = s_mac ? nm_utils_hwaddr_ntoa (s_mac->data, ARPHRD_ETHER) : NULL;
ce_page_setup_mac_combo (page->device_mac, s_mac_str, mac_list);
g_free (s_mac_str);
g_strfreev (mac_list);
g_signal_connect_swapped (page->device_mac, "changed", G_CALLBACK (ce_page_changed), page);
/* Cloned MAC address */
ce_page_mac_to_entry (nm_setting_wired_get_cloned_mac_address (setting),
ARPHRD_ETHER, page->cloned_mac);
g_signal_connect_swapped (page->cloned_mac, "changed", G_CALLBACK (ce_page_changed), page);
/* MTU */
mtu_def = ce_get_property_default (NM_SETTING (setting), NM_SETTING_WIRED_MTU);
g_signal_connect (page->mtu, "output",
G_CALLBACK (ce_spin_output_with_default),
GINT_TO_POINTER (mtu_def));
gtk_spin_button_set_value (page->mtu, (gdouble) nm_setting_wired_get_mtu (setting));
g_signal_connect (page->mtu, "value-changed",
G_CALLBACK (mtu_changed), page);
mtu_changed (page->mtu, page);
g_signal_connect_swapped (page->name, "changed", G_CALLBACK (ce_page_changed), page);
g_signal_connect_swapped (page->mtu, "value-changed", G_CALLBACK (ce_page_changed), page);
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder,
"auto_connect_check"));
sc = nm_connection_get_setting_connection (CE_PAGE (page)->connection);
g_object_bind_property (sc, "autoconnect",
widget, "active",
G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
g_signal_connect_swapped (widget, "toggled", G_CALLBACK (ce_page_changed), page);
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder,
"all_user_check"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget),
nm_setting_connection_get_num_permissions (sc) == 0);
g_signal_connect (widget, "toggled",
G_CALLBACK (all_user_changed), page);
g_signal_connect_swapped (widget, "toggled", G_CALLBACK (ce_page_changed), page);
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder, "combo_zone"));
firewall_ui_setup (sc, widget, CE_PAGE (page)->cancellable);
g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page);
}
