static char *
get_new_connection_ifname (NMPlatform *platform,
const GSList *existing,
const char *prefix)
{
int i;
char *name;
const GSList *iter;
gboolean found;
for (i = 0; i < 500; i++) {
name = g_strdup_printf ("%s%d", prefix, i);
if (nm_platform_link_get_by_ifname (platform, name))
goto next;
for (iter = existing, found = FALSE; iter; iter = g_slist_next (iter)) {
NMConnection *candidate = iter->data;
if (g_strcmp0 (nm_connection_get_interface_name (candidate), name) == 0) {
found = TRUE;
break;
}
}
if (!found)
return name;
next:
g_free (name);
}
return NULL;
}
static char *
get_virtual_iface_name (NMDeviceFactory *factory,
NMConnection *connection,
const char *parent_iface)
{
const char *ifname;
NMSettingVlan *s_vlan;
g_return_val_if_fail (nm_connection_is_type (connection, NM_SETTING_VLAN_SETTING_NAME), NULL);
s_vlan = nm_connection_get_setting_vlan (connection);
g_assert (s_vlan);
if (!parent_iface)
return NULL;
ifname = nm_connection_get_interface_name (connection);
if (ifname)
return g_strdup (ifname);
/* If the connection doesn't specify the interface name for the VLAN
* device, we create one for it using the VLAN ID and the parent
* interface's name.
*/
return nm_utils_new_vlan_name (parent_iface, nm_setting_vlan_get_id (s_vlan));
}
/* Returns an editor for @slave's master, if any */
NMConnectionEditor *
nm_connection_editor_get_master (NMConnection *slave)
{
GHashTableIter iter;
gpointer connection, editor;
NMSettingConnection *s_con;
const char *master;
if (!active_editors)
return NULL;
s_con = nm_connection_get_setting_connection (slave);
master = nm_setting_connection_get_master (s_con);
if (!master)
return NULL;
g_hash_table_iter_init (&iter, active_editors);
while (g_hash_table_iter_next (&iter, &connection, &editor)) {
if (!g_strcmp0 (master, nm_connection_get_uuid (connection)))
return editor;
if (!g_strcmp0 (master, nm_connection_get_interface_name (connection)))
return editor;
}
return NULL;
}
static NMDevice *
create_virtual_device_for_connection (NMDeviceFactory *factory,
NMConnection *connection,
NMDevice *parent,
GError **error)
{
const char *iface;
if (!nm_connection_is_type (connection, NM_SETTING_BOND_SETTING_NAME))
return NULL;
iface = nm_connection_get_interface_name (connection);
g_return_val_if_fail (iface != NULL, NULL);
if ( !nm_platform_bond_add (iface)
&& nm_platform_get_error () != NM_PLATFORM_ERROR_EXISTS) {
nm_log_warn (LOGD_DEVICE | LOGD_BOND, "(%s): failed to create bonding master interface for '%s': %s",
iface, nm_connection_get_id (connection),
nm_platform_get_error_msg ());
return NULL;
}
return (NMDevice *) g_object_new (NM_TYPE_DEVICE_BOND,
NM_DEVICE_IFACE, iface,
NM_DEVICE_DRIVER, "bonding",
NM_DEVICE_TYPE_DESC, "Bond",
NM_DEVICE_DEVICE_TYPE, NM_DEVICE_TYPE_BOND,
NM_DEVICE_IS_MASTER, TRUE,
NULL);
}
void
bond_connection_new (GtkWindow *parent,
const char *detail,
NMClient *client,
PageNewConnectionResultFunc result_func,
gpointer user_data)
{
NMConnection *connection;
NMSettingConnection *s_con;
int bond_num = 0, num, i;
const GPtrArray *connections;
NMConnection *conn2;
const char *iface;
char *my_iface;
connection = ce_page_new_connection (_("Bond connection %d"),
NM_SETTING_BOND_SETTING_NAME,
TRUE,
client,
user_data);
nm_connection_add_setting (connection, nm_setting_bond_new ());
/* Find an available interface name */
connections = nm_client_get_connections (client);
for (i = 0; i < connections->len; i++) {
conn2 = connections->pdata[i];
if (!nm_connection_is_type (conn2, NM_SETTING_BOND_SETTING_NAME))
continue;
iface = nm_connection_get_interface_name (conn2);
if (!iface || strncmp (iface, "bond", 4) != 0 || !g_ascii_isdigit (iface[4]))
continue;
num = atoi (iface + 4);
if (bond_num <= num)
bond_num = num + 1;
}
s_con = nm_connection_get_setting_connection (connection);
my_iface = g_strdup_printf ("bond%d", bond_num);
g_object_set (G_OBJECT (s_con),
NM_SETTING_CONNECTION_INTERFACE_NAME, my_iface,
NULL);
g_free (my_iface);
(*result_func) (connection, FALSE, NULL, user_data);
}
NMDevice *
nm_device_vlan_new_for_connection (NMConnection *connection, NMDevice *parent)
{
NMDevice *device;
NMSettingVlan *s_vlan;
char *iface;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (NM_IS_DEVICE (parent), NULL);
s_vlan = nm_connection_get_setting_vlan (connection);
g_return_val_if_fail (s_vlan != NULL, NULL);
iface = g_strdup (nm_connection_get_interface_name (connection));
if (!iface) {
iface = nm_utils_new_vlan_name (nm_device_get_ip_iface (parent),
nm_setting_vlan_get_id (s_vlan));
}
if ( !nm_platform_vlan_add (iface,
nm_device_get_ifindex (parent),
nm_setting_vlan_get_id (s_vlan),
nm_setting_vlan_get_flags (s_vlan))
&& nm_platform_get_error () != NM_PLATFORM_ERROR_EXISTS) {
nm_log_warn (LOGD_DEVICE | LOGD_VLAN, "(%s) failed to add VLAN interface for '%s'",
iface, nm_connection_get_id (connection));
g_free (iface);
return NULL;
}
device = (NMDevice *) g_object_new (NM_TYPE_DEVICE_VLAN,
NM_DEVICE_IFACE, iface,
NM_DEVICE_VLAN_PARENT, parent,
NM_DEVICE_DRIVER, "8021q",
NM_DEVICE_TYPE_DESC, "VLAN",
NM_DEVICE_DEVICE_TYPE, NM_DEVICE_TYPE_VLAN,
NULL);
g_free (iface);
if (NM_DEVICE_VLAN_GET_PRIVATE (device)->invalid) {
g_object_unref (device);
device = NULL;
}
return device;
}
static char *
get_connection_iface (NMDeviceFactory *factory,
NMConnection *connection,
const char *parent_iface)
{
const char *ifname;
NMSettingVxlan *s_vxlan;
g_return_val_if_fail (nm_connection_is_type (connection, NM_SETTING_VXLAN_SETTING_NAME), NULL);
s_vxlan = nm_connection_get_setting_vxlan (connection);
g_assert (s_vxlan);
if (nm_setting_vxlan_get_parent (s_vxlan) && !parent_iface)
return NULL;
ifname = nm_connection_get_interface_name (connection);
return g_strdup (ifname);
}
void
nmt_remove_connection (NMRemoteConnection *connection)
{
const GPtrArray *all_conns;
GSList *slaves, *iter;
int i;
NMRemoteConnection *slave;
NMSettingConnection *s_con;
const char *uuid, *iface, *master;
int choice;
choice = nmt_newt_choice_dialog (_("Cancel"),
_("Delete"),
_("Are you sure you want to delete the connection '%s'?"),
nm_connection_get_id (NM_CONNECTION (connection)));
if (choice == 1)
return;
g_object_ref (connection);
remove_one_connection (connection);
uuid = nm_connection_get_uuid (NM_CONNECTION (connection));
iface = nm_connection_get_interface_name (NM_CONNECTION (connection));
all_conns = nm_client_get_connections (nm_client);
slaves = NULL;
for (i = 0; i < all_conns->len; i++) {
slave = all_conns->pdata[i];
s_con = nm_connection_get_setting_connection (NM_CONNECTION (slave));
master = nm_setting_connection_get_master (s_con);
if (master) {
if (!g_strcmp0 (master, uuid) || !g_strcmp0 (master, iface))
slaves = g_slist_prepend (slaves, g_object_ref (slave));
}
}
for (iter = slaves; iter; iter = iter->next)
remove_one_connection (iter->data);
g_slist_free_full (slaves, g_object_unref);
g_object_unref (connection);
}
static char *
get_virtual_iface_name (NMDeviceFactory *factory,
NMConnection *connection,
const char *parent_iface)
{
const char *ifname;
NMSettingIPTunnel *s_ip_tunnel;
g_return_val_if_fail (nm_connection_is_type (connection, NM_SETTING_IP_TUNNEL_SETTING_NAME), NULL);
s_ip_tunnel = nm_connection_get_setting_ip_tunnel (connection);
g_assert (s_ip_tunnel);
if (nm_setting_ip_tunnel_get_parent (s_ip_tunnel) && !parent_iface)
return NULL;
ifname = nm_connection_get_interface_name (connection);
return g_strdup (ifname);
}
char *
nm_device_factory_get_connection_iface (NMDeviceFactory *factory,
NMConnection *connection,
const char *parent_iface,
GError **error)
{
NMDeviceFactoryInterface *klass;
char *ifname;
g_return_val_if_fail (factory != NULL, NULL);
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (!error || !*error, NULL);
klass = NM_DEVICE_FACTORY_GET_INTERFACE (factory);
if (klass->get_connection_iface)
ifname = klass->get_connection_iface (factory, connection, parent_iface);
else
ifname = g_strdup (nm_connection_get_interface_name (connection));
if (!ifname) {
g_set_error (error,
NM_MANAGER_ERROR,
NM_MANAGER_ERROR_FAILED,
"failed to determine interface name: error determine name for %s",
nm_connection_get_connection_type (connection));
return NULL;
}
if (!nm_utils_iface_valid_name (ifname)) {
g_set_error (error,
NM_MANAGER_ERROR,
NM_MANAGER_ERROR_FAILED,
"failed to determine interface name: name \"%s\" is invalid",
ifname);
g_free (ifname);
return NULL;
}
return ifname;
}
static gboolean
check_connection_compatible (NMDevice *device, NMConnection *connection)
{
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (device);
NMSettingVlan *s_vlan;
const char *parent, *iface = NULL;
if (!NM_DEVICE_CLASS (nm_device_vlan_parent_class)->check_connection_compatible (device, connection))
return FALSE;
s_vlan = nm_connection_get_setting_vlan (connection);
if (!s_vlan)
return FALSE;
if (nm_setting_vlan_get_id (s_vlan) != priv->vlan_id)
return FALSE;
/* Check parent interface; could be an interface name or a UUID */
parent = nm_setting_vlan_get_parent (s_vlan);
if (parent) {
if (!match_parent (NM_DEVICE_VLAN (device), parent))
return FALSE;
} else {
/* Parent could be a MAC address in an NMSettingWired */
if (!match_hwaddr (device, connection, TRUE))
return FALSE;
}
/* Ensure the interface name matches. If not specified we assume a match
* since both the parent interface and the VLAN ID matched by the time we
* get here.
*/
iface = nm_connection_get_interface_name (connection);
if (iface) {
if (g_strcmp0 (nm_device_get_ip_iface (device), iface) != 0)
return FALSE;
}
return TRUE;
}
static gboolean
check_connection_compatible (NMDevice *device, NMConnection *connection)
{
const char *iface;
NMSettingTeam *s_team;
if (!NM_DEVICE_CLASS (nm_device_team_parent_class)->check_connection_compatible (device, connection))
return FALSE;
s_team = nm_connection_get_setting_team (connection);
if (!s_team || !nm_connection_is_type (connection, NM_SETTING_TEAM_SETTING_NAME))
return FALSE;
/* Team connections must specify the virtual interface name */
iface = nm_connection_get_interface_name (connection);
if (!iface || strcmp (nm_device_get_iface (device), iface))
return FALSE;
/* FIXME: match team properties like mode, etc? */
return TRUE;
}
static gboolean
edit_connection_list_filter (NmtEditConnectionList *list,
NMConnection *connection,
gpointer user_data)
{
NMSettingConnection *s_con;
const char *master, *slave_type;
const char *uuid, *ifname;
const GPtrArray *conns;
int i;
gboolean found_master = FALSE;
s_con = nm_connection_get_setting_connection (connection);
g_return_val_if_fail (s_con != NULL, FALSE);
master = nm_setting_connection_get_master (s_con);
if (!master)
return TRUE;
slave_type = nm_setting_connection_get_slave_type (s_con);
if ( g_strcmp0 (slave_type, NM_SETTING_BOND_SETTING_NAME) != 0
&& g_strcmp0 (slave_type, NM_SETTING_TEAM_SETTING_NAME) != 0
&& g_strcmp0 (slave_type, NM_SETTING_BRIDGE_SETTING_NAME) != 0)
return TRUE;
conns = nm_client_get_connections (nm_client);
for (i = 0; i < conns->len; i++) {
NMConnection *candidate = conns->pdata[i];
uuid = nm_connection_get_uuid (candidate);
ifname = nm_connection_get_interface_name (candidate);
if (!g_strcmp0 (master, uuid) || !g_strcmp0 (master, ifname)) {
found_master = TRUE;
break;
}
}
return !found_master;
}
static gboolean
connection_compatible (NMDevice *device, NMConnection *connection, GError **error)
{
const char *iface_name;
if (!NM_DEVICE_CLASS (nm_device_generic_parent_class)->connection_compatible (device, connection, error))
return FALSE;
if (!nm_connection_is_type (connection, NM_SETTING_GENERIC_SETTING_NAME)) {
g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION,
_("The connection was not a generic connection."));
return FALSE;
}
iface_name = nm_connection_get_interface_name (connection);
if (!iface_name) {
g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INVALID_CONNECTION,
_("The connection did not specify an interface name."));
return FALSE;
}
return TRUE;
}
static void
populate_ui (CEPageWifi *self)
{
CEPageWifiPrivate *priv = CE_PAGE_WIFI_GET_PRIVATE (self);
NMSettingWireless *setting = priv->setting;
GBytes *ssid;
const char *mode;
const char *band;
int band_idx = 0;
int rate_def;
int tx_power_def;
int mtu_def;
char *utf8_ssid;
const char *s_ifname, *s_mac, *s_bssid;
GPtrArray *bssid_array;
char **bssid_list;
guint32 idx;
rate_def = ce_get_property_default (NM_SETTING (setting), NM_SETTING_WIRELESS_RATE);
g_signal_connect (priv->rate, "output",
G_CALLBACK (ce_spin_output_with_automatic),
GINT_TO_POINTER (rate_def));
g_signal_connect_swapped (priv->rate, "value-changed", G_CALLBACK (ce_page_changed), self);
tx_power_def = ce_get_property_default (NM_SETTING (setting), NM_SETTING_WIRELESS_TX_POWER);
g_signal_connect (priv->tx_power, "output",
G_CALLBACK (ce_spin_output_with_automatic),
GINT_TO_POINTER (tx_power_def));
g_signal_connect_swapped (priv->tx_power, "value-changed", G_CALLBACK (ce_page_changed), self);
mtu_def = ce_get_property_default (NM_SETTING (setting), NM_SETTING_WIRELESS_MTU);
g_signal_connect (priv->mtu, "output",
G_CALLBACK (ce_spin_output_with_automatic),
GINT_TO_POINTER (mtu_def));
g_signal_connect_swapped (priv->mtu, "value-changed", G_CALLBACK (ce_page_changed), self);
ssid = nm_setting_wireless_get_ssid (setting);
mode = nm_setting_wireless_get_mode (setting);
band = nm_setting_wireless_get_band (setting);
if (ssid)
utf8_ssid = nm_utils_ssid_to_utf8 (g_bytes_get_data (ssid, NULL),
g_bytes_get_size (ssid));
else
utf8_ssid = g_strdup ("");
gtk_entry_set_text (priv->ssid, utf8_ssid);
g_signal_connect_swapped (priv->ssid, "changed", G_CALLBACK (ce_page_changed), self);
g_free (utf8_ssid);
/* Default to Infrastructure */
gtk_combo_box_set_active (priv->mode, 0);
if (!g_strcmp0 (mode, "ap"))
gtk_combo_box_set_active (priv->mode, 1);
if (!g_strcmp0 (mode, "adhoc"))
gtk_combo_box_set_active (priv->mode, 2);
mode_combo_changed_cb (priv->mode, self);
g_signal_connect (priv->mode, "changed", G_CALLBACK (mode_combo_changed_cb), self);
g_signal_connect (priv->channel, "output",
G_CALLBACK (channel_spin_output_cb),
self);
g_signal_connect (priv->channel, "input",
G_CALLBACK (channel_spin_input_cb),
self);
gtk_widget_set_sensitive (GTK_WIDGET (priv->channel), FALSE);
if (band) {
if (!strcmp (band, "a")) {
band_idx = 1;
gtk_widget_set_sensitive (GTK_WIDGET (priv->channel), TRUE);
} else if (!strcmp (band, "bg")) {
band_idx = 2;
gtk_widget_set_sensitive (GTK_WIDGET (priv->channel), TRUE);
}
}
gtk_combo_box_set_active (priv->band, band_idx);
g_signal_connect (priv->band, "changed",
G_CALLBACK (band_value_changed_cb),
self);
/* Update the channel _after_ the band has been set so that it gets
* the right values */
priv->last_channel = nm_setting_wireless_get_channel (setting);
gtk_spin_button_set_value (priv->channel, (gdouble) priv->last_channel);
g_signal_connect_swapped (priv->channel, "value-changed", G_CALLBACK (ce_page_changed), self);
/* BSSID */
bssid_array = g_ptr_array_new ();
for (idx = 0; idx < nm_setting_wireless_get_num_seen_bssids (setting); idx++)
g_ptr_array_add (bssid_array, g_strdup (nm_setting_wireless_get_seen_bssid (setting, idx)));
g_ptr_array_add (bssid_array, NULL);
bssid_list = (char **) g_ptr_array_free (bssid_array, FALSE);
s_bssid = nm_setting_wireless_get_bssid (setting);
ce_page_setup_mac_combo (CE_PAGE (self), GTK_COMBO_BOX (priv->bssid),
s_bssid, bssid_list);
g_strfreev (bssid_list);
g_signal_connect_swapped (priv->bssid, "changed", G_CALLBACK (ce_page_changed), self);
/* Device MAC address */
s_ifname = nm_connection_get_interface_name (CE_PAGE (self)->connection);
s_mac = nm_setting_wireless_get_mac_address (setting);
ce_page_setup_device_combo (CE_PAGE (self), GTK_COMBO_BOX (priv->device_combo),
NM_TYPE_DEVICE_WIFI, s_ifname,
s_mac, NM_DEVICE_WIFI_PERMANENT_HW_ADDRESS, TRUE);
g_signal_connect_swapped (priv->device_combo, "changed", G_CALLBACK (ce_page_changed), self);
/* Cloned MAC address */
s_mac = nm_setting_wireless_get_cloned_mac_address (setting);
if (s_mac)
gtk_entry_set_text (priv->cloned_mac, s_mac);
g_signal_connect_swapped (priv->cloned_mac, "changed", G_CALLBACK (ce_page_changed), self);
gtk_spin_button_set_value (priv->rate, (gdouble) nm_setting_wireless_get_rate (setting));
gtk_spin_button_set_value (priv->tx_power, (gdouble) nm_setting_wireless_get_tx_power (setting));
gtk_spin_button_set_value (priv->mtu, (gdouble) nm_setting_wireless_get_mtu (setting));
}
