// 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 <NetworkManager.h>

#include "page-master.h"

#include "nm-connection-editor.h"

G_DEFINE_TYPE (CEPageMaster, ce_page_master, CE_TYPE_PAGE)

#define CE_PAGE_MASTER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), CE_TYPE_PAGE_MASTER, CEPageMasterPrivate))

typedef struct {

	const char *uuid;

	GtkWindow *toplevel;

	GtkEntry *interface_name;

	GtkTreeView *connections;

	GtkTreeModel *connections_model;

	GtkButton *add, *edit, *delete;

	GHashTable *new_slaves;  /* track whether some slave(s) were added */

} CEPageMasterPrivate;

static void finish_setup (CEPageMaster *self, gpointer user_data);

enum {

	COL_CONNECTION,

	COL_NAME

};

static int

name_sort_func (GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer user_data)

{

	NMConnection *conn_a, *conn_b;

	int ret;

	/* We fetch COL_CONNECTION rather than COL_NAME to avoid a strdup/free. */

	gtk_tree_model_get (model, a, COL_CONNECTION, &conn_a, -1);

	gtk_tree_model_get (model, b, COL_CONNECTION, &conn_b, -1);

	ret = strcmp (nm_connection_get_id (conn_a), nm_connection_get_id (conn_b));

	g_object_unref (conn_a);

	g_object_unref (conn_b);

	return ret;

}

static void

constructed (GObject *object)

{

	CEPageMaster *self = CE_PAGE_MASTER (object);

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

	G_OBJECT_CLASS (ce_page_master_parent_class)->constructed (object);

}

static void

dispose (GObject *object)

{

	CEPageMaster *self = CE_PAGE_MASTER (object);

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	GtkTreeIter iter;

	g_signal_handlers_disconnect_matched (CE_PAGE (self)->client, G_SIGNAL_MATCH_DATA,

	                                      0, 0, NULL, NULL, self);

	if (gtk_tree_model_get_iter_first (priv->connections_model, &iter)) {

		do {

			NMRemoteConnection *connection = NULL;

			gtk_tree_model_get (priv->connections_model, &iter,

			                    COL_CONNECTION, &connection,

			                    -1);

			g_signal_handlers_disconnect_matched (connection, G_SIGNAL_MATCH_DATA,

			                                      0, 0, NULL, NULL, self);

			g_object_unref (connection);

		} while (gtk_tree_model_iter_next (priv->connections_model, &iter));

	}

	g_hash_table_destroy (priv->new_slaves);

	G_OBJECT_CLASS (ce_page_master_parent_class)->dispose (object);

}

static void

stuff_changed (GtkWidget *widget, gpointer user_data)

{

	ce_page_changed (CE_PAGE (user_data));

}

static gboolean

find_connection (CEPageMaster *self, NMRemoteConnection *connection, GtkTreeIter *iter)

{

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	if (!gtk_tree_model_get_iter_first (priv->connections_model, iter))

		return FALSE;

	do {

		NMRemoteConnection *candidate = NULL;

		gtk_tree_model_get (priv->connections_model, iter,

		                    COL_CONNECTION, &candidate,

		                    -1);

		if (candidate == connection)

			return TRUE;

	} while (gtk_tree_model_iter_next (priv->connections_model, iter));

	return FALSE;

}

static void

connection_removed (NMClient *client,

                    NMRemoteConnection *connection,

                    gpointer user_data)

{

	CEPageMaster *self = CE_PAGE_MASTER (user_data);

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	GtkTreeIter iter;

	if (!find_connection (self, connection, &iter))

		return;

	gtk_list_store_remove (GTK_LIST_STORE (priv->connections_model), &iter);

	ce_page_changed (CE_PAGE (self));

}

static void

connection_changed (NMRemoteConnection *connection, gpointer user_data)

{

	CEPageMaster *self = CE_PAGE_MASTER (user_data);

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	GtkTreeIter iter;

	NMSettingConnection *s_con;

	if (!find_connection (self, connection, &iter))

		return;

	/* Name might have changed */

	s_con = nm_connection_get_setting_connection (NM_CONNECTION (connection));

	gtk_list_store_set (GTK_LIST_STORE (priv->connections_model), &iter,

	                    COL_NAME, nm_setting_connection_get_id (s_con),

	                    -1);

}

static NMDevice *

get_device_for_connection (NMClient *client, NMConnection *conn)

{

	const GPtrArray *devices;

	NMSettingConnection *s_con;

	int i;

	devices = nm_client_get_devices (client);

	if (!devices)

		return NULL;

	/* Make sure the connection is actually locked to a specific device */

	s_con = nm_connection_get_setting_connection (conn);

	if (   !nm_setting_connection_get_interface_name (s_con)

	       && !nm_connection_get_interface_name (conn)) {

		NMSetting *s_hw;

		gs_free char *mac_address = NULL;

		s_hw = nm_connection_get_setting_by_name (conn, nm_setting_connection_get_connection_type (s_con));

		if (!s_hw || !g_object_class_find_property (G_OBJECT_GET_CLASS (s_hw), "mac-address"))

			return NULL;

		g_object_get (G_OBJECT (s_hw), "mac-address", &mac_address, NULL);

		if (!mac_address)

			return NULL;

	}

	/* OK, now find that device */

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

		NMDevice *device = devices->pdata[i];

		if (nm_device_connection_compatible (device, conn, NULL))

			return device;

	}

	return NULL;

}

static void

check_new_slave_physical_port (CEPageMaster *self, NMConnection *conn)

{

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	NMConnection *conn2;

	NMDevice *dev, *dev2;

	const char *id, *id2;

	GtkTreeIter iter;

	dev = get_device_for_connection (CE_PAGE (self)->client, conn);

	if (!dev)

		return;

	id = nm_device_get_physical_port_id (dev);

	if (!id)

		return;

	if (!gtk_tree_model_get_iter_first (priv->connections_model, &iter))

		return;

	do {

		gtk_tree_model_get (priv->connections_model, &iter, 0, &conn2, -1);

		g_object_unref (conn2); /* gtk_tree_model_get() adds a ref */

		dev2 = get_device_for_connection (CE_PAGE (self)->client, conn2);

		if (!dev2)

			continue;

		if (dev == dev2) {

			nm_connection_editor_warning (CE_PAGE (self)->parent_window,

			                              _("Duplicate slaves"),

			                              _("Slaves “%s” and “%s” both apply to device “%s”"),

			                              nm_connection_get_id (conn),

			                              nm_connection_get_id (conn2),

			                              nm_device_get_iface (dev));

			return;

		}

		id2 = nm_device_get_physical_port_id (dev2);

		if (self->aggregating && id && id2 && !strcmp (id, id2)) {

			nm_connection_editor_warning (CE_PAGE (self)->parent_window,

			                              _("Duplicate slaves"),

			                              _("Slaves “%s” and “%s” apply to different virtual "

			                                "ports (“%s” and “%s”) of the same physical device."),

			                              nm_connection_get_id (conn),

			                              nm_connection_get_id (conn2),

			                              nm_device_get_iface (dev),

			                              nm_device_get_iface (dev2));

			return;

		}

	} while (gtk_tree_model_iter_next (priv->connections_model, &iter));

}

static void

connection_added (NMClient *client,

                  NMRemoteConnection *connection,

                  gpointer user_data)

{

	CEPageMaster *self = CE_PAGE_MASTER (user_data);

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	NMSettingConnection *s_con;

	const char *master_type;

	const char *slave_type, *master;

	const char *interface_name;

	GtkTreeIter iter;

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

	master_type = nm_setting_connection_get_connection_type (s_con);

	s_con = nm_connection_get_setting_connection (NM_CONNECTION (connection));

	if (!s_con)

		return;

	slave_type = nm_setting_connection_get_slave_type (s_con);

	if (g_strcmp0 (slave_type, master_type) != 0)

		return;

	master = nm_setting_connection_get_master (s_con);

	if (!master)

		return;

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

	if (g_strcmp0 (master, interface_name) != 0 && g_strcmp0 (master, priv->uuid) != 0)

		return;

	check_new_slave_physical_port (self, NM_CONNECTION (connection));

	gtk_list_store_append (GTK_LIST_STORE (priv->connections_model), &iter);

	gtk_list_store_set (GTK_LIST_STORE (priv->connections_model), &iter,

	                    COL_CONNECTION, connection,

	                    COL_NAME, nm_setting_connection_get_id (s_con),

	                    -1);

	ce_page_changed (CE_PAGE (self));

	g_signal_connect (client, NM_CLIENT_CONNECTION_REMOVED,

	                  G_CALLBACK (connection_removed), self);

	g_signal_connect (connection, NM_CONNECTION_CHANGED,

	                  G_CALLBACK (connection_changed), self);

}

static void

connections_selection_changed_cb (GtkTreeSelection *selection, gpointer user_data)

{

	CEPageMaster *self = user_data;

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	GtkTreeIter iter;

	GtkTreeModel *model;

	NMRemoteConnection *connection;

	NMSettingConnection *s_con;

	gboolean sensitive = FALSE;

	if (gtk_tree_selection_get_selected (selection, &model, &iter)) {

		gtk_tree_model_get (model, &iter,

		                    0, &connection,

		                    -1);

		s_con = nm_connection_get_setting_connection (NM_CONNECTION (connection));

		g_assert (s_con);

		sensitive = !nm_setting_connection_get_read_only (s_con);

	}

	gtk_widget_set_sensitive (GTK_WIDGET (priv->edit), sensitive);

	gtk_widget_set_sensitive (GTK_WIDGET (priv->delete), sensitive);

}

static void

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

{

	CEPageMaster *self = user_data;

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	const char *uuid;

	if (response == GTK_RESPONSE_OK) {

		uuid = nm_connection_get_uuid (editor->connection);

		g_hash_table_add (priv->new_slaves, g_strdup (uuid));

	}

	g_object_unref (editor);

}

static void

add_connection (FUNC_TAG_NEW_CONNECTION_RESULT_IMPL,

                NMConnection *connection,

                gpointer user_data)

{

	CEPageMaster *self = user_data;

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	NMSettingConnection *s_con;

	NMConnectionEditor *editor;

	const char *iface_name, *master_type;

	char *name;

	if (!connection)

		return;

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

	master_type = nm_setting_connection_get_connection_type (s_con);

	/* Mark the connection as a slave, and rename it. */

	s_con = nm_connection_get_setting_connection (connection);

	g_assert (s_con != NULL);

	iface_name = gtk_entry_get_text (priv->interface_name);

	if (!*iface_name)

		iface_name = nm_connection_get_interface_name (connection);

	if (!iface_name || !nm_utils_is_valid_iface_name (iface_name, NULL))

		iface_name = nm_connection_get_id (connection);

	name = g_strdup_printf (_("%s slave %d"), iface_name,

	                        gtk_tree_model_iter_n_children (priv->connections_model, NULL) + 1);

	g_object_set (G_OBJECT (s_con),

	              NM_SETTING_CONNECTION_ID, name,

	              NM_SETTING_CONNECTION_MASTER, priv->uuid,

	              NM_SETTING_CONNECTION_SLAVE_TYPE, master_type,

	              NM_SETTING_CONNECTION_AUTOCONNECT, TRUE,

	              NULL);

	g_free (name);

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

	if (!editor)

		return;

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

	nm_connection_editor_run (editor);

}

static void

add_clicked (GtkButton *button, gpointer user_data)

{

	CEPageMaster *self = user_data;

	CE_PAGE_MASTER_GET_CLASS (self)->add_slave (self, add_connection);

}

static NMRemoteConnection *

get_selected_connection (CEPageMaster *self)

{

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	GtkTreeSelection *selection;

	GList *selected_rows;

	GtkTreeModel *model = NULL;

	GtkTreeIter iter;

	NMRemoteConnection *connection = NULL;

	selection = gtk_tree_view_get_selection (priv->connections);

	selected_rows = gtk_tree_selection_get_selected_rows (selection, &model);

	if (!selected_rows)

		return NULL;

	if (gtk_tree_model_get_iter (model, &iter, (GtkTreePath *) selected_rows->data))

		gtk_tree_model_get (model, &iter, 0, &connection, -1);

	g_list_free_full (selected_rows, (GDestroyNotify) gtk_tree_path_free);

	return connection;

}

static void

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

{

	g_object_unref (editor);

}

static void

edit_clicked (GtkButton *button, gpointer user_data)

{

	CEPageMaster *self = user_data;

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	NMConnectionEditor *editor;

	NMRemoteConnection *connection;

	connection = get_selected_connection (self);

	if (!connection)

		return;

	editor = nm_connection_editor_get (NM_CONNECTION (connection));

	if (editor) {

		nm_connection_editor_present (editor);

		return;

	}

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

	if (!editor)

		return;

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

	nm_connection_editor_run (editor);

}

static void

connection_double_clicked_cb (GtkTreeView *tree_view,

                              GtkTreePath *path,

                              GtkTreeViewColumn *column,

                              gpointer user_data)

{

	edit_clicked (NULL, user_data);

}

static void

delete_result_cb (FUNC_TAG_DELETE_CONNECTION_RESULT_IMPL,

                  NMRemoteConnection *connection,

                  gboolean deleted,

                  gpointer user_data)

{

	CEPageMaster *self = user_data;

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	if (deleted) {

		g_hash_table_remove (priv->new_slaves,

		                     nm_connection_get_uuid (NM_CONNECTION (connection)));

	}

}

static void

delete_clicked (GtkButton *button, gpointer user_data)

{

	CEPageMaster *self = user_data;

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	NMRemoteConnection *connection;

	connection = get_selected_connection (self);

	if (!connection)

		return;

	delete_connection (priv->toplevel, connection, delete_result_cb, self);

}

static void

populate_ui (CEPageMaster *self)

{

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	NMSettingConnection *s_con;

	const char *iface;

	const GPtrArray *connections;

	int i;

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

	g_return_if_fail (s_con != NULL);

	/* Interface name */

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

	gtk_entry_set_text (priv->interface_name, iface ? iface : "");

	/* Slave connections */

	connections = nm_client_get_connections (CE_PAGE (self)->client);

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

		connection_added (CE_PAGE (self)->client, connections->pdata[i], self);

}

static void

finish_setup (CEPageMaster *self, gpointer user_data)

{

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	GtkTreeSelection *selection;

	GtkBuilder *builder;

	NMSettingConnection *s_con;

	builder = CE_PAGE (self)->builder;

	priv->interface_name = GTK_ENTRY (gtk_builder_get_object (builder, "master_interface"));

	priv->connections = GTK_TREE_VIEW (gtk_builder_get_object (builder, "master_connections"));

	priv->connections_model = GTK_TREE_MODEL (gtk_builder_get_object (builder, "master_connections_model"));

	gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (priv->connections_model),

	                                 COL_NAME, name_sort_func,

	                                 NULL, NULL);

	gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (priv->connections_model),

	                                      COL_NAME, GTK_SORT_ASCENDING);

	priv->add = GTK_BUTTON (gtk_builder_get_object (builder, "master_connection_add"));

	priv->edit = GTK_BUTTON (gtk_builder_get_object (builder, "master_connection_edit"));

	priv->delete = GTK_BUTTON (gtk_builder_get_object (builder, "master_connection_delete"));

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

	                                                      GTK_TYPE_WINDOW));

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

	priv->uuid = nm_setting_connection_get_uuid (s_con);

	populate_ui (self);

	g_signal_connect (CE_PAGE (self)->client, NM_CLIENT_CONNECTION_ADDED,

	                  G_CALLBACK (connection_added), self);

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

	g_signal_connect (priv->add, "clicked", G_CALLBACK (add_clicked), self);

	g_signal_connect (priv->edit, "clicked", G_CALLBACK (edit_clicked), self);

	g_signal_connect (priv->delete, "clicked", G_CALLBACK (delete_clicked), self);

	g_signal_connect (priv->connections, "row-activated", G_CALLBACK (connection_double_clicked_cb), self);

	selection = gtk_tree_view_get_selection (priv->connections);

	g_signal_connect (selection, "changed", G_CALLBACK (connections_selection_changed_cb), self);

	connections_selection_changed_cb (selection, self);

}

static void

ui_to_setting (CEPageMaster *self)

{

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	NMSettingConnection *s_con;

	const char *interface_name;

	/* Interface name */

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

	interface_name = gtk_entry_get_text (priv->interface_name);

	if (!*interface_name)

		interface_name = NULL;

	g_object_set (s_con, "interface-name", interface_name, NULL);

	/* Slaves are updated as they're edited, so nothing to do */

}

static gboolean

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

{

	CEPageMaster *self = CE_PAGE_MASTER (page);

	/* We don't need to recursively check that the slaves connections

	 * are valid because they can't end up in the table if they're not.

	 */

	ui_to_setting (self);

	/* Subtype ce_page_validate_v() method will validate the interface name */

	return TRUE;

}

static gboolean

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

{

	CEPageMaster *self = CE_PAGE_MASTER (page);

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	const char *interface_name, *tmp, *uuid;

	NMSettingConnection *s_con;

	GtkTreeIter iter;

	/* No new slave added - leave master property as it is. */

	if (g_hash_table_size (priv->new_slaves) == 0)

		return TRUE;

	/*

	 * Set master property of all slaves to be the interface name.

	 * Even if UUID has the advantage of being stable and thus easier to use,

	 * users may prefer using interface name instead.

	*/

	interface_name = gtk_entry_get_text (priv->interface_name);

	if (gtk_tree_model_get_iter_first (priv->connections_model, &iter)) {

		do {

			NMRemoteConnection *rcon = NULL;

			gtk_tree_model_get (priv->connections_model, &iter,

			                    COL_CONNECTION, &rcon,

			                    -1);

			tmp = nm_connection_get_interface_name (NM_CONNECTION (rcon));

			uuid = nm_connection_get_uuid (NM_CONNECTION (rcon));

			if (   g_hash_table_contains (priv->new_slaves, uuid)

			    && g_strcmp0 (interface_name, tmp) != 0) {

				s_con = nm_connection_get_setting_connection (NM_CONNECTION (rcon));

				g_object_set (s_con, NM_SETTING_CONNECTION_MASTER, interface_name, NULL);

				nm_remote_connection_commit_changes_async (rcon, TRUE, NULL, NULL, NULL);

			}

			g_object_unref (rcon);

		} while (gtk_tree_model_iter_next (priv->connections_model, &iter));

	}

	return TRUE;

}

static void

ce_page_master_init (CEPageMaster *self)

{

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	priv->new_slaves = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);

}

static void

ce_page_master_class_init (CEPageMasterClass *master_class)

{

	GObjectClass *object_class = G_OBJECT_CLASS (master_class);

	CEPageClass *parent_class = CE_PAGE_CLASS (master_class);

	g_type_class_add_private (object_class, sizeof (CEPageMasterPrivate));

	/* virtual methods */

	object_class->constructed = constructed;

	object_class->dispose = dispose;

	parent_class->ce_page_validate_v = ce_page_validate_v;

	parent_class->last_update = last_update;

}

gboolean

ce_page_master_has_slaves (CEPageMaster *self)

{

	CEPageMasterPrivate *priv = CE_PAGE_MASTER_GET_PRIVATE (self);

	GtkTreeIter iter;

	return gtk_tree_model_get_iter_first (priv->connections_model, &iter);

}