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

/* NetworkManager Connection editor -- Connection editor for NetworkManager

 *

 * Copyright 2008 - 2014 Red Hat, Inc.

 */

#include "nm-default.h"

#include <stdlib.h>

#include <string.h>

#include <net/ethernet.h>

#include "page-vlan.h"

#include "connection-helpers.h"

#include "nm-connection-editor.h"

G_DEFINE_TYPE (CEPageVlan, ce_page_vlan, CE_TYPE_PAGE)

#define CE_PAGE_VLAN_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), CE_TYPE_PAGE_VLAN, CEPageVlanPrivate))

typedef struct {

	char *label;

	NMDevice *device;

	NMConnection *connection;

} VlanParent;

typedef struct {

	NMSettingVlan *setting;

	NMSetting *s_hw;

	VlanParent **parents;

	char **parent_labels;

	int parents_len;

	GtkWindow *toplevel;

	GtkComboBox *parent;

	GtkEntry *parent_entry;

	GtkSpinButton *id_entry;

	GtkEntry *name_entry;

	GtkComboBoxText *cloned_mac;

	GtkSpinButton *mtu;

	GtkToggleButton *flag_reorder_hdr, *flag_gvrp, *flag_loose_binding, *flag_mvrp;

	char *last_parent;

	int last_id;

} CEPageVlanPrivate;

static void

vlan_private_init (CEPageVlan *self)

{

	CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self);

	GtkBuilder *builder;

	GtkWidget *vbox;

	GtkLabel *label;

	builder = CE_PAGE (self)->builder;

	priv->parent = GTK_COMBO_BOX (gtk_combo_box_text_new_with_entry ());

	gtk_combo_box_set_entry_text_column (priv->parent, 0);

	priv->parent_entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (priv->parent)));

	vbox = GTK_WIDGET (gtk_builder_get_object (builder, "vlan_parent_vbox"));

	gtk_container_add (GTK_CONTAINER (vbox), GTK_WIDGET (priv->parent));

	gtk_widget_show_all (GTK_WIDGET (priv->parent));

	/* Set mnemonic widget for parent label */

	label = GTK_LABEL (gtk_builder_get_object (builder, "vlan_parent_label"));

	gtk_label_set_mnemonic_widget (label, GTK_WIDGET (priv->parent));

	priv->id_entry = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "vlan_id_entry"));

	priv->name_entry = GTK_ENTRY (gtk_builder_get_object (builder, "vlan_name_entry"));

	priv->cloned_mac = GTK_COMBO_BOX_TEXT (gtk_builder_get_object (builder, "vlan_cloned_mac_entry"));

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

	priv->flag_reorder_hdr = GTK_TOGGLE_BUTTON (gtk_builder_get_object (builder, "reorder_hdr_flag"));

	priv->flag_gvrp = GTK_TOGGLE_BUTTON (gtk_builder_get_object (builder, "gvrp_flag"));

	priv->flag_loose_binding = GTK_TOGGLE_BUTTON (gtk_builder_get_object (builder, "loose_binding_flag"));

	priv->flag_mvrp = GTK_TOGGLE_BUTTON (gtk_builder_get_object (builder, "mvrp_flag"));

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

	                                                      GTK_TYPE_WINDOW));

}

static void

stuff_changed (GtkWidget *w, gpointer user_data)

{

	ce_page_changed (CE_PAGE (user_data));

}

static void name_changed (GtkWidget *widget, gpointer user_data);

static void

sync_iface (CEPageVlan *self, GtkEntry *changed_entry)

{

	CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self);

	const char *iface, *iface_end, *parent_text;

	char *new_iface, *end;

	int iface_id, iface_len, parent_iface_len, id;

	gboolean vlan_style_name;

	iface = gtk_entry_get_text (priv->name_entry);

	if (!*iface)

		return;

	if (g_str_has_prefix (iface, "vlan")) {

		iface_end = iface + 4;

		iface_id = strtoul (iface_end, &end, 10);

		vlan_style_name = TRUE;

	} else if ((iface_end = strchr (iface, '.'))) {

		iface_id = strtoul (iface_end + 1, &end, 10);

		vlan_style_name = FALSE;

	} else

		return;

	if (*end)

		return;

	iface_len = iface_end - iface;

	parent_text = gtk_entry_get_text (priv->parent_entry);

	parent_iface_len = strcspn (parent_text, " ");

	id = gtk_spin_button_get_value_as_int (priv->id_entry);

	if (changed_entry == priv->name_entry) {

		/* The user changed the interface name. If it now matches

		 * parent and id, then update the last_* members, so we'll

		 * start keeping it in sync again.

		 */

		if (iface_id == id)

			priv->last_id = iface_id;

		else

			priv->last_id = -1;

		g_free (priv->last_parent);

		if (   iface_len == parent_iface_len

		    && !strncmp (iface, parent_text, iface_len))

			priv->last_parent = g_strndup (iface, iface_len);

		else

			priv->last_parent = NULL;

		return;

	}

	/* The user changed the parent or ID; if the previous parent and

	 * ID matched the interface name, then update the interface name

	 * to match the new one as well.

	 */

	if (iface_id != priv->last_id)

		return;

	if (   !vlan_style_name

	    && priv->last_parent

	    && strncmp (iface, priv->last_parent, iface_len) != 0)

		return;

	if (vlan_style_name) {

		new_iface = g_strdup_printf ("vlan%d", id);

	} else if (changed_entry == priv->parent_entry) {

		new_iface = g_strdup_printf ("%.*s.%d",

		                             parent_iface_len,

		                             parent_text, id);

	} else {

		new_iface = g_strdup_printf ("%.*s.%d", iface_len, iface, id);

	}

	g_signal_handlers_block_by_func (priv->name_entry, G_CALLBACK (name_changed), self);

	gtk_entry_set_text (priv->name_entry, new_iface);

	g_signal_handlers_unblock_by_func (priv->name_entry, G_CALLBACK (name_changed), self);

	g_free (new_iface);

	if (changed_entry == priv->parent_entry) {

		g_free (priv->last_parent);

		priv->last_parent = g_strndup (parent_text, parent_iface_len);

	} else if (changed_entry == GTK_ENTRY (priv->id_entry))

		priv->last_id = id;

}

/* The first item in the combo box may be an arbitrary string not contained in parents array */

static int

get_parents_index (int parents_len, GtkComboBox *box, int combo_index)

{

	int size;

	GtkTreeModel *model;

	/* Get number of items in the combo box */

	model = gtk_combo_box_get_model (box);

	size = gtk_tree_model_iter_n_children (model, NULL);

	return combo_index - (size - parents_len);

}

static void

edit_parent_cb (NMConnectionEditor *editor, GtkResponseType response, gpointer user_data)

{

	CEPageVlan *self = user_data;

	CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self);

	NMConnection *connection;

	NMConnection *parent;

	NMSettingConnection *s_con;

	if (response != GTK_RESPONSE_OK)

		goto finish;

	connection = nm_connection_editor_get_connection (editor);

	parent = (NMConnection *)nm_client_get_connection_by_uuid (CE_PAGE (self)->client,

	                                                           nm_connection_get_uuid (connection));

	s_con = nm_connection_get_setting_connection (parent);

	gtk_entry_set_text (priv->parent_entry, nm_setting_connection_get_interface_name (s_con));

finish:

	g_object_unref (editor);

}

static void

edit_parent (FUNC_TAG_NEW_CONNECTION_RESULT_IMPL,

             NMConnection *connection,

             gpointer user_data)

{

	CEPageVlan *self = user_data;

	CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self);

	NMSettingConnection *s_con;

	NMConnectionEditor *editor;

	if (!connection)

		return;

	s_con = nm_connection_get_setting_connection (CE_PAGE (self)->connection);

	g_object_set (G_OBJECT (s_con),

	              NM_SETTING_CONNECTION_AUTOCONNECT, TRUE,

	              NULL);

	editor = ce_page_new_editor (CE_PAGE (self), priv->toplevel, connection);

	if (!editor)

		return;

	g_signal_connect (editor, NM_CONNECTION_EDITOR_DONE, G_CALLBACK (edit_parent_cb), self);

	nm_connection_editor_run (editor);

}

static gboolean

connection_type_filter (FUNC_TAG_NEW_CONNECTION_TYPE_FILTER_IMPL,

                        GType type,

                        gpointer self)

{

	return nm_utils_check_virtual_device_compatibility (NM_TYPE_SETTING_VLAN, type);

}

static void

parent_changed (GtkWidget *widget, gpointer user_data)

{

	CEPageVlan *self = user_data;

	CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self);

	int active_id, parent_id;

	active_id = gtk_combo_box_get_active (GTK_COMBO_BOX (priv->parent));

	parent_id = get_parents_index (priv->parents_len, GTK_COMBO_BOX (priv->parent), active_id);

	if (parent_id == priv->parents_len - 1) {

		gtk_entry_set_text (priv->parent_entry, "");

		new_connection_dialog (priv->toplevel,

		                       CE_PAGE (self)->client,

		                       connection_type_filter,

		                       edit_parent,

		                       self);

		return;

	}

	if (parent_id > -1 && priv->parents[parent_id]->device != NULL) {

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

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

	} else {

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

		ce_page_setup_cloned_mac_combo (priv->cloned_mac, NULL);

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

		gtk_spin_button_set_value (priv->mtu, 1500);

	}

	sync_iface (self, priv->parent_entry);

	ce_page_changed (CE_PAGE (self));

}

static void

name_changed (GtkWidget *w, gpointer user_data)

{

	CEPageVlan *self = user_data;

	CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self);

	sync_iface (self, priv->name_entry);

	ce_page_changed (CE_PAGE (self));

}

static void

id_changed (GtkWidget *w, gpointer user_data)

{

	CEPageVlan *self = user_data;

	CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self);

	sync_iface (self, GTK_ENTRY (priv->id_entry));

	ce_page_changed (CE_PAGE (self));

}

static int

sort_parents (gconstpointer a, gconstpointer b)

{

	VlanParent *pa = *(VlanParent **)a;

	VlanParent *pb = *(VlanParent **)b;

	if (pa->connection && !pb->connection)

		return 1;

	else if (pb->connection && !pa->connection)

		return -1;

	return strcmp (pa->label, pb->label);

}

static GSList *

get_vlan_devices (CEPageVlan *self)

{

	const GPtrArray *devices_array;

	GSList *devices;

	NMDevice *device;

	int i;

	devices_array = nm_client_get_devices (CE_PAGE (self)->client);

	devices = NULL;

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

		device = devices_array->pdata[i];

		if (!nm_utils_check_virtual_device_compatibility (NM_TYPE_SETTING_VLAN,

		                                                  nm_device_get_setting_type (device)))

			continue;

		devices = g_slist_prepend (devices, device);

	}

	return devices;

}

static void

build_vlan_parent_list (CEPageVlan *self, GSList *devices)

{

	CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self);

	const GPtrArray *connections;

	GSList *d_iter;

	GPtrArray *parents;

	VlanParent *parent;

	NMDevice *device;

	const char *iface, *mac, *id;

	int i;

	parents = g_ptr_array_new ();

	/* Devices with no interesting 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_client_get_connections (CE_PAGE (self)->client);

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

		NMConnection *candidate = connections->pdata[i];

		NMSettingConnection *s_con = nm_connection_get_setting_connection (candidate);

		GType connection_gtype;

		if (nm_setting_connection_get_master (s_con))

			continue;

		connection_gtype = nm_setting_lookup_type (nm_setting_connection_get_connection_type (s_con));

		if (!nm_utils_check_virtual_device_compatibility (NM_TYPE_SETTING_VLAN, connection_gtype))

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

				/* Translators: the first %s is a device name (eg, "em1"), the

				 * second is a connection name (eg, "Auto Ethernet").

				 */

				parent->label = g_strdup_printf (_("%s (via “%s”)"), iface, id);

				g_ptr_array_add (parents, parent);

				/* no break here; the connection may apply to multiple devices */

			}

		}

	}

	g_ptr_array_sort (parents, sort_parents);

	parent = g_slice_new (VlanParent);

	parent->device = NULL;

	parent->connection = NULL;

	parent->label = g_strdup_printf (_("New connection…"));

	g_ptr_array_add (parents, parent);

	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;

	priv->parents_len = i;

}

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;

	guint32 flags;

	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_client_get_connection_by_uuid (CE_PAGE (self)->client, 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 char *device_mac;

		const char *mac;

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

			for (d_iter = devices; d_iter; d_iter = d_iter->next) {

				device = d_iter->data;

				if (NM_IS_DEVICE_ETHERNET (device))

					device_mac = nm_device_ethernet_get_permanent_hw_address (NM_DEVICE_ETHERNET (device));

				else

					device_mac = NULL;

				if (device_mac && nm_utils_hwaddr_matches (mac, -1, device_mac, -1)) {

					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;

		}

	}

	g_signal_connect (priv->parent, "changed", G_CALLBACK (parent_changed), self);

	ce_page_setup_data_combo (CE_PAGE (self), priv->parent, current_parent, priv->parent_labels);

	if (current_parent)

		priv->last_parent = g_strndup (current_parent, strcspn (current_parent, " "));

	/* Name */

	iface = nm_connection_get_interface_name (CE_PAGE (self)->connection);

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

		const char *mac = nm_setting_wired_get_cloned_mac_address (NM_SETTING_WIRED (priv->s_hw));

		ce_page_setup_cloned_mac_combo (priv->cloned_mac, mac);

	} else {

		ce_page_setup_cloned_mac_combo (priv->cloned_mac, NULL);

	}

	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;

	}

	ce_spin_automatic_val (priv->mtu, mtu_def);

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

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

	/* Flags */

	flags = nm_setting_vlan_get_flags (priv->setting);

	if (flags & NM_VLAN_FLAG_REORDER_HEADERS)

		gtk_toggle_button_set_active (priv->flag_reorder_hdr, TRUE);

	if (flags & NM_VLAN_FLAG_GVRP)

		gtk_toggle_button_set_active (priv->flag_gvrp, TRUE);

	if (flags & NM_VLAN_FLAG_LOOSE_BINDING)

		gtk_toggle_button_set_active (priv->flag_loose_binding, TRUE);

	if (flags & NM_VLAN_FLAG_MVRP)

		gtk_toggle_button_set_active (priv->flag_mvrp, TRUE);

	g_slist_free (devices);

}

static void

finish_setup (CEPageVlan *self, gpointer user_data)

{

	populate_ui (self);

}

CEPage *

ce_page_vlan_new (NMConnectionEditor *editor,

                  NMConnection *connection,

                  GtkWindow *parent_window,

                  NMClient *client,

                  const char **out_secrets_setting_name,

                  GError **error)

{

	CEPageVlan *self;

	CEPageVlanPrivate *priv;

	self = CE_PAGE_VLAN (ce_page_new (CE_TYPE_PAGE_VLAN,

	                                  editor,

	                                  connection,

	                                  parent_window,

	                                  client,

	                                  "/org/gnome/nm_connection_editor/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, CE_PAGE_INITIALIZED, G_CALLBACK (finish_setup), 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);

	char *cloned_mac = NULL;

	VlanParent *parent = NULL;

	int active_id, 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;

	guint32 flags = 0;

	active_id = gtk_combo_box_get_active (GTK_COMBO_BOX (priv->parent));

	parent_id = get_parents_index (priv->parents_len, GTK_COMBO_BOX (priv->parent), active_id);

	if (parent_id < 0) {

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

	/* Flags */

	if (gtk_toggle_button_get_active (priv->flag_reorder_hdr))

		flags |= NM_VLAN_FLAG_REORDER_HEADERS;

	if (gtk_toggle_button_get_active (priv->flag_gvrp))

		flags |= NM_VLAN_FLAG_GVRP;

	if (gtk_toggle_button_get_active (priv->flag_loose_binding))

		flags |= NM_VLAN_FLAG_LOOSE_BINDING;

	if (gtk_toggle_button_get_active (priv->flag_mvrp))

		flags |= NM_VLAN_FLAG_MVRP;

	g_object_set (s_con, NM_SETTING_CONNECTION_INTERFACE_NAME, *iface ? iface : NULL, NULL);

	g_object_set (priv->setting,

	              NM_SETTING_VLAN_PARENT, parent_uuid ? parent_uuid : parent_iface,

	              NM_SETTING_VLAN_ID, vid,

	              NM_SETTING_VLAN_FLAGS, flags,

	              NULL);

	if (hwtype != G_TYPE_NONE) {

		cloned_mac = ce_page_cloned_mac_get (priv->cloned_mac);

		if (cloned_mac && !*cloned_mac)

			cloned_mac = 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);

		} 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);

	g_free (cloned_mac);

}

static gboolean

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

{

	CEPageVlan *self = CE_PAGE_VLAN (page);

	CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self);

	const char *parent;

	char *parent_iface;

	if (gtk_combo_box_get_active (GTK_COMBO_BOX (priv->parent)) == -1) {

		parent = gtk_entry_get_text (priv->parent_entry);

		parent_iface = g_strndup (parent, strcspn (parent, " "));

		if (!ce_page_interface_name_valid (parent_iface, _("vlan parent"), error)) {

			g_free (parent_iface);

			return FALSE;

		}

		g_free (parent_iface);

	}

	if (!ce_page_cloned_mac_combo_valid (priv->cloned_mac, ARPHRD_ETHER, _("cloned MAC"), error))

		return FALSE;

	ui_to_setting (self);

	if (   priv->s_hw

	    && !nm_setting_verify (priv->s_hw, NULL, error))

		return FALSE;

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

}

static void

finalize (GObject *object)

{

	CEPageVlan *self = CE_PAGE_VLAN (object);

	CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self);

	int i;

	g_free (priv->last_parent);

	for (i = 0; priv->parents[i]; i++)

		g_slice_free (VlanParent, priv->parents[i]);

	g_free (priv->parents);

	G_OBJECT_CLASS (ce_page_vlan_parent_class)->finalize (object);

}

static void

ce_page_vlan_init (CEPageVlan *self)

{

}

static void

ce_page_vlan_class_init (CEPageVlanClass *vlan_class)

{

	GObjectClass *object_class = G_OBJECT_CLASS (vlan_class);

	CEPageClass *parent_class = CE_PAGE_CLASS (vlan_class);

	g_type_class_add_private (object_class, sizeof (CEPageVlanPrivate));

	/* virtual methods */

	object_class->finalize = finalize;

	parent_class->ce_page_validate_v = ce_page_validate_v;

}

void

vlan_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;

	connection = _ensure_connection_other (connection, &connection_tmp);

	ce_page_complete_connection (connection,

	                             _("VLAN connection %d"),

	                             NM_SETTING_VLAN_SETTING_NAME,

	                             TRUE,

	                             client);

	nm_connection_add_setting (connection, nm_setting_vlan_new ());

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

}