static void
device_combo_changed (GtkWidget *combo,
gpointer user_data)
{
NMAWirelessDialog *self = NMA_WIRELESS_DIALOG (user_data);
NMAWirelessDialogPrivate *priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self);
GtkTreeIter iter;
GtkTreeModel *model;
gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter);
model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
g_object_unref (priv->device);
gtk_tree_model_get (model, &iter, D_DEV_COLUMN, &priv->device, -1);
if (!connection_combo_init (self, NULL)) {
g_warning ("Couldn't change connection combo box.");
return;
}
if (!security_combo_init (self)) {
g_warning ("Couldn't change wireless security combo box.");
return;
}
security_combo_changed (priv->sec_combo, self);
}
static void
ssid_entry_changed (GtkWidget *entry, gpointer user_data)
{
NMAWirelessDialog *self = NMA_WIRELESS_DIALOG (user_data);
NMAWirelessDialogPrivate *priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self);
GtkTreeIter iter;
WirelessSecurity *sec = NULL;
GtkTreeModel *model;
gboolean valid = FALSE;
GByteArray *ssid;
ssid = validate_dialog_ssid (self);
if (!ssid)
goto out;
model = gtk_combo_box_get_model (GTK_COMBO_BOX (priv->sec_combo));
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (priv->sec_combo), &iter))
gtk_tree_model_get (model, &iter, S_SEC_COLUMN, &sec, -1);
if (sec) {
valid = wireless_security_validate (sec, ssid);
wireless_security_unref (sec);
} else {
valid = TRUE;
}
out:
gtk_dialog_set_response_sensitive (GTK_DIALOG (self), GTK_RESPONSE_OK, valid);
}
static void
stuff_changed_cb (WirelessSecurity *sec, gpointer user_data)
{
NMAWirelessDialog *self = NMA_WIRELESS_DIALOG (user_data);
NMAWirelessDialogPrivate *priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self);
GByteArray *ssid = NULL;
gboolean free_ssid = TRUE;
gboolean valid = FALSE;
if (priv->connection) {
NMSettingWireless *s_wireless;
s_wireless = NM_SETTING_WIRELESS (nm_connection_get_setting (priv->connection, NM_TYPE_SETTING_WIRELESS));
g_assert (s_wireless);
ssid = (GByteArray *) nm_setting_wireless_get_ssid (s_wireless);
free_ssid = FALSE;
} else {
ssid = validate_dialog_ssid (self);
}
if (ssid) {
valid = wireless_security_validate (sec, ssid);
if (free_ssid)
g_byte_array_free (ssid, TRUE);
}
gtk_dialog_set_response_sensitive (GTK_DIALOG (self), GTK_RESPONSE_OK, valid);
}
static gboolean
revalidate (gpointer user_data)
{
NMAWirelessDialog *self = NMA_WIRELESS_DIALOG (user_data);
NMAWirelessDialogPrivate *priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self);
security_combo_changed (priv->sec_combo, self);
return FALSE;
}
static void
nag_dialog_response_cb (GtkDialog *nag_dialog,
gint response,
gpointer user_data)
{
NMAWirelessDialog *wireless_dialog = NMA_WIRELESS_DIALOG (user_data);
if (response == GTK_RESPONSE_NO) { /* user opted not to correct the warning */
nma_wireless_dialog_set_nag_ignored (wireless_dialog, TRUE);
gtk_dialog_response (GTK_DIALOG (wireless_dialog), GTK_RESPONSE_OK);
}
}
static void
security_combo_changed (GtkWidget *combo,
gpointer user_data)
{
NMAWirelessDialog *self = NMA_WIRELESS_DIALOG (user_data);
NMAWirelessDialogPrivate *priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self);
GtkWidget *vbox;
GList *elt, *children;
GtkTreeIter iter;
GtkTreeModel *model;
WirelessSecurity *sec = NULL;
GtkWidget *sec_widget;
vbox = GTK_WIDGET (gtk_builder_get_object (priv->builder, "security_vbox"));
g_assert (vbox);
size_group_clear (priv->group);
/* Remove any previous wireless security widgets */
children = gtk_container_get_children (GTK_CONTAINER (vbox));
for (elt = children; elt; elt = g_list_next (elt))
gtk_container_remove (GTK_CONTAINER (vbox), GTK_WIDGET (elt->data));
model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter)) {
g_warning ("%s: no active security combo box item.", __func__);
return;
}
gtk_tree_model_get (model, &iter, S_SEC_COLUMN, &sec, -1);
if (!sec)
return;
sec_widget = wireless_security_get_widget (sec);
g_assert (sec_widget);
size_group_add_permanent (priv->group, priv->builder);
wireless_security_add_to_size_group (sec, priv->group);
if (gtk_widget_get_parent (sec_widget))
gtk_widget_reparent (sec_widget, vbox);
else
gtk_container_add (GTK_CONTAINER (vbox), sec_widget);
wireless_security_unref (sec);
/* Re-validate */
wireless_security_changed_cb (NULL, sec);
}
static void
connection_combo_changed (GtkWidget *combo,
gpointer user_data)
{
NMAWirelessDialog *self = NMA_WIRELESS_DIALOG (user_data);
NMAWirelessDialogPrivate *priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self);
GtkTreeIter iter;
GtkTreeModel *model;
gboolean is_new = FALSE;
NMSettingWireless *s_wireless;
char *utf8_ssid;
GtkWidget *widget;
gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter);
model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
if (priv->connection)
g_object_unref (priv->connection);
gtk_tree_model_get (model, &iter,
C_CON_COLUMN, &priv->connection,
C_NEW_COLUMN, &is_new, -1);
if (!security_combo_init (self)) {
g_warning ("Couldn't change wireless security combo box.");
return;
}
security_combo_changed (priv->sec_combo, self);
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "network_name_entry"));
if (priv->connection) {
const GByteArray *ssid;
s_wireless = NM_SETTING_WIRELESS (nm_connection_get_setting (priv->connection, NM_TYPE_SETTING_WIRELESS));
ssid = nm_setting_wireless_get_ssid (s_wireless);
utf8_ssid = nm_utils_ssid_to_utf8 ((const char *) ssid->data, ssid->len);
gtk_entry_set_text (GTK_ENTRY (widget), utf8_ssid);
g_free (utf8_ssid);
} else {
gtk_entry_set_text (GTK_ENTRY (widget), "");
}
gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (priv->builder, "network_name_entry")), is_new);
gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (priv->builder, "network_name_label")), is_new);
gtk_widget_set_sensitive (priv->sec_combo, is_new);
gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (priv->builder, "security_combo_label")), is_new);
gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (priv->builder, "security_vbox")), is_new);
}
GtkWidget *
nma_wireless_dialog_new (NMClient *client,
NMConnection *connection,
NMDevice *device,
NMAccessPoint *ap)
{
NMAWirelessDialog *self;
NMAWirelessDialogPrivate *priv;
guint32 dev_caps;
g_return_val_if_fail (NM_IS_CLIENT (client), NULL);
g_return_val_if_fail (NM_IS_CONNECTION (connection), NULL);
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), NULL);
/* Ensure device validity */
dev_caps = nm_device_get_capabilities (device);
g_return_val_if_fail (dev_caps & NM_DEVICE_CAP_NM_SUPPORTED, NULL);
g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), NULL);
self = NMA_WIRELESS_DIALOG (g_object_new (NMA_TYPE_WIRELESS_DIALOG, NULL));
if (!self)
return NULL;
priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self);
priv->client = g_object_ref (client);
priv->ap = g_object_ref (ap);
if (!internal_init (self, connection, device, TRUE, FALSE)) {
nm_warning ("Couldn't create wireless security dialog.");
g_object_unref (self);
return NULL;
}
return GTK_WIDGET (self);
}
static void
secrets_requested (NMConnectionItem *item,
NMConnection *connection,
const char *setting_name,
const char **hints,
gboolean ask_user,
NMNewSecretsRequestedFunc callback,
gpointer callback_data)
{
GtkWidget *dialog;
SecretsRequestInfo *info;
dialog = nma_wireless_dialog_new (nm_connection_item_get_client (item),
connection,
nm_device_item_get_device (NM_DEVICE_ITEM (item)),
nm_wifi_item_get_ap (NM_WIFI_ITEM (item)));
info = g_new (SecretsRequestInfo, 1);
info->callback = callback;
info->callback_data = callback_data;
g_signal_connect (dialog, "done", G_CALLBACK (connection_secrets_response_cb), info);
nma_wireless_dialog_show (NMA_WIRELESS_DIALOG (dialog));
}
GtkWidget *
nma_wireless_dialog_hidden_new (NMClient *client)
{
NMAWirelessDialog *self;
NMAWirelessDialogPrivate *priv;
g_return_val_if_fail (NM_IS_CLIENT (client), NULL);
self = NMA_WIRELESS_DIALOG (g_object_new (NMA_TYPE_WIRELESS_DIALOG, NULL));
if (!self)
return NULL;
priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self);
priv->client = g_object_ref (client);
if (!internal_init (self, NULL, NULL, FALSE, FALSE)) {
nm_warning ("Couldn't create wireless security dialog.");
g_object_unref (self);
return NULL;
}
return GTK_WIDGET (self);
}
static void
wireless_dialog_response_cb (GtkDialog *foo,
gint response,
gpointer user_data)
{
NMAWirelessDialog *dialog = NMA_WIRELESS_DIALOG (foo);
WirelessDialogClosure *closure = user_data;
NMConnection *connection, *fuzzy_match = NULL;
NMDevice *device;
NMAccessPoint *ap;
GSList *all, *iter;
if (response != GTK_RESPONSE_OK)
goto done;
if (!nma_wireless_dialog_get_nag_ignored (dialog)) {
GtkWidget *nag_dialog;
/* Nag the user about certificates or whatever. Only destroy the dialog
* if no nagging was done.
*/
nag_dialog = nma_wireless_dialog_nag_user (dialog);
if (nag_dialog) {
gtk_window_set_transient_for (GTK_WINDOW (nag_dialog), GTK_WINDOW (dialog));
g_signal_connect (nag_dialog, "response",
G_CALLBACK (nag_dialog_response_cb),
dialog);
return;
}
}
/* nma_wireless_dialog_get_connection() returns a connection with the
* refcount incremented, so the caller must remember to unref it.
*/
connection = nma_wireless_dialog_get_connection (dialog, &device, &ap);
g_assert (connection);
g_assert (device);
/* Find a similar connection and use that instead */
all = nm_remote_settings_list_connections (closure->settings);
for (iter = all; iter; iter = g_slist_next (iter)) {
if (nm_connection_compare (connection,
NM_CONNECTION (iter->data),
(NM_SETTING_COMPARE_FLAG_FUZZY | NM_SETTING_COMPARE_FLAG_IGNORE_ID))) {
fuzzy_match = NM_CONNECTION (iter->data);
break;
}
}
g_slist_free (all);
if (fuzzy_match) {
nm_client_activate_connection (closure->client,
fuzzy_match,
device,
ap ? nm_object_get_path (NM_OBJECT (ap)) : NULL,
activate_existing_cb,
NULL);
} else {
NMSetting *s_con;
NMSettingWireless *s_wifi;
const char *mode = NULL;
/* Entirely new connection */
/* Don't autoconnect adhoc networks by default for now */
s_wifi = (NMSettingWireless *) nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS);
if (s_wifi)
mode = nm_setting_wireless_get_mode (s_wifi);
if (g_strcmp0 (mode, "adhoc") == 0) {
s_con = nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION);
if (!s_con) {
s_con = nm_setting_connection_new ();
nm_connection_add_setting (connection, s_con);
}
g_object_set (G_OBJECT (s_con), NM_SETTING_CONNECTION_AUTOCONNECT, FALSE, NULL);
}
nm_client_add_and_activate_connection (closure->client,
connection,
device,
ap ? nm_object_get_path (NM_OBJECT (ap)) : NULL,
activate_new_cb,
NULL);
}
/* Balance nma_wireless_dialog_get_connection() */
g_object_unref (connection);
done:
gtk_widget_hide (GTK_WIDGET (dialog));
gtk_widget_destroy (GTK_WIDGET (dialog));
}
static void
dialog_response (GtkDialog *dialog,
gint response,
gpointer user_data)
{
NMAWirelessDialog *self = NMA_WIRELESS_DIALOG (user_data);
NMAWirelessDialogPrivate *priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self);
NMSetting *setting;
GtkTreeModel *model;
GtkTreeIter iter;
WirelessSecurity *sec = NULL;
if (response != GTK_RESPONSE_OK)
goto out;
if (!priv->connection) {
/* Create new connection */
char *id;
char *uuid;
GByteArray *ssid;
priv->connection = nm_connection_new ();
/* Wireless setting */
setting = nm_setting_wireless_new ();
ssid = validate_dialog_ssid (self);
g_object_set (setting, NM_SETTING_WIRELESS_SSID, ssid, NULL);
nm_connection_add_setting (priv->connection, setting);
if (ssid) {
id = nm_utils_ssid_to_utf8 ((char *) ssid->data, ssid->len);
g_byte_array_free (ssid, TRUE);
} else
id = NULL;
/* Connection setting */
setting = nm_setting_connection_new ();
uuid = nm_utils_uuid_generate ();
/* FIXME: don't autoconnect until the connection is successful at least once */
/* Don't autoconnect adhoc networks by default for now */
g_object_set (setting,
NM_SETTING_CONNECTION_TYPE, NM_SETTING_WIRELESS_SETTING_NAME,
NM_SETTING_CONNECTION_UUID, uuid,
NM_SETTING_CONNECTION_ID, id,
NM_SETTING_CONNECTION_AUTOCONNECT, !priv->adhoc_create,
NULL);
g_free (uuid);
g_free (id);
nm_connection_add_setting (priv->connection, setting);
/* IPv4 setting */
if (priv->adhoc_create) {
g_object_set (setting, NM_SETTING_WIRELESS_MODE, "adhoc", NULL);
setting = nm_setting_ip4_config_new ();
g_object_set (setting,
NM_SETTING_IP4_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_SHARED,
NULL);
nm_connection_add_setting (priv->connection, setting);
}
}
model = gtk_combo_box_get_model (GTK_COMBO_BOX (priv->sec_combo));
gtk_combo_box_get_active_iter (GTK_COMBO_BOX (priv->sec_combo), &iter);
gtk_tree_model_get (model, &iter, S_SEC_COLUMN, &sec, -1);
if (sec && !priv->nag_ignored) {
GtkWidget *nag_dialog;
/* Nag the user about certificates or whatever. Only destroy the dialog
* if no nagging was done.
*/
nag_dialog = wireless_security_nag_user (sec);
if (nag_dialog) {
gtk_window_set_transient_for (GTK_WINDOW (nag_dialog), GTK_WINDOW (dialog));
g_signal_connect (nag_dialog, "response",
G_CALLBACK (nag_dialog_response_cb),
dialog);
return;
}
}
/* Fill security */
if (sec) {
wireless_security_fill_connection (sec, priv->connection);
wireless_security_unref (sec);
} else {
/* Unencrypted */
setting = nm_connection_get_setting (priv->connection, NM_TYPE_SETTING_WIRELESS);
g_object_set (setting, NM_SETTING_WIRELESS_SEC, NULL, NULL);
}
out:
g_signal_emit (self, signals[DONE], 0, response);
nm_utils_dialog_done ();
/* FIXME: clear security? */
}
