// SPDX-License-Identifier: GPL-2.0+

/* NetworkManager Connection editor -- Connection editor for NetworkManager

 *

 * Copyright 2012 - 2014 Red Hat, Inc.

 */

#include "nm-default.h"

#include <stdlib.h>

#include "page-bond.h"

#include "page-infiniband.h"

#include "nm-connection-editor.h"

#include "connection-helpers.h"

G_DEFINE_TYPE (CEPageBond, ce_page_bond, CE_TYPE_PAGE_MASTER)

#define CE_PAGE_BOND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), CE_TYPE_PAGE_BOND, CEPageBondPrivate))

typedef struct {

	NMSettingBond *setting;

	NMSettingWired *wired;

	int slave_arptype;

	GtkWindow *toplevel;

	GtkComboBox *mode;

	GtkEntry *primary;

	GtkWidget *primary_label;

	GtkComboBox *monitoring;

	GtkSpinButton *frequency;

	GtkSpinButton *updelay;

	GtkWidget *updelay_label;

	GtkWidget *updelay_box;

	GtkSpinButton *downdelay;

	GtkWidget *downdelay_label;

	GtkWidget *downdelay_box;

	GtkEntry *arp_targets;

	GtkWidget *arp_targets_label;

	GtkSpinButton *mtu;

} CEPageBondPrivate;

#define MODE_BALANCE_RR    0

#define MODE_ACTIVE_BACKUP 1

#define MODE_BALANCE_XOR   2

#define MODE_BROADCAST     3

#define MODE_802_3AD       4

#define MODE_BALANCE_TLB   5

#define MODE_BALANCE_ALB   6

#define MONITORING_MII 0

#define MONITORING_ARP 1

static void

bond_private_init (CEPageBond *self)

{

	CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self);

	GtkBuilder *builder;

	builder = CE_PAGE (self)->builder;

	priv->mode = GTK_COMBO_BOX (gtk_builder_get_object (builder, "bond_mode"));

	priv->primary = GTK_ENTRY (gtk_builder_get_object (builder, "bond_primary"));

	priv->primary_label = GTK_WIDGET (gtk_builder_get_object (builder, "bond_primary_label"));

	priv->monitoring = GTK_COMBO_BOX (gtk_builder_get_object (builder, "bond_monitoring"));

	priv->frequency = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "bond_frequency"));

	priv->updelay = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "bond_updelay"));

	priv->updelay_label = GTK_WIDGET (gtk_builder_get_object (builder, "bond_updelay_label"));

	priv->updelay_box = GTK_WIDGET (gtk_builder_get_object (builder, "bond_updelay_box"));

	priv->downdelay = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "bond_downdelay"));

	priv->downdelay_label = GTK_WIDGET (gtk_builder_get_object (builder, "bond_downdelay_label"));

	priv->downdelay_box = GTK_WIDGET (gtk_builder_get_object (builder, "bond_downdelay_box"));

	priv->arp_targets = GTK_ENTRY (gtk_builder_get_object (builder, "bond_arp_targets"));

	priv->arp_targets_label = GTK_WIDGET (gtk_builder_get_object (builder, "bond_arp_targets_label"));

	priv->mtu = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "bond_mtu"));

	priv->toplevel = GTK_WINDOW (gtk_widget_get_ancestor (GTK_WIDGET (priv->mode),

	                                                      GTK_TYPE_WINDOW));

}

static void

stuff_changed (GtkWidget *w, gpointer user_data)

{

	ce_page_changed (CE_PAGE (user_data));

}

static void

connection_removed (CEPageMaster *master, NMConnection *connection)

{

	CEPageBond *self = CE_PAGE_BOND (master);

	CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self);

	if (!ce_page_master_has_slaves (master))

		priv->slave_arptype = ARPHRD_VOID;

}

static void

connection_added (CEPageMaster *master, NMConnection *connection)

{

	CEPageBond *self = CE_PAGE_BOND (master);

	CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self);

	if (nm_connection_is_type (connection, NM_SETTING_INFINIBAND_SETTING_NAME)) {

		priv->slave_arptype = ARPHRD_INFINIBAND;

		gtk_combo_box_set_active (priv->mode, MODE_ACTIVE_BACKUP);

		gtk_widget_set_sensitive (GTK_WIDGET (priv->mode), FALSE);

	} else {

		priv->slave_arptype = ARPHRD_ETHER;

		gtk_widget_set_sensitive (GTK_WIDGET (priv->mode), TRUE);

	}

}

static void

bonding_mode_changed (GtkComboBox *combo, gpointer user_data)

{

	CEPageBond *self = user_data;

	CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self);

	int mode;

	mode = gtk_combo_box_get_active (combo);

	if (mode == MODE_BALANCE_TLB || mode == MODE_BALANCE_ALB) {

		gtk_combo_box_set_active (priv->monitoring, MONITORING_MII);

		gtk_widget_set_sensitive (GTK_WIDGET (priv->monitoring), FALSE);

	} else {

		gtk_widget_set_sensitive (GTK_WIDGET (priv->monitoring), TRUE);

	}

	if (mode == MODE_ACTIVE_BACKUP) {

		gtk_widget_show (GTK_WIDGET (priv->primary));

		gtk_widget_show (GTK_WIDGET (priv->primary_label));

	} else {

		gtk_widget_hide (GTK_WIDGET (priv->primary));

		gtk_widget_hide (GTK_WIDGET (priv->primary_label));

	}

}

static void

monitoring_mode_changed (GtkComboBox *combo, gpointer user_data)

{

	CEPageBond *self = user_data;

	CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self);

	if (gtk_combo_box_get_active (combo) == MONITORING_MII) {

		gtk_widget_show (GTK_WIDGET (priv->updelay));

		gtk_widget_show (priv->updelay_label);

		gtk_widget_show (priv->updelay_box);

		gtk_widget_show (GTK_WIDGET (priv->downdelay));

		gtk_widget_show (priv->downdelay_label);

		gtk_widget_show (priv->downdelay_box);

		gtk_widget_hide (GTK_WIDGET (priv->arp_targets));

		gtk_widget_hide (priv->arp_targets_label);

	} else {

		gtk_widget_hide (GTK_WIDGET (priv->updelay));

		gtk_widget_hide (priv->updelay_label);

		gtk_widget_hide (priv->updelay_box);

		gtk_widget_hide (GTK_WIDGET (priv->downdelay));

		gtk_widget_hide (priv->downdelay_label);

		gtk_widget_hide (priv->downdelay_box);

		gtk_widget_show (GTK_WIDGET (priv->arp_targets));

		gtk_widget_show (priv->arp_targets_label);

	}

}

static void

frequency_changed (GtkSpinButton *button, gpointer user_data)

{

	CEPageBond *self = user_data;

	CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self);

	int frequency, delay;

	frequency = gtk_spin_button_get_value_as_int (priv->frequency);

	/* Round updelay and downdelay up to a multiple of frequency */

	delay = gtk_spin_button_get_value_as_int (priv->updelay);

	if (frequency == 0) {

		if (delay != 0)

			gtk_spin_button_set_value (priv->updelay, 0.0);

	} else if (delay % frequency) {

		delay += frequency - (delay % frequency);

		gtk_spin_button_set_value (priv->updelay, delay);

	}

	gtk_spin_button_set_increments (priv->updelay, frequency, frequency);

	delay = gtk_spin_button_get_value_as_int (priv->downdelay);

	if (frequency == 0) {

		if (delay != 0)

			gtk_spin_button_set_value (priv->downdelay, 0.0);

	} else if (delay % frequency) {

		delay += frequency - (delay % frequency);

		gtk_spin_button_set_value (priv->downdelay, (gdouble)delay);

	}

	gtk_spin_button_set_increments (priv->downdelay, frequency, frequency);

}

static void

delay_changed (GtkSpinButton *button, gpointer user_data)

{

	CEPageBond *self = user_data;

	CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self);

	int frequency, delay;

	/* Clamp to nearest multiple of frequency */

	frequency = gtk_spin_button_get_value_as_int (priv->frequency);

	delay = gtk_spin_button_get_value_as_int (button);

	if (frequency == 0) {

		if (delay != 0)

			gtk_spin_button_set_value (button, 0.0);

	} else if (delay % frequency) {

		if (delay % frequency < frequency / 2)

			delay -= delay % frequency;

		else

			delay += frequency - (delay % frequency);

		gtk_spin_button_set_value (button, (gdouble)delay);

	}

}

static char *

prettify_targets (const char *text)

{

	char **addrs, *targets;

	if (!text || !*text)

		return NULL;

	addrs = g_strsplit (text, ",", -1);

	targets = g_strjoinv (", ", addrs);

	g_strfreev (addrs);

	return targets;

}

static char *

uglify_targets (const char *text)

{

	char **addrs, *targets;

	int i;

	if (!text || !*text)

		return NULL;

	addrs = g_strsplit (text, ",", -1);

	for (i = 0; addrs[i]; i++)

		g_strstrip (addrs[i]);

	targets = g_strjoinv (",", addrs);

	g_strfreev (addrs);

	return targets;

}

static void

populate_ui (CEPageBond *self)

{

	CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self);

	NMSettingBond *setting = priv->setting;

	const char *mode, *primary, *frequency, *updelay, *downdelay, *raw_targets;

	char *targets;

	int mode_idx = MODE_BALANCE_RR;

	guint32 mtu_def, mtu_val;

	/* Mode */

	mode = nm_setting_bond_get_option_by_name (setting, NM_SETTING_BOND_OPTION_MODE);

	if (mode) {

		if (!strcmp (mode, "balance-rr"))

			mode_idx = MODE_BALANCE_RR;

		else if (!strcmp (mode, "active-backup"))

			mode_idx = MODE_ACTIVE_BACKUP;

		else if (!strcmp (mode, "balance-xor"))

			mode_idx = MODE_BALANCE_XOR;

		else if (!strcmp (mode, "broadcast"))

			mode_idx = MODE_BROADCAST;

		else if (!strcmp (mode, "802.3ad"))

			mode_idx = MODE_802_3AD;

		else if (!strcmp (mode, "balance-tlb"))

			mode_idx = MODE_BALANCE_TLB;

		else if (!strcmp (mode, "balance-alb"))

			mode_idx = MODE_BALANCE_ALB;

	}

	gtk_combo_box_set_active (priv->mode, mode_idx);

	g_signal_connect (priv->mode, "changed",

	                  G_CALLBACK (bonding_mode_changed),

	                  self);

	bonding_mode_changed (priv->mode, self);

	/* Primary */

	primary = nm_setting_bond_get_option_by_name (setting, NM_SETTING_BOND_OPTION_PRIMARY);

	gtk_entry_set_text (priv->primary, primary ? primary : "");

	/* Monitoring mode/frequency */

	frequency = nm_setting_bond_get_option_by_name (setting, NM_SETTING_BOND_OPTION_ARP_INTERVAL);

	if (frequency) {

		gtk_combo_box_set_active (priv->monitoring, MONITORING_ARP);

	} else {

		gtk_combo_box_set_active (priv->monitoring, MONITORING_MII);

		frequency = nm_setting_bond_get_option_by_name (setting, NM_SETTING_BOND_OPTION_MIIMON);

	}

	g_signal_connect (priv->monitoring, "changed",

	                  G_CALLBACK (monitoring_mode_changed),

	                  self);

	monitoring_mode_changed (priv->monitoring, self);

	if (frequency)

		gtk_spin_button_set_value (priv->frequency, (gdouble) atoi (frequency));

	else

		gtk_spin_button_set_value (priv->frequency, 0.0);

	g_signal_connect (priv->frequency, "value-changed",

	                  G_CALLBACK (frequency_changed),

	                  self);

	updelay = nm_setting_bond_get_option_by_name (setting, NM_SETTING_BOND_OPTION_UPDELAY);

	if (updelay)

		gtk_spin_button_set_value (priv->updelay, (gdouble) atoi (updelay));

	else

		gtk_spin_button_set_value (priv->updelay, 0.0);

	g_signal_connect (priv->updelay, "value-changed",

	                  G_CALLBACK (delay_changed),

	                  self);

	downdelay = nm_setting_bond_get_option_by_name (setting, NM_SETTING_BOND_OPTION_DOWNDELAY);

	if (downdelay)

		gtk_spin_button_set_value (priv->downdelay, (gdouble) atoi (downdelay));

	else

		gtk_spin_button_set_value (priv->downdelay, 0.0);

	g_signal_connect (priv->downdelay, "value-changed",

	                  G_CALLBACK (delay_changed),

	                  self);

	/* ARP targets */

	raw_targets = nm_setting_bond_get_option_by_name (setting, NM_SETTING_BOND_OPTION_ARP_IP_TARGET);

	targets = prettify_targets (raw_targets);

	if (targets) {

		gtk_entry_set_text (priv->arp_targets, targets);

		g_free (targets);

	}

	/* MTU */

	if (priv->wired) {

		mtu_def = ce_get_property_default (NM_SETTING (priv->wired), NM_SETTING_WIRED_MTU);

		mtu_val = nm_setting_wired_get_mtu (priv->wired);

	} else {

		mtu_def = mtu_val = 0;

	}

	ce_spin_automatic_val (priv->mtu, mtu_def);

	gtk_spin_button_set_value (priv->mtu, (gdouble) mtu_val);

}

static gboolean

connection_type_filter (FUNC_TAG_NEW_CONNECTION_TYPE_FILTER_IMPL,

                        GType type,

                        gpointer self)

{

	CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self);

	if (!nm_utils_check_virtual_device_compatibility (NM_TYPE_SETTING_BOND, type))

		return FALSE;

	/* Can only have connections of a single arptype. Note that we don't

	 * need to check the reverse case here since we don't need to call

	 * new_connection_dialog() in the InfiniBand case.

	 */

	if (   priv->slave_arptype == ARPHRD_ETHER

	    && type == NM_TYPE_SETTING_INFINIBAND)

		return FALSE;

	return TRUE;

}

static void

add_slave (CEPageMaster *master, NewConnectionResultFunc result_func)

{

	CEPageBond *self = CE_PAGE_BOND (master);

	CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self);

	if (priv->slave_arptype == ARPHRD_INFINIBAND) {

		new_connection_of_type (priv->toplevel,

		                        NULL,

		                        NULL,

		                        NULL,

		                        CE_PAGE (self)->client,

		                        infiniband_connection_new,

		                        result_func,

		                        master);

	} else {

		new_connection_dialog (priv->toplevel,

		                       CE_PAGE (self)->client,

		                       connection_type_filter,

		                       result_func,

		                       master);

	}

}

static void

finish_setup (CEPageBond *self, gpointer user_data)

{

	CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self);

	populate_ui (self);

	g_signal_connect (priv->mode, "changed", G_CALLBACK (stuff_changed), self);

	g_signal_connect (priv->primary, "changed", G_CALLBACK (stuff_changed), self);

	g_signal_connect (priv->monitoring, "changed", G_CALLBACK (stuff_changed), self);

	g_signal_connect (priv->frequency, "value-changed", G_CALLBACK (stuff_changed), self);

	g_signal_connect (priv->updelay, "value-changed", G_CALLBACK (stuff_changed), self);

	g_signal_connect (priv->downdelay, "value-changed", G_CALLBACK (stuff_changed), self);

	g_signal_connect (priv->arp_targets, "changed", G_CALLBACK (stuff_changed), self);

	g_signal_connect (priv->mtu, "value-changed", G_CALLBACK (stuff_changed), self);

}

CEPage *

ce_page_bond_new (NMConnectionEditor *editor,

                  NMConnection *connection,

                  GtkWindow *parent_window,

                  NMClient *client,

                  const char **out_secrets_setting_name,

                  GError **error)

{

	CEPageBond *self;

	CEPageBondPrivate *priv;

	self = CE_PAGE_BOND (ce_page_new (CE_TYPE_PAGE_BOND,

	                                  editor,

	                                  connection,

	                                  parent_window,

	                                  client,

	                                  "/org/gnome/nm_connection_editor/ce-page-bond.ui",

	                                  "BondPage",

	                                  _("Bond")));

	if (!self) {

		g_set_error_literal (error, NMA_ERROR, NMA_ERROR_GENERIC,

		                     _("Could not load bond user interface."));

		return NULL;

	}

	bond_private_init (self);

	priv = CE_PAGE_BOND_GET_PRIVATE (self);

	priv->setting = nm_connection_get_setting_bond (connection);

	if (!priv->setting) {

		priv->setting = NM_SETTING_BOND (nm_setting_bond_new ());

		nm_connection_add_setting (connection, NM_SETTING (priv->setting));

	}

	priv->wired = nm_connection_get_setting_wired (connection);

	g_signal_connect (self, CE_PAGE_INITIALIZED, G_CALLBACK (finish_setup), NULL);

	return CE_PAGE (self);

}

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 gboolean

ce_page_validate_v (CEPage *page, NMConnection *connection, GError **error)

{

	CEPageBond *self = CE_PAGE_BOND (page);

	CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self);

	if (!CE_PAGE_CLASS (ce_page_bond_parent_class)->ce_page_validate_v (page, connection, error))

		return FALSE;

	if (!ce_page_interface_name_valid (gtk_entry_get_text (priv->primary),

	                                   _("primary"), error))

		return FALSE;

	ui_to_setting (self);

	return nm_setting_verify (NM_SETTING (priv->setting), connection, error);

}

static void

ce_page_bond_init (CEPageBond *self)

{

	CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self);

	CEPageMaster *master = CE_PAGE_MASTER (self);

	priv->slave_arptype = ARPHRD_VOID;

	master->aggregating = TRUE;

}

static void

ce_page_bond_class_init (CEPageBondClass *bond_class)

{

	GObjectClass *object_class = G_OBJECT_CLASS (bond_class);

	CEPageClass *parent_class = CE_PAGE_CLASS (bond_class);

	CEPageMasterClass *master_class = CE_PAGE_MASTER_CLASS (bond_class);

	g_type_class_add_private (object_class, sizeof (CEPageBondPrivate));

	/* virtual methods */

	parent_class->ce_page_validate_v = ce_page_validate_v;

	master_class->connection_added = connection_added;

	master_class->connection_removed = connection_removed;

	master_class->add_slave = add_slave;

}

void

bond_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)

{

	NMSettingConnection *s_con;

	int bond_num = 0, num, i;

	const GPtrArray *connections;

	NMConnection *conn2;

	const char *iface;

	char *my_iface;

	gs_unref_object NMConnection *connection_tmp = NULL;

	connection = _ensure_connection_other (connection, &connection_tmp);

	ce_page_complete_connection (connection,

	                             _("Bond connection %d"),

	                             NM_SETTING_BOND_SETTING_NAME,

	                             TRUE,

	                             client);

	nm_connection_add_setting (connection, nm_setting_bond_new ());

	/* Find an available interface name */

	connections = nm_client_get_connections (client);

	for (i = 0; i < connections->len; i++) {

		conn2 = connections->pdata[i];

		if (!nm_connection_is_type (conn2, NM_SETTING_BOND_SETTING_NAME))

			continue;

		iface = nm_connection_get_interface_name (conn2);

		if (!iface || strncmp (iface, "bond", 4) != 0 || !g_ascii_isdigit (iface[4]))

			continue;

		num = atoi (iface + 4);

		if (bond_num <= num)

			bond_num = num + 1;

	}

	s_con = nm_connection_get_setting_connection (connection);

	my_iface = g_strdup_printf ("bond%d", bond_num);

	g_object_set (G_OBJECT (s_con),

	              NM_SETTING_CONNECTION_INTERFACE_NAME, my_iface,

	              NULL);

	g_free (my_iface);

	(*result_func) (FUNC_TAG_PAGE_NEW_CONNECTION_RESULT_CALL, connection, FALSE, NULL, user_data);

}