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

/* NetworkManager Connection editor -- Connection editor for NetworkManager

 *

 * Copyright 2016 Red Hat, Inc.

 */

#include "nm-default.h"

#include "page-ip-tunnel.h"

#include "nm-connection-editor.h"

G_DEFINE_TYPE (CEPageIPTunnel, ce_page_ip_tunnel, CE_TYPE_PAGE)

#define CE_PAGE_IP_TUNNEL_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), CE_TYPE_PAGE_IP_TUNNEL, CEPageIPTunnelPrivate))

typedef struct {

	NMSettingIPTunnel *setting;

	GtkEntry *name;

	GtkComboBoxText *parent;

	GtkComboBox *mode;

	GtkEntry *local;

	GtkEntry *remote;

	GtkEntry *input_key;

	GtkEntry *output_key;

	GtkSpinButton *mtu;

} CEPageIPTunnelPrivate;

static void

ip_tunnel_private_init (CEPageIPTunnel *self)

{

	CEPageIPTunnelPrivate *priv = CE_PAGE_IP_TUNNEL_GET_PRIVATE (self);

	GtkBuilder *builder;

	builder = CE_PAGE (self)->builder;

	priv->name = GTK_ENTRY (gtk_builder_get_object (builder, "ip_tunnel_name"));

	priv->parent = GTK_COMBO_BOX_TEXT (gtk_builder_get_object (builder, "ip_tunnel_parent"));

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

	priv->local = GTK_ENTRY (gtk_builder_get_object (builder, "ip_tunnel_local"));

	priv->remote = GTK_ENTRY (gtk_builder_get_object (builder, "ip_tunnel_remote"));

	priv->input_key = GTK_ENTRY (gtk_builder_get_object (builder, "ip_tunnel_ikey"));

	priv->output_key = GTK_ENTRY (gtk_builder_get_object (builder, "ip_tunnel_okey"));

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

}

static void

mode_changed (GtkComboBox *combo, gpointer user_data)

{

	CEPageIPTunnel *self = user_data;

	CEPageIPTunnelPrivate *priv = CE_PAGE_IP_TUNNEL_GET_PRIVATE (self);

	NMIPTunnelMode mode;

	gboolean enable;

	mode = gtk_combo_box_get_active (combo) + 1;

	enable = (mode == NM_IP_TUNNEL_MODE_GRE || mode == NM_IP_TUNNEL_MODE_IP6GRE);

	gtk_widget_set_sensitive (GTK_WIDGET (priv->input_key), enable);

	gtk_widget_set_sensitive (GTK_WIDGET (priv->output_key), enable);

	if (!enable) {

		gtk_entry_set_text (priv->input_key, "");

		gtk_entry_set_text (priv->output_key, "");

	}

}

static void

populate_ui (CEPageIPTunnel *self, NMConnection *connection)

{

	CEPageIPTunnelPrivate *priv = CE_PAGE_IP_TUNNEL_GET_PRIVATE (self);

	NMSettingIPTunnel *setting = priv->setting;

	NMIPTunnelMode mode;

	const char *str;

	int mtu_def;

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

	if (str)

		gtk_entry_set_text (priv->name, str);

	str = nm_setting_ip_tunnel_get_parent (setting);

	ce_page_setup_device_combo (CE_PAGE (self), GTK_COMBO_BOX (priv->parent),

	                            G_TYPE_NONE, str,

	                            NULL, NULL);

	mode = nm_setting_ip_tunnel_get_mode (setting);

	if (mode >= NM_IP_TUNNEL_MODE_IPIP && mode <= NM_IP_TUNNEL_MODE_VTI6)

		gtk_combo_box_set_active (priv->mode, mode - 1);

	str = nm_setting_ip_tunnel_get_local (setting);

	if (str)

		gtk_entry_set_text (priv->local, str);

	str = nm_setting_ip_tunnel_get_remote (setting);

	if (str)

		gtk_entry_set_text (priv->remote, str);

	str = nm_setting_ip_tunnel_get_input_key (setting);

	if (str)

		gtk_entry_set_text (priv->input_key, str);

	str = nm_setting_ip_tunnel_get_output_key (setting);

	if (str)

		gtk_entry_set_text (priv->output_key, str);

	mtu_def = ce_get_property_default (NM_SETTING (setting), NM_SETTING_IP_TUNNEL_MTU);

	ce_spin_automatic_val (priv->mtu, mtu_def);

	gtk_spin_button_set_value (priv->mtu, (gdouble) nm_setting_ip_tunnel_get_mtu (setting));

	mode_changed (priv->mode, self);

}

static void

stuff_changed (GtkEditable *editable, gpointer user_data)

{

	ce_page_changed (CE_PAGE (user_data));

}

static void

finish_setup (CEPageIPTunnel *self, gpointer user_data)

{

	CEPage *parent = CE_PAGE (self);

	CEPageIPTunnelPrivate *priv = CE_PAGE_IP_TUNNEL_GET_PRIVATE (self);

	populate_ui (self, parent->connection);

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

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

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

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

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

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

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

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

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

}

CEPage *

ce_page_ip_tunnel_new (NMConnectionEditor *editor,

                       NMConnection *connection,

                       GtkWindow *parent_window,

                       NMClient *client,

                       const char **out_secrets_setting_name,

                       GError **error)

{

	CEPageIPTunnel *self;

	CEPageIPTunnelPrivate *priv;

	self = CE_PAGE_IP_TUNNEL (ce_page_new (CE_TYPE_PAGE_IP_TUNNEL,

	                                       editor,

	                                       connection,

	                                       parent_window,

	                                       client,

	                                       "/org/gnome/nm_connection_editor/ce-page-ip-tunnel.ui",

	                                       "IPTunnelPage",

	                                       _("IP tunnel")));

	if (!self) {

		g_set_error_literal (error, NMA_ERROR, NMA_ERROR_GENERIC, _("Could not load IP tunnel user interface."));

		return NULL;

	}

	ip_tunnel_private_init (self);

	priv = CE_PAGE_IP_TUNNEL_GET_PRIVATE (self);

	priv->setting = nm_connection_get_setting_ip_tunnel (connection);

	if (!priv->setting) {

		priv->setting = NM_SETTING_IP_TUNNEL (nm_setting_ip_tunnel_new ());

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

	}

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

	return CE_PAGE (self);

}

static void

ui_to_setting (CEPageIPTunnel *self)

{

	CEPageIPTunnelPrivate *priv = CE_PAGE_IP_TUNNEL_GET_PRIVATE (self);

	NMSettingConnection *s_con;

	const char *parent = NULL;

	const char *local;

	const char *remote;

	const char *input_key;

	const char *output_key;

	NMIPTunnelMode mode;

	GtkWidget *entry;

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

	g_return_if_fail (s_con != NULL);

	g_object_set (s_con,

	              NM_SETTING_CONNECTION_INTERFACE_NAME, gtk_entry_get_text (priv->name),

	              NULL);

	entry = gtk_bin_get_child (GTK_BIN (priv->parent));

	if (entry) {

		ce_page_device_entry_get (GTK_ENTRY (entry), ARPHRD_ETHER, TRUE,

		                          (char **) &parent, NULL, NULL, NULL);

	}

	mode = gtk_combo_box_get_active (priv->mode) + 1;

	local = gtk_entry_get_text (priv->local);

	if (local && !local[0])

		local = NULL;

	remote = gtk_entry_get_text (priv->remote);

	if (remote && !remote[0])

		remote = NULL;

	input_key = gtk_entry_get_text (priv->input_key);

	if (input_key && !input_key[0])

		input_key = NULL;

	output_key = gtk_entry_get_text (priv->output_key);

	if (output_key && !output_key[0])

		output_key = NULL;

	g_object_set (priv->setting,

	              NM_SETTING_IP_TUNNEL_PARENT, parent,

	              NM_SETTING_IP_TUNNEL_MODE, mode,

	              NM_SETTING_IP_TUNNEL_LOCAL, local,

	              NM_SETTING_IP_TUNNEL_REMOTE, remote,

	              NM_SETTING_IP_TUNNEL_INPUT_KEY, input_key,

	              NM_SETTING_IP_TUNNEL_OUTPUT_KEY, output_key,

	              NM_SETTING_IP_TUNNEL_MTU, gtk_spin_button_get_value_as_int (priv->mtu),

	              NULL);

}

static gboolean

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

{

	CEPageIPTunnel *self = CE_PAGE_IP_TUNNEL (page);

	CEPageIPTunnelPrivate *priv = CE_PAGE_IP_TUNNEL_GET_PRIVATE (self);

	ui_to_setting (self);

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

}

static void

ce_page_ip_tunnel_init (CEPageIPTunnel *self)

{

}

static void

ce_page_ip_tunnel_class_init (CEPageIPTunnelClass *ip_tunnel_class)

{

	GObjectClass *object_class = G_OBJECT_CLASS (ip_tunnel_class);

	CEPageClass *parent_class = CE_PAGE_CLASS (ip_tunnel_class);

	g_type_class_add_private (object_class, sizeof (CEPageIPTunnelPrivate));

	parent_class->ce_page_validate_v = ce_page_validate_v;

}

void

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

{

	NMSetting *s_ip_tunnel;

	gs_unref_object NMConnection *connection_tmp = NULL;

	connection = _ensure_connection_other (connection, &connection_tmp);

	ce_page_complete_connection (connection,

	                             _("IP tunnel connection %d"),

	                             NM_SETTING_IP_TUNNEL_SETTING_NAME,

	                             FALSE,

	                             client);

	s_ip_tunnel = nm_setting_ip_tunnel_new ();

	g_object_set (s_ip_tunnel, NM_SETTING_IP_TUNNEL_MODE, NM_IP_TUNNEL_MODE_IPIP, NULL);

	nm_connection_add_setting (connection, s_ip_tunnel);

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

}