Adding upstream version 1.4.34+dfsg.upstream/1.4.34+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2226 insertions, 0 deletions

diff --git a/src/remmina_protocol_widget.c b/src/remmina_protocol_widget.c
new file mode 100644
index 0000000..7becda0
--- /dev/null
+++ b/src/remmina_protocol_widget.c
@@ -0,0 +1,2226 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009-2011 Vic Lee
+ * Copyright (C) 2014-2015 Antenore Gatta, Fabio Castelli, Giovanni Panozzo
+ * Copyright (C) 2016-2023 Antenore Gatta, Giovanni Panozzo
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301, USA.
+ *
+ *  In addition, as a special exception, the copyright holders give
+ *  permission to link the code of portions of this program with the
+ *  OpenSSL library under certain conditions as described in each
+ *  individual source file, and distribute linked combinations
+ *  including the two.
+ *  You must obey the GNU General Public License in all respects
+ *  for all of the code used other than OpenSSL. *  If you modify
+ *  file(s) with this exception, you may extend this exception to your
+ *  version of the file(s), but you are not obligated to do so. *  If you
+ *  do not wish to do so, delete this exception statement from your
+ *  version. *  If you delete this exception statement from all source
+ *  files in the program, then also delete it here.
+ *
+ */
+
+#include "config.h"
+
+#include <gtk/gtk.h>
+#include <gtk/gtkx.h>
+#include <glib/gi18n.h>
+#include <gmodule.h>
+#include <stdlib.h>
+
+#include "remmina_chat_window.h"
+#include "remmina_masterthread_exec.h"
+#include "remmina_ext_exec.h"
+#include "remmina_plugin_manager.h"
+#include "remmina_pref.h"
+#include "remmina_protocol_widget.h"
+#include "remmina_public.h"
+#include "remmina_ssh.h"
+#include "remmina_log.h"
+#include "remmina/remmina_trace_calls.h"
+
+#ifdef GDK_WINDOWING_WAYLAND
+#include <gdk/gdkwayland.h>
+#endif
+
+struct _RemminaProtocolWidgetPriv {
+	RemminaFile *		remmina_file;
+	RemminaProtocolPlugin * plugin;
+	RemminaProtocolFeature *features;
+
+	gint			width;
+	gint			height;
+	RemminaScaleMode	scalemode;
+	gboolean		scaler_expand;
+
+	gboolean		has_error;
+	gchar *			error_message;
+	gboolean		user_disconnect;
+	/* ssh_tunnels is an array of RemminaSSHTunnel*
+	 * the 1st one is the "main" tunnel, other tunnels are used for example in sftp commands */
+	GPtrArray *		ssh_tunnels;
+	RemminaTunnelInitFunc	init_func;
+
+	GtkWidget *		chat_window;
+
+	gboolean		closed;
+
+	RemminaHostkeyFunc	hostkey_func;
+
+	gint			profile_remote_width;
+	gint			profile_remote_height;
+	gint			multimon;
+
+	RemminaMessagePanel *	connect_message_panel;
+	RemminaMessagePanel *	listen_message_panel;
+	RemminaMessagePanel *	auth_message_panel;
+	RemminaMessagePanel *	retry_message_panel;
+
+	/* Data saved from the last message_panel when the user confirm */
+	gchar *			username;
+	gchar *			password;
+	gchar *			domain;
+	gboolean		save_password;
+
+	gchar *			cacert;
+	gchar *			cacrl;
+	gchar *			clientcert;
+	gchar *			clientkey;
+};
+
+enum panel_type {
+	RPWDT_AUTH,
+	RPWDT_QUESTIONYESNO,
+	RPWDT_AUTHX509
+};
+
+G_DEFINE_TYPE(RemminaProtocolWidget, remmina_protocol_widget, GTK_TYPE_EVENT_BOX)
+
+enum {
+	CONNECT_SIGNAL,
+	DISCONNECT_SIGNAL,
+	DESKTOP_RESIZE_SIGNAL,
+	UPDATE_ALIGN_SIGNAL,
+	LOCK_DYNRES_SIGNAL,
+	UNLOCK_DYNRES_SIGNAL,
+	LAST_SIGNAL
+};
+
+typedef struct _RemminaProtocolWidgetSignalData {
+	RemminaProtocolWidget * gp;
+	const gchar *		signal_name;
+} RemminaProtocolWidgetSignalData;
+
+static guint remmina_protocol_widget_signals[LAST_SIGNAL] =
+{ 0 };
+
+static void remmina_protocol_widget_class_init(RemminaProtocolWidgetClass *klass)
+{
+	TRACE_CALL(__func__);
+	remmina_protocol_widget_signals[CONNECT_SIGNAL] = g_signal_new("connect", G_TYPE_FROM_CLASS(klass),
+								       G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaProtocolWidgetClass, connect), NULL, NULL,
+								       g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+	remmina_protocol_widget_signals[DISCONNECT_SIGNAL] = g_signal_new("disconnect", G_TYPE_FROM_CLASS(klass),
+									  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaProtocolWidgetClass, disconnect), NULL, NULL,
+									  g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+	remmina_protocol_widget_signals[DESKTOP_RESIZE_SIGNAL] = g_signal_new("desktop-resize", G_TYPE_FROM_CLASS(klass),
+									      G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaProtocolWidgetClass, desktop_resize), NULL, NULL,
+									      g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+	remmina_protocol_widget_signals[UPDATE_ALIGN_SIGNAL] = g_signal_new("update-align", G_TYPE_FROM_CLASS(klass),
+									    G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaProtocolWidgetClass, update_align), NULL, NULL,
+									    g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+	remmina_protocol_widget_signals[LOCK_DYNRES_SIGNAL] = g_signal_new("lock-dynres", G_TYPE_FROM_CLASS(klass),
+									   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaProtocolWidgetClass, lock_dynres), NULL, NULL,
+									   g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+	remmina_protocol_widget_signals[UNLOCK_DYNRES_SIGNAL] = g_signal_new("unlock-dynres", G_TYPE_FROM_CLASS(klass),
+									     G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaProtocolWidgetClass, unlock_dynres), NULL, NULL,
+									     g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+}
+
+
+static void remmina_protocol_widget_close_all_tunnels(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	int i;
+
+	if (gp->priv && gp->priv->ssh_tunnels) {
+		for (i = 0; i < gp->priv->ssh_tunnels->len; i++) {
+#ifdef HAVE_LIBSSH
+			remmina_ssh_tunnel_free((RemminaSSHTunnel *)gp->priv->ssh_tunnels->pdata[i]);
+#else
+			REMMINA_DEBUG("LibSSH support turned off, no need to free SSH tunnel data");
+#endif
+		}
+		g_ptr_array_set_size(gp->priv->ssh_tunnels, 0);
+	}
+}
+
+
+static void remmina_protocol_widget_destroy(RemminaProtocolWidget *gp, gpointer data)
+{
+	TRACE_CALL(__func__);
+
+	g_free(gp->priv->username);
+	gp->priv->username = NULL;
+
+	g_free(gp->priv->password);
+	gp->priv->password = NULL;
+
+	g_free(gp->priv->domain);
+	gp->priv->domain = NULL;
+
+	g_free(gp->priv->cacert);
+	gp->priv->cacert = NULL;
+
+	g_free(gp->priv->cacrl);
+	gp->priv->cacrl = NULL;
+
+	g_free(gp->priv->clientcert);
+	gp->priv->clientcert = NULL;
+
+	g_free(gp->priv->clientkey);
+	gp->priv->clientkey = NULL;
+
+	g_free(gp->priv->features);
+	gp->priv->features = NULL;
+
+	g_free(gp->priv->error_message);
+	gp->priv->error_message = NULL;
+
+	g_free(gp->priv->remmina_file);
+	gp->priv->remmina_file = NULL;
+
+	g_free(gp->priv);
+	gp->priv = NULL;
+
+	remmina_protocol_widget_close_all_tunnels(gp);
+
+	if (gp->priv && gp->priv->ssh_tunnels) {
+		g_ptr_array_free(gp->priv->ssh_tunnels, TRUE);
+		gp->priv->ssh_tunnels = NULL;
+	}
+}
+
+void remmina_protocol_widget_grab_focus(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *child;
+
+	child = gtk_bin_get_child(GTK_BIN(gp));
+
+	if (child) {
+		gtk_widget_set_can_focus(child, TRUE);
+		gtk_widget_grab_focus(child);
+	}
+}
+
+static void remmina_protocol_widget_init(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidgetPriv *priv;
+
+	priv = g_new0(RemminaProtocolWidgetPriv, 1);
+	gp->priv = priv;
+	gp->priv->user_disconnect = FALSE;
+	gp->priv->closed = TRUE;
+	gp->priv->ssh_tunnels = g_ptr_array_new();
+
+	g_signal_connect(G_OBJECT(gp), "destroy", G_CALLBACK(remmina_protocol_widget_destroy), NULL);
+}
+
+void remmina_protocol_widget_open_connection_real(gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = REMMINA_PROTOCOL_WIDGET(data);
+
+	REMMINA_DEBUG("Opening connection");
+
+	RemminaProtocolPlugin *plugin;
+	RemminaProtocolFeature *feature;
+	gint num_plugin;
+	gint num_ssh;
+
+	gp->priv->closed = FALSE;
+
+	plugin = gp->priv->plugin;
+	plugin->init(gp);
+
+	for (num_plugin = 0, feature = (RemminaProtocolFeature *)plugin->features; feature && feature->type; num_plugin++, feature++) {
+	}
+
+	num_ssh = 0;
+#ifdef HAVE_LIBSSH
+	if (remmina_file_get_int(gp->priv->remmina_file, "ssh_tunnel_enabled", FALSE))
+		num_ssh += 2;
+
+#endif
+	if (num_plugin + num_ssh == 0) {
+		gp->priv->features = NULL;
+	} else {
+		gp->priv->features = g_new0(RemminaProtocolFeature, num_plugin + num_ssh + 1);
+		feature = gp->priv->features;
+		if (plugin->features) {
+			memcpy(feature, plugin->features, sizeof(RemminaProtocolFeature) * num_plugin);
+			feature += num_plugin;
+		}
+#ifdef HAVE_LIBSSH
+		REMMINA_DEBUG("Have SSH");
+		if (num_ssh) {
+			feature->type = REMMINA_PROTOCOL_FEATURE_TYPE_TOOL;
+			feature->id = REMMINA_PROTOCOL_FEATURE_TOOL_SSH;
+			feature->opt1 = _("Connect via SSH from a new terminal");
+			feature->opt1_type_hint = REMMINA_TYPEHINT_STRING;
+			feature->opt2 = "utilities-terminal";
+			feature->opt2_type_hint = REMMINA_TYPEHINT_STRING;
+			feature->opt3 = NULL;
+			feature->opt3_type_hint = REMMINA_TYPEHINT_UNDEFINED;
+			feature++;
+
+			feature->type = REMMINA_PROTOCOL_FEATURE_TYPE_TOOL;
+			feature->id = REMMINA_PROTOCOL_FEATURE_TOOL_SFTP;
+			feature->opt1 = _("Open SFTP transfer…");
+			feature->opt1_type_hint = REMMINA_TYPEHINT_STRING;
+			feature->opt2 = "folder-remote";
+			feature->opt2_type_hint = REMMINA_TYPEHINT_STRING;
+			feature->opt3 = NULL;
+			feature->opt3_type_hint = REMMINA_TYPEHINT_UNDEFINED;
+			feature++;
+		}
+		feature->type = REMMINA_PROTOCOL_FEATURE_TYPE_END;
+#endif
+	}
+
+	if (!plugin->open_connection(gp))
+		remmina_protocol_widget_close_connection(gp);
+}
+
+static void cancel_open_connection_cb(void *cbdata, int btn)
+{
+	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)cbdata;
+
+	remmina_protocol_widget_close_connection(gp);
+}
+
+void remmina_protocol_widget_open_connection(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	gchar *s;
+	const gchar *name;
+	RemminaMessagePanel *mp;
+
+	/* Exec precommand before everything else */
+	mp = remmina_message_panel_new();
+	remmina_message_panel_setup_progress(mp, _("Executing external commands…"), NULL, NULL);
+	rco_show_message_panel(gp->cnnobj, mp);
+
+	remmina_ext_exec_new(gp->priv->remmina_file, "precommand");
+	rco_destroy_message_panel(gp->cnnobj, mp);
+
+	name = remmina_file_get_string(gp->priv->remmina_file, "name");
+	// TRANSLATORS: “%s” is a placeholder for the connection profile name
+	s = g_strdup_printf(_("Connecting to “%s”…"), (name ? name : "*"));
+
+	mp = remmina_message_panel_new();
+	remmina_message_panel_setup_progress(mp, s, cancel_open_connection_cb, gp);
+	g_free(s);
+	gp->priv->connect_message_panel = mp;
+	rco_show_message_panel(gp->cnnobj, mp);
+
+	remmina_protocol_widget_open_connection_real(gp);
+}
+
+static gboolean conn_closed_real(gpointer data, int button){
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)data;
+
+	#ifdef HAVE_LIBSSH
+	/* This will close all tunnels */
+	remmina_protocol_widget_close_all_tunnels(gp);
+#endif
+	/* Exec postcommand */
+	remmina_ext_exec_new(gp->priv->remmina_file, "postcommand");
+	/* Notify listeners (usually rcw) that the connection is closed */
+	g_signal_emit_by_name(G_OBJECT(gp), "disconnect");
+	return G_SOURCE_REMOVE;
+
+}
+
+static gboolean conn_closed(gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)data;
+	int disconnect_prompt = remmina_file_get_int(gp->priv->remmina_file, "disconnect-prompt", FALSE);
+	if (!gp->priv->user_disconnect && !gp->priv->has_error && disconnect_prompt){
+		const char* msg = "Plugin Disconnected";
+		if (gp->priv->has_error){
+			msg = remmina_protocol_widget_get_error_message(gp);
+			remmina_protocol_widget_set_error(gp, NULL);
+		}
+		gp->priv->user_disconnect = FALSE;
+		RemminaMessagePanel* mp = remmina_message_panel_new();
+		remmina_message_panel_setup_message(mp, msg, (RemminaMessagePanelCallback)conn_closed_real, gp);
+		rco_show_message_panel(gp->cnnobj, mp);
+		return G_SOURCE_REMOVE;
+	}
+	else{
+		return conn_closed_real(gp, 0);
+	}
+
+}
+
+void remmina_protocol_widget_signal_connection_closed(RemminaProtocolWidget *gp)
+{
+	/* User told us that they closed the connection,
+	 * or the connection was closed with a known error,
+	 * add async event to main thread to complete our close tasks */
+	TRACE_CALL(__func__);
+	gp->priv->closed = TRUE;
+	g_idle_add(conn_closed, (gpointer)gp);
+}
+
+static gboolean conn_opened(gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)data;
+
+#ifdef HAVE_LIBSSH
+	if (gp->priv->ssh_tunnels) {
+		for (guint i = 0; i < gp->priv->ssh_tunnels->len; i++)
+			remmina_ssh_tunnel_cancel_accept((RemminaSSHTunnel *)gp->priv->ssh_tunnels->pdata[i]);
+	}
+#endif
+	if (gp->priv->listen_message_panel) {
+		rco_destroy_message_panel(gp->cnnobj, gp->priv->listen_message_panel);
+		gp->priv->listen_message_panel = NULL;
+	}
+	if (gp->priv->connect_message_panel) {
+		rco_destroy_message_panel(gp->cnnobj, gp->priv->connect_message_panel);
+		gp->priv->connect_message_panel = NULL;
+	}
+	if (gp->priv->retry_message_panel) {
+		rco_destroy_message_panel(gp->cnnobj, gp->priv->retry_message_panel);
+		gp->priv->retry_message_panel = NULL;
+	}
+	g_signal_emit_by_name(G_OBJECT(gp), "connect");
+	return G_SOURCE_REMOVE;
+}
+
+void remmina_protocol_widget_signal_connection_opened(RemminaProtocolWidget *gp)
+{
+	/* Plugin told us that it opened the connection,
+	 * add async event to main thread to complete our close tasks */
+	TRACE_CALL(__func__);
+	g_idle_add(conn_opened, (gpointer)gp);
+}
+
+static gboolean update_align(gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)data;
+
+	g_signal_emit_by_name(G_OBJECT(gp), "update-align");
+	return G_SOURCE_REMOVE;
+}
+
+void remmina_protocol_widget_update_align(RemminaProtocolWidget *gp)
+{
+	/* Called by the plugin to do updates on rcw */
+	TRACE_CALL(__func__);
+	g_idle_add(update_align, (gpointer)gp);
+}
+
+static gboolean lock_dynres(gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)data;
+
+	g_signal_emit_by_name(G_OBJECT(gp), "lock-dynres");
+	return G_SOURCE_REMOVE;
+}
+
+static gboolean unlock_dynres(gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)data;
+
+	g_signal_emit_by_name(G_OBJECT(gp), "unlock-dynres");
+	return G_SOURCE_REMOVE;
+}
+
+void remmina_protocol_widget_lock_dynres(RemminaProtocolWidget *gp)
+{
+	/* Called by the plugin to do updates on rcw */
+	TRACE_CALL(__func__);
+	g_idle_add(lock_dynres, (gpointer)gp);
+}
+
+void remmina_protocol_widget_unlock_dynres(RemminaProtocolWidget *gp)
+{
+	/* Called by the plugin to do updates on rcw */
+	TRACE_CALL(__func__);
+	g_idle_add(unlock_dynres, (gpointer)gp);
+}
+
+static gboolean desktop_resize(gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)data;
+
+	g_signal_emit_by_name(G_OBJECT(gp), "desktop-resize");
+	return G_SOURCE_REMOVE;
+}
+
+void remmina_protocol_widget_desktop_resize(RemminaProtocolWidget *gp)
+{
+	/* Called by the plugin to do updates on rcw */
+	TRACE_CALL(__func__);
+	g_idle_add(desktop_resize, (gpointer)gp);
+}
+
+
+void remmina_protocol_widget_close_connection(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+
+	/* kindly ask the protocol plugin to close the connection.
+	 *      Nothing else is done here. */
+
+	if (!GTK_IS_WIDGET(gp))
+		return;
+
+	if (gp->priv->chat_window) {
+		gtk_widget_destroy(gp->priv->chat_window);
+		gp->priv->chat_window = NULL;
+	}
+
+	if (gp->priv->closed) {
+		/* Connection is already closed by the plugin, but
+		 * rcw is asking to close again (usually after an error panel)
+		 */
+		/* Clear the current error, or "disconnect" signal func will reshow a panel */
+		remmina_protocol_widget_set_error(gp, NULL);
+		g_signal_emit_by_name(G_OBJECT(gp), "disconnect");
+		return;
+	}
+	gp->priv->user_disconnect = TRUE;
+
+	/* Ask the plugin to close, async.
+	 *      The plugin will emit a "disconnect" signal on gp to call our
+	 *      remmina_protocol_widget_on_disconnected() when done */
+	gp->priv->plugin->close_connection(gp);
+
+	return;
+}
+
+/** Check if the plugin accepts keystrokes.
+ */
+gboolean remmina_protocol_widget_plugin_receives_keystrokes(RemminaProtocolWidget *gp)
+{
+	return gp->priv->plugin->send_keystrokes ? TRUE : FALSE;
+}
+
+/**
+ * Send to the plugin some keystrokes.
+ */
+void remmina_protocol_widget_send_keystrokes(RemminaProtocolWidget *gp, GtkMenuItem *widget)
+{
+	TRACE_CALL(__func__);
+	gchar *keystrokes = g_object_get_data(G_OBJECT(widget), "keystrokes");
+	guint *keyvals;
+	gint i;
+	GdkKeymap *keymap = gdk_keymap_get_for_display(gdk_display_get_default());
+	gunichar character;
+	guint keyval;
+	GdkKeymapKey *keys;
+	gint n_keys;
+
+	/* Single keystroke replace */
+	typedef struct _KeystrokeReplace {
+		gchar * search;
+		gchar * replace;
+		guint	keyval;
+	} KeystrokeReplace;
+	/* Special characters to replace */
+	KeystrokeReplace keystrokes_replaces[] =
+	{
+		{ "\\n",  "\n", GDK_KEY_Return	  },
+		{ "\\t",  "\t", GDK_KEY_Tab	  },
+		{ "\\b",  "\b", GDK_KEY_BackSpace },
+		{ "\\e",  "\e", GDK_KEY_Escape	  },
+		{ "\\\\", "\\", GDK_KEY_backslash },
+		{ NULL,	  NULL, 0		  }
+	};
+
+	/* Keystrokes can only be sent to plugins that accepts them */
+	if (remmina_protocol_widget_plugin_receives_keystrokes(gp)) {
+		/* Replace special characters */
+		for (i = 0; keystrokes_replaces[i].replace; i++) {
+			REMMINA_DEBUG("Keystrokes before replacement is \'%s\'", keystrokes);
+			keystrokes = g_strdup(remmina_public_str_replace_in_place(keystrokes,
+										  keystrokes_replaces[i].search,
+										  keystrokes_replaces[i].replace));
+			REMMINA_DEBUG("Keystrokes after replacement is \'%s\'", keystrokes);
+		}
+		gchar *iter = g_strdup(keystrokes);
+		keyvals = (guint *)g_malloc(strlen(keystrokes));
+		while (TRUE) {
+			/* Process each character in the keystrokes */
+			character = g_utf8_get_char_validated(iter, -1);
+			if (character == 0)
+				break;
+			keyval = gdk_unicode_to_keyval(character);
+			/* Replace all the special character with its keyval */
+			for (i = 0; keystrokes_replaces[i].replace; i++) {
+				if (character == keystrokes_replaces[i].replace[0]) {
+					keys = g_new0(GdkKeymapKey, 1);
+					keyval = keystrokes_replaces[i].keyval;
+					/* A special character was generated, no keyval lookup needed */
+					character = 0;
+					break;
+				}
+			}
+			/* Decode character if it’s not a special character */
+			if (character) {
+				/* get keyval without modifications */
+				if (!gdk_keymap_get_entries_for_keyval(keymap, keyval, &keys, &n_keys)) {
+					g_warning("keyval 0x%04x has no keycode!", keyval);
+					iter = g_utf8_find_next_char(iter, NULL);
+					continue;
+				}
+			}
+			/* Add modifier keys */
+			n_keys = 0;
+			if (keys->level & 1)
+				keyvals[n_keys++] = GDK_KEY_Shift_L;
+			if (keys->level & 2)
+				keyvals[n_keys++] = GDK_KEY_Alt_R;
+			keyvals[n_keys++] = keyval;
+			/* Send keystroke to the plugin */
+			gp->priv->plugin->send_keystrokes(gp, keyvals, n_keys);
+			g_free(keys);
+			/* Process next character in the keystrokes */
+			iter = g_utf8_find_next_char(iter, NULL);
+		}
+		g_free(keyvals);
+	}
+	g_free(keystrokes);
+	return;
+}
+
+/**
+ * Send to the plugin some keystrokes from the content of the clipboard
+ * This is a copy of remmina_protocol_widget_send_keystrokes but it uses the clipboard content
+ * get from remmina_protocol_widget_send_clipboard
+ * Probably we don't need the replacement table.
+ */
+void remmina_protocol_widget_send_clip_strokes(GtkClipboard *clipboard, const gchar *clip_text, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = REMMINA_PROTOCOL_WIDGET(data);
+	gchar *text = g_utf8_normalize(clip_text, -1, G_NORMALIZE_DEFAULT_COMPOSE);
+	guint *keyvals;
+	gint i;
+	GdkKeymap *keymap = gdk_keymap_get_for_display(gdk_display_get_default());
+	gunichar character;
+	guint keyval;
+	GdkKeymapKey *keys;
+	gint n_keys;
+
+	/* Single keystroke replace */
+	typedef struct _KeystrokeReplace {
+		gchar * search;
+		gchar * replace;
+		guint	keyval;
+	} KeystrokeReplace;
+	/* Special characters to replace */
+	KeystrokeReplace text_replaces[] =
+	{
+		{ "\\n",  "\n", GDK_KEY_Return	  },
+		{ "\\t",  "\t", GDK_KEY_Tab	  },
+		{ "\\b",  "\b", GDK_KEY_BackSpace },
+		{ "\\e",  "\e", GDK_KEY_Escape	  },
+		{ "\\\\", "\\", GDK_KEY_backslash },
+		{ NULL,	  NULL, 0		  }
+	};
+
+	if (remmina_protocol_widget_plugin_receives_keystrokes(gp)) {
+		if (text) {
+			/* Replace special characters */
+			for (i = 0; text_replaces[i].replace; i++) {
+				REMMINA_DEBUG("Text clipboard before replacement is \'%s\'", text);
+				text = g_strdup(remmina_public_str_replace_in_place(text,
+										    text_replaces[i].search,
+										    text_replaces[i].replace));
+				REMMINA_DEBUG("Text clipboard after replacement is \'%s\'", text);
+			}
+			gchar *iter = g_strdup(text);
+			REMMINA_DEBUG("Iter: %s", iter),
+			keyvals = (guint *)g_malloc(strlen(text));
+			while (TRUE) {
+				/* Process each character in the keystrokes */
+				character = g_utf8_get_char_validated(iter, -1);
+				REMMINA_DEBUG("Char: U+%04" G_GINT32_FORMAT"X", character);
+				if (character == 0)
+					break;
+				keyval = gdk_unicode_to_keyval(character);
+				REMMINA_DEBUG("Keyval: %u", keyval);
+				/* Replace all the special character with its keyval */
+				for (i = 0; text_replaces[i].replace; i++) {
+					if (character == text_replaces[i].replace[0]) {
+						keys = g_new0(GdkKeymapKey, 1);
+						keyval = text_replaces[i].keyval;
+						REMMINA_DEBUG("Special Keyval: %u", keyval);
+						/* A special character was generated, no keyval lookup needed */
+						character = 0;
+						break;
+					}
+				}
+				/* Decode character if it’s not a special character */
+				if (character) {
+					/* get keyval without modifications */
+					if (!gdk_keymap_get_entries_for_keyval(keymap, keyval, &keys, &n_keys)) {
+						REMMINA_WARNING("keyval 0x%04x has no keycode!", keyval);
+						iter = g_utf8_find_next_char(iter, NULL);
+						continue;
+					}
+				}
+				/* Add modifier keys */
+				n_keys = 0;
+				if (keys->level & 1)
+					keyvals[n_keys++] = GDK_KEY_Shift_L;
+				if (keys->level & 2)
+					keyvals[n_keys++] = GDK_KEY_Alt_R;
+				/*
+				 * @fixme heap buffer overflow
+				 * In some cases, for example sending \t as the only sequence
+				 * may lead to a buffer overflow
+				 */
+				keyvals[n_keys++] = keyval;
+				/* Send keystroke to the plugin */
+				gp->priv->plugin->send_keystrokes(gp, keyvals, n_keys);
+				g_free(keys);
+				/* Process next character in the keystrokes */
+				iter = g_utf8_find_next_char(iter, NULL);
+			}
+			g_free(keyvals);
+		}
+		g_free(text);
+	}
+	return;
+}
+
+void remmina_protocol_widget_send_clipboard(RemminaProtocolWidget *gp, GObject*widget)
+{
+	TRACE_CALL(__func__);
+	GtkClipboard *clipboard;
+
+	clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
+
+	/* Request the contents of the clipboard, contents_received will be
+	 * called when we do get the contents.
+	 */
+	gtk_clipboard_request_text(clipboard,
+				   remmina_protocol_widget_send_clip_strokes, gp);
+}
+
+gboolean remmina_protocol_widget_plugin_screenshot(RemminaProtocolWidget *gp, RemminaPluginScreenshotData *rpsd)
+{
+	TRACE_CALL(__func__);
+	if (!gp->priv->plugin->get_plugin_screenshot) {
+		REMMINA_DEBUG("plugin screenshot function is not implemented, using core Remmina functionality");
+		return FALSE;
+	}
+
+	return gp->priv->plugin->get_plugin_screenshot(gp, rpsd);
+}
+
+gboolean remmina_protocol_widget_map_event(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	if (!gp->priv->plugin->map_event) {
+		REMMINA_DEBUG("Map plugin function not implemented");
+		return FALSE;
+	}
+
+	REMMINA_DEBUG("Calling plugin mapping function");
+	return gp->priv->plugin->map_event(gp);
+}
+
+gboolean remmina_protocol_widget_unmap_event(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	if (!gp->priv->plugin->unmap_event) {
+		REMMINA_DEBUG("Unmap plugin function not implemented");
+		return FALSE;
+	}
+
+	REMMINA_DEBUG("Calling plugin unmapping function");
+	return gp->priv->plugin->unmap_event(gp);
+}
+
+void remmina_protocol_widget_emit_signal(RemminaProtocolWidget *gp, const gchar *signal_name)
+{
+	TRACE_CALL(__func__);
+
+	REMMINA_DEBUG("Emitting signals should be used from the object itself, not from another object");
+	raise(SIGINT);
+
+	if (!remmina_masterthread_exec_is_main_thread()) {
+		/* Allow the execution of this function from a non main thread */
+		RemminaMTExecData *d;
+		d = (RemminaMTExecData *)g_malloc(sizeof(RemminaMTExecData));
+		d->func = FUNC_PROTOCOLWIDGET_EMIT_SIGNAL;
+		d->p.protocolwidget_emit_signal.signal_name = signal_name;
+		d->p.protocolwidget_emit_signal.gp = gp;
+		remmina_masterthread_exec_and_wait(d);
+		g_free(d);
+		return;
+	}
+	g_signal_emit_by_name(G_OBJECT(gp), signal_name);
+}
+
+const RemminaProtocolFeature *remmina_protocol_widget_get_features(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	return gp->priv->features;
+}
+
+gboolean remmina_protocol_widget_query_feature_by_type(RemminaProtocolWidget *gp, RemminaProtocolFeatureType type)
+{
+	TRACE_CALL(__func__);
+	const RemminaProtocolFeature *feature;
+
+#ifdef HAVE_LIBSSH
+	if (type == REMMINA_PROTOCOL_FEATURE_TYPE_TOOL &&
+	    remmina_file_get_int(gp->priv->remmina_file, "ssh_tunnel_enabled", FALSE))
+		return TRUE;
+
+#endif
+	for (feature = gp->priv->plugin->features; feature && feature->type; feature++)
+		if (feature->type == type)
+			return TRUE;
+	return FALSE;
+}
+
+gboolean remmina_protocol_widget_query_feature_by_ref(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature)
+{
+	TRACE_CALL(__func__);
+	return gp->priv->plugin->query_feature(gp, feature);
+}
+
+void remmina_protocol_widget_call_feature_by_type(RemminaProtocolWidget *gp, RemminaProtocolFeatureType type, gint id)
+{
+	TRACE_CALL(__func__);
+	const RemminaProtocolFeature *feature;
+
+	for (feature = gp->priv->plugin->features; feature && feature->type; feature++) {
+		if (feature->type == type && (id == 0 || feature->id == id)) {
+			remmina_protocol_widget_call_feature_by_ref(gp, feature);
+			break;
+		}
+	}
+}
+
+void remmina_protocol_widget_call_feature_by_ref(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature)
+{
+	TRACE_CALL(__func__);
+	switch (feature->id) {
+#ifdef HAVE_LIBSSH
+	case REMMINA_PROTOCOL_FEATURE_TOOL_SSH:
+		if (gp->priv->ssh_tunnels && gp->priv->ssh_tunnels->len > 0) {
+			rcw_open_from_file_full(
+				remmina_file_dup_temp_protocol(gp->priv->remmina_file, "SSH"), NULL,
+				(RemminaSSHTunnel *)gp->priv->ssh_tunnels->pdata[0], NULL);
+			return;
+		}
+		break;
+
+	case REMMINA_PROTOCOL_FEATURE_TOOL_SFTP:
+		if (gp->priv->ssh_tunnels && gp->priv->ssh_tunnels->len > 0) {
+			rcw_open_from_file_full(
+				remmina_file_dup_temp_protocol(gp->priv->remmina_file, "SFTP"), NULL,
+				gp->priv->ssh_tunnels->pdata[0], NULL);
+			return;
+		}
+		break;
+#endif
+	default:
+		break;
+	}
+	gp->priv->plugin->call_feature(gp, feature);
+}
+
+static gboolean remmina_protocol_widget_on_key_press(GtkWidget *widget, GdkEventKey *event, RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	if (gp->priv->hostkey_func)
+		return gp->priv->hostkey_func(gp, event->keyval, FALSE);
+	return FALSE;
+}
+
+static gboolean remmina_protocol_widget_on_key_release(GtkWidget *widget, GdkEventKey *event, RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	if (gp->priv->hostkey_func)
+		return gp->priv->hostkey_func(gp, event->keyval, TRUE);
+
+	return FALSE;
+}
+
+void remmina_protocol_widget_register_hostkey(RemminaProtocolWidget *gp, GtkWidget *widget)
+{
+	TRACE_CALL(__func__);
+	g_signal_connect(G_OBJECT(widget), "key-press-event", G_CALLBACK(remmina_protocol_widget_on_key_press), gp);
+	g_signal_connect(G_OBJECT(widget), "key-release-event", G_CALLBACK(remmina_protocol_widget_on_key_release), gp);
+}
+
+void remmina_protocol_widget_set_hostkey_func(RemminaProtocolWidget *gp, RemminaHostkeyFunc func)
+{
+	TRACE_CALL(__func__);
+	gp->priv->hostkey_func = func;
+}
+
+RemminaMessagePanel *remmina_protocol_widget_mpprogress(RemminaConnectionObject *cnnobj, const gchar *msg, RemminaMessagePanelCallback response_callback, gpointer response_callback_data)
+{
+	RemminaMessagePanel *mp;
+
+	if (!remmina_masterthread_exec_is_main_thread()) {
+		/* Allow the execution of this function from a non main thread */
+		RemminaMTExecData *d;
+		d = (RemminaMTExecData *)g_malloc(sizeof(RemminaMTExecData));
+		d->func = FUNC_PROTOCOLWIDGET_MPPROGRESS;
+		d->p.protocolwidget_mpprogress.cnnobj = cnnobj;
+		d->p.protocolwidget_mpprogress.message = msg;
+		d->p.protocolwidget_mpprogress.response_callback = response_callback;
+		d->p.protocolwidget_mpprogress.response_callback_data = response_callback_data;
+		remmina_masterthread_exec_and_wait(d);
+		mp = d->p.protocolwidget_mpprogress.ret_mp;
+		g_free(d);
+		return mp;
+	}
+
+	mp = remmina_message_panel_new();
+	remmina_message_panel_setup_progress(mp, msg, response_callback, response_callback_data);
+	rco_show_message_panel(cnnobj, mp);
+	return mp;
+}
+
+void remmina_protocol_widget_mpdestroy(RemminaConnectionObject *cnnobj, RemminaMessagePanel *mp)
+{
+	if (!remmina_masterthread_exec_is_main_thread()) {
+		/* Allow the execution of this function from a non main thread */
+		RemminaMTExecData *d;
+		d = (RemminaMTExecData *)g_malloc(sizeof(RemminaMTExecData));
+		d->func = FUNC_PROTOCOLWIDGET_MPDESTROY;
+		d->p.protocolwidget_mpdestroy.cnnobj = cnnobj;
+		d->p.protocolwidget_mpdestroy.mp = mp;
+		remmina_masterthread_exec_and_wait(d);
+		g_free(d);
+		return;
+	}
+	rco_destroy_message_panel(cnnobj, mp);
+}
+
+#ifdef HAVE_LIBSSH
+static void cancel_init_tunnel_cb(void *cbdata, int btn)
+{
+	printf("Remmina: Cancelling an opening tunnel is not implemented\n");
+}
+
+static RemminaSSHTunnel *remmina_protocol_widget_init_tunnel(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaSSHTunnel *tunnel;
+	gint ret;
+	gchar *msg;
+	RemminaMessagePanel *mp;
+	gboolean partial = FALSE;
+	gboolean cont = FALSE;
+
+	tunnel = remmina_ssh_tunnel_new_from_file(gp->priv->remmina_file);
+
+	REMMINA_DEBUG("Creating SSH tunnel to “%s” via SSH…", REMMINA_SSH(tunnel)->server);
+	// TRANSLATORS: “%s” is a placeholder for an hostname or an IP address.
+	msg = g_strdup_printf(_("Connecting to “%s” via SSH…"), REMMINA_SSH(tunnel)->server);
+
+	mp = remmina_protocol_widget_mpprogress(gp->cnnobj, msg, cancel_init_tunnel_cb, NULL);
+	g_free(msg);
+
+
+
+	while (1) {
+		if (!partial) {
+			if (!remmina_ssh_init_session(REMMINA_SSH(tunnel))) {
+				REMMINA_DEBUG("SSH Tunnel init session error: %s", REMMINA_SSH(tunnel)->error);
+				remmina_protocol_widget_set_error(gp, REMMINA_SSH(tunnel)->error);
+				// exit the loop here: OK
+				break;
+			}
+		}
+
+		ret = remmina_ssh_auth_gui(REMMINA_SSH(tunnel), gp, gp->priv->remmina_file);
+		REMMINA_DEBUG("Tunnel auth returned %d", ret);
+		switch (ret) {
+		case REMMINA_SSH_AUTH_SUCCESS:
+			REMMINA_DEBUG("Authentication success");
+			break;
+		case REMMINA_SSH_AUTH_PARTIAL:
+			REMMINA_DEBUG("Continue with the next auth method");
+			partial = TRUE;
+			// Continue the loop: OK
+			continue;
+			break;
+		case REMMINA_SSH_AUTH_RECONNECT:
+			REMMINA_DEBUG("Reconnecting…");
+			if (REMMINA_SSH(tunnel)->session) {
+				ssh_disconnect(REMMINA_SSH(tunnel)->session);
+				ssh_free(REMMINA_SSH(tunnel)->session);
+				REMMINA_SSH(tunnel)->session = NULL;
+			}
+			g_free(REMMINA_SSH(tunnel)->callback);
+			// Continue the loop: OK
+			continue;
+			break;
+		case REMMINA_SSH_AUTH_USERCANCEL:
+			REMMINA_DEBUG("Interrupted by the user");
+			// exit the loop here: OK
+			goto BREAK;
+			break;
+		default:
+			REMMINA_DEBUG("Error during the authentication: %s", REMMINA_SSH(tunnel)->error);
+			remmina_protocol_widget_set_error(gp, REMMINA_SSH(tunnel)->error);
+			// exit the loop here: OK
+			goto BREAK;
+		}
+
+
+		cont = TRUE;
+		break;
+	}
+
+#if 0
+
+	if (!remmina_ssh_init_session(REMMINA_SSH(tunnel))) {
+		REMMINA_DEBUG("Cannot init SSH session with tunnel struct");
+		remmina_protocol_widget_set_error(gp, REMMINA_SSH(tunnel)->error);
+		remmina_ssh_tunnel_free(tunnel);
+		return NULL;
+	}
+
+	ret = remmina_ssh_auth_gui(REMMINA_SSH(tunnel), gp, gp->priv->remmina_file);
+	REMMINA_DEBUG("Tunnel auth returned %d", ret);
+	if (ret != REMMINA_SSH_AUTH_SUCCESS) {
+		if (ret != REMMINA_SSH_AUTH_USERCANCEL)
+			remmina_protocol_widget_set_error(gp, REMMINA_SSH(tunnel)->error);
+		remmina_ssh_tunnel_free(tunnel);
+		return NULL;
+	}
+
+#endif
+
+BREAK:
+	if (!cont) {
+		remmina_ssh_tunnel_free(tunnel);
+		return NULL;
+	}
+	remmina_protocol_widget_mpdestroy(gp->cnnobj, mp);
+
+	return tunnel;
+}
+#endif
+
+
+#ifdef HAVE_LIBSSH
+static void cancel_start_direct_tunnel_cb(void *cbdata, int btn)
+{
+	printf("Remmina: Cancelling start_direct_tunnel is not implemented\n");
+}
+
+static gboolean remmina_protocol_widget_tunnel_destroy(RemminaSSHTunnel *tunnel, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = REMMINA_PROTOCOL_WIDGET(data);
+	guint idx = 0;
+
+#if GLIB_CHECK_VERSION(2, 54, 0)
+	gboolean found = g_ptr_array_find(gp->priv->ssh_tunnels, tunnel, &idx);
+#else
+	int i;
+	gboolean found = FALSE;
+	for (i = 0; i < gp->priv->ssh_tunnels->len; i++) {
+		if ((RemminaSSHTunnel *)gp->priv->ssh_tunnels->pdata[i] == tunnel) {
+			found = TRUE;
+			idx = i;
+		}
+	}
+#endif
+
+	printf("Tunnel %s found at idx = %d\n", found ? "yes": "not", idx);
+
+	if (found) {
+#ifdef HAVE_LIBSSH
+		REMMINA_DEBUG("[Tunnel with idx %u has been disconnected", idx);
+		remmina_ssh_tunnel_free(tunnel);
+#endif
+		g_ptr_array_remove(gp->priv->ssh_tunnels, tunnel);
+	}
+	return TRUE;
+}
+#endif
+
+/**
+ * Start an SSH tunnel if possible and return the host:port string.
+ *
+ */
+gchar *remmina_protocol_widget_start_direct_tunnel(RemminaProtocolWidget *gp, gint default_port, gboolean port_plus)
+{
+	TRACE_CALL(__func__);
+	const gchar *server;
+	const gchar *ssh_tunnel_server;
+	gchar *ssh_tunnel_host, *srv_host, *dest;
+	gint srv_port, ssh_tunnel_port = 0;
+
+	REMMINA_DEBUG("SSH tunnel initialization…");
+
+	server = remmina_file_get_string(gp->priv->remmina_file, "server");
+	ssh_tunnel_server = remmina_file_get_string(gp->priv->remmina_file, "ssh_tunnel_server");
+
+	if (!server)
+		return g_strdup("");
+
+	if (strstr(g_strdup(server), "unix:///") != NULL) {
+		REMMINA_DEBUG("%s is a UNIX socket", server);
+		return g_strdup(server);
+	}
+
+	REMMINA_DEBUG("Calling remmina_public_get_server_port");
+	remmina_public_get_server_port(server, default_port, &srv_host, &srv_port);
+	REMMINA_DEBUG("Calling remmina_public_get_server_port (tunnel)");
+	remmina_public_get_server_port(ssh_tunnel_server, 22, &ssh_tunnel_host, &ssh_tunnel_port);
+	REMMINA_DEBUG("server: %s, port: %d", srv_host, srv_port);
+
+	if (port_plus && srv_port < 100)
+		/* Protocols like VNC supports using instance number :0, :1, etc. as port number. */
+		srv_port += default_port;
+
+#ifdef HAVE_LIBSSH
+	gchar *msg;
+	RemminaMessagePanel *mp;
+	RemminaSSHTunnel *tunnel;
+
+	if (!remmina_file_get_int(gp->priv->remmina_file, "ssh_tunnel_enabled", FALSE)) {
+		dest = g_strdup_printf("[%s]:%i", srv_host, srv_port);
+		g_free(srv_host);
+		g_free(ssh_tunnel_host);
+		return dest;
+	}
+
+	tunnel = remmina_protocol_widget_init_tunnel(gp);
+	if (!tunnel) {
+		g_free(srv_host);
+		g_free(ssh_tunnel_host);
+		REMMINA_DEBUG("remmina_protocol_widget_init_tunnel failed with error is %s",
+			      remmina_protocol_widget_get_error_message(gp));
+		return NULL;
+	}
+
+	// TRANSLATORS: “%s” is a placeholder for an hostname or an IP address.
+	msg = g_strdup_printf(_("Connecting to “%s” via SSH…"), server);
+	mp = remmina_protocol_widget_mpprogress(gp->cnnobj, msg, cancel_start_direct_tunnel_cb, NULL);
+	g_free(msg);
+
+	if (remmina_file_get_int(gp->priv->remmina_file, "ssh_tunnel_loopback", FALSE)) {
+		g_free(srv_host);
+		g_free(ssh_tunnel_host);
+		ssh_tunnel_host = NULL;
+		srv_host = g_strdup("127.0.0.1");
+	}
+
+	REMMINA_DEBUG("Starting tunnel to: %s, port: %d", ssh_tunnel_host, ssh_tunnel_port);
+	if (!remmina_ssh_tunnel_open(tunnel, srv_host, srv_port, remmina_pref.sshtunnel_port)) {
+		g_free(srv_host);
+		g_free(ssh_tunnel_host);
+		remmina_protocol_widget_set_error(gp, REMMINA_SSH(tunnel)->error);
+		remmina_ssh_tunnel_free(tunnel);
+		return NULL;
+	}
+	g_free(srv_host);
+	g_free(ssh_tunnel_host);
+
+	remmina_protocol_widget_mpdestroy(gp->cnnobj, mp);
+
+	tunnel->destroy_func = remmina_protocol_widget_tunnel_destroy;
+	tunnel->destroy_func_callback_data = (gpointer)gp;
+
+	g_ptr_array_add(gp->priv->ssh_tunnels, tunnel);
+
+	return g_strdup_printf("127.0.0.1:%i", remmina_pref.sshtunnel_port);
+
+#else
+
+	dest = g_strdup_printf("[%s]:%i", srv_host, srv_port);
+	g_free(srv_host);
+	g_free(ssh_tunnel_host);
+	return dest;
+
+#endif
+}
+
+#ifdef HAVE_LIBSSH
+static void cancel_start_reverse_tunnel_cb(void *cbdata, int btn)
+{
+	printf("Remmina: Cancelling start_reverse_tunnel is not implemented\n");
+}
+#endif
+
+
+gboolean remmina_protocol_widget_start_reverse_tunnel(RemminaProtocolWidget *gp, gint local_port)
+{
+	TRACE_CALL(__func__);
+#ifdef HAVE_LIBSSH
+	gchar *msg;
+	RemminaMessagePanel *mp;
+	RemminaSSHTunnel *tunnel;
+
+	if (!remmina_file_get_int(gp->priv->remmina_file, "ssh_tunnel_enabled", FALSE))
+		return TRUE;
+
+	if (!(tunnel = remmina_protocol_widget_init_tunnel(gp)))
+		return FALSE;
+
+	// TRANSLATORS: “%i” is a placeholder for a TCP port number.
+	msg = g_strdup_printf(_("Awaiting incoming SSH connection on port %i…"), remmina_file_get_int(gp->priv->remmina_file, "listenport", 0));
+	mp = remmina_protocol_widget_mpprogress(gp->cnnobj, msg, cancel_start_reverse_tunnel_cb, NULL);
+	g_free(msg);
+
+	if (!remmina_ssh_tunnel_reverse(tunnel, remmina_file_get_int(gp->priv->remmina_file, "listenport", 0), local_port)) {
+		remmina_ssh_tunnel_free(tunnel);
+		remmina_protocol_widget_set_error(gp, REMMINA_SSH(tunnel)->error);
+		return FALSE;
+	}
+	remmina_protocol_widget_mpdestroy(gp->cnnobj, mp);
+	g_ptr_array_add(gp->priv->ssh_tunnels, tunnel);
+#endif
+
+	return TRUE;
+}
+
+gboolean remmina_protocol_widget_ssh_exec(RemminaProtocolWidget *gp, gboolean wait, const gchar *fmt, ...)
+{
+	TRACE_CALL(__func__);
+#ifdef HAVE_LIBSSH
+	RemminaSSHTunnel *tunnel;
+	ssh_channel channel;
+	gint status;
+	gboolean ret = FALSE;
+	gchar *cmd, *ptr;
+	va_list args;
+
+	if (gp->priv->ssh_tunnels->len < 1)
+		return FALSE;
+
+	tunnel = (RemminaSSHTunnel *)gp->priv->ssh_tunnels->pdata[0];
+
+	if ((channel = ssh_channel_new(REMMINA_SSH(tunnel)->session)) == NULL)
+		return FALSE;
+
+	va_start(args, fmt);
+	cmd = g_strdup_vprintf(fmt, args);
+	va_end(args);
+
+	if (ssh_channel_open_session(channel) == SSH_OK &&
+	    ssh_channel_request_exec(channel, cmd) == SSH_OK) {
+		if (wait) {
+			ssh_channel_send_eof(channel);
+			status = ssh_channel_get_exit_status(channel);
+			ptr = strchr(cmd, ' ');
+			if (ptr) *ptr = '\0';
+			switch (status) {
+			case 0:
+				ret = TRUE;
+				break;
+			case 127:
+				// TRANSLATORS: “%s” is a place holder for a unix command path.
+				remmina_ssh_set_application_error(REMMINA_SSH(tunnel),
+								  _("The “%s” command is not available on the SSH server."), cmd);
+				break;
+			default:
+				// TRANSLATORS: “%s” is a place holder for a unix command path. “%i” is a placeholder for an error code number.
+				remmina_ssh_set_application_error(REMMINA_SSH(tunnel),
+								  _("Could not run the “%s” command on the SSH server (status = %i)."), cmd, status);
+				break;
+			}
+		} else {
+			ret = TRUE;
+		}
+	} else {
+		// TRANSLATORS: %s is a placeholder for an error message
+		remmina_ssh_set_error(REMMINA_SSH(tunnel), _("Could not run command. %s"));
+	}
+	g_free(cmd);
+	if (wait)
+		ssh_channel_close(channel);
+	ssh_channel_free(channel);
+	return ret;
+
+#else
+
+	return FALSE;
+
+#endif
+}
+
+#ifdef HAVE_LIBSSH
+static gboolean remmina_protocol_widget_xport_tunnel_init_callback(RemminaSSHTunnel *tunnel, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = REMMINA_PROTOCOL_WIDGET(data);
+	gchar *server;
+	gint port;
+	gboolean ret;
+
+	REMMINA_DEBUG("Calling remmina_public_get_server_port");
+	remmina_public_get_server_port(remmina_file_get_string(gp->priv->remmina_file, "server"), 177, &server, &port);
+	ret = ((RemminaXPortTunnelInitFunc)gp->priv->init_func)(gp,
+								tunnel->remotedisplay, (tunnel->bindlocalhost ? "localhost" : server), port);
+	g_free(server);
+
+	return ret;
+}
+
+static gboolean remmina_protocol_widget_xport_tunnel_connect_callback(RemminaSSHTunnel *tunnel, gpointer data)
+{
+	TRACE_CALL(__func__);
+	return TRUE;
+}
+
+static gboolean remmina_protocol_widget_xport_tunnel_disconnect_callback(RemminaSSHTunnel *tunnel, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = REMMINA_PROTOCOL_WIDGET(data);
+
+	if (REMMINA_SSH(tunnel)->error)
+		remmina_protocol_widget_set_error(gp, "%s", REMMINA_SSH(tunnel)->error);
+
+	IDLE_ADD((GSourceFunc)remmina_protocol_widget_close_connection, gp);
+	return TRUE;
+}
+#endif
+#ifdef HAVE_LIBSSH
+static void cancel_connect_xport_cb(void *cbdata, int btn)
+{
+	printf("Remmina: Cancelling an XPort connection is not implemented\n");
+}
+#endif
+gboolean remmina_protocol_widget_start_xport_tunnel(RemminaProtocolWidget *gp, RemminaXPortTunnelInitFunc init_func)
+{
+	TRACE_CALL(__func__);
+#ifdef HAVE_LIBSSH
+	gboolean bindlocalhost;
+	gchar *server;
+	gchar *msg;
+	RemminaMessagePanel *mp;
+	RemminaSSHTunnel *tunnel;
+
+	if (!(tunnel = remmina_protocol_widget_init_tunnel(gp))) return FALSE;
+
+	// TRANSLATORS: “%s” is a placeholder for a hostname or IP address.
+	msg = g_strdup_printf(_("Connecting to %s via SSH…"), remmina_file_get_string(gp->priv->remmina_file, "server"));
+	mp = remmina_protocol_widget_mpprogress(gp->cnnobj, msg, cancel_connect_xport_cb, NULL);
+	g_free(msg);
+
+	gp->priv->init_func = init_func;
+	tunnel->init_func = remmina_protocol_widget_xport_tunnel_init_callback;
+	tunnel->connect_func = remmina_protocol_widget_xport_tunnel_connect_callback;
+	tunnel->disconnect_func = remmina_protocol_widget_xport_tunnel_disconnect_callback;
+	tunnel->callback_data = gp;
+
+	REMMINA_DEBUG("Calling remmina_public_get_server_port");
+	remmina_public_get_server_port(remmina_file_get_string(gp->priv->remmina_file, "server"), 0, &server, NULL);
+	bindlocalhost = (g_strcmp0(REMMINA_SSH(tunnel)->server, server) == 0);
+	g_free(server);
+
+	if (!remmina_ssh_tunnel_xport(tunnel, bindlocalhost)) {
+		remmina_protocol_widget_set_error(gp, "Could not open channel, %s",
+						  ssh_get_error(REMMINA_SSH(tunnel)->session));
+		remmina_ssh_tunnel_free(tunnel);
+		return FALSE;
+	}
+
+	remmina_protocol_widget_mpdestroy(gp->cnnobj, mp);
+	g_ptr_array_add(gp->priv->ssh_tunnels, tunnel);
+
+	return TRUE;
+
+#else
+	return FALSE;
+#endif
+}
+
+void remmina_protocol_widget_set_display(RemminaProtocolWidget *gp, gint display)
+{
+	TRACE_CALL(__func__);
+#ifdef HAVE_LIBSSH
+	RemminaSSHTunnel *tunnel;
+	if (gp->priv->ssh_tunnels->len < 1)
+		return;
+	tunnel = (RemminaSSHTunnel *)gp->priv->ssh_tunnels->pdata[0];
+	if (tunnel->localdisplay) g_free(tunnel->localdisplay);
+	tunnel->localdisplay = g_strdup_printf("unix:%i", display);
+#endif
+}
+
+gint remmina_protocol_widget_get_profile_remote_width(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	/* Returns the width of remote desktop as chosen by the user profile */
+	return gp->priv->profile_remote_width;
+}
+
+gint remmina_protocol_widget_get_multimon(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	/* Returns ehenever multi monitor is enabled (1) */
+	gp->priv->multimon = remmina_file_get_int(gp->priv->remmina_file, "multimon", -1);
+	REMMINA_DEBUG("Multi monitor is set to %d", gp->priv->multimon);
+	return gp->priv->multimon;
+}
+
+gint remmina_protocol_widget_get_profile_remote_height(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	/* Returns the height of remote desktop as chosen by the user profile */
+	return gp->priv->profile_remote_height;
+}
+
+const gchar* remmina_protocol_widget_get_name(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	return gp ? gp->plugin ? gp->plugin->name : NULL : NULL;
+}
+
+gint remmina_protocol_widget_get_width(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	return gp->priv->width;
+}
+
+void remmina_protocol_widget_set_width(RemminaProtocolWidget *gp, gint width)
+{
+	TRACE_CALL(__func__);
+	gp->priv->width = width;
+}
+
+gint remmina_protocol_widget_get_height(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	return gp->priv->height;
+}
+
+void remmina_protocol_widget_set_height(RemminaProtocolWidget *gp, gint height)
+{
+	TRACE_CALL(__func__);
+	gp->priv->height = height;
+}
+
+RemminaScaleMode remmina_protocol_widget_get_current_scale_mode(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	return gp->priv->scalemode;
+}
+
+void remmina_protocol_widget_set_current_scale_mode(RemminaProtocolWidget *gp, RemminaScaleMode scalemode)
+{
+	TRACE_CALL(__func__);
+	gp->priv->scalemode = scalemode;
+}
+
+gboolean remmina_protocol_widget_get_expand(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	return gp->priv->scaler_expand;
+}
+
+void remmina_protocol_widget_set_expand(RemminaProtocolWidget *gp, gboolean expand)
+{
+	TRACE_CALL(__func__);
+	gp->priv->scaler_expand = expand;
+	return;
+}
+
+gboolean remmina_protocol_widget_has_error(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	return gp->priv->has_error;
+}
+
+const gchar *remmina_protocol_widget_get_error_message(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	return gp->priv->error_message;
+}
+
+void remmina_protocol_widget_set_error(RemminaProtocolWidget *gp, const gchar *fmt, ...)
+{
+	TRACE_CALL(__func__);
+	va_list args;
+
+	if (gp->priv->error_message) g_free(gp->priv->error_message);
+
+	if (fmt == NULL) {
+		gp->priv->has_error = FALSE;
+		gp->priv->error_message = NULL;
+		return;
+	}
+
+	va_start(args, fmt);
+	gp->priv->error_message = g_strdup_vprintf(fmt, args);
+	va_end(args);
+
+	gp->priv->has_error = TRUE;
+}
+
+gboolean remmina_protocol_widget_is_closed(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	return gp->priv->closed;
+}
+
+RemminaFile *remmina_protocol_widget_get_file(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	return gp->priv->remmina_file;
+}
+
+struct remmina_protocol_widget_dialog_mt_data_t {
+	/* Input data */
+	RemminaProtocolWidget *		gp;
+	gchar *				title;
+	gchar *				default_username;
+	gchar *				default_password;
+	gchar *				default_domain;
+	gchar *				strpasswordlabel;
+	enum panel_type			dtype;
+	RemminaMessagePanelFlags	pflags;
+	gboolean			called_from_subthread;
+	/* Running status */
+	pthread_mutex_t			pt_mutex;
+	pthread_cond_t			pt_cond;
+	/* Output/retval */
+	int				rcbutton;
+};
+
+static void authpanel_mt_cb(void *user_data, int button)
+{
+	struct remmina_protocol_widget_dialog_mt_data_t *d = (struct remmina_protocol_widget_dialog_mt_data_t *)user_data;
+
+	d->rcbutton = button;
+	if (button == GTK_RESPONSE_OK) {
+		if (d->dtype == RPWDT_AUTH) {
+			d->gp->priv->password = remmina_message_panel_field_get_string(d->gp->priv->auth_message_panel, REMMINA_MESSAGE_PANEL_PASSWORD);
+			d->gp->priv->username = remmina_message_panel_field_get_string(d->gp->priv->auth_message_panel, REMMINA_MESSAGE_PANEL_USERNAME);
+			d->gp->priv->domain = remmina_message_panel_field_get_string(d->gp->priv->auth_message_panel, REMMINA_MESSAGE_PANEL_DOMAIN);
+			d->gp->priv->save_password = remmina_message_panel_field_get_switch_state(d->gp->priv->auth_message_panel, REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD);
+		} else if (d->dtype == RPWDT_AUTHX509) {
+			d->gp->priv->cacert = remmina_message_panel_field_get_filename(d->gp->priv->auth_message_panel, REMMINA_MESSAGE_PANEL_CACERTFILE);
+			d->gp->priv->cacrl = remmina_message_panel_field_get_filename(d->gp->priv->auth_message_panel, REMMINA_MESSAGE_PANEL_CACRLFILE);
+			d->gp->priv->clientcert = remmina_message_panel_field_get_filename(d->gp->priv->auth_message_panel, REMMINA_MESSAGE_PANEL_CLIENTCERTFILE);
+			d->gp->priv->clientkey = remmina_message_panel_field_get_filename(d->gp->priv->auth_message_panel, REMMINA_MESSAGE_PANEL_CLIENTKEYFILE);
+		}
+	}
+
+	if (d->called_from_subthread) {
+		/* Hide and destroy message panel, we can do it now because we are on the main thread */
+		rco_destroy_message_panel(d->gp->cnnobj, d->gp->priv->auth_message_panel);
+
+		/* Awake the locked subthread, when called from subthread */
+		pthread_mutex_lock(&d->pt_mutex);
+		pthread_cond_signal(&d->pt_cond);
+		pthread_mutex_unlock(&d->pt_mutex);
+	} else {
+		/* Signal completion, when called from main thread. Message panel will be destroyed by the caller */
+		remmina_message_panel_response(d->gp->priv->auth_message_panel, button);
+	}
+}
+
+static gboolean remmina_protocol_widget_dialog_mt_setup(gpointer user_data)
+{
+	struct remmina_protocol_widget_dialog_mt_data_t *d = (struct remmina_protocol_widget_dialog_mt_data_t *)user_data;
+
+	RemminaFile *remminafile = d->gp->priv->remmina_file;
+	RemminaMessagePanel *mp;
+	const gchar *s;
+
+	if (d->gp->cnnobj == NULL)
+		return FALSE;
+
+	mp = remmina_message_panel_new();
+
+	if (d->dtype == RPWDT_AUTH) {
+		if (d->pflags & REMMINA_MESSAGE_PANEL_FLAG_USERNAME) {
+			remmina_message_panel_field_set_string(mp, REMMINA_MESSAGE_PANEL_USERNAME, d->default_username);
+		}
+		remmina_message_panel_setup_auth(mp, authpanel_mt_cb, d, d->title, d->strpasswordlabel, d->pflags);
+		remmina_message_panel_field_set_string(mp, REMMINA_MESSAGE_PANEL_USERNAME, d->default_username);
+		if (d->pflags & REMMINA_MESSAGE_PANEL_FLAG_DOMAIN)
+			remmina_message_panel_field_set_string(mp, REMMINA_MESSAGE_PANEL_DOMAIN, d->default_domain);
+		remmina_message_panel_field_set_string(mp, REMMINA_MESSAGE_PANEL_PASSWORD, d->default_password);
+		if (d->pflags & REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD)
+			remmina_message_panel_field_set_switch(mp, REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD, (d->default_password == NULL || d->default_password[0] == 0) ? FALSE: TRUE);
+	} else if (d->dtype == RPWDT_QUESTIONYESNO) {
+		remmina_message_panel_setup_question(mp, d->title, authpanel_mt_cb, d);
+	} else if (d->dtype == RPWDT_AUTHX509) {
+		remmina_message_panel_setup_auth_x509(mp, authpanel_mt_cb, d);
+		if ((s = remmina_file_get_string(remminafile, "cacert")) != NULL)
+			remmina_message_panel_field_set_filename(mp, REMMINA_MESSAGE_PANEL_CACERTFILE, s);
+		if ((s = remmina_file_get_string(remminafile, "cacrl")) != NULL)
+			remmina_message_panel_field_set_filename(mp, REMMINA_MESSAGE_PANEL_CACRLFILE, s);
+		if ((s = remmina_file_get_string(remminafile, "clientcert")) != NULL)
+			remmina_message_panel_field_set_filename(mp, REMMINA_MESSAGE_PANEL_CLIENTCERTFILE, s);
+		if ((s = remmina_file_get_string(remminafile, "clientkey")) != NULL)
+			remmina_message_panel_field_set_filename(mp, REMMINA_MESSAGE_PANEL_CLIENTKEYFILE, s);
+	}
+
+	d->gp->priv->auth_message_panel = mp;
+	rco_show_message_panel(d->gp->cnnobj, mp);
+
+	return FALSE;
+}
+
+typedef struct {
+	RemminaMessagePanel *	mp;
+	GMainLoop *		loop;
+	gint			response;
+	gboolean		destroyed;
+} MpRunInfo;
+
+static void shutdown_loop(MpRunInfo *mpri)
+{
+	if (g_main_loop_is_running(mpri->loop))
+		g_main_loop_quit(mpri->loop);
+}
+
+static void run_response_handler(RemminaMessagePanel *mp, gint response_id, gpointer data)
+{
+	MpRunInfo *mpri = (MpRunInfo *)data;
+
+	mpri->response = response_id;
+	shutdown_loop(mpri);
+}
+
+static void run_unmap_handler(RemminaMessagePanel *mp, gpointer data)
+{
+	MpRunInfo *mpri = (MpRunInfo *)data;
+
+	mpri->response = GTK_RESPONSE_CANCEL;
+	shutdown_loop(mpri);
+}
+
+static void run_destroy_handler(RemminaMessagePanel *mp, gpointer data)
+{
+	MpRunInfo *mpri = (MpRunInfo *)data;
+
+	mpri->destroyed = TRUE;
+	mpri->response = GTK_RESPONSE_CANCEL;
+	shutdown_loop(mpri);
+}
+
+static int remmina_protocol_widget_dialog(enum panel_type dtype, RemminaProtocolWidget *gp, RemminaMessagePanelFlags pflags,
+					  const gchar *title, const gchar *default_username, const gchar *default_password, const gchar *default_domain,
+					  const gchar *strpasswordlabel)
+{
+	TRACE_CALL(__func__);
+
+	struct remmina_protocol_widget_dialog_mt_data_t *d = (struct remmina_protocol_widget_dialog_mt_data_t *)g_malloc(sizeof(struct remmina_protocol_widget_dialog_mt_data_t));
+	int rcbutton;
+
+	d->gp = gp;
+	d->pflags = pflags;
+	d->dtype = dtype;
+	d->title = g_strdup(title);
+	d->strpasswordlabel = g_strdup(strpasswordlabel);
+	d->default_username = g_strdup(default_username);
+	d->default_password = g_strdup(default_password);
+	d->default_domain = g_strdup(default_domain);
+	d->called_from_subthread = FALSE;
+
+	if (remmina_masterthread_exec_is_main_thread()) {
+		/* Run the MessagePanel in main thread, in a very similar way of gtk_dialog_run() */
+		MpRunInfo mpri = { NULL, NULL, GTK_RESPONSE_CANCEL, FALSE };
+
+		gulong unmap_handler;
+		gulong destroy_handler;
+		gulong response_handler;
+
+		remmina_protocol_widget_dialog_mt_setup(d);
+
+		mpri.mp = d->gp->priv->auth_message_panel;
+
+		if (!gtk_widget_get_visible(GTK_WIDGET(mpri.mp)))
+			gtk_widget_show(GTK_WIDGET(mpri.mp));
+		response_handler = g_signal_connect(mpri.mp, "response", G_CALLBACK(run_response_handler), &mpri);
+		unmap_handler = g_signal_connect(mpri.mp, "unmap", G_CALLBACK(run_unmap_handler), &mpri);
+		destroy_handler = g_signal_connect(mpri.mp, "destroy", G_CALLBACK(run_destroy_handler), &mpri);
+
+		g_object_ref(mpri.mp);
+
+		mpri.loop = g_main_loop_new(NULL, FALSE);
+		g_main_loop_run(mpri.loop);
+		g_main_loop_unref(mpri.loop);
+
+		if (!mpri.destroyed) {
+			g_signal_handler_disconnect(mpri.mp, response_handler);
+			g_signal_handler_disconnect(mpri.mp, destroy_handler);
+			g_signal_handler_disconnect(mpri.mp, unmap_handler);
+		}
+		g_object_unref(mpri.mp);
+
+		rco_destroy_message_panel(d->gp->cnnobj, d->gp->priv->auth_message_panel);
+
+		rcbutton = mpri.response;
+	} else {
+		d->called_from_subthread = TRUE;
+		// pthread_cleanup_push(ptcleanup, (void*)d);
+		pthread_cond_init(&d->pt_cond, NULL);
+		pthread_mutex_init(&d->pt_mutex, NULL);
+		g_idle_add(remmina_protocol_widget_dialog_mt_setup, d);
+		pthread_mutex_lock(&d->pt_mutex);
+		pthread_cond_wait(&d->pt_cond, &d->pt_mutex);
+		// pthread_cleanup_pop(0);
+		pthread_mutex_destroy(&d->pt_mutex);
+		pthread_cond_destroy(&d->pt_cond);
+
+		rcbutton = d->rcbutton;
+	}
+
+	g_free(d->title);
+	g_free(d->strpasswordlabel);
+	g_free(d->default_username);
+	g_free(d->default_password);
+	g_free(d->default_domain);
+	g_free(d);
+	return rcbutton;
+}
+
+gint remmina_protocol_widget_panel_question_yesno(RemminaProtocolWidget *gp, const char *msg)
+{
+	return remmina_protocol_widget_dialog(RPWDT_QUESTIONYESNO, gp, 0, msg, NULL, NULL, NULL, NULL);
+}
+
+gint remmina_protocol_widget_panel_auth(RemminaProtocolWidget *gp, RemminaMessagePanelFlags pflags,
+					const gchar *title, const gchar *default_username, const gchar *default_password, const gchar *default_domain, const gchar *password_prompt)
+{
+	TRACE_CALL(__func__);
+	return remmina_protocol_widget_dialog(RPWDT_AUTH, gp, pflags, title, default_username,
+					      default_password, default_domain, password_prompt == NULL ? _("Password") : password_prompt);
+}
+
+gint remmina_protocol_widget_panel_authuserpwd_ssh_tunnel(RemminaProtocolWidget *gp, gboolean want_domain, gboolean allow_password_saving)
+{
+	TRACE_CALL(__func__);
+	unsigned pflags;
+	RemminaFile *remminafile = gp->priv->remmina_file;
+	const gchar *username, *password;
+
+	pflags = REMMINA_MESSAGE_PANEL_FLAG_USERNAME;
+	if (remmina_file_get_filename(remminafile) != NULL &&
+	    !remminafile->prevent_saving && allow_password_saving)
+		pflags |= REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD;
+
+	username = remmina_file_get_string(remminafile, "ssh_tunnel_username");
+	password = remmina_file_get_string(remminafile, "ssh_tunnel_password");
+
+	return remmina_protocol_widget_dialog(RPWDT_AUTH, gp, pflags, _("Type in SSH username and password."), username,
+					      password, NULL, _("Password"));
+}
+
+/*
+ * gint remmina_protocol_widget_panel_authpwd(RemminaProtocolWidget* gp, RemminaAuthpwdType authpwd_type, gboolean allow_password_saving)
+ * {
+ *      TRACE_CALL(__func__);
+ *      unsigned pflags;
+ *      RemminaFile* remminafile = gp->priv->remmina_file;
+ *      char *password_prompt;
+ *      int rc;
+ *
+ *      pflags = 0;
+ *      if (remmina_file_get_filename(remminafile) != NULL &&
+ *               !remminafile->prevent_saving && allow_password_saving)
+ *              pflags |= REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD;
+ *
+ *      switch (authpwd_type) {
+ *              case REMMINA_AUTHPWD_TYPE_PROTOCOL:
+ *                      password_prompt = g_strdup_printf(_("%s password"), remmina_file_get_string(remminafile, "protocol"));
+ *                      break;
+ *              case REMMINA_AUTHPWD_TYPE_SSH_PWD:
+ *                      password_prompt = g_strdup(_("SSH password"));
+ *                      break;
+ *              case REMMINA_AUTHPWD_TYPE_SSH_PRIVKEY:
+ *                      password_prompt = g_strdup(_("SSH private key passphrase"));
+ *                      break;
+ *              default:
+ *                      password_prompt = g_strdup(_("Password"));
+ *                      break;
+ *      }
+ *
+ *      rc = remmina_protocol_widget_dialog(RPWDT_AUTH, gp, pflags, password_prompt);
+ *      g_free(password_prompt);
+ *      return rc;
+ *
+ * }
+ */
+gint remmina_protocol_widget_panel_authx509(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+
+	return remmina_protocol_widget_dialog(RPWDT_AUTHX509, gp, 0, NULL, NULL, NULL, NULL, NULL);
+}
+
+
+gint remmina_protocol_widget_panel_new_certificate(RemminaProtocolWidget *gp, const gchar *subject, const gchar *issuer, const gchar *fingerprint)
+{
+	TRACE_CALL(__func__);
+	gchar *s;
+	int rc;
+
+	if (remmina_pref_get_boolean("trust_all")) {
+		/* For compatibility with plugin API: The plugin expects GTK_RESPONSE_OK when user confirms new cert */
+		remmina_public_send_notification("remmina-security-trust-all-id", _("Fingerprint automatically accepted"), fingerprint);
+		rc = GTK_RESPONSE_OK;
+		return rc;
+	}
+	// For markup see https://developer.gnome.org/pygtk/stable/pango-markup-language.html
+	s = g_strdup_printf(
+		"<big>%s</big>\n\n%s %s\n%s %s\n%s %s\n\n<big>%s</big>",
+		// TRANSLATORS: The user is asked to verify a new SSL certificate.
+		_("Certificate details:"),
+		// TRANSLATORS: An SSL certificate subject is usually the remote server the user connect to.
+		_("Subject:"), subject,
+		// TRANSLATORS: The name or email of the entity that have issued the SSL certificate
+		_("Issuer:"), issuer,
+		// TRANSLATORS: An SSL certificate fingerprint, is a hash of a certificate calculated on all certificate's data and its signature.
+		_("Fingerprint:"), fingerprint,
+		// TRANSLATORS: The user is asked to accept or refuse a new SSL certificate.
+		_("Accept certificate?"));
+	rc = remmina_protocol_widget_dialog(RPWDT_QUESTIONYESNO, gp, 0, s, NULL, NULL, NULL, NULL);
+	g_free(s);
+
+	/* For compatibility with plugin API: the plugin expects GTK_RESPONSE_OK when user confirms new cert */
+	return rc == GTK_RESPONSE_YES ? GTK_RESPONSE_OK : rc;
+}
+
+gint remmina_protocol_widget_panel_changed_certificate(RemminaProtocolWidget *gp, const gchar *subject, const gchar *issuer, const gchar *new_fingerprint, const gchar *old_fingerprint)
+{
+	TRACE_CALL(__func__);
+	gchar *s;
+	int rc;
+
+	if (remmina_pref_get_boolean("trust_all")) {
+		/* For compatibility with plugin API: The plugin expects GTK_RESPONSE_OK when user confirms new cert */
+		remmina_public_send_notification("remmina-security-trust-all-id", _("Fingerprint automatically accepted"), new_fingerprint);
+		rc = GTK_RESPONSE_OK;
+		return rc;
+	}
+	// For markup see https://developer.gnome.org/pygtk/stable/pango-markup-language.html
+	s = g_strdup_printf(
+		"<big>%s</big>\n\n%s %s\n%s %s\n%s %s\n%s %s\n\n<big>%s</big>",
+		// TRANSLATORS: The user is asked to verify a new SSL certificate.
+		_("The certificate changed! Details:"),
+		// TRANSLATORS: An SSL certificate subject is usually the remote server the user connect to.
+		_("Subject:"), subject,
+		// TRANSLATORS: The name or email of the entity that have issued the SSL certificate
+		_("Issuer:"), issuer,
+		// TRANSLATORS: An SSL certificate fingerprint, is a hash of a certificate calculated on all certificate's data and its signature.
+		_("Old fingerprint:"), old_fingerprint,
+		// TRANSLATORS: An SSL certificate fingerprint, is a hash of a certificate calculated on all certificate's data and its signature.
+		_("New fingerprint:"), new_fingerprint,
+		// TRANSLATORS: The user is asked to accept or refuse a new SSL certificate.
+		_("Accept changed certificate?"));
+	rc = remmina_protocol_widget_dialog(RPWDT_QUESTIONYESNO, gp, 0, s, NULL, NULL, NULL, NULL);
+	g_free(s);
+
+	/* For compatibility with plugin API: The plugin expects GTK_RESPONSE_OK when user confirms new cert */
+	return rc == GTK_RESPONSE_YES ? GTK_RESPONSE_OK : rc;
+}
+
+gchar *remmina_protocol_widget_get_username(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	return g_strdup(gp->priv->username);
+}
+
+gchar *remmina_protocol_widget_get_password(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	return g_strdup(gp->priv->password);
+}
+
+gchar *remmina_protocol_widget_get_domain(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	return g_strdup(gp->priv->domain);
+}
+
+gboolean remmina_protocol_widget_get_savepassword(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	return gp->priv->save_password;
+}
+
+gchar *remmina_protocol_widget_get_cacert(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	gchar *s;
+
+	s = gp->priv->cacert;
+	return s && s[0] ? g_strdup(s) : NULL;
+}
+
+gchar *remmina_protocol_widget_get_cacrl(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	gchar *s;
+
+	s = gp->priv->cacrl;
+	return s && s[0] ? g_strdup(s) : NULL;
+}
+
+gchar *remmina_protocol_widget_get_clientcert(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	gchar *s;
+
+	s = gp->priv->clientcert;
+	return s && s[0] ? g_strdup(s) : NULL;
+}
+
+gchar *remmina_protocol_widget_get_clientkey(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	gchar *s;
+
+	s = gp->priv->clientkey;
+	return s && s[0] ? g_strdup(s) : NULL;
+}
+
+void remmina_protocol_widget_save_cred(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+
+	RemminaFile *remminafile = gp->priv->remmina_file;
+	gchar *s;
+	gboolean save = FALSE;
+
+	if (!remmina_masterthread_exec_is_main_thread()) {
+		/* Allow the execution of this function from a non main thread */
+		RemminaMTExecData *d;
+		d = (RemminaMTExecData *)g_malloc(sizeof(RemminaMTExecData));
+		d->func = FUNC_INIT_SAVE_CRED;
+		d->p.init_save_creds.gp = gp;
+		remmina_masterthread_exec_and_wait(d);
+		g_free(d);
+		return;
+	}
+
+	/* Save username and certificates if any; save the password if it’s requested to do so */
+	s = gp->priv->username;
+	if (s && s[0]) {
+		remmina_file_set_string(remminafile, "username", s);
+		save = TRUE;
+	}
+	s = gp->priv->cacert;
+	if (s && s[0]) {
+		remmina_file_set_string(remminafile, "cacert", s);
+		save = TRUE;
+	}
+	s = gp->priv->cacrl;
+	if (s && s[0]) {
+		remmina_file_set_string(remminafile, "cacrl", s);
+		save = TRUE;
+	}
+	s = gp->priv->clientcert;
+	if (s && s[0]) {
+		remmina_file_set_string(remminafile, "clientcert", s);
+		save = TRUE;
+	}
+	s = gp->priv->clientkey;
+	if (s && s[0]) {
+		remmina_file_set_string(remminafile, "clientkey", s);
+		save = TRUE;
+	}
+	if (gp->priv->save_password) {
+		remmina_file_set_string(remminafile, "password", gp->priv->password);
+		save = TRUE;
+	}
+	if (save)
+		remmina_file_save(remminafile);
+}
+
+
+void remmina_protocol_widget_panel_show_listen(RemminaProtocolWidget *gp, gint port)
+{
+	TRACE_CALL(__func__);
+	RemminaMessagePanel *mp;
+	gchar *s;
+
+	if (!remmina_masterthread_exec_is_main_thread()) {
+		/* Allow the execution of this function from a non main thread */
+		RemminaMTExecData *d;
+		d = (RemminaMTExecData *)g_malloc(sizeof(RemminaMTExecData));
+		d->func = FUNC_PROTOCOLWIDGET_PANELSHOWLISTEN;
+		d->p.protocolwidget_panelshowlisten.gp = gp;
+		d->p.protocolwidget_panelshowlisten.port = port;
+		remmina_masterthread_exec_and_wait(d);
+		g_free(d);
+		return;
+	}
+
+	mp = remmina_message_panel_new();
+	s = g_strdup_printf(
+		// TRANSLATORS: “%i” is a placeholder for a port number. “%s”  is a placeholder for a protocol name (VNC).
+		_("Listening on port %i for an incoming %s connection…"), port,
+		remmina_file_get_string(gp->priv->remmina_file, "protocol"));
+	remmina_message_panel_setup_progress(mp, s, NULL, NULL);
+	g_free(s);
+	gp->priv->listen_message_panel = mp;
+	rco_show_message_panel(gp->cnnobj, mp);
+}
+
+void remmina_protocol_widget_panel_show_retry(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaMessagePanel *mp;
+
+	if (!remmina_masterthread_exec_is_main_thread()) {
+		/* Allow the execution of this function from a non main thread */
+		RemminaMTExecData *d;
+		d = (RemminaMTExecData *)g_malloc(sizeof(RemminaMTExecData));
+		d->func = FUNC_PROTOCOLWIDGET_MPSHOWRETRY;
+		d->p.protocolwidget_mpshowretry.gp = gp;
+		remmina_masterthread_exec_and_wait(d);
+		g_free(d);
+		return;
+	}
+
+	mp = remmina_message_panel_new();
+	remmina_message_panel_setup_progress(mp, _("Could not authenticate, attempting reconnection…"), NULL, NULL);
+	gp->priv->retry_message_panel = mp;
+	rco_show_message_panel(gp->cnnobj, mp);
+}
+
+void remmina_protocol_widget_panel_show(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	printf("Remmina: The %s function is not implemented, and is left here only for plugin API compatibility.\n", __func__);
+}
+
+void remmina_protocol_widget_panel_hide(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	printf("Remmina: The %s function is not implemented, and is left here only for plugin API compatibility.\n", __func__);
+}
+
+static void remmina_protocol_widget_chat_on_destroy(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	gp->priv->chat_window = NULL;
+}
+
+void remmina_protocol_widget_chat_open(RemminaProtocolWidget *gp, const gchar *name,
+				       void (*on_send)(RemminaProtocolWidget *gp, const gchar *text), void (*on_destroy)(RemminaProtocolWidget *gp))
+{
+	TRACE_CALL(__func__);
+	if (gp->priv->chat_window) {
+		gtk_window_present(GTK_WINDOW(gp->priv->chat_window));
+	} else {
+		gp->priv->chat_window = remmina_chat_window_new(GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(gp))), name);
+		g_signal_connect_swapped(G_OBJECT(gp->priv->chat_window), "send", G_CALLBACK(on_send), gp);
+		g_signal_connect_swapped(G_OBJECT(gp->priv->chat_window), "destroy",
+					 G_CALLBACK(remmina_protocol_widget_chat_on_destroy), gp);
+		g_signal_connect_swapped(G_OBJECT(gp->priv->chat_window), "destroy", G_CALLBACK(on_destroy), gp);
+		gtk_widget_show(gp->priv->chat_window);
+	}
+}
+
+void remmina_protocol_widget_chat_close(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	if (gp->priv->chat_window)
+		gtk_widget_destroy(gp->priv->chat_window);
+}
+
+void remmina_protocol_widget_chat_receive(RemminaProtocolWidget *gp, const gchar *text)
+{
+	TRACE_CALL(__func__);
+	/* This function can be called from a non main thread */
+
+	if (gp->priv->chat_window) {
+		if (!remmina_masterthread_exec_is_main_thread()) {
+			/* Allow the execution of this function from a non main thread */
+			RemminaMTExecData *d;
+			d = (RemminaMTExecData *)g_malloc(sizeof(RemminaMTExecData));
+			d->func = FUNC_CHAT_RECEIVE;
+			d->p.chat_receive.gp = gp;
+			d->p.chat_receive.text = text;
+			remmina_masterthread_exec_and_wait(d);
+			g_free(d);
+			return;
+		}
+		remmina_chat_window_receive(REMMINA_CHAT_WINDOW(gp->priv->chat_window), _("Server"), text);
+		gtk_window_present(GTK_WINDOW(gp->priv->chat_window));
+	}
+}
+
+void remmina_protocol_widget_setup(RemminaProtocolWidget *gp, RemminaFile *remminafile, RemminaConnectionObject *cnnobj)
+{
+	RemminaProtocolPlugin *plugin;
+
+	gp->priv->remmina_file = remminafile;
+	gp->cnnobj = cnnobj;
+
+	/* Locate the protocol plugin */
+	plugin = (RemminaProtocolPlugin *)remmina_plugin_manager_get_plugin(REMMINA_PLUGIN_TYPE_PROTOCOL,
+									    remmina_file_get_string(remminafile, "protocol"));
+
+	if (!plugin || !plugin->init || !plugin->open_connection) {
+		// TRANSLATORS: “%s” is a placeholder for a protocol name, like “RDP”.
+		remmina_protocol_widget_set_error(gp, _("Install the %s protocol plugin first."),
+						  remmina_file_get_string(remminafile, "protocol"));
+		gp->priv->plugin = NULL;
+		return;
+	}
+	gp->priv->plugin = plugin;
+	gp->plugin = plugin;
+
+	gp->priv->scalemode = remmina_file_get_int(gp->priv->remmina_file, "scale", FALSE);
+	gp->priv->scaler_expand = remmina_file_get_int(gp->priv->remmina_file, "scaler_expand", FALSE);
+}
+
+GtkWindow *remmina_protocol_widget_get_gtkwindow(RemminaProtocolWidget *gp)
+{
+	return rcw_get_gtkwindow(gp->cnnobj);
+}
+
+GtkWidget *remmina_protocol_widget_gtkviewport(RemminaProtocolWidget *gp)
+{
+	return rcw_get_gtkviewport(gp->cnnobj);
+}
+
+GtkWidget *remmina_protocol_widget_new(void)
+{
+	return GTK_WIDGET(g_object_new(REMMINA_TYPE_PROTOCOL_WIDGET, NULL));
+}
+
+/* Send one or more keystrokes to a specific widget by firing key-press and
+ * key-release events.
+ * GdkEventType action can be GDK_KEY_PRESS or GDK_KEY_RELEASE or both to
+ * press the keys and release them in reversed order. */
+void remmina_protocol_widget_send_keys_signals(GtkWidget *widget, const guint *keyvals, int keyvals_length, GdkEventType action)
+{
+	TRACE_CALL(__func__);
+	int i;
+	GdkEventKey event;
+	gboolean result;
+	GdkKeymap *keymap = gdk_keymap_get_for_display(gdk_display_get_default());
+
+	event.window = gtk_widget_get_window(widget);
+	event.send_event = TRUE;
+	event.time = GDK_CURRENT_TIME;
+	event.state = 0;
+	event.length = 0;
+	event.string = "";
+	event.group = 0;
+
+	if (action & GDK_KEY_PRESS) {
+		/* Press the requested buttons */
+		event.type = GDK_KEY_PRESS;
+		for (i = 0; i < keyvals_length; i++) {
+			event.keyval = keyvals[i];
+			event.hardware_keycode = remmina_public_get_keycode_for_keyval(keymap, event.keyval);
+			event.is_modifier = (int)remmina_public_get_modifier_for_keycode(keymap, event.hardware_keycode);
+			REMMINA_DEBUG("Sending keyval: %u, hardware_keycode: %u", event.keyval, event.hardware_keycode);
+			g_signal_emit_by_name(G_OBJECT(widget), "key-press-event", &event, &result);
+		}
+	}
+
+	if (action & GDK_KEY_RELEASE) {
+		/* Release the requested buttons in reverse order */
+		event.type = GDK_KEY_RELEASE;
+		for (i = (keyvals_length - 1); i >= 0; i--) {
+			event.keyval = keyvals[i];
+			event.hardware_keycode = remmina_public_get_keycode_for_keyval(keymap, event.keyval);
+			event.is_modifier = (int)remmina_public_get_modifier_for_keycode(keymap, event.hardware_keycode);
+			g_signal_emit_by_name(G_OBJECT(widget), "key-release-event", &event, &result);
+		}
+	}
+}
+
+void remmina_protocol_widget_update_remote_resolution(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	GdkRectangle rect;
+	gint w, h;
+	gint wfile, hfile;
+	RemminaProtocolWidgetResolutionMode res_mode;
+	RemminaScaleMode scalemode;
+
+	rco_get_monitor_geometry(gp->cnnobj, &rect);
+
+	/* Integrity check: check that we have a cnnwin visible and get t  */
+
+	res_mode = remmina_file_get_int(gp->priv->remmina_file, "resolution_mode", RES_INVALID);
+	scalemode = remmina_file_get_int(gp->priv->remmina_file, "scale", REMMINA_PROTOCOL_WIDGET_SCALE_MODE_NONE);
+	wfile = remmina_file_get_int(gp->priv->remmina_file, "resolution_width", -1);
+	hfile = remmina_file_get_int(gp->priv->remmina_file, "resolution_height", -1);
+
+	/* If resolution_mode is non-existent (-1), then we try to calculate it
+	 * as we did before having resolution_mode */
+	if (res_mode == RES_INVALID) {
+		if (wfile <= 0 || hfile <= 0)
+			res_mode = RES_USE_INITIAL_WINDOW_SIZE;
+		else
+			res_mode = RES_USE_CUSTOM;
+	}
+
+	if (res_mode == RES_USE_INITIAL_WINDOW_SIZE || scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_DYNRES) {
+		/* Use internal window size as remote desktop size */
+		GtkAllocation al;
+		gtk_widget_get_allocation(GTK_WIDGET(gp), &al);
+		/* use a multiple of four to mitigate scaling when remote host rounds up */
+		w = al.width - al.width % 4;
+		h = al.height - al.height % 4;
+		if (w < 10) {
+			printf("Remmina warning: %s RemminaProtocolWidget w=%d h=%d are too small, adjusting to 640x480\n", __func__, w, h);
+			w = 640;
+			h = 480;
+		}
+		/* Due to approximations while GTK calculates scaling, (w x h) may exceed our monitor geometry
+		 * Adjust to fit. */
+		if (w > rect.width)
+			w = rect.width;
+		if (h > rect.height)
+			h = rect.height;
+	} else if (res_mode == RES_USE_CLIENT) {
+		w = rect.width;
+		h = rect.height;
+	} else {
+		w = wfile;
+		h = hfile;
+	}
+	gp->priv->profile_remote_width = w;
+	gp->priv->profile_remote_height = h;
+}