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

/* NetworkManager Connection editor -- Connection editor for NetworkManager

 *

 * Dan Williams <dcbw@redhat.com>

 *

 * Copyright 2008 - 2017 Red Hat, Inc.

 */

#include "nm-default.h"

#include <string.h>

#include "page-mobile.h"

#include "nm-connection-editor.h"

#include "nma-mobile-wizard.h"

G_DEFINE_TYPE (CEPageMobile, ce_page_mobile, CE_TYPE_PAGE)

#define CE_PAGE_MOBILE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), CE_TYPE_PAGE_MOBILE, CEPageMobilePrivate))

typedef struct {

	NMSetting *setting;

	/* Common to GSM and CDMA */

	GtkEntry *number;

	GtkEntry *username;

	GtkEntry *password;

	/* GSM only */

	GtkEntry *apn;

	GtkButton *apn_button;

	GtkEntry *network_id;

	GtkToggleButton *roaming_allowed;

	GtkEntry *pin;

	GtkWindowGroup *window_group;

	gboolean window_added;

} CEPageMobilePrivate;

#define NET_TYPE_ANY         0

#define NET_TYPE_3G          1

#define NET_TYPE_2G          2

#define NET_TYPE_PREFER_3G   3

#define NET_TYPE_PREFER_2G   4

#define NET_TYPE_PREFER_4G   5

#define NET_TYPE_4G          6

static void

mobile_private_init (CEPageMobile *self)

{

	CEPageMobilePrivate *priv = CE_PAGE_MOBILE_GET_PRIVATE (self);

	GtkBuilder *builder;

	builder = CE_PAGE (self)->builder;

	priv->number = GTK_ENTRY (gtk_builder_get_object (builder, "mobile_number"));

	priv->username = GTK_ENTRY (gtk_builder_get_object (builder, "mobile_username"));

	priv->password = GTK_ENTRY (gtk_builder_get_object (builder, "mobile_password"));

	priv->apn = GTK_ENTRY (gtk_builder_get_object (builder, "mobile_apn"));

	priv->apn_button = GTK_BUTTON (gtk_builder_get_object (builder, "mobile_apn_button"));

	priv->network_id = GTK_ENTRY (gtk_builder_get_object (builder, "mobile_network_id"));

	priv->roaming_allowed = GTK_TOGGLE_BUTTON (gtk_builder_get_object (builder, "mobile_roaming_allowed"));

	priv->pin = GTK_ENTRY (gtk_builder_get_object (builder, "mobile_pin"));

	priv->window_group = gtk_window_group_new ();

}

static void

populate_gsm_ui (CEPageMobile *self, NMConnection *connection)

{

	CEPageMobilePrivate *priv = CE_PAGE_MOBILE_GET_PRIVATE (self);

	NMSettingGsm *setting = NM_SETTING_GSM (priv->setting);

	const char *s;

	/* FIXME: no longer use gsm.number property. It's deprecated and has

	 * no effect for NetworkManager. */

	G_GNUC_BEGIN_IGNORE_DEPRECATIONS

	s = nm_setting_gsm_get_number (setting);

	G_GNUC_END_IGNORE_DEPRECATIONS

	if (s)

		gtk_entry_set_text (priv->number, s);

	s = nm_setting_gsm_get_username (setting);

	if (s)

		gtk_entry_set_text (priv->username, s);

	s = nm_setting_gsm_get_apn (setting);

	if (s)

		gtk_entry_set_text (priv->apn, s);

	s = nm_setting_gsm_get_network_id (setting);

	if (s)

		gtk_entry_set_text (priv->network_id, s);

	gtk_toggle_button_set_active (priv->roaming_allowed,

	                              !nm_setting_gsm_get_home_only (setting));

	s = nm_setting_gsm_get_password (setting);

	if (s)

		gtk_entry_set_text (priv->password, s);

	s = nm_setting_gsm_get_pin (setting);

	if (s)

		gtk_entry_set_text (priv->pin, s);

}

static void

populate_cdma_ui (CEPageMobile *self, NMConnection *connection)

{

	CEPageMobilePrivate *priv = CE_PAGE_MOBILE_GET_PRIVATE (self);

	NMSettingCdma *setting = NM_SETTING_CDMA (priv->setting);

	const char *s;

	s = nm_setting_cdma_get_number (setting);

	if (s)

		gtk_entry_set_text (priv->number, s);

	s = nm_setting_cdma_get_username (setting);

	if (s)

		gtk_entry_set_text (priv->username, s);

	s = nm_setting_cdma_get_password (setting);

	if (s)

		gtk_entry_set_text (priv->password, s);

	/* Hide GSM specific widgets */

	gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (CE_PAGE (self)->builder, "mobile_basic_label")));

	gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (CE_PAGE (self)->builder, "mobile_advanced_vbox")));

}

static void

stuff_changed (GtkWidget *w, gpointer user_data)

{

	ce_page_changed (CE_PAGE (user_data));

}

static void

show_passwords (GtkToggleButton *button, gpointer user_data)

{

	CEPageMobilePrivate *priv = CE_PAGE_MOBILE_GET_PRIVATE (user_data);

	gboolean active;

	active = gtk_toggle_button_get_active (button);

	gtk_entry_set_visibility (priv->password, active);

	gtk_entry_set_visibility (priv->pin, active);

}

static void

apn_button_mobile_wizard_done (NMAMobileWizard *wizard,

                               gboolean canceled,

                               NMAMobileWizardAccessMethod *method,

                               gpointer user_data)

{

	CEPageMobile *self = CE_PAGE_MOBILE (user_data);

	CEPageMobilePrivate *priv = CE_PAGE_MOBILE_GET_PRIVATE (self);

	if (canceled || !method) {

		nma_mobile_wizard_destroy (wizard);

		return;

	}

	if (!canceled && method) {

		switch (method->devtype) {

		case NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS:

			gtk_entry_set_text (GTK_ENTRY (priv->username),

			                    method->username ? method->username : "");

			gtk_entry_set_text (GTK_ENTRY (priv->password),

			                    method->password ? method->password : "");

			gtk_entry_set_text (GTK_ENTRY (priv->apn),

			                    method->gsm_apn ? method->gsm_apn : "");

			break;

		case NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO:

			gtk_entry_set_text (GTK_ENTRY (priv->username),

			                    method->username ? method->username : "");

			gtk_entry_set_text (GTK_ENTRY (priv->password),

			                    method->password ? method->password : "");

			break;

		default:

			g_assert_not_reached ();

			break;

		}

	}

	nma_mobile_wizard_destroy (wizard);

}

static void

apn_button_clicked (GtkButton *button, gpointer user_data)

{

	CEPageMobile *self = CE_PAGE_MOBILE (user_data);

	CEPageMobilePrivate *priv = CE_PAGE_MOBILE_GET_PRIVATE (self);

	NMAMobileWizard *wizard;

	GtkWidget *toplevel;

	toplevel = gtk_widget_get_toplevel (CE_PAGE (self)->page);

	g_return_if_fail (gtk_widget_is_toplevel (toplevel));

	if (!priv->window_added) {

		gtk_window_group_add_window (priv->window_group, GTK_WINDOW (toplevel));

		priv->window_added = TRUE;

	}

	wizard = nma_mobile_wizard_new (GTK_WINDOW (toplevel),

									priv->window_group,

									NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS,

									FALSE,

									apn_button_mobile_wizard_done,

									self);

	if (wizard)

		nma_mobile_wizard_present (wizard);

}

static void

network_id_filter_cb (GtkEditable *editable,

                      gchar *text,

                      gint length,

                      gint *position,

                      gpointer user_data)

{

	utils_filter_editable_on_insert_text (editable,

	                                      text, length, position, user_data,

	                                      utils_char_is_ascii_digit,

	                                      network_id_filter_cb);

}

static void

apn_filter_cb (GtkEditable *editable,

               gchar *text,

               gint length,

               gint *position,

               gpointer user_data)

{

	utils_filter_editable_on_insert_text (editable,

	                                      text, length, position, user_data,

	                                      utils_char_is_ascii_apn,

	                                      apn_filter_cb);

}

static void

finish_setup (CEPageMobile *self, gpointer user_data)

{

	CEPage *parent = CE_PAGE (self);

	CEPageMobilePrivate *priv = CE_PAGE_MOBILE_GET_PRIVATE (self);

	if (NM_IS_SETTING_GSM (priv->setting))

		populate_gsm_ui (self, parent->connection);

	else if (NM_IS_SETTING_CDMA (priv->setting))

		populate_cdma_ui (self, parent->connection);

	else

		g_assert_not_reached ();

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

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

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

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

	gtk_entry_set_max_length (priv->apn, 64);  /* APNs are max 64 chars */

	g_signal_connect (priv->apn, "insert-text", G_CALLBACK (apn_filter_cb), self);

	g_signal_connect (priv->apn_button, "clicked", G_CALLBACK (apn_button_clicked), self);

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

	gtk_entry_set_max_length (priv->network_id, 6);  /* MCC/MNCs are max 6 chars */

	g_signal_connect (priv->network_id, "insert-text", G_CALLBACK (network_id_filter_cb), self);

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

	g_signal_connect (priv->roaming_allowed, "toggled", G_CALLBACK (stuff_changed), self);

	g_signal_connect (GTK_WIDGET (gtk_builder_get_object (parent->builder, "mobile_show_passwords")),

	                  "toggled",

	                  G_CALLBACK (show_passwords),

	                  self);

}

CEPage *

ce_page_mobile_new (NMConnectionEditor *editor,

                    NMConnection *connection,

                    GtkWindow *parent_window,

                    NMClient *client,

                    const char **out_secrets_setting_name,

                    GError **error)

{

	CEPageMobile *self;

	CEPageMobilePrivate *priv;

	self = CE_PAGE_MOBILE (ce_page_new (CE_TYPE_PAGE_MOBILE,

	                                    editor,

	                                    connection,

	                                    parent_window,

	                                    client,

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

	                                    "MobilePage",

	                                    _("Mobile Broadband")));

	if (!self) {

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

		return NULL;

	}

	mobile_private_init (self);

	priv = CE_PAGE_MOBILE_GET_PRIVATE (self);

	priv->setting = nm_connection_get_setting (connection, NM_TYPE_SETTING_GSM);

	if (priv->setting)

		*out_secrets_setting_name = NM_SETTING_GSM_SETTING_NAME;

	else {

		priv->setting = nm_connection_get_setting (connection, NM_TYPE_SETTING_CDMA);

		if (priv->setting)

			*out_secrets_setting_name = NM_SETTING_CDMA_SETTING_NAME;

	}

	if (!priv->setting) {

		g_set_error (error, NMA_ERROR, NMA_ERROR_GENERIC, "%s", _("Unsupported mobile broadband connection type."));

		g_object_unref (self);

		return NULL;

	}

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

	return CE_PAGE (self);

}

static const char *

nm_entry_get_text (GtkEntry *entry)

{

	const char *txt;

	txt = gtk_entry_get_text (entry);

	if (txt && strlen (txt) > 0)

		return txt;

	return NULL;

}

static void

gsm_ui_to_setting (CEPageMobile *self)

{

	CEPageMobilePrivate *priv = CE_PAGE_MOBILE_GET_PRIVATE (self);

	gboolean roaming_allowed;

	roaming_allowed = gtk_toggle_button_get_active (priv->roaming_allowed);

	g_object_set (priv->setting,

	              NM_SETTING_GSM_NUMBER,       nm_entry_get_text (priv->number),

	              NM_SETTING_GSM_USERNAME,     nm_entry_get_text (priv->username),

	              NM_SETTING_GSM_PASSWORD,     nm_entry_get_text (priv->password),

	              NM_SETTING_GSM_APN,          nm_entry_get_text (priv->apn),

	              NM_SETTING_GSM_NETWORK_ID,   nm_entry_get_text (priv->network_id),

	              NM_SETTING_GSM_PIN,          nm_entry_get_text (priv->pin),

	              NM_SETTING_GSM_HOME_ONLY,    !roaming_allowed,

	              NULL);

}

static void

cdma_ui_to_setting (CEPageMobile *self)

{

	CEPageMobilePrivate *priv = CE_PAGE_MOBILE_GET_PRIVATE (self);

	g_object_set (priv->setting,

				  NM_SETTING_CDMA_NUMBER,   nm_entry_get_text (priv->number),

				  NM_SETTING_CDMA_USERNAME, nm_entry_get_text (priv->username),

				  NM_SETTING_CDMA_PASSWORD, nm_entry_get_text (priv->password),

				  NULL);

}

static void

ui_to_setting (CEPageMobile *self)

{

	CEPageMobilePrivate *priv = CE_PAGE_MOBILE_GET_PRIVATE (self);

	if (NM_IS_SETTING_GSM (priv->setting))

		gsm_ui_to_setting (self);

	else if (NM_IS_SETTING_CDMA (priv->setting))

		cdma_ui_to_setting (self);

	else

		g_error ("Invalid setting");

}

static gboolean

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

{

	CEPageMobile *self = CE_PAGE_MOBILE (page);

	CEPageMobilePrivate *priv = CE_PAGE_MOBILE_GET_PRIVATE (self);

	ui_to_setting (self);

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

}

static void

dispose (GObject *object)

{

	g_clear_object (&CE_PAGE_MOBILE_GET_PRIVATE (object)->window_group);

	G_OBJECT_CLASS (ce_page_mobile_parent_class)->dispose (object);

}

static void

ce_page_mobile_init (CEPageMobile *self)

{

}

static void

ce_page_mobile_class_init (CEPageMobileClass *mobile_class)

{

	GObjectClass *object_class = G_OBJECT_CLASS (mobile_class);

	CEPageClass *parent_class = CE_PAGE_CLASS (mobile_class);

	g_type_class_add_private (object_class, sizeof (CEPageMobilePrivate));

	/* virtual methods */

	parent_class->ce_page_validate_v = ce_page_validate_v;

	object_class->dispose = dispose;

}

typedef struct {

	NMClient *client;

	PageNewConnectionResultFunc result_func;

	gpointer user_data;

	NMConnection *connection;

} WizardInfo;

static void

new_connection_mobile_wizard_done (NMAMobileWizard *wizard,

                                   gboolean canceled,

                                   NMAMobileWizardAccessMethod *method,

                                   gpointer user_data)

{

	WizardInfo *info = user_data;

	if (!canceled && method) {

		NMSetting *type_setting;

		const char *ctype = NULL;

		char *detail = NULL;

		switch (method->devtype) {

		case NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS:

			ctype = NM_SETTING_GSM_SETTING_NAME;

			type_setting = nm_setting_gsm_new ();

			/* De-facto standard for GSM */

			g_object_set (type_setting,

			              NM_SETTING_GSM_NUMBER, "*99#",

			              NM_SETTING_GSM_USERNAME, method->username,

			              NM_SETTING_GSM_PASSWORD, method->password,

			              NM_SETTING_GSM_APN, method->gsm_apn,

			              NULL);

			break;

		case NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO:

			ctype = NM_SETTING_CDMA_SETTING_NAME;

			type_setting = nm_setting_cdma_new ();

			/* De-facto standard for CDMA */

			g_object_set (type_setting,

			              NM_SETTING_CDMA_NUMBER, "#777",

			              NM_SETTING_GSM_USERNAME, method->username,

			              NM_SETTING_GSM_PASSWORD, method->password,

			              NULL);

			break;

		default:

			g_assert_not_reached ();

			break;

		}

		if (method->plan_name)

			detail = g_strdup_printf ("%s %s %%d", method->provider_name, method->plan_name);

		else

			detail = g_strdup_printf ("%s connection %%d", method->provider_name);

		_ensure_connection_own (&info->connection);

		ce_page_complete_connection (info->connection,

		                             detail,

		                             ctype,

		                             FALSE,

		                             info->client);

		g_free (detail);

		nm_connection_add_setting (info->connection, type_setting);

		nm_connection_add_setting (info->connection, nm_setting_ppp_new ());

	}

	(*info->result_func) (FUNC_TAG_PAGE_NEW_CONNECTION_RESULT_CALL, info->connection, canceled, NULL, info->user_data);

	if (wizard)

		nma_mobile_wizard_destroy (wizard);

	g_object_unref (info->client);

	nm_g_object_unref (info->connection);

	g_free (info);

}

static void

cancel_dialog (GtkDialog *dialog)

{

	gtk_dialog_response (dialog, GTK_RESPONSE_CANCEL);

}

void

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

{

	NMAMobileWizard *wizard;

	WizardInfo *info;

	GtkWidget *dialog, *vbox, *gsm_radio, *cdma_radio, *label, *content, *alignment;

	GtkWidget *hbox, *image;

	gint response;

	NMAMobileWizardAccessMethod method;

	info = g_malloc0 (sizeof (WizardInfo));

	info->result_func = result_func;

	info->client = g_object_ref (client);

	info->user_data = user_data;

	info->connection = nm_g_object_ref (connection);

	wizard = nma_mobile_wizard_new (parent, NULL, NM_DEVICE_MODEM_CAPABILITY_NONE, FALSE,

	                                new_connection_mobile_wizard_done, info);

	if (wizard) {

		nma_mobile_wizard_present (wizard);

		return;

	}

	/* Fall back to just asking for GSM vs. CDMA */

	dialog = gtk_dialog_new_with_buttons (_("Select Mobile Broadband Provider Type"),

	                                      parent,

	                                      GTK_DIALOG_MODAL,

	                                      _("_Cancel"),

	                                      GTK_RESPONSE_CANCEL,

	                                      _("_OK"),

	                                      GTK_RESPONSE_OK,

	                                      NULL);

	g_signal_connect (dialog, "delete-event", G_CALLBACK (cancel_dialog), NULL);

	gtk_window_set_icon_name (GTK_WINDOW (dialog), "nm-device-wwan");

	content = gtk_dialog_get_content_area (GTK_DIALOG (dialog));

	alignment = gtk_alignment_new (0, 0, 0.5, 0.5);

	gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 12, 12, 12, 12);

	gtk_box_pack_start (GTK_BOX (content), alignment, TRUE, FALSE, 6);

	hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);

	gtk_container_add (GTK_CONTAINER (alignment), hbox);

	image = gtk_image_new_from_icon_name ("nm-device-wwan", GTK_ICON_SIZE_DIALOG);

	gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0);

	gtk_misc_set_padding (GTK_MISC (image), 0, 6);

	gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 6);

	vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);

	gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, FALSE, 0);

	label = gtk_label_new (_("Select the technology your mobile broadband provider uses. If you are unsure, ask your provider."));

	gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);

	gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);

	gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 12);

	gsm_radio = gtk_radio_button_new_with_mnemonic (NULL, _("My provider uses _GSM-based technology (i.e. GPRS, EDGE, UMTS, HSDPA)"));

	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gsm_radio), TRUE);

	gtk_box_pack_start (GTK_BOX (vbox), gsm_radio, FALSE, FALSE, 6);

	cdma_radio = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (gsm_radio),

                                           /* Translators: CDMA has 'D' accelerator key; 'C' collides with 'Cancel' button.

                                                           You may need to change it according to your language. */

                                           _("My provider uses C_DMA-based technology (i.e. 1xRTT, EVDO)"));

	gtk_box_pack_start (GTK_BOX (vbox), cdma_radio, FALSE, FALSE, 6);

	gtk_widget_show_all (dialog);

	memset (&method, 0, sizeof (method));

	response = gtk_dialog_run (GTK_DIALOG (dialog));

	if (response == GTK_RESPONSE_OK) {

		if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (cdma_radio))) {

			method.devtype = NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO;

			method.provider_name = _("CDMA");

		} else {

			method.devtype = NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS;

			method.provider_name = _("GSM");

		}

	}

	gtk_widget_destroy (dialog);

	new_connection_mobile_wizard_done (NULL,

	                                   (response != GTK_RESPONSE_OK),

	                                   (response == GTK_RESPONSE_OK) ? &method : NULL,

	                                   info);

}