// SPDX-License-Identifier: GPL-2.0+
/* NetworkManager Connection editor -- Connection editor for NetworkManager
*
* Copyright 2020 Red Hat, Inc.
*/
#include "nm-default.h"
#include <string.h>
#include "page-wireguard.h"
#include "nm-connection-editor.h"
#include "nma-ui-utils.h"
G_DEFINE_TYPE (CEPageWireGuard, ce_page_wireguard, CE_TYPE_PAGE)
#define CE_PAGE_WIREGUARD_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), CE_TYPE_PAGE_WIREGUARD, CEPageWireGuardPrivate))
typedef struct {
NMWireGuardPeer *peer;
GtkInfoBar *info_bar;
GtkLabel *label_info;
GtkButton *button_apply;
GtkBuilder *builder;
GtkEntry *entry_public_key;
GtkEntry *entry_allowed_ips;
GtkEntry *entry_endpoint;
GtkEntry *entry_psk;
GtkSpinButton *spin_persistent_keepalive;
GtkToggleButton *toggle_show_psk;
} PeerDialogData;
typedef struct {
NMSettingWireGuard *setting;
NMWireGuardPeer *dialog_peer;
int dialog_peer_index;
GtkEntry *entry_ifname;
GtkEntry *entry_pk;
GtkSpinButton *spin_mtu;
GtkSpinButton *spin_fwmark;
GtkSpinButton *spin_listen_port;
GtkToggleButton *toggle_peer_routes;
GtkToggleButton *toggle_show_pk;
GtkButton *button_add;
GtkButton *button_delete;
GtkTreeView *tree;
GtkTreeStore *store;
} CEPageWireGuardPrivate;
enum {
COL_PUBLIC_KEY,
COL_ALLOWED_IPS,
N_COLUMNS,
};
static void
peer_dialog_data_destroy (PeerDialogData *data)
{
g_object_unref (data->builder);
nm_wireguard_peer_unref (data->peer);
g_free (data);
}
static char *
format_allowed_ips (NMWireGuardPeer *peer)
{
guint i, len;
GString *string = NULL;
len = nm_wireguard_peer_get_allowed_ips_len (peer);
for (i = 0; i < len; i++) {
if (!string)
string = g_string_new ("");
else
g_string_append_c (string, ',');
g_string_append (string, nm_wireguard_peer_get_allowed_ip (peer, i, NULL));
}
return string ? g_string_free (string, FALSE) : NULL;
}
static void
peer_dialog_update_ui (GtkWidget *dialog)
{
PeerDialogData *data;
gs_free char *allowed_ips = NULL;
data = g_object_get_data (G_OBJECT (dialog), "data");
g_return_if_fail (data && data->peer);
allowed_ips = format_allowed_ips (data->peer);
gtk_entry_set_text (data->entry_public_key, nm_wireguard_peer_get_public_key (data->peer) ?: "");
gtk_entry_set_text (data->entry_allowed_ips, allowed_ips ?: "");
gtk_entry_set_text (data->entry_endpoint, nm_wireguard_peer_get_endpoint (data->peer) ?: "");
gtk_spin_button_set_value (data->spin_persistent_keepalive, nm_wireguard_peer_get_persistent_keepalive (data->peer));
gtk_entry_set_text (data->entry_psk, nm_wireguard_peer_get_preshared_key (data->peer) ?: "");
nma_utils_update_password_storage (GTK_WIDGET (data->entry_psk),
nm_wireguard_peer_get_preshared_key_flags (data->peer),
NULL,
NULL);
}
static void
peer_dialog_update_peer (GtkWidget *dialog)
{
PeerDialogData *data;
const char *pk;
const char *allowed_ips;
const char *endpoint;
const char *psk;
char **strv;
guint i;
int keepalive;
NMSettingSecretFlags secret_flags;
data = g_object_get_data (G_OBJECT (dialog), "data");
g_return_if_fail (data && data->peer);
pk = gtk_entry_get_text (data->entry_public_key);
nm_wireguard_peer_set_public_key (data->peer, pk && pk[0] ? pk : NULL, TRUE);
nm_wireguard_peer_clear_allowed_ips (data->peer);
allowed_ips = gtk_entry_get_text (data->entry_allowed_ips);
strv = g_strsplit (allowed_ips, ",", -1);
for (i = 0; strv && strv[i]; i++)
nm_wireguard_peer_append_allowed_ip (data->peer, g_strstrip (strv[i]), TRUE);
g_strfreev (strv);
endpoint = gtk_entry_get_text (data->entry_endpoint);
nm_wireguard_peer_set_endpoint (data->peer, endpoint && endpoint[0] ? endpoint : NULL, TRUE);
keepalive = gtk_spin_button_get_value_as_int (data->spin_persistent_keepalive);
nm_wireguard_peer_set_persistent_keepalive (data->peer, keepalive);
psk = gtk_entry_get_text (data->entry_psk);
nm_wireguard_peer_set_preshared_key (data->peer, psk && psk[0] ? psk : NULL, TRUE);
secret_flags = nma_utils_menu_to_secret_flags ((GtkWidget *) data->entry_psk);
nm_wireguard_peer_set_preshared_key_flags (data->peer, secret_flags);
}
static void
peer_dialog_apply_clicked (GtkWidget *dialog)
{
PeerDialogData *data;
gs_free_error GError *error = NULL;
gs_free char *reason = NULL;
data = g_object_get_data (G_OBJECT (dialog), "data");
if (!nm_wireguard_peer_is_valid (data->peer, TRUE, TRUE, &error)) {
reason = g_strdup_printf ("Error: %s", error->message);
gtk_label_set_text (data->label_info, reason);
gtk_widget_set_visible (GTK_WIDGET (data->info_bar), TRUE);
} else {
gtk_label_set_text (data->label_info, "");
gtk_widget_set_visible (GTK_WIDGET (data->info_bar), FALSE);
gtk_dialog_response (GTK_DIALOG (dialog), GTK_RESPONSE_APPLY);
}
}
static void
peer_dialog_show_psk (GtkDialog *dialog)
{
PeerDialogData *data;
data = g_object_get_data (G_OBJECT (dialog), "data");
gtk_entry_set_visibility (data->entry_psk,
gtk_toggle_button_get_active (data->toggle_show_psk));
}
static GtkWidget *
peer_dialog_create (GtkWidget *toplevel, NMWireGuardPeer *peer)
{
GtkWidget *dialog;
gs_free_error GError *error = NULL;
PeerDialogData *data;
GtkBuilder *builder;
builder = gtk_builder_new ();
if (!gtk_builder_add_from_resource (builder,
"/org/gnome/nm_connection_editor/ce-page-wireguard.ui",
&error)) {
g_warning ("Couldn't load builder resource: %s", error->message);
g_error_free (error);
return NULL;
}
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "PeerDialog"));
data = g_new0 (PeerDialogData, 1);
data->peer = nm_wireguard_peer_ref (peer);
data->builder = builder;
data->button_apply = GTK_BUTTON (gtk_builder_get_object (builder, "button_apply"));
data->entry_public_key = GTK_ENTRY (gtk_builder_get_object (builder, "entry_public_key"));
data->entry_allowed_ips = GTK_ENTRY (gtk_builder_get_object (builder, "entry_allowed_ips"));
data->entry_endpoint = GTK_ENTRY (gtk_builder_get_object (builder, "entry_endpoint"));
data->entry_psk = GTK_ENTRY (gtk_builder_get_object (builder, "entry_psk"));
data->spin_persistent_keepalive = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "spin_persistent_keepalive"));
data->info_bar = GTK_INFO_BAR (gtk_builder_get_object (builder, "info_bar"));
data->label_info = GTK_LABEL (gtk_builder_get_object (builder, "label_info"));
data->toggle_show_psk = GTK_TOGGLE_BUTTON (gtk_builder_get_object (builder, "toggle_show_psk"));
g_object_set_data_full (G_OBJECT (dialog), "data",
data,
(GDestroyNotify) peer_dialog_data_destroy);
nma_utils_setup_password_storage ((GtkWidget *) data->entry_psk, 0,
NULL, NULL, TRUE, FALSE);
ce_spin_off_val (data->spin_persistent_keepalive, 0);
gtk_entry_set_visibility (data->entry_psk, FALSE);
peer_dialog_update_ui (dialog);
g_signal_connect_swapped (data->button_apply, "clicked", G_CALLBACK (peer_dialog_apply_clicked), dialog);
g_signal_connect_swapped (data->entry_public_key, "changed", G_CALLBACK (peer_dialog_update_peer), dialog);
g_signal_connect_swapped (data->entry_allowed_ips, "changed", G_CALLBACK (peer_dialog_update_peer), dialog);
g_signal_connect_swapped (data->entry_endpoint, "changed", G_CALLBACK (peer_dialog_update_peer), dialog);
g_signal_connect_swapped (data->entry_psk, "changed", G_CALLBACK (peer_dialog_update_peer), dialog);
g_signal_connect_swapped (data->toggle_show_psk, "toggled", G_CALLBACK (peer_dialog_show_psk), dialog);
gtk_label_set_text (data->label_info, "");
gtk_widget_set_visible (GTK_WIDGET (data->info_bar), FALSE);
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (toplevel));
return dialog;
}
static void
wireguard_private_init (CEPageWireGuard *self)
{
CEPageWireGuardPrivate *priv = CE_PAGE_WIREGUARD_GET_PRIVATE (self);
GtkBuilder *builder;
GtkTreeViewColumn *column;
builder = CE_PAGE (self)->builder;
priv->entry_ifname = GTK_ENTRY (gtk_builder_get_object (builder, "entry_ifname"));
priv->entry_pk = GTK_ENTRY (gtk_builder_get_object (builder, "entry_private_key"));
priv->spin_mtu = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "spin_mtu"));
priv->spin_fwmark = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "spin_fwmark"));
priv->spin_listen_port = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "spin_listen_port"));
priv->toggle_peer_routes = GTK_TOGGLE_BUTTON (gtk_builder_get_object (builder, "toggle_peer_routes"));
priv->toggle_show_pk = GTK_TOGGLE_BUTTON (gtk_builder_get_object (builder, "toggle_show_private_key"));
priv->tree = GTK_TREE_VIEW (gtk_builder_get_object (builder, "tree_peers"));
priv->button_add = GTK_BUTTON (gtk_builder_get_object (builder, "button_add"));
priv->button_delete = GTK_BUTTON (gtk_builder_get_object (builder, "button_delete"));
gtk_entry_set_visibility (priv->entry_pk, FALSE);
priv->store = gtk_tree_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
column = gtk_tree_view_column_new_with_attributes (_("Public key"),
gtk_cell_renderer_text_new (),
"text", COL_PUBLIC_KEY,
NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (priv->tree, column);
column = gtk_tree_view_column_new_with_attributes (_("Allowed IPs"),
gtk_cell_renderer_text_new (),
"text", COL_ALLOWED_IPS,
NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (priv->tree, column);
gtk_tree_view_set_model (priv->tree, GTK_TREE_MODEL (priv->store));
}
static void
update_peers_table (CEPageWireGuard *self)
{
CEPageWireGuardPrivate *priv = CE_PAGE_WIREGUARD_GET_PRIVATE (self);
NMSettingWireGuard *setting = priv->setting;
guint i, num;
gtk_tree_store_clear (priv->store);
num = nm_setting_wireguard_get_peers_len (setting);
for (i = 0; i < num; i++) {
NMWireGuardPeer *peer;
GtkTreeIter iter;
gs_free char *ips = NULL;
peer = nm_setting_wireguard_get_peer (setting, i);
ips = format_allowed_ips (peer);
gtk_tree_store_append (priv->store, &iter, NULL);
gtk_tree_store_set (priv->store, &iter,
COL_PUBLIC_KEY, nm_wireguard_peer_get_public_key (peer),
COL_ALLOWED_IPS, ips,
-1);
}
}
static int
get_selected_index (CEPageWireGuard *self)
{
CEPageWireGuardPrivate *priv = CE_PAGE_WIREGUARD_GET_PRIVATE (self);
GtkTreeSelection *selection;
GtkTreeModel *model;
GList *list;
int *indices;
int ret = -1;
selection = gtk_tree_view_get_selection (priv->tree);
nm_assert (selection);
list = gtk_tree_selection_get_selected_rows (selection, &model);
if (!list)
goto done;
indices = gtk_tree_path_get_indices ((GtkTreePath *) list->data);
if (!indices)
goto done;
ret = indices[0];
done:
g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
return ret;
}
static void
tree_selection_changed (CEPageWireGuard *self)
{
CEPageWireGuardPrivate *priv = CE_PAGE_WIREGUARD_GET_PRIVATE (self);
int index;
index = get_selected_index (self);
gtk_widget_set_sensitive (GTK_WIDGET (priv->button_delete), index >= 0);
}
static void
populate_ui (CEPageWireGuard *self)
{
CEPageWireGuardPrivate *priv = CE_PAGE_WIREGUARD_GET_PRIVATE (self);
NMSettingWireGuard *setting = priv->setting;
NMConnection *connection;
const char *str;
connection = CE_PAGE (self)->connection;
str = nm_connection_get_interface_name (connection);
if (str)
gtk_entry_set_text (priv->entry_ifname, str);
gtk_entry_set_text (priv->entry_pk, nm_setting_wireguard_get_private_key (setting) ?: "");
nma_utils_setup_password_storage ((GtkWidget *) priv->entry_pk, 0,
(NMSetting *) priv->setting,
NM_SETTING_WIREGUARD_PRIVATE_KEY,
FALSE, FALSE);
ce_spin_automatic_val (priv->spin_mtu, 0);
ce_spin_automatic_val (priv->spin_listen_port, 0);
ce_spin_off_val (priv->spin_fwmark, 0);
gtk_spin_button_set_value (priv->spin_mtu, nm_setting_wireguard_get_mtu (setting));
gtk_spin_button_set_value (priv->spin_fwmark, nm_setting_wireguard_get_fwmark (setting));
gtk_spin_button_set_value (priv->spin_listen_port, nm_setting_wireguard_get_listen_port (setting));
gtk_toggle_button_set_active (priv->toggle_peer_routes,
nm_setting_wireguard_get_peer_routes (setting));
update_peers_table (self);
tree_selection_changed (self);
}
static void
stuff_changed (GtkEditable *editable, gpointer user_data)
{
ce_page_changed (CE_PAGE (user_data));
}
static void
peer_dialog_response_cb (GtkWidget *dialog, gint response, gpointer user_data)
{
CEPageWireGuard *self = CE_PAGE_WIREGUARD (user_data);
CEPageWireGuardPrivate *priv = CE_PAGE_WIREGUARD_GET_PRIVATE (self);
if (response == GTK_RESPONSE_APPLY) {
peer_dialog_update_peer (dialog);
if (priv->dialog_peer_index >= 0) {
nm_setting_wireguard_set_peer (priv->setting,
priv->dialog_peer,
priv->dialog_peer_index);
} else {
nm_setting_wireguard_append_peer (priv->setting,
priv->dialog_peer);
}
update_peers_table (self);
}
nm_wireguard_peer_unref (priv->dialog_peer);
priv->dialog_peer = NULL;
priv->dialog_peer_index = -1;
gtk_widget_hide (dialog);
gtk_widget_destroy (dialog);
}
static void
add_delete_clicked (GtkButton *button, CEPageWireGuard *self)
{
CEPageWireGuardPrivate *priv = CE_PAGE_WIREGUARD_GET_PRIVATE (self);
GtkWidget *dialog;
int index;
g_return_if_fail (NM_IN_SET (button, priv->button_add, priv->button_delete));
if (button == priv->button_add) {
priv->dialog_peer = nm_wireguard_peer_new ();
priv->dialog_peer_index = -1;
dialog = peer_dialog_create (gtk_widget_get_toplevel (CE_PAGE (self)->page),
priv->dialog_peer);
if (!dialog)
return;
g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (peer_dialog_response_cb), self);
gtk_widget_show (dialog);
} else {
index = get_selected_index (self);
if (index >= 0) {
nm_setting_wireguard_remove_peer (priv->setting, (guint) index);
update_peers_table (self);
}
}
}
static void
row_activated (GtkTreeView *tree_view,
GtkTreePath *path,
GtkTreeViewColumn *column,
CEPageWireGuard *self)
{
CEPageWireGuardPrivate *priv = CE_PAGE_WIREGUARD_GET_PRIVATE (self);
NMWireGuardPeer *peer;
GtkWidget *dialog;
int index;
index = get_selected_index (self);
if (index < 0)
return;
peer = nm_setting_wireguard_get_peer (priv->setting, index);
priv->dialog_peer = nm_wireguard_peer_new_clone (peer, TRUE);
priv->dialog_peer_index = index;
dialog = peer_dialog_create (gtk_widget_get_toplevel (CE_PAGE (self)->page),
priv->dialog_peer);
if (!dialog)
return;
g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (peer_dialog_response_cb), self);
gtk_widget_show (dialog);
}
static void
show_private_key (GtkToggleButton *button, gpointer user_data)
{
CEPageWireGuardPrivate *priv = CE_PAGE_WIREGUARD_GET_PRIVATE (user_data);
gtk_entry_set_visibility (priv->entry_pk, gtk_toggle_button_get_active (button));
}
static void
finish_setup (CEPageWireGuard *self, gpointer user_data)
{
CEPageWireGuardPrivate *priv = CE_PAGE_WIREGUARD_GET_PRIVATE (self);
GtkTreeSelection *selection;
selection = gtk_tree_view_get_selection (priv->tree);
populate_ui (self);
g_signal_connect (priv->entry_ifname, "changed", G_CALLBACK (stuff_changed), self);
g_signal_connect (priv->entry_pk, "changed", G_CALLBACK (stuff_changed), self);
g_signal_connect (priv->spin_mtu, "value-changed", G_CALLBACK (stuff_changed), self);
g_signal_connect (priv->spin_listen_port, "value-changed", G_CALLBACK (stuff_changed), self);
g_signal_connect (priv->button_add, "clicked", G_CALLBACK (add_delete_clicked), self);
g_signal_connect (priv->button_delete, "clicked", G_CALLBACK (add_delete_clicked), self);
g_signal_connect (priv->tree, "row-activated", G_CALLBACK (row_activated), self);
g_signal_connect (priv->toggle_show_pk, "toggled", G_CALLBACK (show_private_key), self);
g_signal_connect_swapped (selection, "changed", G_CALLBACK (tree_selection_changed), self);
}
CEPage *
ce_page_wireguard_new (NMConnectionEditor *editor,
NMConnection *connection,
GtkWindow *parent_window,
NMClient *client,
const char **out_secrets_setting_name,
GError **error)
{
CEPageWireGuard *self;
CEPageWireGuardPrivate *priv;
self = CE_PAGE_WIREGUARD (ce_page_new (CE_TYPE_PAGE_WIREGUARD,
editor,
connection,
parent_window,
client,
"/org/gnome/nm_connection_editor/ce-page-wireguard.ui",
"WireGuardPage",
_("WireGuard")));
if (!self) {
g_set_error_literal (error, NMA_ERROR, NMA_ERROR_GENERIC, _("Could not load WireGuard user interface."));
return NULL;
}
wireguard_private_init (self);
priv = CE_PAGE_WIREGUARD_GET_PRIVATE (self);
priv->setting = (NMSettingWireGuard *) nm_connection_get_setting (connection, NM_TYPE_SETTING_WIREGUARD);
if (!priv->setting) {
priv->setting = NM_SETTING_WIREGUARD (nm_setting_wireguard_new ());
nm_connection_add_setting (connection, NM_SETTING (priv->setting));
}
g_signal_connect (self, CE_PAGE_INITIALIZED, G_CALLBACK (finish_setup), NULL);
*out_secrets_setting_name = NM_SETTING_WIREGUARD_SETTING_NAME;
return CE_PAGE (self);
}
static void
ui_to_setting (CEPageWireGuard *self)
{
CEPageWireGuardPrivate *priv = CE_PAGE_WIREGUARD_GET_PRIVATE (self);
NMSettingConnection *s_con;
guint32 mtu;
guint32 fwmark;
guint16 listen_port;
const char *private_key;
const char *ifname;
NMSettingSecretFlags secret_flags;
gboolean peer_routes;
s_con = nm_connection_get_setting_connection (CE_PAGE (self)->connection);
g_return_if_fail (s_con != NULL);
ifname = gtk_entry_get_text (priv->entry_ifname);
if (ifname && ifname[0] == '\0')
ifname = NULL;
g_object_set (s_con,
NM_SETTING_CONNECTION_INTERFACE_NAME,
ifname,
NULL);
private_key = gtk_entry_get_text (priv->entry_pk);
if (private_key && private_key[0] == '\0')
private_key = NULL;
mtu = gtk_spin_button_get_value_as_int (priv->spin_mtu);
fwmark = gtk_spin_button_get_value_as_int (priv->spin_fwmark);
listen_port = gtk_spin_button_get_value_as_int (priv->spin_listen_port);
peer_routes = gtk_toggle_button_get_active (priv->toggle_peer_routes);
g_object_set (priv->setting,
NM_SETTING_WIREGUARD_PRIVATE_KEY, private_key,
NM_SETTING_WIREGUARD_LISTEN_PORT, listen_port,
NM_SETTING_WIREGUARD_FWMARK, fwmark,
NM_SETTING_WIREGUARD_MTU, mtu,
NM_SETTING_WIREGUARD_PEER_ROUTES, peer_routes,
NULL);
/* Save private key flags to the connection */
secret_flags = nma_utils_menu_to_secret_flags ((GtkWidget *) priv->entry_pk);
nm_setting_set_secret_flags (NM_SETTING (priv->setting),
NM_SETTING_WIREGUARD_PRIVATE_KEY,
secret_flags, NULL);
/* Update secret flags and popup when editing the connection */
nma_utils_update_password_storage ((GtkWidget *) priv->entry_pk,
secret_flags,
NM_SETTING (priv->setting),
NM_SETTING_WIREGUARD_PRIVATE_KEY);
}
static gboolean
ce_page_validate_v (CEPage *page, NMConnection *connection, GError **error)
{
CEPageWireGuard *self = CE_PAGE_WIREGUARD (page);
CEPageWireGuardPrivate *priv = CE_PAGE_WIREGUARD_GET_PRIVATE (self);
ui_to_setting (self);
return nm_setting_verify (NM_SETTING (priv->setting), connection, error)
&& nm_setting_verify_secrets (NM_SETTING (priv->setting), connection, error);
}
static void
ce_page_wireguard_init (CEPageWireGuard *self)
{
}
static void
ce_page_wireguard_class_init (CEPageWireGuardClass *wireguard_class)
{
GObjectClass *object_class = G_OBJECT_CLASS (wireguard_class);
CEPageClass *parent_class = CE_PAGE_CLASS (wireguard_class);
g_type_class_add_private (object_class, sizeof (CEPageWireGuardPrivate));
parent_class->ce_page_validate_v = ce_page_validate_v;
}
void
wireguard_connection_new (FUNC_TAG_PAGE_NEW_CONNECTION_IMPL,
GtkWindow *parent,
const char *detail,
gpointer detail_data,
NMConnection *connection,
NMClient *client,
PageNewConnectionResultFunc result_func,
gpointer user_data)
{
gs_unref_object NMConnection *connection_tmp = NULL;
NMSettingIPConfig *s_ip;
connection = _ensure_connection_other (connection, &connection_tmp);
ce_page_complete_connection (connection,
_("WireGuard connection %d"),
NM_SETTING_WIREGUARD_SETTING_NAME,
FALSE,
client);
nm_connection_add_setting (connection, nm_setting_wireguard_new ());
s_ip = (NMSettingIPConfig *) nm_setting_ip4_config_new ();
g_object_set (s_ip, NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_DISABLED, NULL);
nm_connection_add_setting (connection, (NMSetting *) s_ip);
s_ip = (NMSettingIPConfig *) nm_setting_ip6_config_new ();
g_object_set (s_ip, NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP6_CONFIG_METHOD_IGNORE, NULL);
nm_connection_add_setting (connection, (NMSetting *) s_ip);
(*result_func) (FUNC_TAG_PAGE_NEW_CONNECTION_RESULT_CALL, connection, FALSE, NULL, user_data);
}