CEPage *
ce_page_vlan_new (NMConnection *connection,
GtkWindow *parent_window,
NMClient *client,
NMRemoteSettings *settings,
const char **out_secrets_setting_name,
GError **error)
{
CEPageVlan *self;
CEPageVlanPrivate *priv;
self = CE_PAGE_VLAN (ce_page_new (CE_TYPE_PAGE_VLAN,
connection,
parent_window,
client,
settings,
UIDIR "/ce-page-vlan.ui",
"VlanPage",
_("VLAN")));
if (!self) {
g_set_error_literal (error, NMA_ERROR, NMA_ERROR_GENERIC, _("Could not load vlan user interface."));
return NULL;
}
vlan_private_init (self);
priv = CE_PAGE_VLAN_GET_PRIVATE (self);
priv->setting = nm_connection_get_setting_vlan (connection);
if (!priv->setting) {
priv->setting = NM_SETTING_VLAN (nm_setting_vlan_new ());
nm_connection_add_setting (connection, NM_SETTING (priv->setting));
}
priv->s_hw = nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRED);
g_signal_connect (self, "initialized", G_CALLBACK (finish_setup), NULL);
return CE_PAGE (self);
}
CEPage *
ce_page_infiniband_new (NMConnection *connection,
GtkWindow *parent_window,
NMClient *client,
NMRemoteSettings *settings,
const char **out_secrets_setting_name,
GError **error)
{
CEPageInfiniband *self;
CEPageInfinibandPrivate *priv;
self = CE_PAGE_INFINIBAND (ce_page_new (CE_TYPE_PAGE_INFINIBAND,
connection,
parent_window,
client,
settings,
UIDIR "/ce-page-infiniband.ui",
"InfinibandPage",
_("InfiniBand")));
if (!self) {
g_set_error_literal (error, NMA_ERROR, NMA_ERROR_GENERIC,
_("Could not load InfiniBand user interface."));
return NULL;
}
infiniband_private_init (self);
priv = CE_PAGE_INFINIBAND_GET_PRIVATE (self);
priv->setting = nm_connection_get_setting_infiniband (connection);
if (!priv->setting) {
priv->setting = NM_SETTING_INFINIBAND (nm_setting_infiniband_new ());
nm_connection_add_setting (connection, NM_SETTING (priv->setting));
}
g_signal_connect (self, "initialized", G_CALLBACK (finish_setup), NULL);
return CE_PAGE (self);
}
static void
finish_setup (CEPageMobile *self, gpointer unused, GError *error, gpointer user_data)
{
CEPage *parent = CE_PAGE (self);
CEPageMobilePrivate *priv = CE_PAGE_MOBILE_GET_PRIVATE (self);
if (error)
return;
if (NM_IS_SETTING_GSM (priv->setting))
populate_gsm_ui (self, parent->connection);
else if (NM_IS_SETTING_CDMA (priv->setting))
populate_cdma_ui (self, parent->connection);
else
g_assert_not_reached ();
g_signal_connect (priv->number, "changed", G_CALLBACK (stuff_changed), self);
g_signal_connect (priv->username, "changed", G_CALLBACK (stuff_changed), self);
g_signal_connect (priv->password, "changed", G_CALLBACK (stuff_changed), self);
g_signal_connect (priv->apn, "changed", G_CALLBACK (stuff_changed), self);
gtk_entry_set_max_length (priv->apn, 64); /* APNs are max 64 chars */
g_signal_connect (priv->apn, "insert-text", G_CALLBACK (apn_filter_cb), self);
g_signal_connect (priv->apn_button, "clicked", G_CALLBACK (apn_button_clicked), self);
g_signal_connect (priv->network_id, "changed", G_CALLBACK (stuff_changed), self);
gtk_entry_set_max_length (priv->network_id, 6); /* MCC/MNCs are max 6 chars */
g_signal_connect (priv->network_id, "insert-text", G_CALLBACK (network_id_filter_cb), self);
g_signal_connect (priv->network_type, "changed", G_CALLBACK (stuff_changed), self);
g_signal_connect (priv->pin, "changed", G_CALLBACK (stuff_changed), self);
g_signal_connect (priv->roaming_allowed, "toggled", G_CALLBACK (stuff_changed), self);
g_signal_connect (GTK_WIDGET (gtk_builder_get_object (parent->builder, "mobile_show_passwords")),
"toggled",
G_CALLBACK (show_passwords),
self);
}
static void
routes_button_clicked_cb (GtkWidget *button, gpointer user_data)
{
CEPageIP4 *self = CE_PAGE_IP4 (user_data);
CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self);
GtkWidget *dialog, *toplevel;
gboolean automatic = FALSE;
const char *method;
char *tmp;
toplevel = gtk_widget_get_toplevel (CE_PAGE (self)->page);
g_return_if_fail (gtk_widget_is_toplevel (toplevel));
method = nm_setting_ip_config_get_method (priv->setting);
if (!method || !strcmp (method, NM_SETTING_IP4_CONFIG_METHOD_AUTO))
automatic = TRUE;
dialog = ip4_routes_dialog_new (priv->setting, automatic);
if (!dialog) {
g_warning ("%s: failed to create the routes dialog!", __func__);
return;
}
gtk_window_group_add_window (priv->window_group, GTK_WINDOW (dialog));
if (!priv->window_added) {
gtk_window_group_add_window (priv->window_group, GTK_WINDOW (toplevel));
priv->window_added = TRUE;
}
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (toplevel));
tmp = g_strdup_printf (_("Editing IPv4 routes for %s"), priv->connection_id);
gtk_window_set_title (GTK_WINDOW (dialog), tmp);
g_free (tmp);
g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (routes_dialog_response_cb), self);
gtk_widget_show_all (dialog);
}
CEPage *
ce_page_ethernet_new (NMConnection *connection,
GtkWindow *parent_window,
NMClient *client,
NMRemoteSettings *settings,
const char **out_secrets_setting_name,
GError **error)
{
CEPageEthernet *self;
CEPageEthernetPrivate *priv;
self = CE_PAGE_ETHERNET (ce_page_new (CE_TYPE_PAGE_ETHERNET,
connection,
parent_window,
client,
settings,
UIDIR "/ce-page-ethernet.ui",
"EthernetPage",
_("Ethernet")));
if (!self) {
g_set_error_literal (error, NMA_ERROR, NMA_ERROR_GENERIC, _("Could not load ethernet user interface."));
return NULL;
}
ethernet_private_init (self);
priv = CE_PAGE_ETHERNET_GET_PRIVATE (self);
priv->setting = nm_connection_get_setting_wired (connection);
if (!priv->setting) {
priv->setting = NM_SETTING_WIRED (nm_setting_wired_new ());
nm_connection_add_setting (connection, NM_SETTING (priv->setting));
}
g_signal_connect (self, "initialized", G_CALLBACK (finish_setup), NULL);
return CE_PAGE (self);
}
static void
band_value_changed_cb (GtkComboBox *box, gpointer user_data)
{
CEPageWifi *self = CE_PAGE_WIFI (user_data);
CEPageWifiPrivate *priv = CE_PAGE_WIFI_GET_PRIVATE (self);
gboolean sensitive;
priv->last_channel = 0;
gtk_spin_button_set_value (priv->channel, 0);
switch (gtk_combo_box_get_active (GTK_COMBO_BOX (box))) {
case 1: /* A */
case 2: /* B/G */
sensitive = TRUE;
break;
default:
sensitive = FALSE;
break;
}
gtk_widget_set_sensitive (GTK_WIDGET (priv->channel), sensitive);
ce_page_changed (CE_PAGE (self));
}
static void
auth_methods_button_clicked_cb (GtkWidget *button, gpointer user_data)
{
CEPagePpp *self = CE_PAGE_PPP (user_data);
CEPagePppPrivate *priv = CE_PAGE_PPP_GET_PRIVATE (self);
GtkWidget *dialog, *toplevel;
char *tmp;
toplevel = gtk_widget_get_toplevel (CE_PAGE (self)->page);
g_return_if_fail (gtk_widget_is_toplevel (toplevel));
dialog = ppp_auth_methods_dialog_new (priv->refuse_eap,
priv->refuse_pap,
priv->refuse_chap,
priv->refuse_mschap,
priv->refuse_mschapv2);
if (!dialog) {
g_warning ("%s: failed to create the PPP authentication methods dialog!", __func__);
return;
}
gtk_window_group_add_window (priv->window_group, GTK_WINDOW (dialog));
if (!priv->window_added) {
gtk_window_group_add_window (priv->window_group, GTK_WINDOW (toplevel));
priv->window_added = TRUE;
}
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (toplevel));
tmp = g_strdup_printf (_("Editing PPP authentication methods for %s"), priv->connection_id);
gtk_window_set_title (GTK_WINDOW (dialog), tmp);
g_free (tmp);
g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (auth_methods_dialog_response_cb), self);
gtk_widget_show_all (dialog);
}
static void
wifi_private_init (CEPageWifi *self)
{
CEPageWifiPrivate *priv = CE_PAGE_WIFI_GET_PRIVATE (self);
GtkBuilder *builder;
GtkWidget *widget;
GtkWidget *align;
GtkLabel *label;
builder = CE_PAGE (self)->builder;
priv->group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->ssid = GTK_ENTRY (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_ssid")));
priv->cloned_mac = GTK_ENTRY (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_cloned_mac")));
priv->mode = GTK_COMBO_BOX (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_mode")));
priv->band = GTK_COMBO_BOX (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_band")));
priv->channel = GTK_SPIN_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_channel")));
/* BSSID */
#if GTK_CHECK_VERSION(2,24,0)
priv->bssid = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new_with_entry ());
gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (priv->bssid), 0);
#else
priv->bssid = GTK_COMBO_BOX_ENTRY (gtk_combo_box_entry_new_text ());
gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (priv->bssid), 0);
#endif
gtk_widget_set_tooltip_text (GTK_WIDGET (priv->bssid),
_("This option locks this connection to the Wi-Fi access point (AP) specified by the BSSID entered here. Example: 00:11:22:33:44:55"));
align = GTK_WIDGET (gtk_builder_get_object (builder, "wifi_bssid_alignment"));
gtk_container_add (GTK_CONTAINER (align), GTK_WIDGET (priv->bssid));
gtk_widget_show_all (GTK_WIDGET (priv->bssid));
/* Device MAC */
#if GTK_CHECK_VERSION(2,24,0)
priv->device_mac = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new_with_entry ());
gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (priv->device_mac), 0);
#else
priv->device_mac = GTK_COMBO_BOX_ENTRY (gtk_combo_box_entry_new_text ());
gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (priv->device_mac), 0);
#endif
gtk_widget_set_tooltip_text (GTK_WIDGET (priv->device_mac),
_("This option locks this connection to the network device specified by its permanent MAC address entered here. Example: 00:11:22:33:44:55"));
align = GTK_WIDGET (gtk_builder_get_object (builder, "wifi_device_mac_alignment"));
gtk_container_add (GTK_CONTAINER (align), GTK_WIDGET (priv->device_mac));
gtk_widget_show_all (GTK_WIDGET (priv->device_mac));
/* Set mnemonic widget for device MAC label */
label = GTK_LABEL (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_device_mac_label")));
gtk_label_set_mnemonic_widget (label, GTK_WIDGET (priv->device_mac));
priv->rate = GTK_SPIN_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_rate")));
widget = GTK_WIDGET (gtk_builder_get_object (builder, "rate_units"));
gtk_size_group_add_widget (priv->group, widget);
priv->tx_power = GTK_SPIN_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_tx_power")));
widget = GTK_WIDGET (gtk_builder_get_object (builder, "tx_power_units"));
gtk_size_group_add_widget (priv->group, widget);
priv->mtu = GTK_SPIN_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_mtu")));
widget = GTK_WIDGET (gtk_builder_get_object (builder, "mtu_units"));
gtk_size_group_add_widget (priv->group, widget);
}
static void
stuff_changed (GtkWidget *w, gpointer user_data)
{
ce_page_changed (CE_PAGE (user_data));
}
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
stuff_changed_cb (WirelessSecurity *sec, gpointer user_data)
{
ce_page_changed (CE_PAGE (user_data));
}
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
build_vlan_parent_list (CEPageVlan *self, GSList *devices)
{
CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self);
GSList *connections, *c_iter, *d_iter;
GPtrArray *parents;
VlanParent *parent;
NMDevice *device;
const char *iface, *mac, *id;
int i;
parents = g_ptr_array_new ();
/* Devices with no L2 configuration can spawn VLANs directly. At the
* moment, this means just Ethernet.
*/
for (d_iter = devices; d_iter; d_iter = d_iter->next) {
device = d_iter->data;
if (!NM_IS_DEVICE_ETHERNET (device))
continue;
parent = g_slice_new (VlanParent);
parent->device = device;
parent->connection = NULL;
iface = nm_device_get_iface (device);
mac = nm_device_ethernet_get_permanent_hw_address (NM_DEVICE_ETHERNET (device));
parent->label = g_strdup_printf ("%s (%s)", iface, mac);
g_ptr_array_add (parents, parent);
}
/* Otherwise, VLANs have to be built on top of configured connections */
connections = nm_remote_settings_list_connections (CE_PAGE (self)->settings);
for (c_iter = connections; c_iter; c_iter = c_iter->next) {
NMConnection *candidate = c_iter->data;
NMSettingConnection *s_con = nm_connection_get_setting_connection (candidate);
if (nm_setting_connection_get_master (s_con))
continue;
for (d_iter = devices; d_iter; d_iter = d_iter->next) {
device = d_iter->data;
if (nm_device_connection_valid (device, candidate)) {
parent = g_slice_new (VlanParent);
parent->device = device;
parent->connection = candidate;
iface = nm_device_get_iface (device);
id = nm_setting_connection_get_id (s_con);
parent->label = g_strdup_printf ("%s (%s)", iface, id);
g_ptr_array_add (parents, parent);
/* no break here; the connection may apply to multiple devices */
}
}
}
g_slist_free (connections);
g_ptr_array_sort (parents, sort_parents);
g_ptr_array_add (parents, NULL);
priv->parent_labels = g_new (char *, parents->len);
priv->parents = (VlanParent **)g_ptr_array_free (parents, FALSE);
for (i = 0; priv->parents[i]; i++)
priv->parent_labels[i] = priv->parents[i]->label;
priv->parent_labels[i] = NULL;
}
static void
finish_setup (CEPagePpp *self, gpointer unused, GError *error, gpointer user_data)
{
if (!error)
populate_ui (self, CE_PAGE (self)->connection);
}
static void
ui_to_setting (CEPageWifi *self)
{
CEPageWifiPrivate *priv = CE_PAGE_WIFI_GET_PRIVATE (self);
NMSettingConnection *s_con;
GBytes *ssid;
const char *bssid = NULL;
char *ifname = NULL;
char *device_mac = NULL;
const char *cloned_mac;
const char *mode;
const char *band;
GtkWidget *entry;
s_con = nm_connection_get_setting_connection (CE_PAGE (self)->connection);
g_return_if_fail (s_con != NULL);
ssid = ce_page_wifi_get_ssid (self);
switch (gtk_combo_box_get_active (priv->mode)) {
case 1:
mode = "ap";
break;
case 2:
mode = "adhoc";
break;
default:
mode = "infrastructure";
break;
}
switch (gtk_combo_box_get_active (priv->band)) {
case 1:
band = "a";
break;
case 2:
band = "bg";
break;
case 0:
default:
band = NULL;
break;
}
entry = gtk_bin_get_child (GTK_BIN (priv->bssid));
/* BSSID is only valid for infrastructure */
if (entry && mode && strcmp (mode, "infrastructure") == 0)
bssid = gtk_entry_get_text (GTK_ENTRY (entry));
entry = gtk_bin_get_child (GTK_BIN (priv->device_combo));
if (entry)
ce_page_device_entry_get (GTK_ENTRY (entry), ARPHRD_ETHER, TRUE, &ifname, &device_mac, NULL, NULL);
cloned_mac = gtk_entry_get_text (priv->cloned_mac);
g_object_set (s_con,
NM_SETTING_CONNECTION_INTERFACE_NAME, ifname,
NULL);
g_object_set (priv->setting,
NM_SETTING_WIRELESS_SSID, ssid,
NM_SETTING_WIRELESS_BSSID, bssid && *bssid ? bssid : NULL,
NM_SETTING_WIRELESS_MAC_ADDRESS, device_mac,
NM_SETTING_WIRELESS_CLONED_MAC_ADDRESS, cloned_mac && *cloned_mac ? cloned_mac : NULL,
NM_SETTING_WIRELESS_MODE, mode,
NM_SETTING_WIRELESS_BAND, band,
NM_SETTING_WIRELESS_CHANNEL, gtk_spin_button_get_value_as_int (priv->channel),
NM_SETTING_WIRELESS_RATE, gtk_spin_button_get_value_as_int (priv->rate),
NM_SETTING_WIRELESS_TX_POWER, gtk_spin_button_get_value_as_int (priv->tx_power),
NM_SETTING_WIRELESS_MTU, gtk_spin_button_get_value_as_int (priv->mtu),
NULL);
g_bytes_unref (ssid);
g_free (ifname);
g_free (device_mac);
}
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));
}
static void
finish_setup (CEPageSecurity *page)
{
NMConnection *connection = CE_PAGE (page)->connection;
NMSettingWireless *sw;
NMSettingWirelessSecurity *sws;
gboolean is_adhoc = FALSE;
GtkListStore *sec_model;
GtkTreeIter iter;
const gchar *mode;
const gchar *security;
guint32 dev_caps = 0;
NMUtilsSecurityType default_type = NMU_SEC_NONE;
int active = -1;
int item = 0;
GtkComboBox *combo;
GtkCellRenderer *renderer;
sw = nm_connection_get_setting_wireless (connection);
g_assert (sw);
page->group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
page->security_heading = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder, "heading_sec"));
page->security_combo = combo = GTK_COMBO_BOX (gtk_builder_get_object (CE_PAGE (page)->builder, "combo_sec"));
dev_caps = NM_WIFI_DEVICE_CAP_CIPHER_WEP40
| NM_WIFI_DEVICE_CAP_CIPHER_WEP104
| NM_WIFI_DEVICE_CAP_CIPHER_TKIP
| NM_WIFI_DEVICE_CAP_CIPHER_CCMP
| NM_WIFI_DEVICE_CAP_WPA
| NM_WIFI_DEVICE_CAP_RSN;
mode = nm_setting_wireless_get_mode (sw);
if (mode && !strcmp (mode, "adhoc"))
is_adhoc = TRUE;
page->adhoc = is_adhoc;
sws = nm_connection_get_setting_wireless_security (connection);
security = nm_setting_wireless_get_security (sw);
if (!security || strcmp (security, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME) != 0)
sws = NULL;
if (sws)
default_type = get_default_type_for_security (sws);
sec_model = gtk_list_store_new (3, G_TYPE_STRING, wireless_security_get_g_type (), G_TYPE_BOOLEAN);
if (nm_utils_security_valid (NMU_SEC_NONE, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
gtk_list_store_insert_with_values (sec_model, &iter, -1,
S_NAME_COLUMN, C_("Wi-Fi/Ethernet security", "None"),
S_ADHOC_VALID_COLUMN, TRUE,
-1);
if (default_type == NMU_SEC_NONE)
active = item;
item++;
}
if (nm_utils_security_valid (NMU_SEC_STATIC_WEP, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
WirelessSecurityWEPKey *ws_wep;
NMWepKeyType wep_type = NM_WEP_KEY_TYPE_KEY;
if (default_type == NMU_SEC_STATIC_WEP) {
sws = nm_connection_get_setting_wireless_security (connection);
if (sws)
wep_type = nm_setting_wireless_security_get_wep_key_type (sws);
if (wep_type == NM_WEP_KEY_TYPE_UNKNOWN)
wep_type = NM_WEP_KEY_TYPE_KEY;
}
ws_wep = ws_wep_key_new (connection, NM_WEP_KEY_TYPE_KEY, FALSE, FALSE);
if (ws_wep) {
add_security_item (page, WIRELESS_SECURITY (ws_wep), sec_model,
&iter, _("WEP 40/128-bit Key (Hex or ASCII)"),
TRUE);
if ((active < 0) && (default_type == NMU_SEC_STATIC_WEP) && (wep_type == NM_WEP_KEY_TYPE_KEY))
active = item;
item++;
}
ws_wep = ws_wep_key_new (connection, NM_WEP_KEY_TYPE_PASSPHRASE, FALSE, FALSE);
if (ws_wep) {
add_security_item (page, WIRELESS_SECURITY (ws_wep), sec_model,
&iter, _("WEP 128-bit Passphrase"), TRUE);
if ((active < 0) && (default_type == NMU_SEC_STATIC_WEP) && (wep_type == NM_WEP_KEY_TYPE_PASSPHRASE))
active = item;
item++;
}
}
if (nm_utils_security_valid (NMU_SEC_LEAP, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
WirelessSecurityLEAP *ws_leap;
ws_leap = ws_leap_new (connection, FALSE);
if (ws_leap) {
add_security_item (page, WIRELESS_SECURITY (ws_leap), sec_model,
&iter, _("LEAP"), FALSE);
if ((active < 0) && (default_type == NMU_SEC_LEAP))
active = item;
item++;
}
}
if (nm_utils_security_valid (NMU_SEC_DYNAMIC_WEP, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
WirelessSecurityDynamicWEP *ws_dynamic_wep;
ws_dynamic_wep = ws_dynamic_wep_new (connection, TRUE, FALSE);
if (ws_dynamic_wep) {
add_security_item (page, WIRELESS_SECURITY (ws_dynamic_wep), sec_model,
&iter, _("Dynamic WEP (802.1x)"), FALSE);
if ((active < 0) && (default_type == NMU_SEC_DYNAMIC_WEP))
active = item;
item++;
}
}
if (nm_utils_security_valid (NMU_SEC_WPA_PSK, dev_caps, FALSE, is_adhoc, 0, 0, 0) ||
nm_utils_security_valid (NMU_SEC_WPA2_PSK, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
WirelessSecurityWPAPSK *ws_wpa_psk;
ws_wpa_psk = ws_wpa_psk_new (connection, FALSE);
if (ws_wpa_psk) {
add_security_item (page, WIRELESS_SECURITY (ws_wpa_psk), sec_model,
&iter, _("WPA & WPA2 Personal"), FALSE);
if ((active < 0) && ((default_type == NMU_SEC_WPA_PSK) || (default_type == NMU_SEC_WPA2_PSK)))
active = item;
item++;
}
}
if (nm_utils_security_valid (NMU_SEC_WPA_ENTERPRISE, dev_caps, FALSE, is_adhoc, 0, 0, 0) ||
nm_utils_security_valid (NMU_SEC_WPA2_ENTERPRISE, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
WirelessSecurityWPAEAP *ws_wpa_eap;
ws_wpa_eap = ws_wpa_eap_new (connection, TRUE, FALSE);
if (ws_wpa_eap) {
add_security_item (page, WIRELESS_SECURITY (ws_wpa_eap), sec_model,
&iter, _("WPA & WPA2 Enterprise"), FALSE);
if ((active < 0) && ((default_type == NMU_SEC_WPA_ENTERPRISE) || (default_type == NMU_SEC_WPA2_ENTERPRISE)))
active = item;
item++;
}
}
gtk_combo_box_set_model (combo, GTK_TREE_MODEL (sec_model));
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo));
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer, "text", S_NAME_COLUMN, NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo), renderer, set_sensitive, &page->adhoc, NULL);
gtk_combo_box_set_active (combo, active < 0 ? 0 : (guint32) active);
g_object_unref (G_OBJECT (sec_model));
page->security_combo = combo;
security_combo_changed (combo, page);
g_signal_connect (combo, "changed",
G_CALLBACK (security_combo_changed), page);
}
CEPage *
ce_page_wireless_security_new (NMConnection *connection, GtkWindow *parent_window, GError **error)
{
CEPageWirelessSecurity *self;
CEPage *parent;
NMSettingWireless *s_wireless;
NMSettingWirelessSecurity *s_wsec = NULL;
const char *setting_name = NULL;
NMUtilsSecurityType default_type = NMU_SEC_NONE;
const char *security;
self = CE_PAGE_WIRELESS_SECURITY (g_object_new (CE_TYPE_PAGE_WIRELESS_SECURITY,
CE_PAGE_CONNECTION, connection,
CE_PAGE_PARENT_WINDOW, parent_window,
NULL));
parent = CE_PAGE (self);
s_wireless = NM_SETTING_WIRELESS (nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS));
if (!s_wireless) {
g_set_error (error, 0, 0, "%s", _("Could not load WiFi security user interface; missing WiFi setting."));
g_object_unref (self);
return NULL;
}
parent->xml = glade_xml_new (GLADEDIR "/ce-page-wireless-security.glade", "WirelessSecurityPage", NULL);
if (!parent->xml) {
g_set_error (error, 0, 0, "%s", _("Could not load WiFi security user interface."));
g_object_unref (self);
return NULL;
}
parent->page = glade_xml_get_widget (parent->xml, "WirelessSecurityPage");
if (!parent->page) {
g_set_error (error, 0, 0, "%s", _("Could not load WiFi security user interface."));
g_object_unref (self);
return NULL;
}
g_object_ref_sink (parent->page);
parent->title = g_strdup (_("Wireless Security"));
self->group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
s_wsec = NM_SETTING_WIRELESS_SECURITY (nm_connection_get_setting (connection,
NM_TYPE_SETTING_WIRELESS_SECURITY));
security = nm_setting_wireless_get_security (s_wireless);
if (!security || strcmp (security, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME))
s_wsec = NULL;
if (s_wsec)
default_type = get_default_type_for_security (s_wsec);
/* Get secrets if the connection is not 802.1x enabled */
if ( default_type == NMU_SEC_STATIC_WEP
|| default_type == NMU_SEC_LEAP
|| default_type == NMU_SEC_WPA_PSK
|| default_type == NMU_SEC_WPA2_PSK) {
setting_name = NM_SETTING_WIRELESS_SECURITY_SETTING_NAME;
}
/* Or if it is 802.1x enabled */
if ( default_type == NMU_SEC_DYNAMIC_WEP
|| default_type == NMU_SEC_WPA_ENTERPRISE
|| default_type == NMU_SEC_WPA2_ENTERPRISE) {
setting_name = NM_SETTING_802_1X_SETTING_NAME;
}
g_signal_connect (self, "initialized", G_CALLBACK (finish_setup), NULL);
if (!ce_page_initialize (parent, setting_name, error)) {
g_object_unref (self);
return NULL;
}
return CE_PAGE (self);
}
static void
ui_to_setting (CEPageVlan *self)
{
CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self);
NMConnection *connection = CE_PAGE (self)->connection;
NMSettingConnection *s_con = nm_connection_get_setting_connection (connection);
GByteArray *cloned_mac = NULL;
VlanParent *parent = NULL;
int parent_id, vid;
const char *parent_iface = NULL, *parent_uuid = NULL;
const char *slave_type;
const char *iface;
char *tmp_parent_iface = NULL;
GType hwtype;
gboolean mtu_set;
int mtu;
parent_id = gtk_combo_box_get_active (GTK_COMBO_BOX (priv->parent));
if (parent_id == -1) {
parent_iface = gtk_entry_get_text (priv->parent_entry);
tmp_parent_iface = g_strndup (parent_iface, strcspn (parent_iface, " "));
parent_iface = tmp_parent_iface;
} else {
parent = priv->parents[parent_id];
if (parent->connection)
parent_uuid = nm_connection_get_uuid (parent->connection);
if (parent->device)
parent_iface = nm_device_get_iface (parent->device);
}
g_assert (parent_uuid != NULL || parent_iface != NULL);
slave_type = nm_setting_connection_get_slave_type (s_con);
if (parent_uuid) {
/* Update NMSettingConnection:master if it's set, but don't
* set it if it's not.
*/
if (!g_strcmp0 (slave_type, NM_SETTING_VLAN_SETTING_NAME)) {
g_object_set (s_con,
NM_SETTING_CONNECTION_MASTER, parent_uuid,
NULL);
}
} else if (!g_strcmp0 (slave_type, NM_SETTING_VLAN_SETTING_NAME)) {
g_object_set (s_con,
NM_SETTING_CONNECTION_MASTER, NULL,
NM_SETTING_CONNECTION_SLAVE_TYPE, NULL,
NULL);
}
if (parent && NM_IS_DEVICE_ETHERNET (parent->device))
hwtype = NM_TYPE_SETTING_WIRED;
else
hwtype = G_TYPE_NONE;
if (priv->s_hw && G_OBJECT_TYPE (priv->s_hw) != hwtype) {
nm_connection_remove_setting (connection, G_OBJECT_TYPE (priv->s_hw));
priv->s_hw = NULL;
}
iface = gtk_entry_get_text (priv->name_entry);
vid = gtk_spin_button_get_value_as_int (priv->id_entry);
g_object_set (priv->setting,
NM_SETTING_VLAN_PARENT, parent_uuid ? parent_uuid : parent_iface,
NM_SETTING_VLAN_INTERFACE_NAME, iface,
NM_SETTING_VLAN_ID, vid,
NULL);
if (hwtype != G_TYPE_NONE) {
cloned_mac = ce_page_entry_to_mac (priv->cloned_mac, ARPHRD_ETHER, NULL);
mtu_set = g_ascii_isdigit (*gtk_entry_get_text (GTK_ENTRY (priv->mtu)));
mtu = gtk_spin_button_get_value_as_int (priv->mtu);
if (cloned_mac || mtu_set) {
if (!priv->s_hw) {
priv->s_hw = g_object_new (hwtype, NULL);
nm_connection_add_setting (connection, priv->s_hw);
}
g_object_set (priv->s_hw,
NM_SETTING_WIRED_CLONED_MAC_ADDRESS, cloned_mac,
NM_SETTING_WIRED_MTU, (guint32) mtu,
NULL);
if (cloned_mac)
g_byte_array_free (cloned_mac, TRUE);
} else if (priv->s_hw) {
nm_connection_remove_setting (connection, G_OBJECT_TYPE (priv->s_hw));
priv->s_hw = NULL;
}
}
g_free (tmp_parent_iface);
}
static void
vpn_plugin_changed_cb (NMVpnPluginUiInterface *plugin, CEPageVpn *self)
{
ce_page_changed (CE_PAGE (self));
}
static void
finish_setup (CEPageWirelessSecurity *self, gpointer unused, GError *error, gpointer user_data)
{
CEPage *parent = CE_PAGE (self);
NMSettingWireless *s_wireless;
NMSettingWirelessSecurity *s_wireless_sec;
NMConnection *connection = parent->connection;
gboolean is_adhoc = FALSE;
GtkListStore *sec_model;
GtkTreeIter iter;
const char *mode;
const char *security;
guint32 dev_caps = 0;
NMUtilsSecurityType default_type = NMU_SEC_NONE;
int active = -1;
int item = 0;
const char *glade_file = GLADEDIR "/applet.glade";
GtkComboBox *combo;
if (error)
return;
s_wireless = NM_SETTING_WIRELESS (nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS));
g_assert (s_wireless);
combo = GTK_COMBO_BOX (glade_xml_get_widget (parent->xml, "wireless_security_combo"));
dev_caps = NM_WIFI_DEVICE_CAP_CIPHER_WEP40
| NM_WIFI_DEVICE_CAP_CIPHER_WEP104
| NM_WIFI_DEVICE_CAP_CIPHER_TKIP
| NM_WIFI_DEVICE_CAP_CIPHER_CCMP
| NM_WIFI_DEVICE_CAP_WPA
| NM_WIFI_DEVICE_CAP_RSN;
mode = nm_setting_wireless_get_mode (s_wireless);
if (mode && !strcmp (mode, "adhoc"))
is_adhoc = TRUE;
s_wireless_sec = NM_SETTING_WIRELESS_SECURITY (nm_connection_get_setting (connection,
NM_TYPE_SETTING_WIRELESS_SECURITY));
security = nm_setting_wireless_get_security (s_wireless);
if (!security || strcmp (security, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME))
s_wireless_sec = NULL;
if (s_wireless_sec)
default_type = get_default_type_for_security (s_wireless_sec);
sec_model = gtk_list_store_new (2, G_TYPE_STRING, wireless_security_get_g_type ());
if (nm_utils_security_valid (NMU_SEC_NONE, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
gtk_list_store_append (sec_model, &iter);
gtk_list_store_set (sec_model, &iter,
S_NAME_COLUMN, _("None"),
-1);
if (default_type == NMU_SEC_NONE)
active = item;
item++;
}
if (nm_utils_security_valid (NMU_SEC_STATIC_WEP, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
WirelessSecurityWEPKey *ws_wep;
NMWepKeyType wep_type = NM_WEP_KEY_TYPE_KEY;
if (default_type == NMU_SEC_STATIC_WEP) {
NMSettingWirelessSecurity *s_wsec;
s_wsec = (NMSettingWirelessSecurity *) nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS_SECURITY);
if (s_wsec)
wep_type = nm_setting_wireless_security_get_wep_key_type (s_wsec);
if (wep_type == NM_WEP_KEY_TYPE_UNKNOWN)
wep_type = NM_WEP_KEY_TYPE_KEY;
}
ws_wep = ws_wep_key_new (glade_file, connection, NM_WEP_KEY_TYPE_KEY, FALSE, FALSE);
if (ws_wep) {
add_security_item (self, WIRELESS_SECURITY (ws_wep), sec_model,
&iter, _("WEP 40/128-bit Key"));
if ((active < 0) && (default_type == NMU_SEC_STATIC_WEP) && (wep_type == NM_WEP_KEY_TYPE_KEY))
active = item;
item++;
}
ws_wep = ws_wep_key_new (glade_file, connection, NM_WEP_KEY_TYPE_PASSPHRASE, FALSE, FALSE);
if (ws_wep) {
add_security_item (self, WIRELESS_SECURITY (ws_wep), sec_model,
&iter, _("WEP 128-bit Passphrase"));
if ((active < 0) && (default_type == NMU_SEC_STATIC_WEP) && (wep_type == NM_WEP_KEY_TYPE_PASSPHRASE))
active = item;
item++;
}
}
if (nm_utils_security_valid (NMU_SEC_LEAP, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
WirelessSecurityLEAP *ws_leap;
ws_leap = ws_leap_new (glade_file, connection);
if (ws_leap) {
add_security_item (self, WIRELESS_SECURITY (ws_leap), sec_model,
&iter, _("LEAP"));
if ((active < 0) && (default_type == NMU_SEC_LEAP))
active = item;
item++;
}
}
if (nm_utils_security_valid (NMU_SEC_DYNAMIC_WEP, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
WirelessSecurityDynamicWEP *ws_dynamic_wep;
ws_dynamic_wep = ws_dynamic_wep_new (glade_file, connection);
if (ws_dynamic_wep) {
add_security_item (self, WIRELESS_SECURITY (ws_dynamic_wep), sec_model,
&iter, _("Dynamic WEP (802.1x)"));
if ((active < 0) && (default_type == NMU_SEC_DYNAMIC_WEP))
active = item;
item++;
}
}
if ( nm_utils_security_valid (NMU_SEC_WPA_PSK, dev_caps, FALSE, is_adhoc, 0, 0, 0)
|| nm_utils_security_valid (NMU_SEC_WPA2_PSK, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
WirelessSecurityWPAPSK *ws_wpa_psk;
ws_wpa_psk = ws_wpa_psk_new (glade_file, connection);
if (ws_wpa_psk) {
add_security_item (self, WIRELESS_SECURITY (ws_wpa_psk), sec_model,
&iter, _("WPA & WPA2 Personal"));
if ((active < 0) && ((default_type == NMU_SEC_WPA_PSK) || (default_type == NMU_SEC_WPA2_PSK)))
active = item;
item++;
}
}
if ( nm_utils_security_valid (NMU_SEC_WPA_ENTERPRISE, dev_caps, FALSE, is_adhoc, 0, 0, 0)
|| nm_utils_security_valid (NMU_SEC_WPA2_ENTERPRISE, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
WirelessSecurityWPAEAP *ws_wpa_eap;
ws_wpa_eap = ws_wpa_eap_new (glade_file, connection);
if (ws_wpa_eap) {
add_security_item (self, WIRELESS_SECURITY (ws_wpa_eap), sec_model,
&iter, _("WPA & WPA2 Enterprise"));
if ((active < 0) && ((default_type == NMU_SEC_WPA_ENTERPRISE) || (default_type == NMU_SEC_WPA2_ENTERPRISE)))
active = item;
item++;
}
}
gtk_combo_box_set_model (combo, GTK_TREE_MODEL (sec_model));
gtk_combo_box_set_active (combo, active < 0 ? 0 : (guint32) active);
g_object_unref (G_OBJECT (sec_model));
self->security_combo = combo;
wireless_security_combo_changed (combo, self);
g_signal_connect (combo, "changed",
G_CALLBACK (wireless_security_combo_changed),
self);
}
static void
vpn_plugin_changed_cb (NMVpnEditorPlugin *plugin, CEPageVpn *self)
{
ce_page_changed (CE_PAGE (self));
}
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
ip4_private_init (CEPageIP4 *self, NMConnection *connection)
{
CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self);
GtkBuilder *builder;
GtkTreeIter iter;
NMSettingConnection *s_con;
const char *connection_type;
char *str_auto = NULL, *str_auto_only = NULL;
GList *cells;
builder = CE_PAGE (self)->builder;
s_con = nm_connection_get_setting_connection (connection);
g_assert (s_con);
connection_type = nm_setting_connection_get_connection_type (s_con);
g_assert (connection_type);
priv->connection_type = nm_setting_lookup_type (connection_type);
if (priv->connection_type == NM_TYPE_SETTING_VPN) {
str_auto = _("Automatic (VPN)");
str_auto_only = _("Automatic (VPN) addresses only");
} else if ( priv->connection_type == NM_TYPE_SETTING_GSM
|| priv->connection_type == NM_TYPE_SETTING_CDMA) {
str_auto = _("Automatic");
str_auto_only = _("Automatic, addresses only");
} else if (priv->connection_type == NM_TYPE_SETTING_PPPOE) {
str_auto = _("Automatic (PPPoE)");
str_auto_only = _("Automatic (PPPoE) addresses only");
} else {
str_auto = _("Automatic (DHCP)");
str_auto_only = _("Automatic (DHCP) addresses only");
}
priv->method = GTK_COMBO_BOX (gtk_builder_get_object (builder, "ip4_method"));
cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (priv->method));
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (priv->method), cells->data,
"sensitive", METHOD_COL_ENABLED);
priv->method_store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_BOOLEAN);
gtk_list_store_append (priv->method_store, &iter);
gtk_list_store_set (priv->method_store, &iter,
METHOD_COL_NAME, str_auto,
METHOD_COL_NUM, IP4_METHOD_AUTO,
METHOD_COL_ENABLED, TRUE,
-1);
gtk_list_store_append (priv->method_store, &iter);
gtk_list_store_set (priv->method_store, &iter,
METHOD_COL_NAME, str_auto_only,
METHOD_COL_NUM, IP4_METHOD_AUTO_ADDRESSES,
METHOD_COL_ENABLED, TRUE,
-1);
/* Manual is pointless for Mobile Broadband */
if ( priv->connection_type != NM_TYPE_SETTING_GSM
&& priv->connection_type != NM_TYPE_SETTING_CDMA
&& priv->connection_type != NM_TYPE_SETTING_VPN) {
gtk_list_store_append (priv->method_store, &iter);
gtk_list_store_set (priv->method_store, &iter,
METHOD_COL_NAME, _("Manual"),
METHOD_COL_NUM, IP4_METHOD_MANUAL,
METHOD_COL_ENABLED, TRUE,
-1);
}
/* Link-local is pointless for VPNs, Mobile Broadband, and PPPoE */
if ( priv->connection_type != NM_TYPE_SETTING_VPN
&& priv->connection_type != NM_TYPE_SETTING_PPPOE
&& priv->connection_type != NM_TYPE_SETTING_GSM
&& priv->connection_type != NM_TYPE_SETTING_CDMA) {
gtk_list_store_append (priv->method_store, &iter);
gtk_list_store_set (priv->method_store, &iter,
METHOD_COL_NAME, _("Link-Local Only"),
METHOD_COL_NUM, IP4_METHOD_LINK_LOCAL,
METHOD_COL_ENABLED, TRUE,
-1);
gtk_list_store_append (priv->method_store, &iter);
gtk_list_store_set (priv->method_store, &iter,
METHOD_COL_NAME, _("Shared to other computers"),
METHOD_COL_NUM, IP4_METHOD_SHARED,
METHOD_COL_ENABLED, TRUE,
-1);
}
/* Disabled is only supported for types that also support IPv6 */
if (connection_supports_ip6 (connection)) {
gtk_list_store_append (priv->method_store, &iter);
gtk_list_store_set (priv->method_store, &iter,
METHOD_COL_NAME, _("Disabled"),
METHOD_COL_NUM, IP4_METHOD_DISABLED,
METHOD_COL_ENABLED, TRUE,
-1);
}
gtk_combo_box_set_model (priv->method, GTK_TREE_MODEL (priv->method_store));
priv->addr_label = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_addr_label"));
priv->addr_add = GTK_BUTTON (gtk_builder_get_object (builder, "ip4_addr_add_button"));
priv->addr_delete = GTK_BUTTON (gtk_builder_get_object (builder, "ip4_addr_delete_button"));
priv->addr_list = GTK_TREE_VIEW (gtk_builder_get_object (builder, "ip4_addresses"));
priv->dns_servers_label = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_dns_servers_label"));
priv->dns_servers = GTK_ENTRY (gtk_builder_get_object (builder, "ip4_dns_servers_entry"));
priv->dns_searches_label = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_dns_searches_label"));
priv->dns_searches = GTK_ENTRY (gtk_builder_get_object (builder, "ip4_dns_searches_entry"));
priv->dhcp_client_id_label = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_dhcp_client_id_label"));
priv->dhcp_client_id = GTK_ENTRY (gtk_builder_get_object (builder, "ip4_dhcp_client_id_entry"));
/* Hide DHCP stuff if it'll never be used for a particular method */
if ( priv->connection_type == NM_TYPE_SETTING_VPN
|| priv->connection_type == NM_TYPE_SETTING_GSM
|| priv->connection_type == NM_TYPE_SETTING_CDMA
|| priv->connection_type == NM_TYPE_SETTING_PPPOE) {
gtk_widget_hide (GTK_WIDGET (priv->dhcp_client_id_label));
gtk_widget_hide (GTK_WIDGET (priv->dhcp_client_id));
}
priv->ip4_required = GTK_CHECK_BUTTON (gtk_builder_get_object (builder, "ip4_required_checkbutton"));
/* Hide IP4-require button if it'll never be used for a particular method */
if ( priv->connection_type == NM_TYPE_SETTING_VPN
|| priv->connection_type == NM_TYPE_SETTING_GSM
|| priv->connection_type == NM_TYPE_SETTING_CDMA
|| priv->connection_type == NM_TYPE_SETTING_PPPOE)
gtk_widget_hide (GTK_WIDGET (priv->ip4_required));
priv->routes_button = GTK_BUTTON (gtk_builder_get_object (builder, "ip4_routes_button"));
}
static void
connect_ip6_page (CEPageIP6 *page)
{
GtkWidget *content;
const gchar *str_method;
gboolean disabled;
GtkListStore *store;
GtkTreeIter iter;
guint method;
add_address_section (page);
add_dns_section (page);
add_routes_section (page);
page->enabled = GTK_SWITCH (gtk_builder_get_object (CE_PAGE (page)->builder, "switch_enable"));
g_signal_connect (page->enabled, "notify::active", G_CALLBACK (switch_toggled), page);
str_method = nm_setting_ip6_config_get_method (page->setting);
disabled = g_strcmp0 (str_method, NM_SETTING_IP6_CONFIG_METHOD_IGNORE) == 0;
gtk_switch_set_active (page->enabled, !disabled);
g_signal_connect_swapped (page->enabled, "notify::active", G_CALLBACK (ce_page_changed), page);
content = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder, "page_content"));
g_object_bind_property (page->enabled, "active",
content, "sensitive",
G_BINDING_SYNC_CREATE);
page->method = GTK_COMBO_BOX (gtk_builder_get_object (CE_PAGE (page)->builder, "combo_addresses"));
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_UINT);
gtk_list_store_insert_with_values (store, &iter, -1,
METHOD_COL_NAME, _("Automatic"),
METHOD_COL_METHOD, IP6_METHOD_AUTO,
-1);
gtk_list_store_insert_with_values (store, &iter, -1,
METHOD_COL_NAME, _("Automatic, DHCP only"),
METHOD_COL_METHOD, IP6_METHOD_DHCP,
-1);
gtk_list_store_insert_with_values (store, &iter, -1,
METHOD_COL_NAME, _("Manual"),
METHOD_COL_METHOD, IP6_METHOD_MANUAL,
-1);
gtk_list_store_insert_with_values (store, &iter, -1,
METHOD_COL_NAME, _("Link-Local Only"),
METHOD_COL_METHOD, IP6_METHOD_LINK_LOCAL,
-1);
gtk_combo_box_set_model (page->method, GTK_TREE_MODEL (store));
method = IP6_METHOD_AUTO;
if (g_strcmp0 (str_method, NM_SETTING_IP6_CONFIG_METHOD_DHCP) == 0) {
method = IP6_METHOD_DHCP;
} else if (g_strcmp0 (str_method, NM_SETTING_IP6_CONFIG_METHOD_LINK_LOCAL) == 0) {
method = IP6_METHOD_LINK_LOCAL;
} else if (g_strcmp0 (str_method, NM_SETTING_IP6_CONFIG_METHOD_MANUAL) == 0) {
method = IP6_METHOD_MANUAL;
} else if (g_strcmp0 (str_method, NM_SETTING_IP6_CONFIG_METHOD_SHARED) == 0) {
method = IP6_METHOD_SHARED;
} else if (g_strcmp0 (str_method, NM_SETTING_IP6_CONFIG_METHOD_IGNORE) == 0) {
method = IP6_METHOD_IGNORE;
}
page->never_default = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder, "never_default_check"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (page->never_default),
nm_setting_ip6_config_get_never_default (page->setting));
g_signal_connect (page->method, "changed", G_CALLBACK (method_changed), page);
if (method != IP6_METHOD_SHARED && method != IP6_METHOD_IGNORE)
gtk_combo_box_set_active (page->method, method);
}
static void
method_changed (GtkComboBox *combo, gpointer user_data)
{
CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (user_data);
guint32 method = IP4_METHOD_AUTO;
gboolean addr_enabled = FALSE;
gboolean dns_enabled = FALSE;
gboolean dhcp_enabled = FALSE;
gboolean routes_enabled = FALSE;
gboolean ip4_required_enabled = TRUE;
gboolean method_auto = FALSE;
GtkTreeIter iter;
if (gtk_combo_box_get_active_iter (priv->method, &iter)) {
gtk_tree_model_get (GTK_TREE_MODEL (priv->method_store), &iter,
METHOD_COL_NUM, &method, -1);
}
switch (method) {
case IP4_METHOD_AUTO:
addr_enabled = FALSE;
dhcp_enabled = routes_enabled = TRUE;
dns_enabled = TRUE;
method_auto = TRUE;
break;
case IP4_METHOD_AUTO_ADDRESSES:
addr_enabled = FALSE;
dns_enabled = dhcp_enabled = routes_enabled = TRUE;
break;
case IP4_METHOD_MANUAL:
addr_enabled = dns_enabled = routes_enabled = TRUE;
break;
case IP4_METHOD_DISABLED:
addr_enabled = dns_enabled = dhcp_enabled = routes_enabled = ip4_required_enabled = FALSE;
default:
break;
}
/* Disable DHCP stuff for VPNs (though in the future we should support
* DHCP over tap interfaces for OpenVPN and vpnc).
*/
if ( priv->connection_type == NM_TYPE_SETTING_VPN
|| priv->connection_type == NM_TYPE_SETTING_GSM
|| priv->connection_type == NM_TYPE_SETTING_CDMA
|| priv->connection_type == NM_TYPE_SETTING_PPPOE)
dhcp_enabled = FALSE;
gtk_widget_set_sensitive (priv->addr_label, addr_enabled);
gtk_widget_set_sensitive (GTK_WIDGET (priv->addr_add), addr_enabled);
gtk_widget_set_sensitive (GTK_WIDGET (priv->addr_delete), addr_enabled);
gtk_widget_set_sensitive (GTK_WIDGET (priv->addr_list), addr_enabled);
if (!addr_enabled) {
GtkListStore *store;
store = GTK_LIST_STORE (gtk_tree_view_get_model (priv->addr_list));
gtk_list_store_clear (store);
}
gtk_widget_set_sensitive (priv->dns_servers_label, dns_enabled);
if (method_auto)
gtk_label_set_text_with_mnemonic (GTK_LABEL (priv->dns_servers_label), _("Additional DNS ser_vers:"));
else
gtk_label_set_text_with_mnemonic (GTK_LABEL (priv->dns_servers_label), _("DNS ser_vers:"));
gtk_widget_set_sensitive (GTK_WIDGET (priv->dns_servers), dns_enabled);
if (!dns_enabled)
gtk_entry_set_text (priv->dns_servers, "");
gtk_widget_set_sensitive (priv->dns_searches_label, dns_enabled);
if (method_auto)
gtk_label_set_text_with_mnemonic (GTK_LABEL (priv->dns_searches_label), _("Additional s_earch domains:"));
else
gtk_label_set_text_with_mnemonic (GTK_LABEL (priv->dns_searches_label), _("S_earch domains:"));
gtk_widget_set_sensitive (GTK_WIDGET (priv->dns_searches), dns_enabled);
if (!dns_enabled)
gtk_entry_set_text (priv->dns_searches, "");
gtk_widget_set_sensitive (priv->dhcp_client_id_label, dhcp_enabled);
gtk_widget_set_sensitive (GTK_WIDGET (priv->dhcp_client_id), dhcp_enabled);
if (!dhcp_enabled)
gtk_entry_set_text (priv->dhcp_client_id, "");
gtk_widget_set_sensitive (GTK_WIDGET (priv->ip4_required), ip4_required_enabled);
gtk_widget_set_sensitive (GTK_WIDGET (priv->routes_button), routes_enabled);
ce_page_changed (CE_PAGE (user_data));
}
static void
ui_to_setting (CEPageBond *self)
{
CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self);
NMConnection *connection = CE_PAGE (self)->connection;
const char *mode;
const char *frequency;
const char *updelay;
const char *downdelay;
const char *primary = NULL;
char *targets;
guint32 mtu;
/* Mode */
switch (gtk_combo_box_get_active (priv->mode)) {
case MODE_BALANCE_RR:
mode = "balance-rr";
break;
case MODE_ACTIVE_BACKUP:
mode = "active-backup";
primary = gtk_entry_get_text (priv->primary);
break;
case MODE_BALANCE_XOR:
mode = "balance-xor";
break;
case MODE_BROADCAST:
mode = "broadcast";
break;
case MODE_802_3AD:
mode = "802.3ad";
break;
case MODE_BALANCE_TLB:
mode = "balance-tlb";
break;
case MODE_BALANCE_ALB:
mode = "balance-alb";
break;
default:
g_assert_not_reached ();
break;
}
/* Set bond mode and primary */
nm_setting_bond_add_option (priv->setting, NM_SETTING_BOND_OPTION_MODE, mode);
if (primary && *primary)
nm_setting_bond_add_option (priv->setting, NM_SETTING_BOND_OPTION_PRIMARY, primary);
else
nm_setting_bond_remove_option (priv->setting, NM_SETTING_BOND_OPTION_PRIMARY);
/* Monitoring mode/frequency */
frequency = gtk_entry_get_text (GTK_ENTRY (priv->frequency));
updelay = gtk_entry_get_text (GTK_ENTRY (priv->updelay));
downdelay = gtk_entry_get_text (GTK_ENTRY (priv->downdelay));
targets = uglify_targets (gtk_entry_get_text (priv->arp_targets));
switch (gtk_combo_box_get_active (priv->monitoring)) {
case MONITORING_MII:
nm_setting_bond_add_option (priv->setting, NM_SETTING_BOND_OPTION_MIIMON, frequency);
nm_setting_bond_add_option (priv->setting, NM_SETTING_BOND_OPTION_UPDELAY, updelay);
nm_setting_bond_add_option (priv->setting, NM_SETTING_BOND_OPTION_DOWNDELAY, downdelay);
nm_setting_bond_remove_option (priv->setting, NM_SETTING_BOND_OPTION_ARP_INTERVAL);
nm_setting_bond_remove_option (priv->setting, NM_SETTING_BOND_OPTION_ARP_IP_TARGET);
break;
case MONITORING_ARP:
nm_setting_bond_add_option (priv->setting, NM_SETTING_BOND_OPTION_ARP_INTERVAL, frequency);
if (targets)
nm_setting_bond_add_option (priv->setting, NM_SETTING_BOND_OPTION_ARP_IP_TARGET, targets);
else
nm_setting_bond_remove_option (priv->setting, NM_SETTING_BOND_OPTION_ARP_IP_TARGET);
nm_setting_bond_remove_option (priv->setting, NM_SETTING_BOND_OPTION_MIIMON);
nm_setting_bond_remove_option (priv->setting, NM_SETTING_BOND_OPTION_UPDELAY);
nm_setting_bond_remove_option (priv->setting, NM_SETTING_BOND_OPTION_DOWNDELAY);
break;
default:
g_assert_not_reached ();
break;
}
g_free (targets);
mtu = gtk_spin_button_get_value_as_int (priv->mtu);
if (mtu && !priv->wired) {
priv->wired = NM_SETTING_WIRED (nm_setting_wired_new ());
nm_connection_add_setting (connection, NM_SETTING (priv->wired));
}
if (priv->wired)
g_object_set (priv->wired, NM_SETTING_WIRED_MTU, mtu, NULL);
}
static void
cell_edited (GtkCellRendererText *cell,
const gchar *path_string,
const gchar *new_text,
gpointer user_data)
{
CEPageIP4 *self = CE_PAGE_IP4 (user_data);
CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self);
GtkListStore *store = GTK_LIST_STORE (gtk_tree_view_get_model (priv->addr_list));
GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
GtkTreeIter iter;
guint32 column;
GtkTreeViewColumn *next_col;
GtkCellRenderer *next_cell;
gboolean can_cycle;
int direction, tmp;
/* Free auxiliary stuff */
g_free (priv->last_edited);
priv->last_edited = NULL;
g_free (priv->last_path);
priv->last_path = NULL;
priv->last_column = -1;
column = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (cell), "column"));
gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path);
gtk_list_store_set (store, &iter, column, new_text, -1);
/* Try to autodetect the prefix from the given address if we can */
if (column == COL_ADDRESS && new_text && strlen (new_text)) {
char *prefix = NULL;
const char *guess_prefix = NULL;
gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (store), &iter, path_string);
gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, COL_PREFIX, &prefix, -1);
if (!prefix || !strlen (prefix)) {
if (!strncmp ("10.", new_text, 3))
guess_prefix = "8";
else if (!strncmp ("172.16.", new_text, 7))
guess_prefix = "16";
else if (!strncmp ("192.168.", new_text, 8))
guess_prefix = "24";
if (guess_prefix)
gtk_list_store_set (store, &iter, COL_PREFIX, guess_prefix, -1);
}
g_free (prefix);
}
/* Move focus to the next/previous column */
can_cycle = g_object_get_data (G_OBJECT (cell), DO_NOT_CYCLE_TAG) == NULL;
direction = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), DIRECTION_TAG));
g_object_set_data (G_OBJECT (cell), DIRECTION_TAG, NULL);
g_object_set_data (G_OBJECT (cell), DO_NOT_CYCLE_TAG, NULL);
if (direction == 0) /* Move forward by default */
direction = 1;
tmp = column + direction;
if (can_cycle)
column = tmp < 0 ? COL_LAST : tmp > COL_LAST ? 0 : tmp;
else
column = tmp;
next_col = gtk_tree_view_get_column (priv->addr_list, column);
next_cell = column <= COL_LAST ? priv->addr_cells[column] : NULL;
gtk_tree_view_set_cursor_on_cell (priv->addr_list, path, next_col, next_cell, TRUE);
gtk_tree_path_free (path);
ce_page_changed (CE_PAGE (self));
}
static void
connect_wifi_page (CEPageWifi *page)
{
NMSettingConnection *sc;
GtkWidget *widget;
const GByteArray *ssid;
gchar *utf8_ssid;
GPtrArray *bssid_array;
gchar **bssid_list;
const GByteArray *s_bssid;
gchar *s_bssid_str;
gchar **mac_list;
const GByteArray *s_mac;
gchar *s_mac_str;
gint i;
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder,
"entry_ssid"));
ssid = nm_setting_wireless_get_ssid (page->setting);
if (ssid)
utf8_ssid = nm_utils_ssid_to_utf8 (ssid);
else
utf8_ssid = g_strdup ("");
gtk_entry_set_text (GTK_ENTRY (widget), utf8_ssid);
g_free (utf8_ssid);
g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page);
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder,
"combo_bssid"));
bssid_array = g_ptr_array_new ();
for (i = 0; i < nm_setting_wireless_get_num_seen_bssids (page->setting); i++) {
g_ptr_array_add (bssid_array, g_strdup (nm_setting_wireless_get_seen_bssid (page->setting, i)));
}
g_ptr_array_add (bssid_array, NULL);
bssid_list = (gchar **) g_ptr_array_free (bssid_array, FALSE);
s_bssid = nm_setting_wireless_get_bssid (page->setting);
s_bssid_str = s_bssid ? nm_utils_hwaddr_ntoa (s_bssid->data, ARPHRD_ETHER) : NULL;
ce_page_setup_mac_combo (GTK_COMBO_BOX_TEXT (widget), s_bssid_str, bssid_list);
g_free (s_bssid_str);
g_strfreev (bssid_list);
g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page);
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder,
"combo_mac"));
mac_list = ce_page_get_mac_list (CE_PAGE (page)->client, NM_TYPE_DEVICE_WIFI,
NM_DEVICE_WIFI_PERMANENT_HW_ADDRESS);
s_mac = nm_setting_wireless_get_mac_address (page->setting);
s_mac_str = s_mac ? nm_utils_hwaddr_ntoa (s_mac->data, ARPHRD_ETHER) : NULL;
ce_page_setup_mac_combo (GTK_COMBO_BOX_TEXT (widget), s_mac_str, mac_list);
g_free (s_mac_str);
g_strfreev (mac_list);
g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page);
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder,
"entry_cloned_mac"));
ce_page_mac_to_entry (nm_setting_wireless_get_cloned_mac_address (page->setting),
ARPHRD_ETHER, GTK_ENTRY (widget));
g_signal_connect_swapped (widget, "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);
}
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);
}
