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

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

110 files changed, 41310 insertions, 0 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
new file mode 100644
index 0000000..9a0627c
--- /dev/null
+++ b/src/CMakeLists.txt
@@ -0,0 +1,282 @@
+# src/remmina - The GTK+ Remote Desktop Client
+#
+# Copyright (C) 2011 Marc-Andre Moreau
+# 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.
+
+list(
+  APPEND
+  REMMINA_SRCS
+  "remmina_about.c"
+  "remmina_about.h"
+  "remmina_applet_menu.c"
+  "remmina_applet_menu.h"
+  "remmina_applet_menu_item.c"
+  "remmina_applet_menu_item.h"
+  "remmina_avahi.c"
+  "remmina_avahi.h"
+  "remmina.c"
+  "remmina.h"
+  "remmina_bug_report.c"
+  "remmina_bug_report.h"
+  "remmina_chat_window.c"
+  "remmina_chat_window.h"
+  "remmina_crypt.c"
+  "remmina_crypt.h"
+  "remmina_exec.c"
+  "remmina_exec.h"
+  "remmina_file.c"
+  "remmina_file_editor.c"
+  "remmina_file_editor.h"
+  "remmina_file.h"
+  "remmina_file_manager.c"
+  "remmina_file_manager.h"
+  "remmina_ftp_client.c"
+  "remmina_ftp_client.h"
+  "remmina_icon.c"
+  "remmina_icon.h"
+  "remmina_key_chooser.c"
+  "remmina_key_chooser.h"
+  "remmina_log.c"
+  "remmina_log.h"
+  "remmina_main.c"
+  "remmina_main.h"
+  "remmina_monitor.c"
+  "remmina_monitor.h"
+  "remmina_marshals.c"
+  "remmina_marshals.h"
+  "remmina_marshals.list"
+  "remmina_masterthread_exec.c"
+  "remmina_masterthread_exec.h"
+  "remmina_message_panel.c"
+  "remmina_message_panel.h"
+  "remmina_plugin_manager.c"
+  "remmina_plugin_manager.h"
+  "remmina_plugin_native.c"
+  "remmina_plugin_native.h"
+  "remmina_ext_exec.c"
+  "remmina_ext_exec.h"
+  "remmina_passwd.c"
+  "remmina_passwd.h"
+  "remmina_pref.c"
+  "remmina_pref_dialog.c"
+  "remmina_pref_dialog.h"
+  "remmina_pref.h"
+  "remmina_protocol_widget.c"
+  "remmina_protocol_widget.h"
+  "remmina_public.c"
+  "remmina_public.h"
+  "remmina_scrolled_viewport.c"
+  "remmina_scrolled_viewport.h"
+  "remmina_sftp_client.c"
+  "remmina_sftp_client.h"
+  "remmina_sftp_plugin.c"
+  "remmina_sftp_plugin.h"
+  "remmina_sodium.c"
+  "remmina_sodium.h"
+  "remmina_curl_connector.c"
+  "remmina_curl_connector.h"
+  "remmina_ssh.c"
+  "remmina_ssh.h"
+  "remmina_ssh_plugin.c"
+  "remmina_ssh_plugin.h"
+  "remmina_string_array.c"
+  "remmina_string_array.h"
+  "remmina_string_list.c"
+  "remmina_string_list.h"
+  "remmina_unlock.c"
+  "remmina_unlock.h"
+  "remmina_utils.c"
+  "remmina_utils.h"
+  "remmina_widget_pool.c"
+  "remmina_widget_pool.h"
+  "remmina_external_tools.c"
+  "remmina_external_tools.h"
+  "remmina_sysinfo.h"
+  "remmina_sysinfo.c"
+  "rcw.c"
+  "rcw.h"
+  "remmina_mpchange.c"
+  "remmina_mpchange.h"
+  "remmina_scheduler.c"
+  "remmina_scheduler.h"
+  "remmina_info.c"
+  "remmina_info.h"
+  "resources.c")
+
+set(RESOURCE_LIST
+    ${CMAKE_CURRENT_SOURCE_DIR}/../data/ui/remmina_about.glade
+    ${CMAKE_CURRENT_SOURCE_DIR}/../data/ui/remmina_bug_report.glade
+    ${CMAKE_CURRENT_SOURCE_DIR}/../data/ui/remmina_key_chooser.glade
+    ${CMAKE_CURRENT_SOURCE_DIR}/../data/ui/remmina_main.glade
+    ${CMAKE_CURRENT_SOURCE_DIR}/../data/ui/remmina_mpc.glade
+    ${CMAKE_CURRENT_SOURCE_DIR}/../data/ui/remmina_info.glade
+    ${CMAKE_CURRENT_SOURCE_DIR}/../data/ui/remmina_passwd.glade
+    ${CMAKE_CURRENT_SOURCE_DIR}/../data/ui/remmina_preferences.glade
+    ${CMAKE_CURRENT_SOURCE_DIR}/../data/ui/remmina_search.glade
+    ${CMAKE_CURRENT_SOURCE_DIR}/../data/ui/remmina_search_popover.glade
+    ${CMAKE_CURRENT_SOURCE_DIR}/../data/ui/remmina_snap_info_dialog.glade
+    ${CMAKE_CURRENT_SOURCE_DIR}/../data/ui/remmina_spinner.glade
+    ${CMAKE_CURRENT_SOURCE_DIR}/../data/ui/remmina_string_list.glade
+    ${CMAKE_CURRENT_SOURCE_DIR}/../data/ui/remmina_unlock.glade)
+message(DEBUG "Source list set to: " ${REMMINA_SRCS})
+
+compile_gresources(
+  RESOURCE_FILE
+  XML_OUT
+  TYPE
+  EMBED_C
+  PREFIX
+  /org/remmina/Remmina/src
+  SOURCE_DIR
+  ${CMAKE_CURRENT_SOURCE_DIR}
+  RESOURCES
+  ${RESOURCE_LIST})
+
+add_custom_target(resource DEPENDS ${RESOURCE_FILE})
+add_executable(remmina ${REMMINA_SRCS} ${RESOURCE_FILE})
+add_dependencies(remmina resource)
+target_link_libraries(remmina ${GTK_LIBRARIES} -rdynamic)
+
+if(WITH_PYTHONLIBS)
+  if(PythonLibs_FOUND)
+    include_directories(${PYTHON_INCLUDE_DIRS})
+    target_link_libraries(remmina ${PYTHON_LIBRARIES})
+  endif()
+endif()
+
+if(WITH_MANPAGES)
+  install(FILES remmina.1 DESTINATION ${CMAKE_INSTALL_FULL_MANDIR}/man1)
+endif()
+
+target_link_libraries(remmina ${CMAKE_THREAD_LIBS_INIT})
+
+if(Intl_FOUND)
+  message(STATUS "${CMAKE_SYSTEM_NAME} detected, building with Intl")
+  include_directories(${Intl_INCLUDE_DIRS})
+  target_link_libraries(remmina ${Intl_LIBRARIES})
+endif()
+
+find_suggested_package(LIBSSH)
+if(LIBSSH_FOUND)
+  add_definitions(-DHAVE_LIBSSH)
+  include_directories(${LIBSSH_INCLUDE_DIRS})
+  target_link_libraries(remmina ${LIBSSH_LIBRARIES})
+endif()
+
+if(GCRYPT_FOUND)
+  include_directories(${GCRYPT_INCLUDE_DIRS})
+  target_link_libraries(remmina ${GCRYPT_LIBRARIES})
+endif()
+
+if(AVAHI_FOUND)
+  include_directories(${AVAHI_INCLUDE_DIRS})
+  target_link_libraries(remmina ${AVAHI_LIBRARIES})
+endif()
+
+if(OPENSSL_FOUND)
+  include_directories(${OPENSSL_INCLUDE_DIRS})
+  target_link_libraries(remmina ${OPENSSL_LIBRARIES})
+endif()
+
+option(WITH_VTE "Build with support for VTE" ON)
+if(GTK3_FOUND AND WITH_VTE)
+  set(_VTE_VERSION_NUMS 2.91 2.90)
+  foreach(__VTE_VERSION ${_VTE_VERSION_NUMS})
+    set(_VTE_VERSION_NUM ${__VTE_VERSION})
+    find_suggested_package(VTE)
+    if(VTE_FOUND)
+      break()
+    endif()
+    message(STATUS "VTE ${__VTE_VERSION} not found")
+  endforeach()
+elseif(WITH_VTE)
+  set(_VTE_VERSION_NUM)
+  find_package(VTE)
+endif()
+
+if(VTE_FOUND)
+  add_definitions(-DHAVE_LIBVTE)
+  include_directories(${VTE_INCLUDE_DIRS})
+  target_link_libraries(remmina ${VTE_LIBRARIES})
+endif()
+
+if(sodium_FOUND)
+  message(STATUS "Sodium found")
+  message(STATUS "Sodium include dirs ${sodium_INCLUDE_DIR}")
+  include_directories(${sodium_INCLUDE_DIR})
+  target_link_libraries(remmina sodium)
+endif()
+
+option(HAVE_LIBAPPINDICATOR "Build with support for status icon. Appindicator is required" ON)
+if(GTK3_FOUND)
+    if(HAVE_LIBAPPINDICATOR)
+        find_required_package(APPINDICATOR)
+        if(APPINDICATOR_FOUND)
+            add_definitions(-DHAVE_LIBAPPINDICATOR)
+            include_directories(${APPINDICATOR_INCLUDE_DIRS})
+            target_link_libraries(remmina ${APPINDICATOR_LIBRARIES})
+            message(STATUS "AppIndicator library dirs ${APPINDICATOR_LIBRARIES}")
+            message(STATUS "AppIndicator include dirs ${APPINDICATOR_INCLUDE_DIRS}")
+        else()
+            message(FATAL_ERROR "AppIndicator not found")
+        endif()
+    endif()
+  find_required_package(JSONGLIB)
+  if(JSONGLIB_FOUND)
+    include_directories(${JSONGLIB_INCLUDE_DIRS})
+    target_link_libraries(remmina ${JSONGLIB_LIBRARIES})
+  else()
+    message(FATAL_ERROR "json-glib library not found")
+  endif()
+endif()
+
+find_required_package(CURL)
+if(NOT CURL_FOUND)
+  message(FATAL_ERROR "libcurl not found")
+else()
+  include_directories(${CURL_INCLUDE_DIRS})
+  target_link_libraries(remmina ${CURL_LIBRARIES})
+endif()
+
+find_required_package(PCRE2)
+if(NOT PCRE2_FOUND)
+  message(FATAL_ERROR "libpcre2 library not found")
+endif()
+include_directories(${PCRE2_INCLUDE_DIRS})
+
+add_subdirectory(external_tools)
+
+install(TARGETS remmina DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(
+  DIRECTORY include/remmina/
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/remmina
+  FILES_MATCHING
+  PATTERN "*.h")
+
+add_definitions(-DG_LOG_DOMAIN="remmina")
diff --git a/src/external_tools/CMakeLists.txt b/src/external_tools/CMakeLists.txt
new file mode 100644
index 0000000..f7b17cf
--- /dev/null
+++ b/src/external_tools/CMakeLists.txt
@@ -0,0 +1,44 @@
+# desktop/remmina - The GTK+ Remote Desktop Client
+#
+# Copyright (C) 2011 Marc-Andre Moreau
+# Copyright (C) 2014-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.
+
+INSTALL(PROGRAMS
+    launcher.sh
+    functions.sh
+    remmina_filezilla_sftp.sh
+    remmina_filezilla_sftp_pki.sh
+    remmina_nslookup.sh
+    remmina_ping.sh
+    remmina_traceroute.sh
+    DESTINATION ${REMMINA_EXTERNAL_TOOLS_DIR})
+
+
diff --git a/src/external_tools/functions.sh b/src/external_tools/functions.sh
new file mode 100755
index 0000000..2f70eaf
--- /dev/null
+++ b/src/external_tools/functions.sh
@@ -0,0 +1,16 @@
+#!/bin/sh
+
+# Awaits user key press.
+pause ()
+{
+ echo "Press any key to continue…"
+ OLDCONFIG=$(stty -g)
+ stty -icanon -echo min 1 time 0
+ dd count=1 2>/dev/null
+ stty $OLDCONFIG
+}
+
+# Set terminal title for gnome-terminal and many others
+settitle() {
+  echo -n -e "\033]0;${remmina_term_title}\007"
+}
diff --git a/src/external_tools/launcher.sh b/src/external_tools/launcher.sh
new file mode 100755
index 0000000..ff056cc
--- /dev/null
+++ b/src/external_tools/launcher.sh
@@ -0,0 +1,28 @@
+#!/bin/sh
+
+####################
+# Main Script
+####################
+
+TERMINALS="xfce4-terminal gnome-terminal x-terminal-emulator"
+
+for t in $TERMINALS; do
+  TERMBIN="$(command -v "$t")"
+  if [ "$?" -eq 0 ]; then
+    case "$t" in
+      xfce4-terminal)
+        TERMBIN="$TERMBIN --disable-server"
+        break
+        ;;
+      gnome-terminal)
+        break
+        ;;
+      x-terminal-emulator)
+        break
+        ;;
+    esac
+  fi
+done
+
+$TERMBIN -e "$1" &
+
diff --git a/src/external_tools/remmina_filezilla_sftp.sh b/src/external_tools/remmina_filezilla_sftp.sh
new file mode 100755
index 0000000..63c1b11
--- /dev/null
+++ b/src/external_tools/remmina_filezilla_sftp.sh
@@ -0,0 +1,7 @@
+#!/bin/sh
+
+. $(dirname $0)/functions.sh
+settitle
+
+filezilla sftp://$username:"$password"@$server 
+
diff --git a/src/external_tools/remmina_filezilla_sftp_pki.sh b/src/external_tools/remmina_filezilla_sftp_pki.sh
new file mode 100755
index 0000000..5b1ac50
--- /dev/null
+++ b/src/external_tools/remmina_filezilla_sftp_pki.sh
@@ -0,0 +1,7 @@
+#!/bin/sh
+
+. $(dirname $0)/functions.sh
+settitle
+
+filezilla sftp://$ssh_username@$server 
+
diff --git a/src/external_tools/remmina_nslookup.sh b/src/external_tools/remmina_nslookup.sh
new file mode 100755
index 0000000..9f48953
--- /dev/null
+++ b/src/external_tools/remmina_nslookup.sh
@@ -0,0 +1,8 @@
+#!/bin/sh
+
+. $(dirname $0)/functions.sh
+settitle
+
+nslookup $server
+
+pause
diff --git a/src/external_tools/remmina_ping.sh b/src/external_tools/remmina_ping.sh
new file mode 100755
index 0000000..f69fe5e
--- /dev/null
+++ b/src/external_tools/remmina_ping.sh
@@ -0,0 +1,8 @@
+#!/bin/sh
+
+. $(dirname $0)/functions.sh
+settitle
+
+ping -c3 $server
+
+pause
diff --git a/src/external_tools/remmina_traceroute.sh b/src/external_tools/remmina_traceroute.sh
new file mode 100755
index 0000000..3b5d8cc
--- /dev/null
+++ b/src/external_tools/remmina_traceroute.sh
@@ -0,0 +1,8 @@
+#!/bin/sh
+
+. $(dirname $0)/functions.sh
+settitle
+
+traceroute $server
+
+pause
diff --git a/src/include/remmina/plugin.h b/src/include/remmina/plugin.h
new file mode 100644
index 0000000..64e367a
--- /dev/null
+++ b/src/include/remmina/plugin.h
@@ -0,0 +1,326 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010-2011 Vic Lee
+ * Copyright (C) 2014-2015 Antenore Gatta, Fabio Castelli, Giovanni Panozzo
+ * Copyright (C) 2016-2023 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include <stdarg.h>
+#include <remmina/types.h>
+#include "remmina/remmina_trace_calls.h"
+
+G_BEGIN_DECLS
+
+typedef enum {
+	REMMINA_PLUGIN_TYPE_PROTOCOL	= 0,
+	REMMINA_PLUGIN_TYPE_ENTRY	= 1,
+	REMMINA_PLUGIN_TYPE_FILE	= 2,
+	REMMINA_PLUGIN_TYPE_TOOL	= 3,
+	REMMINA_PLUGIN_TYPE_PREF	= 4,
+	REMMINA_PLUGIN_TYPE_SECRET	= 5,
+	REMMINA_PLUGIN_TYPE_LANGUAGE_WRAPPER	= 6
+} RemminaPluginType;
+
+typedef struct _RemminaPlugin {
+	RemminaPluginType	type;
+	const gchar *		name;
+	const gchar *		description;
+	const gchar *		domain;
+	const gchar *		version;
+} RemminaPlugin;
+
+typedef struct _RemminaServerPluginResponse {
+	const gchar * name;
+	const gchar * version;
+	const gchar * file_name; 
+    /*
+     * This is the signature received directly from the server. It should be base64 encoded.
+     */
+	const guchar * signature;
+    /*
+     * This is the data received directly from the server. It should be
+     * first compressed with gzip and then base64 encoded.
+    */
+	guchar * data;
+} RemminaServerPluginResponse;
+
+typedef struct _RemminaProtocolPlugin _RemminaProtocolPlugin;
+typedef struct _RemminaProtocolPlugin {
+	RemminaPluginType		type;
+	const gchar *			name;
+	const gchar *			description;
+	const gchar *			domain;
+	const gchar *			version;
+
+	const gchar *			icon_name;
+	const gchar *			icon_name_ssh;
+	const RemminaProtocolSetting *	basic_settings;
+    	const RemminaProtocolSetting *	advanced_settings;
+	RemminaProtocolSSHSetting	ssh_setting;
+	const RemminaProtocolFeature *	features;
+
+	void (*init)(RemminaProtocolWidget *gp);
+	gboolean (*open_connection)(RemminaProtocolWidget *gp);
+	gboolean (*close_connection)(RemminaProtocolWidget *gp);
+	gboolean (*query_feature)(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature);
+	void (*call_feature)(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature);
+	void (*send_keystrokes)(RemminaProtocolWidget *gp, const guint keystrokes[], const gint keylen);
+	gboolean (*get_plugin_screenshot)(RemminaProtocolWidget *gp, RemminaPluginScreenshotData *rpsd);
+	gboolean (*map_event)(RemminaProtocolWidget *gp);
+	gboolean (*unmap_event)(RemminaProtocolWidget *gp);
+} RemminaProtocolPlugin;
+
+typedef struct _RemminaEntryPlugin {
+	RemminaPluginType	type;
+	const gchar *		name;
+	const gchar *		description;
+	const gchar *		domain;
+	const gchar *		version;
+
+	void (*entry_func)(struct _RemminaEntryPlugin* instance);
+} RemminaEntryPlugin;
+
+typedef struct _RemminaFilePlugin {
+	RemminaPluginType	type;
+	const gchar *		name;
+	const gchar *		description;
+	const gchar *		domain;
+	const gchar *		version;
+
+	gboolean (*import_test_func)(struct _RemminaFilePlugin* instance, const gchar *from_file);
+	RemminaFile * (*import_func)(struct _RemminaFilePlugin* instance, const gchar * from_file);
+	gboolean (*export_test_func)(struct _RemminaFilePlugin* instance, RemminaFile *file);
+	gboolean (*export_func)(struct _RemminaFilePlugin* instance, RemminaFile *file, const gchar *to_file);
+	const gchar *		export_hints;
+} RemminaFilePlugin;
+
+typedef struct _RemminaToolPlugin {
+	RemminaPluginType	type;
+	const gchar *		name;
+	const gchar *		description;
+	const gchar *		domain;
+	const gchar *		version;
+
+	void (*exec_func)(GtkMenuItem* item, struct _RemminaToolPlugin* instance);
+} RemminaToolPlugin;
+
+typedef struct _RemminaPrefPlugin {
+	RemminaPluginType	type;
+	const gchar *		name;
+	const gchar *		description;
+	const gchar *		domain;
+	const gchar *		version;
+
+	const gchar *		pref_label;
+	GtkWidget * (*get_pref_body)(struct _RemminaPrefPlugin* instance);
+} RemminaPrefPlugin;
+
+typedef struct _RemminaSecretPlugin {
+	RemminaPluginType	type;
+	const gchar *		name;
+	const gchar *		description;
+	const gchar *		domain;
+	const gchar *		version;
+	int			init_order;
+
+	gboolean (*init)(struct _RemminaSecretPlugin* instance);
+	gboolean (*is_service_available)(struct _RemminaSecretPlugin* instance);
+	void (*store_password)(struct _RemminaSecretPlugin* instance, RemminaFile *remminafile, const gchar *key, const gchar *password);
+	gchar * (*get_password)(struct _RemminaSecretPlugin* instance, RemminaFile * remminafile, const gchar *key);
+	void (*delete_password)(struct _RemminaSecretPlugin* instance, RemminaFile *remminafile, const gchar *key);
+} RemminaSecretPlugin;
+
+typedef struct _RemminaLanguageWrapperPlugin {
+	RemminaPluginType	type;
+	const gchar *		name;
+	const gchar *		description;
+	const gchar *		domain;
+	const gchar *		version;
+	const gchar **		supported_extentions;
+
+	gboolean (*init)(struct _RemminaLanguageWrapperPlugin* instance);
+	gboolean (*load)(struct _RemminaLanguageWrapperPlugin* instance, const gchar* plugin_file);
+} RemminaLanguageWrapperPlugin;
+
+/* Plugin Service is a struct containing a list of function pointers,
+ * which is passed from Remmina main program to the plugin module
+ * through the plugin entry function remmina_plugin_entry() */
+typedef struct _RemminaPluginService {
+	gboolean (*register_plugin)(RemminaPlugin *plugin);
+
+	gint (*protocol_plugin_get_width)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_set_width)(RemminaProtocolWidget *gp, gint width);
+	gint (*protocol_plugin_get_height)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_set_height)(RemminaProtocolWidget *gp, gint height);
+	RemminaScaleMode (*remmina_protocol_widget_get_current_scale_mode)(RemminaProtocolWidget *gp);
+	gboolean (*protocol_plugin_get_expand)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_set_expand)(RemminaProtocolWidget *gp, gboolean expand);
+	gboolean (*protocol_plugin_has_error)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_set_error)(RemminaProtocolWidget *gp, const gchar *fmt, ...);
+	gboolean (*protocol_plugin_is_closed)(RemminaProtocolWidget *gp);
+	RemminaFile * (*protocol_plugin_get_file)(RemminaProtocolWidget * gp);
+	void (*protocol_plugin_emit_signal)(RemminaProtocolWidget *gp, const gchar *signal_name);
+	void (*protocol_plugin_register_hostkey)(RemminaProtocolWidget *gp, GtkWidget *widget);
+	gchar *       (*protocol_plugin_start_direct_tunnel)(RemminaProtocolWidget * gp, gint default_port, gboolean port_plus);
+	gboolean (*protocol_plugin_start_reverse_tunnel)(RemminaProtocolWidget *gp, gint local_port);
+	gboolean (*protocol_plugin_start_xport_tunnel)(RemminaProtocolWidget *gp, RemminaXPortTunnelInitFunc init_func);
+	void (*protocol_plugin_set_display)(RemminaProtocolWidget *gp, gint display);
+	void (*protocol_plugin_signal_connection_closed)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_signal_connection_opened)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_update_align)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_lock_dynres)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_unlock_dynres)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_desktop_resize)(RemminaProtocolWidget *gp);
+	gint (*protocol_plugin_init_auth)(RemminaProtocolWidget *gp, RemminaMessagePanelFlags pflags, const gchar *title, const gchar *default_username, const gchar *default_password, const gchar *default_domain, const gchar *password_prompt);
+	gint (*protocol_plugin_init_certificate)(RemminaProtocolWidget *gp, const gchar *subject, const gchar *issuer, const gchar *fingerprint);
+	gint (*protocol_plugin_changed_certificate)(RemminaProtocolWidget *gp, const gchar *subject, const gchar *issuer, const gchar *new_fingerprint, const gchar *old_fingerprint);
+	gchar *       (*protocol_plugin_init_get_username)(RemminaProtocolWidget * gp);
+	gchar *       (*protocol_plugin_init_get_password)(RemminaProtocolWidget * gp);
+	gchar *       (*protocol_plugin_init_get_domain)(RemminaProtocolWidget * gp);
+	gboolean (*protocol_plugin_init_get_savepassword)(RemminaProtocolWidget *gp);
+	gint (*protocol_plugin_init_authx509)(RemminaProtocolWidget *gp);
+	gchar *       (*protocol_plugin_init_get_cacert)(RemminaProtocolWidget * gp);
+	gchar *       (*protocol_plugin_init_get_cacrl)(RemminaProtocolWidget * gp);
+	gchar *       (*protocol_plugin_init_get_clientcert)(RemminaProtocolWidget * gp);
+	gchar *       (*protocol_plugin_init_get_clientkey)(RemminaProtocolWidget * gp);
+	void (*protocol_plugin_init_save_cred)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_init_show_listen)(RemminaProtocolWidget *gp, gint port);
+	void (*protocol_plugin_init_show_retry)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_init_show)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_init_hide)(RemminaProtocolWidget *gp);
+	gboolean (*protocol_plugin_ssh_exec)(RemminaProtocolWidget *gp, gboolean wait, const gchar *fmt, ...);
+	void (*protocol_plugin_chat_open)(RemminaProtocolWidget *gp, const gchar *name, void (*on_send)(RemminaProtocolWidget *gp, const gchar *text), void (*on_destroy)(RemminaProtocolWidget *gp));
+	void (*protocol_plugin_chat_close)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_chat_receive)(RemminaProtocolWidget *gp, const gchar *text);
+	void (*protocol_plugin_send_keys_signals)(GtkWidget *widget, const guint *keyvals, int length, GdkEventType action);
+
+	gchar *       (*file_get_user_datadir)(void);
+
+	RemminaFile * (*file_new)(void);
+	const gchar * (*file_get_path)(RemminaFile * remminafile);
+	void (*file_set_string)(RemminaFile *remminafile, const gchar *setting, const gchar *value);
+	const gchar * (*file_get_string)(RemminaFile * remminafile, const gchar *setting);
+	gchar *       (*file_get_secret)(RemminaFile * remminafile, const gchar *setting);
+	void (*file_set_int)(RemminaFile *remminafile, const gchar *setting, gint value);
+	gint (*file_get_int)(RemminaFile *remminafile, const gchar *setting, gint default_value);
+	gdouble (*file_get_double)(RemminaFile *remminafile, const gchar *setting, gdouble default_value);
+	void (*file_unsave_passwords)(RemminaFile *remminafile);
+
+	void (*pref_set_value)(const gchar *key, const gchar *value);
+	gchar *       (*pref_get_value)(const gchar * key);
+	gint (*pref_get_scale_quality)(void);
+	gint (*pref_get_sshtunnel_port)(void);
+	gint (*pref_get_ssh_loglevel)(void);
+	gboolean (*pref_get_ssh_parseconfig)(void);
+	guint *(*pref_keymap_get_table)(const gchar *keymap);
+	guint (*pref_keymap_get_keyval)(const gchar *keymap, guint keyval);
+
+	void (*_remmina_info)(const gchar *fmt, ...);
+	void (*_remmina_message)(const gchar *fmt, ...);
+	void (*_remmina_debug)(const gchar *func, const gchar *fmt, ...);
+	void (*_remmina_warning)(const gchar *func, const gchar *fmt, ...);
+	void (*_remmina_audit)(const gchar *func, const gchar *fmt, ...);
+	void (*_remmina_error)(const gchar *func, const gchar *fmt, ...);
+	void (*_remmina_critical)(const gchar *func, const gchar *fmt, ...);
+	void (*log_print)(const gchar *text);
+	void (*log_printf)(const gchar *fmt, ...);
+
+	void (*ui_register)(GtkWidget *widget);
+
+	GtkWidget *   (*open_connection)(RemminaFile * remminafile, GCallback disconnect_cb, gpointer data, guint *handler);
+	gint (*open_unix_sock)(const char *unixsock);
+	void (*get_server_port)(const gchar *server, gint defaultport, gchar **host, gint *port);
+	gboolean (*is_main_thread)(void);
+	gboolean (*gtksocket_available)(void);
+	gint (*get_profile_remote_width)(RemminaProtocolWidget *gp);
+	gint (*get_profile_remote_height)(RemminaProtocolWidget *gp);
+	const gchar*(*protocol_widget_get_name)(RemminaProtocolWidget *gp);
+	gint(*protocol_widget_get_width)(RemminaProtocolWidget *gp);
+	gint(*protocol_widget_get_height)(RemminaProtocolWidget *gp);
+	void(*protocol_widget_set_width)(RemminaProtocolWidget *gp, gint width);
+	void(*protocol_widget_set_height)(RemminaProtocolWidget *gp, gint height);
+	RemminaScaleMode(*protocol_widget_get_current_scale_mode)(RemminaProtocolWidget *gp);
+	gboolean (*protocol_widget_get_expand)(RemminaProtocolWidget *gp);
+	void (*protocol_widget_set_expand)(RemminaProtocolWidget *gp, gboolean expand);
+	void (*protocol_widget_set_error)(RemminaProtocolWidget *gp, const gchar *fmt, ...);
+	gboolean (*protocol_widget_has_error)(RemminaProtocolWidget *gp);
+	GtkWidget *(*protocol_widget_gtkviewport)(RemminaProtocolWidget *gp);
+	gboolean (*protocol_widget_is_closed)(RemminaProtocolWidget *gp);
+	RemminaFile *(*protocol_widget_get_file)(RemminaProtocolWidget *gp);
+	gint (*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);
+	void (*protocol_widget_register_hostkey)(RemminaProtocolWidget *gp, GtkWidget *widget);
+	gchar *(*protocol_widget_start_direct_tunnel)(RemminaProtocolWidget *gp, gint default_port, gboolean port_plus);
+	gboolean (*protocol_widget_start_reverse_tunnel)(RemminaProtocolWidget *gp, gint local_port);
+	void (*protocol_widget_send_keys_signals)(GtkWidget *widget, const guint *keyvals, int keyvals_length, GdkEventType action);
+	void (*protocol_widget_chat_receive)(RemminaProtocolWidget *gp, const gchar *text);
+	void (*protocol_widget_panel_hide)(RemminaProtocolWidget *gp);
+	void (*protocol_widget_chat_open)(RemminaProtocolWidget *gp, const gchar *name,
+				       void (*on_send)(RemminaProtocolWidget *gp, const gchar *text), void (*on_destroy)(RemminaProtocolWidget *gp));
+	gboolean (*protocol_widget_ssh_exec)(RemminaProtocolWidget *gp, gboolean wait, const gchar *fmt, ...);
+	void (*protocol_widget_panel_show)(RemminaProtocolWidget *gp);
+	void (*protocol_widget_panel_show_retry)(RemminaProtocolWidget *gp);
+	gboolean (*protocol_widget_start_xport_tunnel)(RemminaProtocolWidget *gp, RemminaXPortTunnelInitFunc init_func);
+	void (*protocol_widget_set_display)(RemminaProtocolWidget *gp, gint display);
+	void (*protocol_widget_signal_connection_closed)(RemminaProtocolWidget *gp);
+	void (*protocol_widget_signal_connection_opened)(RemminaProtocolWidget *gp);
+	void (*protocol_widget_update_align)(RemminaProtocolWidget *gp);
+	void (*protocol_widget_unlock_dynres)(RemminaProtocolWidget *gp);
+	void (*protocol_widget_desktop_resize)(RemminaProtocolWidget *gp);
+	gint (*protocol_widget_panel_new_certificate)(RemminaProtocolWidget *gp, const gchar *subject, const gchar *issuer, const gchar *fingerprint);
+	gint (*protocol_widget_panel_changed_certificate)(RemminaProtocolWidget *gp, const gchar *subject, const gchar *issuer, const gchar *new_fingerprint, const gchar *old_fingerprint);
+	gchar *(*protocol_widget_get_username)(RemminaProtocolWidget *gp);
+	gchar *(*protocol_widget_get_password)(RemminaProtocolWidget *gp);
+	gchar *(*protocol_widget_get_domain)(RemminaProtocolWidget *gp);
+	gboolean (*protocol_widget_get_savepassword)(RemminaProtocolWidget *gp);
+	gint (*protocol_widget_panel_authx509)(RemminaProtocolWidget *gp);
+	gchar *(*protocol_widget_get_cacert)(RemminaProtocolWidget *gp);
+	gchar *(*protocol_widget_get_cacrl)(RemminaProtocolWidget *gp);
+	gchar *(*protocol_widget_get_clientcert)(RemminaProtocolWidget *gp);
+	gchar *(*protocol_widget_get_clientkey)(RemminaProtocolWidget *gp);
+	void (*protocol_widget_save_cred)(RemminaProtocolWidget *gp);
+	void (*protocol_widget_panel_show_listen)(RemminaProtocolWidget *gp, gint port);
+	void (*widget_pool_register)(GtkWidget *widget);
+	GtkWidget *(*rcw_open_from_file_full)(RemminaFile *remminafile, GCallback disconnect_cb, gpointer data, guint *handler);
+	void (*show_dialog)(GtkMessageType msg, GtkButtonsType buttons, const gchar* message);
+	GtkWindow *(*get_window)(void);
+	gint (*plugin_unlock_new)(GtkWindow* parent);
+} RemminaPluginService;
+
+/* "Prototype" of the plugin entry function */
+typedef gboolean (*RemminaPluginEntryFunc) (RemminaPluginService *service);
+
+G_END_DECLS
diff --git a/src/include/remmina/remmina_trace_calls.h b/src/include/remmina/remmina_trace_calls.h
new file mode 100644
index 0000000..1539927
--- /dev/null
+++ b/src/include/remmina/remmina_trace_calls.h
@@ -0,0 +1,51 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * 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.
+ *
+ */
+
+#pragma once
+
+#ifdef  WITH_TRACE_CALLS
+#include <gtk/gtk.h>
+
+#define TRACE_CALL(text) \
+	{ \
+		GDateTime *datetime = g_date_time_new_now_local(); \
+		gchar *sfmtdate = g_date_time_format(datetime, "%x %X"); \
+		g_print("%s Trace calls: %s\n", sfmtdate, text); \
+		g_free(sfmtdate); \
+		g_date_time_unref(datetime); \
+	}
+#else
+#define TRACE_CALL(text)
+#endif  /* _WITH_TRACE_CALLS_ */
diff --git a/src/include/remmina/types.h b/src/include/remmina/types.h
new file mode 100644
index 0000000..43d7ec2
--- /dev/null
+++ b/src/include/remmina/types.h
@@ -0,0 +1,164 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010 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.
+ *
+ */
+
+#pragma once
+
+#include <glib.h>
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+typedef struct _RemminaFile RemminaFile;
+
+typedef enum {
+	REMMINA_PROTOCOL_FEATURE_TYPE_END,
+	REMMINA_PROTOCOL_FEATURE_TYPE_PREF,
+	REMMINA_PROTOCOL_FEATURE_TYPE_TOOL,
+	REMMINA_PROTOCOL_FEATURE_TYPE_UNFOCUS,
+	REMMINA_PROTOCOL_FEATURE_TYPE_SCALE,
+	REMMINA_PROTOCOL_FEATURE_TYPE_DYNRESUPDATE,
+	REMMINA_PROTOCOL_FEATURE_TYPE_MULTIMON,
+	REMMINA_PROTOCOL_FEATURE_TYPE_GTKSOCKET
+} RemminaProtocolFeatureType;
+
+#define REMMINA_PROTOCOL_FEATURE_PREF_RADIO 1
+#define REMMINA_PROTOCOL_FEATURE_PREF_CHECK 2
+
+typedef enum
+{
+    REMMINA_TYPEHINT_STRING,
+    REMMINA_TYPEHINT_SIGNED,
+    REMMINA_TYPEHINT_UNSIGNED,
+    REMMINA_TYPEHINT_BOOLEAN,
+    REMMINA_TYPEHINT_CPOINTER,
+    REMMINA_TYPEHINT_RAW,
+    REMMINA_TYPEHINT_TUPLE,
+    REMMINA_TYPEHINT_UNDEFINED,
+} RemminaTypeHint;
+
+typedef struct _RemminaProtocolFeature {
+	RemminaProtocolFeatureType	type;
+	gint				id;
+	gpointer			opt1;
+	gpointer			opt2;
+	gpointer			opt3;
+    	RemminaTypeHint     		opt1_type_hint;
+    	RemminaTypeHint     		opt2_type_hint;
+    	RemminaTypeHint     		opt3_type_hint;
+} RemminaProtocolFeature;
+
+typedef struct _RemminaPluginScreenshotData {
+	unsigned char * buffer;
+	int		bitsPerPixel;
+	int		bytesPerPixel;
+	int		width;
+	int		height;
+} RemminaPluginScreenshotData;
+
+
+typedef struct _RemminaProtocolWidgetClass RemminaProtocolWidgetClass;
+typedef struct _RemminaProtocolWidget RemminaProtocolWidget;
+typedef gpointer RemminaTunnelInitFunc;
+typedef gboolean (*RemminaXPortTunnelInitFunc) (RemminaProtocolWidget *gp, gint remotedisplay, const gchar *server, gint port);
+
+typedef enum {
+	REMMINA_PROTOCOL_SETTING_TYPE_END,
+
+	REMMINA_PROTOCOL_SETTING_TYPE_SERVER,
+	REMMINA_PROTOCOL_SETTING_TYPE_PASSWORD,
+	REMMINA_PROTOCOL_SETTING_TYPE_RESOLUTION,
+	REMMINA_PROTOCOL_SETTING_TYPE_ASSISTANCE,
+	REMMINA_PROTOCOL_SETTING_TYPE_KEYMAP,
+
+	REMMINA_PROTOCOL_SETTING_TYPE_TEXT,
+	REMMINA_PROTOCOL_SETTING_TYPE_TEXTAREA,
+	REMMINA_PROTOCOL_SETTING_TYPE_SELECT,
+	REMMINA_PROTOCOL_SETTING_TYPE_COMBO,
+	REMMINA_PROTOCOL_SETTING_TYPE_CHECK,
+	REMMINA_PROTOCOL_SETTING_TYPE_FILE,
+	REMMINA_PROTOCOL_SETTING_TYPE_FOLDER,
+	REMMINA_PROTOCOL_SETTING_TYPE_INT,
+	REMMINA_PROTOCOL_SETTING_TYPE_DOUBLE
+} RemminaProtocolSettingType;
+
+typedef struct _RemminaProtocolSetting {
+	RemminaProtocolSettingType	type;
+	const gchar *			name;
+	const gchar *			label;
+	gboolean			compact;
+	gpointer			opt1;
+	gpointer			opt2;
+	gpointer			validator_data;
+	GCallback			validator;
+} RemminaProtocolSetting;
+
+typedef enum {
+	REMMINA_PROTOCOL_SSH_SETTING_NONE,
+	REMMINA_PROTOCOL_SSH_SETTING_TUNNEL,
+	REMMINA_PROTOCOL_SSH_SETTING_SSH,
+	REMMINA_PROTOCOL_SSH_SETTING_REVERSE_TUNNEL,
+	REMMINA_PROTOCOL_SSH_SETTING_SFTP
+} RemminaProtocolSSHSetting;
+
+typedef enum {
+	REMMINA_AUTHPWD_TYPE_PROTOCOL,
+	REMMINA_AUTHPWD_TYPE_SSH_PWD,
+	REMMINA_AUTHPWD_TYPE_SSH_PRIVKEY
+} RemminaAuthpwdType;
+
+typedef enum {
+	REMMINA_PROTOCOL_WIDGET_SCALE_MODE_NONE		= 0,
+	REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED	= 1,
+	REMMINA_PROTOCOL_WIDGET_SCALE_MODE_DYNRES	= 2
+} RemminaScaleMode;
+
+typedef enum {
+	RES_INVALID			= -1,
+	RES_USE_CUSTOM			= 0,
+	RES_USE_CLIENT			= 1,
+	RES_USE_INITIAL_WINDOW_SIZE	= 2
+} RemminaProtocolWidgetResolutionMode;
+
+/* pflags field for remmina_protocol_widget_panel_auth() */
+typedef enum {
+	REMMINA_MESSAGE_PANEL_FLAG_USERNAME	= 1,    /* require username in auth panel */
+	REMMINA_MESSAGE_PANEL_FLAG_USERNAME_READONLY	= 2,    /* Username, if required, is readonly */
+	REMMINA_MESSAGE_PANEL_FLAG_DOMAIN	= 4,    /* require domain in auth panel */
+	REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD = 8     /* require savepassword switch in auth panel */
+
+} RemminaMessagePanelFlags;
+
+G_END_DECLS
diff --git a/src/pygobject.h b/src/pygobject.h
new file mode 100644
index 0000000..145d1c6
--- /dev/null
+++ b/src/pygobject.h
@@ -0,0 +1,669 @@
+/* -*- Mode: C; c-basic-offset: 4 -*- */
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * 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.
+ *
+ */
+
+#ifndef _PYGOBJECT_H_
+#define _PYGOBJECT_H_
+
+#include <Python.h>
+
+#include <glib.h>
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+/* PyGClosure is a _private_ structure */
+typedef void (* PyClosureExceptionHandler) (GValue *ret, guint n_param_values, const GValue *params);
+typedef struct _PyGClosure PyGClosure;
+typedef struct _PyGObjectData PyGObjectData;
+
+struct _PyGClosure {
+    GClosure closure;
+    PyObject *callback;
+    PyObject *extra_args; /* tuple of extra args to pass to callback */
+    PyObject *swap_data; /* other object for gtk_signal_connect__object */
+    PyClosureExceptionHandler exception_handler;
+};
+
+typedef enum {
+    PYGOBJECT_USING_TOGGLE_REF = 1 << 0,
+    PYGOBJECT_IS_FLOATING_REF = 1 << 1
+} PyGObjectFlags;
+
+  /* closures is just an alias for what is found in the
+   * PyGObjectData */
+typedef struct {
+    PyObject_HEAD
+    GObject *obj;
+    PyObject *inst_dict; /* the instance dictionary -- must be last */
+    PyObject *weakreflist; /* list of weak references */
+
+      /*< private >*/
+      /* using union to preserve ABI compatibility (structure size
+       * must not change) */
+    union {
+        GSList *closures; /* stale field; no longer updated DO-NOT-USE! */
+        PyGObjectFlags flags;
+    } private_flags;
+
+} PyGObject;
+
+#define pygobject_get(v) (((PyGObject *)(v))->obj)
+#define pygobject_check(v,base) (PyObject_TypeCheck(v,base))
+
+typedef struct {
+    PyObject_HEAD
+    gpointer boxed;
+    GType gtype;
+    gboolean free_on_dealloc;
+} PyGBoxed;
+
+#define pyg_boxed_get(v,t)      ((t *)((PyGBoxed *)(v))->boxed)
+#define pyg_boxed_check(v,typecode) (PyObject_TypeCheck(v, &PyGBoxed_Type) && ((PyGBoxed *)(v))->gtype == typecode)
+
+typedef struct {
+    PyObject_HEAD
+    gpointer pointer;
+    GType gtype;
+} PyGPointer;
+
+#define pyg_pointer_get(v,t)      ((t *)((PyGPointer *)(v))->pointer)
+#define pyg_pointer_check(v,typecode) (PyObject_TypeCheck(v, &PyGPointer_Type) && ((PyGPointer *)(v))->gtype == typecode)
+
+typedef void (*PyGFatalExceptionFunc) (void);
+typedef void (*PyGThreadBlockFunc) (void);
+
+typedef struct {
+    PyObject_HEAD
+    GParamSpec *pspec;
+} PyGParamSpec;
+
+#define PyGParamSpec_Get(v) (((PyGParamSpec *)v)->pspec)
+#define PyGParamSpec_Check(v) (PyObject_TypeCheck(v, &PyGParamSpec_Type))
+
+typedef int (*PyGClassInitFunc) (gpointer gclass, PyTypeObject *pyclass);
+typedef PyTypeObject * (*PyGTypeRegistrationFunction) (const gchar *name,
+						       gpointer data);
+
+struct _PyGObject_Functions {
+    /*
+     * All field names in here are considered private,
+     * use the macros below instead, which provides stability
+     */
+    void (* register_class)(PyObject *dict, const gchar *class_name,
+			    GType gtype, PyTypeObject *type, PyObject *bases);
+    void (* register_wrapper)(PyObject *self);
+    PyTypeObject *(* lookup_class)(GType type);
+    PyObject *(* newgobj)(GObject *obj);
+
+    GClosure *(* closure_new)(PyObject *callback, PyObject *extra_args,
+			      PyObject *swap_data);
+    void      (* object_watch_closure)(PyObject *self, GClosure *closure);
+    GDestroyNotify destroy_notify;
+
+    GType (* type_from_object)(PyObject *obj);
+    PyObject *(* type_wrapper_new)(GType type);
+
+    gint (* enum_get_value)(GType enum_type, PyObject *obj, gint *val);
+    gint (* flags_get_value)(GType flag_type, PyObject *obj, gint *val);
+    void (* register_gtype_custom)(GType gtype,
+			    PyObject *(* from_func)(const GValue *value),
+			    int (* to_func)(GValue *value, PyObject *obj));
+    int (* value_from_pyobject)(GValue *value, PyObject *obj);
+    PyObject *(* value_as_pyobject)(const GValue *value, gboolean copy_boxed);
+
+    void (* register_interface)(PyObject *dict, const gchar *class_name,
+				GType gtype, PyTypeObject *type);
+
+    PyTypeObject *boxed_type;
+    void (* register_boxed)(PyObject *dict, const gchar *class_name,
+			    GType boxed_type, PyTypeObject *type);
+    PyObject *(* boxed_new)(GType boxed_type, gpointer boxed,
+			    gboolean copy_boxed, gboolean own_ref);
+
+    PyTypeObject *pointer_type;
+    void (* register_pointer)(PyObject *dict, const gchar *class_name,
+			      GType pointer_type, PyTypeObject *type);
+    PyObject *(* pointer_new)(GType boxed_type, gpointer pointer);
+
+    void (* enum_add_constants)(PyObject *module, GType enum_type,
+				const gchar *strip_prefix);
+    void (* flags_add_constants)(PyObject *module, GType flags_type,
+				 const gchar *strip_prefix);
+
+    const gchar *(* constant_strip_prefix)(const gchar *name,
+				     const gchar *strip_prefix);
+
+    gboolean (* error_check)(GError **error);
+
+    /* hooks to register handlers for getting GDK threads to cooperate
+     * with python threading */
+    void (* set_thread_block_funcs) (PyGThreadBlockFunc block_threads_func,
+				     PyGThreadBlockFunc unblock_threads_func);
+    PyGThreadBlockFunc block_threads;
+    PyGThreadBlockFunc unblock_threads;
+    PyTypeObject *paramspec_type;
+    PyObject *(* paramspec_new)(GParamSpec *spec);
+    GParamSpec *(*paramspec_get)(PyObject *tuple);
+    int (*pyobj_to_unichar_conv)(PyObject *pyobj, void* ptr);
+    gboolean (*parse_constructor_args)(GType        obj_type,
+                                       char       **arg_names,
+                                       char       **prop_names,
+                                       GParameter  *params,
+                                       guint       *nparams,
+                                       PyObject   **py_args);
+    PyObject *(* param_gvalue_as_pyobject) (const GValue* gvalue,
+                                            gboolean copy_boxed,
+					    const GParamSpec* pspec);
+    int (* gvalue_from_param_pyobject) (GValue* value,
+                                        PyObject* py_obj,
+					const GParamSpec* pspec);
+    PyTypeObject *enum_type;
+    PyObject *(*enum_add)(PyObject *module,
+			  const char *type_name_,
+			  const char *strip_prefix,
+			  GType gtype);
+    PyObject* (*enum_from_gtype)(GType gtype, int value);
+
+    PyTypeObject *flags_type;
+    PyObject *(*flags_add)(PyObject *module,
+			   const char *type_name_,
+			   const char *strip_prefix,
+			   GType gtype);
+    PyObject* (*flags_from_gtype)(GType gtype, int value);
+
+    gboolean threads_enabled;
+    int       (*enable_threads) (void);
+
+    int       (*gil_state_ensure) (void);
+    void      (*gil_state_release) (int flag);
+
+    void      (*register_class_init) (GType gtype, PyGClassInitFunc class_init);
+    void      (*register_interface_info) (GType gtype, const GInterfaceInfo *info);
+    void      (*closure_set_exception_handler) (GClosure *closure, PyClosureExceptionHandler handler);
+
+    void      (*add_warning_redirection) (const char *domain,
+                                          PyObject   *warning);
+    void      (*disable_warning_redirections) (void);
+    void      (*type_register_custom)(const gchar *type_name,
+				      PyGTypeRegistrationFunction callback,
+				      gpointer data);
+    gboolean  (*gerror_exception_check) (GError **error);
+    PyObject* (*option_group_new) (GOptionGroup *group);
+    GType (* type_from_object_strict) (PyObject *obj, gboolean strict);
+};
+
+#ifndef _INSIDE_PYGOBJECT_
+
+#if defined(NO_IMPORT) || defined(NO_IMPORT_PYGOBJECT)
+extern struct _PyGObject_Functions *_PyGObject_API;
+#else
+struct _PyGObject_Functions *_PyGObject_API;
+#endif
+
+#define pygobject_register_class    (_PyGObject_API->register_class)
+#define pygobject_register_wrapper  (_PyGObject_API->register_wrapper)
+#define pygobject_lookup_class      (_PyGObject_API->lookup_class)
+#define pygobject_new               (_PyGObject_API->newgobj)
+#define pyg_closure_new             (_PyGObject_API->closure_new)
+#define pygobject_watch_closure     (_PyGObject_API->object_watch_closure)
+#define pyg_closure_set_exception_handler (_PyGObject_API->closure_set_exception_handler)
+#define pyg_destroy_notify          (_PyGObject_API->destroy_notify)
+#define pyg_type_from_object_strict   (_PyGObject_API->type_from_object_strict)
+#define pyg_type_from_object        (_PyGObject_API->type_from_object)
+#define pyg_type_wrapper_new        (_PyGObject_API->type_wrapper_new)
+#define pyg_enum_get_value          (_PyGObject_API->enum_get_value)
+#define pyg_flags_get_value         (_PyGObject_API->flags_get_value)
+#define pyg_register_gtype_custom   (_PyGObject_API->register_gtype_custom)
+#define pyg_value_from_pyobject     (_PyGObject_API->value_from_pyobject)
+#define pyg_value_as_pyobject       (_PyGObject_API->value_as_pyobject)
+#define pyg_register_interface      (_PyGObject_API->register_interface)
+#define PyGBoxed_Type               (*_PyGObject_API->boxed_type)
+#define pyg_register_boxed          (_PyGObject_API->register_boxed)
+#define pyg_boxed_new               (_PyGObject_API->boxed_new)
+#define PyGPointer_Type             (*_PyGObject_API->pointer_type)
+#define pyg_register_pointer        (_PyGObject_API->register_pointer)
+#define pyg_pointer_new             (_PyGObject_API->pointer_new)
+#define pyg_enum_add_constants      (_PyGObject_API->enum_add_constants)
+#define pyg_flags_add_constants     (_PyGObject_API->flags_add_constants)
+#define pyg_constant_strip_prefix   (_PyGObject_API->constant_strip_prefix)
+#define pyg_error_check             (_PyGObject_API->error_check)
+#define pyg_set_thread_block_funcs  (_PyGObject_API->set_thread_block_funcs)
+#define PyGParamSpec_Type           (*_PyGObject_API->paramspec_type)
+#define pyg_param_spec_new          (_PyGObject_API->paramspec_new)
+#define pyg_param_spec_from_object  (_PyGObject_API->paramspec_get)
+#define pyg_pyobj_to_unichar_conv   (_PyGObject_API->pyobj_to_unichar_conv)
+#define pyg_parse_constructor_args  (_PyGObject_API->parse_constructor_args)
+#define pyg_param_gvalue_as_pyobject   (_PyGObject_API->value_as_pyobject)
+#define pyg_param_gvalue_from_pyobject (_PyGObject_API->gvalue_from_param_pyobject)
+#define PyGEnum_Type                (*_PyGObject_API->enum_type)
+#define pyg_enum_add                (_PyGObject_API->enum_add)
+#define pyg_enum_from_gtype         (_PyGObject_API->enum_from_gtype)
+#define PyGFlags_Type               (*_PyGObject_API->flags_type)
+#define pyg_flags_add               (_PyGObject_API->flags_add)
+#define pyg_flags_from_gtype        (_PyGObject_API->flags_from_gtype)
+#define pyg_enable_threads          (_PyGObject_API->enable_threads)
+#define pyg_gil_state_ensure        (_PyGObject_API->gil_state_ensure)
+#define pyg_gil_state_release       (_PyGObject_API->gil_state_release)
+#define pyg_register_class_init     (_PyGObject_API->register_class_init)
+#define pyg_register_interface_info (_PyGObject_API->register_interface_info)
+#define pyg_add_warning_redirection   (_PyGObject_API->add_warning_redirection)
+#define pyg_disable_warning_redirections (_PyGObject_API->disable_warning_redirections)
+#define pyg_type_register_custom_callback (_PyGObject_API->type_register_custom)
+#define pyg_gerror_exception_check (_PyGObject_API->gerror_exception_check)
+#define pyg_option_group_new       (_PyGObject_API->option_group_new)
+
+#define pyg_block_threads()   G_STMT_START {   \
+    if (_PyGObject_API->block_threads != NULL) \
+      (* _PyGObject_API->block_threads)();     \
+  } G_STMT_END
+#define pyg_unblock_threads() G_STMT_START {     \
+    if (_PyGObject_API->unblock_threads != NULL) \
+      (* _PyGObject_API->unblock_threads)();     \
+  } G_STMT_END
+
+#define pyg_threads_enabled (_PyGObject_API->threads_enabled)
+
+#define pyg_begin_allow_threads                 \
+    G_STMT_START {                              \
+        PyThreadState *_save = NULL;            \
+        if (_PyGObject_API->threads_enabled)    \
+            _save = PyEval_SaveThread();
+#define pyg_end_allow_threads                   \
+        if (_PyGObject_API->threads_enabled)    \
+            PyEval_RestoreThread(_save);        \
+    } G_STMT_END
+
+
+/**
+ * pygobject_init:
+ * @req_major: minimum version major number, or -1
+ * @req_minor: minimum version minor number, or -1
+ * @req_micro: minimum version micro number, or -1
+ *
+ * Imports and initializes the 'gobject' python module.  Can
+ * optionally check for a required minimum version if @req_major,
+ * @req_minor, and @req_micro are all different from -1.
+ *
+ * Returns: a new reference to the gobject module on success, NULL in
+ * case of failure (and raises ImportError).
+ **/
+static inline PyObject *
+pygobject_init(int req_major, int req_minor, int req_micro)
+{
+    PyObject *gobject, *cobject;
+
+    gobject = PyImport_ImportModule("gi._gobject");
+    if (!gobject) {
+        if (PyErr_Occurred())
+        {
+            PyObject *type, *value, *traceback;
+            PyObject *py_orig_exc;
+            PyErr_Fetch(&type, &value, &traceback);
+            py_orig_exc = PyObject_Repr(value);
+            Py_XDECREF(type);
+            Py_XDECREF(value);
+            Py_XDECREF(traceback);
+
+
+#if PY_VERSION_HEX < 0x03000000
+            PyErr_Format(PyExc_ImportError,
+                         "could not import gobject (error was: %s)",
+                         PyString_AsString(py_orig_exc));
+#else
+            {
+                /* Can not use PyErr_Format because it doesn't have
+                 * a format string for dealing with PyUnicode objects
+                 * like PyUnicode_FromFormat has
+                 */
+                PyObject *errmsg = PyUnicode_FromFormat("could not import gobject (error was: %U)",
+                                                        py_orig_exc);
+
+                if (errmsg) {
+                   PyErr_SetObject(PyExc_ImportError,
+                                   errmsg);
+                   Py_DECREF(errmsg);
+                }
+                /* if errmsg is NULL then we might have OOM
+                 * PyErr should already be set and trying to
+                 * return our own error would be futile
+                 */
+            }
+#endif
+            Py_DECREF(py_orig_exc);
+        } else {
+            PyErr_SetString(PyExc_ImportError,
+                            "could not import gobject (no error given)");
+        }
+        return NULL;
+    }
+
+    cobject = PyObject_GetAttrString(gobject, "_PyGObject_API");
+#if PY_VERSION_HEX >= 0x03000000
+    if (cobject && PyCapsule_CheckExact(cobject))
+        _PyGObject_API = (struct _PyGObject_Functions *) PyCapsule_GetPointer(cobject, "gobject._PyGObject_API");
+
+#else
+    if (cobject && PyCObject_Check(cobject))
+        _PyGObject_API = (struct _PyGObject_Functions *) PyCObject_AsVoidPtr(cobject);
+#endif
+    else {
+        PyErr_SetString(PyExc_ImportError,
+                        "could not import gobject (could not find _PyGObject_API object)");
+        Py_DECREF(gobject);
+        return NULL;
+    }
+
+    if (req_major != -1)
+    {
+        int found_major, found_minor, found_micro;
+        PyObject *version;
+
+        version = PyObject_GetAttrString(gobject, "pygobject_version");
+        if (!version) {
+            PyErr_SetString(PyExc_ImportError,
+                            "could not import gobject (version too old)");
+            Py_DECREF(gobject);
+            return NULL;
+        }
+        if (!PyArg_ParseTuple(version, "iii",
+                              &found_major, &found_minor, &found_micro)) {
+            PyErr_SetString(PyExc_ImportError,
+                            "could not import gobject (version has invalid format)");
+            Py_DECREF(version);
+            Py_DECREF(gobject);
+            return NULL;
+        }
+        Py_DECREF(version);
+        if (req_major != found_major ||
+            req_minor >  found_minor ||
+            (req_minor == found_minor && req_micro > found_micro)) {
+            PyErr_Format(PyExc_ImportError,
+                         "could not import gobject (version mismatch, %d.%d.%d is required, "
+                         "found %d.%d.%d)", req_major, req_minor, req_micro,
+                         found_major, found_minor, found_micro);
+            Py_DECREF(gobject);
+            return NULL;
+        }
+    }
+    return gobject;
+}
+
+/**
+ * PYLIST_FROMGLIBLIST:
+ * @type: the type of the GLib list e.g. #GList or #GSList
+ * @prefix: the prefix of functions that manipulate a list of the type
+ * given by type.
+ *
+ * A macro that creates a type specific code block which converts a GLib
+ * list (#GSList or #GList) to a Python list. The first two args of the macro
+ * are used to specify the type and list function prefix so that the type
+ * specific macros can be generated.
+ *
+ * The rest of the args are for the standard args for the type specific
+ * macro(s) created from this macro.
+ */
+ #define PYLIST_FROMGLIBLIST(type,prefix,py_list,list,item_convert_func,\
+                            list_free,list_item_free)  \
+G_STMT_START \
+{ \
+    gint i, len; \
+    PyObject *item; \
+    void (*glib_list_free)(type*) = list_free; \
+    GFunc glib_list_item_free = (GFunc)list_item_free;  \
+ \
+    len = prefix##_length(list); \
+    py_list = PyList_New(len); \
+    for (i = 0; i < len; i++) { \
+        gpointer list_item = prefix##_nth_data(list, i); \
+ \
+        item = item_convert_func; \
+        PyList_SetItem(py_list, i, item); \
+    } \
+    if (glib_list_item_free != NULL) \
+        prefix##_foreach(list, glib_list_item_free, NULL); \
+    if (glib_list_free != NULL) \
+        glib_list_free(list); \
+} G_STMT_END
+
+/**
+ * PYLIST_FROMGLIST:
+ * @py_list: the name of the Python list
+ *
+ * @list: the #GList to be converted to a Python list
+ *
+ * @item_convert_func: the function that converts a list item to a Python
+ * object. The function must refer to the list item using "@list_item" and
+ * must return a #PyObject* object. An example conversion function is:
+ * [[
+ * PyString_FromString(list_item)
+ * ]]
+ * A more elaborate function is:
+ * [[
+ * pyg_boxed_new(GTK_TYPE_RECENT_INFO, list_item, TRUE, TRUE)
+ * ]]
+ * @list_free: the name of a function that takes a single arg (the list) and
+ * frees its memory. Can be NULL if the list should not be freed. An example
+ * is:
+ * [[
+ * g_list_free
+ * ]]
+ * @list_item_free: the name of a #GFunc function that frees the memory used
+ * by the items in the list or %NULL if the list items do not have to be
+ * freed. A simple example is:
+ * [[
+ * g_free
+ * ]]
+ *
+ * A macro that adds code that converts a #GList to a Python list.
+ *
+ */
+#define PYLIST_FROMGLIST(py_list,list,item_convert_func,list_free,\
+                         list_item_free) \
+        PYLIST_FROMGLIBLIST(GList,g_list,py_list,list,item_convert_func,\
+                            list_free,list_item_free)
+
+/**
+ * PYLIST_FROMGSLIST:
+ * @py_list: the name of the Python list
+ *
+ * @list: the #GSList to be converted to a Python list
+ *
+ * @item_convert_func: the function that converts a list item to a Python
+ * object. The function must refer to the list item using "@list_item" and
+ * must return a #PyObject* object. An example conversion function is:
+ * [[
+ * PyString_FromString(list_item)
+ * ]]
+ * A more elaborate function is:
+ * [[
+ * pyg_boxed_new(GTK_TYPE_RECENT_INFO, list_item, TRUE, TRUE)
+ * ]]
+ * @list_free: the name of a function that takes a single arg (the list) and
+ * frees its memory. Can be %NULL if the list should not be freed. An example
+ * is:
+ * [[
+ * g_list_free
+ * ]]
+ * @list_item_free: the name of a #GFunc function that frees the memory used
+ * by the items in the list or %NULL if the list items do not have to be
+ * freed. A simple example is:
+ * [[
+ * g_free
+ * ]]
+ *
+ * A macro that adds code that converts a #GSList to a Python list.
+ *
+ */
+#define PYLIST_FROMGSLIST(py_list,list,item_convert_func,list_free,\
+                          list_item_free) \
+        PYLIST_FROMGLIBLIST(GSList,g_slist,py_list,list,item_convert_func,\
+                            list_free,list_item_free)
+
+/**
+ * PYLIST_ASGLIBLIST
+ * @type: the type of the GLib list e.g. GList or GSList
+ * @prefix: the prefix of functions that manipulate a list of the type
+ * given by type e.g. g_list or g_slist
+ *
+ * A macro that creates a type specific code block to be used to convert a
+ * Python list to a GLib list (GList or GSList). The first two args of the
+ * macro are used to specify the type and list function prefix so that the
+ * type specific macros can be generated.
+ *
+ * The rest of the args are for the standard args for the type specific
+ * macro(s) created from this macro.
+ */
+#define PYLIST_ASGLIBLIST(type,prefix,py_list,list,check_func,\
+                           convert_func,child_free_func,errormsg,errorreturn) \
+G_STMT_START \
+{ \
+    Py_ssize_t i, n_list; \
+    GFunc glib_child_free_func = (GFunc)child_free_func;        \
+ \
+    if (!(py_list = PySequence_Fast(py_list, ""))) { \
+        errormsg; \
+        return errorreturn; \
+    } \
+    n_list = PySequence_Fast_GET_SIZE(py_list); \
+    for (i = 0; i < n_list; i++) { \
+        PyObject *py_item = PySequence_Fast_GET_ITEM(py_list, i); \
+ \
+        if (!check_func) { \
+            if (glib_child_free_func) \
+                    prefix##_foreach(list, glib_child_free_func, NULL); \
+            prefix##_free(list); \
+            Py_DECREF(py_list); \
+            errormsg; \
+            return errorreturn; \
+        } \
+        list = prefix##_prepend(list, convert_func); \
+    }; \
+        Py_DECREF(py_list); \
+        list =  prefix##_reverse(list); \
+} \
+G_STMT_END
+/**
+ * PYLIST_ASGLIST
+ * @py_list: the Python list to be converted
+ * @list: the #GList list to be converted
+ * @check_func: the expression that takes a #PyObject* arg (must be named
+ * @py_item) and returns an int value indicating if the Python object matches
+ * the required list item type (0 - %False or 1 - %True). An example is:
+ * [[
+ * (PyString_Check(py_item)||PyUnicode_Check(py_item))
+ * ]]
+ * @convert_func: the function that takes a #PyObject* arg (must be named
+ * py_item) and returns a pointer to the converted list object. An example
+ * is:
+ * [[
+ * pygobject_get(py_item)
+ * ]]
+ * @child_free_func: the name of a #GFunc function that frees a GLib list
+ * item or %NULL if the list item does not have to be freed. This function is
+ * used to help free the items in a partially created list if there is an
+ * error. An example is:
+ * [[
+ * g_free
+ * ]]
+ * @errormsg: a function that sets up a Python error message. An example is:
+ * [[
+ * PyErr_SetString(PyExc_TypeError, "strings must be a sequence of" "strings
+ * or unicode objects")
+ * ]]
+ * @errorreturn: the value to return if an error occurs, e.g.:
+ * [[
+ * %NULL
+ * ]]
+ *
+ * A macro that creates code that converts a Python list to a #GList. The
+ * returned list must be freed using the appropriate list free function when
+ * it's no longer needed. If an error occurs the child_free_func is used to
+ * release the memory used by the list items and then the list memory is
+ * freed.
+ */
+#define PYLIST_ASGLIST(py_list,list,check_func,convert_func,child_free_func,\
+                       errormsg,errorreturn) \
+        PYLIST_ASGLIBLIST(GList,g_list,py_list,list,check_func,convert_func,\
+                          child_free_func,errormsg,errorreturn)
+
+/**
+ * PYLIST_ASGSLIST
+ * @py_list: the Python list to be converted
+ * @list: the #GSList list to be converted
+ * @check_func: the expression that takes a #PyObject* arg (must be named
+ * @py_item) and returns an int value indicating if the Python object matches
+ * the required list item type (0 - %False or 1 - %True). An example is:
+ * [[
+ * (PyString_Check(py_item)||PyUnicode_Check(py_item))
+ * ]]
+ * @convert_func: the function that takes a #PyObject* arg (must be named
+ * py_item) and returns a pointer to the converted list object. An example
+ * is:
+ * [[
+ * pygobject_get(py_item)
+ * ]]
+ * @child_free_func: the name of a #GFunc function that frees a GLib list
+ * item or %NULL if the list item does not have to be freed. This function is
+ * used to help free the items in a partially created list if there is an
+ * error. An example is:
+ * [[
+ * g_free
+ * ]]
+ * @errormsg: a function that sets up a Python error message. An example is:
+ * [[
+ * PyErr_SetString(PyExc_TypeError, "strings must be a sequence of" "strings
+ * or unicode objects")
+ * ]]
+ * @errorreturn: the value to return if an error occurs, e.g.:
+ * [[
+ * %NULL
+ * ]]
+ *
+ * A macro that creates code that converts a Python list to a #GSList. The
+ * returned list must be freed using the appropriate list free function when
+ * it's no longer needed. If an error occurs the child_free_func is used to
+ * release the memory used by the list items and then the list memory is
+ * freed.
+ */
+#define PYLIST_ASGSLIST(py_list,list,check_func,convert_func,child_free_func,\
+                        errormsg,errorreturn) \
+        PYLIST_ASGLIBLIST(GSList,g_slist,py_list,list,check_func,convert_func,\
+                          child_free_func,errormsg,errorreturn)
+
+#endif /* !_INSIDE_PYGOBJECT_ */
+
+G_END_DECLS
+
+#endif /* !_PYGOBJECT_H_ */
diff --git a/src/rcw.c b/src/rcw.c
new file mode 100644
index 0000000..8d00965
--- /dev/null
+++ b/src/rcw.c
@@ -0,0 +1,4812 @@
+/*
+ * 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"
+
+#ifdef GDK_WINDOWING_X11
+#include <cairo/cairo-xlib.h>
+#else
+#include <cairo/cairo.h>
+#endif
+#include <gdk/gdk.h>
+#include <gdk/gdkkeysyms.h>
+#include <glib/gi18n.h>
+#include <stdlib.h>
+
+#include "remmina.h"
+#include "remmina_main.h"
+#include "rcw.h"
+#include "remmina_applet_menu_item.h"
+#include "remmina_applet_menu.h"
+#include "remmina_file.h"
+#include "remmina_file_manager.h"
+#include "remmina_log.h"
+#include "remmina_message_panel.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_scrolled_viewport.h"
+#include "remmina_unlock.h"
+#include "remmina_utils.h"
+#include "remmina_widget_pool.h"
+#include "remmina/remmina_trace_calls.h"
+
+#ifdef GDK_WINDOWING_WAYLAND
+#include <gdk/gdkwayland.h>
+#endif
+
+
+#define DEBUG_KB_GRABBING 0
+#include "remmina_exec.h"
+
+gchar *remmina_pref_file;
+RemminaPref remmina_pref;
+
+G_DEFINE_TYPE(RemminaConnectionWindow, rcw, GTK_TYPE_WINDOW)
+
+#define MOTION_TIME 100
+
+/* default timeout used to hide the floating toolbar when switching profile */
+#define TB_HIDE_TIME_TIME 1500
+
+#define FULL_SCREEN_TARGET_MONITOR_UNDEFINED -1
+
+struct _RemminaConnectionWindowPriv {
+	GtkNotebook *					notebook;
+	GtkWidget *					floating_toolbar_widget;
+	GtkWidget *					overlay;
+	GtkWidget *					revealer;
+	GtkWidget *					overlay_ftb_overlay;
+	GtkWidget *					overlay_ftb_fr;
+
+	GtkWidget *					floating_toolbar_label;
+	gdouble						floating_toolbar_opacity;
+
+	/* Various delayed and timer event source ids */
+	guint						acs_eventsourceid;              // timeout
+	guint						spf_eventsourceid;              // idle
+	guint						grab_retry_eventsourceid;       // timeout
+	guint						delayed_grab_eventsourceid;
+	guint						ftb_hide_eventsource;           // timeout
+	guint						tar_eventsource;                // timeout
+	guint						hidetb_eventsource;             // timeout
+	guint						dwp_eventsourceid;              // timeout
+
+	GtkWidget *					toolbar;
+	GtkWidget *					grid;
+
+	/* Toolitems that need to be handled */
+	GtkToolItem *					toolitem_menu;
+	GtkToolItem *					toolitem_autofit;
+	GtkToolItem *					toolitem_fullscreen;
+	GtkToolItem *					toolitem_switch_page;
+	GtkToolItem *					toolitem_dynres;
+	GtkToolItem *					toolitem_scale;
+	GtkToolItem *					toolitem_grab;
+	GtkToolItem *					toolitem_multimon;
+	GtkToolItem *					toolitem_preferences;
+	GtkToolItem *					toolitem_tools;
+	GtkToolItem *					toolitem_new;
+	GtkToolItem *					toolitem_duplicate;
+	GtkToolItem *					toolitem_screenshot;
+	GtkWidget *					fullscreen_option_button;
+	GtkWidget *					fullscreen_scaler_button;
+	GtkWidget *					scaler_option_button;
+
+	GtkWidget *					pin_button;
+	gboolean					pin_down;
+
+	gboolean					sticky;
+
+	/* Flag to turn off toolbar signal handling when toolbar is
+	 * reconfiguring, usually due to a tab switch */
+	gboolean					toolbar_is_reconfiguring;
+
+	/* This is the current view mode, i.e. VIEWPORT_FULLSCREEN_MODE,
+	 * as saved on the "viwemode" profile preference file */
+	gint						view_mode;
+
+	/* Status variables used when in fullscreen mode. Needed
+	 * to restore a fullscreen mode after coming from scrolled */
+	gint						fss_view_mode;
+	/* Status variables used when in scrolled window mode. Needed
+	 * to restore a scrolled window mode after coming from fullscreen */
+	gint						ss_width, ss_height;
+	gboolean					ss_maximized;
+
+	gboolean					kbcaptured;
+	gboolean					pointer_captured;
+	gboolean					hostkey_activated;
+	gboolean					hostkey_used;
+
+	gboolean					pointer_entered;
+
+	RemminaConnectionWindowOnDeleteConfirmMode	on_delete_confirm_mode;
+};
+
+typedef struct _RemminaConnectionObject {
+	RemminaConnectionWindow *	cnnwin;
+	RemminaFile *			remmina_file;
+
+	GtkWidget *			proto;
+	GtkWidget *			aspectframe;
+	GtkWidget *			viewport;
+
+	GtkWidget *			scrolled_container;
+
+	gboolean			plugin_can_scale;
+
+	gboolean			connected;
+	gboolean			dynres_unlocked;
+
+	gulong				deferred_open_size_allocate_handler;
+} RemminaConnectionObject;
+
+enum {
+	TOOLBARPLACE_SIGNAL,
+	LAST_SIGNAL
+};
+
+static guint rcw_signals[LAST_SIGNAL] =
+{ 0 };
+
+static RemminaConnectionWindow *rcw_create_scrolled(gint width, gint height, gboolean maximize);
+static RemminaConnectionWindow *rcw_create_fullscreen(GtkWindow *old, gint view_mode);
+static gboolean rcw_hostkey_func(RemminaProtocolWidget *gp, guint keyval, gboolean release);
+static GtkWidget *rco_create_tab_page(RemminaConnectionObject *cnnobj);
+static GtkWidget *rco_create_tab_label(RemminaConnectionObject *cnnobj);
+
+void rcw_grab_focus(RemminaConnectionWindow *cnnwin);
+static GtkWidget *rcw_create_toolbar(RemminaConnectionWindow *cnnwin, gint mode);
+static void rcw_place_toolbar(GtkToolbar *toolbar, GtkGrid *grid, GtkWidget *sibling, int toolbar_placement);
+static void rco_update_toolbar(RemminaConnectionObject *cnnobj);
+static void rcw_keyboard_grab(RemminaConnectionWindow *cnnwin);
+static GtkWidget *rcw_append_new_page(RemminaConnectionWindow *cnnwin, RemminaConnectionObject *cnnobj);
+
+
+static void rcw_ftb_drag_begin(GtkWidget *widget, GdkDragContext *context, gpointer user_data);
+
+static const GtkTargetEntry dnd_targets_ftb[] =
+{
+	{
+		(char *)"text/x-remmina-ftb",
+		GTK_TARGET_SAME_APP | GTK_TARGET_OTHER_WIDGET,
+		0
+	},
+};
+
+static const GtkTargetEntry dnd_targets_tb[] =
+{
+	{
+		(char *)"text/x-remmina-tb",
+		GTK_TARGET_SAME_APP,
+		0
+	},
+};
+
+static void rcw_class_init(RemminaConnectionWindowClass *klass)
+{
+	TRACE_CALL(__func__);
+	GtkCssProvider *provider;
+
+	provider = gtk_css_provider_new();
+
+	/* It’s important to remove padding, border and shadow from GtkViewport or
+	 * we will never know its internal area size, because GtkViweport::viewport_get_view_allocation,
+	 * which returns the internal size of the GtkViewport, is private and we cannot access it */
+
+#if GTK_CHECK_VERSION(3, 14, 0)
+	gtk_css_provider_load_from_data(provider,
+					"#remmina-cw-viewport, #remmina-cw-aspectframe {\n"
+					"  padding:0;\n"
+					"  border:0;\n"
+					"  background-color: black;\n"
+					"}\n"
+					"GtkDrawingArea {\n"
+					"}\n"
+					"GtkToolbar {\n"
+					"  -GtkWidget-window-dragging: 0;\n"
+					"}\n"
+					"#remmina-connection-window-fullscreen {\n"
+					"  border-color: black;\n"
+					"}\n"
+					"#remmina-small-button {\n"
+					"  outline-offset: 0;\n"
+					"  outline-width: 0;\n"
+					"  padding: 0;\n"
+					"  border: 0;\n"
+					"}\n"
+					"#remmina-pin-button {\n"
+					"  outline-offset: 0;\n"
+					"  outline-width: 0;\n"
+					"  padding: 2px;\n"
+					"  border: 0;\n"
+					"}\n"
+					"#remmina-tab-page {\n"
+					"  background-color: black;\n"
+					"}\n"
+					"#remmina-scrolled-container {\n"
+					"}\n"
+					"#remmina-scrolled-container.undershoot {\n"
+					"  background: none;\n"
+					"}\n"
+					"#remmina-tab-page {\n"
+					"}\n"
+					"#ftbbox-upper {\n"
+					"  background-color: white;\n"
+					"  color: black;\n"
+					"  border-style: none solid solid solid;\n"
+					"  border-width: 1px;\n"
+					"  border-radius: 4px;\n"
+					"  padding: 0px;\n"
+					"}\n"
+					"#ftbbox-lower {\n"
+					"  background-color: white;\n"
+					"  color: black;\n"
+					"  border-style: solid solid none solid;\n"
+					"  border-width: 1px;\n"
+					"  border-radius: 4px;\n"
+					"  padding: 0px;\n"
+					"}\n"
+					"#ftb-handle {\n"
+					"}\n"
+					".message_panel {\n"
+					"  border: 0px solid;\n"
+					"  padding: 20px 20px 20px 20px;\n"
+					"}\n"
+					".message_panel entry {\n"
+					"  background-image: none;\n"
+					"  border-width: 4px;\n"
+					"  border-radius: 8px;\n"
+					"}\n"
+					".message_panel .title_label {\n"
+					"  font-size: 2em; \n"
+					"}\n"
+					, -1, NULL);
+
+#else
+	gtk_css_provider_load_from_data(provider,
+					"#remmina-cw-viewport, #remmina-cw-aspectframe {\n"
+					"  padding:0;\n"
+					"  border:0;\n"
+					"  background-color: black;\n"
+					"}\n"
+					"#remmina-cw-message-panel {\n"
+					"}\n"
+					"GtkDrawingArea {\n"
+					"}\n"
+					"GtkToolbar {\n"
+					"  -GtkWidget-window-dragging: 0;\n"
+					"}\n"
+					"#remmina-connection-window-fullscreen {\n"
+					"  border-color: black;\n"
+					"}\n"
+					"#remmina-small-button {\n"
+					"  -GtkWidget-focus-padding: 0;\n"
+					"  -GtkWidget-focus-line-width: 0;\n"
+					"  padding: 0;\n"
+					"  border: 0;\n"
+					"}\n"
+					"#remmina-pin-button {\n"
+					"  -GtkWidget-focus-padding: 0;\n"
+					"  -GtkWidget-focus-line-width: 0;\n"
+					"  padding: 2px;\n"
+					"  border: 0;\n"
+					"}\n"
+					"#remmina-scrolled-container {\n"
+					"}\n"
+					"#remmina-scrolled-container.undershoot {\n"
+					"  background: none\n"
+					"}\n"
+					"#remmina-tab-page {\n"
+					"}\n"
+					"#ftbbox-upper {\n"
+					"  border-style: none solid solid solid;\n"
+					"  border-width: 1px;\n"
+					"  border-radius: 4px;\n"
+					"  padding: 0px;\n"
+					"}\n"
+					"#ftbbox-lower {\n"
+					"  border-style: solid solid none solid;\n"
+					"  border-width: 1px;\n"
+					"  border-radius: 4px;\n"
+					"  padding: 0px;\n"
+					"}\n"
+					"#ftb-handle {\n"
+					"}\n"
+
+					, -1, NULL);
+#endif
+
+	gtk_style_context_add_provider_for_screen(gdk_screen_get_default(),
+						  GTK_STYLE_PROVIDER(provider),
+						  GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+
+	g_object_unref(provider);
+
+	/* Define a signal used to notify all rcws of toolbar move */
+	rcw_signals[TOOLBARPLACE_SIGNAL] = g_signal_new("toolbar-place", G_TYPE_FROM_CLASS(klass),
+							G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaConnectionWindowClass, toolbar_place), NULL, NULL,
+							g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+}
+
+static RemminaConnectionObject *rcw_get_cnnobj_at_page(RemminaConnectionWindow *cnnwin, gint npage)
+{
+	GtkWidget *po;
+
+	if (!cnnwin->priv->notebook)
+		return NULL;
+	po = gtk_notebook_get_nth_page(GTK_NOTEBOOK(cnnwin->priv->notebook), npage);
+	return g_object_get_data(G_OBJECT(po), "cnnobj");
+}
+
+static RemminaConnectionObject *rcw_get_visible_cnnobj(RemminaConnectionWindow *cnnwin)
+{
+	gint np;
+
+	if (cnnwin != NULL && cnnwin->priv != NULL && cnnwin->priv->notebook != NULL) {
+		np = gtk_notebook_get_current_page(GTK_NOTEBOOK(cnnwin->priv->notebook));
+		if (np < 0)
+			return NULL;
+		return rcw_get_cnnobj_at_page(cnnwin, np);
+	} else {
+		return NULL;
+	}
+}
+
+static RemminaScaleMode get_current_allowed_scale_mode(RemminaConnectionObject *cnnobj, gboolean *dynres_avail, gboolean *scale_avail)
+{
+	TRACE_CALL(__func__);
+	RemminaScaleMode scalemode;
+	gboolean plugin_has_dynres, plugin_can_scale;
+
+	scalemode = remmina_protocol_widget_get_current_scale_mode(REMMINA_PROTOCOL_WIDGET(cnnobj->proto));
+
+	plugin_has_dynres = remmina_protocol_widget_query_feature_by_type(REMMINA_PROTOCOL_WIDGET(cnnobj->proto),
+									  REMMINA_PROTOCOL_FEATURE_TYPE_DYNRESUPDATE);
+
+	plugin_can_scale = remmina_protocol_widget_query_feature_by_type(REMMINA_PROTOCOL_WIDGET(cnnobj->proto),
+									 REMMINA_PROTOCOL_FEATURE_TYPE_SCALE);
+
+	/* Forbid scalemode REMMINA_PROTOCOL_WIDGET_SCALE_MODE_DYNRES when not possible */
+	if ((!plugin_has_dynres) && scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_DYNRES)
+		scalemode = REMMINA_PROTOCOL_WIDGET_SCALE_MODE_NONE;
+
+	/* Forbid scalemode REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED when not possible */
+	if (!plugin_can_scale && scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED)
+		scalemode = REMMINA_PROTOCOL_WIDGET_SCALE_MODE_NONE;
+
+	if (scale_avail)
+		*scale_avail = plugin_can_scale;
+	if (dynres_avail)
+		*dynres_avail = (plugin_has_dynres && cnnobj->dynres_unlocked);
+
+	return scalemode;
+}
+
+static void rco_disconnect_current_page(RemminaConnectionObject *cnnobj)
+{
+	TRACE_CALL(__func__);
+
+	/* Disconnects the connection which is currently in view in the notebook */
+	remmina_protocol_widget_close_connection(REMMINA_PROTOCOL_WIDGET(cnnobj->proto));
+}
+
+static void rcw_kp_ungrab(RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	GdkDisplay *display;
+
+#if GTK_CHECK_VERSION(3, 20, 0)
+	GdkSeat *seat;
+#else
+	GdkDeviceManager *manager;
+	GdkDevice *keyboard = NULL;
+#endif
+
+	if (cnnwin->priv->grab_retry_eventsourceid) {
+		g_source_remove(cnnwin->priv->grab_retry_eventsourceid);
+		cnnwin->priv->grab_retry_eventsourceid = 0;
+	}
+	if (cnnwin->priv->delayed_grab_eventsourceid) {
+		g_source_remove(cnnwin->priv->delayed_grab_eventsourceid);
+		cnnwin->priv->delayed_grab_eventsourceid = 0;
+	}
+
+	display = gtk_widget_get_display(GTK_WIDGET(cnnwin));
+#if GTK_CHECK_VERSION(3, 20, 0)
+	seat = gdk_display_get_default_seat(display);
+	// keyboard = gdk_seat_get_pointer(seat);
+#else
+	manager = gdk_display_get_device_manager(display);
+	keyboard = gdk_device_manager_get_client_pointer(manager);
+#endif
+
+	if (!cnnwin->priv->kbcaptured && !cnnwin->priv->pointer_captured)
+		return;
+
+#if DEBUG_KB_GRABBING
+	printf("DEBUG_KB_GRABBING: --- ungrabbing\n");
+#endif
+
+
+
+#if GTK_CHECK_VERSION(3, 20, 0)
+	/* We can use gtk_seat_grab()/_ungrab() only after GTK 3.24 */
+	gdk_seat_ungrab(seat);
+#else
+	if (keyboard != NULL) {
+		if (gdk_device_get_source(keyboard) != GDK_SOURCE_KEYBOARD)
+			keyboard = gdk_device_get_associated_device(keyboard);
+		G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+		gdk_device_ungrab(keyboard, GDK_CURRENT_TIME);
+		G_GNUC_END_IGNORE_DEPRECATIONS
+	}
+#endif
+	cnnwin->priv->kbcaptured = FALSE;
+	cnnwin->priv->pointer_captured = FALSE;
+}
+
+static gboolean rcw_keyboard_grab_retry(gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindow *cnnwin = (RemminaConnectionWindow *)user_data;
+
+#if DEBUG_KB_GRABBING
+	printf("%s retry grab\n", __func__);
+#endif
+	rcw_keyboard_grab(cnnwin);
+	cnnwin->priv->grab_retry_eventsourceid = 0;
+	return G_SOURCE_REMOVE;
+}
+
+static void rcw_pointer_ungrab(RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+#if GTK_CHECK_VERSION(3, 20, 0)
+	GdkSeat *seat;
+	GdkDisplay *display;
+	if (!cnnwin->priv->pointer_captured)
+		return;
+
+	display = gtk_widget_get_display(GTK_WIDGET(cnnwin));
+	seat = gdk_display_get_default_seat(display);
+	gdk_seat_ungrab(seat);
+#endif
+}
+
+static void rcw_pointer_grab(RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	/* This function in Wayland is useless and generates a spurious leave-notify event.
+	 * Should we remove it ? https://gitlab.gnome.org/GNOME/mutter/-/issues/2450#note_1588081 */
+#if GTK_CHECK_VERSION(3, 20, 0)
+	GdkSeat *seat;
+	GdkDisplay *display;
+	GdkGrabStatus ggs;
+
+
+	if (cnnwin->priv->pointer_captured) {
+#if DEBUG_KB_GRABBING
+		printf("DEBUG_KB_GRABBING: pointer_captured is true, it should not\n");
+#endif
+		return;
+	}
+
+	display = gtk_widget_get_display(GTK_WIDGET(cnnwin));
+	seat = gdk_display_get_default_seat(display);
+	ggs = gdk_seat_grab(seat, gtk_widget_get_window(GTK_WIDGET(cnnwin)),
+			    GDK_SEAT_CAPABILITY_ALL_POINTING, TRUE, NULL, NULL, NULL, NULL);
+	if (ggs != GDK_GRAB_SUCCESS) {
+#if DEBUG_KB_GRABBING
+		printf("DEBUG_KB_GRABBING: GRAB of POINTER failed. GdkGrabStatus: %d\n", (int)ggs);
+#endif
+	} else {
+		cnnwin->priv->pointer_captured = TRUE;
+	}
+
+#endif
+}
+
+static void rcw_keyboard_grab(RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	GdkDisplay *display;
+
+#if GTK_CHECK_VERSION(3, 20, 0)
+	GdkSeat *seat;
+#else
+	GdkDeviceManager *manager;
+#endif
+	GdkGrabStatus ggs;
+	GdkDevice *keyboard = NULL;
+
+	if (cnnwin->priv->kbcaptured) {
+#if DEBUG_KB_GRABBING
+		printf("DEBUG_KB_GRABBING: %s not grabbing because already grabbed.\n", __func__);
+#endif
+		return;
+	}
+
+	display = gtk_widget_get_display(GTK_WIDGET(cnnwin));
+#if GTK_CHECK_VERSION(3, 20, 0)
+	seat = gdk_display_get_default_seat(display);
+	keyboard = gdk_seat_get_pointer(seat);
+#else
+	manager = gdk_display_get_device_manager(display);
+	keyboard = gdk_device_manager_get_client_pointer(manager);
+#endif
+
+	if (keyboard != NULL) {
+		if (gdk_device_get_source(keyboard) != GDK_SOURCE_KEYBOARD)
+			keyboard = gdk_device_get_associated_device(keyboard);
+
+
+#if DEBUG_KB_GRABBING
+		printf("DEBUG_KB_GRABBING: profile asks for grabbing, let’s try.\n");
+#endif
+		/* Up to GTK version 3.20 we can grab the keyboard with gdk_device_grab().
+		 * in GTK 3.20 gdk_seat_grab() should be used instead of gdk_device_grab().
+		 * There is a bug in GTK up to 3.22: When gdk_device_grab() fails
+		 * the widget is hidden:
+		 * https://gitlab.gnome.org/GNOME/gtk/commit/726ad5a5ae7c4f167e8dd454cd7c250821c400ab
+		 * The bugfix will be released with GTK 3.24.
+		 * Also please note that the newer gdk_seat_grab() is still calling gdk_device_grab().
+		 *
+		 * Warning: gdk_seat_grab() will call XGrabKeyboard() or XIGrabDevice()
+		 * which in turn will generate a core X input event FocusOut and FocusIn
+		 * but not Xinput2 events.
+		 * In some cases, GTK is unable to neutralize FocusIn and FocusOut core
+		 * events (ie: i3wm+Plasma with GDK_CORE_DEVICE_EVENTS=1 because detail=NotifyNonlinear
+		 * instead of detail=NotifyAncestor/detail=NotifyInferior)
+		 * Receiving a FocusOut event for Remmina at this time will cause an infinite loop.
+		 * Therefore is important for GTK to use Xinput2 instead of core X events
+		 * by unsetting GDK_CORE_DEVICE_EVENTS
+		 */
+#if GTK_CHECK_VERSION(3, 20, 0)
+		ggs = gdk_seat_grab(seat, gtk_widget_get_window(GTK_WIDGET(cnnwin)),
+				    GDK_SEAT_CAPABILITY_KEYBOARD, TRUE, NULL, NULL, NULL, NULL);
+#else
+		ggs = gdk_device_grab(keyboard, gtk_widget_get_window(GTK_WIDGET(cnnwin)), GDK_OWNERSHIP_WINDOW,
+				      TRUE, GDK_KEY_PRESS | GDK_KEY_RELEASE, NULL, GDK_CURRENT_TIME);
+#endif
+		if (ggs != GDK_GRAB_SUCCESS) {
+#if DEBUG_KB_GRABBING
+			printf("GRAB of keyboard failed.\n");
+#endif
+			/* Reschedule grabbing in half a second if not already done */
+			if (cnnwin->priv->grab_retry_eventsourceid == 0)
+				cnnwin->priv->grab_retry_eventsourceid = g_timeout_add(500, (GSourceFunc)rcw_keyboard_grab_retry, cnnwin);
+		} else {
+#if DEBUG_KB_GRABBING
+			printf("Keyboard grabbed\n");
+#endif
+			if (cnnwin->priv->grab_retry_eventsourceid != 0) {
+				g_source_remove(cnnwin->priv->grab_retry_eventsourceid);
+				cnnwin->priv->grab_retry_eventsourceid = 0;
+			}
+			cnnwin->priv->kbcaptured = TRUE;
+		}
+	} else {
+		rcw_kp_ungrab(cnnwin);
+	}
+}
+
+static void rcw_close_all_connections(RemminaConnectionWindow *cnnwin)
+{
+	RemminaConnectionWindowPriv *priv = cnnwin->priv;
+	GtkNotebook *notebook = GTK_NOTEBOOK(priv->notebook);
+	GtkWidget *w;
+	RemminaConnectionObject *cnnobj;
+	gint i, n;
+
+	if (GTK_IS_WIDGET(notebook)) {
+		n = gtk_notebook_get_n_pages(notebook);
+		for (i = n - 1; i >= 0; i--) {
+			w = gtk_notebook_get_nth_page(notebook, i);
+			cnnobj = (RemminaConnectionObject *)g_object_get_data(G_OBJECT(w), "cnnobj");
+			/* Do close the connection on this tab */
+			remmina_protocol_widget_close_connection(REMMINA_PROTOCOL_WIDGET(cnnobj->proto));
+		}
+	}
+}
+
+gboolean rcw_delete(RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv = cnnwin->priv;
+	GtkNotebook *notebook = GTK_NOTEBOOK(priv->notebook);
+	GtkWidget *dialog;
+	gint i, n, nopen;
+
+	if (!REMMINA_IS_CONNECTION_WINDOW(cnnwin))
+		return TRUE;
+
+	if (cnnwin->priv->on_delete_confirm_mode != RCW_ONDELETE_NOCONFIRM) {
+		n = gtk_notebook_get_n_pages(notebook);
+		nopen = 0;
+		/* count all non-closed connections */
+		for(i = 0; i < n; i ++) {
+			RemminaConnectionObject *cnnobj = rcw_get_cnnobj_at_page(cnnwin, i);
+			if (!remmina_protocol_widget_is_closed((RemminaProtocolWidget *)cnnobj->proto))
+				nopen ++;
+		}
+		if (nopen > 1) {
+			dialog = gtk_message_dialog_new(GTK_WINDOW(cnnwin), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION,
+							GTK_BUTTONS_YES_NO,
+							_("Are you sure you want to close %i active connections in the current window?"), nopen);
+			i = gtk_dialog_run(GTK_DIALOG(dialog));
+			gtk_widget_destroy(dialog);
+			if (i != GTK_RESPONSE_YES)
+				return FALSE;
+		}
+		else if (nopen == 1) {
+			if (remmina_pref.confirm_close) {
+				dialog = gtk_message_dialog_new(GTK_WINDOW(cnnwin), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION,
+								GTK_BUTTONS_YES_NO,
+								_("Are you sure you want to close this last active connection?"));
+				i = gtk_dialog_run(GTK_DIALOG(dialog));
+				gtk_widget_destroy(dialog);
+				if (i != GTK_RESPONSE_YES)
+					return FALSE;
+			}
+		}
+	}
+	rcw_close_all_connections(cnnwin);
+
+	return TRUE;
+}
+
+static gboolean rcw_delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
+{
+	TRACE_CALL(__func__);
+	rcw_delete(RCW(widget));
+	return TRUE;
+}
+
+static void rcw_destroy(GtkWidget *widget, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv;
+	RemminaConnectionWindow *cnnwin;
+
+	if (!REMMINA_IS_CONNECTION_WINDOW(widget))
+		return;
+
+	cnnwin = (RemminaConnectionWindow *)widget;
+	priv = cnnwin->priv;
+
+	if (priv->kbcaptured)
+		rcw_kp_ungrab(cnnwin);
+
+	if (priv->acs_eventsourceid) {
+		g_source_remove(priv->acs_eventsourceid);
+		priv->acs_eventsourceid = 0;
+	}
+	if (priv->spf_eventsourceid) {
+		g_source_remove(priv->spf_eventsourceid);
+		priv->spf_eventsourceid = 0;
+	}
+	if (priv->grab_retry_eventsourceid) {
+		g_source_remove(priv->grab_retry_eventsourceid);
+		priv->grab_retry_eventsourceid = 0;
+	}
+	if (cnnwin->priv->delayed_grab_eventsourceid) {
+		g_source_remove(cnnwin->priv->delayed_grab_eventsourceid);
+		cnnwin->priv->delayed_grab_eventsourceid = 0;
+	}
+	if (priv->ftb_hide_eventsource) {
+		g_source_remove(priv->ftb_hide_eventsource);
+		priv->ftb_hide_eventsource = 0;
+	}
+	if (priv->tar_eventsource) {
+		g_source_remove(priv->tar_eventsource);
+		priv->tar_eventsource = 0;
+	}
+	if (priv->hidetb_eventsource) {
+		g_source_remove(priv->hidetb_eventsource);
+		priv->hidetb_eventsource = 0;
+	}
+	if (priv->dwp_eventsourceid) {
+		g_source_remove(priv->dwp_eventsourceid);
+		priv->dwp_eventsourceid = 0;
+	}
+
+	/* There is no need to destroy priv->floating_toolbar_widget,
+	 * because it’s our child and will be destroyed automatically */
+
+	cnnwin->priv = NULL;
+	g_free(priv);
+}
+
+gboolean rcw_notify_widget_toolbar_placement(GtkWidget *widget, gpointer data)
+{
+	TRACE_CALL(__func__);
+	GType rcwtype;
+
+	rcwtype = rcw_get_type();
+	if (G_TYPE_CHECK_INSTANCE_TYPE(widget, rcwtype)) {
+		g_signal_emit_by_name(G_OBJECT(widget), "toolbar-place");
+		return TRUE;
+	}
+	return FALSE;
+}
+
+static gboolean rcw_tb_drag_failed(GtkWidget *widget, GdkDragContext *context,
+				   GtkDragResult result, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv;
+	RemminaConnectionWindow *cnnwin;
+
+
+	cnnwin = (RemminaConnectionWindow *)user_data;
+	priv = cnnwin->priv;
+
+	if (priv->toolbar)
+		gtk_widget_show(GTK_WIDGET(priv->toolbar));
+
+	return TRUE;
+}
+
+static gboolean rcw_tb_drag_drop(GtkWidget *widget, GdkDragContext *context,
+				 gint x, gint y, guint time, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	GtkAllocation wa;
+	gint new_toolbar_placement;
+	RemminaConnectionWindowPriv *priv;
+	RemminaConnectionWindow *cnnwin;
+
+	cnnwin = (RemminaConnectionWindow *)user_data;
+	priv = cnnwin->priv;
+
+	gtk_widget_get_allocation(widget, &wa);
+
+	if (wa.width * y >= wa.height * x) {
+		if (wa.width * y > wa.height * (wa.width - x))
+			new_toolbar_placement = TOOLBAR_PLACEMENT_BOTTOM;
+		else
+			new_toolbar_placement = TOOLBAR_PLACEMENT_LEFT;
+	} else {
+		if (wa.width * y > wa.height * (wa.width - x))
+			new_toolbar_placement = TOOLBAR_PLACEMENT_RIGHT;
+		else
+			new_toolbar_placement = TOOLBAR_PLACEMENT_TOP;
+	}
+
+	gtk_drag_finish(context, TRUE, TRUE, time);
+
+	if (new_toolbar_placement != remmina_pref.toolbar_placement) {
+		/* Save new position */
+		remmina_pref.toolbar_placement = new_toolbar_placement;
+		remmina_pref_save();
+
+		/* Signal all windows that the toolbar must be moved */
+		remmina_widget_pool_foreach(rcw_notify_widget_toolbar_placement, NULL);
+	}
+	if (priv->toolbar)
+		gtk_widget_show(GTK_WIDGET(priv->toolbar));
+
+	return TRUE;
+}
+
+static void rcw_tb_drag_begin(GtkWidget *widget, GdkDragContext *context, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+
+	cairo_surface_t *surface;
+	cairo_t *cr;
+	GtkAllocation wa;
+	double dashes[] = { 10 };
+
+	gtk_widget_get_allocation(widget, &wa);
+
+	surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 16, 16);
+	cr = cairo_create(surface);
+	cairo_set_source_rgb(cr, 0.6, 0.6, 0.6);
+	cairo_set_line_width(cr, 4);
+	cairo_set_dash(cr, dashes, 1, 0);
+	cairo_rectangle(cr, 0, 0, 16, 16);
+	cairo_stroke(cr);
+	cairo_destroy(cr);
+
+	gtk_widget_hide(widget);
+
+	gtk_drag_set_icon_surface(context, surface);
+}
+
+void rcw_update_toolbar_opacity(RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv = cnnwin->priv;
+	RemminaConnectionObject *cnnobj;
+
+	cnnobj = rcw_get_visible_cnnobj(cnnwin);
+	if (!cnnobj) return;
+
+	priv->floating_toolbar_opacity = (1.0 - TOOLBAR_OPACITY_MIN) / ((gdouble)TOOLBAR_OPACITY_LEVEL)
+					 * ((gdouble)(TOOLBAR_OPACITY_LEVEL - remmina_file_get_int(cnnobj->remmina_file, "toolbar_opacity", 0)))
+					 + TOOLBAR_OPACITY_MIN;
+	if (priv->floating_toolbar_widget)
+		gtk_widget_set_opacity(GTK_WIDGET(priv->overlay_ftb_overlay), priv->floating_toolbar_opacity);
+}
+
+static gboolean rcw_floating_toolbar_make_invisible(gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv = (RemminaConnectionWindowPriv *)data;
+
+	gtk_widget_set_opacity(GTK_WIDGET(priv->overlay_ftb_overlay), 0.0);
+	priv->ftb_hide_eventsource = 0;
+	return G_SOURCE_REMOVE;
+}
+
+static void rcw_floating_toolbar_show(RemminaConnectionWindow *cnnwin, gboolean show)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv = cnnwin->priv;
+
+	if (priv->floating_toolbar_widget == NULL)
+		return;
+
+	if (show || priv->pin_down) {
+		/* Make the FTB no longer transparent, in case we have an hidden toolbar */
+		rcw_update_toolbar_opacity(cnnwin);
+		/* Remove outstanding hide events, if not yet active */
+		if (priv->ftb_hide_eventsource) {
+			g_source_remove(priv->ftb_hide_eventsource);
+			priv->ftb_hide_eventsource = 0;
+		}
+	} else {
+		/* If we are hiding and the toolbar must be made invisible, schedule
+		 * a later toolbar hide */
+		if (remmina_pref.fullscreen_toolbar_visibility == FLOATING_TOOLBAR_VISIBILITY_INVISIBLE)
+			if (priv->ftb_hide_eventsource == 0)
+				priv->ftb_hide_eventsource = g_timeout_add(1000, rcw_floating_toolbar_make_invisible, priv);
+	}
+
+	gtk_revealer_set_reveal_child(GTK_REVEALER(priv->revealer), show || priv->pin_down);
+}
+
+static void rco_get_desktop_size(RemminaConnectionObject *cnnobj, gint *width, gint *height)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = REMMINA_PROTOCOL_WIDGET(cnnobj->proto);
+
+
+	*width = remmina_protocol_widget_get_width(gp);
+	*height = remmina_protocol_widget_get_height(gp);
+	if (*width == 0) {
+		/* Before connecting we do not have real remote width/height,
+		 * so we ask profile values */
+		*width = remmina_protocol_widget_get_profile_remote_width(gp);
+		*height = remmina_protocol_widget_get_profile_remote_height(gp);
+	}
+}
+
+void rco_set_scrolled_policy(RemminaScaleMode scalemode, GtkScrolledWindow *scrolled_window)
+{
+	TRACE_CALL(__func__);
+
+	gtk_scrolled_window_set_policy(scrolled_window,
+				       scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED ? GTK_POLICY_NEVER : GTK_POLICY_AUTOMATIC,
+				       scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED ? GTK_POLICY_NEVER : GTK_POLICY_AUTOMATIC);
+}
+
+static GtkWidget *rco_create_scrolled_container(RemminaScaleMode scalemode, int view_mode)
+{
+	GtkWidget *scrolled_container;
+
+	if (view_mode == VIEWPORT_FULLSCREEN_MODE) {
+		scrolled_container = remmina_scrolled_viewport_new();
+	} else {
+		scrolled_container = gtk_scrolled_window_new(NULL, NULL);
+		rco_set_scrolled_policy(scalemode, GTK_SCROLLED_WINDOW(scrolled_container));
+		gtk_container_set_border_width(GTK_CONTAINER(scrolled_container), 0);
+		gtk_widget_set_can_focus(scrolled_container, FALSE);
+	}
+
+	gtk_widget_set_name(scrolled_container, "remmina-scrolled-container");
+	gtk_widget_show(scrolled_container);
+
+	return scrolled_container;
+}
+
+gboolean rcw_toolbar_autofit_restore(RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+
+	RemminaConnectionWindowPriv *priv = cnnwin->priv;
+	RemminaConnectionObject *cnnobj;
+	gint dwidth, dheight;
+	GtkAllocation nba, ca, ta;
+
+	cnnwin->priv->tar_eventsource = 0;
+
+	if (priv->toolbar_is_reconfiguring)
+		return G_SOURCE_REMOVE;
+
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return FALSE;
+
+	if (cnnobj->connected && GTK_IS_SCROLLED_WINDOW(cnnobj->scrolled_container)) {
+		rco_get_desktop_size(cnnobj, &dwidth, &dheight);
+		gtk_widget_get_allocation(GTK_WIDGET(priv->notebook), &nba);
+		gtk_widget_get_allocation(cnnobj->scrolled_container, &ca);
+		gtk_widget_get_allocation(priv->toolbar, &ta);
+		if (remmina_pref.toolbar_placement == TOOLBAR_PLACEMENT_LEFT ||
+		    remmina_pref.toolbar_placement == TOOLBAR_PLACEMENT_RIGHT)
+			gtk_window_resize(GTK_WINDOW(cnnobj->cnnwin), MAX(1, dwidth + ta.width + nba.width - ca.width),
+					  MAX(1, dheight + nba.height - ca.height));
+		else
+			gtk_window_resize(GTK_WINDOW(cnnobj->cnnwin), MAX(1, dwidth + nba.width - ca.width),
+					  MAX(1, dheight + ta.height + nba.height - ca.height));
+		gtk_container_check_resize(GTK_CONTAINER(cnnobj->cnnwin));
+	}
+	if (GTK_IS_SCROLLED_WINDOW(cnnobj->scrolled_container)) {
+		RemminaScaleMode scalemode = get_current_allowed_scale_mode(cnnobj, NULL, NULL);
+		rco_set_scrolled_policy(scalemode, GTK_SCROLLED_WINDOW(cnnobj->scrolled_container));
+	}
+
+	return G_SOURCE_REMOVE;
+}
+
+static void rcw_toolbar_autofit(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj;
+
+	if (cnnwin->priv->toolbar_is_reconfiguring)
+		return;
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+
+	if (GTK_IS_SCROLLED_WINDOW(cnnobj->scrolled_container)) {
+		if ((gdk_window_get_state(gtk_widget_get_window(GTK_WIDGET(cnnwin))) & GDK_WINDOW_STATE_MAXIMIZED) != 0)
+			gtk_window_unmaximize(GTK_WINDOW(cnnwin));
+
+		/* It’s tricky to make the toolbars disappear automatically, while keeping scrollable.
+		 * Please tell me if you know a better way to do this */
+		gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(cnnobj->scrolled_container), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
+
+		cnnwin->priv->tar_eventsource = g_timeout_add(200, (GSourceFunc)rcw_toolbar_autofit_restore, cnnwin);
+	}
+}
+
+void rco_get_monitor_geometry(RemminaConnectionObject *cnnobj, GdkRectangle *sz)
+{
+	TRACE_CALL(__func__);
+
+	/* Fill sz with the monitor (or workarea) size and position
+	 * of the monitor (or workarea) where cnnobj->cnnwin is located */
+
+	GdkRectangle monitor_geometry;
+
+	sz->x = sz->y = sz->width = sz->height = 0;
+
+	if (!cnnobj)
+		return;
+	if (!cnnobj->cnnwin)
+		return;
+	if (!gtk_widget_is_visible(GTK_WIDGET(cnnobj->cnnwin)))
+		return;
+
+#if GTK_CHECK_VERSION(3, 22, 0)
+	GdkDisplay *display;
+	GdkMonitor *monitor;
+	display = gtk_widget_get_display(GTK_WIDGET(cnnobj->cnnwin));
+	monitor = gdk_display_get_monitor_at_window(display, gtk_widget_get_window(GTK_WIDGET(cnnobj->cnnwin)));
+#else
+	GdkScreen *screen;
+	gint monitor;
+	screen = gtk_window_get_screen(GTK_WINDOW(cnnobj->cnnwin));
+	monitor = gdk_screen_get_monitor_at_window(screen, gtk_widget_get_window(GTK_WIDGET(cnnobj->cnnwin)));
+#endif
+
+#if GTK_CHECK_VERSION(3, 22, 0)
+	gdk_monitor_get_workarea(monitor, &monitor_geometry);
+	/* Under Wayland, GTK 3.22, all values returned by gdk_monitor_get_geometry()
+	 * and gdk_monitor_get_workarea() seem to have been divided by the
+	 * gdk scale factor, so we need to adjust the returned rect
+	 * undoing the division */
+#ifdef GDK_WINDOWING_WAYLAND
+	if (GDK_IS_WAYLAND_DISPLAY(display)) {
+		int monitor_scale_factor = gdk_monitor_get_scale_factor(monitor);
+		monitor_geometry.width *= monitor_scale_factor;
+		monitor_geometry.height *= monitor_scale_factor;
+	}
+#endif
+#elif gdk_screen_get_monitor_workarea
+	gdk_screen_get_monitor_workarea(screen, monitor, &monitor_geometry);
+#else
+	gdk_screen_get_monitor_geometry(screen, monitor, &monitor_geometry);
+#endif
+	*sz = monitor_geometry;
+}
+
+static void rco_check_resize(RemminaConnectionObject *cnnobj)
+{
+	TRACE_CALL(__func__);
+	gboolean scroll_required = FALSE;
+
+	GdkRectangle monitor_geometry;
+	gint rd_width, rd_height;
+	gint bordersz;
+	gint scalemode;
+
+	scalemode = remmina_protocol_widget_get_current_scale_mode(REMMINA_PROTOCOL_WIDGET(cnnobj->proto));
+
+	/* Get remote destkop size */
+	rco_get_desktop_size(cnnobj, &rd_width, &rd_height);
+
+	/* Get our monitor size */
+	rco_get_monitor_geometry(cnnobj, &monitor_geometry);
+
+	if (!remmina_protocol_widget_get_expand(REMMINA_PROTOCOL_WIDGET(cnnobj->proto)) &&
+	    (monitor_geometry.width < rd_width || monitor_geometry.height < rd_height) &&
+	    scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_NONE)
+		scroll_required = TRUE;
+
+	switch (cnnobj->cnnwin->priv->view_mode) {
+	case SCROLLED_FULLSCREEN_MODE:
+		gtk_window_resize(GTK_WINDOW(cnnobj->cnnwin), monitor_geometry.width, monitor_geometry.height);
+		gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(cnnobj->scrolled_container),
+					       (scroll_required ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER),
+					       (scroll_required ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER));
+		break;
+
+	case VIEWPORT_FULLSCREEN_MODE:
+		bordersz = scroll_required ? SCROLL_BORDER_SIZE : 0;
+		gtk_window_resize(GTK_WINDOW(cnnobj->cnnwin), monitor_geometry.width, monitor_geometry.height);
+		if (REMMINA_IS_SCROLLED_VIEWPORT(cnnobj->scrolled_container))
+			/* Put a border around Notebook content (RemminaScrolledViewpord), so we can
+			 * move the mouse over the border to scroll */
+			gtk_container_set_border_width(GTK_CONTAINER(cnnobj->scrolled_container), bordersz);
+
+		break;
+
+	case SCROLLED_WINDOW_MODE:
+		if (remmina_file_get_int(cnnobj->remmina_file, "viewmode", UNDEFINED_MODE) == UNDEFINED_MODE) {
+			/* ToDo: is this really needed ? When ? */
+			gtk_window_set_default_size(GTK_WINDOW(cnnobj->cnnwin),
+						    MIN(rd_width, monitor_geometry.width), MIN(rd_height, monitor_geometry.height));
+			if (rd_width >= monitor_geometry.width || rd_height >= monitor_geometry.height) {
+				gtk_window_maximize(GTK_WINDOW(cnnobj->cnnwin));
+				remmina_file_set_int(cnnobj->remmina_file, "window_maximize", TRUE);
+			} else {
+				rcw_toolbar_autofit(NULL, cnnobj->cnnwin);
+				remmina_file_set_int(cnnobj->remmina_file, "window_maximize", FALSE);
+			}
+		} else {
+			if (remmina_file_get_int(cnnobj->remmina_file, "window_maximize", FALSE))
+				gtk_window_maximize(GTK_WINDOW(cnnobj->cnnwin));
+		}
+		break;
+
+	default:
+		break;
+	}
+}
+
+static void rcw_set_tooltip(GtkWidget *item, const gchar *tip, guint key1, guint key2)
+{
+	TRACE_CALL(__func__);
+	gchar *s1;
+	gchar *s2;
+
+	if (remmina_pref.hostkey && key1) {
+		if (key2)
+			s1 = g_strdup_printf(" (%s + %s,%s)", gdk_keyval_name(remmina_pref.hostkey),
+					     gdk_keyval_name(gdk_keyval_to_upper(key1)), gdk_keyval_name(gdk_keyval_to_upper(key2)));
+		else if (key1 == remmina_pref.hostkey)
+			s1 = g_strdup_printf(" (%s)", gdk_keyval_name(remmina_pref.hostkey));
+		else
+			s1 = g_strdup_printf(" (%s + %s)", gdk_keyval_name(remmina_pref.hostkey),
+					     gdk_keyval_name(gdk_keyval_to_upper(key1)));
+	} else {
+		s1 = NULL;
+	}
+	s2 = g_strdup_printf("%s%s", tip, s1 ? s1 : "");
+	gtk_widget_set_tooltip_text(item, s2);
+	g_free(s2);
+	g_free(s1);
+}
+
+static void remmina_protocol_widget_update_alignment(RemminaConnectionObject *cnnobj)
+{
+	TRACE_CALL(__func__);
+	RemminaScaleMode scalemode;
+	gboolean scaledexpandedmode;
+	int rdwidth, rdheight;
+	gfloat aratio;
+
+	if (!cnnobj->plugin_can_scale) {
+		/* If we have a plugin that cannot scale,
+		 * (i.e. SFTP plugin), then we expand proto */
+		gtk_widget_set_halign(GTK_WIDGET(cnnobj->proto), GTK_ALIGN_FILL);
+		gtk_widget_set_valign(GTK_WIDGET(cnnobj->proto), GTK_ALIGN_FILL);
+	} else {
+		/* Plugin can scale */
+
+		scalemode = get_current_allowed_scale_mode(cnnobj, NULL, NULL);
+		scaledexpandedmode = remmina_protocol_widget_get_expand(REMMINA_PROTOCOL_WIDGET(cnnobj->proto));
+
+		/* Check if we need aspectframe and create/destroy it accordingly */
+		if (scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED && !scaledexpandedmode) {
+			/* We need an aspectframe as a parent of proto */
+			rdwidth = remmina_protocol_widget_get_width(REMMINA_PROTOCOL_WIDGET(cnnobj->proto));
+			rdheight = remmina_protocol_widget_get_height(REMMINA_PROTOCOL_WIDGET(cnnobj->proto));
+			aratio = (gfloat)rdwidth / (gfloat)rdheight;
+			if (!cnnobj->aspectframe) {
+				/* We need a new aspectframe */
+				cnnobj->aspectframe = gtk_aspect_frame_new(NULL, 0.5, 0.5, aratio, FALSE);
+				gtk_widget_set_name(cnnobj->aspectframe, "remmina-cw-aspectframe");
+				gtk_frame_set_shadow_type(GTK_FRAME(cnnobj->aspectframe), GTK_SHADOW_NONE);
+				g_object_ref(cnnobj->proto);
+				gtk_container_remove(GTK_CONTAINER(cnnobj->viewport), cnnobj->proto);
+				gtk_container_add(GTK_CONTAINER(cnnobj->viewport), cnnobj->aspectframe);
+				gtk_container_add(GTK_CONTAINER(cnnobj->aspectframe), cnnobj->proto);
+				g_object_unref(cnnobj->proto);
+				gtk_widget_show(cnnobj->aspectframe);
+				if (cnnobj != NULL && cnnobj->cnnwin != NULL && cnnobj->cnnwin->priv->notebook != NULL)
+					rcw_grab_focus(cnnobj->cnnwin);
+			} else {
+				gtk_aspect_frame_set(GTK_ASPECT_FRAME(cnnobj->aspectframe), 0.5, 0.5, aratio, FALSE);
+			}
+		} else {
+			/* We do not need an aspectframe as a parent of proto */
+			if (cnnobj->aspectframe) {
+				/* We must remove the old aspectframe reparenting proto to viewport */
+				g_object_ref(cnnobj->aspectframe);
+				g_object_ref(cnnobj->proto);
+				gtk_container_remove(GTK_CONTAINER(cnnobj->aspectframe), cnnobj->proto);
+				gtk_container_remove(GTK_CONTAINER(cnnobj->viewport), cnnobj->aspectframe);
+				g_object_unref(cnnobj->aspectframe);
+				cnnobj->aspectframe = NULL;
+				gtk_container_add(GTK_CONTAINER(cnnobj->viewport), cnnobj->proto);
+				g_object_unref(cnnobj->proto);
+				if (cnnobj != NULL && cnnobj->cnnwin != NULL && cnnobj->cnnwin->priv->notebook != NULL)
+					rcw_grab_focus(cnnobj->cnnwin);
+			}
+		}
+
+		if (scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED || scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_DYNRES) {
+			/* We have a plugin that can be scaled, and the scale button
+			 * has been pressed. Give it the correct WxH maintaining aspect
+			 * ratio of remote destkop size */
+			gtk_widget_set_halign(GTK_WIDGET(cnnobj->proto), GTK_ALIGN_FILL);
+			gtk_widget_set_valign(GTK_WIDGET(cnnobj->proto), GTK_ALIGN_FILL);
+		} else {
+			/* Plugin can scale, but no scaling is active. Ensure that we have
+			 * aspectframe with a ratio of 1 */
+			gtk_widget_set_halign(GTK_WIDGET(cnnobj->proto), GTK_ALIGN_CENTER);
+			gtk_widget_set_valign(GTK_WIDGET(cnnobj->proto), GTK_ALIGN_CENTER);
+		}
+	}
+}
+
+static void nb_set_current_page(GtkNotebook *notebook, GtkWidget *page)
+{
+	gint np, i;
+
+	np = gtk_notebook_get_n_pages(notebook);
+	for (i = 0; i < np; i++) {
+		if (gtk_notebook_get_nth_page(notebook, i) == page) {
+			gtk_notebook_set_current_page(notebook, i);
+			break;
+		}
+	}
+}
+
+static void nb_migrate_message_panels(GtkWidget *frompage, GtkWidget *topage)
+{
+	/* Migrate a single connection tab from a notebook to another one */
+	GList *lst, *l;
+
+	/* Reparent message panels */
+	lst = gtk_container_get_children(GTK_CONTAINER(frompage));
+	for (l = lst; l != NULL; l = l->next) {
+		if (REMMINA_IS_MESSAGE_PANEL(l->data)) {
+			g_object_ref(l->data);
+			gtk_container_remove(GTK_CONTAINER(frompage), GTK_WIDGET(l->data));
+			gtk_container_add(GTK_CONTAINER(topage), GTK_WIDGET(l->data));
+			g_object_unref(l->data);
+			gtk_box_reorder_child(GTK_BOX(topage), GTK_WIDGET(l->data), 0);
+		}
+	}
+	g_list_free(lst);
+
+}
+
+static void rcw_migrate(RemminaConnectionWindow *from, RemminaConnectionWindow *to)
+{
+	/* Migrate a complete notebook from a window to another */
+
+	gchar *tag;
+	gint cp, np, i;
+	GtkNotebook *from_notebook;
+	GtkWidget *frompage, *newpage, *old_scrolled_container;
+	RemminaConnectionObject *cnnobj;
+	RemminaScaleMode scalemode;
+
+	/* Migrate TAG */
+	tag = g_strdup((gchar *)g_object_get_data(G_OBJECT(from), "tag"));
+	g_object_set_data_full(G_OBJECT(to), "tag", tag, (GDestroyNotify)g_free);
+
+	/* Migrate notebook content */
+	from_notebook = from->priv->notebook;
+	if (from_notebook && GTK_IS_NOTEBOOK(from_notebook)) {
+
+		cp = gtk_notebook_get_current_page(from_notebook);
+		np = gtk_notebook_get_n_pages(from_notebook);
+		/* Create pages on dest notebook and migrate
+		 * page content */
+		for (i = 0; i < np; i++) {
+			frompage = gtk_notebook_get_nth_page(from_notebook, i);
+			cnnobj = g_object_get_data(G_OBJECT(frompage), "cnnobj");
+
+			/* A scrolled container must be recreated, because it can be different on the new window/page
+			  depending on view_mode */
+			scalemode = get_current_allowed_scale_mode(cnnobj, NULL, NULL);
+			old_scrolled_container = cnnobj->scrolled_container;
+			cnnobj->scrolled_container = rco_create_scrolled_container(scalemode, to->priv->view_mode);
+
+			newpage = rcw_append_new_page(to, cnnobj);
+
+			nb_migrate_message_panels(frompage, newpage);
+
+			/* Reparent the viewport (which is inside scrolled_container) to the new page */
+			g_object_ref(cnnobj->viewport);
+			gtk_container_remove(GTK_CONTAINER(old_scrolled_container), cnnobj->viewport);
+			gtk_container_add(GTK_CONTAINER(cnnobj->scrolled_container), cnnobj->viewport);
+			g_object_unref(cnnobj->viewport);
+
+			/* Destroy old scrolled_container. Not really needed, it will be destroyed
+			 * when removing the page from the notepad */
+			gtk_widget_destroy(old_scrolled_container);
+
+		}
+
+		/* Remove all the pages from source notebook */
+		for (i = np - 1; i >= 0; i--)
+			gtk_notebook_remove_page(from_notebook, i);
+		gtk_notebook_set_current_page(to->priv->notebook, cp);
+
+	}
+}
+
+static void rcw_switch_viewmode(RemminaConnectionWindow *cnnwin, int newmode)
+{
+	GdkWindowState s;
+	RemminaConnectionWindow *newwin;
+	gint old_width, old_height;
+	int old_mode;
+
+	old_mode = cnnwin->priv->view_mode;
+	if (old_mode == newmode)
+		return;
+
+	if (newmode == VIEWPORT_FULLSCREEN_MODE || newmode == SCROLLED_FULLSCREEN_MODE) {
+		if (old_mode == SCROLLED_WINDOW_MODE) {
+			/* We are leaving SCROLLED_WINDOW_MODE, save W,H, and maximized
+			 * status before self destruction of cnnwin */
+			gtk_window_get_size(GTK_WINDOW(cnnwin), &old_width, &old_height);
+			s = gdk_window_get_state(gtk_widget_get_window(GTK_WIDGET(cnnwin)));
+		}
+		newwin = rcw_create_fullscreen(GTK_WINDOW(cnnwin), cnnwin->priv->fss_view_mode);
+		rcw_migrate(cnnwin, newwin);
+		if (old_mode == SCROLLED_WINDOW_MODE) {
+			newwin->priv->ss_maximized = (s & GDK_WINDOW_STATE_MAXIMIZED) ? TRUE : FALSE;
+			newwin->priv->ss_width = old_width;
+			newwin->priv->ss_height = old_height;
+		}
+	} else {
+		newwin = rcw_create_scrolled(cnnwin->priv->ss_width, cnnwin->priv->ss_height,
+					     cnnwin->priv->ss_maximized);
+		rcw_migrate(cnnwin, newwin);
+		if (old_mode == VIEWPORT_FULLSCREEN_MODE || old_mode == SCROLLED_FULLSCREEN_MODE)
+			/* We are leaving a FULLSCREEN mode, save some parameters
+			 * status before self destruction of cnnwin */
+			newwin->priv->fss_view_mode = old_mode;
+	}
+
+	/* Prevent unreleased hostkey from old window to be released here */
+	newwin->priv->hostkey_used = TRUE;
+}
+
+
+static void rcw_toolbar_fullscreen(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+
+	RemminaConnectionObject *cnnobj;
+
+	if (cnnwin->priv->toolbar_is_reconfiguring)
+		return;
+
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+
+	RemminaProtocolWidget *gp = REMMINA_PROTOCOL_WIDGET(cnnobj->proto);
+
+	if (remmina_protocol_widget_get_multimon(gp) >= 1) {
+		REMMINA_DEBUG("Fullscreen on all monitor");
+		gdk_window_set_fullscreen_mode(gtk_widget_get_window(GTK_WIDGET(toggle)), GDK_FULLSCREEN_ON_ALL_MONITORS);
+	} else {
+		REMMINA_DEBUG("Fullscreen on one monitor");
+	}
+
+	if ((toggle != NULL && toggle == cnnwin->priv->toolitem_fullscreen)) {
+		if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toggle))) {
+			if (remmina_protocol_widget_get_multimon(gp) >= 1)
+				gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(cnnwin->priv->toolitem_multimon), TRUE);
+			rcw_switch_viewmode(cnnwin, cnnwin->priv->fss_view_mode);
+		} else {
+			rcw_switch_viewmode(cnnwin, SCROLLED_WINDOW_MODE);
+		}
+	} else
+	if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(cnnwin->priv->toolitem_multimon))) {
+		rcw_switch_viewmode(cnnwin, cnnwin->priv->fss_view_mode);
+	} else {
+		rcw_switch_viewmode(cnnwin, SCROLLED_WINDOW_MODE);
+	}
+}
+
+static void rco_viewport_fullscreen_mode(GtkWidget *widget, RemminaConnectionObject *cnnobj)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindow *newwin;
+
+	if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget)))
+		return;
+	cnnobj->cnnwin->priv->fss_view_mode = VIEWPORT_FULLSCREEN_MODE;
+	newwin = rcw_create_fullscreen(GTK_WINDOW(cnnobj->cnnwin), VIEWPORT_FULLSCREEN_MODE);
+	rcw_migrate(cnnobj->cnnwin, newwin);
+}
+
+static void rco_scrolled_fullscreen_mode(GtkWidget *widget, RemminaConnectionObject *cnnobj)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindow *newwin;
+
+	if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget)))
+		return;
+	cnnobj->cnnwin->priv->fss_view_mode = SCROLLED_FULLSCREEN_MODE;
+	newwin = rcw_create_fullscreen(GTK_WINDOW(cnnobj->cnnwin), SCROLLED_FULLSCREEN_MODE);
+	rcw_migrate(cnnobj->cnnwin, newwin);
+}
+
+static void rcw_fullscreen_option_popdown(GtkWidget *widget, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv = cnnwin->priv;
+
+	priv->sticky = FALSE;
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->fullscreen_option_button), FALSE);
+	rcw_floating_toolbar_show(cnnwin, FALSE);
+}
+
+void rcw_toolbar_fullscreen_option(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj;
+	GtkWidget *menu;
+	GtkWidget *menuitem;
+	GSList *group;
+
+	if (cnnwin->priv->toolbar_is_reconfiguring)
+		return;
+
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+
+	if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggle)))
+		return;
+
+	cnnwin->priv->sticky = TRUE;
+
+	menu = gtk_menu_new();
+
+	menuitem = gtk_radio_menu_item_new_with_label(NULL, _("Viewport fullscreen mode"));
+	gtk_widget_show(menuitem);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
+	group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menuitem));
+	if (cnnwin->priv->view_mode == VIEWPORT_FULLSCREEN_MODE)
+		gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE);
+	g_signal_connect(G_OBJECT(menuitem), "toggled", G_CALLBACK(rco_viewport_fullscreen_mode), cnnobj);
+
+	menuitem = gtk_radio_menu_item_new_with_label(group, _("Scrolled fullscreen"));
+	gtk_widget_show(menuitem);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
+	if (cnnwin->priv->view_mode == SCROLLED_FULLSCREEN_MODE)
+		gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE);
+	g_signal_connect(G_OBJECT(menuitem), "toggled", G_CALLBACK(rco_scrolled_fullscreen_mode), cnnobj);
+
+	g_signal_connect(G_OBJECT(menu), "deactivate", G_CALLBACK(rcw_fullscreen_option_popdown), cnnwin);
+
+#if GTK_CHECK_VERSION(3, 22, 0)
+	gtk_menu_popup_at_widget(GTK_MENU(menu), GTK_WIDGET(toggle),
+				 GDK_GRAVITY_SOUTH_WEST, GDK_GRAVITY_NORTH_WEST, NULL);
+#else
+	gtk_menu_popup(GTK_MENU(menu), NULL, NULL, remmina_public_popup_position, cnnwin->priv->toolitem_fullscreen, 0,
+		       gtk_get_current_event_time());
+#endif
+}
+
+
+static void rcw_scaler_option_popdown(GtkWidget *widget, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv = cnnwin->priv;
+
+	if (priv->toolbar_is_reconfiguring)
+		return;
+	priv->sticky = FALSE;
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->scaler_option_button), FALSE);
+	rcw_floating_toolbar_show(cnnwin, FALSE);
+}
+
+static void rcw_scaler_expand(GtkWidget *widget, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj;
+
+	if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget)))
+		return;
+	cnnobj = rcw_get_visible_cnnobj(cnnwin);
+	if (!cnnobj)
+		return;
+	remmina_protocol_widget_set_expand(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), TRUE);
+	remmina_file_set_int(cnnobj->remmina_file, "scaler_expand", TRUE);
+	remmina_protocol_widget_update_alignment(cnnobj);
+}
+static void rcw_scaler_keep_aspect(GtkWidget *widget, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj;
+
+	if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget)))
+		return;
+	cnnobj = rcw_get_visible_cnnobj(cnnwin);
+	if (!cnnobj)
+		return;
+
+	remmina_protocol_widget_set_expand(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), FALSE);
+	remmina_file_set_int(cnnobj->remmina_file, "scaler_expand", FALSE);
+	remmina_protocol_widget_update_alignment(cnnobj);
+}
+
+static void rcw_toolbar_scaler_option(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv;
+	RemminaConnectionObject *cnnobj;
+	GtkWidget *menu;
+	GtkWidget *menuitem;
+	GSList *group;
+	gboolean scaler_expand;
+
+	if (cnnwin->priv->toolbar_is_reconfiguring)
+		return;
+
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+	priv = cnnwin->priv;
+
+	if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggle)))
+		return;
+
+	scaler_expand = remmina_protocol_widget_get_expand(REMMINA_PROTOCOL_WIDGET(cnnobj->proto));
+
+	priv->sticky = TRUE;
+
+	menu = gtk_menu_new();
+
+	menuitem = gtk_radio_menu_item_new_with_label(NULL, _("Keep aspect ratio when scaled"));
+	gtk_widget_show(menuitem);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
+	group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menuitem));
+	if (!scaler_expand)
+		gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE);
+	g_signal_connect(G_OBJECT(menuitem), "toggled", G_CALLBACK(rcw_scaler_keep_aspect), cnnwin);
+
+	menuitem = gtk_radio_menu_item_new_with_label(group, _("Fill client window when scaled"));
+	gtk_widget_show(menuitem);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
+	if (scaler_expand)
+		gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE);
+	g_signal_connect(G_OBJECT(menuitem), "toggled", G_CALLBACK(rcw_scaler_expand), cnnwin);
+
+	g_signal_connect(G_OBJECT(menu), "deactivate", G_CALLBACK(rcw_scaler_option_popdown), cnnwin);
+
+#if GTK_CHECK_VERSION(3, 22, 0)
+	gtk_menu_popup_at_widget(GTK_MENU(menu), GTK_WIDGET(toggle),
+				 GDK_GRAVITY_SOUTH_WEST, GDK_GRAVITY_NORTH_WEST, NULL);
+#else
+	gtk_menu_popup(GTK_MENU(menu), NULL, NULL, remmina_public_popup_position, priv->toolitem_scale, 0,
+		       gtk_get_current_event_time());
+#endif
+}
+
+void rco_switch_page_activate(GtkMenuItem *menuitem, RemminaConnectionObject *cnnobj)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv = cnnobj->cnnwin->priv;
+	gint page_num;
+
+	page_num = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menuitem), "new-page-num"));
+	gtk_notebook_set_current_page(GTK_NOTEBOOK(priv->notebook), page_num);
+}
+
+void rcw_toolbar_switch_page_popdown(GtkWidget *widget, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv = cnnwin->priv;
+
+	priv->sticky = FALSE;
+
+	gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_switch_page), FALSE);
+	rcw_floating_toolbar_show(cnnwin, FALSE);
+}
+
+static void rcw_toolbar_switch_page(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+
+	RemminaConnectionWindowPriv *priv = cnnwin->priv;
+	RemminaConnectionObject *cnnobj;
+
+	GtkWidget *menu;
+	GtkWidget *menuitem;
+	GtkWidget *image;
+	gint i, n;
+
+	if (priv->toolbar_is_reconfiguring)
+		return;
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+
+	if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toggle)))
+		return;
+
+	priv->sticky = TRUE;
+
+	menu = gtk_menu_new();
+
+	n = gtk_notebook_get_n_pages(GTK_NOTEBOOK(priv->notebook));
+	for (i = 0; i < n; i++) {
+		cnnobj = rcw_get_cnnobj_at_page(cnnobj->cnnwin, i);
+
+		menuitem = gtk_menu_item_new_with_label(remmina_file_get_string(cnnobj->remmina_file, "name"));
+		gtk_widget_show(menuitem);
+		gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
+
+		image = gtk_image_new_from_icon_name(remmina_file_get_icon_name(cnnobj->remmina_file), GTK_ICON_SIZE_MENU);
+		gtk_widget_show(image);
+
+		g_object_set_data(G_OBJECT(menuitem), "new-page-num", GINT_TO_POINTER(i));
+		g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(rco_switch_page_activate), cnnobj);
+		if (i == gtk_notebook_get_current_page(GTK_NOTEBOOK(priv->notebook)))
+			gtk_widget_set_sensitive(menuitem, FALSE);
+	}
+
+	g_signal_connect(G_OBJECT(menu), "deactivate", G_CALLBACK(rcw_toolbar_switch_page_popdown),
+			 cnnwin);
+
+#if GTK_CHECK_VERSION(3, 22, 0)
+	gtk_menu_popup_at_widget(GTK_MENU(menu), GTK_WIDGET(toggle),
+				 GDK_GRAVITY_SOUTH_WEST, GDK_GRAVITY_NORTH_WEST, NULL);
+#else
+	gtk_menu_popup(GTK_MENU(menu), NULL, NULL, remmina_public_popup_position, widget, 0, gtk_get_current_event_time());
+#endif
+}
+
+void rco_update_toolbar_autofit_button(RemminaConnectionObject *cnnobj)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv = cnnobj->cnnwin->priv;
+	GtkToolItem *toolitem;
+	RemminaScaleMode sc;
+
+	toolitem = priv->toolitem_autofit;
+	if (toolitem) {
+		if (priv->view_mode != SCROLLED_WINDOW_MODE) {
+			gtk_widget_set_sensitive(GTK_WIDGET(toolitem), FALSE);
+		} else {
+			sc = get_current_allowed_scale_mode(cnnobj, NULL, NULL);
+			gtk_widget_set_sensitive(GTK_WIDGET(toolitem), sc == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_NONE);
+		}
+	}
+}
+
+static void rco_change_scalemode(RemminaConnectionObject *cnnobj, gboolean bdyn, gboolean bscale)
+{
+	RemminaScaleMode scalemode;
+	RemminaConnectionWindowPriv *priv = cnnobj->cnnwin->priv;
+
+	if (bdyn)
+		scalemode = REMMINA_PROTOCOL_WIDGET_SCALE_MODE_DYNRES;
+	else if (bscale)
+		scalemode = REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED;
+	else
+		scalemode = REMMINA_PROTOCOL_WIDGET_SCALE_MODE_NONE;
+
+	remmina_protocol_widget_set_current_scale_mode(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), scalemode);
+	remmina_file_set_int(cnnobj->remmina_file, "scale", scalemode);
+	gtk_widget_set_sensitive(GTK_WIDGET(priv->scaler_option_button), scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED);
+	rco_update_toolbar_autofit_button(cnnobj);
+
+	remmina_protocol_widget_call_feature_by_type(REMMINA_PROTOCOL_WIDGET(cnnobj->proto),
+						     REMMINA_PROTOCOL_FEATURE_TYPE_SCALE, 0);
+
+	if (cnnobj->cnnwin->priv->view_mode != SCROLLED_WINDOW_MODE)
+		rco_check_resize(cnnobj);
+	if (GTK_IS_SCROLLED_WINDOW(cnnobj->scrolled_container)) {
+		rco_set_scrolled_policy(scalemode, GTK_SCROLLED_WINDOW(cnnobj->scrolled_container));
+	}
+}
+
+static void rcw_toolbar_dynres(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	gboolean bdyn, bscale;
+	RemminaConnectionObject *cnnobj;
+
+	if (cnnwin->priv->toolbar_is_reconfiguring)
+		return;
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+
+	if (cnnobj->connected) {
+		bdyn = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toggle));
+		bscale = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(cnnobj->cnnwin->priv->toolitem_scale));
+
+		if (bdyn && bscale) {
+			gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(cnnobj->cnnwin->priv->toolitem_scale), FALSE);
+			bscale = FALSE;
+		}
+
+		rco_change_scalemode(cnnobj, bdyn, bscale);
+	}
+}
+
+static void rcw_toolbar_scaled_mode(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	gboolean bdyn, bscale;
+	RemminaConnectionObject *cnnobj;
+
+	if (cnnwin->priv->toolbar_is_reconfiguring)
+		return;
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+
+	bdyn = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(cnnobj->cnnwin->priv->toolitem_dynres));
+	bscale = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toggle));
+
+	if (bdyn && bscale) {
+		gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(cnnobj->cnnwin->priv->toolitem_dynres), FALSE);
+		bdyn = FALSE;
+	}
+
+	rco_change_scalemode(cnnobj, bdyn, bscale);
+}
+
+static void rcw_toolbar_multi_monitor_mode(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj;
+
+	if (cnnwin->priv->toolbar_is_reconfiguring)
+		return;
+
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+
+	if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toggle))) {
+		REMMINA_DEBUG("Saving multimon as 1");
+		remmina_file_set_int(cnnobj->remmina_file, "multimon", 1);
+		remmina_file_save(cnnobj->remmina_file);
+		remmina_protocol_widget_call_feature_by_type(REMMINA_PROTOCOL_WIDGET(cnnobj->proto),
+							     REMMINA_PROTOCOL_FEATURE_TYPE_MULTIMON, 0);
+		if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(cnnwin->priv->toolitem_fullscreen)))
+			gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(cnnwin->priv->toolitem_fullscreen), TRUE);
+	} else {
+		REMMINA_DEBUG("Saving multimon as 0");
+		remmina_file_set_int(cnnobj->remmina_file, "multimon", 0);
+		remmina_file_save(cnnobj->remmina_file);
+		rcw_toolbar_fullscreen(NULL, cnnwin);
+	}
+}
+
+static void rcw_toolbar_open_main(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+
+	if (cnnwin->priv->toolbar_is_reconfiguring)
+		return;
+
+	remmina_exec_command(REMMINA_COMMAND_MAIN, NULL);
+}
+
+static void rcw_toolbar_preferences_popdown(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj;
+
+	if (cnnwin->priv->toolbar_is_reconfiguring)
+		return;
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+
+	cnnobj->cnnwin->priv->sticky = FALSE;
+
+	gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(cnnobj->cnnwin->priv->toolitem_preferences), FALSE);
+	rcw_floating_toolbar_show(cnnwin, FALSE);
+}
+
+void rcw_toolbar_menu_popdown(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv = cnnwin->priv;
+
+	if (priv->toolbar_is_reconfiguring)
+		return;
+
+	priv->sticky = FALSE;
+
+	gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_menu), FALSE);
+	rcw_floating_toolbar_show(cnnwin, FALSE);
+}
+
+void rcw_toolbar_tools_popdown(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv = cnnwin->priv;
+
+	if (priv->toolbar_is_reconfiguring)
+		return;
+
+	priv->sticky = FALSE;
+
+	gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_tools), FALSE);
+	rcw_floating_toolbar_show(cnnwin, FALSE);
+}
+
+static void rco_call_protocol_feature_radio(GtkMenuItem *menuitem, RemminaConnectionObject *cnnobj)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolFeature *feature;
+	gpointer value;
+
+	if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) {
+		feature = (RemminaProtocolFeature *)g_object_get_data(G_OBJECT(menuitem), "feature-type");
+		value = g_object_get_data(G_OBJECT(menuitem), "feature-value");
+
+		remmina_file_set_string(cnnobj->remmina_file, (const gchar *)feature->opt2, (const gchar *)value);
+		remmina_protocol_widget_call_feature_by_ref(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), feature);
+	}
+}
+
+static void rco_call_protocol_feature_check(GtkMenuItem *menuitem, RemminaConnectionObject *cnnobj)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolFeature *feature;
+	gboolean value;
+
+	feature = (RemminaProtocolFeature *)g_object_get_data(G_OBJECT(menuitem), "feature-type");
+	value = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem));
+	remmina_file_set_int(cnnobj->remmina_file, (const gchar *)feature->opt2, value);
+	remmina_protocol_widget_call_feature_by_ref(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), feature);
+}
+
+static void rco_call_protocol_feature_activate(GtkMenuItem *menuitem, RemminaConnectionObject *cnnobj)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolFeature *feature;
+
+	feature = (RemminaProtocolFeature *)g_object_get_data(G_OBJECT(menuitem), "feature-type");
+	remmina_protocol_widget_call_feature_by_ref(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), feature);
+}
+
+void rcw_toolbar_preferences_radio(RemminaConnectionObject *cnnobj, RemminaFile *remminafile,
+				   GtkWidget *menu, const RemminaProtocolFeature *feature, const gchar *domain, gboolean enabled)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *menuitem;
+	GSList *group;
+	gint i;
+	const gchar **list;
+	const gchar *value;
+
+	group = NULL;
+	value = remmina_file_get_string(remminafile, (const gchar *)feature->opt2);
+	list = (const gchar **)feature->opt3;
+	for (i = 0; list[i]; i += 2) {
+		menuitem = gtk_radio_menu_item_new_with_label(group, g_dgettext(domain, list[i + 1]));
+		group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menuitem));
+		gtk_widget_show(menuitem);
+		gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
+
+		if (enabled) {
+			g_object_set_data(G_OBJECT(menuitem), "feature-type", (gpointer)feature);
+			g_object_set_data(G_OBJECT(menuitem), "feature-value", (gpointer)list[i]);
+
+			if (value && g_strcmp0(list[i], value) == 0)
+				gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE);
+
+			g_signal_connect(G_OBJECT(menuitem), "toggled",
+					 G_CALLBACK(rco_call_protocol_feature_radio), cnnobj);
+		} else {
+			gtk_widget_set_sensitive(menuitem, FALSE);
+		}
+	}
+}
+
+void rcw_toolbar_preferences_check(RemminaConnectionObject *cnnobj,
+				   GtkWidget *menu, const RemminaProtocolFeature *feature,
+				   const gchar *domain, gboolean enabled)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *menuitem;
+
+	menuitem = gtk_check_menu_item_new_with_label(g_dgettext(domain, (const gchar *)feature->opt3));
+	gtk_widget_show(menuitem);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
+
+	if (enabled) {
+		g_object_set_data(G_OBJECT(menuitem), "feature-type", (gpointer)feature);
+
+		gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem),
+					       remmina_file_get_int(cnnobj->remmina_file, (const gchar *)feature->opt2, FALSE));
+
+		g_signal_connect(G_OBJECT(menuitem), "toggled",
+				 G_CALLBACK(rco_call_protocol_feature_check), cnnobj);
+	} else {
+		gtk_widget_set_sensitive(menuitem, FALSE);
+	}
+}
+
+static void rcw_toolbar_preferences(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv;
+	RemminaConnectionObject *cnnobj;
+	const RemminaProtocolFeature *feature;
+	GtkWidget *menu;
+	GtkWidget *menuitem;
+	gboolean separator;
+	gchar *domain;
+	gboolean enabled;
+
+	if (cnnwin->priv->toolbar_is_reconfiguring)
+		return;
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+	priv = cnnobj->cnnwin->priv;
+
+	if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toggle)))
+		return;
+
+	priv->sticky = TRUE;
+
+	separator = FALSE;
+
+	domain = remmina_protocol_widget_get_domain(REMMINA_PROTOCOL_WIDGET(cnnobj->proto));
+	menu = gtk_menu_new();
+	for (feature = remmina_protocol_widget_get_features(REMMINA_PROTOCOL_WIDGET(cnnobj->proto)); feature && feature->type;
+	     feature++) {
+		if (feature->type != REMMINA_PROTOCOL_FEATURE_TYPE_PREF)
+			continue;
+
+		if (separator) {
+			menuitem = gtk_separator_menu_item_new();
+			gtk_widget_show(menuitem);
+			gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
+			separator = FALSE;
+		}
+		enabled = remmina_protocol_widget_query_feature_by_ref(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), feature);
+		switch (GPOINTER_TO_INT(feature->opt1)) {
+		case REMMINA_PROTOCOL_FEATURE_PREF_RADIO:
+			rcw_toolbar_preferences_radio(cnnobj, cnnobj->remmina_file, menu, feature,
+						      domain, enabled);
+			separator = TRUE;
+			break;
+		case REMMINA_PROTOCOL_FEATURE_PREF_CHECK:
+			rcw_toolbar_preferences_check(cnnobj, menu, feature,
+						      domain, enabled);
+			break;
+		}
+	}
+
+	g_free(domain);
+
+	g_signal_connect(G_OBJECT(menu), "deactivate", G_CALLBACK(rcw_toolbar_preferences_popdown), cnnwin);
+
+#if GTK_CHECK_VERSION(3, 22, 0)
+	gtk_menu_popup_at_widget(GTK_MENU(menu), GTK_WIDGET(toggle),
+				 GDK_GRAVITY_SOUTH_WEST, GDK_GRAVITY_NORTH_WEST, NULL);
+#else
+	gtk_menu_popup(GTK_MENU(menu), NULL, NULL, remmina_public_popup_position, widget, 0, gtk_get_current_event_time());
+#endif
+}
+
+static void rcw_toolbar_menu_on_launch_item(RemminaAppletMenu *menu, RemminaAppletMenuItem *menuitem, gpointer data)
+{
+	TRACE_CALL(__func__);
+	gchar *s;
+
+	switch (menuitem->item_type) {
+	case REMMINA_APPLET_MENU_ITEM_NEW:
+		remmina_exec_command(REMMINA_COMMAND_NEW, NULL);
+		break;
+	case REMMINA_APPLET_MENU_ITEM_FILE:
+		remmina_exec_command(REMMINA_COMMAND_CONNECT, menuitem->filename);
+		break;
+	case REMMINA_APPLET_MENU_ITEM_DISCOVERED:
+		s = g_strdup_printf("%s,%s", menuitem->protocol, menuitem->name);
+		remmina_exec_command(REMMINA_COMMAND_NEW, s);
+		g_free(s);
+		break;
+	}
+}
+
+static void rcw_toolbar_menu(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv;
+	RemminaConnectionObject *cnnobj;
+	GtkWidget *menu;
+	GtkWidget *menuitem = NULL;
+
+	if (cnnwin->priv->toolbar_is_reconfiguring)
+		return;
+
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+	priv = cnnobj->cnnwin->priv;
+
+	if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toggle)))
+		return;
+
+	priv->sticky = TRUE;
+
+	menu = remmina_applet_menu_new();
+	remmina_applet_menu_set_hide_count(REMMINA_APPLET_MENU(menu), remmina_pref.applet_hide_count);
+	remmina_applet_menu_populate(REMMINA_APPLET_MENU(menu));
+
+	g_signal_connect(G_OBJECT(menu), "launch-item", G_CALLBACK(rcw_toolbar_menu_on_launch_item), NULL);
+	//g_signal_connect(G_OBJECT(menu), "edit-item", G_CALLBACK(rcw_toolbar_menu_on_edit_item), NULL);
+	menuitem = gtk_separator_menu_item_new();
+	gtk_widget_show(menuitem);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
+#if GTK_CHECK_VERSION(3, 22, 0)
+	gtk_menu_popup_at_widget(GTK_MENU(menu), GTK_WIDGET(toggle),
+				 GDK_GRAVITY_SOUTH_WEST, GDK_GRAVITY_NORTH_WEST, NULL);
+#else
+	gtk_menu_popup(GTK_MENU(menu), NULL, NULL, remmina_public_popup_position, widget, 0, gtk_get_current_event_time());
+#endif
+	g_signal_connect(G_OBJECT(menu), "deactivate", G_CALLBACK(rcw_toolbar_menu_popdown), cnnwin);
+}
+
+static void rcw_toolbar_tools(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv;
+	RemminaConnectionObject *cnnobj;
+	const RemminaProtocolFeature *feature;
+	GtkWidget *menu;
+	GtkWidget *menuitem = NULL;
+	GtkMenu *submenu_keystrokes;
+	const gchar *domain;
+	gboolean enabled;
+	gchar **keystrokes;
+	gchar **keystroke_values;
+	gint i;
+
+	if (cnnwin->priv->toolbar_is_reconfiguring)
+		return;
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+	priv = cnnobj->cnnwin->priv;
+
+	if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toggle)))
+		return;
+
+	priv->sticky = TRUE;
+
+	domain = remmina_protocol_widget_get_domain(REMMINA_PROTOCOL_WIDGET(cnnobj->proto));
+	menu = gtk_menu_new();
+	for (feature = remmina_protocol_widget_get_features(REMMINA_PROTOCOL_WIDGET(cnnobj->proto)); feature && feature->type;
+	     feature++) {
+		if (feature->type != REMMINA_PROTOCOL_FEATURE_TYPE_TOOL)
+			continue;
+
+		if (feature->opt1)
+			menuitem = gtk_menu_item_new_with_label(g_dgettext(domain, (const gchar *)feature->opt1));
+		if (feature->opt3)
+			rcw_set_tooltip(menuitem, "", GPOINTER_TO_UINT(feature->opt3), 0);
+		gtk_widget_show(menuitem);
+		gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
+
+		enabled = remmina_protocol_widget_query_feature_by_ref(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), feature);
+		if (enabled) {
+			g_object_set_data(G_OBJECT(menuitem), "feature-type", (gpointer)feature);
+
+			g_signal_connect(G_OBJECT(menuitem), "activate",
+					 G_CALLBACK(rco_call_protocol_feature_activate), cnnobj);
+		} else {
+			gtk_widget_set_sensitive(menuitem, FALSE);
+		}
+	}
+
+	/* If the plugin accepts keystrokes include the keystrokes menu */
+	if (remmina_protocol_widget_plugin_receives_keystrokes(REMMINA_PROTOCOL_WIDGET(cnnobj->proto))) {
+		/* Get the registered keystrokes list */
+		keystrokes = g_strsplit(remmina_pref.keystrokes, STRING_DELIMITOR, -1);
+		if (g_strv_length(keystrokes)) {
+			/* Add a keystrokes submenu */
+			menuitem = gtk_menu_item_new_with_label(_("Keystrokes"));
+			submenu_keystrokes = GTK_MENU(gtk_menu_new());
+			gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), GTK_WIDGET(submenu_keystrokes));
+			gtk_widget_show(menuitem);
+			gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
+			/* Add each registered keystroke */
+			for (i = 0; i < g_strv_length(keystrokes); i++) {
+				keystroke_values = g_strsplit(keystrokes[i], STRING_DELIMITOR2, -1);
+				if (g_strv_length(keystroke_values) > 1) {
+					/* Add the keystroke if no description was available */
+					menuitem = gtk_menu_item_new_with_label(
+						g_strdup(keystroke_values[strlen(keystroke_values[0]) ? 0 : 1]));
+					g_object_set_data(G_OBJECT(menuitem), "keystrokes", g_strdup(keystroke_values[1]));
+					g_signal_connect_swapped(G_OBJECT(menuitem), "activate",
+								 G_CALLBACK(remmina_protocol_widget_send_keystrokes),
+								 REMMINA_PROTOCOL_WIDGET(cnnobj->proto));
+					gtk_widget_show(menuitem);
+					gtk_menu_shell_append(GTK_MENU_SHELL(submenu_keystrokes), menuitem);
+				}
+				g_strfreev(keystroke_values);
+			}
+			menuitem = gtk_menu_item_new_with_label(_("Send clipboard content as keystrokes"));
+			static gchar k_tooltip[] =
+				N_("CAUTION: Pasted text will be sent as a sequence of key-codes as if typed on your local keyboard.\n"
+				"\n"
+				"  • For best results use same keyboard settings for both, client and server.\n"
+				"\n"
+				"  • If client-keyboard is different from server-keyboard the received text can contain wrong or erroneous characters.\n"
+				"\n"
+				"  • Unicode characters and other special characters that can't be translated to local key-codes won’t be sent to the server.\n"
+				"\n");
+			gtk_widget_set_tooltip_text(menuitem, k_tooltip);
+			gtk_menu_shell_append(GTK_MENU_SHELL(submenu_keystrokes), menuitem);
+			g_signal_connect_swapped(G_OBJECT(menuitem), "activate",
+						 G_CALLBACK(remmina_protocol_widget_send_clipboard),
+						 REMMINA_PROTOCOL_WIDGET(cnnobj->proto));
+			gtk_widget_show(menuitem);
+		}
+		g_strfreev(keystrokes);
+	}
+
+	g_signal_connect(G_OBJECT(menu), "deactivate", G_CALLBACK(rcw_toolbar_tools_popdown), cnnwin);
+
+#if GTK_CHECK_VERSION(3, 22, 0)
+	gtk_menu_popup_at_widget(GTK_MENU(menu), GTK_WIDGET(toggle),
+				 GDK_GRAVITY_SOUTH_WEST, GDK_GRAVITY_NORTH_WEST, NULL);
+#else
+	gtk_menu_popup(GTK_MENU(menu), NULL, NULL, remmina_public_popup_position, widget, 0, gtk_get_current_event_time());
+#endif
+}
+
+static void rcw_toolbar_duplicate(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+
+	RemminaConnectionObject *cnnobj;
+
+	if (cnnwin->priv->toolbar_is_reconfiguring)
+		return;
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+
+	remmina_file_save(cnnobj->remmina_file);
+
+	remmina_exec_command(REMMINA_COMMAND_CONNECT, cnnobj->remmina_file->filename);
+}
+
+static void rcw_toolbar_screenshot(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+
+	GdkPixbuf *screenshot;
+	GdkWindow *active_window;
+	cairo_t *cr;
+	gint width, height;
+	GString *pngstr;
+	gchar *pngname;
+	GtkWidget *dialog;
+	RemminaProtocolWidget *gp;
+	RemminaPluginScreenshotData rpsd;
+	RemminaConnectionObject *cnnobj;
+	cairo_surface_t *srcsurface;
+	cairo_format_t cairo_format;
+	cairo_surface_t *surface;
+	int stride;
+
+	if (cnnwin->priv->toolbar_is_reconfiguring)
+		return;
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+
+	GDateTime *date = g_date_time_new_now_utc();
+
+	// We will take a screenshot of the currently displayed RemminaProtocolWidget.
+	gp = REMMINA_PROTOCOL_WIDGET(cnnobj->proto);
+
+	gchar *denyclip = remmina_pref_get_value("deny_screenshot_clipboard");
+
+	REMMINA_DEBUG("deny_screenshot_clipboard is set to %s", denyclip);
+
+	GtkClipboard *c = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
+
+	// Ask the plugin if it can give us a screenshot
+	if (remmina_protocol_widget_plugin_screenshot(gp, &rpsd)) {
+		// Good, we have a screenshot from the plugin !
+
+		REMMINA_DEBUG("Screenshot from plugin: w=%d h=%d bpp=%d bytespp=%d\n",
+			      rpsd.width, rpsd.height, rpsd.bitsPerPixel, rpsd.bytesPerPixel);
+
+		width = rpsd.width;
+		height = rpsd.height;
+
+		if (rpsd.bitsPerPixel == 32)
+			cairo_format = CAIRO_FORMAT_ARGB32;
+		else if (rpsd.bitsPerPixel == 24)
+			cairo_format = CAIRO_FORMAT_RGB24;
+		else
+			cairo_format = CAIRO_FORMAT_RGB16_565;
+
+		stride = cairo_format_stride_for_width(cairo_format, width);
+
+		srcsurface = cairo_image_surface_create_for_data(rpsd.buffer, cairo_format, width, height, stride);
+		// Transfer the PixBuf in the main clipboard selection
+		if (denyclip && (g_strcmp0(denyclip, "true")))
+			gtk_clipboard_set_image(c, gdk_pixbuf_get_from_surface(
+							srcsurface, 0, 0, width, height));
+		surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, height);
+		cr = cairo_create(surface);
+		cairo_set_source_surface(cr, srcsurface, 0, 0);
+		cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
+		cairo_paint(cr);
+		cairo_surface_destroy(srcsurface);
+
+		free(rpsd.buffer);
+	} else {
+		// The plugin is not releasing us a screenshot, just try to catch one via GTK
+
+		/* Warn the user if image is distorted */
+		if (cnnobj->plugin_can_scale &&
+		    get_current_allowed_scale_mode(cnnobj, NULL, NULL) == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED) {
+			dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
+							_("Turn off scaling to avoid screenshot distortion."));
+			g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(gtk_widget_destroy), NULL);
+			gtk_widget_show(dialog);
+		}
+
+		// Get the screenshot.
+		active_window = gtk_widget_get_window(GTK_WIDGET(gp));
+		// width = gdk_window_get_width(gtk_widget_get_window(GTK_WIDGET(cnnobj->cnnwin)));
+		width = gdk_window_get_width(active_window);
+		// height = gdk_window_get_height(gtk_widget_get_window(GTK_WIDGET(cnnobj->cnnwin)));
+		height = gdk_window_get_height(active_window);
+
+		screenshot = gdk_pixbuf_get_from_window(active_window, 0, 0, width, height);
+		if (screenshot == NULL)
+			g_print("gdk_pixbuf_get_from_window failed\n");
+
+		// Transfer the PixBuf in the main clipboard selection
+		if (denyclip && (g_strcmp0(denyclip, "true")))
+			gtk_clipboard_set_image(c, screenshot);
+		// Prepare the destination Cairo surface.
+		surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, height);
+		cr = cairo_create(surface);
+
+		// Copy the source pixbuf to the surface and paint it.
+		gdk_cairo_set_source_pixbuf(cr, screenshot, 0, 0);
+		cairo_paint(cr);
+
+		// Deallocate screenshot pixbuf
+		g_object_unref(screenshot);
+	}
+
+	//home/antenore/Pictures/remmina_%p_%h_%Y  %m %d-%H%M%S.png pngname
+	//home/antenore/Pictures/remmina_st_  _2018 9 24-151958.240374.png
+
+	pngstr = g_string_new(g_strdup_printf("%s/%s.png",
+					      remmina_pref.screenshot_path,
+					      remmina_pref.screenshot_name));
+	remmina_utils_string_replace_all(pngstr, "%p",
+					 remmina_file_get_string(cnnobj->remmina_file, "name"));
+	remmina_utils_string_replace_all(pngstr, "%h",
+					 remmina_file_get_string(cnnobj->remmina_file, "server"));
+	remmina_utils_string_replace_all(pngstr, "%Y",
+					 g_strdup_printf("%d", g_date_time_get_year(date)));
+	remmina_utils_string_replace_all(pngstr, "%m", g_strdup_printf("%02d",
+								       g_date_time_get_month(date)));
+	remmina_utils_string_replace_all(pngstr, "%d",
+					 g_strdup_printf("%02d", g_date_time_get_day_of_month(date)));
+	remmina_utils_string_replace_all(pngstr, "%H",
+					 g_strdup_printf("%02d", g_date_time_get_hour(date)));
+	remmina_utils_string_replace_all(pngstr, "%M",
+					 g_strdup_printf("%02d", g_date_time_get_minute(date)));
+	remmina_utils_string_replace_all(pngstr, "%S",
+					 g_strdup_printf("%02d", g_date_time_get_second(date)));
+	g_date_time_unref(date);
+	pngname = g_string_free(pngstr, FALSE);
+
+	cairo_surface_write_to_png(surface, pngname);
+
+	/* send a desktop notification */
+	if (g_file_test(pngname, G_FILE_TEST_EXISTS))
+		remmina_public_send_notification("remmina-screenshot-is-ready-id", _("Screenshot taken"), pngname);
+
+	//Clean up and return.
+	cairo_destroy(cr);
+	cairo_surface_destroy(surface);
+}
+
+static void rcw_toolbar_minimize(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+
+	if (cnnwin->priv->toolbar_is_reconfiguring)
+		return;
+
+	rcw_floating_toolbar_show(cnnwin, FALSE);
+	gtk_window_iconify(GTK_WINDOW(cnnwin));
+}
+
+static void rcw_toolbar_disconnect(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj;
+
+	if (cnnwin->priv->toolbar_is_reconfiguring)
+		return;
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+	rco_disconnect_current_page(cnnobj);
+}
+
+static void rcw_toolbar_grab(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	gboolean capture;
+	RemminaConnectionObject *cnnobj;
+
+	if (cnnwin->priv->toolbar_is_reconfiguring)
+		return;
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+
+	capture = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toggle));
+	
+	if (cnnobj->connected){
+		remmina_file_set_int(cnnobj->remmina_file, "keyboard_grab", capture);
+	}
+
+	if (capture && cnnobj->connected) {
+		
+#if DEBUG_KB_GRABBING
+		printf("DEBUG_KB_GRABBING: Grabbing for button\n");
+#endif
+		rcw_keyboard_grab(cnnobj->cnnwin);
+		if (cnnobj->cnnwin->priv->pointer_entered)
+			rcw_pointer_grab(cnnobj->cnnwin);
+	} else {
+		rcw_kp_ungrab(cnnobj->cnnwin);
+	}
+
+	rco_update_toolbar(cnnobj);
+}
+
+static GtkWidget *
+rcw_create_toolbar(RemminaConnectionWindow *cnnwin, gint mode)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv = cnnwin->priv;
+	RemminaConnectionObject *cnnobj;
+	GtkWidget *toolbar;
+	GtkToolItem *toolitem;
+	GtkWidget *widget;
+	GtkWidget *arrow;
+
+	GdkDisplay *display;
+	gint n_monitors;
+
+	display = gdk_display_get_default();
+	n_monitors = gdk_display_get_n_monitors(display);
+
+	cnnobj = rcw_get_visible_cnnobj(cnnwin);
+
+	priv->toolbar_is_reconfiguring = TRUE;
+
+	toolbar = gtk_toolbar_new();
+	gtk_widget_show(toolbar);
+	gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
+
+	/* Main actions */
+
+	/* Menu */
+	toolitem = gtk_toggle_tool_button_new();
+	gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "view-more-symbolic");
+	gtk_tool_button_set_label(GTK_TOOL_BUTTON(toolitem), _("_Menu"));
+	gtk_tool_item_set_tooltip_text(toolitem, _("Menu"));
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	gtk_widget_show(GTK_WIDGET(toolitem));
+	g_signal_connect(G_OBJECT(toolitem), "toggled", G_CALLBACK(rcw_toolbar_menu), cnnwin);
+	priv->toolitem_menu = toolitem;
+
+	/* Open Main window */
+	toolitem = gtk_tool_button_new(NULL, "Open Remmina Main window");
+	gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "go-home-symbolic");
+	gtk_tool_item_set_tooltip_text(toolitem, _("Open the Remmina main window"));
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	gtk_widget_show(GTK_WIDGET(toolitem));
+	g_signal_connect(G_OBJECT(toolitem), "clicked", G_CALLBACK(rcw_toolbar_open_main), cnnwin);
+
+	priv->toolitem_new = toolitem;
+
+	/* Duplicate session */
+	toolitem = gtk_tool_button_new(NULL, "Duplicate connection");
+	gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-duplicate-symbolic");
+	gtk_tool_item_set_tooltip_text(toolitem, _("Duplicate current connection"));
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	gtk_widget_show(GTK_WIDGET(toolitem));
+	g_signal_connect(G_OBJECT(toolitem), "clicked", G_CALLBACK(rcw_toolbar_duplicate), cnnwin);
+	if (!cnnobj)
+		gtk_widget_set_sensitive(GTK_WIDGET(toolitem), FALSE);
+
+	priv->toolitem_duplicate = toolitem;
+
+	/* Separator */
+	toolitem = gtk_separator_tool_item_new();
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	gtk_widget_show(GTK_WIDGET(toolitem));
+
+	/* Auto-Fit */
+	toolitem = gtk_tool_button_new(NULL, NULL);
+	gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-fit-window-symbolic");
+	rcw_set_tooltip(GTK_WIDGET(toolitem), _("Resize the window to fit in remote resolution"),
+			remmina_pref.shortcutkey_autofit, 0);
+	g_signal_connect(G_OBJECT(toolitem), "clicked", G_CALLBACK(rcw_toolbar_autofit), cnnwin);
+	priv->toolitem_autofit = toolitem;
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	gtk_widget_show(GTK_WIDGET(toolitem));
+
+
+	/* Fullscreen toggle */
+	toolitem = gtk_toggle_tool_button_new();
+	gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-fullscreen-symbolic");
+	rcw_set_tooltip(GTK_WIDGET(toolitem), _("Toggle fullscreen mode"),
+			remmina_pref.shortcutkey_fullscreen, 0);
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	gtk_widget_show(GTK_WIDGET(toolitem));
+	priv->toolitem_fullscreen = toolitem;
+	if (kioskmode) {
+		gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(toolitem), FALSE);
+	} else {
+		gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(toolitem), mode != SCROLLED_WINDOW_MODE);
+		g_signal_connect(G_OBJECT(toolitem), "clicked", G_CALLBACK(rcw_toolbar_fullscreen), cnnwin);
+	}
+
+	/* Fullscreen drop-down options */
+	toolitem = gtk_tool_item_new();
+	gtk_widget_show(GTK_WIDGET(toolitem));
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	widget = gtk_toggle_button_new();
+	gtk_widget_show(widget);
+	gtk_container_set_border_width(GTK_CONTAINER(widget), 0);
+	gtk_button_set_relief(GTK_BUTTON(widget), GTK_RELIEF_NONE);
+#if GTK_CHECK_VERSION(3, 20, 0)
+	gtk_widget_set_focus_on_click(GTK_WIDGET(widget), FALSE);
+	if (remmina_pref.small_toolbutton)
+		gtk_widget_set_name(widget, "remmina-small-button");
+
+#else
+	gtk_button_set_focus_on_click(GTK_BUTTON(widget), FALSE);
+#endif
+	gtk_container_add(GTK_CONTAINER(toolitem), widget);
+
+#if GTK_CHECK_VERSION(3, 14, 0)
+	arrow = gtk_image_new_from_icon_name("org.remmina.Remmina-pan-down-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR);
+#else
+	arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE);
+#endif
+	gtk_widget_show(arrow);
+	gtk_container_add(GTK_CONTAINER(widget), arrow);
+	g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(rcw_toolbar_fullscreen_option), cnnwin);
+	priv->fullscreen_option_button = widget;
+	if (mode == SCROLLED_WINDOW_MODE)
+		gtk_widget_set_sensitive(GTK_WIDGET(widget), FALSE);
+
+	/* Multi monitor */
+	if (n_monitors > 1) {
+		toolitem = gtk_toggle_tool_button_new();
+		gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-multi-monitor-symbolic");
+		rcw_set_tooltip(GTK_WIDGET(toolitem), _("Multi monitor"),
+				remmina_pref.shortcutkey_multimon, 0);
+		gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+		gtk_widget_show(GTK_WIDGET(toolitem));
+		g_signal_connect(G_OBJECT(toolitem), "toggled", G_CALLBACK(rcw_toolbar_multi_monitor_mode), cnnwin);
+		priv->toolitem_multimon = toolitem;
+		if (!cnnobj)
+			gtk_widget_set_sensitive(GTK_WIDGET(toolitem), FALSE);
+		else
+			gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(toolitem),
+							  remmina_file_get_int(cnnobj->remmina_file, "multimon", FALSE));
+	}
+
+	/* Dynamic Resolution Update */
+	toolitem = gtk_toggle_tool_button_new();
+	gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-dynres-symbolic");
+	rcw_set_tooltip(GTK_WIDGET(toolitem), _("Toggle dynamic resolution update"),
+			remmina_pref.shortcutkey_dynres, 0);
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	gtk_widget_show(GTK_WIDGET(toolitem));
+	g_signal_connect(G_OBJECT(toolitem), "toggled", G_CALLBACK(rcw_toolbar_dynres), cnnwin);
+	priv->toolitem_dynres = toolitem;
+
+	/* Scaler button */
+	toolitem = gtk_toggle_tool_button_new();
+	gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-scale-symbolic");
+	rcw_set_tooltip(GTK_WIDGET(toolitem), _("Toggle scaled mode"), remmina_pref.shortcutkey_scale, 0);
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	gtk_widget_show(GTK_WIDGET(toolitem));
+	g_signal_connect(G_OBJECT(toolitem), "toggled", G_CALLBACK(rcw_toolbar_scaled_mode), cnnwin);
+	priv->toolitem_scale = toolitem;
+
+	/* Scaler aspect ratio dropdown menu */
+	toolitem = gtk_tool_item_new();
+	gtk_widget_show(GTK_WIDGET(toolitem));
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	widget = gtk_toggle_button_new();
+	gtk_widget_show(widget);
+	gtk_container_set_border_width(GTK_CONTAINER(widget), 0);
+	gtk_button_set_relief(GTK_BUTTON(widget), GTK_RELIEF_NONE);
+#if GTK_CHECK_VERSION(3, 20, 0)
+	gtk_widget_set_focus_on_click(GTK_WIDGET(widget), FALSE);
+#else
+	gtk_button_set_focus_on_click(GTK_BUTTON(widget), FALSE);
+#endif
+	if (remmina_pref.small_toolbutton)
+		gtk_widget_set_name(widget, "remmina-small-button");
+	gtk_container_add(GTK_CONTAINER(toolitem), widget);
+#if GTK_CHECK_VERSION(3, 14, 0)
+	arrow = gtk_image_new_from_icon_name("org.remmina.Remmina-pan-down-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR);
+#else
+	arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE);
+#endif
+	gtk_widget_show(arrow);
+	gtk_container_add(GTK_CONTAINER(widget), arrow);
+	g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(rcw_toolbar_scaler_option), cnnwin);
+	priv->scaler_option_button = widget;
+
+	/* Separator */
+	toolitem = gtk_separator_tool_item_new();
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	gtk_widget_show(GTK_WIDGET(toolitem));
+
+	/* Switch tabs */
+	toolitem = gtk_toggle_tool_button_new();
+	gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-switch-page-symbolic");
+	rcw_set_tooltip(GTK_WIDGET(toolitem), _("Switch tab pages"), remmina_pref.shortcutkey_prevtab,
+			remmina_pref.shortcutkey_nexttab);
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	gtk_widget_show(GTK_WIDGET(toolitem));
+	g_signal_connect(G_OBJECT(toolitem), "toggled", G_CALLBACK(rcw_toolbar_switch_page), cnnwin);
+	priv->toolitem_switch_page = toolitem;
+
+	/* Grab keyboard button */
+	toolitem = gtk_toggle_tool_button_new();
+	gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-keyboard-symbolic");
+	rcw_set_tooltip(GTK_WIDGET(toolitem), _("Grab all keyboard events"),
+			remmina_pref.shortcutkey_grab, 0);
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	gtk_widget_show(GTK_WIDGET(toolitem));
+	g_signal_connect(G_OBJECT(toolitem), "toggled", G_CALLBACK(rcw_toolbar_grab), cnnwin);
+	priv->toolitem_grab = toolitem;
+	if (!cnnobj)
+		gtk_widget_set_sensitive(GTK_WIDGET(toolitem), FALSE);
+	else {
+		const gchar *protocol = remmina_file_get_string(cnnobj->remmina_file, "protocol");
+		if (g_strcmp0(protocol, "SFTP") == 0 || g_strcmp0(protocol, "SSH") == 0)
+			gtk_widget_set_sensitive(GTK_WIDGET(toolitem), FALSE);
+	}
+
+	/* Preferences */
+	toolitem = gtk_toggle_tool_button_new();
+	gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-preferences-system-symbolic");
+	gtk_tool_item_set_tooltip_text(toolitem, _("Preferences"));
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	gtk_widget_show(GTK_WIDGET(toolitem));
+	g_signal_connect(G_OBJECT(toolitem), "toggled", G_CALLBACK(rcw_toolbar_preferences), cnnwin);
+	priv->toolitem_preferences = toolitem;
+
+	/* Tools */
+	toolitem = gtk_toggle_tool_button_new();
+	gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-system-run-symbolic");
+	gtk_tool_button_set_label(GTK_TOOL_BUTTON(toolitem), _("_Tools"));
+	gtk_tool_item_set_tooltip_text(toolitem, _("Tools"));
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	gtk_widget_show(GTK_WIDGET(toolitem));
+	g_signal_connect(G_OBJECT(toolitem), "toggled", G_CALLBACK(rcw_toolbar_tools), cnnwin);
+	priv->toolitem_tools = toolitem;
+
+	/* Separator */
+	toolitem = gtk_separator_tool_item_new();
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	gtk_widget_show(GTK_WIDGET(toolitem));
+
+	toolitem = gtk_tool_button_new(NULL, "_Screenshot");
+	gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-camera-photo-symbolic");
+	rcw_set_tooltip(GTK_WIDGET(toolitem), _("Screenshot"), remmina_pref.shortcutkey_screenshot, 0);
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	gtk_widget_show(GTK_WIDGET(toolitem));
+	g_signal_connect(G_OBJECT(toolitem), "clicked", G_CALLBACK(rcw_toolbar_screenshot), cnnwin);
+	priv->toolitem_screenshot = toolitem;
+
+	/* Separator */
+	toolitem = gtk_separator_tool_item_new();
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	gtk_widget_show(GTK_WIDGET(toolitem));
+
+	/* Minimize */
+	toolitem = gtk_tool_button_new(NULL, "_Bottom");
+	gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-go-bottom-symbolic");
+	rcw_set_tooltip(GTK_WIDGET(toolitem), _("Minimize window"), remmina_pref.shortcutkey_minimize, 0);
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	gtk_widget_show(GTK_WIDGET(toolitem));
+	g_signal_connect(G_OBJECT(toolitem), "clicked", G_CALLBACK(rcw_toolbar_minimize), cnnwin);
+	if (kioskmode)
+		gtk_widget_set_sensitive(GTK_WIDGET(toolitem), FALSE);
+
+	/* Disconnect */
+	toolitem = gtk_tool_button_new(NULL, "_Disconnect");
+	gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-disconnect-symbolic");
+	rcw_set_tooltip(GTK_WIDGET(toolitem), _("Disconnect"), remmina_pref.shortcutkey_disconnect, 0);
+	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
+	gtk_widget_show(GTK_WIDGET(toolitem));
+	g_signal_connect(G_OBJECT(toolitem), "clicked", G_CALLBACK(rcw_toolbar_disconnect), cnnwin);
+
+	priv->toolbar_is_reconfiguring = FALSE;
+	return toolbar;
+}
+
+static void rcw_place_toolbar(GtkToolbar *toolbar, GtkGrid *grid, GtkWidget *sibling, int toolbar_placement)
+{
+	/* Place the toolbar inside the grid and set its orientation */
+
+	if (toolbar_placement == TOOLBAR_PLACEMENT_LEFT || toolbar_placement == TOOLBAR_PLACEMENT_RIGHT)
+		gtk_orientable_set_orientation(GTK_ORIENTABLE(toolbar), GTK_ORIENTATION_VERTICAL);
+	else
+		gtk_orientable_set_orientation(GTK_ORIENTABLE(toolbar), GTK_ORIENTATION_HORIZONTAL);
+
+
+	switch (toolbar_placement) {
+	case TOOLBAR_PLACEMENT_TOP:
+		gtk_widget_set_hexpand(GTK_WIDGET(toolbar), TRUE);
+		gtk_widget_set_vexpand(GTK_WIDGET(toolbar), FALSE);
+		gtk_grid_attach_next_to(GTK_GRID(grid), GTK_WIDGET(toolbar), sibling, GTK_POS_TOP, 1, 1);
+		break;
+	case TOOLBAR_PLACEMENT_RIGHT:
+		gtk_widget_set_vexpand(GTK_WIDGET(toolbar), TRUE);
+		gtk_widget_set_hexpand(GTK_WIDGET(toolbar), FALSE);
+		gtk_grid_attach_next_to(GTK_GRID(grid), GTK_WIDGET(toolbar), sibling, GTK_POS_RIGHT, 1, 1);
+		break;
+	case TOOLBAR_PLACEMENT_BOTTOM:
+		gtk_widget_set_hexpand(GTK_WIDGET(toolbar), TRUE);
+		gtk_widget_set_vexpand(GTK_WIDGET(toolbar), FALSE);
+		gtk_grid_attach_next_to(GTK_GRID(grid), GTK_WIDGET(toolbar), sibling, GTK_POS_BOTTOM, 1, 1);
+		break;
+	case TOOLBAR_PLACEMENT_LEFT:
+		gtk_widget_set_vexpand(GTK_WIDGET(toolbar), TRUE);
+		gtk_widget_set_hexpand(GTK_WIDGET(toolbar), FALSE);
+		gtk_grid_attach_next_to(GTK_GRID(grid), GTK_WIDGET(toolbar), sibling, GTK_POS_LEFT, 1, 1);
+		break;
+	}
+}
+
+static void rco_update_toolbar(RemminaConnectionObject *cnnobj)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv = cnnobj->cnnwin->priv;
+	GtkToolItem *toolitem;
+	gboolean bval, dynres_avail, scale_avail;
+	gboolean test_floating_toolbar;
+	RemminaScaleMode scalemode;
+
+	priv->toolbar_is_reconfiguring = TRUE;
+
+	rco_update_toolbar_autofit_button(cnnobj);
+
+	toolitem = priv->toolitem_switch_page;
+	if (kioskmode)
+		bval = FALSE;
+	else
+		bval = (gtk_notebook_get_n_pages(GTK_NOTEBOOK(priv->notebook)) > 1);
+	gtk_widget_set_sensitive(GTK_WIDGET(toolitem), bval);
+
+	if (cnnobj->remmina_file->filename)
+		gtk_widget_set_sensitive(GTK_WIDGET(priv->toolitem_duplicate), TRUE);
+	else
+		gtk_widget_set_sensitive(GTK_WIDGET(priv->toolitem_duplicate), FALSE);
+
+	scalemode = get_current_allowed_scale_mode(cnnobj, &dynres_avail, &scale_avail);
+	gtk_widget_set_sensitive(GTK_WIDGET(priv->toolitem_dynres), dynres_avail && cnnobj->connected);
+	gtk_widget_set_sensitive(GTK_WIDGET(priv->toolitem_scale), scale_avail && cnnobj->connected);
+
+	switch (scalemode) {
+	case REMMINA_PROTOCOL_WIDGET_SCALE_MODE_NONE:
+		gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_dynres), FALSE);
+		gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_scale), FALSE);
+		gtk_widget_set_sensitive(GTK_WIDGET(priv->scaler_option_button), FALSE);
+		break;
+	case REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED:
+		gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_dynres), FALSE);
+		gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_scale), TRUE);
+		gtk_widget_set_sensitive(GTK_WIDGET(priv->scaler_option_button), TRUE && cnnobj->connected);
+		break;
+	case REMMINA_PROTOCOL_WIDGET_SCALE_MODE_DYNRES:
+		gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_dynres), TRUE);
+		gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_scale), FALSE);
+		gtk_widget_set_sensitive(GTK_WIDGET(priv->scaler_option_button), FALSE);
+		break;
+	}
+
+	/* REMMINA_PROTOCOL_FEATURE_TYPE_MULTIMON */
+	toolitem = priv->toolitem_multimon;
+	if (toolitem) {
+		gint hasmultimon = remmina_protocol_widget_query_feature_by_type(REMMINA_PROTOCOL_WIDGET(cnnobj->proto),
+										 REMMINA_PROTOCOL_FEATURE_TYPE_MULTIMON);
+
+		gtk_widget_set_sensitive(GTK_WIDGET(toolitem), cnnobj->connected);
+		gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(toolitem),
+						  remmina_file_get_int(cnnobj->remmina_file, "multimon", FALSE));
+		gtk_widget_set_sensitive(GTK_WIDGET(toolitem), hasmultimon);
+	}
+
+	toolitem = priv->toolitem_grab;
+	gtk_widget_set_sensitive(GTK_WIDGET(toolitem), cnnobj->connected);
+	gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(toolitem),
+					  remmina_file_get_int(cnnobj->remmina_file, "keyboard_grab", FALSE));
+	const gchar *protocol = remmina_file_get_string(cnnobj->remmina_file, "protocol");
+	if (g_strcmp0(protocol, "SFTP") == 0 || g_strcmp0(protocol, "SSH") == 0) {
+		gtk_widget_set_sensitive(GTK_WIDGET(toolitem), FALSE);
+		gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(toolitem), FALSE);
+		remmina_file_set_int(cnnobj->remmina_file, "keyboard_grab", FALSE);
+	}
+
+	toolitem = priv->toolitem_preferences;
+	gtk_widget_set_sensitive(GTK_WIDGET(toolitem), cnnobj->connected);
+	bval = remmina_protocol_widget_query_feature_by_type(REMMINA_PROTOCOL_WIDGET(cnnobj->proto),
+							     REMMINA_PROTOCOL_FEATURE_TYPE_PREF);
+	gtk_widget_set_sensitive(GTK_WIDGET(toolitem), bval && cnnobj->connected);
+
+	toolitem = priv->toolitem_tools;
+	bval = remmina_protocol_widget_query_feature_by_type(REMMINA_PROTOCOL_WIDGET(cnnobj->proto),
+							     REMMINA_PROTOCOL_FEATURE_TYPE_TOOL);
+	gtk_widget_set_sensitive(GTK_WIDGET(toolitem), bval && cnnobj->connected);
+
+	gtk_widget_set_sensitive(GTK_WIDGET(priv->toolitem_screenshot), cnnobj->connected);
+
+	gtk_window_set_title(GTK_WINDOW(cnnobj->cnnwin), remmina_file_get_string(cnnobj->remmina_file, "name"));
+
+	test_floating_toolbar = (priv->floating_toolbar_widget != NULL);
+
+	if (test_floating_toolbar) {
+		const gchar *str = remmina_file_get_string(cnnobj->remmina_file, "name");
+		const gchar *format;
+		GdkRGBA rgba;
+		gchar *bg;
+
+		bg = g_strdup(remmina_pref.grab_color);
+		if (!gdk_rgba_parse(&rgba, bg)) {
+			REMMINA_DEBUG("%s cannot be parsed as a color", bg);
+			bg = g_strdup("#00FF00");
+		} else {
+			REMMINA_DEBUG("Using %s as background color", bg);
+		}
+
+		if (remmina_file_get_int(cnnobj->remmina_file, "keyboard_grab", FALSE)) {
+			if (remmina_pref_get_boolean("grab_color_switch")) {
+				gtk_widget_override_background_color(priv->overlay_ftb_fr, GTK_STATE_NORMAL, &rgba);
+				format = g_strconcat("<span bgcolor=\"", bg, "\" size=\"large\"><b>(G: ON) - \%s</b></span>", NULL);
+			} else {
+				gtk_widget_override_background_color(priv->overlay_ftb_fr, GTK_STATE_NORMAL, NULL);
+				format = "<big><b>(G: ON) - \%s</b></big>";
+			}
+		} else {
+			gtk_widget_override_background_color(priv->overlay_ftb_fr, GTK_STATE_NORMAL, NULL);
+			format = "<big><b>(G:OFF) - \%s</b></big>";
+		}
+		gchar *markup;
+
+		markup = g_markup_printf_escaped(format, str);
+		gtk_label_set_markup(GTK_LABEL(priv->floating_toolbar_label), markup);
+		g_free(markup);
+		g_free(bg);
+	}
+
+	priv->toolbar_is_reconfiguring = FALSE;
+}
+
+static void rcw_set_toolbar_visibility(RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv = cnnwin->priv;
+
+	if (priv->view_mode == SCROLLED_WINDOW_MODE) {
+		if (remmina_pref.hide_connection_toolbar)
+			gtk_widget_hide(priv->toolbar);
+		else
+			gtk_widget_show(priv->toolbar);
+	}
+}
+
+#if DEBUG_KB_GRABBING
+static void print_crossing_event(GdkEventCrossing *event) {
+	printf("DEBUG_KB_GRABBING: --- Crossing event detail: ");
+	switch (event->detail) {
+	case GDK_NOTIFY_ANCESTOR: printf("GDK_NOTIFY_ANCESTOR"); break;
+	case GDK_NOTIFY_VIRTUAL: printf("GDK_NOTIFY_VIRTUAL"); break;
+	case GDK_NOTIFY_NONLINEAR: printf("GDK_NOTIFY_NONLINEAR"); break;
+	case GDK_NOTIFY_NONLINEAR_VIRTUAL: printf("GDK_NOTIFY_NONLINEAR_VIRTUAL"); break;
+	case GDK_NOTIFY_UNKNOWN: printf("GDK_NOTIFY_UNKNOWN"); break;
+	case GDK_NOTIFY_INFERIOR: printf("GDK_NOTIFY_INFERIOR"); break;
+	default: printf("unknown");
+	}
+	printf("\n");
+	printf("DEBUG_KB_GRABBING: --- Crossing event mode=");
+	switch (event->mode) {
+	case GDK_CROSSING_NORMAL: printf("GDK_CROSSING_NORMAL"); break;
+	case GDK_CROSSING_GRAB: printf("GDK_CROSSING_GRAB"); break;
+	case GDK_CROSSING_UNGRAB: printf("GDK_CROSSING_UNGRAB"); break;
+	case GDK_CROSSING_GTK_GRAB: printf("GDK_CROSSING_GTK_GRAB"); break;
+	case GDK_CROSSING_GTK_UNGRAB: printf("GDK_CROSSING_GTK_UNGRAB"); break;
+	case GDK_CROSSING_STATE_CHANGED: printf("GDK_CROSSING_STATE_CHANGED"); break;
+	case GDK_CROSSING_TOUCH_BEGIN: printf("GDK_CROSSING_TOUCH_BEGIN"); break;
+	case GDK_CROSSING_TOUCH_END: printf("GDK_CROSSING_TOUCH_END"); break;
+	case GDK_CROSSING_DEVICE_SWITCH: printf("GDK_CROSSING_DEVICE_SWITCH"); break;
+	default: printf("unknown");
+	}
+	printf("\n");
+}
+#endif
+
+static gboolean rcw_floating_toolbar_on_enter(GtkWidget *widget, GdkEventCrossing *event,
+					      RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	rcw_floating_toolbar_show(cnnwin, TRUE);
+	return TRUE;
+}
+
+static gboolean rcw_floating_toolbar_on_leave(GtkWidget *widget, GdkEventCrossing *event,
+					      RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	if (event->detail != GDK_NOTIFY_INFERIOR)
+		rcw_floating_toolbar_show(cnnwin, FALSE);
+	return TRUE;
+}
+
+
+static gboolean rcw_on_enter_notify_event(GtkWidget *widget, GdkEventCrossing *event,
+					  gpointer user_data)
+{
+	TRACE_CALL(__func__);
+#if DEBUG_KB_GRABBING
+	printf("DEBUG_KB_GRABBING: enter-notify-event on rcw received\n");
+	print_crossing_event(event);
+#endif
+	return FALSE;
+}
+
+
+
+static gboolean rcw_on_leave_notify_event(GtkWidget *widget, GdkEventCrossing *event,
+					  gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindow *cnnwin = (RemminaConnectionWindow *)widget;
+
+#if DEBUG_KB_GRABBING
+	printf("DEBUG_KB_GRABBING: leave-notify-event on rcw received\n");
+	print_crossing_event(event);
+#endif
+
+	if (event->mode != GDK_CROSSING_NORMAL && event->mode != GDK_CROSSING_UNGRAB) {
+#if DEBUG_KB_GRABBING
+	printf("DEBUG_KB_GRABBING:   ignored because mode is not GDK_CROSSING_NORMAL GDK_CROSSING_UNGRAB\n");
+#endif
+		return FALSE;
+	}
+
+	if (cnnwin->priv->delayed_grab_eventsourceid) {
+		g_source_remove(cnnwin->priv->delayed_grab_eventsourceid);
+		cnnwin->priv->delayed_grab_eventsourceid = 0;
+	}
+
+	/* Workaround for https://gitlab.gnome.org/GNOME/mutter/-/issues/2450#note_1586570 */
+	if (event->mode != GDK_CROSSING_UNGRAB) {
+		rcw_kp_ungrab(cnnwin);
+		rcw_pointer_ungrab(cnnwin);
+	} else {
+#if DEBUG_KB_GRABBING
+		printf("DEBUG_KB_GRABBING:   not ungrabbing, this event seems to be an unwanted event from GTK\n");
+#endif
+	}
+
+	return FALSE;
+}
+
+
+static gboolean rco_leave_protocol_widget(GtkWidget *widget, GdkEventCrossing *event,
+					  RemminaConnectionObject *cnnobj)
+{
+	TRACE_CALL(__func__);
+
+#if DEBUG_KB_GRABBING
+	printf("DEBUG_KB_GRABBING: received leave event on RCO.\n");
+	print_crossing_event(event);
+#endif
+
+	if (cnnobj->cnnwin->priv->delayed_grab_eventsourceid) {
+		g_source_remove(cnnobj->cnnwin->priv->delayed_grab_eventsourceid);
+		cnnobj->cnnwin->priv->delayed_grab_eventsourceid = 0;
+	}
+
+	cnnobj->cnnwin->priv->pointer_entered = FALSE;
+
+	/* Ungrab only if the leave is due to normal mouse motion and not to an inferior */
+	if (event->mode == GDK_CROSSING_NORMAL && event->detail != GDK_NOTIFY_INFERIOR)
+		rcw_kp_ungrab(cnnobj->cnnwin);
+
+	return FALSE;
+}
+
+
+gboolean rco_enter_protocol_widget(GtkWidget *widget, GdkEventCrossing *event,
+				   RemminaConnectionObject *cnnobj)
+{
+	TRACE_CALL(__func__);
+	gboolean active;
+
+#if DEBUG_KB_GRABBING
+	printf("DEBUG_KB_GRABBING: %s: enter on protocol widget event received\n", __func__);
+	print_crossing_event(event);
+#endif
+
+	RemminaConnectionWindowPriv *priv = cnnobj->cnnwin->priv;
+	if (!priv->sticky && event->mode == GDK_CROSSING_NORMAL)
+		rcw_floating_toolbar_show(cnnobj->cnnwin, FALSE);
+
+	priv->pointer_entered = TRUE;
+
+	if (event->mode == GDK_CROSSING_UNGRAB) {
+		// Someone steal our grab, take note and do not attempt to regrab
+		cnnobj->cnnwin->priv->kbcaptured = FALSE;
+		cnnobj->cnnwin->priv->pointer_captured = FALSE;
+		return FALSE;
+	}
+
+	/* Check if we need grabbing */
+	active = gtk_window_is_active(GTK_WINDOW(cnnobj->cnnwin));
+	if (remmina_file_get_int(cnnobj->remmina_file, "keyboard_grab", FALSE) && active) {
+		rcw_keyboard_grab(cnnobj->cnnwin);
+		rcw_pointer_grab(cnnobj->cnnwin);
+	}
+
+	return FALSE;
+}
+
+static gboolean focus_in_delayed_grab(RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+
+#if DEBUG_KB_GRABBING
+	printf("DEBUG_KB_GRABBING:   %s\n", __func__);
+#endif
+	if (cnnwin->priv->pointer_entered) {
+#if DEBUG_KB_GRABBING
+		printf("DEBUG_KB_GRABBING:   delayed requesting kb and pointer grab, because of pointer inside\n");
+#endif
+		rcw_keyboard_grab(cnnwin);
+		rcw_pointer_grab(cnnwin);
+	}
+#if DEBUG_KB_GRABBING
+	else {
+		printf("DEBUG_KB_GRABBING:   %s not grabbing because pointer_entered is false\n", __func__);
+	}
+#endif
+	cnnwin->priv->delayed_grab_eventsourceid = 0;
+	return G_SOURCE_REMOVE;
+}
+
+static void rcw_focus_in(RemminaConnectionWindow *cnnwin)
+{
+	/* This function is the default signal handler for focus-in-event,
+	 * but can also be called after a window focus state change event
+	 * from rcw_state_event(). So expect to be called twice
+	 * when cnnwin gains the focus */
+
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj;
+
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+
+	if (cnnobj && cnnobj->connected && remmina_file_get_int(cnnobj->remmina_file, "keyboard_grab", FALSE)) {
+#if DEBUG_KB_GRABBING
+		printf("DEBUG_KB_GRABBING: Received focus in on rcw, grabbing enabled: requesting kb grab, delayed\n");
+#endif
+		if (cnnwin->priv->delayed_grab_eventsourceid == 0)
+			cnnwin->priv->delayed_grab_eventsourceid = g_timeout_add(300, (GSourceFunc)focus_in_delayed_grab, cnnwin);
+	}
+#if DEBUG_KB_GRABBING
+	else {
+		printf("DEBUG_KB_GRABBING: Received focus in on rcw, but a condition will prevent to grab\n");
+	}
+#endif
+}
+
+static void rcw_focus_out(RemminaConnectionWindow *cnnwin)
+{
+	/* This function is the default signal handler for focus-out-event,
+	 * but can also be called after a window focus state change event
+	 * from rcw_state_event(). So expect to be called twice
+	 * when cnnwin loses the focus */
+
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj;
+
+	rcw_kp_ungrab(cnnwin);
+
+	cnnwin->priv->hostkey_activated = FALSE;
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+
+	if (REMMINA_IS_SCROLLED_VIEWPORT(cnnobj->scrolled_container))
+		remmina_scrolled_viewport_remove_motion(REMMINA_SCROLLED_VIEWPORT(cnnobj->scrolled_container));
+
+	if (cnnobj->proto && cnnobj->scrolled_container)
+		remmina_protocol_widget_call_feature_by_type(REMMINA_PROTOCOL_WIDGET(cnnobj->proto),
+							     REMMINA_PROTOCOL_FEATURE_TYPE_UNFOCUS, 0);
+}
+
+static gboolean
+rcw_floating_toolbar_hide(RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv = cnnwin->priv;
+
+	priv->hidetb_eventsource = 0;
+	rcw_floating_toolbar_show(cnnwin, FALSE);
+	return G_SOURCE_REMOVE;
+}
+
+static gboolean rcw_floating_toolbar_on_scroll(GtkWidget *widget, GdkEventScroll *event,
+					       RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj;
+
+	int opacity;
+
+	cnnobj = rcw_get_visible_cnnobj(cnnwin);
+	if (!cnnobj)
+		return TRUE;
+
+	opacity = remmina_file_get_int(cnnobj->remmina_file, "toolbar_opacity", 0);
+	switch (event->direction) {
+	case GDK_SCROLL_UP:
+		if (opacity > 0) {
+			remmina_file_set_int(cnnobj->remmina_file, "toolbar_opacity", opacity - 1);
+			rcw_update_toolbar_opacity(cnnwin);
+			return TRUE;
+		}
+		break;
+	case GDK_SCROLL_DOWN:
+		if (opacity < TOOLBAR_OPACITY_LEVEL) {
+			remmina_file_set_int(cnnobj->remmina_file, "toolbar_opacity", opacity + 1);
+			rcw_update_toolbar_opacity(cnnwin);
+			return TRUE;
+		}
+		break;
+#if GTK_CHECK_VERSION(3, 4, 0)
+	case GDK_SCROLL_SMOOTH:
+		if (event->delta_y < 0 && opacity > 0) {
+			remmina_file_set_int(cnnobj->remmina_file, "toolbar_opacity", opacity - 1);
+			rcw_update_toolbar_opacity(cnnwin);
+			return TRUE;
+		}
+		if (event->delta_y > 0 && opacity < TOOLBAR_OPACITY_LEVEL) {
+			remmina_file_set_int(cnnobj->remmina_file, "toolbar_opacity", opacity + 1);
+			rcw_update_toolbar_opacity(cnnwin);
+			return TRUE;
+		}
+		break;
+#endif
+	default:
+		break;
+	}
+	return TRUE;
+}
+
+static gboolean rcw_after_configure_scrolled(gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gint width, height;
+	GdkWindowState s;
+	gint ipg, npages;
+	RemminaConnectionWindow *cnnwin;
+
+	cnnwin = (RemminaConnectionWindow *)user_data;
+
+	if (!cnnwin || !cnnwin->priv)
+		return FALSE;
+
+	s = gdk_window_get_state(gtk_widget_get_window(GTK_WIDGET(cnnwin)));
+
+
+	/* Changed window_maximize, window_width and window_height for all
+	 * connections inside the notebook */
+	npages = gtk_notebook_get_n_pages(GTK_NOTEBOOK(cnnwin->priv->notebook));
+	for (ipg = 0; ipg < npages; ipg++) {
+		RemminaConnectionObject *cnnobj;
+		cnnobj = g_object_get_data(
+			G_OBJECT(gtk_notebook_get_nth_page(GTK_NOTEBOOK(cnnwin->priv->notebook), ipg)),
+			"cnnobj");
+		if (s & GDK_WINDOW_STATE_MAXIMIZED) {
+			remmina_file_set_int(cnnobj->remmina_file, "window_maximize", TRUE);
+		} else {
+			gtk_window_get_size(GTK_WINDOW(cnnobj->cnnwin), &width, &height);
+			remmina_file_set_int(cnnobj->remmina_file, "window_width", width);
+			remmina_file_set_int(cnnobj->remmina_file, "window_height", height);
+			remmina_file_set_int(cnnobj->remmina_file, "window_maximize", FALSE);
+		}
+	}
+	cnnwin->priv->acs_eventsourceid = 0;
+	return FALSE;
+}
+
+static gboolean rcw_on_configure(GtkWidget *widget, GdkEventConfigure *event,
+				 gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindow *cnnwin;
+	RemminaConnectionObject *cnnobj;
+
+	if (!REMMINA_IS_CONNECTION_WINDOW(widget))
+		return FALSE;
+
+	cnnwin = (RemminaConnectionWindow *)widget;
+
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return FALSE;
+
+	if (cnnwin->priv->acs_eventsourceid) {
+		g_source_remove(cnnwin->priv->acs_eventsourceid);
+		cnnwin->priv->acs_eventsourceid = 0;
+	}
+
+	if (gtk_widget_get_window(GTK_WIDGET(cnnwin))
+	    && cnnwin->priv->view_mode == SCROLLED_WINDOW_MODE)
+		/* Under GNOME Shell we receive this configure_event BEFORE a window
+		 * is really unmaximized, so we must read its new state and dimensions
+		 * later, not now */
+		cnnwin->priv->acs_eventsourceid = g_timeout_add(500, rcw_after_configure_scrolled, cnnwin);
+
+	if (cnnwin->priv->view_mode != SCROLLED_WINDOW_MODE)
+		/* Notify window of change so that scroll border can be hidden or shown if needed */
+		rco_check_resize(cnnobj);
+	return FALSE;
+}
+
+static void rcw_update_pin(RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	if (cnnwin->priv->pin_down)
+		gtk_button_set_image(GTK_BUTTON(cnnwin->priv->pin_button),
+				     gtk_image_new_from_icon_name("org.remmina.Remmina-pin-down-symbolic", GTK_ICON_SIZE_MENU));
+	else
+		gtk_button_set_image(GTK_BUTTON(cnnwin->priv->pin_button),
+				     gtk_image_new_from_icon_name("org.remmina.Remmina-pin-up-symbolic", GTK_ICON_SIZE_MENU));
+}
+
+static void rcw_toolbar_pin(GtkWidget *widget, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	remmina_pref.toolbar_pin_down = cnnwin->priv->pin_down = !cnnwin->priv->pin_down;
+	remmina_pref_save();
+	rcw_update_pin(cnnwin);
+}
+
+static void rcw_create_floating_toolbar(RemminaConnectionWindow *cnnwin, gint mode)
+{
+	TRACE_CALL(__func__);
+
+	RemminaConnectionWindowPriv *priv = cnnwin->priv;
+	GtkWidget *ftb_widget;
+	GtkWidget *vbox;
+	GtkWidget *hbox;
+	GtkWidget *label;
+	GtkWidget *pinbutton;
+	GtkWidget *tb;
+
+
+	/* A widget to be used for GtkOverlay for GTK >= 3.10 */
+	ftb_widget = gtk_event_box_new();
+
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+	gtk_widget_show(vbox);
+
+	gtk_container_add(GTK_CONTAINER(ftb_widget), vbox);
+
+	tb = rcw_create_toolbar(cnnwin, mode);
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+	gtk_widget_show(hbox);
+
+
+	/* The pin button */
+	pinbutton = gtk_button_new();
+	gtk_widget_show(pinbutton);
+	gtk_box_pack_start(GTK_BOX(hbox), pinbutton, FALSE, FALSE, 0);
+	gtk_button_set_relief(GTK_BUTTON(pinbutton), GTK_RELIEF_NONE);
+#if GTK_CHECK_VERSION(3, 20, 0)
+	gtk_widget_set_focus_on_click(GTK_WIDGET(pinbutton), FALSE);
+#else
+	gtk_button_set_focus_on_click(GTK_BUTTON(pinbutton), FALSE);
+#endif
+	gtk_widget_set_name(pinbutton, "remmina-pin-button");
+	g_signal_connect(G_OBJECT(pinbutton), "clicked", G_CALLBACK(rcw_toolbar_pin), cnnwin);
+	priv->pin_button = pinbutton;
+	priv->pin_down = remmina_pref.toolbar_pin_down;
+	rcw_update_pin(cnnwin);
+
+
+	label = gtk_label_new("");
+	gtk_label_set_max_width_chars(GTK_LABEL(label), 50);
+	gtk_widget_show(label);
+
+	gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
+
+	priv->floating_toolbar_label = label;
+
+	if (remmina_pref.floating_toolbar_placement == FLOATING_TOOLBAR_PLACEMENT_BOTTOM) {
+		gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
+		gtk_box_pack_start(GTK_BOX(vbox), tb, FALSE, FALSE, 0);
+	} else {
+		gtk_box_pack_start(GTK_BOX(vbox), tb, FALSE, FALSE, 0);
+		gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
+	}
+
+	priv->floating_toolbar_widget = ftb_widget;
+	gtk_widget_show(ftb_widget);
+}
+
+static void rcw_toolbar_place_signal(RemminaConnectionWindow *cnnwin, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv;
+
+	priv = cnnwin->priv;
+	/* Detach old toolbar widget and reattach in new position in the grid */
+	if (priv->toolbar && priv->grid) {
+		g_object_ref(priv->toolbar);
+		gtk_container_remove(GTK_CONTAINER(priv->grid), priv->toolbar);
+		rcw_place_toolbar(GTK_TOOLBAR(priv->toolbar), GTK_GRID(priv->grid), GTK_WIDGET(priv->notebook), remmina_pref.toolbar_placement);
+		g_object_unref(priv->toolbar);
+	}
+}
+
+
+static void rcw_init(RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv;
+
+	priv = g_new0(RemminaConnectionWindowPriv, 1);
+	cnnwin->priv = priv;
+
+	priv->view_mode = SCROLLED_WINDOW_MODE;
+	if (kioskmode && kioskmode == TRUE)
+		priv->view_mode = VIEWPORT_FULLSCREEN_MODE;
+
+	priv->floating_toolbar_opacity = 1.0;
+	priv->kbcaptured = FALSE;
+	priv->pointer_captured = FALSE;
+	priv->pointer_entered = FALSE;
+	priv->fss_view_mode = VIEWPORT_FULLSCREEN_MODE;
+	priv->ss_width = 640;
+	priv->ss_height = 480;
+	priv->ss_maximized = FALSE;
+
+	remmina_widget_pool_register(GTK_WIDGET(cnnwin));
+}
+
+static gboolean rcw_focus_in_event(GtkWidget *widget, GdkEventWindowState *event, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+#if DEBUG_KB_GRABBING
+	printf("DEBUG_KB_GRABBING: RCW focus-in-event received\n");
+#endif
+	rcw_focus_in((RemminaConnectionWindow *)widget);
+	return FALSE;
+}
+
+static gboolean rcw_focus_out_event(GtkWidget *widget, GdkEventWindowState *event, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+#if DEBUG_KB_GRABBING
+	printf("DEBUG_KB_GRABBING: RCW focus-out-event received\n");
+#endif
+	rcw_focus_out((RemminaConnectionWindow *)widget);
+	return FALSE;
+}
+
+
+static gboolean rcw_state_event(GtkWidget *widget, GdkEventWindowState *event, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+
+	if (!REMMINA_IS_CONNECTION_WINDOW(widget))
+		return FALSE;
+
+#if DEBUG_KB_GRABBING
+	printf("DEBUG_KB_GRABBING: window-state-event received\n");
+#endif
+
+	if (event->changed_mask & GDK_WINDOW_STATE_FOCUSED) {
+		if (event->new_window_state & GDK_WINDOW_STATE_FOCUSED)
+			rcw_focus_in((RemminaConnectionWindow *)widget);
+		else
+			rcw_focus_out((RemminaConnectionWindow *)widget);
+	}
+
+	return FALSE;
+}
+
+static gboolean rcw_map_event(GtkWidget *widget, GdkEvent *event, gpointer data)
+{
+	TRACE_CALL(__func__);
+
+
+
+	RemminaConnectionWindow *cnnwin = (RemminaConnectionWindow *)widget;
+	RemminaConnectionObject *cnnobj;
+	RemminaProtocolWidget *gp;
+
+	if (cnnwin->priv->toolbar_is_reconfiguring) return FALSE;
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return FALSE;
+
+	gp = REMMINA_PROTOCOL_WIDGET(cnnobj->proto);
+	REMMINA_DEBUG("Mapping: %s", gtk_widget_get_name(widget));
+	if (remmina_protocol_widget_map_event(gp))
+		REMMINA_DEBUG("Called plugin mapping function");
+	return FALSE;
+}
+
+static gboolean rcw_unmap_event(GtkWidget *widget, GdkEvent *event, gpointer data)
+{
+	TRACE_CALL(__func__);
+
+	RemminaConnectionWindow *cnnwin = (RemminaConnectionWindow *)widget;
+	RemminaConnectionObject *cnnobj;
+	RemminaProtocolWidget *gp;
+
+	if (cnnwin->priv->toolbar_is_reconfiguring) return FALSE;
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return FALSE;
+
+	gp = REMMINA_PROTOCOL_WIDGET(cnnobj->proto);
+	REMMINA_DEBUG("Unmapping: %s", gtk_widget_get_name(widget));
+	if (remmina_protocol_widget_unmap_event(gp))
+		REMMINA_DEBUG("Called plugin mapping function");
+	return FALSE;
+}
+
+static gboolean rcw_map_event_fullscreen(GtkWidget *widget, GdkEvent *event, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj;
+	gint target_monitor;
+
+	REMMINA_DEBUG("Mapping: %s", gtk_widget_get_name(widget));
+
+	if (!REMMINA_IS_CONNECTION_WINDOW(widget)) {
+		REMMINA_DEBUG("Remmina Connection Window undefined, cannot go fullscreen");
+		return FALSE;
+	}
+
+	//RemminaConnectionWindow *cnnwin = (RemminaConnectionWindow *)data;
+	cnnobj = rcw_get_visible_cnnobj((RemminaConnectionWindow *)widget);
+	//cnnobj = g_object_get_data(G_OBJECT(widget), "cnnobj");
+	if (!cnnobj) {
+		REMMINA_DEBUG("Remmina Connection Object undefined, cannot go fullscreen");
+		return FALSE;
+	}
+
+	RemminaProtocolWidget *gp = REMMINA_PROTOCOL_WIDGET(cnnobj->proto);
+
+	if (!gp)
+		REMMINA_DEBUG("Remmina Protocol Widget undefined, cannot go fullscreen");
+
+	if (remmina_protocol_widget_get_multimon(gp) >= 1) {
+		REMMINA_DEBUG("Fullscreen on all monitor");
+		gdk_window_set_fullscreen_mode(gtk_widget_get_window(widget), GDK_FULLSCREEN_ON_ALL_MONITORS);
+		gdk_window_fullscreen(gtk_widget_get_window(widget));
+		return TRUE;
+	} else {
+		REMMINA_DEBUG("Fullscreen on one monitor");
+	}
+
+	target_monitor = GPOINTER_TO_INT(data);
+
+#if GTK_CHECK_VERSION(3, 18, 0)
+	if (remmina_pref.fullscreen_on_auto) {
+		if (target_monitor == FULL_SCREEN_TARGET_MONITOR_UNDEFINED)
+			gtk_window_fullscreen(GTK_WINDOW(widget));
+		else
+			gtk_window_fullscreen_on_monitor(GTK_WINDOW(widget), gtk_window_get_screen(GTK_WINDOW(widget)),
+							 target_monitor);
+	} else {
+		REMMINA_DEBUG("Fullscreen managed by WM or by the user, as per settings");
+		gtk_window_fullscreen(GTK_WINDOW(widget));
+	}
+#else
+	REMMINA_DEBUG("Cannot fullscreen on a specific monitor, feature available from GTK 3.18");
+	gtk_window_fullscreen(GTK_WINDOW(widget));
+#endif
+
+	if (remmina_protocol_widget_map_event(gp))
+		REMMINA_DEBUG("Called plugin mapping function");
+
+	return FALSE;
+}
+
+static RemminaConnectionWindow *
+rcw_new(gboolean fullscreen, int full_screen_target_monitor)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindow *cnnwin;
+
+	cnnwin = RCW(g_object_new(REMMINA_TYPE_CONNECTION_WINDOW, NULL));
+	cnnwin->priv->on_delete_confirm_mode = RCW_ONDELETE_CONFIRM_IF_2_OR_MORE;
+
+	if (fullscreen)
+		/* Put the window in fullscreen after it is mapped to have it appear on the same monitor */
+		g_signal_connect(G_OBJECT(cnnwin), "map-event", G_CALLBACK(rcw_map_event_fullscreen), GINT_TO_POINTER(full_screen_target_monitor));
+	else
+		g_signal_connect(G_OBJECT(cnnwin), "map-event", G_CALLBACK(rcw_map_event), NULL);
+	g_signal_connect(G_OBJECT(cnnwin), "unmap-event", G_CALLBACK(rcw_unmap_event), NULL);
+
+	gtk_container_set_border_width(GTK_CONTAINER(cnnwin), 0);
+	g_signal_connect(G_OBJECT(cnnwin), "toolbar-place", G_CALLBACK(rcw_toolbar_place_signal), NULL);
+
+	g_signal_connect(G_OBJECT(cnnwin), "delete-event", G_CALLBACK(rcw_delete_event), NULL);
+	g_signal_connect(G_OBJECT(cnnwin), "destroy", G_CALLBACK(rcw_destroy), NULL);
+
+	/* Under Xorg focus-in-event and focus-out-event don’t work when keyboard is grabbed
+	 * via gdk_device_grab. So we listen for window-state-event to detect focus in and focus out.
+	 * But we must also listen focus-in-event and focus-out-event because some
+	 * window managers missing _NET_WM_STATE_FOCUSED hint, does not update the window state
+	 * in case of focus change */
+	g_signal_connect(G_OBJECT(cnnwin), "window-state-event", G_CALLBACK(rcw_state_event), NULL);
+	g_signal_connect(G_OBJECT(cnnwin), "focus-in-event", G_CALLBACK(rcw_focus_in_event), NULL);
+	g_signal_connect(G_OBJECT(cnnwin), "focus-out-event", G_CALLBACK(rcw_focus_out_event), NULL);
+
+	g_signal_connect(G_OBJECT(cnnwin), "enter-notify-event", G_CALLBACK(rcw_on_enter_notify_event), NULL);
+	g_signal_connect(G_OBJECT(cnnwin), "leave-notify-event", G_CALLBACK(rcw_on_leave_notify_event), NULL);
+
+
+	g_signal_connect(G_OBJECT(cnnwin), "configure_event", G_CALLBACK(rcw_on_configure), NULL);
+
+	return cnnwin;
+}
+
+/* This function will be called for the first connection. A tag is set to the window so that
+ * other connections can determine if whether a new tab should be append to the same window
+ */
+static void rcw_update_tag(RemminaConnectionWindow *cnnwin, RemminaConnectionObject *cnnobj)
+{
+	TRACE_CALL(__func__);
+	gchar *tag;
+
+	switch (remmina_pref.tab_mode) {
+	case REMMINA_TAB_BY_GROUP:
+		tag = g_strdup(remmina_file_get_string(cnnobj->remmina_file, "group"));
+		break;
+	case REMMINA_TAB_BY_PROTOCOL:
+		tag = g_strdup(remmina_file_get_string(cnnobj->remmina_file, "protocol"));
+		break;
+	default:
+		tag = NULL;
+		break;
+	}
+	g_object_set_data_full(G_OBJECT(cnnwin), "tag", tag, (GDestroyNotify)g_free);
+}
+
+void rcw_grab_focus(RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj;
+
+	if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return;
+
+	if (GTK_IS_WIDGET(cnnobj->proto))
+		remmina_protocol_widget_grab_focus(REMMINA_PROTOCOL_WIDGET(cnnobj->proto));
+}
+
+static GtkWidget *nb_find_page_by_cnnobj(GtkNotebook *notebook, RemminaConnectionObject *cnnobj)
+{
+	gint i, np;
+	GtkWidget *found_page, *pg;
+
+	if (cnnobj == NULL || cnnobj->cnnwin == NULL || cnnobj->cnnwin->priv == NULL)
+		return NULL;
+	found_page = NULL;
+	np = gtk_notebook_get_n_pages(cnnobj->cnnwin->priv->notebook);
+	for (i = 0; i < np; i++) {
+		pg = gtk_notebook_get_nth_page(cnnobj->cnnwin->priv->notebook, i);
+		if (g_object_get_data(G_OBJECT(pg), "cnnobj") == cnnobj) {
+			found_page = pg;
+			break;
+		}
+	}
+
+	return found_page;
+}
+
+
+void rco_closewin(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj = gp->cnnobj;
+	GtkWidget *page_to_remove;
+
+
+	if (cnnobj && cnnobj->scrolled_container && REMMINA_IS_SCROLLED_VIEWPORT(cnnobj->scrolled_container)) {
+		REMMINA_DEBUG("deleting motion");
+		remmina_scrolled_viewport_remove_motion(REMMINA_SCROLLED_VIEWPORT(cnnobj->scrolled_container));
+	}
+
+	if (cnnobj && cnnobj->cnnwin) {
+		page_to_remove = nb_find_page_by_cnnobj(cnnobj->cnnwin->priv->notebook, cnnobj);
+		if (page_to_remove) {
+			gtk_notebook_remove_page(
+				cnnobj->cnnwin->priv->notebook,
+				gtk_notebook_page_num(cnnobj->cnnwin->priv->notebook, page_to_remove));
+			/* Invalidate pointers to objects destroyed by page removal */
+			cnnobj->aspectframe = NULL;
+			cnnobj->viewport = NULL;
+			cnnobj->scrolled_container = NULL;
+			/* we cannot invalidate cnnobj->proto, because it can be already been
+			 * detached from the widget hierarchy in rco_on_disconnect() */
+		}
+	}
+	if (cnnobj) {
+		cnnobj->remmina_file = NULL;
+		g_free(cnnobj);
+		gp->cnnobj = NULL;
+	}
+
+	remmina_application_condexit(REMMINA_CONDEXIT_ONDISCONNECT);
+}
+
+void rco_on_close_button_clicked(GtkButton *button, RemminaConnectionObject *cnnobj)
+{
+	TRACE_CALL(__func__);
+	if (REMMINA_IS_PROTOCOL_WIDGET(cnnobj->proto)) {
+		if (!remmina_protocol_widget_is_closed((RemminaProtocolWidget *)cnnobj->proto))
+			remmina_protocol_widget_close_connection(REMMINA_PROTOCOL_WIDGET(cnnobj->proto));
+		else
+			rco_closewin((RemminaProtocolWidget *)cnnobj->proto);
+	}
+}
+
+static GtkWidget *rco_create_tab_label(RemminaConnectionObject *cnnobj)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *hbox;
+	GtkWidget *widget;
+	GtkWidget *button;
+
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
+	gtk_widget_show(hbox);
+
+	widget = gtk_image_new_from_icon_name(remmina_file_get_icon_name(cnnobj->remmina_file), GTK_ICON_SIZE_MENU);
+	gtk_widget_show(widget);
+	gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
+
+	widget = gtk_label_new(remmina_file_get_string(cnnobj->remmina_file, "name"));
+	gtk_widget_set_valign(widget, GTK_ALIGN_CENTER);
+	gtk_widget_set_halign(widget, GTK_ALIGN_CENTER);
+
+	gtk_widget_show(widget);
+	gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
+
+	button = gtk_button_new();      // The "x" to close the tab
+	gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
+#if GTK_CHECK_VERSION(3, 20, 0)
+	gtk_widget_set_focus_on_click(GTK_WIDGET(widget), FALSE);
+#else
+	gtk_button_set_focus_on_click(GTK_BUTTON(button), FALSE);
+#endif
+	gtk_widget_set_name(button, "remmina-small-button");
+	gtk_widget_show(button);
+
+	widget = gtk_image_new_from_icon_name("window-close", GTK_ICON_SIZE_MENU);
+	gtk_widget_show(widget);
+	gtk_container_add(GTK_CONTAINER(button), widget);
+
+	gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
+
+	g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(rco_on_close_button_clicked), cnnobj);
+
+
+	return hbox;
+}
+
+static GtkWidget *rco_create_tab_page(RemminaConnectionObject *cnnobj)
+{
+	GtkWidget *page;
+
+	page = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+	gtk_widget_set_name(page, "remmina-tab-page");
+
+
+	return page;
+}
+
+static GtkWidget *rcw_append_new_page(RemminaConnectionWindow *cnnwin, RemminaConnectionObject *cnnobj)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *page, *label;
+	GtkNotebook *notebook;
+
+	notebook = cnnwin->priv->notebook;
+
+	page = rco_create_tab_page(cnnobj);
+	g_object_set_data(G_OBJECT(page), "cnnobj", cnnobj);
+	label = rco_create_tab_label(cnnobj);
+
+	cnnobj->cnnwin = cnnwin;
+
+	gtk_notebook_append_page(notebook, page, label);
+	gtk_notebook_set_tab_reorderable(notebook, page, TRUE);
+	gtk_notebook_set_tab_detachable(notebook, page, TRUE);
+	/* This trick prevents the tab label from being focused */
+	gtk_widget_set_can_focus(gtk_widget_get_parent(label), FALSE);
+
+	if (gtk_widget_get_parent(cnnobj->scrolled_container) != NULL)
+		printf("REMMINA WARNING in %s: scrolled_container already has a parent\n", __func__);
+	gtk_box_pack_start(GTK_BOX(page), cnnobj->scrolled_container, TRUE, TRUE, 0);
+
+	gtk_widget_show(page);
+
+	return page;
+}
+
+
+static void rcw_update_notebook(RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	GtkNotebook *notebook;
+	gint n;
+
+	notebook = GTK_NOTEBOOK(cnnwin->priv->notebook);
+
+	switch (cnnwin->priv->view_mode) {
+	case SCROLLED_WINDOW_MODE:
+		n = gtk_notebook_get_n_pages(notebook);
+		gtk_notebook_set_show_tabs(notebook, remmina_pref.always_show_tab ? TRUE : n > 1);
+		gtk_notebook_set_show_border(notebook, remmina_pref.always_show_tab ? TRUE : n > 1);
+		break;
+	default:
+		gtk_notebook_set_show_tabs(notebook, FALSE);
+		gtk_notebook_set_show_border(notebook, FALSE);
+		break;
+	}
+}
+
+static gboolean rcw_on_switch_page_finalsel(gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv;
+	RemminaConnectionObject *cnnobj;
+
+	if (!user_data)
+		return FALSE;
+
+	cnnobj = (RemminaConnectionObject *)user_data;
+	if (!cnnobj->cnnwin)
+		return FALSE;
+
+	priv = cnnobj->cnnwin->priv;
+
+	if (GTK_IS_WIDGET(cnnobj->cnnwin)) {
+		rcw_floating_toolbar_show(cnnobj->cnnwin, TRUE);
+		if (!priv->hidetb_eventsource)
+			priv->hidetb_eventsource = g_timeout_add(TB_HIDE_TIME_TIME, (GSourceFunc)
+								 rcw_floating_toolbar_hide, cnnobj->cnnwin);
+		rco_update_toolbar(cnnobj);
+		rcw_grab_focus(cnnobj->cnnwin);
+		if (priv->view_mode != SCROLLED_WINDOW_MODE)
+			rco_check_resize(cnnobj);
+	}
+	priv->spf_eventsourceid = 0;
+	return FALSE;
+}
+
+static void rcw_on_switch_page(GtkNotebook *notebook, GtkWidget *newpage, guint page_num,
+			       RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindowPriv *priv = cnnwin->priv;
+	RemminaConnectionObject *cnnobj_newpage;
+
+	cnnobj_newpage = g_object_get_data(G_OBJECT(newpage), "cnnobj");
+	if (priv->spf_eventsourceid)
+		g_source_remove(priv->spf_eventsourceid);
+	priv->spf_eventsourceid = g_idle_add(rcw_on_switch_page_finalsel, cnnobj_newpage);
+}
+
+static void rcw_on_page_added(GtkNotebook *notebook, GtkWidget *child, guint page_num,
+			      RemminaConnectionWindow *cnnwin)
+{
+	if (gtk_notebook_get_n_pages(GTK_NOTEBOOK(cnnwin->priv->notebook)) > 0)
+		rcw_update_notebook(cnnwin);
+}
+
+static void rcw_on_page_removed(GtkNotebook *notebook, GtkWidget *child, guint page_num,
+				RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+
+	if (gtk_notebook_get_n_pages(GTK_NOTEBOOK(cnnwin->priv->notebook)) <= 0)
+		gtk_widget_destroy(GTK_WIDGET(cnnwin));
+
+}
+
+static GtkNotebook *
+rcw_on_notebook_create_window(GtkNotebook *notebook, GtkWidget *page, gint x, gint y, gpointer data)
+{
+	/* This signal callback is called by GTK when a detachable tab is dropped on the root window
+	 * or in an existing window */
+
+	TRACE_CALL(__func__);
+	RemminaConnectionWindow *srccnnwin;
+	RemminaConnectionWindow *dstcnnwin;
+	RemminaConnectionObject *cnnobj;
+	GdkWindow *window;
+	gchar *srctag;
+	gint width, height;
+
+#if GTK_CHECK_VERSION(3, 20, 0)
+	GdkSeat *seat;
+#else
+	GdkDeviceManager *manager;
+#endif
+	GdkDevice *device = NULL;
+
+#if GTK_CHECK_VERSION(3, 20, 0)
+	seat = gdk_display_get_default_seat(gdk_display_get_default());
+	device = gdk_seat_get_pointer(seat);
+#else
+	manager = gdk_display_get_device_manager(gdk_display_get_default());
+	device = gdk_device_manager_get_client_pointer(manager);
+#endif
+
+	window = gdk_device_get_window_at_position(device, &x, &y);
+	srccnnwin = RCW(gtk_widget_get_toplevel(GTK_WIDGET(notebook)));
+	dstcnnwin = RCW(remmina_widget_pool_find_by_window(REMMINA_TYPE_CONNECTION_WINDOW, window));
+
+	if (srccnnwin == dstcnnwin)
+		return NULL;
+
+	if (gtk_notebook_get_n_pages(GTK_NOTEBOOK(srccnnwin->priv->notebook)) == 1 && !dstcnnwin)
+		return NULL;
+
+	cnnobj = (RemminaConnectionObject *)g_object_get_data(G_OBJECT(page), "cnnobj");
+
+	if (!dstcnnwin) {
+		/* Drop is directed to a new rcw: create a new scrolled window to accommodate
+		 * the dropped connectionand move our cnnobj there. Width and
+		 * height of the new window are cloned from the current window */
+		srctag = (gchar *)g_object_get_data(G_OBJECT(srccnnwin), "tag");
+		gtk_window_get_size(GTK_WINDOW(srccnnwin), &width, &height);
+		dstcnnwin = rcw_create_scrolled(width, height, FALSE);  // New dropped window is never maximized
+		g_object_set_data_full(G_OBJECT(dstcnnwin), "tag", g_strdup(srctag), (GDestroyNotify)g_free);
+		/* when returning, GTK will move the whole tab to the new notebook.
+		 * Prepare cnnobj to be hosted in the new cnnwin */
+		cnnobj->cnnwin = dstcnnwin;
+	} else {
+		cnnobj->cnnwin = dstcnnwin;
+	}
+
+	remmina_protocol_widget_set_hostkey_func(REMMINA_PROTOCOL_WIDGET(cnnobj->proto),
+						 (RemminaHostkeyFunc)rcw_hostkey_func);
+
+	return GTK_NOTEBOOK(cnnobj->cnnwin->priv->notebook);
+}
+
+static GtkNotebook *
+rcw_create_notebook(RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	GtkNotebook *notebook;
+
+	notebook = GTK_NOTEBOOK(gtk_notebook_new());
+
+	gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE);
+	gtk_widget_show(GTK_WIDGET(notebook));
+
+	g_signal_connect(G_OBJECT(notebook), "create-window", G_CALLBACK(rcw_on_notebook_create_window), NULL);
+	g_signal_connect(G_OBJECT(notebook), "switch-page", G_CALLBACK(rcw_on_switch_page), cnnwin);
+	g_signal_connect(G_OBJECT(notebook), "page-added", G_CALLBACK(rcw_on_page_added), cnnwin);
+	g_signal_connect(G_OBJECT(notebook), "page-removed", G_CALLBACK(rcw_on_page_removed), cnnwin);
+	gtk_widget_set_can_focus(GTK_WIDGET(notebook), FALSE);
+
+	return notebook;
+}
+
+/* Create a scrolled toplevel window */
+static RemminaConnectionWindow *rcw_create_scrolled(gint width, gint height, gboolean maximize)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindow *cnnwin;
+	GtkWidget *grid;
+	GtkWidget *toolbar;
+	GtkNotebook *notebook;
+	GtkSettings *settings = gtk_settings_get_default();
+
+	cnnwin = rcw_new(FALSE, 0);
+	gtk_widget_realize(GTK_WIDGET(cnnwin));
+
+	gtk_window_set_default_size(GTK_WINDOW(cnnwin), width, height);
+	g_object_set(settings, "gtk-application-prefer-dark-theme", remmina_pref.dark_theme, NULL);
+
+	/* Create the toolbar */
+	toolbar = rcw_create_toolbar(cnnwin, SCROLLED_WINDOW_MODE);
+
+	/* Create the notebook */
+	notebook = rcw_create_notebook(cnnwin);
+
+	/* Create the grid container for toolbars+notebook and populate it */
+	grid = gtk_grid_new();
+
+
+	gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(notebook), 0, 0, 1, 1);
+
+	gtk_widget_set_hexpand(GTK_WIDGET(notebook), TRUE);
+	gtk_widget_set_vexpand(GTK_WIDGET(notebook), TRUE);
+
+	rcw_place_toolbar(GTK_TOOLBAR(toolbar), GTK_GRID(grid), GTK_WIDGET(notebook), remmina_pref.toolbar_placement);
+
+	gtk_container_add(GTK_CONTAINER(cnnwin), grid);
+
+	/* Add drag capabilities to the toolbar */
+	gtk_drag_source_set(GTK_WIDGET(toolbar), GDK_BUTTON1_MASK,
+			    dnd_targets_tb, sizeof dnd_targets_tb / sizeof *dnd_targets_tb, GDK_ACTION_MOVE);
+	g_signal_connect_after(GTK_WIDGET(toolbar), "drag-begin", G_CALLBACK(rcw_tb_drag_begin), NULL);
+	g_signal_connect(GTK_WIDGET(toolbar), "drag-failed", G_CALLBACK(rcw_tb_drag_failed), cnnwin);
+
+	/* Add drop capabilities to the drop/dest target for the toolbar (the notebook) */
+	gtk_drag_dest_set(GTK_WIDGET(notebook), GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT,
+			  dnd_targets_tb, sizeof dnd_targets_tb / sizeof *dnd_targets_tb, GDK_ACTION_MOVE);
+	gtk_drag_dest_set_track_motion(GTK_WIDGET(notebook), TRUE);
+	g_signal_connect(GTK_WIDGET(notebook), "drag-drop", G_CALLBACK(rcw_tb_drag_drop), cnnwin);
+
+	cnnwin->priv->view_mode = SCROLLED_WINDOW_MODE;
+	cnnwin->priv->toolbar = toolbar;
+	cnnwin->priv->grid = grid;
+	cnnwin->priv->notebook = notebook;
+	cnnwin->priv->ss_width = width;
+	cnnwin->priv->ss_height = height;
+	cnnwin->priv->ss_maximized = maximize;
+
+	/* The notebook and all its child must be realized now, or a reparent will
+	 * call unrealize() and will destroy a GtkSocket */
+	gtk_widget_show(grid);
+	gtk_widget_show(GTK_WIDGET(cnnwin));
+	GtkWindowGroup *wingrp = gtk_window_group_new();
+
+	gtk_window_group_add_window(wingrp, GTK_WINDOW(cnnwin));
+	gtk_window_set_transient_for(GTK_WINDOW(cnnwin), NULL);
+
+	if (maximize)
+		gtk_window_maximize(GTK_WINDOW(cnnwin));
+
+
+	rcw_set_toolbar_visibility(cnnwin);
+
+	return cnnwin;
+}
+
+static void rcw_create_overlay_ftb_overlay(RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+
+	GtkWidget *revealer;
+	RemminaConnectionWindowPriv *priv;
+
+	priv = cnnwin->priv;
+
+	if (priv->overlay_ftb_overlay != NULL) {
+		gtk_widget_destroy(priv->overlay_ftb_overlay);
+		priv->overlay_ftb_overlay = NULL;
+		priv->revealer = NULL;
+	}
+	if (priv->overlay_ftb_fr != NULL) {
+		gtk_widget_destroy(priv->overlay_ftb_fr);
+		priv->overlay_ftb_fr = NULL;
+	}
+
+	rcw_create_floating_toolbar(cnnwin, priv->fss_view_mode);
+
+	priv->overlay_ftb_overlay = gtk_event_box_new();
+
+	GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+
+	gtk_container_set_border_width(GTK_CONTAINER(vbox), 0);
+
+	GtkWidget *handle = gtk_drawing_area_new();
+
+	gtk_widget_set_size_request(handle, 4, 4);
+	gtk_widget_set_name(handle, "ftb-handle");
+
+	revealer = gtk_revealer_new();
+
+	gtk_widget_set_halign(GTK_WIDGET(priv->overlay_ftb_overlay), GTK_ALIGN_CENTER);
+
+	if (remmina_pref.floating_toolbar_placement == FLOATING_TOOLBAR_PLACEMENT_BOTTOM) {
+		gtk_box_pack_start(GTK_BOX(vbox), handle, FALSE, FALSE, 0);
+		gtk_box_pack_start(GTK_BOX(vbox), revealer, FALSE, FALSE, 0);
+		gtk_revealer_set_transition_type(GTK_REVEALER(revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP);
+		gtk_widget_set_valign(GTK_WIDGET(priv->overlay_ftb_overlay), GTK_ALIGN_END);
+	} else {
+		gtk_box_pack_start(GTK_BOX(vbox), revealer, FALSE, FALSE, 0);
+		gtk_box_pack_start(GTK_BOX(vbox), handle, FALSE, FALSE, 0);
+		gtk_revealer_set_transition_type(GTK_REVEALER(revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN);
+		gtk_widget_set_valign(GTK_WIDGET(priv->overlay_ftb_overlay), GTK_ALIGN_START);
+	}
+
+
+	gtk_container_add(GTK_CONTAINER(revealer), priv->floating_toolbar_widget);
+	gtk_widget_set_halign(GTK_WIDGET(revealer), GTK_ALIGN_CENTER);
+	gtk_widget_set_valign(GTK_WIDGET(revealer), GTK_ALIGN_START);
+
+	priv->revealer = revealer;
+
+	GtkWidget *fr;
+
+	fr = gtk_frame_new(NULL);
+	priv->overlay_ftb_fr = fr;
+	gtk_container_add(GTK_CONTAINER(priv->overlay_ftb_overlay), fr);
+	gtk_container_add(GTK_CONTAINER(fr), vbox);
+
+	gtk_widget_show(vbox);
+	gtk_widget_show(revealer);
+	gtk_widget_show(handle);
+	gtk_widget_show(priv->overlay_ftb_overlay);
+	gtk_widget_show(fr);
+
+	if (remmina_pref.floating_toolbar_placement == FLOATING_TOOLBAR_PLACEMENT_BOTTOM)
+		gtk_widget_set_name(fr, "ftbbox-lower");
+	else
+		gtk_widget_set_name(fr, "ftbbox-upper");
+
+	gtk_overlay_add_overlay(GTK_OVERLAY(priv->overlay), priv->overlay_ftb_overlay);
+
+	rcw_floating_toolbar_show(cnnwin, TRUE);
+
+	g_signal_connect(G_OBJECT(priv->overlay_ftb_overlay), "enter-notify-event", G_CALLBACK(rcw_floating_toolbar_on_enter), cnnwin);
+	g_signal_connect(G_OBJECT(priv->overlay_ftb_overlay), "leave-notify-event", G_CALLBACK(rcw_floating_toolbar_on_leave), cnnwin);
+	g_signal_connect(G_OBJECT(priv->overlay_ftb_overlay), "scroll-event", G_CALLBACK(rcw_floating_toolbar_on_scroll), cnnwin);
+	gtk_widget_add_events(
+		GTK_WIDGET(priv->overlay_ftb_overlay),
+		GDK_SCROLL_MASK
+#if GTK_CHECK_VERSION(3, 4, 0)
+		| GDK_SMOOTH_SCROLL_MASK
+#endif
+		);
+
+	/* Add drag and drop capabilities to the source */
+	gtk_drag_source_set(GTK_WIDGET(priv->overlay_ftb_overlay), GDK_BUTTON1_MASK,
+			    dnd_targets_ftb, sizeof dnd_targets_ftb / sizeof *dnd_targets_ftb, GDK_ACTION_MOVE);
+	g_signal_connect_after(GTK_WIDGET(priv->overlay_ftb_overlay), "drag-begin", G_CALLBACK(rcw_ftb_drag_begin), cnnwin);
+
+	if (remmina_pref.fullscreen_toolbar_visibility == FLOATING_TOOLBAR_VISIBILITY_DISABLE)
+		/* toolbar in fullscreenmode disabled, hide everything */
+		gtk_widget_hide(fr);
+}
+
+
+static gboolean rcw_ftb_drag_drop(GtkWidget *widget, GdkDragContext *context,
+				  gint x, gint y, guint time, RemminaConnectionWindow *cnnwin)
+{
+	TRACE_CALL(__func__);
+	GtkAllocation wa;
+	gint new_floating_toolbar_placement;
+	RemminaConnectionObject *cnnobj;
+
+	gtk_widget_get_allocation(widget, &wa);
+
+	if (y >= wa.height / 2)
+		new_floating_toolbar_placement = FLOATING_TOOLBAR_PLACEMENT_BOTTOM;
+	else
+		new_floating_toolbar_placement = FLOATING_TOOLBAR_PLACEMENT_TOP;
+
+	gtk_drag_finish(context, TRUE, TRUE, time);
+
+	if (new_floating_toolbar_placement != remmina_pref.floating_toolbar_placement) {
+		/* Destroy and recreate the FTB */
+		remmina_pref.floating_toolbar_placement = new_floating_toolbar_placement;
+		remmina_pref_save();
+		rcw_create_overlay_ftb_overlay(cnnwin);
+		cnnobj = rcw_get_visible_cnnobj(cnnwin);
+		if (cnnobj) rco_update_toolbar(cnnobj);
+	}
+
+	return TRUE;
+}
+
+static void rcw_ftb_drag_begin(GtkWidget *widget, GdkDragContext *context, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+
+	cairo_surface_t *surface;
+	cairo_t *cr;
+	GtkAllocation wa;
+	double dashes[] = { 10 };
+
+	gtk_widget_get_allocation(widget, &wa);
+
+	surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, wa.width, wa.height);
+	cr = cairo_create(surface);
+	cairo_set_source_rgb(cr, 0.6, 0.6, 0.6);
+	cairo_set_line_width(cr, 2);
+	cairo_set_dash(cr, dashes, 1, 0);
+	cairo_rectangle(cr, 0, 0, wa.width, wa.height);
+	cairo_stroke(cr);
+	cairo_destroy(cr);
+
+	gtk_drag_set_icon_surface(context, surface);
+}
+
+RemminaConnectionWindow *rcw_create_fullscreen(GtkWindow *old, gint view_mode)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindow *cnnwin;
+	GtkNotebook *notebook;
+
+#if GTK_CHECK_VERSION(3, 22, 0)
+	gint n_monitors;
+	gint i;
+	GdkMonitor *old_monitor;
+	GdkDisplay *old_display;
+	GdkWindow *old_window;
+#endif
+	gint full_screen_target_monitor;
+
+	full_screen_target_monitor = FULL_SCREEN_TARGET_MONITOR_UNDEFINED;
+	if (old) {
+#if GTK_CHECK_VERSION(3, 22, 0)
+		old_window = gtk_widget_get_window(GTK_WIDGET(old));
+		old_display = gdk_window_get_display(old_window);
+		old_monitor = gdk_display_get_monitor_at_window(old_display, old_window);
+		n_monitors = gdk_display_get_n_monitors(old_display);
+		for (i = 0; i < n_monitors; ++i) {
+			if (gdk_display_get_monitor(old_display, i) == old_monitor) {
+				full_screen_target_monitor = i;
+				break;
+			}
+		}
+#else
+		full_screen_target_monitor = gdk_screen_get_monitor_at_window(
+			gdk_screen_get_default(),
+			gtk_widget_get_window(GTK_WIDGET(old)));
+#endif
+	}
+
+	cnnwin = rcw_new(TRUE, full_screen_target_monitor);
+	gtk_widget_set_name(GTK_WIDGET(cnnwin), "remmina-connection-window-fullscreen");
+	gtk_widget_realize(GTK_WIDGET(cnnwin));
+
+	if (!view_mode)
+		view_mode = VIEWPORT_FULLSCREEN_MODE;
+
+	notebook = rcw_create_notebook(cnnwin);
+
+	cnnwin->priv->overlay = gtk_overlay_new();
+	gtk_container_add(GTK_CONTAINER(cnnwin), cnnwin->priv->overlay);
+	gtk_container_add(GTK_CONTAINER(cnnwin->priv->overlay), GTK_WIDGET(notebook));
+	gtk_widget_show(GTK_WIDGET(cnnwin->priv->overlay));
+
+	cnnwin->priv->notebook = notebook;
+	cnnwin->priv->view_mode = view_mode;
+	cnnwin->priv->fss_view_mode = view_mode;
+
+	/* Create the floating toolbar */
+	rcw_create_overlay_ftb_overlay(cnnwin);
+	/* Add drag and drop capabilities to the drop/dest target for floating toolbar */
+	gtk_drag_dest_set(GTK_WIDGET(cnnwin->priv->overlay), GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT,
+			  dnd_targets_ftb, sizeof dnd_targets_ftb / sizeof *dnd_targets_ftb, GDK_ACTION_MOVE);
+	gtk_drag_dest_set_track_motion(GTK_WIDGET(cnnwin->priv->notebook), TRUE);
+	g_signal_connect(GTK_WIDGET(cnnwin->priv->overlay), "drag-drop", G_CALLBACK(rcw_ftb_drag_drop), cnnwin);
+
+	gtk_widget_show(GTK_WIDGET(cnnwin));
+	GtkWindowGroup *wingrp = gtk_window_group_new();
+	gtk_window_group_add_window(wingrp, GTK_WINDOW(cnnwin));
+	gtk_window_set_transient_for(GTK_WINDOW(cnnwin), NULL);
+
+	return cnnwin;
+}
+
+static gboolean rcw_hostkey_func(RemminaProtocolWidget *gp, guint keyval, gboolean release)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj = gp->cnnobj;
+	RemminaConnectionWindowPriv *priv = cnnobj->cnnwin->priv;
+	const RemminaProtocolFeature *feature;
+	gint i;
+
+	if (release) {
+		if (remmina_pref.hostkey && keyval == remmina_pref.hostkey) {
+			priv->hostkey_activated = FALSE;
+			if (priv->hostkey_used)
+				/* hostkey pressed + something else */
+				return TRUE;
+		}
+		/* If hostkey is released without pressing other keys, we should execute the
+		 * shortcut key which is the same as hostkey. Be default, this is grab/ungrab
+		 * keyboard */
+		else if (priv->hostkey_activated) {
+			/* Trap all key releases when hostkey is pressed */
+			/* hostkey pressed + something else */
+			return TRUE;
+		} else {
+			/* Any key pressed, no hostkey */
+			return FALSE;
+		}
+	} else if (remmina_pref.hostkey && keyval == remmina_pref.hostkey) {
+		/** @todo Add callback for hostname transparent overlay #832 */
+		priv->hostkey_activated = TRUE;
+		priv->hostkey_used = FALSE;
+		return TRUE;
+	} else if (!priv->hostkey_activated) {
+		/* Any key pressed, no hostkey */
+		return FALSE;
+	}
+
+	priv->hostkey_used = TRUE;
+	keyval = gdk_keyval_to_lower(keyval);
+	if (keyval == GDK_KEY_Up || keyval == GDK_KEY_Down
+	    || keyval == GDK_KEY_Left || keyval == GDK_KEY_Right) {
+		GtkAdjustment *adjust;
+		int pos;
+
+		if (cnnobj->connected && GTK_IS_SCROLLED_WINDOW(cnnobj->scrolled_container)) {
+			if (keyval == GDK_KEY_Up || keyval == GDK_KEY_Down)
+				adjust = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(cnnobj->scrolled_container));
+			else
+				adjust = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(cnnobj->scrolled_container));
+
+			if (keyval == GDK_KEY_Up || keyval == GDK_KEY_Left)
+				pos = 0;
+			else
+				pos = gtk_adjustment_get_upper(adjust);
+
+			gtk_adjustment_set_value(adjust, pos);
+			if (keyval == GDK_KEY_Up || keyval == GDK_KEY_Down)
+				gtk_scrolled_window_set_vadjustment(GTK_SCROLLED_WINDOW(cnnobj->scrolled_container), adjust);
+			else
+				gtk_scrolled_window_set_hadjustment(GTK_SCROLLED_WINDOW(cnnobj->scrolled_container), adjust);
+		} else if (REMMINA_IS_SCROLLED_VIEWPORT(cnnobj->scrolled_container)) {
+			RemminaScrolledViewport *gsv;
+			GtkWidget *child;
+			GdkWindow *gsvwin;
+			gint sz;
+			GtkAdjustment *adj;
+			gdouble value;
+
+			if (!GTK_IS_BIN(cnnobj->scrolled_container))
+				return FALSE;
+
+			gsv = REMMINA_SCROLLED_VIEWPORT(cnnobj->scrolled_container);
+			child = gtk_bin_get_child(GTK_BIN(gsv));
+			if (!GTK_IS_VIEWPORT(child))
+				return FALSE;
+
+			gsvwin = gtk_widget_get_window(GTK_WIDGET(gsv));
+			if (!gsv)
+				return FALSE;
+
+			if (keyval == GDK_KEY_Up || keyval == GDK_KEY_Down) {
+				sz = gdk_window_get_height(gsvwin) + 2; // Add 2px of black scroll border
+				adj = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(child));
+			} else {
+				sz = gdk_window_get_width(gsvwin) + 2; // Add 2px of black scroll border
+				adj = gtk_scrollable_get_hadjustment(GTK_SCROLLABLE(child));
+			}
+
+			if (keyval == GDK_KEY_Up || keyval == GDK_KEY_Left)
+				value = 0;
+			else
+				value = gtk_adjustment_get_upper(GTK_ADJUSTMENT(adj)) - (gdouble)sz + 2.0;
+
+			gtk_adjustment_set_value(GTK_ADJUSTMENT(adj), value);
+		}
+	}
+
+	if (keyval == remmina_pref.shortcutkey_fullscreen && !extrahardening) {
+		switch (priv->view_mode) {
+		case SCROLLED_WINDOW_MODE:
+			rcw_switch_viewmode(cnnobj->cnnwin, priv->fss_view_mode);
+			break;
+		case SCROLLED_FULLSCREEN_MODE:
+		case VIEWPORT_FULLSCREEN_MODE:
+			rcw_switch_viewmode(cnnobj->cnnwin, SCROLLED_WINDOW_MODE);
+			break;
+		default:
+			break;
+		}
+	} else if (keyval == remmina_pref.shortcutkey_autofit && !extrahardening) {
+		if (priv->toolitem_autofit && gtk_widget_is_sensitive(GTK_WIDGET(priv->toolitem_autofit)))
+			rcw_toolbar_autofit(GTK_TOOL_ITEM(gp), cnnobj->cnnwin);
+	} else if (keyval == remmina_pref.shortcutkey_nexttab && !extrahardening) {
+		i = gtk_notebook_get_current_page(GTK_NOTEBOOK(priv->notebook)) + 1;
+		if (i >= gtk_notebook_get_n_pages(GTK_NOTEBOOK(priv->notebook)))
+			i = 0;
+		gtk_notebook_set_current_page(GTK_NOTEBOOK(priv->notebook), i);
+	} else if (keyval == remmina_pref.shortcutkey_prevtab && !extrahardening) {
+		i = gtk_notebook_get_current_page(GTK_NOTEBOOK(priv->notebook)) - 1;
+		if (i < 0)
+			i = gtk_notebook_get_n_pages(GTK_NOTEBOOK(priv->notebook)) - 1;
+		gtk_notebook_set_current_page(GTK_NOTEBOOK(priv->notebook), i);
+	} else if (keyval == remmina_pref.shortcutkey_clipboard && !extrahardening) {
+		if (remmina_protocol_widget_plugin_receives_keystrokes(REMMINA_PROTOCOL_WIDGET(cnnobj->proto))) {
+			remmina_protocol_widget_send_clipboard((RemminaProtocolWidget*)cnnobj->proto, G_OBJECT(cnnobj->proto));
+		}
+	} else if (keyval == remmina_pref.shortcutkey_scale && !extrahardening) {
+		if (gtk_widget_is_sensitive(GTK_WIDGET(priv->toolitem_scale))) {
+			gtk_toggle_tool_button_set_active(
+				GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_scale),
+				!gtk_toggle_tool_button_get_active(
+					GTK_TOGGLE_TOOL_BUTTON(
+						priv->toolitem_scale)));
+		}
+	} else if (keyval == remmina_pref.shortcutkey_grab && !extrahardening) {
+		gtk_toggle_tool_button_set_active(
+			GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_grab),
+			!gtk_toggle_tool_button_get_active(
+				GTK_TOGGLE_TOOL_BUTTON(
+					priv->toolitem_grab)));
+	} else if (keyval == remmina_pref.shortcutkey_minimize && !extrahardening) {
+		rcw_toolbar_minimize(GTK_TOOL_ITEM(gp),
+				     cnnobj->cnnwin);
+	} else if (keyval == remmina_pref.shortcutkey_viewonly && !extrahardening) {
+		remmina_file_set_int(cnnobj->remmina_file, "viewonly",
+				     (remmina_file_get_int(cnnobj->remmina_file, "viewonly", 0)
+				      == 0) ? 1 : 0);
+	} else if (keyval == remmina_pref.shortcutkey_screenshot && !extrahardening) {
+		rcw_toolbar_screenshot(GTK_TOOL_ITEM(gp),
+				       cnnobj->cnnwin);
+	} else if (keyval == remmina_pref.shortcutkey_disconnect && !extrahardening) {
+		rco_disconnect_current_page(cnnobj);
+	} else if (keyval == remmina_pref.shortcutkey_toolbar && !extrahardening) {
+		if (priv->view_mode == SCROLLED_WINDOW_MODE) {
+			remmina_pref.hide_connection_toolbar =
+				!remmina_pref.hide_connection_toolbar;
+			rcw_set_toolbar_visibility(cnnobj->cnnwin);
+		}
+	} else {
+		for (feature =
+			     remmina_protocol_widget_get_features(
+				     REMMINA_PROTOCOL_WIDGET(
+					     cnnobj->proto));
+		     feature && feature->type;
+		     feature++) {
+			if (feature->type
+			    == REMMINA_PROTOCOL_FEATURE_TYPE_TOOL
+			    && GPOINTER_TO_UINT(
+				    feature->opt3)
+			    == keyval) {
+				remmina_protocol_widget_call_feature_by_ref(
+					REMMINA_PROTOCOL_WIDGET(
+						cnnobj->proto),
+					feature);
+				break;
+			}
+		}
+	}
+	/* If a keypress makes the current cnnobj to move to another window,
+	 * priv is now invalid. So we can no longer use priv here */
+	cnnobj->cnnwin->priv->hostkey_activated = FALSE;
+
+	/* Trap all keypresses when hostkey is pressed */
+	return TRUE;
+}
+
+static RemminaConnectionWindow *rcw_find(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	const gchar *tag;
+
+	switch (remmina_pref.tab_mode) {
+	case REMMINA_TAB_BY_GROUP:
+		tag = remmina_file_get_string(remminafile, "group");
+		break;
+	case REMMINA_TAB_BY_PROTOCOL:
+		tag = remmina_file_get_string(remminafile, "protocol");
+		break;
+	case REMMINA_TAB_ALL:
+		tag = NULL;
+		break;
+	case REMMINA_TAB_NONE:
+	default:
+		return NULL;
+	}
+	return RCW(remmina_widget_pool_find(REMMINA_TYPE_CONNECTION_WINDOW, tag));
+}
+
+gboolean rcw_delayed_window_present(gpointer user_data)
+{
+	RemminaConnectionWindow *cnnwin = (RemminaConnectionWindow *)user_data;
+
+	if (cnnwin) {
+		gtk_window_present_with_time(GTK_WINDOW(cnnwin), (guint32)(g_get_monotonic_time() / 1000));
+		rcw_grab_focus(cnnwin);
+	}
+	cnnwin->priv->dwp_eventsourceid = 0;
+	return G_SOURCE_REMOVE;
+}
+
+void rco_on_connect(RemminaProtocolWidget *gp, RemminaConnectionObject *cnnobj)
+{
+	TRACE_CALL(__func__);
+
+	REMMINA_DEBUG("Connect signal emitted");
+
+	/* This signal handler is called by a plugin when it’s correctly connected
+	 * (and authenticated) */
+
+	cnnobj->connected = TRUE;
+
+	remmina_protocol_widget_set_hostkey_func(REMMINA_PROTOCOL_WIDGET(cnnobj->proto),
+						 (RemminaHostkeyFunc)rcw_hostkey_func);
+
+	/** Remember recent list for quick connect, and save the current date
+	 * in the last_used field.
+	 */
+	if (remmina_file_get_filename(cnnobj->remmina_file) == NULL)
+		remmina_pref_add_recent(remmina_file_get_string(cnnobj->remmina_file, "protocol"),
+					remmina_file_get_string(cnnobj->remmina_file, "server"));
+	REMMINA_DEBUG("We save the last successful connection date");
+	//remmina_file_set_string(cnnobj->remmina_file, "last_success", last_success);
+	remmina_file_state_last_success(cnnobj->remmina_file);
+	//REMMINA_DEBUG("Last connection made on %s.", last_success);
+
+	REMMINA_DEBUG("Saving credentials");
+	/* Save credentials */
+	remmina_file_save(cnnobj->remmina_file);
+
+	if (cnnobj->cnnwin->priv->floating_toolbar_widget)
+		gtk_widget_show(cnnobj->cnnwin->priv->floating_toolbar_widget);
+
+	rco_update_toolbar(cnnobj);
+
+	REMMINA_DEBUG("Trying to present the window");
+	/* Try to present window */
+	cnnobj->cnnwin->priv->dwp_eventsourceid = g_timeout_add(200, rcw_delayed_window_present, (gpointer)cnnobj->cnnwin);
+}
+
+static void cb_lasterror_confirmed(void *cbdata, int btn)
+{
+	TRACE_CALL(__func__);
+	rco_closewin((RemminaProtocolWidget *)cbdata);
+}
+
+void rco_on_disconnect(RemminaProtocolWidget *gp, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj = gp->cnnobj;
+	RemminaConnectionWindowPriv *priv = cnnobj->cnnwin->priv;
+	GtkWidget *pparent;
+
+	REMMINA_DEBUG("Disconnect signal received on RemminaProtocolWidget");
+	/* Detach the protocol widget from the notebook now, or we risk that a
+	 * window delete will destroy cnnobj->proto before we complete disconnection.
+	 */
+	pparent = gtk_widget_get_parent(cnnobj->proto);
+	if (pparent != NULL) {
+		g_object_ref(cnnobj->proto);
+		gtk_container_remove(GTK_CONTAINER(pparent), cnnobj->proto);
+	}
+
+	cnnobj->connected = FALSE;
+
+	if (remmina_pref.save_view_mode) {
+		if (cnnobj->cnnwin)
+			remmina_file_set_int(cnnobj->remmina_file, "viewmode", cnnobj->cnnwin->priv->view_mode);
+		remmina_file_save(cnnobj->remmina_file);
+	}
+
+	rcw_kp_ungrab(cnnobj->cnnwin);
+	gtk_toggle_tool_button_set_active(
+		GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_grab),
+		FALSE);
+
+	if (remmina_protocol_widget_has_error(gp)) {
+		/* We cannot close window immediately, but we must show a message panel */
+		RemminaMessagePanel *mp;
+		/* Destroy scrolled_container (and viewport) and all its children the plugin created
+		 * on it, so they will not receive GUI signals */
+		if (cnnobj->scrolled_container) {
+			gtk_widget_destroy(cnnobj->scrolled_container);
+			cnnobj->scrolled_container = NULL;
+		}
+		cnnobj->viewport = NULL;
+		mp = remmina_message_panel_new();
+		remmina_message_panel_setup_message(mp, remmina_protocol_widget_get_error_message(gp), cb_lasterror_confirmed, gp);
+		rco_show_message_panel(gp->cnnobj, mp);
+		REMMINA_DEBUG("Could not disconnect");
+	} else {
+		rco_closewin(gp);
+		REMMINA_DEBUG("Disconnected");
+	}
+}
+
+void rco_on_desktop_resize(RemminaProtocolWidget *gp, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj = gp->cnnobj;
+
+	if (cnnobj && cnnobj->cnnwin && cnnobj->cnnwin->priv->view_mode != SCROLLED_WINDOW_MODE)
+		rco_check_resize(cnnobj);
+}
+
+void rco_on_update_align(RemminaProtocolWidget *gp, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj = gp->cnnobj;
+
+	remmina_protocol_widget_update_alignment(cnnobj);
+}
+
+void rco_on_lock_dynres(RemminaProtocolWidget *gp, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj = gp->cnnobj;
+
+	cnnobj->dynres_unlocked = FALSE;
+	rco_update_toolbar(cnnobj);
+}
+
+void rco_on_unlock_dynres(RemminaProtocolWidget *gp, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj = gp->cnnobj;
+
+	cnnobj->dynres_unlocked = TRUE;
+	rco_update_toolbar(cnnobj);
+}
+
+gboolean rcw_open_from_filename(const gchar *filename)
+{
+	TRACE_CALL(__func__);
+	RemminaFile *remminafile;
+	GtkWidget *dialog;
+
+	remminafile = remmina_file_manager_load_file(filename);
+	if (remminafile) {
+		if (remmina_file_get_int (remminafile, "profile-lock", FALSE)
+				&& remmina_unlock_new(remmina_main_get_window()) == 0)
+			return FALSE;
+		rcw_open_from_file(remminafile);
+		return TRUE;
+	} else {
+		dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
+						_("The file “%s” is corrupted, unreadable, or could not be found."), filename);
+		g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(gtk_widget_destroy), NULL);
+		gtk_widget_show(dialog);
+		remmina_widget_pool_register(dialog);
+		return FALSE;
+	}
+}
+
+static gboolean open_connection_last_stage(gpointer user_data)
+{
+	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)user_data;
+
+	/* Now we have an allocated size for our RemminaProtocolWidget. We can proceed with the connection */
+	remmina_protocol_widget_update_remote_resolution(gp);
+	remmina_protocol_widget_open_connection(gp);
+	rco_check_resize(gp->cnnobj);
+
+	return FALSE;
+}
+
+static void rpw_size_allocated_on_connection(GtkWidget *w, GdkRectangle *allocation, gpointer user_data)
+{
+	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)w;
+
+	/* Disconnect signal handler to avoid to be called again after a normal resize */
+	g_signal_handler_disconnect(w, gp->cnnobj->deferred_open_size_allocate_handler);
+
+	/* Allow extra 100 ms for size allocation (do we really need it?) */
+	g_timeout_add(100, open_connection_last_stage, gp);
+
+	return;
+}
+
+void rcw_open_from_file(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	rcw_open_from_file_full(remminafile, NULL, NULL, NULL);
+}
+
+static void set_label_selectable(gpointer data, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget = GTK_WIDGET(data);
+
+	if (GTK_IS_LABEL(widget))
+		gtk_label_set_selectable(GTK_LABEL(widget), TRUE);
+}
+
+/**
+ * @brief These define the response id's of the
+ *	  gtksocket-is-not-available-warning-dialog buttons.
+ */
+enum GTKSOCKET_NOT_AVAIL_RESPONSE_TYPE {
+	GTKSOCKET_NOT_AVAIL_RESPONSE_OPEN_BROWSER = 0,
+	GTKSOCKET_NOT_AVAIL_RESPONSE_NUM
+};
+
+/**
+ * @brief Gets called if the user interacts with the
+ *	  gtksocket-is-not-available-warning-dialog
+ */
+static void rcw_gtksocket_not_available_dialog_response(GtkDialog *			self,
+							gint				response_id,
+							RemminaConnectionObject *	cnnobj)
+{
+	TRACE_CALL(__func__);
+
+	GError *error = NULL;
+
+	if (response_id == GTKSOCKET_NOT_AVAIL_RESPONSE_OPEN_BROWSER) {
+		gtk_show_uri_on_window(
+			NULL,
+			// TRANSLATORS: This should be a link to the Remmina wiki page:
+			// TRANSLATORS: 'GtkSocket feature is not available'.
+			_("https://gitlab.com/Remmina/Remmina/-/wikis/GtkSocket-feature-is-not-available-in-a-Wayland-session"),
+			GDK_CURRENT_TIME, &error
+			);
+	}
+
+	// Close the current page since it's useless without GtkSocket.
+	// The user would need to manually click the close button.
+	if (cnnobj) rco_disconnect_current_page(cnnobj);
+
+	gtk_widget_destroy(GTK_WIDGET(self));
+}
+
+GtkWidget *rcw_open_from_file_full(RemminaFile *remminafile, GCallback disconnect_cb, gpointer data, guint *handler)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionObject *cnnobj;
+
+	gint ret;
+	GtkWidget *dialog;
+	GtkWidget *newpage;
+	gint width, height;
+	gboolean maximize;
+	gint view_mode;
+	const gchar *msg;
+	RemminaScaleMode scalemode;
+
+	if (disconnect_cb) {
+		g_print("disconnect_cb is deprecated inside rcw_open_from_file_full() and should be null\n");
+		return NULL;
+	}
+
+
+	/* Create the RemminaConnectionObject */
+	cnnobj = g_new0(RemminaConnectionObject, 1);
+	cnnobj->remmina_file = remminafile;
+
+	/* Create the RemminaProtocolWidget */
+	cnnobj->proto = remmina_protocol_widget_new();
+	remmina_protocol_widget_setup((RemminaProtocolWidget *)cnnobj->proto, remminafile, cnnobj);
+	if (remmina_protocol_widget_has_error((RemminaProtocolWidget *)cnnobj->proto)) {
+		GtkWindow *wparent;
+		wparent = remmina_main_get_window();
+		msg = remmina_protocol_widget_get_error_message((RemminaProtocolWidget *)cnnobj->proto);
+		dialog = gtk_message_dialog_new(wparent, GTK_DIALOG_DESTROY_WITH_PARENT,
+						GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", msg);
+		gtk_dialog_run(GTK_DIALOG(dialog));
+		gtk_widget_destroy(dialog);
+		/* We should destroy cnnobj->proto and cnnobj now… TODO: Fix this leak */
+		return NULL;
+	}
+
+
+
+	/* Set a name for the widget, for CSS selector */
+	gtk_widget_set_name(GTK_WIDGET(cnnobj->proto), "remmina-protocol-widget");
+
+	gtk_widget_set_halign(GTK_WIDGET(cnnobj->proto), GTK_ALIGN_FILL);
+	gtk_widget_set_valign(GTK_WIDGET(cnnobj->proto), GTK_ALIGN_FILL);
+
+	if (data)
+		g_object_set_data(G_OBJECT(cnnobj->proto), "user-data", data);
+
+	view_mode = remmina_file_get_int(cnnobj->remmina_file, "viewmode", 0);
+	if (kioskmode)
+		view_mode = VIEWPORT_FULLSCREEN_MODE;
+	gint ismultimon = remmina_file_get_int(cnnobj->remmina_file, "multimon", 0);
+
+	if (ismultimon)
+		view_mode = VIEWPORT_FULLSCREEN_MODE;
+
+	if (fullscreen)
+		view_mode = VIEWPORT_FULLSCREEN_MODE;
+
+	/* Create the viewport to make the RemminaProtocolWidget scrollable */
+	cnnobj->viewport = gtk_viewport_new(NULL, NULL);
+	gtk_widget_set_name(cnnobj->viewport, "remmina-cw-viewport");
+	gtk_widget_show(cnnobj->viewport);
+	gtk_container_set_border_width(GTK_CONTAINER(cnnobj->viewport), 0);
+	gtk_viewport_set_shadow_type(GTK_VIEWPORT(cnnobj->viewport), GTK_SHADOW_NONE);
+
+	/* Create the scrolled container */
+	scalemode = get_current_allowed_scale_mode(cnnobj, NULL, NULL);
+	cnnobj->scrolled_container = rco_create_scrolled_container(scalemode, view_mode);
+
+	gtk_container_add(GTK_CONTAINER(cnnobj->scrolled_container), cnnobj->viewport);
+
+	/* Determine whether the plugin can scale or not. If the plugin can scale and we do
+	 * not want to expand, then we add a GtkAspectFrame to maintain aspect ratio during scaling */
+	cnnobj->plugin_can_scale = remmina_plugin_manager_query_feature_by_type(REMMINA_PLUGIN_TYPE_PROTOCOL,
+										remmina_file_get_string(remminafile, "protocol"),
+										REMMINA_PROTOCOL_FEATURE_TYPE_SCALE);
+
+	cnnobj->aspectframe = NULL;
+	gtk_container_add(GTK_CONTAINER(cnnobj->viewport), cnnobj->proto);
+
+	/* Determine whether this connection will be put on a new window
+	 * or in an existing one */
+	cnnobj->cnnwin = rcw_find(remminafile);
+	if (!cnnobj->cnnwin) {
+		/* Connection goes on a new toplevel window */
+		switch (view_mode) {
+		case SCROLLED_FULLSCREEN_MODE:
+		case VIEWPORT_FULLSCREEN_MODE:
+			cnnobj->cnnwin = rcw_create_fullscreen(NULL, view_mode);
+			break;
+		case SCROLLED_WINDOW_MODE:
+		default:
+			width = remmina_file_get_int(cnnobj->remmina_file, "window_width", 640);
+			height = remmina_file_get_int(cnnobj->remmina_file, "window_height", 480);
+			maximize = remmina_file_get_int(cnnobj->remmina_file, "window_maximize", FALSE) ? TRUE : FALSE;
+			cnnobj->cnnwin = rcw_create_scrolled(width, height, maximize);
+			break;
+		}
+		rcw_update_tag(cnnobj->cnnwin, cnnobj);
+		rcw_append_new_page(cnnobj->cnnwin, cnnobj);
+	} else {
+		newpage = rcw_append_new_page(cnnobj->cnnwin, cnnobj);
+		gtk_window_present(GTK_WINDOW(cnnobj->cnnwin));
+		nb_set_current_page(cnnobj->cnnwin->priv->notebook, newpage);
+	}
+
+	// Do not call remmina_protocol_widget_update_alignment(cnnobj); here or cnnobj->proto will not fill its parent size
+	// and remmina_protocol_widget_update_remote_resolution() cannot autodetect available space
+
+	gtk_widget_show(cnnobj->proto);
+	g_signal_connect(G_OBJECT(cnnobj->proto), "connect", G_CALLBACK(rco_on_connect), cnnobj);
+	g_signal_connect(G_OBJECT(cnnobj->proto), "disconnect", G_CALLBACK(rco_on_disconnect), NULL);
+	g_signal_connect(G_OBJECT(cnnobj->proto), "desktop-resize", G_CALLBACK(rco_on_desktop_resize), NULL);
+	g_signal_connect(G_OBJECT(cnnobj->proto), "update-align", G_CALLBACK(rco_on_update_align), NULL);
+	g_signal_connect(G_OBJECT(cnnobj->proto), "lock-dynres", G_CALLBACK(rco_on_lock_dynres), NULL);
+	g_signal_connect(G_OBJECT(cnnobj->proto), "unlock-dynres", G_CALLBACK(rco_on_unlock_dynres), NULL);
+	g_signal_connect(G_OBJECT(cnnobj->proto), "enter-notify-event", G_CALLBACK(rco_enter_protocol_widget), cnnobj);
+	g_signal_connect(G_OBJECT(cnnobj->proto), "leave-notify-event", G_CALLBACK(rco_leave_protocol_widget), cnnobj);
+
+	if (!remmina_pref.save_view_mode)
+		remmina_file_set_int(cnnobj->remmina_file, "viewmode", remmina_pref.default_mode);
+
+
+	/* If it is a GtkSocket plugin and X11 is not available, we inform the
+	 * user and close the connection */
+	ret = remmina_plugin_manager_query_feature_by_type(REMMINA_PLUGIN_TYPE_PROTOCOL,
+							   remmina_file_get_string(remminafile, "protocol"),
+							   REMMINA_PROTOCOL_FEATURE_TYPE_GTKSOCKET);
+	if (ret && !remmina_gtksocket_available()) {
+		gchar *title = _("Warning: This plugin requires GtkSocket, but this "
+				 "feature is unavailable in a Wayland session.");
+
+		gchar *err_msg =
+			// TRANSLATORS: This should be a link to the Remmina wiki page:
+			// 'GtkSocket feature is not available'.
+			_("Plugins relying on GtkSocket can't run in a "
+			  "Wayland session.\nFor more info and a possible "
+			  "workaround, please visit the Remmina wiki at:\n\n"
+			  "https://gitlab.com/Remmina/Remmina/-/wikis/GtkSocket-feature-is-not-available-in-a-Wayland-session");
+
+		dialog = gtk_message_dialog_new(
+			GTK_WINDOW(cnnobj->cnnwin),
+			GTK_DIALOG_MODAL,
+			GTK_MESSAGE_WARNING,
+			GTK_BUTTONS_OK,
+			"%s", title);
+
+		gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog), "%s",
+							 err_msg);
+		gtk_dialog_add_button(GTK_DIALOG(dialog), _("Open in web browser"),
+				      GTKSOCKET_NOT_AVAIL_RESPONSE_OPEN_BROWSER);
+
+		REMMINA_CRITICAL(g_strdup_printf("%s\n%s", title, err_msg));
+
+		g_signal_connect(G_OBJECT(dialog),
+				 "response",
+				 G_CALLBACK(rcw_gtksocket_not_available_dialog_response),
+				 cnnobj);
+
+		// Make Text selectable. Usefull because of the link in the text.
+		GtkWidget *area = gtk_message_dialog_get_message_area(
+			GTK_MESSAGE_DIALOG(dialog));
+		GtkContainer *box = (GtkContainer *)area;
+
+		GList *children = gtk_container_get_children(box);
+		g_list_foreach(children, set_label_selectable, NULL);
+		g_list_free(children);
+
+		gtk_widget_show(dialog);
+
+		return NULL;    /* Should we destroy something before returning? */
+	}
+
+	if (cnnobj->cnnwin->priv->floating_toolbar_widget)
+		gtk_widget_show(cnnobj->cnnwin->priv->floating_toolbar_widget);
+
+	if (remmina_protocol_widget_has_error((RemminaProtocolWidget *)cnnobj->proto)) {
+		printf("OK, an error occurred in initializing the protocol plugin before connecting. The error is %s.\n"
+		       "TODO: Put this string as an error to show", remmina_protocol_widget_get_error_message((RemminaProtocolWidget *)cnnobj->proto));
+		return cnnobj->proto;
+	}
+
+
+	/* GTK window setup is done here, and we are almost ready to call remmina_protocol_widget_open_connection().
+	 * But size has not yet been allocated by GTK
+	 * to the widgets. If we are in RES_USE_INITIAL_WINDOW_SIZE resolution mode or scale is REMMINA_PROTOCOL_WIDGET_SCALE_MODE_DYNRES,
+	 * we should wait for a size allocation from GTK for cnnobj->proto
+	 * before connecting */
+
+	cnnobj->deferred_open_size_allocate_handler = g_signal_connect(G_OBJECT(cnnobj->proto), "size-allocate", G_CALLBACK(rpw_size_allocated_on_connection), NULL);
+
+	return cnnobj->proto;
+}
+
+GtkWindow *rcw_get_gtkwindow(RemminaConnectionObject *cnnobj)
+{
+	return &cnnobj->cnnwin->window;
+}
+GtkWidget *rcw_get_gtkviewport(RemminaConnectionObject *cnnobj)
+{
+	return cnnobj->viewport;
+}
+
+void rcw_set_delete_confirm_mode(RemminaConnectionWindow *cnnwin, RemminaConnectionWindowOnDeleteConfirmMode mode)
+{
+	TRACE_CALL(__func__);
+	cnnwin->priv->on_delete_confirm_mode = mode;
+}
+
+/**
+ * Deletes a RemminaMessagePanel from the current cnnobj
+ * and if it was visible, make visible the last remaining one.
+ */
+void rco_destroy_message_panel(RemminaConnectionObject *cnnobj, RemminaMessagePanel *mp)
+{
+	TRACE_CALL(__func__);
+	GList *childs, *cc;
+	RemminaMessagePanel *lastPanel;
+	gboolean was_visible;
+	GtkWidget *page;
+
+	page = nb_find_page_by_cnnobj(cnnobj->cnnwin->priv->notebook, cnnobj);
+	childs = gtk_container_get_children(GTK_CONTAINER(page));
+	cc = g_list_first(childs);
+	while (cc != NULL) {
+		if ((RemminaMessagePanel *)cc->data == mp)
+			break;
+		cc = g_list_next(cc);
+	}
+	g_list_free(childs);
+
+	if (cc == NULL) {
+		printf("Remmina: Warning. There was a request to destroy a RemminaMessagePanel that is not on the page\n");
+		return;
+	}
+	was_visible = gtk_widget_is_visible(GTK_WIDGET(mp));
+	gtk_widget_destroy(GTK_WIDGET(mp));
+
+	/* And now, show the last remaining message panel, if needed */
+	if (was_visible) {
+		childs = gtk_container_get_children(GTK_CONTAINER(page));
+		cc = g_list_first(childs);
+		lastPanel = NULL;
+		while (cc != NULL) {
+			if (G_TYPE_CHECK_INSTANCE_TYPE(cc->data, REMMINA_TYPE_MESSAGE_PANEL))
+				lastPanel = (RemminaMessagePanel *)cc->data;
+			cc = g_list_next(cc);
+		}
+		g_list_free(childs);
+		if (lastPanel)
+			gtk_widget_show(GTK_WIDGET(lastPanel));
+	}
+}
+
+/**
+ * Each cnnobj->page can have more than one RemminaMessagePanel, but 0 or 1 are visible.
+ *
+ * This function adds a RemminaMessagePanel to cnnobj->page, move it to top,
+ * and makes it the only visible one.
+ */
+void rco_show_message_panel(RemminaConnectionObject *cnnobj, RemminaMessagePanel *mp)
+{
+	TRACE_CALL(__func__);
+	GList *childs, *cc;
+	GtkWidget *page;
+
+	/* Hides all RemminaMessagePanels childs of cnnobj->page */
+	page = nb_find_page_by_cnnobj(cnnobj->cnnwin->priv->notebook, cnnobj);
+	childs = gtk_container_get_children(GTK_CONTAINER(page));
+	cc = g_list_first(childs);
+	while (cc != NULL) {
+		if (G_TYPE_CHECK_INSTANCE_TYPE(cc->data, REMMINA_TYPE_MESSAGE_PANEL))
+			gtk_widget_hide(GTK_WIDGET(cc->data));
+		cc = g_list_next(cc);
+	}
+	g_list_free(childs);
+
+	/* Add the new message panel at the top of cnnobj->page */
+	gtk_box_pack_start(GTK_BOX(page), GTK_WIDGET(mp), FALSE, FALSE, 0);
+	gtk_box_reorder_child(GTK_BOX(page), GTK_WIDGET(mp), 0);
+
+	/* Show the message panel */
+	gtk_widget_show_all(GTK_WIDGET(mp));
+
+	/* Focus the correct field of the RemminaMessagePanel */
+	remmina_message_panel_focus_auth_entry(mp);
+}
diff --git a/src/rcw.h b/src/rcw.h
new file mode 100644
index 0000000..6011abe
--- /dev/null
+++ b/src/rcw.h
@@ -0,0 +1,93 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009 - 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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include "remmina_file.h"
+#include "remmina_message_panel.h"
+
+G_BEGIN_DECLS
+
+#define   REMMINA_TYPE_CONNECTION_WINDOW            (rcw_get_type())
+#define   RCW(obj)                                  (G_TYPE_CHECK_INSTANCE_CAST((obj), REMMINA_TYPE_CONNECTION_WINDOW, RemminaConnectionWindow))
+#define   RCW_CLASS(klass)                          (G_TYPE_CHECK_CLASS_CAST((klass), REMMINA_TYPE_CONNECTION_WINDOW, RemminaConnectionWindowClass))
+#define   REMMINA_IS_CONNECTION_WINDOW(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), REMMINA_TYPE_CONNECTION_WINDOW))
+#define   REMMINA_IS_CONNECTION_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), REMMINA_TYPE_CONNECTION_WINDOW))
+#define   RCW_GET_CLASS(obj)                        (G_TYPE_INSTANCE_GET_CLASS((obj), REMMINA_TYPE_CONNECTION_WINDOW, RemminaConnectionWindowClass))
+
+typedef struct _RemminaConnectionWindowPriv RemminaConnectionWindowPriv;
+
+typedef struct _RemminaConnectionWindow {
+	GtkWindow			window;
+	RemminaConnectionWindowPriv *	priv;
+} RemminaConnectionWindow;
+
+typedef struct _RemminaConnectionWindowClass {
+	GtkWindowClass parent_class;
+	void (*toolbar_place)(RemminaConnectionWindow *gp);
+} RemminaConnectionWindowClass;
+
+typedef struct _RemminaConnectionObject RemminaConnectionObject;
+
+typedef enum {
+	RCW_ONDELETE_CONFIRM_IF_2_OR_MORE	= 0,
+	RCW_ONDELETE_NOCONFIRM			= 1
+} RemminaConnectionWindowOnDeleteConfirmMode;
+
+GType rcw_get_type(void)
+G_GNUC_CONST;
+
+/* Open a new connection window for a .remmina file */
+gboolean rcw_open_from_filename(const gchar *filename);
+/* Open a new connection window for a given RemminaFile struct. The struct will be freed after the call */
+void rcw_open_from_file(RemminaFile *remminafile);
+gboolean rcw_delete(RemminaConnectionWindow *cnnwin);
+void rcw_set_delete_confirm_mode(RemminaConnectionWindow *cnnwin, RemminaConnectionWindowOnDeleteConfirmMode mode);
+GtkWidget *rcw_open_from_file_full(RemminaFile *remminafile, GCallback disconnect_cb, gpointer data, guint *handler);
+GtkWindow* rcw_get_gtkwindow(RemminaConnectionObject *cnnobj);
+GtkWidget* rcw_get_gtkviewport(RemminaConnectionObject *cnnobj);
+
+void rco_destroy_message_panel(RemminaConnectionObject *cnnobj, RemminaMessagePanel *mp);
+void rco_show_message_panel(RemminaConnectionObject *cnnobj, RemminaMessagePanel *mp);
+void rco_get_monitor_geometry(RemminaConnectionObject *cnnobj, GdkRectangle *sz);
+
+
+
+#define MESSAGE_PANEL_SPINNER 0x00000001
+#define MESSAGE_PANEL_OKBUTTON 0x00000002
+
+G_END_DECLS
diff --git a/src/remmina.1 b/src/remmina.1
new file mode 100644
index 0000000..27fc505
--- /dev/null
+++ b/src/remmina.1
@@ -0,0 +1,229 @@
+.\" Generated by scdoc 1.11.2
+.\" Complete documentation for this program is not available as a GNU info page
+.ie \n(.g .ds Aq \(aq
+.el       .ds Aq '
+.nh
+.ad l
+.\" Begin generated content:
+.TH "REMMINA" "1" "2022-03-25"
+.PP
+.SH NAME
+.PP
+remmina -- Remmina the GTK+ Remote Desktop Client
+.PP
+.SH SYNOPSIS
+.PP
+remmina [-a|i|n|q|v] [-c FILE] [-e FILE] [-p TABINDEX] [-s SERVER] 
+[-t PROTOCOL] [-x PLUGIN] [--update-profile] 
+[--set-option OPTION[=VALUE]] [--display DISPLAY]
+.PP
+.SH DESCRIPTION
+.PP
+Remmina is a remote desktop client written in GTK+, aiming to be useful for
+system administrators and travellers, who need to work with lots of remote
+computers in front of either large monitors or tiny netbooks.\& Remmina
+supports multiple network protocols in an integrated and consistent user
+interface.\&
+.PP
+Currently RDP, VNC, SSH, SPICE, and WWW are supported.\&
+.PP
+Remmina is released in separated source packages:
+.PP
+.PD 0
+.IP \(bu 4
+"remmina", the main GTK+ application
+.IP \(bu 4
+"remmina-plugins", a set of plugins
+.PD
+.PP
+Remmina is free and open-source software, released under GNU GPL license.\&
+.PP
+.SH FILES
+.PP
+${XDG_CONFIG_DIRS}/remmina.\&pref or ${XDG_CONFIG_HOME}/remmina/remmina.\&pref :
+.PP
+Remmina configuration files.\&
+.PP
+At the first Remmina execution the system wide Remmina configuration files,
+will be copied in the ${XDG_CONFIG_HOME}
+.PP
+${XDG_DATA_DIRS}/FILE.\&remmina or ${XDG_DATA_HOME}/remmina/FILE.\&remmina :
+.PP
+Remmina profiles, the file name is autogenerated, but you can create
+manually your own files with the FILE name you prefer.\& It'\&s possible to
+specify a custom profile name and location.\&
+.PP
+.SH OPTIONS
+.PP
+\fB-h, --help\fR
+.RS 4
+Show help options
+.PP
+.RE
+\fB-a\fR
+.RS 4
+Show about dialog
+.PP
+.RE
+\fB-c, --connect=FILE\fR
+.RS 4
+Connect directly either to a desktop using options described in a file,
+or a supported URI (RDP, VNC, SSH or SPICE).\&
+.br
+The filetype can be ".\&remmina" or one supported by a plugin capable of
+importing files
+.PP
+.RE
+\fB-e, --edit=FILE\fR
+.RS 4
+Open and edit desktop connection using options described by file,
+file type can be either .\&remmina or one supported by a file
+import capable plugin
+.PP
+.RE
+\fB-k, --kiosk\fR
+.RS 4
+Start Remmina in kiosk mode (thin client)
+.PP
+.RE
+\fB-n, --new\fR
+.RS 4
+Create a new connection profile
+.PP
+.RE
+\fB-p, --pref=TABINDEX\fR
+.RS 4
+Show preferences dialog page
+.PP
+.RE
+\fB-x, --plugin=PLUGIN\fR
+.RS 4
+Execute the plugin
+.PP
+.RE
+\fB-q, --quit\fR
+.RS 4
+Quit the application
+.PP
+.RE
+\fB-s, --server=SERVER\fR
+.RS 4
+Use default server name (for \fB--new\fR)
+.PP
+.RE
+\fB-t, --protocol=PROTOCOL\fR
+.RS 4
+Use default protocol (for \fB--new\fR)
+.PP
+.RE
+\fB-i, --icon\fR
+.RS 4
+Start as tray icon
+.PP
+.RE
+\fB-v, --version\fR
+.RS 4
+Show the application'\&s version
+.PP
+.RE
+\fB--update-profile\fR
+.RS 4
+Modify connection profile, require also \fB--set-option\fR
+.PP
+.RE
+\fB--set-option OPTION[=VALUE]\fR
+.RS 4
+Set one or more profile settings, to be used with \fB--update-pro-file\fR
+.PP
+.RE
+\fB--encrypt-password\fR
+.RS 4
+Encrypt a password
+.PP
+.RE
+\fB--display=DISPLAY\fR
+.RS 4
+X display to use
+.PP
+.RE
+\fB--disable-toolbar\fR
+.RS 4
+Disable toolbar
+.PP
+.RE
+\fB--enable-fullscreen\fR
+.RS 4
+Enable fullscreen
+.PP
+.RE
+\fB--enable-extra-hardening\fR
+.RS 4
+Enable extra hardening (disable closing confirmation, disable unsafe shortcut keys, hide tabs, hide search bar)
+.br
+List of disabled shortcut keys:
+.br
+fullscreen, autofit, prevtab and nexttab, scale, grab, minimize, viewonly, screenshot, disconnect, toolbar
+.PP
+.RE
+\fB--no-tray-icon\fR
+.RS 4
+Disable tray icon
+.PP
+.RE
+.SH EXAMPLES
+.PP
+To connect using an exisitng connection profile use:
+\fBremmina -c FILE.\&remmina\fR
+.PP
+To quick connect using a URI:
+.PP
+remmina -c rdp://username@server
+.br
+remmina -c rdp://domain\\\\username@server
+.br
+remmina -c vnc://username@server
+.br
+remmina -c vnc://server?\&VncUsername=username
+.br
+remmina -c ssh://user@server
+.br
+remmina -c spice://server
+.PP
+To quick connect using a URI along with an encrypted password:
+.PP
+remmina -c rdp://username:encrypted-password@server
+.br
+remmina -c vnc://username:encrypted-password@server
+.br
+remmina -c vnc://server?\&VncUsername=username\\&VncPassword=encrypted-password
+.PP
+To encrypt a password for use with a URI:
+.PP
+remmina --encrypt-password
+.PP
+To update username and password and set a different resolution mode of a
+remmina connection profile use:
+.PP
+echo "ausernamenapassword" | remmina --update-profile /PATH/TO/FOO.\&remmina --set-option username --set-option resolution_mode=2 --set-option password
+.PP
+.SH SEE ALSO
+.PP
+remmina-file-wrapper(1)
+.PP
+.SH AUTHORS
+.PP
+Antenore Gatta <antenore at simbiosi dot org> and
+Giovanni Panozzo <giovanni at panozzo dot it>
+.PP
+See the THANKS file for a more detailed list.\&
+.PP
+Remmina was initially written by Vic Lee <llyzs@163.\&com>
+.PP
+This manual page was written by Antenore Gatta <antenore at simbiosi dot org>.\&
+.PP
+.SH COPYRIGHT
+.PP
+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, or (at your option) any later
+version.\&
diff --git a/src/remmina.c b/src/remmina.c
new file mode 100644
index 0000000..cd8ce56
--- /dev/null
+++ b/src/remmina.c
@@ -0,0 +1,489 @@
+/*
+ * Remmina - The GTK Remote Desktop Client
+ * Copyright (C) 2014-2023 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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 <curl/curl.h>
+#include <gdk/gdk.h>
+
+#define G_LOG_USE_STRUCTURED
+#ifndef G_LOG_DOMAIN
+#define G_LOG_DOMAIN    ((gchar*)"remmina")
+#endif  /* G_LOG_DOMAIN */
+#ifdef GDK_WINDOWING_X11
+#include <gdk/gdkx.h>
+#elif defined(GDK_WINDOWING_WAYLAND)
+#include <gdk/gdkwayland.h>
+#endif
+#include <gio/gio.h>
+#include <glib/gi18n.h>
+#include <stdlib.h>
+
+#include "config.h"
+#include "remmina_sodium.h"
+#include "remmina.h"
+#include "remmina_exec.h"
+#include "remmina_file_manager.h"
+#include "remmina_icon.h"
+#include "remmina_log.h"
+#include "remmina_main.h"
+#include "remmina_masterthread_exec.h"
+#include "remmina_plugin_manager.h"
+#include "remmina_plugin_native.h"
+#ifdef WITH_PYTHONLIBS
+#include "remmina_plugin_python.h"
+#endif
+#include "remmina_pref.h"
+#include "remmina_public.h"
+#include "remmina_sftp_plugin.h"
+#include "remmina_ssh_plugin.h"
+#include "remmina_widget_pool.h"
+#include "remmina/remmina_trace_calls.h"
+#include "remmina_info.h"
+
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#include <pthread.h>
+#ifdef HAVE_LIBGCRYPT
+#include <gcrypt.h>
+# if GCRYPT_VERSION_NUMBER < 0x010600
+GCRY_THREAD_OPTION_PTHREAD_IMPL;
+#endif  /* !GCRYPT_VERSION_NUMBER */
+#endif  /* HAVE_LIBGCRYPT */
+
+#ifdef HAVE_LIBGCRYPT
+# if GCRYPT_VERSION_NUMBER < 0x010600
+static int gcrypt_thread_initialized = 0;
+#endif  /* !GCRYPT_VERSION_NUMBER */
+#endif  /* HAVE_LIBGCRYPT */
+
+gboolean kioskmode;
+gboolean imode;
+gboolean disablenews;
+gboolean disablestats;
+gboolean disabletoolbar;
+gboolean fullscreen;
+gboolean extrahardening;
+gboolean disabletrayicon;
+
+static GOptionEntry remmina_options[] =
+{
+	// TRANSLATORS: Shown in terminal. Do not use characters that may be not supported on a terminal
+	{ "about",	      'a',  0,			  G_OPTION_ARG_NONE,	       NULL, N_("Show \'About\'"),								     NULL	},
+	// TRANSLATORS: Shown in terminal. Do not use characters that may be not supported on a terminal
+	{ "connect",	      'c',  0,			  G_OPTION_ARG_FILENAME_ARRAY, NULL, N_("Connect either to a desktop described in a file (.remmina or a filetype supported by a plugin) or a supported URI (RDP, VNC, SSH or SPICE)"),	     N_("FILE")	},
+	// TRANSLATORS: Shown in terminal. Do not use characters that may be not supported on a terminal
+	{ G_OPTION_REMAINING, '\0', 0,			  G_OPTION_ARG_FILENAME_ARRAY, NULL, N_("Connect to a desktop described in a file (.remmina or a filetype supported by a plugin)"),	     N_("FILE")	},
+	// TRANSLATORS: Shown in terminal. Do not use characters that may be not supported on a terminal
+	{ "edit",	      'e',  0,			  G_OPTION_ARG_FILENAME_ARRAY, NULL, N_("Edit desktop connection described in file (.remmina or a filetype supported by plugin)"), N_("FILE")	},
+	{ "help",	      '?',  G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_NONE,	       NULL, NULL,										     NULL	},
+	// TRANSLATORS: Shown in terminal. Do not use characters that may be not supported on a terminal
+	{ "kiosk",	      'k',  0,			  G_OPTION_ARG_NONE,	       NULL, N_("Start in kiosk mode"),								     NULL	},
+	// TRANSLATORS: Shown in terminal. Do not use characters that may be not supported on a terminal
+	{ "new",	      'n',  0,			  G_OPTION_ARG_NONE,	       NULL, N_("Create new connection profile"),						     NULL	},
+	// TRANSLATORS: Shown in terminal. Do not use characters that may be not supported on a terminal
+	{ "pref",	      'p',  0,			  G_OPTION_ARG_STRING,	       NULL, N_("Show preferences"),								     N_("TABINDEX")	},
+#if 0
+	/* This option was used mainly for telepathy, let's keep it if we will need it in the future */
+	// TRANSLATORS: Shown in terminal. Do not use characters that may be not supported on a terminal
+	//{ "plugin",	      'x',  0,			  G_OPTION_ARG_STRING,	       NULL, N_("Run a plugin"),								     N_("PLUGIN")	},
+#endif
+	// TRANSLATORS: Shown in terminal. Do not use characters that may be not supported on a terminal
+	{ "quit",	      'q',  0,			  G_OPTION_ARG_NONE,	       NULL, N_("Quit"),									     NULL	},
+	// TRANSLATORS: Shown in terminal. Do not use characters that may be not supported on a terminal
+	{ "server",	      's',  0,			  G_OPTION_ARG_STRING,	       NULL, N_("Use default server name (for --new)"),						     N_("SERVER")	},
+	// TRANSLATORS: Shown in terminal. Do not use characters that may be not supported on a terminal
+	{ "protocol",	      't',  0,			  G_OPTION_ARG_STRING,	       NULL, N_("Use default protocol (for --new)"),						     N_("PROTOCOL") },
+	// TRANSLATORS: Shown in terminal. Do not use characters that may be not supported on a terminal
+	{ "icon",	      'i',  0,			  G_OPTION_ARG_NONE,	       NULL, N_("Start in tray"),								     NULL	},
+	// TRANSLATORS: Shown in terminal. Do not use characters that may be not supported on a terminal
+	{ "version",	      'v',  0,			  G_OPTION_ARG_NONE,	       NULL, N_("Show the application version"),						     NULL	},
+	// TRANSLATORS: Shown in terminal. Do not use characters that may be not supported on a terminal
+	{ "full-version",     'V',  0,			  G_OPTION_ARG_NONE,	       NULL, N_("Show version of the application and its plugins"),				     NULL	},
+	// TRANSLATORS: Shown in terminal. Do not use characters that may be not supported on a terminal
+	{ "update-profile",   0,    0,			  G_OPTION_ARG_FILENAME,       NULL, N_("Modify connection profile (requires --set-option)"),				     NULL	},
+	// TRANSLATORS: Shown in terminal. Do not use characters that may be not supported on a terminal
+	{ "set-option",	      0,    0,			  G_OPTION_ARG_STRING_ARRAY,   NULL, N_("Set one or more profile settings, to be used with --update-profile"),		     NULL	},
+	{ "encrypt-password", 0,    0,			  G_OPTION_ARG_NONE,	       NULL, N_("Encrypt a password"),												  NULL		 },
+	{ "disable-news",     0,    0,            G_OPTION_ARG_NONE,           NULL, N_("Disable news"),                                                NULL           },
+	{ "disable-stats",    0,    0,            G_OPTION_ARG_NONE,           NULL, N_("Disable stats"),                                                NULL           },
+	{ "disable-toolbar", 0,    0,			  G_OPTION_ARG_NONE,	       NULL, N_("Disable toolbar"),												  NULL		 },
+	{ "enable-fullscreen", 0,    0,			  G_OPTION_ARG_NONE,	       NULL, N_("Enable fullscreen"),												  NULL		 },
+	{ "enable-extra-hardening", 0,    0,		  G_OPTION_ARG_NONE,	       NULL, N_("Enable extra hardening (disable closing confirmation, disable unsafe shortcut keys, hide tabs, hide search bar)"),	  NULL		 },
+	{ "no-tray-icon", 0,    0,			  G_OPTION_ARG_NONE,	       NULL, N_("Disable tray icon"),												  NULL		 },
+	{ NULL }
+};
+
+#ifdef WITH_LIBGCRYPT
+static int
+_gpg_error_to_errno(gcry_error_t e)
+{
+	/* be lazy right now */
+	if (e == GPG_ERR_NO_ERROR)
+		return 0;
+	else
+		return EINVAL;
+}
+#endif /* !WITH_LIBGCRYPT */
+
+static gint remmina_on_command_line(GApplication *app, GApplicationCommandLine *cmdline)
+{
+	TRACE_CALL(__func__);
+
+	gint status = 0;
+	gboolean executed = FALSE;
+	GVariantDict *opts;
+	gchar *str;
+	const gchar **files;
+	const gchar **remaining_args;
+	gchar *protocol;
+	gchar *server;
+
+#if SODIUM_VERSION_INT >= 90200
+	remmina_sodium_init();
+#endif
+	opts = g_application_command_line_get_options_dict(cmdline);
+
+	if (g_variant_dict_lookup_value(opts, "disable-news", NULL)) {
+		disablenews = TRUE;
+	}
+
+	if (g_variant_dict_lookup_value(opts, "disable-stats", NULL)) {
+		disablestats = TRUE;
+	}
+
+	if (g_variant_dict_lookup_value(opts, "disable-toolbar", NULL)) {
+		disabletoolbar = TRUE;
+	}
+
+	if (g_variant_dict_lookup_value(opts, "enable-fullscreen", NULL)) {
+		fullscreen = TRUE;
+	}
+
+	if (g_variant_dict_lookup_value(opts, "enable-extra-hardening", NULL)) {
+		extrahardening = TRUE;
+	}
+
+	if (g_variant_dict_lookup_value(opts, "no-tray-icon", NULL)) {
+		disabletrayicon = TRUE;
+	}
+
+	remmina_pref_init();
+
+	if (g_variant_dict_lookup_value(opts, "quit", NULL)) {
+		remmina_exec_command(REMMINA_COMMAND_EXIT, NULL);
+		executed = TRUE;
+		status = 1;
+	}
+
+	if (g_variant_dict_lookup_value(opts, "about", NULL)) {
+		imode = TRUE;
+		remmina_exec_command(REMMINA_COMMAND_ABOUT, NULL);
+		executed = TRUE;
+	}
+
+	/** @warning To be used like -c FILE -c FILE -c FILE …
+	 *
+	 */
+	if (g_variant_dict_lookup(opts, "connect", "^aay", &files)) {
+		if (files)
+			for (gint i = 0; files[i]; i++) {
+				g_debug ("Connecting to: %s", files[i]);
+				remmina_exec_command(REMMINA_COMMAND_CONNECT, files[i]);
+			}
+		executed = TRUE;
+	}
+
+	if (g_variant_dict_lookup(opts, G_OPTION_REMAINING, "^a&ay", &remaining_args)) {
+		remmina_exec_command(REMMINA_COMMAND_CONNECT, remaining_args[0]);
+		g_free(remaining_args);
+		executed = TRUE;
+	}
+
+	if (g_variant_dict_lookup(opts, "edit", "^aay", &files)) {
+		imode = TRUE;
+		if (files)
+			for (gint i = 0; files[i]; i++) {
+				g_debug ("Editing file: %s", files[i]);
+				remmina_exec_command(REMMINA_COMMAND_EDIT, files[i]);
+			}
+		//remmina_exec_command(REMMINA_COMMAND_EDIT, str);
+		//g_free(str);
+		executed = TRUE;
+	}
+
+	if (g_variant_dict_lookup_value(opts, "kiosk", NULL)) {
+		kioskmode = TRUE;
+		imode = TRUE;
+		remmina_exec_command(REMMINA_COMMAND_MAIN, NULL);
+		executed = TRUE;
+	}
+
+	if (g_variant_dict_lookup_value(opts, "new", NULL)) {
+		if (!g_variant_dict_lookup(opts, "protocol", "&s", &protocol))
+			protocol = NULL;
+
+		if (g_variant_dict_lookup(opts, "server", "&s", &server))
+			str = g_strdup_printf("%s,%s", protocol, server);
+		else
+			str = g_strdup(protocol);
+
+		remmina_exec_command(REMMINA_COMMAND_NEW, str);
+		g_free(str);
+		executed = TRUE;
+	}
+
+	if (g_variant_dict_lookup(opts, "pref", "&s", &str)) {
+		imode = TRUE;
+		remmina_exec_command(REMMINA_COMMAND_PREF, str);
+		executed = TRUE;
+	}
+
+	if (g_variant_dict_lookup(opts, "plugin", "&s", &str)) {
+		remmina_exec_command(REMMINA_COMMAND_PLUGIN, str);
+		executed = TRUE;
+	}
+
+	if (g_variant_dict_lookup_value(opts, "icon", NULL)) {
+		remmina_exec_command(REMMINA_COMMAND_NONE, NULL);
+		executed = TRUE;
+	}
+
+	if (g_variant_dict_lookup_value(opts, "encrypt-password", NULL)) {
+		remmina_exec_command(REMMINA_COMMAND_ENCRYPT_PASSWORD, NULL);
+		executed = TRUE;
+		status = 1;
+	}
+
+	if (!executed)
+		remmina_exec_command(REMMINA_COMMAND_MAIN, NULL);
+
+	return status;
+}
+
+static void remmina_on_startup(GApplication *app)
+{
+	TRACE_CALL(__func__);
+
+	RemminaSecretPlugin *secret_plugin;
+
+	remmina_widget_pool_init();
+	remmina_sftp_plugin_register();
+	remmina_ssh_plugin_register();
+	remmina_icon_init();
+	g_set_application_name("Remmina");
+	gtk_window_set_default_icon_name(REMMINA_APP_ID);
+
+	/* Setting the X11 program class (WM_CLASS) is necessary to group
+	* windows with .desktop file which has the same StartupWMClass */
+	gdk_set_program_class(REMMINA_APP_ID);
+
+	gtk_icon_theme_append_search_path(gtk_icon_theme_get_default(),
+					  REMMINA_RUNTIME_DATADIR G_DIR_SEPARATOR_S "icons");
+	g_application_hold(app);
+	remmina_info_schedule();
+
+	gchar *log_filename = g_build_filename(g_get_tmp_dir(), LOG_FILE_NAME, NULL);
+	FILE *log_file = fopen(log_filename, "w"); // Flush log file
+	g_free(log_filename);
+
+	if (log_file != NULL) {
+		fclose(log_file);
+	}
+
+	/* Check for secret plugin and service initialization and show console warnings if
+	 * something is missing */
+	remmina_plugin_manager_get_available_plugins();
+	secret_plugin = remmina_plugin_manager_get_secret_plugin();
+	if (!secret_plugin)
+		g_print("Warning: Remmina is running without a secret plugin. Passwords will be saved in a less secure way.\n");
+	else
+		if (!secret_plugin->is_service_available(secret_plugin))
+			g_print("Warning: Remmina is running with a secrecy plugin, but it cannot connect to a secrecy service.\n");
+
+	remmina_exec_command(REMMINA_COMMAND_AUTOSTART, NULL);
+}
+
+static gint remmina_on_local_cmdline(GApplication *app, GVariantDict *opts, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+
+	int status = -1;
+	gchar *str;
+	gchar **settings;
+
+	/* Here you handle any command line options that you want to be executed
+	 * in the local instance (the non-unique instance) */
+
+	if (g_variant_dict_lookup_value(opts, "version", NULL)) {
+		remmina_exec_command(REMMINA_COMMAND_VERSION, NULL);
+		status = 0;
+	}
+
+	if (g_variant_dict_lookup_value(opts, "full-version", NULL)) {
+		remmina_exec_command(REMMINA_COMMAND_FULL_VERSION, NULL);
+		status = 0;
+	}
+
+	if (g_variant_dict_lookup(opts, "update-profile", "^&ay", &str)) { /* ^&ay no need to free */
+		if (g_variant_dict_lookup(opts, "set-option", "^a&s", &settings)) {
+			if (settings != NULL) {
+				status = remmina_exec_set_setting(str, settings);
+				g_free(settings);
+			} else {
+				status = 1;
+			}
+		} else {
+			status = 1;
+			g_print("Error: --update-profile requires --set-option\n");
+		}
+	}
+
+	/* Returning a non negative value here makes the application exit */
+	return status;
+}
+
+int main(int argc, char *argv[])
+{
+	TRACE_CALL(__func__);
+	GtkApplication *app;
+	const gchar *app_id;
+	int status;
+
+	g_unsetenv("GDK_CORE_DEVICE_EVENTS");
+
+	// Checking for environment variable "G_MESSAGES_DEBUG"
+	// Give the less familiar with GLib a tip on where to get
+	// more debugging info.
+	if(!getenv("G_MESSAGES_DEBUG")) {
+		/* TRANSLATORS:
+		 * This link should point to a resource explaining how to get Remmina
+		 * to log more verbose statements.
+		 */
+		g_message(_("Remmina does not log all output statements. "
+			    "Turn on more verbose output by using "
+			    "\"G_MESSAGES_DEBUG=remmina\" as an environment variable.\n"
+			    "More info available on the Remmina wiki at:\n"
+			    "https://gitlab.com/Remmina/Remmina/-/wikis/Usage/Remmina-debugging"
+		));
+	}
+
+	/* Enable wayland backend only after GTK 3.22.27 or the clipboard
+	 * will not work. See GTK bug 790031 */
+	if (remmina_gtk_check_version(3, 22, 27))
+		gdk_set_allowed_backends("wayland,x11,broadway,quartz,mir");
+	else
+		gdk_set_allowed_backends("x11,broadway,quartz,mir");
+
+	remmina_masterthread_exec_save_main_thread_id();
+
+	bindtextdomain(GETTEXT_PACKAGE, REMMINA_RUNTIME_LOCALEDIR);
+	bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
+	textdomain(GETTEXT_PACKAGE);
+
+#ifdef HAVE_LIBGCRYPT
+# if GCRYPT_VERSION_NUMBER < 0x010600
+	gcry_error_t e;
+	if (!gcrypt_thread_initialized) {
+		if ((e = gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread)) != GPG_ERR_NO_ERROR)
+			return -1;
+		gcrypt_thread_initialized++;
+	}
+#endif  /* !GCRYPT_VERSION_NUMBER */
+	gcry_check_version(NULL);
+	gcry_control(GCRYCTL_DISABLE_SECMEM, 0);
+	gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0);
+#endif  /* !HAVE_LIBGCRYPT */
+
+	/* Initialize some Remmina parts needed also on a local instance for correct handle-local-options */
+	curl_global_init(CURL_GLOBAL_ALL);
+	remmina_pref_init();
+	remmina_file_manager_init();
+	remmina_plugin_manager_init();
+
+
+
+	app_id = g_application_id_is_valid(REMMINA_APP_ID) ? REMMINA_APP_ID : NULL;
+	app = gtk_application_new(app_id, G_APPLICATION_HANDLES_COMMAND_LINE | G_APPLICATION_CAN_OVERRIDE_APP_ID);
+#if !GTK_CHECK_VERSION(4, 0, 0) /* This is not needed anymore starting from GTK 4 */
+	g_set_prgname(app_id);
+#endif
+	g_application_add_main_option_entries(G_APPLICATION(app), remmina_options);
+#if GLIB_CHECK_VERSION(2,56,0)
+	gchar *summary = g_strdup_printf ("%s %s", app_id, VERSION);
+	g_application_set_option_context_summary (G_APPLICATION(app), summary);
+	g_free(summary);
+	// TRANSLATORS: Shown in terminal. Do not use characters that may be not supported on a terminal
+	g_application_set_option_context_parameter_string (G_APPLICATION(app), _("- or protocol://username:encryptedpassword@host:port"));
+	// TRANSLATORS: Shown in terminal. Do not use characters that may be not supported on a terminal
+	g_application_set_option_context_description (G_APPLICATION(app),
+			_("Examples:\n"
+				"To connect using an existing connection profile, use:\n"
+				"\n"
+				"\tremmina -c FILE.remmina\n"
+				"\n"
+				"To quick connect using a URI:\n"
+				"\n"
+				"\tremmina -c rdp://username@server\n"
+				"\tremmina -c rdp://domain\\\\username@server\n"
+				"\tremmina -c vnc://username@server\n"
+				"\tremmina -c vnc://server?VncUsername=username\n"
+				"\tremmina -c ssh://user@server\n"
+				"\tremmina -c spice://server\n"
+				"\n"
+				"To quick connect using a URI along with an encrypted password:\n"
+				"\n"
+				"\tremmina -c rdp://username:encrypted-password@server\n"
+				"\tremmina -c vnc://username:encrypted-password@server\n"
+				"\tremmina -c vnc://server?VncUsername=username\\&VncPassword=encrypted-password\n"
+				"\n"
+				"To encrypt a password for use with a URI:\n"
+				"\n"
+				"\tremmina --encrypt-password\n"
+				"\n"
+				"To update username and password and set a different resolution mode of a Remmina connection profile, use:\n"
+				"\n"
+				"\techo \"username\\napassword\" | remmina --update-profile /PATH/TO/FOO.remmina --set-option username --set-option resolution_mode=2 --set-option password\n"));
+#endif
+
+	g_signal_connect(app, "startup", G_CALLBACK(remmina_on_startup), NULL);
+	g_signal_connect(app, "command-line", G_CALLBACK(remmina_on_command_line), NULL);
+	g_signal_connect(app, "handle-local-options", G_CALLBACK(remmina_on_local_cmdline), NULL);
+
+
+	g_application_set_inactivity_timeout(G_APPLICATION(app), 10000);
+	status = g_application_run(G_APPLICATION(app), argc, argv);
+	g_object_unref(app);
+
+	return status;
+}
diff --git a/src/remmina.h b/src/remmina.h
new file mode 100644
index 0000000..05d8f06
--- /dev/null
+++ b/src/remmina.h
@@ -0,0 +1,43 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2014-2023 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+extern gboolean kioskmode;
+extern gboolean imode;
+G_END_DECLS
diff --git a/src/remmina.scd b/src/remmina.scd
new file mode 100644
index 0000000..c9eec11
--- /dev/null
+++ b/src/remmina.scd
@@ -0,0 +1,172 @@
+REMMINA(1)
+
+# NAME
+
+remmina -- Remmina the GTK+ Remote Desktop Client
+
+# SYNOPSIS
+
+remmina [-a|i|n|q|v] [-c FILE] [-e FILE] [-p TABINDEX] [-s SERVER] \
+[-t PROTOCOL] [-x PLUGIN] [--update-profile] \
+[--set-option OPTION[=VALUE]] [--display DISPLAY]
+
+# DESCRIPTION
+
+Remmina is a remote desktop client written in GTK+, aiming to be useful for
+system administrators and travellers, who need to work with lots of remote
+computers in front of either large monitors or tiny netbooks. Remmina
+supports multiple network protocols in an integrated and consistent user
+interface.
+
+Currently RDP, VNC, SSH, SPICE, and WWW are supported.
+
+Remmina is released in separated source packages:
+
+- "remmina", the main GTK+ application
+- "remmina-plugins", a set of plugins
+
+Remmina is free and open-source software, released under GNU GPL license.
+
+# FILES
+
+${XDG_CONFIG_DIRS}/remmina.pref or ${XDG_CONFIG_HOME}/remmina/remmina.pref :
+
+Remmina configuration files.
+
+At the first Remmina execution the system wide Remmina configuration files,
+will be copied in the ${XDG_CONFIG_HOME}
+
+${XDG_DATA_DIRS}/FILE.remmina or ${XDG_DATA_HOME}/remmina/FILE.remmina :
+
+Remmina profiles, the file name is autogenerated, but you can create
+manually your own files with the FILE name you prefer. It's possible to
+specify a custom profile name and location.
+
+# OPTIONS
+
+*-h, --help*
+	Show help options
+
+*-a*
+	Show about dialog
+
+*-c, --connect=FILE*
+	Connect directly either to a desktop using options described in a file,
+	or a supported URI (RDP, VNC, SSH or SPICE).++
+The filetype can be ".remmina" or one supported by a plugin capable of
+	importing files
+
+*-e, --edit=FILE*
+	Open and edit desktop connection using options described by file,
+	file type can be either .remmina or one supported by a file
+	import capable plugin
+
+*-k, --kiosk*
+	Start Remmina in kiosk mode (thin client)
+
+*-n, --new*
+	Create a new connection profile
+
+*-p, --pref=TABINDEX*
+	Show preferences dialog page
+
+*-x, --plugin=PLUGIN*
+	Execute the plugin
+
+*-q, --quit*
+	Quit the application
+
+*-s, --server=SERVER*
+	Use default server name (for *--new*)
+
+*-t, --protocol=PROTOCOL*
+	Use default protocol (for *--new*)
+
+*-i, --icon*
+	Start as tray icon
+
+*-v, --version*
+	Show the application's version
+
+*--update-profile*
+	Modify connection profile, require also *--set-option*
+
+*--set-option OPTION[=VALUE]*
+	Set one or more profile settings, to be used with *--update-pro-file*
+
+*--encrypt-password*
+	Encrypt a password
+
+*--display=DISPLAY*
+	X display to use
+
+*--disable-news*
+    Disable news
+
+*--disable-stats*
+    Disable stats
+
+*--disable-toolbar*
+	Disable toolbar
+
+*--enable-fullscreen*
+	Enable fullscreen
+
+*--enable-extra-hardening*
+	Enable extra hardening (disable closing confirmation, disable unsafe shortcut keys, hide tabs, hide search bar)++
+List of disabled shortcut keys:++
+fullscreen, autofit, prevtab and nexttab, scale, grab, minimize, viewonly, screenshot, disconnect, toolbar
+
+*--no-tray-icon*
+	Disable tray icon
+
+# EXAMPLES
+
+To connect using an exisitng connection profile use:
+*remmina -c FILE.remmina*
+
+To quick connect using a URI:
+
+remmina -c rdp://username@server++
+remmina -c rdp://domain\\\\username@server++
+remmina -c vnc://username@server++
+remmina -c vnc://server?VncUsername=username++
+remmina -c ssh://user@server++
+remmina -c spice://server
+
+To quick connect using a URI along with an encrypted password:
+
+remmina -c rdp://username:encrypted-password@server++
+remmina -c vnc://username:encrypted-password@server++
+remmina -c vnc://server?VncUsername=username\\&VncPassword=encrypted-password
+
+To encrypt a password for use with a URI:
+
+remmina --encrypt-password
+
+To update username and password and set a different resolution mode of a
+remmina connection profile use:
+
+echo "ausername\napassword" | remmina --update-profile /PATH/TO/FOO.remmina --set-option username --set-option resolution_mode=2 --set-option password
+
+# SEE ALSO
+
+remmina-file-wrapper(1)
+
+# AUTHORS
+
+Antenore Gatta <antenore at simbiosi dot org> and
+Giovanni Panozzo <giovanni at panozzo dot it>
+
+See the THANKS file for a more detailed list.
+
+Remmina was initially written by Vic Lee <llyzs@163.com>
+
+This manual page was written by Antenore Gatta <antenore at simbiosi dot org>.
+
+# COPYRIGHT
+
+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, or (at your option) any later
+version.
diff --git a/src/remmina_about.c b/src/remmina_about.c
new file mode 100644
index 0000000..b8d4a29
--- /dev/null
+++ b/src/remmina_about.c
@@ -0,0 +1,64 @@
+/*
+ * 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 <glib/gi18n.h>
+#include "remmina_about.h"
+#include "remmina_public.h"
+#include "remmina/remmina_trace_calls.h"
+
+/* Show the about dialog from the file ui/remmina_about.glade */
+void remmina_about_open(GtkWindow *parent)
+{
+	TRACE_CALL(__func__);
+
+	GtkBuilder *builder = remmina_public_gtk_builder_new_from_resource ("/org/remmina/Remmina/src/../data/ui/remmina_about.glade");
+	GtkDialog *dialog = GTK_DIALOG(gtk_builder_get_object(builder, "dialog_remmina_about"));
+
+	gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(dialog), VERSION " (git " REMMINA_GIT_REVISION ")");
+	// TRANSLATORS: translator-credits should be replaced with a formatted list of translators in your own language
+	gtk_about_dialog_set_translator_credits(GTK_ABOUT_DIALOG(dialog), _("translator-credits"));
+
+	if (parent) {
+		gtk_window_set_transient_for(GTK_WINDOW(dialog), parent);
+		gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE);
+	}
+
+	g_signal_connect(dialog, "response", G_CALLBACK(gtk_widget_destroy), NULL);
+	gtk_window_present(GTK_WINDOW(dialog));
+
+	g_object_unref(G_OBJECT(builder));
+}
diff --git a/src/remmina_about.h b/src/remmina_about.h
new file mode 100644
index 0000000..ac746c0
--- /dev/null
+++ b/src/remmina_about.h
@@ -0,0 +1,44 @@
+/*
+ * 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.
+ *
+ */
+
+#pragma once
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+void remmina_about_open(GtkWindow *parent);
+
+G_END_DECLS
diff --git a/src/remmina_applet_menu.c b/src/remmina_applet_menu.c
new file mode 100644
index 0000000..fa1362f
--- /dev/null
+++ b/src/remmina_applet_menu.c
@@ -0,0 +1,283 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010 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 <glib/gi18n.h>
+#include <string.h>
+
+#include "remmina_public.h"
+#include "remmina_applet_menu.h"
+#include "remmina_file_manager.h"
+#include "remmina_pref.h"
+#include "remmina/remmina_trace_calls.h"
+
+G_DEFINE_TYPE( RemminaAppletMenu, remmina_applet_menu, GTK_TYPE_MENU)
+
+struct _RemminaAppletMenuPriv {
+	gboolean hide_count;
+};
+
+enum {
+	LAUNCH_ITEM_SIGNAL, EDIT_ITEM_SIGNAL, LAST_SIGNAL
+};
+
+static guint remmina_applet_menu_signals[LAST_SIGNAL] =
+{ 0 };
+
+static void remmina_applet_menu_destroy(RemminaAppletMenu *menu, gpointer data)
+{
+	TRACE_CALL(__func__);
+	g_free(menu->priv);
+}
+
+static void remmina_applet_menu_class_init(RemminaAppletMenuClass *klass)
+{
+	TRACE_CALL(__func__);
+	remmina_applet_menu_signals[LAUNCH_ITEM_SIGNAL] = g_signal_new("launch-item", G_TYPE_FROM_CLASS(klass),
+		G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaAppletMenuClass, launch_item), NULL, NULL,
+		g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, G_TYPE_OBJECT);
+	remmina_applet_menu_signals[EDIT_ITEM_SIGNAL] = g_signal_new("edit-item", G_TYPE_FROM_CLASS(klass),
+		G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaAppletMenuClass, edit_item), NULL, NULL,
+		g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, G_TYPE_OBJECT);
+}
+
+static void remmina_applet_menu_init(RemminaAppletMenu *menu)
+{
+	TRACE_CALL(__func__);
+	menu->priv = g_new0(RemminaAppletMenuPriv, 1);
+
+	g_signal_connect(G_OBJECT(menu), "destroy", G_CALLBACK(remmina_applet_menu_destroy), NULL);
+}
+
+static void remmina_applet_menu_on_item_activate(RemminaAppletMenuItem *menuitem, RemminaAppletMenu *menu)
+{
+	TRACE_CALL(__func__);
+	g_signal_emit(G_OBJECT(menu), remmina_applet_menu_signals[LAUNCH_ITEM_SIGNAL], 0, menuitem);
+}
+
+static GtkWidget*
+remmina_applet_menu_add_group(GtkWidget *menu, const gchar *group, gint position, RemminaAppletMenuItem *menuitem,
+			      GtkWidget **groupmenuitem)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget;
+	GtkWidget *submenu;
+
+	widget = gtk_menu_item_new_with_label(group);
+	gtk_widget_show(widget);
+
+	g_object_set_data_full(G_OBJECT(widget), "group", g_strdup(group), g_free);
+	g_object_set_data(G_OBJECT(widget), "count", GINT_TO_POINTER(0));
+	if (groupmenuitem) {
+		*groupmenuitem = widget;
+	}
+	if (position < 0) {
+		gtk_menu_shell_append(GTK_MENU_SHELL(menu), widget);
+	}else  {
+		gtk_menu_shell_insert(GTK_MENU_SHELL(menu), widget, position);
+	}
+
+	submenu = gtk_menu_new();
+	gtk_widget_show(submenu);
+	gtk_menu_item_set_submenu(GTK_MENU_ITEM(widget), submenu);
+
+	return submenu;
+}
+
+static void remmina_applet_menu_increase_group_count(GtkWidget *widget)
+{
+	TRACE_CALL(__func__);
+	gint cnt;
+	gchar *s;
+
+	cnt = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "count")) + 1;
+	g_object_set_data(G_OBJECT(widget), "count", GINT_TO_POINTER(cnt));
+	s = g_strdup_printf("%s (%i)", (const gchar*)g_object_get_data(G_OBJECT(widget), "group"), cnt);
+	gtk_menu_item_set_label(GTK_MENU_ITEM(widget), s);
+	g_free(s);
+}
+
+void remmina_applet_menu_register_item(RemminaAppletMenu *menu, RemminaAppletMenuItem *menuitem)
+{
+	TRACE_CALL(__func__);
+	g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(remmina_applet_menu_on_item_activate), menu);
+}
+
+void remmina_applet_menu_add_item(RemminaAppletMenu *menu, RemminaAppletMenuItem *menuitem)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *submenu;
+	GtkWidget *groupmenuitem;
+	GtkMenuItem *submenuitem;
+	gchar *s, *p1, *p2, *mstr;
+	GList *childs, *child;
+	gint position;
+
+	submenu = GTK_WIDGET(menu);
+	s = g_strdup(menuitem->group);
+	p1 = s;
+	p2 = p1 ? strchr(p1, '/') : NULL;
+	if (p2)
+		*p2++ = '\0';
+	while (p1 && p1[0]) {
+		groupmenuitem = NULL;
+		childs = gtk_container_get_children(GTK_CONTAINER(submenu));
+		position = -1;
+		for (child = g_list_first(childs); child; child = g_list_next(child)) {
+			if (!GTK_IS_MENU_ITEM(child->data))
+				continue;
+			position++;
+			submenuitem = GTK_MENU_ITEM(child->data);
+			if (gtk_menu_item_get_submenu(submenuitem)) {
+				mstr = (gchar*)g_object_get_data(G_OBJECT(submenuitem), "group");
+				if (g_strcmp0(p1, mstr) == 0) {
+					/* Found existing group menu */
+					submenu = gtk_menu_item_get_submenu(submenuitem);
+					groupmenuitem = GTK_WIDGET(submenuitem);
+					break;
+				}else  {
+					/* Redo comparison ignoring case and respecting international
+					 * collation, to set menu sort order */
+					if (strcoll(p1, mstr) < 0) {
+						submenu = remmina_applet_menu_add_group(submenu, p1, position, menuitem,
+							&groupmenuitem);
+						break;
+					}
+				}
+			}else  {
+				submenu = remmina_applet_menu_add_group(submenu, p1, position, menuitem, &groupmenuitem);
+				break;
+			}
+
+		}
+
+		if (!child) {
+			submenu = remmina_applet_menu_add_group(submenu, p1, -1, menuitem, &groupmenuitem);
+		}
+		g_list_free(childs);
+		if (groupmenuitem && !menu->priv->hide_count) {
+			remmina_applet_menu_increase_group_count(groupmenuitem);
+		}
+		p1 = p2;
+		p2 = p1 ? strchr(p1, '/') : NULL;
+		if (p2)
+			*p2++ = '\0';
+	}
+	g_free(s);
+
+	childs = gtk_container_get_children(GTK_CONTAINER(submenu));
+	position = -1;
+	for (child = g_list_first(childs); child; child = g_list_next(child)) {
+		if (!GTK_IS_MENU_ITEM(child->data))
+			continue;
+		position++;
+		submenuitem = GTK_MENU_ITEM(child->data);
+		if (gtk_menu_item_get_submenu(submenuitem))
+			continue;
+		if (!REMMINA_IS_APPLET_MENU_ITEM(submenuitem))
+			continue;
+		if (strcoll(menuitem->name, REMMINA_APPLET_MENU_ITEM(submenuitem)->name) <= 0) {
+			gtk_menu_shell_insert(GTK_MENU_SHELL(submenu), GTK_WIDGET(menuitem), position);
+			break;
+		}
+	}
+	if (!child) {
+		gtk_menu_shell_append(GTK_MENU_SHELL(submenu), GTK_WIDGET(menuitem));
+	}
+	g_list_free(childs);
+	remmina_applet_menu_register_item(menu, menuitem);
+}
+
+GtkWidget*
+remmina_applet_menu_new(void)
+{
+	TRACE_CALL(__func__);
+	RemminaAppletMenu *menu;
+
+	menu = REMMINA_APPLET_MENU(g_object_new(REMMINA_TYPE_APPLET_MENU, NULL));
+
+	return GTK_WIDGET(menu);
+}
+
+void remmina_applet_menu_set_hide_count(RemminaAppletMenu *menu, gboolean hide_count)
+{
+	TRACE_CALL(__func__);
+	menu->priv->hide_count = hide_count;
+}
+
+void remmina_applet_menu_populate(RemminaAppletMenu *menu)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *menuitem;
+	gchar filename[MAX_PATH_LEN];
+	GDir *dir;
+	gchar *remmina_data_dir;
+	const gchar *name;
+	gint count = 0;
+
+	gboolean new_ontop = remmina_pref.applet_new_ontop;
+
+	remmina_data_dir = remmina_file_get_datadir();
+	dir = g_dir_open(remmina_data_dir, 0, NULL);
+	if (dir != NULL) {
+		/* Iterate all remote desktop profiles */
+		while ((name = g_dir_read_name(dir)) != NULL) {
+			if (!g_str_has_suffix(name, ".remmina"))
+				continue;
+			g_snprintf(filename, sizeof(filename), "%s/%s", remmina_data_dir, name);
+
+			menuitem = remmina_applet_menu_item_new(REMMINA_APPLET_MENU_ITEM_FILE, filename);
+			if (menuitem != NULL) {
+				remmina_applet_menu_add_item(menu, REMMINA_APPLET_MENU_ITEM(menuitem));
+				gtk_widget_show(menuitem);
+				count++;
+			}
+		}
+		g_dir_close(dir);
+		if (count > 0) {
+			/* Separator */
+			menuitem = gtk_separator_menu_item_new();
+			gtk_widget_show(menuitem);
+			if (new_ontop)
+				gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menuitem);
+			else
+				gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
+		}
+	}
+	g_free(remmina_data_dir);
+}
+
diff --git a/src/remmina_applet_menu.h b/src/remmina_applet_menu.h
new file mode 100644
index 0000000..1558bca
--- /dev/null
+++ b/src/remmina_applet_menu.h
@@ -0,0 +1,80 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010 Vic Lee
+ * Copyright (C) 2017-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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include "remmina_applet_menu_item.h"
+
+G_BEGIN_DECLS
+
+#define REMMINA_TYPE_APPLET_MENU            (remmina_applet_menu_get_type())
+#define REMMINA_APPLET_MENU(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), REMMINA_TYPE_APPLET_MENU, RemminaAppletMenu))
+#define REMMINA_APPLET_MENU_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), REMMINA_TYPE_APPLET_MENU, RemminaAppletMenuClass))
+#define REMMINA_IS_APPLET_MENU(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), REMMINA_TYPE_APPLET_MENU))
+#define REMMINA_IS_APPLET_MENU_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), REMMINA_TYPE_APPLET_MENU))
+#define REMMINA_APPLET_MENU_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), REMMINA_TYPE_APPLET_MENU, RemminaAppletMenuClass))
+
+typedef enum {
+	REMMINA_APPLET_MENU_NEW_CONNECTION_NONE,
+	REMMINA_APPLET_MENU_NEW_CONNECTION_TOP,
+	REMMINA_APPLET_MENU_NEW_CONNECTION_BOTTOM
+} RemminaAppletMenuNewConnectionType;
+
+typedef struct _RemminaAppletMenuPriv RemminaAppletMenuPriv;
+
+typedef struct _RemminaAppletMenu {
+	GtkMenu			menu;
+
+	RemminaAppletMenuPriv * priv;
+} RemminaAppletMenu;
+
+typedef struct _RemminaAppletMenuClass {
+	GtkMenuClass parent_class;
+
+	void (*launch_item)(RemminaAppletMenu *menu);
+	void (*edit_item)(RemminaAppletMenu *menu);
+} RemminaAppletMenuClass;
+
+GType remmina_applet_menu_get_type(void)
+G_GNUC_CONST;
+
+void remmina_applet_menu_register_item(RemminaAppletMenu *menu, RemminaAppletMenuItem *menuitem);
+void remmina_applet_menu_add_item(RemminaAppletMenu *menu, RemminaAppletMenuItem *menuitem);
+GtkWidget *remmina_applet_menu_new(void);
+void remmina_applet_menu_set_hide_count(RemminaAppletMenu *menu, gboolean hide_count);
+void remmina_applet_menu_populate(RemminaAppletMenu *menu);
+
+G_END_DECLS
diff --git a/src/remmina_applet_menu_item.c b/src/remmina_applet_menu_item.c
new file mode 100644
index 0000000..59da0db
--- /dev/null
+++ b/src/remmina_applet_menu_item.c
@@ -0,0 +1,199 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009-2010 Vic Lee
+ * Copyright (C) 2014-2015 Antenore Gatta, Fabio Castelli, Giovanni Panozzo
+ * Copyright (C) 2016-2022 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2022-2023 Antenore Gatta, Giovanni Panozzo, Hiroyuki Tanaka
+ *
+ * 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 <glib/gi18n.h>
+#include <glib/gprintf.h>
+#include <string.h>
+#include <stdarg.h>
+#include "config.h"
+#include "remmina_plugin_manager.h"
+#include "remmina_applet_menu_item.h"
+#include "remmina/remmina_trace_calls.h"
+
+G_DEFINE_TYPE( RemminaAppletMenuItem, remmina_applet_menu_item, GTK_TYPE_MENU_ITEM)
+
+#define IS_EMPTY(s) ((!s) || (s[0] == 0))
+
+static void remmina_applet_menu_item_destroy(RemminaAppletMenuItem* item, gpointer data)
+{
+	TRACE_CALL(__func__);
+	g_free(item->filename);
+	g_free(item->name);
+	g_free(item->group);
+	g_free(item->protocol);
+	g_free(item->server);
+}
+
+static void remmina_applet_menu_item_class_init(RemminaAppletMenuItemClass* klass)
+{
+	TRACE_CALL(__func__);
+}
+
+static void remmina_applet_menu_item_init(RemminaAppletMenuItem* item)
+{
+	TRACE_CALL(__func__);
+	item->filename = NULL;
+	item->name = NULL;
+	item->group = NULL;
+	item->protocol = NULL;
+	item->server = NULL;
+	item->ssh_tunnel_enabled = FALSE;
+	g_signal_connect(G_OBJECT(item), "destroy", G_CALLBACK(remmina_applet_menu_item_destroy), NULL);
+}
+
+GtkWidget* remmina_applet_menu_item_new(RemminaAppletMenuItemType item_type, ...)
+{
+	TRACE_CALL(__func__);
+	va_list ap;
+	RemminaAppletMenuItem* item;
+	GKeyFile* gkeyfile;
+	GtkWidget* widget;
+	GtkWidget* box;
+	GtkWidget* icon;
+
+	va_start(ap, item_type);
+
+	item = REMMINA_APPLET_MENU_ITEM(g_object_new(REMMINA_TYPE_APPLET_MENU_ITEM, NULL));
+
+	item->item_type = item_type;
+
+	switch (item_type) {
+	case REMMINA_APPLET_MENU_ITEM_FILE:
+		item->filename = g_strdup(va_arg(ap, const gchar*));
+
+		/* Load the file */
+		gkeyfile = g_key_file_new();
+
+		if (!g_key_file_load_from_file(gkeyfile, item->filename, G_KEY_FILE_NONE, NULL)) {
+			g_key_file_free(gkeyfile);
+			va_end(ap);
+			return NULL;
+		}
+
+		item->name = g_key_file_get_string(gkeyfile, "remmina", "name", NULL);
+		item->group = g_key_file_get_string(gkeyfile, "remmina", "group", NULL);
+		item->protocol = g_key_file_get_string(gkeyfile, "remmina", "protocol", NULL);
+		item->server = g_key_file_get_string(gkeyfile, "remmina", "server", NULL);
+		item->ssh_tunnel_enabled = g_key_file_get_boolean(gkeyfile, "remmina", "ssh_tunnel_enabled", NULL);
+
+		g_key_file_free(gkeyfile);
+
+		if (item->name == NULL) {
+			g_printf("WARNING: missing name= line in file %s. Skipping.\n", item->filename);
+			va_end(ap);
+			return NULL;
+		}
+
+		break;
+
+	case REMMINA_APPLET_MENU_ITEM_DISCOVERED:
+		item->name = g_strdup(va_arg(ap, const gchar *));
+		item->group = g_strdup(_("Discovered"));
+		item->protocol = g_strdup("VNC");
+		break;
+
+	case REMMINA_APPLET_MENU_ITEM_NEW:
+		item->name = g_strdup(_("New Connection"));
+		break;
+	}
+
+	va_end(ap);
+
+
+	/* Get the icon based on the protocol */
+	const gchar* icon_name;
+	RemminaProtocolPlugin *plugin;
+	plugin  = (RemminaProtocolPlugin *)remmina_plugin_manager_get_plugin(REMMINA_PLUGIN_TYPE_PROTOCOL,
+									    item->protocol);
+	if (!plugin) {
+		icon_name = g_strconcat(REMMINA_APP_ID, "-symbolic", NULL);
+	} else {
+		icon_name = item->ssh_tunnel_enabled ? plugin->icon_name_ssh : plugin->icon_name;
+	}
+	icon = gtk_image_new_from_icon_name(icon_name, GTK_ICON_SIZE_MENU);
+
+	/* Create the label */
+	widget = gtk_label_new(item->name);
+	box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
+	gtk_widget_show(widget);
+	gtk_widget_show(icon);
+	gtk_widget_show(box);
+	gtk_widget_set_valign(widget, GTK_ALIGN_START);
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	gtk_container_add(GTK_CONTAINER(box), icon);
+	gtk_container_add(GTK_CONTAINER(box), widget);
+	gtk_container_add(GTK_CONTAINER(item), box);
+
+	if (item->server) {
+		gtk_widget_set_tooltip_text(GTK_WIDGET(item), item->server);
+	}
+
+	return GTK_WIDGET(item);
+}
+
+gint remmina_applet_menu_item_compare(gconstpointer a, gconstpointer b, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gint cmp;
+	RemminaAppletMenuItem* itema;
+	RemminaAppletMenuItem* itemb;
+
+	/* Passed in parameters are pointers to pointers */
+	itema = REMMINA_APPLET_MENU_ITEM(*((void**)a));
+	itemb = REMMINA_APPLET_MENU_ITEM(*((void**)b));
+
+	/* Put ungrouped items to the last */
+	if (IS_EMPTY(itema->group) && !IS_EMPTY(itemb->group))
+		return 1;
+	if (!IS_EMPTY(itema->group) && IS_EMPTY(itemb->group))
+		return -1;
+
+	/* Put discovered items the last group */
+	if (itema->item_type == REMMINA_APPLET_MENU_ITEM_DISCOVERED && itemb->item_type != REMMINA_APPLET_MENU_ITEM_DISCOVERED)
+		return 1;
+	if (itema->item_type != REMMINA_APPLET_MENU_ITEM_DISCOVERED && itemb->item_type == REMMINA_APPLET_MENU_ITEM_DISCOVERED)
+		return -1;
+
+	if (itema->item_type != REMMINA_APPLET_MENU_ITEM_DISCOVERED && !IS_EMPTY(itema->group)) {
+		cmp = g_strcmp0(itema->group, itemb->group);
+
+		if (cmp != 0)
+			return cmp;
+	}
+
+	return g_strcmp0(itema->name, itemb->name);
+}
diff --git a/src/remmina_applet_menu_item.h b/src/remmina_applet_menu_item.h
new file mode 100644
index 0000000..9dbceed
--- /dev/null
+++ b/src/remmina_applet_menu_item.h
@@ -0,0 +1,75 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009-2010 Vic Lee
+ * Copyright (C) 2017-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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define REMMINA_TYPE_APPLET_MENU_ITEM            (remmina_applet_menu_item_get_type())
+#define REMMINA_APPLET_MENU_ITEM(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), REMMINA_TYPE_APPLET_MENU_ITEM, RemminaAppletMenuItem))
+#define REMMINA_APPLET_MENU_ITEM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), REMMINA_TYPE_APPLET_MENU_ITEM, RemminaAppletMenuItemClass))
+#define REMMINA_IS_APPLET_MENU_ITEM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), REMMINA_TYPE_APPLET_MENU_ITEM))
+#define REMMINA_IS_APPLET_MENU_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), REMMINA_TYPE_APPLET_MENU_ITEM))
+#define REMMINA_APPLET_MENU_ITEM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), REMMINA_TYPE_APPLET_MENU_ITEM, RemminaAppletMenuItemClass))
+
+typedef enum {
+	REMMINA_APPLET_MENU_ITEM_FILE, REMMINA_APPLET_MENU_ITEM_NEW, REMMINA_APPLET_MENU_ITEM_DISCOVERED
+} RemminaAppletMenuItemType;
+
+typedef struct _RemminaAppletMenuItem {
+	GtkMenuItem		        menu_item;
+
+	RemminaAppletMenuItemType	item_type;
+	gchar *				filename;
+	gchar *				name;
+	gchar *				group;
+	gchar *				protocol;
+	gchar *				server;
+	gboolean			ssh_tunnel_enabled;
+} RemminaAppletMenuItem;
+
+typedef struct _RemminaAppletMenuItemClass {
+	GtkMenuItemClass parent_class;
+} RemminaAppletMenuItemClass;
+
+GType remmina_applet_menu_item_get_type(void)
+G_GNUC_CONST;
+
+GtkWidget *remmina_applet_menu_item_new(RemminaAppletMenuItemType item_type, ...);
+gint remmina_applet_menu_item_compare(gconstpointer a, gconstpointer b, gpointer user_data);
+
+G_END_DECLS
diff --git a/src/remmina_avahi.c b/src/remmina_avahi.c
new file mode 100644
index 0000000..e51cfbf
--- /dev/null
+++ b/src/remmina_avahi.c
@@ -0,0 +1,300 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009-2010 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 "remmina_avahi.h"
+#include "remmina/remmina_trace_calls.h"
+
+#ifdef HAVE_LIBAVAHI_CLIENT
+
+#include <avahi-client/client.h>
+#include <avahi-client/lookup.h>
+#include <avahi-common/simple-watch.h>
+#include <avahi-common/malloc.h>
+#include <avahi-common/error.h>
+
+struct _RemminaAvahiPriv {
+	AvahiSimplePoll* simple_poll;
+	AvahiClient* client;
+	AvahiServiceBrowser* sb;
+	guint iterate_handler;
+	gboolean has_event;
+};
+
+static void
+remmina_avahi_resolve_callback(
+	AvahiServiceResolver* r,
+	AVAHI_GCC_UNUSED AvahiIfIndex interface,
+	AVAHI_GCC_UNUSED AvahiProtocol protocol,
+	AvahiResolverEvent event,
+	const char* name,
+	const char* type,
+	const char* domain,
+	const char* host_name,
+	const AvahiAddress* address,
+	uint16_t port,
+	AvahiStringList* txt,
+	AvahiLookupResultFlags flags,
+	AVAHI_GCC_UNUSED void* userdata)
+{
+	TRACE_CALL(__func__);
+	gchar* key;
+	gchar* value;
+	RemminaAvahi* ga = (RemminaAvahi*)userdata;
+
+	assert(r);
+
+	ga->priv->has_event = TRUE;
+
+	switch (event) {
+	case AVAHI_RESOLVER_FAILURE:
+		g_print("(remmina-applet avahi-resolver) Failed to resolve service '%s' of type '%s' in domain '%s': %s\n",
+			name, type, domain, avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(r))));
+		break;
+
+	case AVAHI_RESOLVER_FOUND:
+		key = g_strdup_printf("%s,%s,%s", name, type, domain);
+		if (g_hash_table_lookup(ga->discovered_services, key)) {
+			g_free(key);
+			break;
+		}
+		value = g_strdup_printf("[%s]:%i", host_name, port);
+		g_hash_table_insert(ga->discovered_services, key, value);
+		/* key and value will be freed with g_free when the has table is freed */
+
+		g_print("(remmina-applet avahi-resolver) Added service '%s'\n", value);
+
+		break;
+	}
+
+	avahi_service_resolver_free(r);
+}
+
+static void
+remmina_avahi_browse_callback(
+	AvahiServiceBrowser* b,
+	AvahiIfIndex interface,
+	AvahiProtocol protocol,
+	AvahiBrowserEvent event,
+	const char* name,
+	const char* type,
+	const char* domain,
+	AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
+	void* userdata)
+{
+	TRACE_CALL(__func__);
+	gchar* key;
+	RemminaAvahi* ga = (RemminaAvahi*)userdata;
+
+	assert(b);
+
+	ga->priv->has_event = TRUE;
+
+	switch (event) {
+	case AVAHI_BROWSER_FAILURE:
+		g_print("(remmina-applet avahi-browser) %s\n",
+			avahi_strerror(avahi_client_errno(avahi_service_browser_get_client(b))));
+		return;
+
+	case AVAHI_BROWSER_NEW:
+		key = g_strdup_printf("%s,%s,%s", name, type, domain);
+		if (g_hash_table_lookup(ga->discovered_services, key)) {
+			g_free(key);
+			break;
+		}
+		g_free(key);
+
+		g_print("(remmina-applet avahi-browser) Found service '%s' of type '%s' in domain '%s'\n", name, type, domain);
+
+		if (!(avahi_service_resolver_new(ga->priv->client, interface, protocol, name, type, domain,
+			      AVAHI_PROTO_UNSPEC, 0, remmina_avahi_resolve_callback, ga))) {
+			g_print("(remmina-applet avahi-browser) Failed to resolve service '%s': %s\n",
+				name, avahi_strerror(avahi_client_errno(ga->priv->client)));
+		}
+		break;
+
+	case AVAHI_BROWSER_REMOVE:
+		g_print("(remmina-applet avahi-browser) Removed service '%s' of type '%s' in domain '%s'\n", name, type, domain);
+		key = g_strdup_printf("%s,%s,%s", name, type, domain);
+		g_hash_table_remove(ga->discovered_services, key);
+		g_free(key);
+		break;
+
+	case AVAHI_BROWSER_ALL_FOR_NOW:
+	case AVAHI_BROWSER_CACHE_EXHAUSTED:
+		break;
+	}
+}
+
+static void remmina_avahi_client_callback(AvahiClient* c, AvahiClientState state, AVAHI_GCC_UNUSED void * userdata)
+{
+	TRACE_CALL(__func__);
+	RemminaAvahi* ga = (RemminaAvahi*)userdata;
+
+	ga->priv->has_event = TRUE;
+
+	if (state == AVAHI_CLIENT_FAILURE) {
+		g_print("(remmina-applet avahi) Server connection failure: %s\n", avahi_strerror(avahi_client_errno(c)));
+	}
+}
+
+static gboolean remmina_avahi_iterate(RemminaAvahi* ga)
+{
+	TRACE_CALL(__func__);
+	while (TRUE) {
+		/* Call the iteration until no further events */
+		ga->priv->has_event = FALSE;
+		avahi_simple_poll_iterate(ga->priv->simple_poll, 0);
+		if (!ga->priv->has_event)
+			break;
+	}
+
+	return TRUE;
+}
+
+RemminaAvahi* remmina_avahi_new(void)
+{
+	TRACE_CALL(__func__);
+	RemminaAvahi* ga;
+
+	ga = g_new(RemminaAvahi, 1);
+	ga->discovered_services = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
+	ga->started = FALSE;
+	ga->priv = g_new(RemminaAvahiPriv, 1);
+	ga->priv->simple_poll = NULL;
+	ga->priv->client = NULL;
+	ga->priv->sb = NULL;
+	ga->priv->iterate_handler = 0;
+	ga->priv->has_event = FALSE;
+
+	return ga;
+}
+
+void remmina_avahi_start(RemminaAvahi* ga)
+{
+	TRACE_CALL(__func__);
+	int error;
+
+	if (ga->started)
+		return;
+
+	ga->started = TRUE;
+
+	ga->priv->simple_poll = avahi_simple_poll_new();
+	if (!ga->priv->simple_poll) {
+		g_print("Failed to create simple poll object.\n");
+		return;
+	}
+
+	ga->priv->client = avahi_client_new(avahi_simple_poll_get(ga->priv->simple_poll), 0, remmina_avahi_client_callback, ga,
+		&error);
+	if (!ga->priv->client) {
+		g_print("Failed to create client: %s\n", avahi_strerror(error));
+		return;
+	}
+
+	/** @todo Customize the default domain here */
+	ga->priv->sb = avahi_service_browser_new(ga->priv->client, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, "_rfb._tcp", NULL, 0,
+		remmina_avahi_browse_callback, ga);
+	if (!ga->priv->sb) {
+		g_print("Failed to create service browser: %s\n", avahi_strerror(avahi_client_errno(ga->priv->client)));
+		return;
+	}
+
+	ga->priv->iterate_handler = g_timeout_add(5000, (GSourceFunc)remmina_avahi_iterate, ga);
+}
+
+void remmina_avahi_stop(RemminaAvahi* ga)
+{
+	TRACE_CALL(__func__);
+	g_hash_table_remove_all(ga->discovered_services);
+	if (ga->priv->iterate_handler) {
+		g_source_remove(ga->priv->iterate_handler);
+		ga->priv->iterate_handler = 0;
+	}
+	if (ga->priv->sb) {
+		avahi_service_browser_free(ga->priv->sb);
+		ga->priv->sb = NULL;
+	}
+	if (ga->priv->client) {
+		avahi_client_free(ga->priv->client);
+		ga->priv->client = NULL;
+	}
+	if (ga->priv->simple_poll) {
+		avahi_simple_poll_free(ga->priv->simple_poll);
+		ga->priv->simple_poll = NULL;
+	}
+	ga->started = FALSE;
+}
+
+void remmina_avahi_free(RemminaAvahi* ga)
+{
+	TRACE_CALL(__func__);
+	if (ga == NULL)
+		return;
+
+	remmina_avahi_stop(ga);
+
+	g_free(ga->priv);
+	g_hash_table_destroy(ga->discovered_services);
+	g_free(ga);
+}
+
+#else
+
+RemminaAvahi* remmina_avahi_new(void)
+{
+	TRACE_CALL(__func__);
+	return NULL;
+}
+
+void remmina_avahi_start(RemminaAvahi* ga)
+{
+	TRACE_CALL(__func__);
+}
+
+void remmina_avahi_stop(RemminaAvahi* ga)
+{
+	TRACE_CALL(__func__);
+}
+
+void remmina_avahi_free(RemminaAvahi* ga)
+{
+	TRACE_CALL(__func__);
+}
+
+#endif
+
diff --git a/src/remmina_avahi.h b/src/remmina_avahi.h
new file mode 100644
index 0000000..70686cd
--- /dev/null
+++ b/src/remmina_avahi.h
@@ -0,0 +1,56 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009-2010 Vic Lee
+ * Copyright (C) 2017-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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+typedef struct _RemminaAvahiPriv RemminaAvahiPriv;
+
+typedef struct _RemminaAvahi {
+	GHashTable *		discovered_services;
+	gboolean		started;
+
+	RemminaAvahiPriv *	priv;
+} RemminaAvahi;
+
+RemminaAvahi *remmina_avahi_new(void);
+void remmina_avahi_start(RemminaAvahi *ga);
+void remmina_avahi_stop(RemminaAvahi *ga);
+void remmina_avahi_free(RemminaAvahi *ga);
+
+G_END_DECLS
diff --git a/src/remmina_bug_report.c b/src/remmina_bug_report.c
new file mode 100644
index 0000000..7512223
--- /dev/null
+++ b/src/remmina_bug_report.c
@@ -0,0 +1,411 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009-2011 Vic Lee
+ * Copyright (C) 2014-2015 Antenore Gatta, Fabio Castelli, Giovanni Panozzo
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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 <glib/gi18n.h>
+#include <string.h>
+#include "remmina_log.h"
+#include "remmina_bug_report.h"
+#include "remmina_public.h"
+#include "remmina/remmina_trace_calls.h"
+#include "remmina_info.h"
+#include "remmina_curl_connector.h"
+#include "remmina_utils.h"
+
+#if !JSON_CHECK_VERSION(1, 2, 0)
+	#define json_node_unref(x) json_node_free(x)
+#endif
+
+#define BUG_REPORT_UPLOAD_URL "https://info.remmina.org/bug_report/bug_report"
+static RemminaBugReportDialog *remmina_bug_report_dialog;
+
+#define GET_OBJECT(object_name) gtk_builder_get_object(remmina_bug_report_dialog->builder, object_name)
+
+#define TEMP_LOG_TEXT_FILE_NAME "remmina_shorter_logs.log"
+#define COMPRESSED_LOG_FILE_NAME "remmina_log_file.gz"
+#define LOG_RECENT_WINDOW 4000
+#define MAX_DESCRIPTION_LENGTH 8000
+const char *bug_report_preview_text_md = \
+"## Problem Description\n"
+"\n"
+"Write a detailed description of the problem.\n"
+"\n"
+"## What is the expected correct behavior?\n"
+"\n"
+"(What you want to see instead.)\n"
+"\n"
+"## Remote System Description\n"
+"\n"
+"* Server (OS name and version):\n"
+"* Special notes regarding the remote system (i.e. gateways, tunnel, etc.):\n"
+"\n"
+"## Debugging\n"
+"\n"
+"Please check the Include Debug Data box to allow for debug log to be sent with this bug report\n"
+"\n"
+"## Local System Description\n"
+"\n"
+"* Client (OS name and version):\n"
+"* Remmina version ( ```remmina --version``` ):\n"
+"* Installation(s):\n"
+"  - [ ] Distribution package.\n"
+"  - [ ] PPA.\n"
+"  - [ ] Snap.\n"
+"  - [ ] Flatpak.\n"
+"  - [ ] Compiled from sources.\n"
+"  - [ ] Other - detail:\n"
+"* Desktop environment (GNOME, Unity, KDE, ..):\n"
+"* Plugin(s):\n"
+"  - [ ] RDP - freerdp version ( ```xfreerdp --version``` ):\n"
+"  - [ ] VNC\n"
+"  - [ ] SSH\n"
+"  - [ ] SFTP\n"
+"  - [ ] SPICE\n"
+"  - [ ] WWW\n"
+"  - [ ] EXEC\n"
+"  - [ ] Other (please specify):\n"
+"* GTK backend (Wayland, Xorg):\n"
+"\n";
+
+
+/* Show the bug report dialog from the file ui/remmina_bug_report.glade */
+void remmina_bug_report_open(GtkWindow *parent)
+{
+	TRACE_CALL(__func__);
+	GtkTextBuffer* bug_report_preview_text_buffer;
+	remmina_bug_report_dialog = g_new0(RemminaBugReportDialog, 1);
+
+	remmina_bug_report_dialog->builder = remmina_public_gtk_builder_new_from_resource ("/org/remmina/Remmina/src/../data/ui/remmina_bug_report.glade");
+	remmina_bug_report_dialog->dialog = GTK_WIDGET(gtk_builder_get_object(remmina_bug_report_dialog->builder, "RemminaBugReportDialog"));
+	remmina_bug_report_dialog->bug_report_submit_button = GTK_BUTTON(GET_OBJECT("bug_report_submit_button"));
+	remmina_bug_report_dialog->bug_report_name_entry = GTK_ENTRY(GET_OBJECT("bug_report_name_entry"));
+	remmina_bug_report_dialog->bug_report_email_entry = GTK_ENTRY(GET_OBJECT("bug_report_email_entry"));
+	remmina_bug_report_dialog->bug_report_title_entry = GTK_ENTRY(GET_OBJECT("bug_report_title_entry"));
+	remmina_bug_report_dialog->bug_report_description_textview = GTK_TEXT_VIEW(GET_OBJECT("bug_report_description_textview"));
+	remmina_bug_report_dialog->bug_report_submit_status_label = GTK_LABEL(GET_OBJECT("bug_report_submit_status_label"));
+	remmina_bug_report_dialog->bug_report_debug_data_check_button = GTK_CHECK_BUTTON(GET_OBJECT("bug_report_debug_data_check_button"));
+	remmina_bug_report_dialog->bug_report_include_system_info_check_button = GTK_CHECK_BUTTON(GET_OBJECT("bug_report_include_system_info_check_button"));
+
+	// Set bug report markdown text in bug description window
+	bug_report_preview_text_buffer = gtk_text_buffer_new(NULL);
+	gtk_text_buffer_set_text(bug_report_preview_text_buffer, bug_report_preview_text_md, strlen(bug_report_preview_text_md));
+	gtk_text_view_set_buffer(remmina_bug_report_dialog->bug_report_description_textview, bug_report_preview_text_buffer);
+
+	if (parent) {
+		gtk_window_set_transient_for(GTK_WINDOW(remmina_bug_report_dialog->dialog), parent);
+		gtk_window_set_destroy_with_parent(GTK_WINDOW(remmina_bug_report_dialog->dialog), TRUE);
+	}
+
+	g_signal_connect(remmina_bug_report_dialog->bug_report_submit_button, "clicked",
+			G_CALLBACK(remmina_bug_report_dialog_on_action_submit), (gpointer)remmina_bug_report_dialog);
+
+	gtk_window_present(GTK_WINDOW(remmina_bug_report_dialog->dialog));
+	g_object_unref(bug_report_preview_text_buffer);
+}
+
+
+void remmina_bug_report_dialog_on_action_submit(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	JsonGenerator *g;
+	JsonObject *o;
+	gchar *b;
+
+	REMMINA_DEBUG("Submit Button Clicked. Uploading Bug Report data.");
+
+	gchar *markup = GRAY_TEXT("Sending Bug Report...");
+	gtk_label_set_markup(remmina_bug_report_dialog->bug_report_submit_status_label, markup);
+	g_free(markup);
+
+	// Store bug report info in JSON blob and encode before submitting
+	JsonNode *bug_report_data = remmina_bug_report_get_all();
+
+	if (bug_report_data == NULL || (o = json_node_get_object(bug_report_data)) == NULL) {
+		REMMINA_DEBUG("Failed to grab bug report data, no request is sent");
+		gchar *markup = RED_TEXT("Failure: Unable to generate bug report message. Please try again.");
+		gtk_label_set_markup(remmina_bug_report_dialog->bug_report_submit_status_label, markup);
+		g_free(markup);
+		json_node_unref(bug_report_data);
+		return;
+	} else if (strcmp(json_object_get_string_member(json_node_get_object(bug_report_data), "Name"), "") == 0) {
+		REMMINA_DEBUG("No text in name entry of bug report data, no request is sent");
+		gchar *markup = RED_TEXT("Failure: Name/Username is required. Please enter a Name/Username.");
+		gtk_label_set_markup(remmina_bug_report_dialog->bug_report_submit_status_label, markup);
+		g_free(markup);
+		json_node_unref(bug_report_data);
+		return;
+	} else {
+		gchar *email_text = g_strdup(json_object_get_string_member(json_node_get_object(bug_report_data), "Email"));
+		if (strcmp(email_text, "") == 0) {
+			REMMINA_DEBUG("No text in email entry of bug report data, no request is sent");
+			gchar *markup = RED_TEXT("Failure: Email is required. Please enter an email.");
+			gtk_label_set_markup(remmina_bug_report_dialog->bug_report_submit_status_label, markup);
+			g_free(markup);
+			g_free(email_text);
+			json_node_unref(bug_report_data);
+			return;
+		} else {
+			gchar *save_ptr;
+			gchar *check_for_at_symbol = strtok_r(email_text, "@", &save_ptr);
+			gchar *check_for_dot = strtok_r(NULL, ".", &save_ptr);
+			gchar *check_for_domain = strtok_r(NULL, "", &save_ptr);
+			if (check_for_at_symbol == NULL || check_for_dot == NULL || check_for_domain == NULL) {
+				REMMINA_DEBUG("Text in email entry of bug report data is not a valid email, no request is sent");
+				gchar *markup = RED_TEXT("Failure: A valid email is required. Email is missing a prefix or domain.");
+				gtk_label_set_markup(remmina_bug_report_dialog->bug_report_submit_status_label, markup);
+				g_free(markup);
+				g_free(email_text);
+				json_node_unref(bug_report_data);
+				return;
+			} else if (strpbrk(check_for_at_symbol, "@.") != NULL || strpbrk(check_for_dot, "@.") != NULL || strpbrk(check_for_domain, "@.") != NULL) {
+				REMMINA_DEBUG("Text in email entry of bug report data is not a valid email, no request is sent");
+				gchar *markup = RED_TEXT("Failure: A valid email is required. Email contains extra @ and . characters.");
+				gtk_label_set_markup(remmina_bug_report_dialog->bug_report_submit_status_label, markup);
+				g_free(markup);
+				g_free(email_text);
+				json_node_unref(bug_report_data);
+				return;
+			}
+		}
+		g_free(email_text);
+		if (strcmp(json_object_get_string_member(json_node_get_object(bug_report_data), "Bug_Title"), "") == 0) {
+			REMMINA_DEBUG("No text in bug title entry of bug report data, no request is sent");
+			gchar *markup = RED_TEXT("Failure: Bug Title is required. Please enter a Bug Title.");
+			gtk_label_set_markup(remmina_bug_report_dialog->bug_report_submit_status_label, markup);
+			g_free(markup);
+			json_node_unref(bug_report_data);
+			return;
+		} else if (strcmp(json_object_get_string_member(json_node_get_object(bug_report_data), "Bug_Description"), "") == 0 || 
+				strcmp(json_object_get_string_member(json_node_get_object(bug_report_data), "Bug_Description"), bug_report_preview_text_md) == 0) {
+			REMMINA_DEBUG("No text in bug description of bug report data, no request is sent");
+			gchar *markup = RED_TEXT("Failure: Bug Description is required. Please fill out the template.");
+			gtk_label_set_markup(remmina_bug_report_dialog->bug_report_submit_status_label, markup);
+			g_free(markup);
+			json_node_unref(bug_report_data);
+			return;
+		}
+	}
+
+	g = json_generator_new();
+	json_generator_set_root(g, bug_report_data);
+	b = json_generator_to_data(g, NULL);
+	g_object_unref(g);
+
+	remmina_curl_compose_message(b, "POST", BUG_REPORT_UPLOAD_URL, remmina_bug_report_dialog->bug_report_submit_status_label);
+	json_node_unref(bug_report_data);
+}
+
+JsonNode *remmina_bug_report_get_all()
+{
+	TRACE_CALL(__func__);
+	JsonBuilder *b_inner, *b_outer; // holds entire JSON blob
+	JsonGenerator *g;
+	JsonNode *n; // temp JSON node
+	gchar *unenc_b, *enc_b;
+	gchar *uid;
+
+	// Initialize JSON blob
+	b_outer = json_builder_new();
+	if (b_outer == NULL) {
+		g_object_unref(b_outer);
+		return NULL;
+	}
+	json_builder_begin_object(b_outer);
+
+	gboolean include_debug_data = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(remmina_bug_report_dialog->bug_report_debug_data_check_button));
+	gboolean include_system_info = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(remmina_bug_report_dialog->bug_report_include_system_info_check_button));
+
+	if (include_debug_data || include_system_info) {
+		b_inner = json_builder_new();
+		if (b_inner == NULL) {
+			g_object_unref(b_inner);
+			g_object_unref(b_outer);
+			return NULL;
+		}
+		json_builder_begin_object(b_inner);
+		
+		if (include_system_info){
+			n = remmina_info_stats_get_all();
+
+			json_builder_set_member_name(b_outer, "System_Info_Enabled");
+			json_builder_add_string_value(b_outer, "ON");
+
+			json_builder_set_member_name(b_inner, "System_Info");
+			json_builder_add_value(b_inner, n);
+		}
+		else{
+			json_builder_set_member_name(b_outer, "System_Info_Enabled");
+			json_builder_add_string_value(b_outer, "OFF");
+		}
+
+		if (include_debug_data){
+			gboolean log_file_result;
+			gchar *log_text;
+			gsize log_length;
+			GError *log_read_error;
+			gchar *log_filename = g_build_filename(g_get_tmp_dir(), LOG_FILE_NAME, NULL);
+			log_file_result = g_file_get_contents(log_filename, &log_text, &log_length, &log_read_error);
+			g_free(log_filename);
+			if (!log_file_result && log_read_error == NULL) {
+				REMMINA_DEBUG("Failed to grab entire log text, read error: %s", log_read_error->message);
+			}
+			gboolean shorter_logs_result;
+			gchar *temp_log_filename = g_build_filename(g_get_tmp_dir(), TEMP_LOG_TEXT_FILE_NAME, NULL);
+			gchar *recent_log_text;
+			if (log_length <= LOG_RECENT_WINDOW) {
+				recent_log_text = log_text;
+				shorter_logs_result = g_file_set_contents(temp_log_filename, recent_log_text, log_length, NULL);
+			}
+			else {
+				recent_log_text = log_text + (log_length - LOG_RECENT_WINDOW);
+				shorter_logs_result = g_file_set_contents(temp_log_filename, recent_log_text, LOG_RECENT_WINDOW, NULL);
+			}
+			g_free(log_text);
+			if (!shorter_logs_result) {
+				REMMINA_DEBUG("Failed to write recent window of logs to temp file.");
+			}
+
+			gchar *comp_log_filename = g_build_filename(g_get_tmp_dir(), COMPRESSED_LOG_FILE_NAME, NULL);
+			GFile *in = g_file_new_for_path(temp_log_filename);
+			GFile *out = g_file_new_for_path(comp_log_filename);
+			// Clear out old compressed log file to prevent appending
+			g_file_delete(out, NULL, NULL);
+			remmina_compress_from_file_to_file(in, out);
+			g_free(temp_log_filename);
+
+			gboolean com_log_file_result;
+			gchar *compressed_logs;
+			gsize com_log_length;
+			GError *com_log_read_error;
+			com_log_file_result = g_file_get_contents(comp_log_filename, &compressed_logs, &com_log_length, &com_log_read_error);
+			n = json_node_alloc();
+			if (!com_log_file_result && com_log_read_error != NULL) {
+				REMMINA_DEBUG("Failed to grab entire compressed log text, read error: %s", com_log_read_error->message);
+				json_node_init_string(n, "");
+			}
+			else {
+				gchar *logs_base64 = g_base64_encode((guchar *)compressed_logs, com_log_length);
+				json_node_init_string(n, logs_base64);
+				g_free(logs_base64);
+			}
+
+			json_builder_set_member_name(b_outer, "Debug_Log_Enabled");
+			json_builder_add_string_value(b_outer, "ON");
+			json_builder_set_member_name(b_inner, "Compressed_Logs");
+			json_builder_add_value(b_inner, n);
+			g_free(compressed_logs);
+			g_free(comp_log_filename);
+
+		}
+		else{
+			json_builder_set_member_name(b_outer, "Debug_Log_Enabled");
+			json_builder_add_string_value(b_outer, "OFF");
+		}
+
+		// Wrap up by setting n to the final JSON blob
+		json_builder_end_object(b_inner);
+		n = json_builder_get_root(b_inner);
+		g_object_unref(b_inner);
+
+		g = json_generator_new();
+		json_generator_set_root(g, n);
+		json_node_unref(n);
+		unenc_b = json_generator_to_data(g, NULL);	// unenc_b=bug report data
+		g_object_unref(g);
+
+		// Now base64 encode report data
+		enc_b = g_base64_encode((guchar *)unenc_b, strlen(unenc_b));
+		if (enc_b == NULL) {
+			g_object_unref(b_outer);
+			g_free(unenc_b);
+			REMMINA_DEBUG("Failed to encode inner JSON");
+			return NULL;
+		}
+		g_free(unenc_b);
+
+		json_builder_set_member_name(b_outer, "encdata");
+		json_builder_add_string_value(b_outer, enc_b);
+		g_free(enc_b);
+	}
+	else {
+		json_builder_set_member_name(b_outer, "System_Info_Enabled");
+		json_builder_add_string_value(b_outer, "OFF");
+		json_builder_set_member_name(b_outer, "Debug_Log_Enabled");
+		json_builder_add_string_value(b_outer, "OFF");	
+	}
+
+	n = remmina_info_stats_get_uid();
+	uid = g_strdup(json_node_get_string(n));
+	json_builder_set_member_name(b_outer, "UID");
+	json_builder_add_string_value(b_outer, uid);
+
+	// Allocate new json node for each text entry and add to total blob
+	n = json_node_alloc();
+	json_node_init_string(n, gtk_entry_get_text(remmina_bug_report_dialog->bug_report_name_entry));
+	json_builder_set_member_name(b_outer, "Name");
+	json_builder_add_value(b_outer, n);
+
+	n = json_node_alloc();
+	json_node_init_string(n, gtk_entry_get_text(remmina_bug_report_dialog->bug_report_email_entry));
+	json_builder_set_member_name(b_outer, "Email");
+	json_builder_add_value(b_outer, n);
+
+	n = json_node_alloc();
+	json_node_init_string(n, gtk_entry_get_text(remmina_bug_report_dialog->bug_report_title_entry));
+	json_builder_set_member_name(b_outer, "Bug_Title");
+	json_builder_add_value(b_outer, n);
+
+	GtkTextBuffer *buffer;
+	gchar *description_text;
+	GtkTextIter start, end;
+	buffer = gtk_text_view_get_buffer(remmina_bug_report_dialog->bug_report_description_textview);
+	gtk_text_buffer_get_start_iter(buffer, &start);
+	gtk_text_buffer_get_iter_at_offset(buffer, &end, MAX_DESCRIPTION_LENGTH);
+	description_text = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
+
+	n = json_node_alloc();
+	json_node_init_string(n, description_text);
+	json_builder_set_member_name(b_outer, "Bug_Description");
+	json_builder_add_value(b_outer, n);
+
+	json_builder_end_object(b_outer);
+	n = json_builder_get_root(b_outer);
+	g_object_unref(b_outer);
+
+	g_free(uid);
+
+	return n;
+}
diff --git a/src/remmina_bug_report.h b/src/remmina_bug_report.h
new file mode 100644
index 0000000..0969323
--- /dev/null
+++ b/src/remmina_bug_report.h
@@ -0,0 +1,61 @@
+/*
+ * 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
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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.
+ *
+ */
+
+#pragma once
+#include <gtk/gtk.h>
+#include "json-glib/json-glib.h"
+
+typedef struct _RemminaBugReportDialog {
+    GtkBuilder *builder;
+    GtkWidget  *dialog;
+    GtkButton  *bug_report_submit_button;
+    GtkEntry   *bug_report_name_entry;
+    GtkEntry   *bug_report_email_entry;
+    GtkEntry   *bug_report_title_entry;
+    GtkTextView *bug_report_description_textview;
+    GtkLabel   *bug_report_submit_status_label;
+    GtkCheckButton *bug_report_debug_data_check_button;
+    GtkCheckButton *bug_report_include_system_info_check_button;
+} RemminaBugReportDialog;
+
+G_BEGIN_DECLS
+
+void remmina_bug_report_open(GtkWindow *parent);
+void remmina_bug_report_dialog_on_action_submit(GSimpleAction *action, GVariant *param, gpointer data);
+JsonNode *remmina_bug_report_get_all(void);
+
+G_END_DECLS
diff --git a/src/remmina_chat_window.c b/src/remmina_chat_window.c
new file mode 100644
index 0000000..da58fb4
--- /dev/null
+++ b/src/remmina_chat_window.c
@@ -0,0 +1,255 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009 - 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 <glib/gi18n.h>
+#include <gdk/gdkkeysyms.h>
+#include "remmina_chat_window.h"
+#include "remmina/remmina_trace_calls.h"
+
+G_DEFINE_TYPE( RemminaChatWindow, remmina_chat_window, GTK_TYPE_WINDOW)
+
+enum {
+	SEND_SIGNAL,
+	LAST_SIGNAL
+};
+
+static guint remmina_chat_window_signals[LAST_SIGNAL] = { 0 };
+
+static void remmina_chat_window_class_init(RemminaChatWindowClass* klass)
+{
+	TRACE_CALL(__func__);
+	remmina_chat_window_signals[SEND_SIGNAL] = g_signal_new("send", G_TYPE_FROM_CLASS(klass),
+		G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaChatWindowClass, send), NULL, NULL,
+		g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
+}
+
+static void remmina_chat_window_init(RemminaChatWindow* window)
+{
+	TRACE_CALL(__func__);
+	window->history_text = NULL;
+	window->send_text = NULL;
+}
+
+static void remmina_chat_window_clear_send_text(GtkWidget* widget, RemminaChatWindow* window)
+{
+	TRACE_CALL(__func__);
+	GtkTextBuffer* buffer;
+
+	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(window->send_text));
+	gtk_text_buffer_set_text(buffer, "", -1);
+	gtk_widget_grab_focus(window->send_text);
+}
+
+static gboolean remmina_chat_window_scroll_proc(RemminaChatWindow* window)
+{
+	TRACE_CALL(__func__);
+	GtkTextBuffer* buffer;
+	GtkTextIter iter;
+
+	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(window->history_text));
+	gtk_text_buffer_get_end_iter(buffer, &iter);
+	gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(window->history_text), &iter, 0.0, FALSE, 0.0, 0.0);
+
+	return FALSE;
+}
+
+static void remmina_chat_window_append_text(RemminaChatWindow* window, const gchar* name, const gchar* tagname,
+					    const gchar* text)
+{
+	TRACE_CALL(__func__);
+	GtkTextBuffer* buffer;
+	GtkTextIter iter;
+	gchar* ptr;
+
+	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(window->history_text));
+
+	if (name) {
+		ptr = g_strdup_printf("(%s) ", name);
+		gtk_text_buffer_get_end_iter(buffer, &iter);
+		if (tagname) {
+			gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, ptr, -1, tagname, NULL);
+		}else  {
+			gtk_text_buffer_insert(buffer, &iter, ptr, -1);
+		}
+		g_free(ptr);
+	}
+
+	if (text && text[0] != 0) {
+		gtk_text_buffer_get_end_iter(buffer, &iter);
+		if (text[strlen(text) - 1] == '\n') {
+			gtk_text_buffer_insert(buffer, &iter, text, -1);
+		}else  {
+			ptr = g_strdup_printf("%s\n", text);
+			gtk_text_buffer_insert(buffer, &iter, ptr, -1);
+			g_free(ptr);
+		}
+	}
+
+	/* Use g_idle_add to make the scroll happen after the text has been actually updated */
+	g_idle_add((GSourceFunc)remmina_chat_window_scroll_proc, window);
+}
+
+static void remmina_chat_window_send(GtkWidget* widget, RemminaChatWindow* window)
+{
+	TRACE_CALL(__func__);
+	GtkTextBuffer* buffer;
+	GtkTextIter start, end;
+	gchar* text;
+
+	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(window->send_text));
+	gtk_text_buffer_get_bounds(buffer, &start, &end);
+	text = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
+
+	if (!text || text[0] == '\0')
+		return;
+
+	g_signal_emit_by_name(G_OBJECT(window), "send", text);
+
+	remmina_chat_window_append_text(window, g_get_user_name(), "sender-foreground", text);
+
+	g_free(text);
+
+	remmina_chat_window_clear_send_text(widget, window);
+}
+
+static gboolean remmina_chat_window_send_text_on_key(GtkWidget* widget, GdkEventKey* event, RemminaChatWindow* window)
+{
+	TRACE_CALL(__func__);
+	if (event->keyval == GDK_KEY_Return) {
+		remmina_chat_window_send(widget, window);
+		return TRUE;
+	}
+	return FALSE;
+}
+
+GtkWidget*
+remmina_chat_window_new(GtkWindow* parent, const gchar* chat_with)
+{
+	TRACE_CALL(__func__);
+	RemminaChatWindow* window;
+	gchar buf[100];
+	GtkWidget* grid;
+	GtkWidget* scrolledwindow;
+	GtkWidget* widget;
+	GtkWidget* image;
+	GtkTextBuffer* buffer;
+
+	window = REMMINA_CHAT_WINDOW(g_object_new(REMMINA_TYPE_CHAT_WINDOW, NULL));
+
+	if (parent) {
+		gtk_window_set_transient_for(GTK_WINDOW(window), parent);
+	}
+
+	/* Title */
+	g_snprintf(buf, sizeof(buf), _("Chat with %s"), chat_with);
+	gtk_window_set_title(GTK_WINDOW(window), buf);
+	gtk_window_set_default_size(GTK_WINDOW(window), 450, 300);
+
+	/* Main container */
+	grid = gtk_grid_new();
+	gtk_widget_show(grid);
+	gtk_grid_set_row_spacing(GTK_GRID(grid), 4);
+	gtk_grid_set_column_spacing(GTK_GRID(grid), 4);
+	gtk_container_set_border_width(GTK_CONTAINER(grid), 8);
+	gtk_container_add(GTK_CONTAINER(window), grid);
+
+	/* Chat history */
+	scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
+	gtk_widget_show(scrolledwindow);
+	gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolledwindow), 100);
+	gtk_widget_set_hexpand(GTK_WIDGET(scrolledwindow), TRUE);
+	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
+	gtk_grid_attach(GTK_GRID(grid), scrolledwindow, 0, 0, 3, 1);
+
+	widget = gtk_text_view_new();
+	gtk_widget_show(widget);
+	gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(widget), GTK_WRAP_WORD_CHAR);
+	gtk_text_view_set_editable(GTK_TEXT_VIEW(widget), FALSE);
+	gtk_container_add(GTK_CONTAINER(scrolledwindow), widget);
+
+	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
+	gtk_text_buffer_create_tag(buffer, "sender-foreground", "foreground", "blue", NULL);
+	gtk_text_buffer_create_tag(buffer, "receiver-foreground", "foreground", "red", NULL);
+
+	window->history_text = widget;
+
+	/* Chat message to be sent */
+	scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
+	gtk_widget_show(scrolledwindow);
+	gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolledwindow), 100);
+	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
+	gtk_widget_set_hexpand(GTK_WIDGET(scrolledwindow), TRUE);
+	gtk_grid_attach(GTK_GRID(grid), scrolledwindow, 0, 1, 3, 1);
+
+	widget = gtk_text_view_new();
+	gtk_widget_show(widget);
+	gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(widget), GTK_WRAP_WORD_CHAR);
+	gtk_container_add(GTK_CONTAINER(scrolledwindow), widget);
+	g_signal_connect(G_OBJECT(widget), "key-press-event", G_CALLBACK(remmina_chat_window_send_text_on_key), window);
+
+	window->send_text = widget;
+
+	/* Send button */
+	image = gtk_image_new_from_icon_name("org.remmina.Remmina-document-send-symbolic", GTK_ICON_SIZE_BUTTON);
+	gtk_widget_show(image);
+
+	widget = gtk_button_new_with_mnemonic(_("_Send"));
+	gtk_widget_show(widget);
+	gtk_button_set_image(GTK_BUTTON(widget), image);
+	gtk_grid_attach(GTK_GRID(grid), widget, 2, 2, 1, 1);
+	g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_chat_window_send), window);
+
+	/* Clear button */
+	image = gtk_image_new_from_icon_name("edit-clear", GTK_ICON_SIZE_BUTTON);
+	gtk_widget_show(image);
+
+	widget = gtk_button_new_with_mnemonic(_("_Clear"));
+	gtk_widget_show(widget);
+	gtk_button_set_image(GTK_BUTTON(widget), image);
+	gtk_grid_attach(GTK_GRID(grid), widget, 1, 2, 1, 1);
+	g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_chat_window_clear_send_text), window);
+
+	gtk_widget_grab_focus(window->send_text);
+
+	return GTK_WIDGET(window);
+}
+
+void remmina_chat_window_receive(RemminaChatWindow* window, const gchar* name, const gchar* text)
+{
+	TRACE_CALL(__func__);
+	remmina_chat_window_append_text(window, name, "receiver-foreground", text);
+}
+
diff --git a/src/remmina_chat_window.h b/src/remmina_chat_window.h
new file mode 100644
index 0000000..68992d1
--- /dev/null
+++ b/src/remmina_chat_window.h
@@ -0,0 +1,68 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009 - Vic Lee
+ * Copyright (C) 2017-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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define REMMINA_TYPE_CHAT_WINDOW               (remmina_chat_window_get_type())
+#define REMMINA_CHAT_WINDOW(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), REMMINA_TYPE_CHAT_WINDOW, RemminaChatWindow))
+#define REMMINA_CHAT_WINDOW_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), REMMINA_TYPE_CHAT_WINDOW, RemminaChatWindowClass))
+#define REMMINA_IS_CHAT_WINDOW(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), REMMINA_TYPE_CHAT_WINDOW))
+#define REMMINA_IS_CHAT_WINDOW_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), REMMINA_TYPE_CHAT_WINDOW))
+#define REMMINA_CHAT_WINDOW_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), REMMINA_TYPE_CHAT_WINDOW, RemminaChatWindowClass))
+
+typedef struct _RemminaChatWindow {
+	GtkWindow	window;
+
+	GtkWidget *	history_text;
+	GtkWidget *	send_text;
+} RemminaChatWindow;
+
+typedef struct _RemminaChatWindowClass {
+	GtkWindowClass parent_class;
+
+	void (*send)(RemminaChatWindow *window);
+} RemminaChatWindowClass;
+
+GType remmina_chat_window_get_type(void)
+G_GNUC_CONST;
+
+GtkWidget *remmina_chat_window_new(GtkWindow *parent, const gchar *chat_with);
+void remmina_chat_window_receive(RemminaChatWindow *window, const gchar *name, const gchar *text);
+
+G_END_DECLS
diff --git a/src/remmina_crypt.c b/src/remmina_crypt.c
new file mode 100644
index 0000000..0ed6c5b
--- /dev/null
+++ b/src/remmina_crypt.c
@@ -0,0 +1,198 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009 - 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"
+#ifdef HAVE_LIBGCRYPT
+#include <gcrypt.h>
+#endif
+#include "remmina_pref.h"
+#include "remmina_crypt.h"
+#include "remmina/remmina_trace_calls.h"
+
+#ifdef HAVE_LIBGCRYPT
+
+static gboolean remmina_crypt_init(gcry_cipher_hd_t *phd)
+{
+	TRACE_CALL(__func__);
+	guchar* secret;
+	gcry_error_t err;
+	gsize secret_len;
+
+	secret = g_base64_decode(remmina_pref.secret, &secret_len);
+
+	if (secret_len < 32) {
+		g_debug("secret corrupted\n");
+		g_free(secret);
+		return FALSE;
+	}
+
+	err = gcry_cipher_open(phd, GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_CBC, 0);
+
+	if (err) {
+		g_debug("gcry_cipher_open failure: %s\n", gcry_strerror(err));
+		g_free(secret);
+		return FALSE;
+	}
+
+	err = gcry_cipher_setkey((*phd), secret, 24);
+
+	if (err) {
+		g_debug("gcry_cipher_setkey failure: %s\n", gcry_strerror(err));
+		g_free(secret);
+		gcry_cipher_close((*phd));
+		return FALSE;
+	}
+
+	err = gcry_cipher_setiv((*phd), secret + 24, 8);
+
+	if (err) {
+		g_debug("gcry_cipher_setiv failure: %s\n", gcry_strerror(err));
+		g_free(secret);
+		gcry_cipher_close((*phd));
+		return FALSE;
+	}
+
+	g_free(secret);
+
+	return TRUE;
+}
+
+gchar* remmina_crypt_encrypt(const gchar *str)
+{
+	TRACE_CALL(__func__);
+	guchar* buf;
+	gint buf_len;
+	gchar* result;
+	gcry_error_t err;
+	gcry_cipher_hd_t hd;
+
+	if (!str || str[0] == '\0')
+		return NULL;
+
+	if (!remmina_crypt_init(&hd))
+		return NULL;
+
+	buf_len = strlen(str);
+	/* Pack to 64bit block size, and make sure it’s always 0-terminated */
+	buf_len += 8 - buf_len % 8;
+	buf = (guchar*)g_malloc(buf_len);
+	memset(buf, 0, buf_len);
+	memcpy(buf, str, strlen(str));
+
+	err = gcry_cipher_encrypt(hd, buf, buf_len, NULL, 0);
+
+	if (err) {
+		g_debug("gcry_cipher_encrypt failure: %s/%s\n",
+				gcry_strsource(err),
+				gcry_strerror(err));
+		g_free(buf);
+		gcry_cipher_close(hd);
+		return NULL;
+	}
+
+	result = g_base64_encode(buf, buf_len);
+
+	g_free(buf);
+	gcry_cipher_close(hd);
+
+	return result;
+}
+
+gchar* remmina_crypt_decrypt(const gchar *str)
+{
+	TRACE_CALL(__func__);
+	guchar* buf;
+	gsize buf_len;
+	gcry_error_t err;
+	gcry_cipher_hd_t hd;
+
+	if (!str || str[0] == '\0')
+		return NULL;
+
+	if (!remmina_crypt_init(&hd))
+		return NULL;
+
+	buf = g_base64_decode(str, &buf_len);
+
+#if 0
+	g_debug ("%s base64 encoded as %p with length %lu",
+			str,
+			&buf,
+			buf_len);
+#endif
+
+	err = gcry_cipher_decrypt(
+			hd,	    // gcry_cipher_hd_t
+			buf,	    // guchar
+			buf_len,    // gsize
+			NULL,	    // NULL and 0 -> in place decrypt
+			0);
+
+	if (err) {
+		g_debug("gcry_cipher_decrypt failure: %s/%s\n",
+				gcry_strsource(err),
+				gcry_strerror(err));
+		g_free(buf);
+		gcry_cipher_close(hd);
+		//return NULL;
+		return g_strdup(str);
+	}
+
+	gcry_cipher_close(hd);
+
+	/* Just in case */
+	if (buf_len > 0)
+		buf[buf_len - 1] = '\0';
+
+	return (gchar*)buf;
+}
+
+#else
+
+gchar* remmina_crypt_encrypt(const gchar *str)
+{
+	TRACE_CALL(__func__);
+	return NULL;
+}
+
+gchar* remmina_crypt_decrypt(const gchar *str)
+{
+	TRACE_CALL(__func__);
+	return NULL;
+}
+
+#endif
+
diff --git a/src/remmina_crypt.h b/src/remmina_crypt.h
new file mode 100644
index 0000000..10ef0e8
--- /dev/null
+++ b/src/remmina_crypt.h
@@ -0,0 +1,45 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009 - Vic Lee
+ * Copyright (C) 2017-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.
+ *
+ */
+
+#pragma once
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+gchar *remmina_crypt_encrypt(const gchar *str);
+gchar *remmina_crypt_decrypt(const gchar *str);
+
+G_END_DECLS
diff --git a/src/remmina_curl_connector.c b/src/remmina_curl_connector.c
new file mode 100644
index 0000000..588d38a
--- /dev/null
+++ b/src/remmina_curl_connector.c
@@ -0,0 +1,275 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2016-2023 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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 <curl/curl.h>
+#include <gtk/gtk.h>
+#include <json-glib/json-glib.h>
+
+#include "remmina.h"
+#include "remmina_info.h"
+#include "remmina_log.h"
+#include "remmina_plugin_manager.h"
+#include "remmina_pref.h"
+#include "remmina_curl_connector.h"
+#include "remmina/remmina_trace_calls.h"
+#include "remmina_utils.h"
+
+
+#ifdef GDK_WINDOWING_WAYLAND
+	#include <gdk/gdkwayland.h>
+#endif
+#ifdef GDK_WINDOWING_X11
+	#include <gdk/gdkx.h>
+#endif
+
+extern gboolean info_disable_stats;
+extern gboolean info_disable_news;
+extern gboolean info_disable_tip;
+
+struct curl_msg {
+	gchar *body;
+	gchar *url;
+	gpointer *user_data;
+	char* response;
+	size_t size;
+};
+
+enum ShowValue {ShowNews, ShowTip, ShowNone};
+
+
+// If we receive a response from the server parse out the message
+// and call the appropiate functions to handle the message.
+void handle_resp(struct curl_msg * message){
+	gchar *news_checksum = NULL;
+	JsonParser *parser = NULL;
+	enum ShowValue to_show = ShowNone;
+
+	if (!imode) {
+		parser = json_parser_new();
+		if (!parser) {
+			return;
+		}
+		if (!json_parser_load_from_data(parser, message->response , message->size, NULL)){
+			g_object_unref(parser);
+			return;
+		}
+		JsonReader *reader = json_reader_new(json_parser_get_root(parser));
+		if (!reader) {
+			g_object_unref(parser);
+			return;
+		}
+		const gchar *json_tip_string;
+		const gchar *json_news_string;
+		gint64 	json_stats_int = 0;
+
+		if (!json_reader_read_element(reader, 0)) {
+			g_object_unref(parser);
+			g_object_unref(reader);
+			return;
+		}
+
+		if (!json_reader_read_member(reader, "TIP")) {
+			json_tip_string = NULL;
+		}
+		else {
+			json_tip_string = json_reader_get_string_value(reader);
+		}
+		json_reader_end_member(reader);
+
+		if (!json_reader_read_member(reader, "NEWS")) {
+			json_news_string = NULL;
+		}
+		else {
+			json_news_string = json_reader_get_string_value(reader);
+
+		}
+		json_reader_end_member(reader);
+
+		if (!json_reader_read_member(reader, "STATS")) {
+			json_stats_int = 0;
+		}
+		else {
+			json_stats_int = json_reader_get_int_value(reader);
+		}
+		json_reader_end_member(reader);
+		
+		if (json_reader_read_member(reader, "LIST")){
+			g_idle_add(remmina_plugin_manager_parse_plugin_list, json_reader_new(json_parser_get_root(parser)));
+		}
+		json_reader_end_member(reader);
+
+		if (json_reader_read_member(reader, "PLUGINS")){
+			g_idle_add(remmina_plugin_manager_download_plugins, json_reader_new(json_parser_get_root(parser)));
+		}
+	
+		json_reader_end_member(reader);
+		json_reader_end_element(reader);
+		g_object_unref(reader);
+
+		if (json_news_string == NULL) {
+			if (json_tip_string == NULL) {
+				to_show = ShowNone;
+			}
+			else if (info_disable_tip == 0) {
+				to_show = ShowTip;
+			}
+		}
+		else {
+			news_checksum = remmina_sha256_buffer((const guchar *)json_news_string, strlen(json_news_string));
+			if (news_checksum == NULL) {
+				REMMINA_DEBUG("News checksum is NULL");
+			}
+			else if ((remmina_pref.periodic_news_last_checksum == NULL) || strcmp(news_checksum, remmina_pref.periodic_news_last_checksum) != 0) {
+				REMMINA_DEBUG("Latest news checksum: %s", news_checksum);
+				remmina_pref.periodic_news_last_checksum = g_strdup(news_checksum);
+				remmina_pref_save();
+				if (info_disable_news == 0) {
+					to_show = ShowNews;
+				}
+			}
+			
+			if (to_show == ShowNone && json_tip_string != NULL && info_disable_tip == 0) {
+				to_show = ShowTip;
+			}
+			g_free(news_checksum);
+		}
+
+		if (to_show == ShowTip) {
+			RemminaInfoMessage *message = malloc(sizeof(RemminaInfoMessage));
+			if (message == NULL) {
+				return;
+			}
+			message->info_string= g_strdup(json_tip_string);
+			message->title_string= g_strdup("Tip of the Day");
+			g_idle_add(remmina_info_show_response, message);
+		}
+		else if (to_show == ShowNews) {
+			RemminaInfoMessage *message = malloc(sizeof(RemminaInfoMessage));
+			if (message == NULL) {
+				return;
+			}
+			message->info_string= g_strdup(json_news_string);
+			message->title_string= g_strdup("NEWS");
+			g_idle_add(remmina_info_show_response, message);
+		}
+
+		if (json_stats_int){
+			remmina_info_stats_collector();
+		}
+
+		g_object_unref(parser);
+	}
+
+}
+
+
+// Allocate memory to hold response from the server in msg->response
+size_t remmina_curl_process_response(void *buffer, size_t size, size_t nmemb, void *userp){
+	size_t realsize = size * nmemb;
+	struct curl_msg *msg = (struct curl_msg *)userp;
+ 
+	char *ptr = realloc(msg->response, msg->size + realsize + 1);
+	if (!ptr) {
+		return 0;  /* out of memory! */
+	}
+	
+	msg->response = ptr;
+	memcpy(&(msg->response[msg->size]), buffer, realsize);
+	msg->size += realsize;
+	msg->response[msg->size] = 0;
+	
+	return realsize;
+}
+
+
+void remmina_curl_send_message(gpointer data)
+{
+	gchar *result_message = NULL;
+    gchar *marked_up_message = NULL;
+	struct curl_msg* message = (struct curl_msg*)data;
+	message->size = 0;
+	message->response = NULL;
+	CURL* curl = curl_easy_init();
+	if (curl){
+		CURLcode res;
+		curl_easy_setopt(curl, CURLOPT_URL, message->url);
+		curl_easy_setopt(curl, CURLOPT_POSTFIELDS, message->body);
+		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, remmina_curl_process_response);
+		curl_easy_setopt(curl, CURLOPT_WRITEDATA, message);
+		curl_easy_setopt(curl, CURLOPT_TIMEOUT, 60);
+		res = curl_easy_perform(curl);
+		if(res != CURLE_OK){
+            curl_easy_strerror(res);
+			result_message = "Failure: Transport error occurred - see debug or logs for more information";
+			marked_up_message = RED_TEXT(result_message);
+		}
+		else{
+			handle_resp(message);
+			result_message = "Success: Message sent successfully, please wait for report to automatically open a new issue. This may take a little while.";
+			marked_up_message = GREEN_TEXT(result_message);
+
+		}
+		if (message->user_data != NULL){
+			gtk_label_set_markup(GTK_LABEL(message->user_data), marked_up_message);
+			
+		}
+		if (message->body){
+			g_free(message->body);
+		}
+		if (message->response){
+			g_free(message->response);
+		}
+		g_free(message);
+		g_free(marked_up_message);
+		curl_easy_cleanup(curl);
+	}
+}
+
+
+
+void remmina_curl_compose_message(gchar* body, char* type, char* url, gpointer data)
+{
+	if (!imode){
+		struct curl_msg* message = (struct curl_msg*)malloc(sizeof(struct curl_msg));
+		if (message == NULL) {
+			return;
+		}
+		message->body = body;
+		message->url = url;
+		message->user_data = data;
+		g_thread_new("send_curl_message", (GThreadFunc)remmina_curl_send_message, message);
+	}
+	
+}
diff --git a/src/remmina_curl_connector.h b/src/remmina_curl_connector.h
new file mode 100644
index 0000000..5ce33a8
--- /dev/null
+++ b/src/remmina_curl_connector.h
@@ -0,0 +1,54 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2016-2023 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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.
+ *
+ */
+#pragma once
+
+#include <glib.h>
+#include "json-glib/json-glib.h"
+
+G_BEGIN_DECLS
+
+#define DOWNLOAD_URL "https://plugins.remmina.org/plugins/plugin_download"
+#define LIST_URL "https://plugins.remmina.org/plugins/get_list"
+#define PERIODIC_UPLOAD_URL "https://info.remmina.org/info/upload_stats"
+#define INFO_REQUEST_URL "https://info.remmina.org/info/handshake"
+
+#define RED_TEXT(str) g_markup_printf_escaped("<span color=\"red\">%s</span>", str)
+#define GREEN_TEXT(str) g_markup_printf_escaped("<span color=\"green\">%s</span>", str)
+#define GRAY_TEXT(str) g_markup_printf_escaped("<span color=\"gray\">%s</span>", str)
+
+void remmina_curl_handshake(gpointer data);
+void remmina_curl_compose_message(gchar* body, char* type, char* url, gpointer data);
+
+G_END_DECLS
diff --git a/src/remmina_exec.c b/src/remmina_exec.c
new file mode 100644
index 0000000..cf76b58
--- /dev/null
+++ b/src/remmina_exec.c
@@ -0,0 +1,544 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010 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 "buildflags.h"
+#include <glib/gi18n.h>
+#include <stdlib.h>
+#include "remmina.h"
+#include "remmina_main.h"
+#include "remmina_log.h"
+#include "remmina_pref.h"
+#include "remmina_widget_pool.h"
+#include "remmina_unlock.h"
+#include "remmina_pref_dialog.h"
+#include "remmina_file.h"
+#include "remmina_file_manager.h"
+#include "remmina_file_editor.h"
+#include "rcw.h"
+#include "remmina_about.h"
+#include "remmina_plugin_manager.h"
+#include "remmina_exec.h"
+#include "remmina/remmina_trace_calls.h"
+#include "remmina_file_manager.h"
+#include "remmina_crypt.h"
+
+#include "remmina_icon.h"
+
+#ifdef SNAP_BUILD
+#   define ISSNAP "- SNAP Build -"
+#else
+#   define ISSNAP "-"
+#endif
+
+static gboolean cb_closewidget(GtkWidget *widget, gpointer data)
+{
+	TRACE_CALL(__func__);
+	/* The correct way to close a rcw is to send
+	 * it a "delete-event" signal. Simply destroying it will not close
+	 * all network connections */
+	if (REMMINA_IS_CONNECTION_WINDOW(widget))
+		return rcw_delete(RCW(widget));
+	return TRUE;
+}
+
+const gchar* remmina_exec_get_build_config(void)
+{
+	static const gchar build_config[] =
+	    "Build configuration: " BUILD_CONFIG "\n"
+	    "Build type:          " BUILD_TYPE "\n"
+	    "CFLAGS:              " CFLAGS "\n"
+	    "Compiler:            " COMPILER_ID ", " COMPILER_VERSION "\n"
+	    "Target architecture: " TARGET_ARCH "\n";
+	return build_config;
+}
+
+void remmina_exec_exitremmina()
+{
+	TRACE_CALL(__func__);
+
+	/* Save main window state/position */
+	remmina_main_save_before_destroy();
+
+	/* Delete all widgets, main window not included */
+	remmina_widget_pool_foreach(cb_closewidget, NULL);
+
+#ifdef HAVE_LIBAPPINDICATOR
+	/* Remove systray menu */
+	remmina_icon_destroy();
+#endif
+
+	/* close/destroy main window struct and window */
+	remmina_main_destroy();
+
+	/* Exit from Remmina */
+	g_application_quit(g_application_get_default());
+}
+
+static gboolean disable_rcw_delete_confirm_cb(GtkWidget *widget, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaConnectionWindow *rcw;
+
+	if (REMMINA_IS_CONNECTION_WINDOW(widget)) {
+		rcw = (RemminaConnectionWindow*)widget;
+		rcw_set_delete_confirm_mode(rcw, RCW_ONDELETE_NOCONFIRM);
+	}
+	return TRUE;
+}
+
+void remmina_exec_exitremmina_one_confirm()
+{
+	TRACE_CALL(__func__);
+	GtkWidget* dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION,
+							GTK_BUTTONS_YES_NO,
+							_("Are you sure you want to fully quit Remmina?\n This will close any active connections."));
+			int response = gtk_dialog_run(GTK_DIALOG(dialog));
+			gtk_widget_destroy(dialog);
+			if (response != GTK_RESPONSE_YES)
+				return;
+	remmina_widget_pool_foreach(disable_rcw_delete_confirm_cb, NULL);
+	remmina_exec_exitremmina();
+}
+
+void remmina_application_condexit(RemminaCondExitType why)
+{
+	TRACE_CALL(__func__);
+
+	/* Exit remmina only if there are no interesting windows left:
+	 * no main window, no systray menu, no connection window.
+	 * This function is usually called after a disconnection */
+
+	switch (why) {
+	case REMMINA_CONDEXIT_ONDISCONNECT:
+		// A connection has disconnected, should we exit remmina ?
+		if (remmina_widget_pool_count() < 1 && !remmina_main_get_window() && !remmina_icon_is_available())
+			remmina_exec_exitremmina();
+		break;
+	case REMMINA_CONDEXIT_ONMAINWINDELETE:
+		/* If we are in Kiosk mode, we just exit */
+		if (kioskmode && kioskmode == TRUE)
+			remmina_exec_exitremmina();
+		// Main window has been deleted
+		if (remmina_widget_pool_count() < 1 && !remmina_icon_is_available())
+			remmina_exec_exitremmina();
+		break;
+	case REMMINA_CONDEXIT_ONQUIT:
+		// Quit command has been sent from main window or appindicator/systray menu
+		// quit means QUIT.
+		remmina_widget_pool_foreach(disable_rcw_delete_confirm_cb, NULL);
+		remmina_exec_exitremmina();
+		break;
+	}
+}
+
+
+static void newline_remove(char *s)
+{
+	char c;
+	while((c = *s) != 0 && c != '\r' && c != '\n')
+		s++;
+	*s = 0;
+}
+
+/* used for commandline parameter --update-profile X --set-option Y --set-option Z
+ * return a status code for exit()
+ */
+int remmina_exec_set_setting(gchar *profilefilename, gchar **settings)
+{
+	RemminaFile *remminafile;
+	int i;
+	gchar **tk, *value = NULL;
+	char *line = NULL;
+	size_t len = 0;
+	ssize_t read;
+	gboolean abort = FALSE;
+
+	remminafile = remmina_file_manager_load_file(profilefilename);
+
+	if (!remminafile) {
+		g_print("Unable to open profile file %s\n", profilefilename);
+		return 2;
+	}
+
+	for(i = 0; settings[i] != NULL && !abort; i++) {
+		if (strlen(settings[i]) > 0) {
+			tk = g_strsplit(settings[i], "=", 2);
+			if (tk[1] == NULL) {
+				read = getline(&line, &len, stdin);
+				if (read > 0) {
+					newline_remove(line);
+					value = line;
+				} else {
+					g_print("Error: an extra line of standard input is needed\n");
+					abort = TRUE;
+				}
+			} else
+				value = tk[1];
+			remmina_file_set_string(remminafile, tk[0], value);
+			g_strfreev(tk);
+		}
+	}
+
+	if (line) free(line);
+
+	if (!abort) remmina_file_save(remminafile);
+
+	return 0;
+
+}
+
+static void remmina_exec_autostart_cb(RemminaFile *remminafile, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+
+	if (remmina_file_get_int(remminafile, "enable-autostart", FALSE)) {
+		REMMINA_DEBUG ("Profile %s is set to autostart", remminafile->filename);
+		rcw_open_from_filename(remminafile->filename);
+	}
+
+}
+
+static void remmina_exec_connect(const gchar *data)
+{
+	TRACE_CALL(__func__);
+
+	gchar *protocol;
+	gchar **protocolserver;
+	gchar *server;
+	RemminaFile *remminafile;
+	gchar **userat;
+	gchar **userpass;
+	gchar *user;
+	gchar *password;
+	gchar **domainuser;
+	gchar **serverquery;
+	gchar **querystring;
+	gchar **querystringpart;
+	gchar **querystringpartkv;
+	gchar *value;
+	gchar *temp;
+	GError *error = NULL;
+
+	protocol = NULL;
+	if (strncmp("rdp://", data, 6) == 0 || strncmp("RDP://", data, 6) == 0)
+		protocol = "RDP";
+	else if (strncmp("vnc://", data, 6) == 0 || strncmp("VNC://", data, 6) == 0)
+		protocol = "VNC";
+	else if (strncmp("ssh://", data, 6) == 0 || strncmp("SSH://", data, 6) == 0)
+		protocol = "SSH";
+	else if (strncmp("spice://", data, 8) == 0 || strncmp("SPICE://", data, 8) == 0)
+		protocol = "SPICE";
+
+	if (strncmp("file://", data, 6) == 0) {
+		gchar *filename = g_filename_from_uri (data, NULL, &error);
+		if (filename != NULL) {
+			rcw_open_from_filename(filename);
+		} else
+			REMMINA_DEBUG ("Opening URI %s failed with error %s", data, error->message);
+		g_error_free(error);
+		return;
+	}
+
+	if (protocol == NULL) {
+		rcw_open_from_filename(data);
+		return;
+	}
+
+	protocolserver = g_strsplit(data, "://", 2);
+	server = g_strdup(protocolserver[1]);
+
+	// Support loading .remmina files using handler
+	if ((temp = strrchr(server, '.')) != NULL && g_strcmp0(temp + 1, "remmina") == 0) {
+		g_strfreev(protocolserver);
+		temp = g_uri_unescape_string(server, NULL);
+		g_free(server);
+		server = temp;
+		rcw_open_from_filename(server);
+		return;
+	}
+
+	remminafile = remmina_file_new();
+
+	// Check for username@server
+	if ((strcmp(protocol, "RDP") == 0 || strcmp(protocol, "VNC") == 0 || strcmp(protocol, "SSH") == 0) && strstr(server, "@") != NULL) {
+		userat = g_strsplit(server, "@", 2);
+
+		// Check for username:password
+		if (strstr(userat[0], ":") != NULL) {
+			userpass = g_strsplit(userat[0], ":", 2);
+			user = g_uri_unescape_string(userpass[0], NULL);
+			password = g_uri_unescape_string(userpass[1], NULL);
+
+			// Try to decrypt the password field if it contains =
+			temp = password != NULL && strrchr(password, '=') != NULL ? remmina_crypt_decrypt(password) : NULL;
+			if (temp != NULL) {
+				g_free(password);
+				password = temp;
+			}
+			remmina_file_set_string(remminafile, "password", password);
+			g_free(password);
+			g_strfreev(userpass);
+		} else {
+			user = g_uri_unescape_string(userat[0], NULL);
+		}
+
+		// Check for domain\user for RDP connections
+		if (strcmp(protocol, "RDP") == 0 && strstr(user, "\\") != NULL) {
+			domainuser = g_strsplit(user, "\\", 2);
+			remmina_file_set_string(remminafile, "domain", domainuser[0]);
+			g_free(user);
+			user = g_strdup(domainuser[1]);
+		}
+
+		remmina_file_set_string(remminafile, "username", user);
+		g_free(user);
+		g_free(server);
+		server = g_strdup(userat[1]);
+		g_strfreev(userat);
+	}
+
+	if (strcmp(protocol, "VNC") == 0 && strstr(server, "?") != NULL) {
+		// https://tools.ietf.org/html/rfc7869
+		// VncUsername, VncPassword and ColorLevel supported for vnc-params
+
+		// Check for query string parameters
+		serverquery = g_strsplit(server, "?", 2);
+		querystring = g_strsplit(serverquery[1], "&", -1);
+		for (querystringpart = querystring; *querystringpart; querystringpart++) {
+			if (strstr(*querystringpart, "=") == NULL)
+				continue;
+			querystringpartkv = g_strsplit(*querystringpart, "=", 2);
+			value = g_uri_unescape_string(querystringpartkv[1], NULL);
+			if (strcmp(querystringpartkv[0], "VncPassword") == 0) {
+				// Try to decrypt password field if it contains =
+				temp = value != NULL && strrchr(value, '=') != NULL ? remmina_crypt_decrypt(value) : NULL;
+				if (temp != NULL) {
+					g_free(value);
+					value = temp;
+				}
+				remmina_file_set_string(remminafile, "password", value);
+			} else if (strcmp(querystringpartkv[0], "VncUsername") == 0) {
+				remmina_file_set_string(remminafile, "username", value);
+			} else if (strcmp(querystringpartkv[0], "ColorLevel") == 0) {
+				remmina_file_set_string(remminafile, "colordepth", value);
+			}
+			g_free(value);
+			g_strfreev(querystringpartkv);
+		}
+		g_strfreev(querystring);
+		g_free(server);
+		server = g_strdup(serverquery[0]);
+		g_strfreev(serverquery);
+	}
+
+	// Unescape server
+	temp = g_uri_unescape_string(server, NULL);
+	g_free(server);
+	server = temp;
+
+	remmina_file_set_string(remminafile, "server", server);
+	remmina_file_set_string(remminafile, "name", server);
+	remmina_file_set_string(remminafile, "sound", "off");
+	remmina_file_set_string(remminafile, "protocol", protocol);
+	g_free(server);
+	g_strfreev(protocolserver);
+	rcw_open_from_file(remminafile);
+}
+
+void remmina_exec_command(RemminaCommandType command, const gchar* data)
+{
+	TRACE_CALL(__func__);
+	gchar *s1;
+	gchar *s2;
+	gchar *temp;
+	GtkWidget *widget;
+	GtkWindow *mainwindow;
+	GtkWidget *prefdialog;
+	RemminaEntryPlugin *plugin;
+    int i;
+    int ch;
+	mainwindow = remmina_main_get_window();
+
+	switch (command) {
+	case REMMINA_COMMAND_AUTOSTART:
+		remmina_file_manager_iterate((GFunc)remmina_exec_autostart_cb, NULL);
+		break;
+
+	case REMMINA_COMMAND_MAIN:
+		if (mainwindow) {
+			gtk_window_present(mainwindow);
+			gtk_window_deiconify(GTK_WINDOW(mainwindow));
+		}else  {
+			widget = remmina_main_new();
+			gtk_widget_show(widget);
+		}
+		break;
+
+	case REMMINA_COMMAND_PREF:
+		if (remmina_pref_get_boolean("use_primary_password")
+				&& remmina_unlock_new(mainwindow) == 0)
+			break;
+		prefdialog = remmina_pref_dialog_get_dialog();
+		if (prefdialog) {
+			gtk_window_present(GTK_WINDOW(prefdialog));
+			gtk_window_deiconify(GTK_WINDOW(prefdialog));
+		}else  {
+			/* Create a new preference dialog */
+			widget = remmina_pref_dialog_new(atoi(data), NULL);
+			gtk_widget_show(widget);
+		}
+		break;
+
+	case REMMINA_COMMAND_NEW:
+		if (remmina_pref_get_boolean("lock_edit")
+				&& remmina_pref_get_boolean("use_primary_password"))
+				if (remmina_unlock_new(mainwindow) == 0)
+					break;
+		s1 = (data ? strchr(data, ',') : NULL);
+		if (s1) {
+			s1 = g_strdup(data);
+			s2 = strchr(s1, ',');
+			*s2++ = '\0';
+			widget = remmina_file_editor_new_full(s2, s1);
+			g_free(s1);
+		}else  {
+			widget = remmina_file_editor_new_full(NULL, data);
+		}
+		gtk_widget_show(widget);
+		break;
+
+	case REMMINA_COMMAND_CONNECT:
+		REMMINA_DEBUG ("Initiating connection");
+		/** @todo This should be a G_OPTION_ARG_FILENAME_ARRAY (^aay) so that
+		 * we can implement multi profile connection:
+		 *    https://gitlab.com/Remmina/Remmina/issues/915
+		 */
+		if (remmina_pref_get_boolean("lock_connect")
+				&& remmina_pref_get_boolean("use_primary_password"))
+				if (remmina_unlock_new(mainwindow) == 0)
+					break;
+		remmina_exec_connect(data);
+		break;
+
+	case REMMINA_COMMAND_EDIT:
+		if (remmina_pref_get_boolean("lock_edit")
+				&& remmina_pref_get_boolean("use_primary_password"))
+				if (remmina_unlock_new(mainwindow) == 0)
+					break;
+		widget = remmina_file_editor_new_from_filename(data);
+		if (widget)
+			gtk_widget_show(widget);
+		break;
+
+	case REMMINA_COMMAND_ABOUT:
+		remmina_about_open(NULL);
+		break;
+
+	case REMMINA_COMMAND_VERSION:
+		mainwindow = remmina_main_get_window();
+		if (mainwindow) {
+			remmina_about_open(NULL);
+		}else  {
+			g_print("%s %s %s (git %s)\n", g_get_application_name(), ISSNAP, VERSION, REMMINA_GIT_REVISION);
+			/* As we do not use the "handle-local-options" signal, we have to exit Remmina */
+			remmina_exec_command(REMMINA_COMMAND_EXIT, NULL);
+		}
+
+		break;
+
+	case REMMINA_COMMAND_FULL_VERSION:
+		mainwindow = remmina_main_get_window();
+		if (mainwindow) {
+			/* Show th widget with the list of plugins and versions */
+			remmina_plugin_manager_show(mainwindow);
+		}else  {
+			g_print("\n%s %s %s (git %s)\n\n", g_get_application_name(), ISSNAP, VERSION, REMMINA_GIT_REVISION);
+
+			remmina_plugin_manager_show_stdout();
+			g_print("\n%s\n", remmina_exec_get_build_config());
+			remmina_exec_command(REMMINA_COMMAND_EXIT, NULL);
+		}
+
+		break;
+
+
+	case REMMINA_COMMAND_PLUGIN:
+		plugin = (RemminaEntryPlugin*)remmina_plugin_manager_get_plugin(REMMINA_PLUGIN_TYPE_ENTRY, data);
+		if (plugin) {
+			plugin->entry_func(plugin);
+		}else  {
+			widget = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
+				_("Plugin %s is not registered."), data);
+			g_signal_connect(G_OBJECT(widget), "response", G_CALLBACK(gtk_widget_destroy), NULL);
+			gtk_widget_show(widget);
+			remmina_widget_pool_register(widget);
+		}
+		break;
+
+	case REMMINA_COMMAND_ENCRYPT_PASSWORD:
+		i = 0;
+		g_print("Enter the password you want to encrypt: ");
+		temp = (char *)g_malloc(255 * sizeof(char));
+		while ((ch = getchar()) != EOF && ch != '\n') {
+			if (i < 254) {
+				temp[i] = ch;
+				i++;
+			}
+		}
+		temp[i] = '\0';
+		s1 = remmina_crypt_encrypt(temp);
+		s2 = g_uri_escape_string(s1, NULL, TRUE);
+		g_print("\nEncrypted password: %s\n\n", s1);
+		g_print("Usage:\n");
+		g_print("rdp://username:%s@server\n", s1);
+		g_print("vnc://username:%s@server\n", s1);
+		g_print("vnc://server?VncUsername=user\\&VncPassword=%s\n", s2);
+		g_free(s1);
+		g_free(s2);
+		g_free(temp);
+		remmina_exec_exitremmina();
+		break;
+
+	case REMMINA_COMMAND_EXIT:
+		remmina_widget_pool_foreach(disable_rcw_delete_confirm_cb, NULL);
+		remmina_exec_exitremmina();
+		break;
+
+	default:
+		break;
+	}
+}
diff --git a/src/remmina_exec.h b/src/remmina_exec.h
new file mode 100644
index 0000000..3cadec0
--- /dev/null
+++ b/src/remmina_exec.h
@@ -0,0 +1,71 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010 Vic Lee
+ * Copyright (C) 2017-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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+typedef enum {
+	REMMINA_COMMAND_NONE		=  0,
+	REMMINA_COMMAND_MAIN		=  1,
+	REMMINA_COMMAND_PREF		=  2,
+	REMMINA_COMMAND_NEW		=  3,
+	REMMINA_COMMAND_CONNECT		=  4,
+	REMMINA_COMMAND_EDIT		=  5,
+	REMMINA_COMMAND_ABOUT		=  6,
+	REMMINA_COMMAND_VERSION		=  7,
+	REMMINA_COMMAND_FULL_VERSION	=  8,
+	REMMINA_COMMAND_PLUGIN		=  9,
+	REMMINA_COMMAND_EXIT		= 10,
+	REMMINA_COMMAND_AUTOSTART	= 11,
+	REMMINA_COMMAND_ENCRYPT_PASSWORD	= 12
+} RemminaCommandType;
+
+typedef enum {
+	REMMINA_CONDEXIT_ONDISCONNECT		= 0,
+	REMMINA_CONDEXIT_ONQUIT			= 1,
+	REMMINA_CONDEXIT_ONMAINWINDELETE	= 2
+} RemminaCondExitType;
+
+void remmina_exec_command(RemminaCommandType command, const gchar *data);
+void remmina_exec_exitremmina(void);
+void remmina_exec_exitremmina_one_confirm(void);
+void remmina_application_condexit(RemminaCondExitType why);
+
+int remmina_exec_set_setting(gchar *profilefilename, gchar **settings);
+
+G_END_DECLS
diff --git a/src/remmina_ext_exec.c b/src/remmina_ext_exec.c
new file mode 100644
index 0000000..38573f4
--- /dev/null
+++ b/src/remmina_ext_exec.c
@@ -0,0 +1,133 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009-2010 Vic Lee
+ * Copyright (C) 2014-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 <gdk/gdkkeysyms.h>
+#include <glib/gi18n.h>
+#include <glib.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include "remmina_utils.h"
+#include "remmina_ext_exec.h"
+#include "remmina_public.h"
+#include "remmina/remmina_trace_calls.h"
+
+#define SPAWN_TIMEOUT 10
+
+#define GET_OBJECT(object_name) gtk_builder_get_object(builder, object_name)
+
+static void wait_for_child(GPid pid, gint script_retval, gpointer data)
+{
+	PCon_Spinner *pcspinner = (PCon_Spinner*)data;
+
+	gtk_spinner_stop(GTK_SPINNER(pcspinner->spinner));
+	gtk_widget_destroy(GTK_WIDGET(pcspinner->dialog));
+	g_spawn_close_pid(pid);
+	/* TODO At the moment background processes will fail to start before the
+	 * remmina connection.
+	 * Adding a delay here could be a (not good) solution, or we should
+	 * monitor each child opened, but it could be quit tricky and messy */
+}
+
+GtkDialog* remmina_ext_exec_new(RemminaFile* remminafile, const char *remmina_ext_exec_type)
+{
+	TRACE_CALL(__func__);
+	GtkBuilder *builder;
+	PCon_Spinner *pcspinner;
+	GError *error = NULL;
+	char **argv;
+	gchar *cmd = NULL;
+	gchar pre[11];
+	gchar post[12];
+	GPid child_pid;
+
+	strcpy(pre, "precommand");
+	strcpy(post, "postcommand");
+
+	if (remmina_ext_exec_type != NULL && (
+				strcmp(remmina_ext_exec_type, pre) |
+				strcmp(remmina_ext_exec_type, post) )) {
+		cmd = g_strdup(remmina_file_get_string(remminafile, remmina_ext_exec_type));
+		g_debug("[%s] %s", remmina_ext_exec_type, cmd);
+	} else
+		return FALSE;
+
+	cmd = remmina_file_format_properties(remminafile, cmd);
+	g_debug("[%s] updated to: %s", remmina_ext_exec_type, cmd);
+	if (*cmd != 0) {
+
+		pcspinner = g_new(PCon_Spinner, 1);
+		builder = remmina_public_gtk_builder_new_from_resource("/org/remmina/Remmina/src/../data/ui/remmina_spinner.glade");
+		pcspinner->dialog = GTK_DIALOG(gtk_builder_get_object(builder, "DialogSpinner"));
+		pcspinner->label_pleasewait = GTK_LABEL(GET_OBJECT("label_pleasewait"));
+		pcspinner->spinner = GTK_WIDGET(GET_OBJECT("spinner"));
+		pcspinner->button_cancel = GTK_BUTTON(GET_OBJECT("button_cancel"));
+		/* Connect signals */
+		gtk_builder_connect_signals(builder, NULL);
+
+		/* Exec a predefined command */
+		g_shell_parse_argv(cmd, NULL, &argv, &error);
+
+		if (error) {
+			g_warning("%s\n", error->message);
+			g_error_free(error);
+		}
+
+		/* Consider using G_SPAWN_SEARCH_PATH_FROM_ENVP (from glib 2.38)*/
+		g_spawn_async(  NULL,                           // cwd
+			argv,                                   // argv
+			NULL,                                   // envp
+			G_SPAWN_SEARCH_PATH |
+			G_SPAWN_SEARCH_PATH_FROM_ENVP |
+			G_SPAWN_DO_NOT_REAP_CHILD,              // flags
+			NULL,                                   // child_setup
+			NULL,                                   // child_setup user data
+			&child_pid,                             // pid location
+			&error);                                // error
+		if (!error) {
+			gtk_spinner_start(GTK_SPINNER(pcspinner->spinner));
+			g_child_watch_add(child_pid, wait_for_child, (gpointer)pcspinner);
+			gtk_dialog_run(pcspinner->dialog);
+		}else  {
+			g_warning("Command %s exited with error: %s\n", cmd, error->message);
+			g_error_free(error);
+		}
+		g_strfreev(argv);
+		g_free(cmd);
+		return (pcspinner->dialog);
+	}
+	g_free(cmd);
+	return FALSE;
+}
diff --git a/src/remmina_ext_exec.h b/src/remmina_ext_exec.h
new file mode 100644
index 0000000..b2aa461
--- /dev/null
+++ b/src/remmina_ext_exec.h
@@ -0,0 +1,52 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009-2010 Vic Lee
+ * Copyright (C) 2014-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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include "remmina_file.h"
+
+G_BEGIN_DECLS
+
+typedef struct {
+	GtkDialog *	dialog;
+	GtkLabel *	label_pleasewait;
+	GtkButton *	button_cancel;
+	GtkWidget *	spinner;
+} PCon_Spinner;
+
+GtkDialog *remmina_ext_exec_new(RemminaFile *remminafile, const char *remmina_ext_exec_type);
+
+G_END_DECLS
diff --git a/src/remmina_external_tools.c b/src/remmina_external_tools.c
new file mode 100644
index 0000000..97543ca
--- /dev/null
+++ b/src/remmina_external_tools.c
@@ -0,0 +1,157 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2011 Marc-Andre Moreau
+ *
+ * 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 <gtk/gtk.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+#include <stdlib.h>
+#include "remmina_file.h"
+#include "remmina/types.h"
+#include "remmina_public.h"
+#include "remmina_external_tools.h"
+#include "remmina/remmina_trace_calls.h"
+
+static gboolean remmina_external_tools_launcher(const gchar* filename, const gchar* scriptname, const gchar* shortname);
+
+static void view_popup_menu_onDoSomething(GtkWidget *menuitem, gpointer userdata)
+{
+	TRACE_CALL(__func__);
+	gchar *remminafilename = g_object_get_data(G_OBJECT(menuitem), "remminafilename");
+	gchar *scriptfilename = g_object_get_data(G_OBJECT(menuitem), "scriptfilename");
+	gchar *scriptshortname = g_object_get_data(G_OBJECT(menuitem), "scriptshortname");
+
+	remmina_external_tools_launcher(remminafilename, scriptfilename, scriptshortname);
+}
+
+gboolean remmina_external_tools_from_filename(RemminaMain *remminamain, gchar* remminafilename)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *menu, *menuitem;
+	gchar dirname[MAX_PATH_LEN];
+	gchar filename[MAX_PATH_LEN];
+	GDir* dir;
+	const gchar* name;
+
+	strcpy(dirname, REMMINA_RUNTIME_EXTERNAL_TOOLS_DIR);
+	dir = g_dir_open(dirname, 0, NULL);
+
+	if (dir == NULL)
+		return FALSE;
+
+	menu = gtk_menu_new();
+
+	while ((name = g_dir_read_name(dir)) != NULL) {
+		if (!g_str_has_prefix(name, "remmina_"))
+			continue;
+		g_snprintf(filename, MAX_PATH_LEN, "%s/%s", dirname, name);
+
+		menuitem = gtk_menu_item_new_with_label(name + 8);
+		g_object_set_data_full(G_OBJECT(menuitem), "remminafilename", g_strdup(remminafilename), g_free);
+		g_object_set_data_full(G_OBJECT(menuitem), "scriptfilename", g_strdup(filename), g_free);
+		g_object_set_data_full(G_OBJECT(menuitem), "scriptshortname", g_strdup(name), g_free);
+		g_signal_connect(menuitem, "activate", (GCallback)view_popup_menu_onDoSomething, NULL);
+		gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
+	}
+	g_dir_close(dir);
+
+	gtk_widget_show_all(menu);
+
+	/* Note: event can be NULL here when called from view_onPopupMenu;
+	 *  gdk_event_get_time() accepts a NULL argument
+	 */
+#if GTK_CHECK_VERSION(3, 22, 0)
+	gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+#else
+	gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, 0);
+#endif
+
+	return TRUE;
+}
+
+static gboolean remmina_external_tools_launcher(const gchar* filename, const gchar* scriptname, const gchar* shortname)
+{
+	TRACE_CALL(__func__);
+	RemminaFile *remminafile;
+	const char *env_format = "%s=%s";
+	char *env;
+	size_t envstrlen;
+	gchar launcher[MAX_PATH_LEN];
+
+	g_snprintf(launcher, MAX_PATH_LEN, "%s/launcher.sh", REMMINA_RUNTIME_EXTERNAL_TOOLS_DIR);
+
+	remminafile = remmina_file_load(filename);
+	if (!remminafile)
+		return FALSE;
+	GHashTableIter iter;
+	const gchar *key, *value;
+	g_hash_table_iter_init(&iter, remminafile->settings);
+	while (g_hash_table_iter_next(&iter, (gpointer*)&key, (gpointer*)&value)) {
+		envstrlen = strlen(key) + strlen(value) + strlen(env_format) + 1;
+		env = (char*)malloc(envstrlen);
+		if (env == NULL) {
+			return -1;
+		}
+
+		int retval = snprintf(env, envstrlen, env_format, key, value);
+		if (retval > 0 && (size_t)retval <= envstrlen) {
+			if (putenv(env) != 0) {
+				/* If putenv fails, we must free the unused space */
+				free(env);
+			}
+		}
+	}
+	/* Adds the window title for the terminal window */
+	const char *term_title_key = "remmina_term_title";
+	const char *term_title_val_prefix = "Remmina external tool";
+	envstrlen = strlen(term_title_key) + strlen(term_title_val_prefix) + strlen(shortname) + 7;
+	env = (char*)malloc(envstrlen);
+	if (env != NULL) {
+		if (snprintf(env, envstrlen, "%s=%s: %s", term_title_key, term_title_val_prefix, shortname) ) {
+			if (putenv(env) != 0) {
+				/* If putenv fails, we must free the unused space */
+				free(env);
+			}
+		}
+	}
+
+	const size_t cmdlen = strlen(launcher) + strlen(scriptname) + 2;
+	gchar *cmd = (gchar*)malloc(cmdlen);
+	g_snprintf(cmd, cmdlen, "%s %s", launcher, scriptname);
+	system(cmd);
+	free(cmd);
+
+	remmina_file_free(remminafile);
+
+	return TRUE;
+}
diff --git a/src/remmina_external_tools.h b/src/remmina_external_tools.h
new file mode 100644
index 0000000..ea5abb9
--- /dev/null
+++ b/src/remmina_external_tools.h
@@ -0,0 +1,46 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009 - Vic Lee
+ * Copyright (C) 2017-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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include "remmina_main.h"
+
+G_BEGIN_DECLS
+
+/* Open a new connection window for a .remmina file */
+gboolean remmina_external_tools_from_filename(RemminaMain *remminamain, gchar *remminafilename);
+
+G_END_DECLS
diff --git a/src/remmina_file.c b/src/remmina_file.c
new file mode 100644
index 0000000..2e7bdc3
--- /dev/null
+++ b/src/remmina_file.c
@@ -0,0 +1,1134 @@
+/*
+ * 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
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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 <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <locale.h>
+#include <langinfo.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <utime.h>
+
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+
+#include "remmina/remmina_trace_calls.h"
+#include "remmina_crypt.h"
+#include "remmina_file_manager.h"
+#include "remmina_log.h"
+#include "remmina_main.h"
+#include "remmina_masterthread_exec.h"
+#include "remmina_plugin_manager.h"
+#include "remmina_pref.h"
+#include "remmina_public.h"
+#include "remmina_sodium.h"
+#include "remmina_utils.h"
+
+#define MIN_WINDOW_WIDTH 10
+#define MIN_WINDOW_HEIGHT 10
+
+#define KEYFILE_GROUP_REMMINA "remmina"
+#define KEYFILE_GROUP_STATE "Remmina Connection States"
+
+static struct timespec times[2];
+
+static RemminaFile *
+remmina_file_new_empty(void)
+{
+	TRACE_CALL(__func__);
+	RemminaFile *remminafile;
+
+	remminafile = g_new0(RemminaFile, 1);
+	remminafile->settings = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
+	remminafile->states = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
+	/* spsettings contains settings that are loaded from the secure_plugin.
+	 * it’s used by remmina_file_store_secret_plugin_password() to know
+	 * where to change */
+	remminafile->spsettings = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
+	remminafile->prevent_saving = FALSE;
+	return remminafile;
+}
+
+RemminaFile *
+remmina_file_new(void)
+{
+	TRACE_CALL(__func__);
+	RemminaFile *remminafile;
+
+	/* Try to load from the preference file for default settings first */
+	remminafile = remmina_file_load(remmina_pref_file);
+
+	if (remminafile) {
+		g_free(remminafile->filename);
+		remminafile->filename = NULL;
+	} else {
+		remminafile = remmina_file_new_empty();
+	}
+
+	return remminafile;
+}
+
+/**
+ * Generate a new Remmina connection profile file name.
+ */
+void remmina_file_generate_filename(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+
+	/** File name restrictions:
+	 * - Do not start with space.
+	 * - Do not end with space or dot.
+	 * - No more than 255 chars.
+	 * - Do not contain \0.
+	 * - Avoid % and $.
+	 * - Avoid underscores and spaces for interoperabiility with everything else.
+	 * - Better all lowercase.
+	 */
+	gchar *invalid_chars = "\\%|/$?<>:*. \"";
+	GString *filenamestr;
+	const gchar *s;
+
+
+	/* functions we can use
+	 * g_strstrip( string )
+	 *	Removes leading and trailing whitespace from a string
+	 * g_strdelimit (str, invalid_chars, '-'))
+	 *	Convert each invalid_chars in a hyphen
+	 * g_ascii_strdown(string)
+	 *	all lowercase
+	 * To be safe we should remove control characters as well (but I'm lazy)
+	 * https://rosettacode.org/wiki/Strip_control_codes_and_extended_characters_from_a_string#C
+	 * g_utf8_strncpy (gchar *dest, const gchar *src, gsize n);
+	 *	copies a given number of characters instead of a given number of bytes. The src string must be valid UTF-8 encoded text.
+	 * g_utf8_validate (const gchar *str, gssize max_len, const gchar **end);
+	 *	Validates UTF-8 encoded text.
+	 */
+
+	//g_free(remminafile->filename), remminafile->filename = NULL;
+
+	filenamestr = g_string_new(g_strdup_printf("%s",
+						   remmina_pref.remmina_file_name));
+	if ((s = remmina_file_get_string(remminafile, "name")) == NULL) s = "name";
+	if (g_strstr_len(filenamestr->str, -1, "%N") != NULL)
+		remmina_utils_string_replace_all(filenamestr, "%N", s);
+
+	if ((s = remmina_file_get_string(remminafile, "group")) == NULL) s = "group";
+	if (g_strstr_len(filenamestr->str, -1, "%G") != NULL)
+		remmina_utils_string_replace_all(filenamestr, "%G", s);
+
+	if ((s = remmina_file_get_string(remminafile, "protocol")) == NULL) s = "proto";
+	if (g_strstr_len(filenamestr->str, -1, "%P") != NULL)
+		remmina_utils_string_replace_all(filenamestr, "%P", s);
+
+	if ((s = remmina_file_get_string(remminafile, "server")) == NULL) s = "host";
+	if (g_strstr_len(filenamestr->str, -1, "%h") != NULL)
+		remmina_utils_string_replace_all(filenamestr, "%h", s);
+
+	s = NULL;
+
+	g_autofree gchar *filename = g_strdelimit(g_ascii_strdown(g_strstrip(g_string_free(filenamestr, FALSE)), -1),
+						  invalid_chars, '-');
+
+	GDir *dir = g_dir_open(remmina_file_get_datadir(), 0, NULL);
+
+	if (dir != NULL)
+		remminafile->filename = g_strdup_printf("%s/%s.remmina", remmina_file_get_datadir(), filename);
+	else
+		remminafile->filename = NULL;
+	g_dir_close(dir);
+
+}
+
+void remmina_file_set_filename(RemminaFile *remminafile, const gchar *filename)
+{
+	TRACE_CALL(__func__);
+	g_free(remminafile->filename);
+	remminafile->filename = g_strdup(filename);
+}
+
+void remmina_file_set_statefile(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+
+	if (!remminafile)
+		return;
+	else
+		g_free(remminafile->statefile);
+
+	gchar *basename = g_path_get_basename(remminafile->filename);
+	gchar *cachedir = g_build_path("/", g_get_user_cache_dir(), "remmina", NULL);
+	GString *fname = g_string_new(basename);
+
+	remminafile->statefile = g_strdup_printf("%s/%s.state", cachedir, fname->str);
+
+	g_free(cachedir);
+	g_string_free(fname, TRUE);
+	g_free(basename);
+}
+
+const gchar *
+remmina_file_get_filename(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	return remminafile->filename;
+}
+
+RemminaFile *
+remmina_file_copy(const gchar *filename)
+{
+	TRACE_CALL(__func__);
+	RemminaFile *remminafile;
+	gchar *buf;
+
+	remminafile = remmina_file_load(filename);
+	buf = g_strdup_printf( "COPY %s",
+			remmina_file_get_string(remminafile, "name"));
+	remmina_file_set_string(remminafile, "name", buf);
+	g_free(buf);
+
+	if (remminafile)
+		remmina_file_generate_filename(remminafile);
+
+	return remminafile;
+}
+
+const RemminaProtocolSetting *find_protocol_setting(const gchar *name, RemminaProtocolPlugin *protocol_plugin)
+{
+	TRACE_CALL(__func__);
+	const RemminaProtocolSetting *setting_iter;
+
+	if (protocol_plugin == NULL)
+		return NULL;
+
+	setting_iter = protocol_plugin->basic_settings;
+	if (setting_iter) {
+		while (setting_iter->type != REMMINA_PROTOCOL_SETTING_TYPE_END) {
+			if (strcmp(name, remmina_plugin_manager_get_canonical_setting_name(setting_iter)) == 0)
+				return setting_iter;
+			setting_iter++;
+		}
+	}
+
+	setting_iter = protocol_plugin->advanced_settings;
+	if (setting_iter) {
+		while (setting_iter->type != REMMINA_PROTOCOL_SETTING_TYPE_END) {
+			if (strcmp(name, remmina_plugin_manager_get_canonical_setting_name(setting_iter)) == 0)
+				return setting_iter;
+			setting_iter++;
+		}
+	}
+
+	return NULL;
+}
+
+
+static void upgrade_sshkeys_202001_mig_common_setting(RemminaFile *remminafile, gboolean protocol_is_ssh, gboolean ssh_enabled, gchar *suffix)
+{
+	gchar *src_key;
+	gchar *dst_key;
+	const gchar *val;
+
+	src_key = g_strdup_printf("ssh_%s", suffix);
+	dst_key = g_strdup_printf("ssh_tunnel_%s", suffix);
+
+	val = remmina_file_get_string(remminafile, src_key);
+	if (!val) {
+		g_free(dst_key);
+		g_free(src_key);
+		return;
+	}
+
+	if (ssh_enabled && val && val[0] != 0)
+		remmina_file_set_string(remminafile, dst_key, val);
+
+	if (!protocol_is_ssh)
+		remmina_file_set_string(remminafile, src_key, NULL);
+
+	g_free(dst_key);
+	g_free(src_key);
+}
+
+static void upgrade_sshkeys_202001(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+
+	gboolean protocol_is_ssh;
+	gboolean ssh_enabled;
+	const gchar *val;
+
+	if (remmina_file_get_string(remminafile, "ssh_enabled")) {
+		/* Upgrade ssh params from remmina pre 1.4 */
+
+		ssh_enabled = remmina_file_get_int(remminafile, "ssh_enabled", 0);
+		val = remmina_file_get_string(remminafile, "protocol");
+		protocol_is_ssh = (strcmp(val, "SSH") == 0);
+
+		upgrade_sshkeys_202001_mig_common_setting(remminafile, protocol_is_ssh, ssh_enabled, "stricthostkeycheck");
+		upgrade_sshkeys_202001_mig_common_setting(remminafile, protocol_is_ssh, ssh_enabled, "kex_algorithms");
+		upgrade_sshkeys_202001_mig_common_setting(remminafile, protocol_is_ssh, ssh_enabled, "hostkeytypes");
+		upgrade_sshkeys_202001_mig_common_setting(remminafile, protocol_is_ssh, ssh_enabled, "ciphers");
+		upgrade_sshkeys_202001_mig_common_setting(remminafile, protocol_is_ssh, ssh_enabled, "proxycommand");
+		upgrade_sshkeys_202001_mig_common_setting(remminafile, protocol_is_ssh, ssh_enabled, "passphrase");
+		upgrade_sshkeys_202001_mig_common_setting(remminafile, protocol_is_ssh, ssh_enabled, "auth");
+		upgrade_sshkeys_202001_mig_common_setting(remminafile, protocol_is_ssh, ssh_enabled, "privatekey");
+
+		val = remmina_file_get_string(remminafile, "ssh_loopback");
+		if (val) {
+			remmina_file_set_string(remminafile, "ssh_tunnel_loopback", val);
+			remmina_file_set_string(remminafile, "ssh_loopback", NULL);
+		}
+
+		val = remmina_file_get_string(remminafile, "ssh_username");
+		if (val) {
+			remmina_file_set_string(remminafile, "ssh_tunnel_username", val);
+			if (protocol_is_ssh)
+				remmina_file_set_string(remminafile, "username", val);
+			remmina_file_set_string(remminafile, "ssh_username", NULL);
+		}
+
+		val = remmina_file_get_string(remminafile, "ssh_password");
+		if (val) {
+			remmina_file_set_string(remminafile, "ssh_tunnel_password", val);
+			if (protocol_is_ssh)
+				remmina_file_set_string(remminafile, "password", val);
+			remmina_file_set_string(remminafile, "ssh_password", NULL);
+		}
+
+		val = remmina_file_get_string(remminafile, "ssh_server");
+		if (val) {
+			remmina_file_set_string(remminafile, "ssh_tunnel_server", val);
+			remmina_file_set_string(remminafile, "ssh_server", NULL);
+		}
+
+		/* Real key removal will be done by remmina_file_save() */
+
+		remmina_file_set_int(remminafile, "ssh_tunnel_enabled", ssh_enabled);
+	}
+}
+
+RemminaFile *
+remmina_file_load(const gchar *filename)
+{
+	TRACE_CALL(__func__);
+	GKeyFile *gkeyfile;
+	RemminaFile *remminafile;
+	gchar *key;
+	gchar *s;
+	RemminaProtocolPlugin *protocol_plugin;
+	RemminaSecretPlugin *secret_plugin;
+	gboolean secret_service_available;
+	int w, h;
+
+	gkeyfile = g_key_file_new();
+
+	if (g_file_test(filename, G_FILE_TEST_IS_REGULAR | G_FILE_TEST_EXISTS)) {
+		if (!g_key_file_load_from_file(gkeyfile, filename, G_KEY_FILE_NONE, NULL)) {
+			g_key_file_free(gkeyfile);
+			REMMINA_DEBUG("Unable to load remmina profile file %s: g_key_file_load_from_file() returned NULL.\n", filename);
+			return NULL;
+		}
+	}
+
+	if (!g_key_file_has_key(gkeyfile, KEYFILE_GROUP_REMMINA, "name", NULL)) {
+
+		REMMINA_DEBUG("Unable to load remmina profile file %s: cannot find key name= in section remmina.\n", filename);
+		remminafile = NULL;
+		remmina_file_set_statefile(remminafile);
+
+		g_key_file_free(gkeyfile);
+
+		return remminafile;
+	}
+	remminafile = remmina_file_new_empty();
+
+	protocol_plugin = NULL;
+
+	/* Identify the protocol plugin and get pointers to its RemminaProtocolSetting structs */
+	gchar *proto = g_key_file_get_string(gkeyfile, KEYFILE_GROUP_REMMINA, "protocol", NULL);
+	if (proto) {
+		protocol_plugin = (RemminaProtocolPlugin *)remmina_plugin_manager_get_plugin(REMMINA_PLUGIN_TYPE_PROTOCOL, proto);
+		g_free(proto);
+	}
+
+	secret_plugin = remmina_plugin_manager_get_secret_plugin();
+	secret_service_available = secret_plugin && secret_plugin->is_service_available(secret_plugin);
+
+	remminafile->filename = g_strdup(filename);
+	gsize nkeys = 0;
+	gint keyindex;
+	GError *err = NULL;
+	gchar **keys = g_key_file_get_keys(gkeyfile, KEYFILE_GROUP_REMMINA, &nkeys, &err);
+	if (keys == NULL) {
+		g_clear_error(&err);
+	}
+	for (keyindex = 0; keyindex < nkeys; ++keyindex) {
+		key = keys[keyindex];
+		/* It may contain an encrypted password
+		 * - password = .         // secret_service
+		 * - password = $argon2id$v=19$m=262144,t=3,p=…    // libsodium
+		 */
+		if (protocol_plugin && remmina_plugin_manager_is_encrypted_setting(protocol_plugin, key)) {
+			s = g_key_file_get_string(gkeyfile, KEYFILE_GROUP_REMMINA, key, NULL);
+#if 0
+			switch (remmina_pref.enc_mode) {
+				case RM_ENC_MODE_SODIUM_INTERACTIVE:
+				case RM_ENC_MODE_SODIUM_MODERATE:
+				case RM_ENC_MODE_SODIUM_SENSITIVE:
+#if SODIUM_VERSION_INT >= 90200
+#endif
+					break;
+				case RM_ENC_MODE_GCRYPT:
+					break;
+				case RM_ENC_MODE_SECRET:
+				default:
+					break;
+			}
+#endif
+			if ((g_strcmp0(s, ".") == 0) && (secret_service_available)) {
+				gchar *sec = secret_plugin->get_password(secret_plugin, remminafile, key);
+				remmina_file_set_string(remminafile, key, sec);
+				/* Annotate in spsettings that this value comes from secret_plugin */
+				g_hash_table_insert(remminafile->spsettings, g_strdup(key), NULL);
+				g_free(sec);
+			} else {
+				gchar *decrypted;
+				decrypted = remmina_crypt_decrypt(s);
+				remmina_file_set_string(remminafile, key, decrypted);
+				g_free(decrypted);
+			}
+			g_free(s), s = NULL;
+		} else {
+			/* If we find "resolution", then we split it in two */
+			if (strcmp(key, "resolution") == 0) {
+				gchar *resolution_str = g_key_file_get_string(gkeyfile, KEYFILE_GROUP_REMMINA, key, NULL);
+				if (remmina_public_split_resolution_string(resolution_str, &w, &h)) {
+					gchar *buf;
+					buf = g_strdup_printf("%i", w); remmina_file_set_string(remminafile, "resolution_width", buf); g_free(buf);
+					buf = g_strdup_printf("%i", h); remmina_file_set_string(remminafile, "resolution_height", buf); g_free(buf);
+				} else {
+					remmina_file_set_string(remminafile, "resolution_width", NULL);
+					remmina_file_set_string(remminafile, "resolution_height", NULL);
+				}
+				g_free(resolution_str);
+			} else {
+				gchar *value;
+				value = g_key_file_get_string(gkeyfile, KEYFILE_GROUP_REMMINA, key, NULL);
+				remmina_file_set_string(remminafile, key, value);
+				g_free(value);
+			}
+		}
+	}
+
+	upgrade_sshkeys_202001(remminafile);
+	g_strfreev(keys);
+	remmina_file_set_statefile(remminafile);
+	g_key_file_free(gkeyfile);
+	return remminafile;
+}
+
+void remmina_file_set_string(RemminaFile *remminafile, const gchar *setting, const gchar *value)
+{
+	TRACE_CALL(__func__);
+
+	/* Note: setting and value are copied on the heap, so it is responsibility of the caller
+	 * to deallocate them when returning from remmina_file_set_string() if needed */
+
+	if (!remmina_masterthread_exec_is_main_thread()) {
+		/* Allow the execution of this function from a non main thread
+		 * (plugins needs it to have user credentials)*/
+		RemminaMTExecData *d;
+		d = (RemminaMTExecData *)g_malloc(sizeof(RemminaMTExecData));
+		d->func = FUNC_FILE_SET_STRING;
+		d->p.file_set_string.remminafile = remminafile;
+		d->p.file_set_string.setting = setting;
+		d->p.file_set_string.value = value;
+		remmina_masterthread_exec_and_wait(d);
+		g_free(d);
+		return;
+	}
+
+	if (value) {
+		/* We refuse to accept to set the "resolution" field */
+		if (strcmp(setting, "resolution") == 0) {
+			// TRANSLATORS: This is a message that pops up when an external Remmina plugin tries to set the window resolution using a legacy parameter.
+			const gchar *message = _("Using the «resolution» parameter in the Remmina preferences file is deprecated.\n");
+			REMMINA_CRITICAL(message);
+			remmina_main_show_warning_dialog(message);
+			return;
+		}
+		g_hash_table_insert(remminafile->settings, g_strdup(setting), g_strdup(value));
+	} else {
+		g_hash_table_insert(remminafile->settings, g_strdup(setting), g_strdup(""));
+	}
+}
+
+void remmina_file_set_state(RemminaFile *remminafile, const gchar *setting, const gchar *value)
+{
+	TRACE_CALL(__func__);
+
+	if (value && value[0] != 0)
+		g_hash_table_insert(remminafile->states, g_strdup(setting), g_strdup(value));
+	else
+		g_hash_table_insert(remminafile->states, g_strdup(setting), g_strdup(""));
+}
+
+const gchar *
+remmina_file_get_string(RemminaFile *remminafile, const gchar *setting)
+{
+	TRACE_CALL(__func__);
+	gchar *value;
+
+	/* Returned value is a pointer to the string stored on the hash table,
+	 * please do not free it or the hash table will contain invalid pointer */
+	if (!remmina_masterthread_exec_is_main_thread()) {
+		/* Allow the execution of this function from a non main thread
+		 * (plugins needs it to have user credentials)*/
+		RemminaMTExecData *d;
+		const gchar *retval;
+		d = (RemminaMTExecData *)g_malloc(sizeof(RemminaMTExecData));
+		d->func = FUNC_FILE_GET_STRING;
+		d->p.file_get_string.remminafile = remminafile;
+		d->p.file_get_string.setting = setting;
+		remmina_masterthread_exec_and_wait(d);
+		retval = d->p.file_get_string.retval;
+		g_free(d);
+		return retval;
+	}
+
+	if (strcmp(setting, "resolution") == 0) {
+		// TRANSLATORS: This is a message that pop-up when an external Remmina plugin tries to set the windows resolution using a legacy parameter.
+		const gchar *message = _("Using the «resolution» parameter in the Remmina preferences file is deprecated.\n");
+		REMMINA_CRITICAL(message);
+		remmina_main_show_warning_dialog(message);
+		return NULL;
+	}
+
+	value = (gchar *)g_hash_table_lookup(remminafile->settings, setting);
+	return value && value[0] ? value : NULL;
+}
+
+gchar *
+remmina_file_get_secret(RemminaFile *remminafile, const gchar *setting)
+{
+	TRACE_CALL(__func__);
+
+	/* This function is in the RemminaPluginService table, we cannot remove it
+	 * without breaking plugin API */
+	g_warning("remmina_file_get_secret(remminafile,“%s”) is deprecated and must not be called. Use remmina_file_get_string() and do not deallocate returned memory.\n", setting);
+	return g_strdup(remmina_file_get_string(remminafile, setting));
+}
+
+gchar *remmina_file_format_properties(RemminaFile *remminafile, const gchar *setting)
+{
+	gchar *res = NULL;
+	GString *fmt_str;
+	GDateTime *now;
+	gchar *date_str = NULL;
+
+	fmt_str = g_string_new(setting);
+	remmina_utils_string_replace_all(fmt_str, "%h", remmina_file_get_string(remminafile, "server"));
+	remmina_utils_string_replace_all(fmt_str, "%t", remmina_file_get_string(remminafile, "ssh_tunnel_server"));
+	remmina_utils_string_replace_all(fmt_str, "%u", remmina_file_get_string(remminafile, "username"));
+	remmina_utils_string_replace_all(fmt_str, "%U", remmina_file_get_string(remminafile, "ssh_tunnel_username"));
+	remmina_utils_string_replace_all(fmt_str, "%p", remmina_file_get_string(remminafile, "name"));
+	remmina_utils_string_replace_all(fmt_str, "%g", remmina_file_get_string(remminafile, "group"));
+
+	now = g_date_time_new_now_local();
+	date_str = g_date_time_format(now, "%FT%TZ");
+	remmina_utils_string_replace_all(fmt_str, "%d", date_str);
+	g_free(date_str);
+
+	res = g_string_free(fmt_str, FALSE);
+	return res;
+}
+
+void remmina_file_set_int(RemminaFile *remminafile, const gchar *setting, gint value)
+{
+	TRACE_CALL(__func__);
+	if (remminafile)
+		g_hash_table_insert(remminafile->settings,
+				    g_strdup(setting),
+				    g_strdup_printf("%i", value));
+}
+
+void remmina_file_set_state_int(RemminaFile *remminafile, const gchar *setting, gint value)
+{
+	TRACE_CALL(__func__);
+	if (remminafile)
+		g_hash_table_insert(remminafile->states,
+				    g_strdup(setting),
+				    g_strdup_printf("%i", value));
+}
+
+gint remmina_file_get_int(RemminaFile *remminafile, const gchar *setting, gint default_value)
+{
+	TRACE_CALL(__func__);
+	gchar *value;
+	gint r;
+
+	value = g_hash_table_lookup(remminafile->settings, setting);
+	r = value == NULL ? default_value : (value[0] == 't' ? TRUE : atoi(value));
+	// TOO verbose: REMMINA_DEBUG ("Integer value is: %d", r);
+	return r;
+}
+
+gint remmina_file_get_state_int(RemminaFile *remminafile, const gchar *setting, gint default_value)
+{
+	TRACE_CALL(__func__);
+	gchar *value;
+	gint r;
+
+	value = g_hash_table_lookup(remminafile->states, setting);
+	r = value == NULL ? default_value : (value[0] == 't' ? TRUE : atoi(value));
+	// TOO verbose: REMMINA_DEBUG ("Integer value is: %d", r);
+	return r;
+}
+
+// sscanf uses the set language to convert the float.
+// therefore '.' and ',' cannot be used interchangeably.
+gdouble remmina_file_get_double(RemminaFile *	remminafile,
+				const gchar *	setting,
+				gdouble		default_value)
+{
+	TRACE_CALL(__func__);
+	gchar *value;
+
+	value = g_hash_table_lookup(remminafile->settings, setting);
+	if (!value)
+		return default_value;
+
+	// str to double.
+	// https://stackoverflow.com/questions/10075294/converting-string-to-a-double-variable-in-c
+	gdouble d;
+	gint ret = sscanf(value, "%lf", &d);
+
+	if (ret != 1)
+		// failed.
+		d = default_value;
+
+	// TOO VERBOSE: REMMINA_DEBUG("Double value is: %lf", d);
+	return d;
+}
+
+// sscanf uses the set language to convert the float.
+// therefore '.' and ',' cannot be used interchangeably.
+gdouble remmina_file_get_state_double(RemminaFile *	remminafile,
+				      const gchar *	setting,
+				      gdouble		default_value)
+{
+	TRACE_CALL(__func__);
+	gchar *value;
+
+	value = g_hash_table_lookup(remminafile->states, setting);
+	if (!value)
+		return default_value;
+
+	// str to double.
+	// https://stackoverflow.com/questions/10075294/converting-string-to-a-double-variable-in-c
+	gdouble d;
+	gint ret = sscanf(value, "%lf", &d);
+
+	if (ret != 1)
+		// failed.
+		d = default_value;
+
+	// TOO VERBOSE: REMMINA_DEBUG("Double value is: %lf", d);
+	return d;
+}
+
+static GKeyFile *
+remmina_file_get_keyfile(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	GKeyFile *gkeyfile;
+
+	if (remminafile->filename == NULL)
+		return NULL;
+	gkeyfile = g_key_file_new();
+	if (!g_key_file_load_from_file(gkeyfile, remminafile->filename, G_KEY_FILE_NONE, NULL)) {
+		/* it will fail if it’s a new file, but shouldn’t matter. */
+	}
+	return gkeyfile;
+}
+
+static GKeyFile *
+remmina_file_get_keystate(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	GKeyFile *gkeyfile;
+
+	if (remminafile->statefile == NULL)
+		return NULL;
+	gkeyfile = g_key_file_new();
+	if (!g_key_file_load_from_file(gkeyfile, remminafile->statefile, G_KEY_FILE_NONE, NULL)) {
+		/* it will fail if it’s a new file, but shouldn’t matter. */
+	}
+	return gkeyfile;
+}
+
+void remmina_file_free(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	if (remminafile == NULL)
+		return;
+
+	if (remminafile->filename)
+		g_free(remminafile->filename);
+	if (remminafile->statefile)
+		g_free(remminafile->statefile);
+	if (remminafile->settings)
+		g_hash_table_destroy(remminafile->settings);
+	if (remminafile->spsettings)
+		g_hash_table_destroy(remminafile->spsettings);
+	if (remminafile->states)
+		g_hash_table_destroy(remminafile->states);
+
+	g_free(remminafile);
+}
+
+
+void remmina_file_save(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	RemminaSecretPlugin *secret_plugin;
+	gboolean secret_service_available;
+	RemminaProtocolPlugin *protocol_plugin;
+	GHashTableIter iter;
+	const gchar *key, *value;
+	gchar *s, *proto, *content;
+	gint nopasswdsave;
+	GKeyFile *gkeyfile;
+	GKeyFile *gkeystate;
+	gsize length = 0;
+	GError *err = NULL;
+
+	if (remminafile->prevent_saving)
+		return;
+
+	if ((gkeyfile = remmina_file_get_keyfile(remminafile)) == NULL)
+		return;
+
+	if ((gkeystate = remmina_file_get_keystate(remminafile)) == NULL)
+		return;
+
+	REMMINA_DEBUG("Saving profile");
+	/* get disablepasswordstoring */
+	nopasswdsave = remmina_file_get_int(remminafile, "disablepasswordstoring", 0);
+	/* Identify the protocol plugin and get pointers to its RemminaProtocolSetting structs */
+	proto = (gchar *)g_hash_table_lookup(remminafile->settings, "protocol");
+	if (proto) {
+		protocol_plugin = (RemminaProtocolPlugin *)remmina_plugin_manager_get_plugin(REMMINA_PLUGIN_TYPE_PROTOCOL, proto);
+	} else {
+		REMMINA_CRITICAL("Saving settings for unknown protocol:", proto);
+		protocol_plugin = NULL;
+	}
+
+	secret_plugin = remmina_plugin_manager_get_secret_plugin();
+	secret_service_available = secret_plugin && secret_plugin->is_service_available(secret_plugin);
+
+	g_hash_table_iter_init(&iter, remminafile->settings);
+	while (g_hash_table_iter_next(&iter, (gpointer *)&key, (gpointer *)&value)) {
+		if (remmina_plugin_manager_is_encrypted_setting(protocol_plugin, key)) {
+			if (remminafile->filename && g_strcmp0(remminafile->filename, remmina_pref_file)) {
+				if (secret_service_available && nopasswdsave == 0) {
+					REMMINA_DEBUG("We have a secret and disablepasswordstoring=0");
+					if (value && value[0]) {
+						if (g_strcmp0(value, ".") != 0)
+							secret_plugin->store_password(secret_plugin, remminafile, key, value);
+						g_key_file_set_string(gkeyfile, KEYFILE_GROUP_REMMINA, key, ".");
+					} else {
+						g_key_file_set_string(gkeyfile, KEYFILE_GROUP_REMMINA, key, "");
+						secret_plugin->delete_password(secret_plugin, remminafile, key);
+					}
+				} else {
+					REMMINA_DEBUG("We have a password and disablepasswordstoring=0");
+					if (value && value[0] && nopasswdsave == 0) {
+						s = remmina_crypt_encrypt(value);
+						g_key_file_set_string(gkeyfile, KEYFILE_GROUP_REMMINA, key, s);
+						g_free(s);
+					} else {
+						g_key_file_set_string(gkeyfile, KEYFILE_GROUP_REMMINA, key, "");
+					}
+				}
+				if (secret_service_available && nopasswdsave == 1) {
+					if (value && value[0]) {
+						if (g_strcmp0(value, ".") != 0) {
+							REMMINA_DEBUG("Deleting the secret in the keyring as disablepasswordstoring=1");
+							secret_plugin->delete_password(secret_plugin, remminafile, key);
+							g_key_file_set_string(gkeyfile, KEYFILE_GROUP_REMMINA, key, ".");
+						}
+					}
+				}
+			}
+		} else {
+			g_key_file_set_string(gkeyfile, KEYFILE_GROUP_REMMINA, key, value);
+		}
+	}
+
+	/* Avoid storing redundant and deprecated "resolution" field */
+	g_key_file_remove_key(gkeyfile, KEYFILE_GROUP_REMMINA, "resolution", NULL);
+
+	/* Delete old pre-1.4 ssh keys */
+	g_key_file_remove_key(gkeyfile, KEYFILE_GROUP_REMMINA, "ssh_enabled", NULL);
+	g_key_file_remove_key(gkeyfile, KEYFILE_GROUP_REMMINA, "save_ssh_server", NULL);
+	g_key_file_remove_key(gkeyfile, KEYFILE_GROUP_REMMINA, "save_ssh_username", NULL);
+
+	/* Store gkeyfile to disk (password are already sent to keyring) */
+	content = g_key_file_to_data(gkeyfile, &length, NULL);
+
+	if (g_file_set_contents(remminafile->filename, content, length, &err))
+		REMMINA_DEBUG("Profile saved");
+	else
+		REMMINA_WARNING("Remmina connection profile cannot be saved, with error %d (%s)", err->code, err->message);
+	if (err != NULL)
+		g_error_free(err);
+
+	g_free(content), content = NULL;
+	/* Saving states */
+	g_hash_table_iter_init(&iter, remminafile->states);
+	while (g_hash_table_iter_next(&iter, (gpointer *)&key, (gpointer *)&value))
+		g_key_file_set_string(gkeyfile, KEYFILE_GROUP_STATE, key, value);
+	content = g_key_file_to_data(gkeystate, &length, NULL);
+	if (g_file_set_contents(remminafile->statefile, content, length, &err))
+		REMMINA_DEBUG("Connection profile states saved");
+	else
+		REMMINA_WARNING("Remmina connection profile cannot be saved, with error %d (%s)", err->code, err->message);
+	if (err != NULL)
+		g_error_free(err);
+	g_free(content), content = NULL;
+	g_key_file_free(gkeyfile);
+	g_key_file_free(gkeystate);
+
+	if (!remmina_pref.list_refresh_workaround)
+		remmina_main_update_file_datetime(remminafile);
+}
+
+void remmina_file_store_secret_plugin_password(RemminaFile *remminafile, const gchar *key, const gchar *value)
+{
+	TRACE_CALL(__func__);
+
+	/* Only change the password in the keyring. This function
+	 * is a shortcut which avoids updating of date/time of .pref file
+	 * when possible, and is used by the mpchanger */
+	RemminaSecretPlugin *plugin;
+
+	if (g_hash_table_lookup_extended(remminafile->spsettings, g_strdup(key), NULL, NULL)) {
+		plugin = remmina_plugin_manager_get_secret_plugin();
+		plugin->store_password(plugin, remminafile, key, value);
+	} else {
+		remmina_file_set_string(remminafile, key, value);
+		remmina_file_save(remminafile);
+	}
+}
+
+RemminaFile *
+remmina_file_dup(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	RemminaFile *dupfile;
+	GHashTableIter iter;
+	const gchar *key, *value;
+
+	dupfile = remmina_file_new_empty();
+	dupfile->filename = g_strdup(remminafile->filename);
+
+	g_hash_table_iter_init(&iter, remminafile->settings);
+	while (g_hash_table_iter_next(&iter, (gpointer *)&key, (gpointer *)&value))
+		remmina_file_set_string(dupfile, key, value);
+
+	remmina_file_set_statefile(dupfile);
+	remmina_file_touch(dupfile);
+	return dupfile;
+}
+
+const gchar *
+remmina_file_get_icon_name(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolPlugin *plugin;
+
+	plugin = (RemminaProtocolPlugin *)remmina_plugin_manager_get_plugin(REMMINA_PLUGIN_TYPE_PROTOCOL,
+									    remmina_file_get_string(remminafile, "protocol"));
+	if (!plugin)
+		return g_strconcat(REMMINA_APP_ID, "-symbolic", NULL);
+
+	return remmina_file_get_int(remminafile, "ssh_tunnel_enabled", FALSE) ? plugin->icon_name_ssh : plugin->icon_name;
+}
+
+RemminaFile *
+remmina_file_dup_temp_protocol(RemminaFile *remminafile, const gchar *new_protocol)
+{
+	TRACE_CALL(__func__);
+	RemminaFile *tmp;
+
+	tmp = remmina_file_dup(remminafile);
+	g_free(tmp->filename);
+	tmp->filename = NULL;
+	remmina_file_set_string(tmp, "protocol", new_protocol);
+	return tmp;
+}
+
+void remmina_file_delete(const gchar *filename)
+{
+	TRACE_CALL(__func__);
+	RemminaFile *remminafile;
+
+	remminafile = remmina_file_load(filename);
+	if (remminafile) {
+		remmina_file_unsave_passwords(remminafile);
+		remmina_file_free(remminafile);
+	}
+	g_unlink(filename);
+}
+
+const gchar *
+remmina_file_get_state(RemminaFile *remminafile, const gchar *setting)
+{
+	TRACE_CALL(__func__);
+	g_autoptr(GError) error = NULL;
+	g_autoptr(GKeyFile) key_file = g_key_file_new();
+
+	if (!g_key_file_load_from_file(key_file, remminafile->statefile, G_KEY_FILE_NONE, &error)) {
+		if (!g_error_matches(error, G_FILE_ERROR, G_FILE_ERROR_NOENT))
+			REMMINA_CRITICAL("Could not load the state file. %s", error->message);
+		return NULL;
+	}
+
+	g_autofree gchar *val = g_key_file_get_string(key_file, KEYFILE_GROUP_STATE, setting, &error);
+
+	if (val == NULL &&
+	    !g_error_matches(error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND)) {
+		REMMINA_CRITICAL("Could not find  \"%s\" in the \"%s\" state file. %s",
+				 setting, remminafile->statefile, error->message);
+		return NULL;
+	}
+	return val && val[0] ? val : NULL;
+}
+
+void remmina_file_state_last_success(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+
+	g_autoptr(GKeyFile) key_statefile = g_key_file_new();
+	g_autoptr(GKeyFile) key_remminafile = g_key_file_new();
+	GError *error = NULL;
+
+	const gchar *date = NULL;
+	GDateTime *d = g_date_time_new_now_utc();
+
+	date = g_strdup_printf("%d%02d%02d",
+			       g_date_time_get_year(d),
+			       g_date_time_get_month(d),
+			       g_date_time_get_day_of_month(d));
+
+	g_key_file_set_string(key_statefile, KEYFILE_GROUP_STATE, "last_success", date);
+
+	REMMINA_DEBUG("State file %s.", remminafile->statefile);
+	if (!g_key_file_save_to_file(key_statefile, remminafile->statefile, &error)) {
+		REMMINA_CRITICAL("Could not save the key file. %s", error->message);
+		g_error_free(error);
+		error = NULL;
+		return;
+	}
+	/* Delete old pre-1.5 keys */
+	g_key_file_remove_key(key_remminafile, KEYFILE_GROUP_REMMINA, "last_success", NULL);
+	REMMINA_DEBUG("Last connection made on %s.", date);
+}
+
+void remmina_file_unsave_passwords(RemminaFile *remminafile)
+{
+	/* Delete all saved secrets for this profile */
+
+	TRACE_CALL(__func__);
+	const RemminaProtocolSetting *setting_iter;
+	RemminaProtocolPlugin *protocol_plugin;
+	gchar *proto;
+
+	protocol_plugin = NULL;
+
+	remmina_file_set_string(remminafile, "password", NULL);
+
+	proto = (gchar *)g_hash_table_lookup(remminafile->settings, "protocol");
+	if (proto) {
+		protocol_plugin = (RemminaProtocolPlugin *)remmina_plugin_manager_get_plugin(REMMINA_PLUGIN_TYPE_PROTOCOL, proto);
+		if (protocol_plugin) {
+			setting_iter = protocol_plugin->basic_settings;
+			if (setting_iter) {
+				while (setting_iter->type != REMMINA_PROTOCOL_SETTING_TYPE_END) {
+					// TOO VERBOSE: g_debug("setting name: %s", setting_iter->name);
+					if (setting_iter->name == NULL)
+						g_error("Internal error: a setting name in protocol plugin %s is null. Please fix RemminaProtocolSetting struct content.", proto);
+					else
+						if (remmina_plugin_manager_is_encrypted_setting(protocol_plugin, setting_iter->name))
+							remmina_file_set_string(remminafile, remmina_plugin_manager_get_canonical_setting_name(setting_iter), NULL);
+					setting_iter++;
+				}
+			}
+			setting_iter = protocol_plugin->advanced_settings;
+			if (setting_iter) {
+				while (setting_iter->type != REMMINA_PROTOCOL_SETTING_TYPE_END) {
+					if (remmina_plugin_manager_is_encrypted_setting(protocol_plugin, setting_iter->name))
+						remmina_file_set_string(remminafile, remmina_plugin_manager_get_canonical_setting_name(setting_iter), NULL);
+					setting_iter++;
+				}
+			}
+			remmina_file_save(remminafile);
+		}
+	}
+}
+
+/**
+ * Return the string date of the last time a Remmina state file has been modified.
+ *
+ * This is used to return the modification date of a file and it’s used
+ * to return the modification date and time of a given Remmina file.
+ * If it fails it will return "Fri, 16 Oct 2009 07:04:46 GMT", that is just a date to don't
+ * return an empty string (challenge: what was happened that day at that time?).
+ * @return A date string in the form "%d/%m/%Y %H:%M:%S".
+ * @todo This should be moved to remmina_utils.c
+ */
+gchar *
+remmina_file_get_datetime(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+
+	GFile *file;
+	GFileInfo *info;
+
+	struct timeval tv;
+	struct tm *ptm;
+	char time_string[256];
+	gchar *tmps;
+
+	guint64 mtime;
+
+	if (remminafile->statefile)
+		//REMMINA_DEBUG ("remminafile->statefile: %s", remminafile->statefile);
+		file = g_file_new_for_path(remminafile->statefile);
+	else
+		file = g_file_new_for_path(remminafile->filename);
+
+	info = g_file_query_info(file,
+				 G_FILE_ATTRIBUTE_TIME_MODIFIED,
+				 G_FILE_QUERY_INFO_NONE,
+				 NULL,
+				 NULL);
+
+	g_object_unref(file);
+
+	if (info == NULL) {
+		//REMMINA_DEBUG("could not get time info");
+
+		// The BDAY "Fri, 16 Oct 2009 07:04:46 GMT"
+		mtime = 1255676686;
+		const gchar *last_success = remmina_file_get_string(remminafile, "last_success");
+		if (last_success) {
+			//REMMINA_DEBUG ("Last success is %s", last_success);
+			GDateTime *dt;
+			tmps = g_strconcat(last_success, "T00:00:00Z", NULL);
+			dt = g_date_time_new_from_iso8601(tmps, NULL);
+			g_free(tmps);
+			if (dt) {
+				//REMMINA_DEBUG("Converting last_success");
+				tmps = g_date_time_format(dt, "%s");
+				mtime = g_ascii_strtoull(tmps, NULL, 10);
+				g_free(tmps);
+				g_date_time_unref(dt);
+			} else {
+				//REMMINA_DEBUG("dt was null");
+				mtime = 191543400;
+			}
+		}
+	} else {
+		mtime = g_file_info_get_attribute_uint64(info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
+		g_object_unref(info);
+	}
+
+	tv.tv_sec = mtime;
+
+	ptm = localtime(&tv.tv_sec);
+	strftime(time_string, sizeof(time_string), "%F - %T", ptm);
+
+	gchar *modtime_string = g_locale_to_utf8(time_string, -1, NULL, NULL, NULL);
+
+	return modtime_string;
+}
+
+/**
+ * Update the atime and mtime of a given filename.
+ * Function used to update the atime and mtime of a given remmina file, partially
+ * taken from suckless sbase
+ * @see https://git.suckless.org/sbase/tree/touch.c
+ * @todo This should be moved to remmina_utils.c
+ */
+void
+remmina_file_touch(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	int fd;
+	struct stat st;
+	int r;
+
+	if ((r = stat(remminafile->statefile, &st)) < 0) {
+		if (errno != ENOENT)
+			REMMINA_DEBUG("stat %s:", remminafile->statefile);
+	} else if (!r) {
+#ifdef __APPLE__
+		times[0] = st.st_atimespec;
+		times[1] = st.st_mtimespec;
+#else
+		times[0] = st.st_atim;
+		times[1] = st.st_mtim;
+#endif
+		if (utimensat(AT_FDCWD, remminafile->statefile, times, 0) < 0)
+			REMMINA_DEBUG("utimensat %s:", remminafile->statefile);
+		return;
+	}
+
+	if ((fd = open(remminafile->statefile, O_CREAT | O_EXCL, 0644)) < 0)
+		REMMINA_DEBUG("open %s:", remminafile->statefile);
+	close(fd);
+
+	remmina_file_touch(remminafile);
+}
diff --git a/src/remmina_file.h b/src/remmina_file.h
new file mode 100644
index 0000000..9696441
--- /dev/null
+++ b/src/remmina_file.h
@@ -0,0 +1,126 @@
+/*
+ * 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 <glib-object.h>
+#include <gobject/gvaluecollector.h>
+
+#include "remmina/types.h"
+
+#pragma once
+
+G_BEGIN_DECLS
+
+struct _RemminaFile {
+	gchar *		filename;
+	// @todo Add a cache file with content remminafile->filename = last_success
+	gchar *		statefile;
+	GHashTable *	settings;
+	GHashTable *	states;
+	GHashTable *	spsettings;
+	gboolean	prevent_saving;
+};
+
+/**
+ * used in remmina_ssh.c and remmina_ssh_plugin.c
+ *
+ * #define SSH_AUTH_METHOD_UNKNOWN     0x0000u
+ * #define SSH_AUTH_METHOD_NONE        0x0001u
+ * #define SSH_AUTH_METHOD_PASSWORD    0x0002u
+ * #define SSH_AUTH_METHOD_PUBLICKEY   0x0004u
+ * #define SSH_AUTH_METHOD_HOSTBASED   0x0008u
+ * #define SSH_AUTH_METHOD_INTERACTIVE 0x0010u
+ * #define SSH_AUTH_METHOD_GSSAPI_MIC  0x0020u
+ */
+enum {
+	SSH_AUTH_PASSWORD,
+	SSH_AUTH_PUBLICKEY,
+	SSH_AUTH_AGENT,
+	SSH_AUTH_AUTO_PUBLICKEY,
+	SSH_AUTH_GSSAPI,
+	SSH_AUTH_KBDINTERACTIVE
+};
+
+
+#define TOOLBAR_OPACITY_LEVEL 8
+#define TOOLBAR_OPACITY_MIN 0.2
+
+/* Create a empty .remmina file */
+RemminaFile *remmina_file_new(void);
+RemminaFile *remmina_file_copy(const gchar *filename);
+void remmina_file_generate_filename(RemminaFile *remminafile);
+void remmina_file_set_filename(RemminaFile *remminafile, const gchar *filename);
+void remmina_file_set_statefile(RemminaFile *remminafile);
+void remmina_file_state_last_success(RemminaFile *remminafile);
+const gchar *remmina_file_get_filename(RemminaFile *remminafile);
+const gchar *remmina_file_get_statefile(RemminaFile *remminafile);
+/* Load a new .remmina file and return the allocated RemminaFile object */
+RemminaFile *remmina_file_load(const gchar *filename);
+/* Settings get/set functions */
+void remmina_file_set_string(RemminaFile *remminafile, const gchar *setting, const gchar *value);
+const gchar *remmina_file_get_string(RemminaFile *remminafile, const gchar *setting);
+gchar *remmina_file_get_secret(RemminaFile *remminafile, const gchar *setting);
+gchar *remmina_file_format_properties(RemminaFile *remminafile, const gchar *setting);
+void remmina_file_set_int(RemminaFile *remminafile, const gchar *setting, gint value);
+gint remmina_file_get_int(RemminaFile *remminafile, const gchar *setting, gint default_value);
+gdouble remmina_file_get_double(RemminaFile *remminafile, const gchar *setting, gdouble default_value);
+void remmina_file_store_secret_plugin_password(RemminaFile *remminafile, const gchar *key, const gchar *value);
+gboolean remmina_file_remove_key(RemminaFile *remminafile, const gchar *setting);
+void remmina_file_set_state(RemminaFile *remminafile, const gchar *setting, const gchar *value);
+const gchar *remmina_file_get_state(RemminaFile *remminafile, const gchar *setting);
+void remmina_file_set_state_int(RemminaFile *remminafile, const gchar *setting, gint value);
+gint remmina_file_get_state_int(RemminaFile *remminafile, const gchar *setting, gint default_value);
+gdouble remmina_file_get_state_double(RemminaFile *remminafile, const gchar *setting, gdouble default_value);
+/* Create or overwrite the .remmina file */
+void remmina_file_save(RemminaFile *remminafile);
+/* Free the RemminaFile object */
+void remmina_file_free(RemminaFile *remminafile);
+/* Duplicate a RemminaFile object */
+RemminaFile *remmina_file_dup(RemminaFile *remminafile);
+/* Get the protocol icon name */
+const gchar *remmina_file_get_icon_name(RemminaFile *remminafile);
+/* Duplicate a temporary RemminaFile and change the protocol */
+RemminaFile *remmina_file_dup_temp_protocol(RemminaFile *remminafile, const gchar *new_protocol);
+/* Delete a .remmina file */
+void remmina_file_delete(const gchar *filename);
+/* Delete a "password" field and save into .remmina file */
+void remmina_file_unsave_passwords(RemminaFile *remminafile);
+/* Function used to update the atime and mtime of a given remmina file, partially
+ * taken from suckless sbase */
+gchar *remmina_file_get_datetime(RemminaFile *remminafile);
+/* Function used to update the atime and mtime of a given remmina file */
+void remmina_file_touch(RemminaFile *remminafile);
+
+G_END_DECLS
diff --git a/src/remmina_file_editor.c b/src/remmina_file_editor.c
new file mode 100644
index 0000000..feca2bc
--- /dev/null
+++ b/src/remmina_file_editor.c
@@ -0,0 +1,2204 @@
+/*
+ * 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
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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 <ctype.h>
+#include "config.h"
+#ifdef HAVE_LIBAVAHI_UI
+#include <avahi-ui/avahi-ui.h>
+#endif
+#include "remmina_public.h"
+#include "remmina_pref.h"
+#include "rcw.h"
+#include "remmina/remmina_trace_calls.h"
+#include "remmina_file.h"
+#include "remmina_file_editor.h"
+#include "remmina_file_manager.h"
+#include "remmina_icon.h"
+#include "remmina_main.h"
+#include "remmina_plugin_manager.h"
+#include "remmina_pref_dialog.h"
+#include "remmina_ssh.h"
+#include "remmina_string_list.h"
+#include "remmina_unlock.h"
+#include "remmina_widget_pool.h"
+
+G_DEFINE_TYPE(RemminaFileEditor, remmina_file_editor, GTK_TYPE_DIALOG)
+
+static const gchar *server_tips = N_("<big>"
+				     "Supported formats\n"
+				     "• server\n"
+				     "• server[:port]\n"
+				     "VNC additional formats\n"
+				     "• ID:repeater ID number\n"
+				     "• unix:///path/socket.sock"
+				     "</big>");
+
+static const gchar *cmd_tips = N_("<big>"
+				  "• command in PATH args %h\n"
+				  "• /path/to/foo -options %h %u\n"
+				  "• %h is substituted with the server name\n"
+				  "• %t is substituted with the SSH server name\n"
+				  "• %u is substituted with the username\n"
+				  "• %U is substituted with the SSH username\n"
+				  "• %p is substituted with Remmina profile name\n"
+				  "• %g is substituted with Remmina profile group name\n"
+				  "• %d is substituted with local date and time in ISO 8601 format\n"
+				  "Do not run in background if you want the command to be executed before connecting.\n"
+				  "</big>");
+
+#ifdef HAVE_LIBSSH
+static const gchar *server_tips2 = N_("<big>"
+				      "Supported formats\n"
+				      "• server\n"
+				      "• server[:port]\n"
+				      "• username@server[:port] (SSH protocol only)"
+				      "</big>");
+#endif
+
+struct _RemminaFileEditorPriv {
+	RemminaFile *		remmina_file;
+	RemminaProtocolPlugin * plugin;
+	const gchar *		avahi_service_type;
+
+	GtkWidget *		name_entry;
+	GtkWidget *		labels_entry;
+	GtkWidget *		group_combo;
+	GtkWidget *		protocol_combo;
+	GtkWidget *		save_button;
+
+	GtkWidget *		config_box;
+	GtkWidget *		config_scrollable;
+	GtkWidget *		config_viewport;
+	GtkWidget *		config_container;
+
+	GtkWidget *		server_combo;
+	GtkWidget *		resolution_iws_radio;
+	GtkWidget *		resolution_auto_radio;
+	GtkWidget *		resolution_custom_radio;
+	GtkWidget *		resolution_custom_combo;
+	GtkWidget *		keymap_combo;
+
+	GtkWidget *		assistance_toggle;
+	GtkWidget *		assistance_file;
+	GtkWidget *		assistance_password;
+	GtkWidget *		assistance_file_label;
+	GtkWidget *		assistance_password_label;
+
+	GtkWidget *		behavior_autostart_check;
+	GtkWidget *		behavior_precommand_entry;
+	GtkWidget *		behavior_postcommand_entry;
+	GtkWidget *		behavior_lock_check;
+	GtkWidget *		behavior_disconnect;
+
+	GtkWidget *		ssh_tunnel_enabled_check;
+	GtkWidget *		ssh_tunnel_loopback_check;
+	GtkWidget *		ssh_tunnel_server_default_radio;
+	GtkWidget *		ssh_tunnel_server_custom_radio;
+	GtkWidget *		ssh_tunnel_server_entry;
+	GtkWidget *		ssh_tunnel_auth_agent_radio;
+	GtkWidget *		ssh_tunnel_auth_password_radio;
+	GtkWidget *		ssh_tunnel_auth_password;
+	GtkWidget *		ssh_tunnel_passphrase;
+	GtkWidget *		ssh_tunnel_auth_publickey_radio;
+	GtkWidget *		ssh_tunnel_auth_auto_publickey_radio;
+	GtkWidget *		ssh_tunnel_auth_combo;
+	GtkWidget *		ssh_tunnel_username_entry;
+	GtkWidget *		ssh_tunnel_privatekey_chooser;
+	GtkWidget *		ssh_tunnel_certfile_chooser;
+
+	GHashTable *		setting_widgets;
+};
+
+static void remmina_file_editor_class_init(RemminaFileEditorClass *klass)
+{
+	TRACE_CALL(__func__);
+}
+
+/**
+ * @brief Shows a tooltip-like window which tells the user what they did wrong
+ * 		  to trigger the validation function of a ProtocolSetting widget.
+ *
+ * @param gfe GtkWindow gfe
+ * @param failed_widget Widget which failed validation
+ * @param err Contains error message for user
+ *
+ *
+ * Mouse click and focus-loss will delete the window. \n
+ * TODO: when Remmina Editor's content is scrollable and failed_widget is not even
+ *	 visible anymore, the window gets shown where failed_widget would be if
+ *       the Remmina Editor was big enough. \n
+ * TODO: Responsive text size and line wrap.
+ */
+static void remmina_file_editor_show_validation_error_popup(RemminaFileEditor * gfe,
+							    GtkWidget *		failed_widget,
+							    GError *		err)
+{
+	if (!err) {
+		err = NULL; // g_set_error doesn't like overwriting errors.
+		g_set_error(&err, 1, 1, _("Input is invalid."));
+	}
+
+	if (!gfe || !failed_widget) {
+		g_critical("(%s): Parameters RemminaFileEditor 'gfe' or "
+			   "GtkWidget* 'failed_widget' are 'NULL'!",
+			   __func__);
+		return;
+	}
+
+	gint widget_width = gtk_widget_get_allocated_width(failed_widget);
+	gint widget_height = gtk_widget_get_allocated_height(failed_widget);
+
+	GtkWidget *err_label = gtk_label_new("");
+	GtkWidget *alert_icon = NULL;
+	GtkWindow *err_window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
+	GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+	GdkWindow *window = gtk_widget_get_window(failed_widget);
+
+	GtkAllocation allocation;
+	gint failed_widget_x, failed_widget_y;
+
+	gchar *markup = g_strdup_printf("<span size='large'>%s</span>", err->message);
+
+	// Setup err_window
+	gtk_window_set_decorated(err_window, FALSE);
+	gtk_window_set_type_hint(err_window, GDK_WINDOW_TYPE_HINT_TOOLTIP);
+	gtk_window_set_default_size(err_window, widget_width, widget_height);
+	gtk_window_set_title(err_window, "Error");
+	gtk_window_set_resizable(err_window, TRUE);
+
+	// Move err_window under failed_widget
+	gtk_window_set_attached_to(err_window, failed_widget);
+	gtk_window_set_transient_for(err_window, GTK_WINDOW(gfe));
+	gdk_window_get_origin(GDK_WINDOW(window), &failed_widget_x, &failed_widget_y);
+	gtk_widget_get_allocation(failed_widget, &allocation);
+	failed_widget_x += allocation.x;
+	failed_widget_y += allocation.y + allocation.height;
+	gtk_window_move(err_window, failed_widget_x, failed_widget_y);
+
+	// Setup label
+	gtk_label_set_selectable(GTK_LABEL(err_label), FALSE);
+	gtk_label_set_max_width_chars(GTK_LABEL(err_label), 1);
+	gtk_widget_set_hexpand(GTK_WIDGET(err_label), TRUE);
+	gtk_widget_set_vexpand(GTK_WIDGET(err_label), TRUE);
+	gtk_label_set_ellipsize(GTK_LABEL(err_label), PANGO_ELLIPSIZE_END);
+	gtk_label_set_line_wrap(GTK_LABEL(err_label), TRUE);
+	gtk_label_set_line_wrap_mode(GTK_LABEL(err_label), PANGO_WRAP_WORD_CHAR);
+	gtk_label_set_markup(GTK_LABEL(err_label), markup);
+
+	alert_icon = gtk_image_new_from_icon_name("dialog-warning-symbolic",
+						  GTK_ICON_SIZE_DND);
+
+	// Fill icon and label into a box.
+	gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(alert_icon), FALSE, FALSE, 0);
+	gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(err_label), TRUE, TRUE, 5);
+
+	// Attach box to err_window
+	gtk_container_add(GTK_CONTAINER(err_window), GTK_WIDGET(box));
+
+	// Display everything.
+	gtk_widget_show_all(GTK_WIDGET(err_window));
+
+	// Mouse click and focus-loss will delete the err_window.
+	g_signal_connect(G_OBJECT(err_window), "focus-out-event",
+			 G_CALLBACK(gtk_window_close), NULL);
+	g_signal_connect(G_OBJECT(err_window), "button-press-event",
+			 G_CALLBACK(gtk_window_close), NULL);
+}
+
+#ifdef HAVE_LIBAVAHI_UI
+
+static void remmina_file_editor_browse_avahi(GtkWidget *button, RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *dialog;
+	gchar *host;
+
+	dialog = aui_service_dialog_new(_("Choose a Remote Desktop Server"),
+					GTK_WINDOW(gfe),
+					_("_Cancel"), GTK_RESPONSE_CANCEL,
+					_("_OK"), GTK_RESPONSE_ACCEPT,
+					NULL);
+
+	gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(gfe));
+	aui_service_dialog_set_resolve_service(AUI_SERVICE_DIALOG(dialog), TRUE);
+	aui_service_dialog_set_resolve_host_name(AUI_SERVICE_DIALOG(dialog), TRUE);
+	aui_service_dialog_set_browse_service_types(AUI_SERVICE_DIALOG(dialog),
+						    gfe->priv->avahi_service_type, NULL);
+
+	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
+		host = g_strdup_printf("[%s]:%i",
+				       aui_service_dialog_get_host_name(AUI_SERVICE_DIALOG(dialog)),
+				       aui_service_dialog_get_port(AUI_SERVICE_DIALOG(dialog)));
+	} else {
+		host = NULL;
+	}
+	gtk_widget_destroy(dialog);
+
+	if (host) {
+		gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(gfe->priv->server_combo))), host);
+		g_free(host);
+	}
+}
+#endif
+
+static void remmina_file_editor_on_realize(GtkWidget *widget, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	RemminaFileEditor *gfe;
+	GtkWidget *defaultwidget;
+
+	gfe = REMMINA_FILE_EDITOR(widget);
+
+	defaultwidget = gfe->priv->server_combo;
+
+	if (defaultwidget) {
+		if (GTK_IS_EDITABLE(defaultwidget))
+			gtk_editable_select_region(GTK_EDITABLE(defaultwidget), 0, -1);
+		gtk_widget_grab_focus(defaultwidget);
+	}
+}
+
+static void remmina_file_editor_destroy(GtkWidget *widget, gpointer data)
+{
+	TRACE_CALL(__func__);
+	remmina_file_free(REMMINA_FILE_EDITOR(widget)->priv->remmina_file);
+	g_hash_table_destroy(REMMINA_FILE_EDITOR(widget)->priv->setting_widgets);
+	g_free(REMMINA_FILE_EDITOR(widget)->priv);
+}
+
+static void remmina_file_editor_button_on_toggled(GtkToggleButton *togglebutton, GtkWidget *widget)
+{
+	TRACE_CALL(__func__);
+	gtk_widget_set_sensitive(widget, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(togglebutton)));
+}
+
+static void remmina_file_editor_create_notebook_container(RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+	/* Create the notebook */
+	gfe->priv->config_container = gtk_notebook_new();
+	gfe->priv->config_viewport = gtk_viewport_new(NULL, NULL);
+	gfe->priv->config_scrollable = gtk_scrolled_window_new(NULL, NULL);
+	gtk_container_set_border_width(GTK_CONTAINER(gfe->priv->config_scrollable), 2);
+	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(gfe->priv->config_scrollable),
+				       GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
+	gtk_widget_show(gfe->priv->config_scrollable);
+
+	gtk_container_add(GTK_CONTAINER(gfe->priv->config_viewport), gfe->priv->config_container);
+	gtk_container_set_border_width(GTK_CONTAINER(gfe->priv->config_viewport), 2);
+	gtk_widget_show(gfe->priv->config_viewport);
+	gtk_container_add(GTK_CONTAINER(gfe->priv->config_scrollable), gfe->priv->config_viewport);
+	gtk_container_set_border_width(GTK_CONTAINER(gfe->priv->config_container), 2);
+	gtk_widget_show(gfe->priv->config_container);
+
+	gtk_container_add(GTK_CONTAINER(gfe->priv->config_box), gfe->priv->config_scrollable);
+}
+
+static GtkWidget *remmina_file_editor_create_notebook_tab(RemminaFileEditor *gfe,
+							  const gchar *stock_id, const gchar *label, gint rows, gint cols)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *tablabel;
+	GtkWidget *tabbody;
+	GtkWidget *grid;
+	GtkWidget *widget;
+
+	tablabel = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+	gtk_widget_show(tablabel);
+
+	widget = gtk_image_new_from_icon_name(stock_id, GTK_ICON_SIZE_BUTTON);
+	gtk_box_pack_start(GTK_BOX(tablabel), widget, FALSE, FALSE, 0);
+	gtk_widget_show(widget);
+
+	widget = gtk_label_new(label);
+	gtk_box_pack_start(GTK_BOX(tablabel), widget, FALSE, FALSE, 0);
+	gtk_widget_show(widget);
+
+	tabbody = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+	gtk_widget_show(tabbody);
+	gtk_notebook_append_page(GTK_NOTEBOOK(gfe->priv->config_container), tabbody, tablabel);
+
+	grid = gtk_grid_new();
+	gtk_widget_show(grid);
+	gtk_grid_set_row_spacing(GTK_GRID(grid), 8);
+	gtk_grid_set_column_spacing(GTK_GRID(grid), 8);
+	gtk_container_set_border_width(GTK_CONTAINER(grid), 15);
+	gtk_box_pack_start(GTK_BOX(tabbody), grid, FALSE, FALSE, 0);
+
+	return grid;
+}
+
+
+static void remmina_file_editor_assistance_enabled_check_on_toggled(GtkToggleButton *togglebutton,
+								    RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+	gboolean enabled = TRUE;
+
+	if (gfe->priv->assistance_toggle) {
+		enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gfe->priv->assistance_toggle));
+		if (gfe->priv->assistance_file)
+			gtk_widget_set_sensitive(GTK_WIDGET(gfe->priv->assistance_file), enabled);
+		if (gfe->priv->assistance_password)
+			gtk_widget_set_sensitive(GTK_WIDGET(gfe->priv->assistance_password), enabled);
+		if (gfe->priv->assistance_file_label)
+			gtk_widget_set_sensitive(GTK_WIDGET(gfe->priv->assistance_file_label), enabled);
+		if (gfe->priv->assistance_password_label)
+			gtk_widget_set_sensitive(GTK_WIDGET(gfe->priv->assistance_password_label), enabled);
+	}
+}
+
+#ifdef HAVE_LIBSSH
+
+static void remmina_file_editor_ssh_tunnel_server_custom_radio_on_toggled(GtkToggleButton *togglebutton, RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+	gtk_widget_set_sensitive(GTK_WIDGET(gfe->priv->ssh_tunnel_server_entry),
+				 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gfe->priv->ssh_tunnel_enabled_check)) &&
+				 (gfe->priv->ssh_tunnel_server_custom_radio == NULL ||
+				  gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gfe->priv->ssh_tunnel_server_custom_radio))));
+}
+
+
+static void remmina_file_editor_ssh_tunnel_enabled_check_on_toggled(GtkToggleButton *togglebutton,
+								    RemminaFileEditor *gfe, RemminaProtocolSSHSetting ssh_setting)
+{
+	TRACE_CALL(__func__);
+	RemminaFileEditorPriv *priv = gfe->priv;
+	gboolean enabled = TRUE;
+	gchar *p;
+	const gchar *cp;
+	const gchar *s = NULL;
+
+	if (gfe->priv->ssh_tunnel_enabled_check) {
+		enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gfe->priv->ssh_tunnel_enabled_check));
+		if (gfe->priv->ssh_tunnel_loopback_check)
+			gtk_widget_set_sensitive(GTK_WIDGET(gfe->priv->ssh_tunnel_loopback_check), enabled);
+		if (gfe->priv->ssh_tunnel_server_default_radio)
+			gtk_widget_set_sensitive(GTK_WIDGET(gfe->priv->ssh_tunnel_server_default_radio), enabled);
+		if (gfe->priv->ssh_tunnel_server_custom_radio)
+			gtk_widget_set_sensitive(GTK_WIDGET(gfe->priv->ssh_tunnel_server_custom_radio), enabled);
+		remmina_file_editor_ssh_tunnel_server_custom_radio_on_toggled(NULL, gfe);
+		p = remmina_public_combo_get_active_text(GTK_COMBO_BOX(priv->protocol_combo));
+		// if (!(g_strcmp0(p, "SFTP") == 0 || g_strcmp0(p, "SSH") == 0)) {
+		gtk_widget_set_sensitive(GTK_WIDGET(gfe->priv->ssh_tunnel_username_entry), enabled);
+		gtk_widget_set_sensitive(GTK_WIDGET(gfe->priv->ssh_tunnel_auth_password), enabled);
+		gtk_widget_set_sensitive(GTK_WIDGET(gfe->priv->ssh_tunnel_auth_combo), enabled);
+		//}
+		g_free(p);
+	}
+	// remmina_file_editor_ssh_tunnel_auth_publickey_radio_on_toggled(NULL, gfe);
+	s = remmina_file_get_string(gfe->priv->remmina_file, "ssh_tunnel_privatekey");
+	if (s)
+		gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(gfe->priv->ssh_tunnel_privatekey_chooser), s);
+	s = remmina_file_get_string(gfe->priv->remmina_file, "ssh_tunnel_certfile");
+	if (s)
+		gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(gfe->priv->ssh_tunnel_certfile_chooser), s);
+
+	if (gfe->priv->ssh_tunnel_username_entry)
+		if (enabled && gtk_entry_get_text(GTK_ENTRY(gfe->priv->ssh_tunnel_username_entry))[0] == '\0') {
+			cp = remmina_file_get_string(priv->remmina_file, "ssh_tunnel_username");
+			gtk_entry_set_text(GTK_ENTRY(gfe->priv->ssh_tunnel_username_entry), cp ? cp : "");
+		}
+
+	if (gfe->priv->ssh_tunnel_auth_password) {
+		if (enabled && gtk_entry_get_text(GTK_ENTRY(gfe->priv->ssh_tunnel_auth_password))[0] == '\0') {
+			cp = remmina_file_get_string(priv->remmina_file, "ssh_tunnel_password");
+			gtk_entry_set_text(GTK_ENTRY(gfe->priv->ssh_tunnel_auth_password), cp ? cp : "");
+		}
+	}
+	if (gfe->priv->ssh_tunnel_passphrase) {
+		if (enabled && gtk_entry_get_text(GTK_ENTRY(gfe->priv->ssh_tunnel_passphrase))[0] == '\0') {
+			cp = remmina_file_get_string(priv->remmina_file, "ssh_tunnel_passphrase");
+			gtk_entry_set_text(GTK_ENTRY(gfe->priv->ssh_tunnel_passphrase), cp ? cp : "");
+		}
+	}
+}
+
+#endif
+
+static void remmina_file_editor_create_server(RemminaFileEditor *gfe, const RemminaProtocolSetting *setting, GtkWidget *grid,
+					      gint row)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolPlugin *plugin = gfe->priv->plugin;
+	GtkWidget *widget;
+#ifdef HAVE_LIBAVAHI_UI
+	GtkWidget *hbox;
+#endif
+	gchar *s;
+
+	widget = gtk_label_new(_("Server"));
+	gtk_widget_show(widget);
+	gtk_widget_set_valign(widget, GTK_ALIGN_START);
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, row, 1, row + 1);
+
+	s = remmina_pref_get_recent(plugin->name);
+	widget = remmina_public_create_combo_entry(s, remmina_file_get_string(gfe->priv->remmina_file, "server"), TRUE);
+	gtk_widget_set_hexpand(widget, TRUE);
+	gtk_widget_show(widget);
+	gtk_widget_set_tooltip_markup(widget, _(server_tips));
+	gtk_entry_set_activates_default(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(widget))), TRUE);
+	gfe->priv->server_combo = widget;
+	g_free(s);
+
+#ifdef HAVE_LIBAVAHI_UI
+	if (setting->opt1) {
+		gfe->priv->avahi_service_type = (const gchar *)setting->opt1;
+
+		hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+		gtk_widget_show(hbox);
+		gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
+
+		widget = gtk_button_new_with_label("…");
+		s = g_strdup_printf(_("Browse the network to find a %s server"), plugin->name);
+		gtk_widget_set_tooltip_text(widget, s);
+		g_free(s);
+		gtk_widget_show(widget);
+		gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
+		g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_file_editor_browse_avahi), gfe);
+
+		gtk_grid_attach(GTK_GRID(grid), hbox, 1, row, 1, 1);
+	} else
+#endif
+	{
+		gtk_grid_attach(GTK_GRID(grid), widget, 1, row, 1, 1);
+	}
+}
+
+
+static GtkWidget *remmina_file_editor_create_password(RemminaFileEditor *gfe, GtkWidget *grid, gint row, gint col, const gchar *label, const gchar *value, gchar *setting_name)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget;
+
+	widget = gtk_label_new(label);
+	gtk_widget_show(widget);
+#if GTK_CHECK_VERSION(3, 12, 0)
+	gtk_widget_set_margin_end(widget, 40);
+#else
+	gtk_widget_set_margin_right(widget, 40);
+#endif
+	gtk_widget_set_valign(widget, GTK_ALIGN_START);
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, row, 1, 1);
+
+	widget = gtk_entry_new();
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, 1, row, 1, 1);
+	gtk_entry_set_max_length(GTK_ENTRY(widget), 0);
+	gtk_entry_set_visibility(GTK_ENTRY(widget), FALSE);
+	gtk_widget_set_hexpand(widget, TRUE);
+	gtk_entry_set_activates_default(GTK_ENTRY(widget), TRUE);
+	if (setting_name)
+		gtk_widget_set_name(widget, setting_name);
+
+	if (value)
+		gtk_entry_set_text(GTK_ENTRY(widget), value);
+	/* Password view Toogle*/
+	if (setting_name) {
+		gtk_entry_set_icon_from_icon_name(GTK_ENTRY(widget), GTK_ENTRY_ICON_SECONDARY, "org.remmina.Remmina-password-reveal-symbolic");
+		gtk_entry_set_icon_activatable(GTK_ENTRY(widget), GTK_ENTRY_ICON_SECONDARY, TRUE);
+		g_signal_connect(widget, "icon-press", G_CALLBACK(remmina_main_toggle_password_view), NULL);
+	}
+	return widget;
+}
+
+static void remmina_file_editor_update_resolution(GtkWidget *widget, RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+	gchar *res_str;
+	res_str = g_strdup_printf("%dx%d",
+				  remmina_file_get_int(gfe->priv->remmina_file, "resolution_width", 0),
+				  remmina_file_get_int(gfe->priv->remmina_file, "resolution_height", 0));
+	remmina_public_load_combo_text_d(gfe->priv->resolution_custom_combo, remmina_pref.resolutions,
+					 res_str, NULL);
+	g_free(res_str);
+}
+
+static void remmina_file_editor_browse_resolution(GtkWidget *button, RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+
+	GtkDialog *dialog = remmina_string_list_new(FALSE, NULL);
+	remmina_string_list_set_validation_func(remmina_public_resolution_validation_func);
+	remmina_string_list_set_text(remmina_pref.resolutions, TRUE);
+	remmina_string_list_set_titles(_("Resolutions"), _("Configure the available resolutions"));
+	gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(gfe));
+	gtk_dialog_run(dialog);
+	g_free(remmina_pref.resolutions);
+	remmina_pref.resolutions = remmina_string_list_get_text();
+	g_signal_connect(G_OBJECT(dialog), "destroy", G_CALLBACK(remmina_file_editor_update_resolution), gfe);
+	gtk_widget_destroy(GTK_WIDGET(dialog));
+}
+
+static void remmina_file_editor_create_resolution(RemminaFileEditor *gfe, const RemminaProtocolSetting *setting,
+						  GtkWidget *grid, gint row)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget;
+	GtkWidget *hbox;
+	int resolution_w, resolution_h;
+	gchar *res_str;
+	RemminaProtocolWidgetResolutionMode res_mode;
+
+	res_mode = remmina_file_get_int(gfe->priv->remmina_file, "resolution_mode", RES_INVALID);
+	resolution_w = remmina_file_get_int(gfe->priv->remmina_file, "resolution_width", -1);
+	resolution_h = remmina_file_get_int(gfe->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 (resolution_w <= 0 || resolution_h <= 0)
+			res_mode = RES_USE_INITIAL_WINDOW_SIZE;
+		else
+			res_mode = RES_USE_CUSTOM;
+	}
+	if (res_mode == RES_USE_CUSTOM)
+		res_str = g_strdup_printf("%dx%d", resolution_w, resolution_h);
+	else
+		res_str = NULL;
+
+	widget = gtk_label_new(_("Resolution"));
+	gtk_widget_show(widget);
+	gtk_widget_set_valign(widget, GTK_ALIGN_START);
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, row, 1, 1);
+
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+	widget = gtk_radio_button_new_with_label(NULL, _("Use initial window size"));
+	gtk_widget_show(widget);
+	gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
+	gfe->priv->resolution_iws_radio = widget;
+	widget = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(gfe->priv->resolution_iws_radio), _("Use client resolution"));
+	gtk_widget_show(widget);
+	gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
+	gfe->priv->resolution_auto_radio = widget;
+	gtk_grid_attach(GTK_GRID(grid), hbox, 1, row, 1, 1);
+	gtk_widget_show(hbox);
+
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+	gtk_widget_show(hbox);
+	gtk_grid_attach(GTK_GRID(grid), hbox, 1, row + 1, 1, 1);
+
+	widget = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(gfe->priv->resolution_iws_radio), _("Custom"));
+	gtk_widget_show(widget);
+	gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
+	gfe->priv->resolution_custom_radio = widget;
+
+	widget = remmina_public_create_combo_text_d(remmina_pref.resolutions, res_str, NULL);
+	gtk_widget_show(widget);
+	gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
+	gfe->priv->resolution_custom_combo = widget;
+
+	widget = gtk_button_new_with_label("…");
+	gtk_widget_show(widget);
+	gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
+	g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_file_editor_browse_resolution), gfe);
+
+	g_signal_connect(G_OBJECT(gfe->priv->resolution_custom_radio), "toggled",
+			 G_CALLBACK(remmina_file_editor_button_on_toggled), gfe->priv->resolution_custom_combo);
+
+	if (res_mode == RES_USE_CUSTOM)
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gfe->priv->resolution_custom_radio), TRUE);
+	else if (res_mode == RES_USE_CLIENT)
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gfe->priv->resolution_auto_radio), TRUE);
+	else
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gfe->priv->resolution_iws_radio), TRUE);
+
+	gtk_widget_set_sensitive(gfe->priv->resolution_custom_combo, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gfe->priv->resolution_custom_radio)));
+
+	g_free(res_str);
+}
+
+
+static void remmina_file_editor_create_assistance(RemminaFileEditor *gfe, const RemminaProtocolSetting *setting,
+						  GtkWidget *grid, gint row)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget;
+
+
+
+	widget = gtk_toggle_button_new_with_label(_("Assistance Mode"));
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, row, 1, 1);
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), remmina_file_get_int(gfe->priv->remmina_file, "assistance_mode", 0));
+	gfe->priv->assistance_toggle = widget;
+	g_signal_connect(widget, "toggled", G_CALLBACK(remmina_file_editor_assistance_enabled_check_on_toggled), gfe);
+
+
+	widget = gtk_label_new("Assistance file");
+	gtk_widget_set_halign(widget, GTK_ALIGN_END);
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, row+1, 1, 1);
+	gfe->priv->assistance_file_label = widget;
+
+	widget = gtk_entry_new();
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	gtk_widget_show(widget);
+	
+	if (remmina_file_get_string(gfe->priv->remmina_file, "assistance_file") != NULL) {
+		gtk_entry_set_text(GTK_ENTRY(widget), remmina_file_get_string(gfe->priv->remmina_file, "assistance_file"));
+	}
+	gtk_grid_attach(GTK_GRID(grid), widget, 1, row+1, 1, 1);
+	gfe->priv->assistance_file = widget;
+
+	widget = gtk_label_new("Assistance Password");
+	gtk_widget_set_halign(widget, GTK_ALIGN_END);
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, row+2, 1, 1);
+	gfe->priv->assistance_password_label = widget;
+
+	widget = gtk_entry_new();
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	gtk_widget_show(widget);
+
+	if (remmina_file_get_string(gfe->priv->remmina_file, "assistance_pass") != NULL) {
+		gtk_entry_set_text(GTK_ENTRY(widget), remmina_file_get_string(gfe->priv->remmina_file, "assistance_pass"));
+	}
+	gtk_grid_attach(GTK_GRID(grid), widget, 1, row+2, 1, 1);
+	gfe->priv->assistance_password = widget;
+
+	remmina_file_editor_assistance_enabled_check_on_toggled(NULL, gfe);
+
+}
+
+
+static GtkWidget *remmina_file_editor_create_text2(RemminaFileEditor *gfe, GtkWidget *grid,
+						   gint row, gint col, const gchar *label, const gchar *value, gint left,
+						   gint right, gchar *setting_name)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget;
+
+	widget = gtk_label_new(label);
+	gtk_widget_show(widget);
+#if GTK_CHECK_VERSION(3, 12, 0)
+	gtk_widget_set_margin_start(widget, left);
+	gtk_widget_set_margin_end(widget, right);
+#else
+	gtk_widget_set_margin_left(widget, left);
+	gtk_widget_set_margin_right(widget, right);
+#endif
+	gtk_widget_set_valign(widget, GTK_ALIGN_START);
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	gtk_grid_attach(GTK_GRID(grid), widget, col, row, 1, 1);
+
+	widget = gtk_entry_new();
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, col + 1, row, 1, 1);
+	gtk_entry_set_max_length(GTK_ENTRY(widget), 300);
+	gtk_widget_set_hexpand(widget, TRUE);
+	if (setting_name)
+		gtk_widget_set_name(widget, setting_name);
+
+	if (value)
+		gtk_entry_set_text(GTK_ENTRY(widget), value);
+
+	return widget;
+}
+
+static GtkWidget *remmina_file_editor_create_text(RemminaFileEditor *gfe, GtkWidget *grid,
+						  gint row, gint col, const gchar *label, const gchar *value,
+						  gchar *setting_name)
+{
+	TRACE_CALL(__func__);
+	return remmina_file_editor_create_text2(gfe, grid, row, col, label, value, 0, 40,
+						setting_name);
+}
+
+static GtkWidget *remmina_file_editor_create_textarea(RemminaFileEditor *gfe, GtkWidget *grid,
+						      gint row, gint col, const gchar *label, const gchar *value,
+						      gchar *setting_name)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget;
+	GtkTextView *view;
+	GtkTextBuffer *buffer;
+	GtkTextIter start;
+
+	widget = gtk_text_view_new();
+	view = GTK_TEXT_VIEW(widget);
+	gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(view), GTK_WRAP_WORD);
+	gtk_text_view_set_top_margin(GTK_TEXT_VIEW(view), 20);
+	gtk_text_view_set_bottom_margin(GTK_TEXT_VIEW(view), 20);
+	gtk_text_view_set_left_margin(GTK_TEXT_VIEW(view), 20);
+	gtk_text_view_set_right_margin(GTK_TEXT_VIEW(view), 20);
+	gtk_text_view_set_monospace(view, TRUE);
+	if (setting_name)
+		gtk_widget_set_name(widget, setting_name);
+	if (value) {
+		buffer = gtk_text_view_get_buffer(view);
+		gtk_text_buffer_set_text(buffer, value, -1);
+		gtk_text_buffer_get_start_iter(buffer, &start);
+		gtk_text_buffer_place_cursor(buffer, &start);
+	}
+	gtk_widget_show(widget);
+	gtk_widget_set_hexpand(widget, TRUE);
+	gtk_widget_set_size_request(GTK_WIDGET(view), 320, 300);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, row, 1, 1);
+	return widget;
+}
+
+static GtkWidget *remmina_file_editor_create_select(RemminaFileEditor *gfe, GtkWidget *grid,
+						    gint row, gint col, const gchar *label, const gpointer *list,
+						    const gchar *value, gchar *setting_name)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget;
+
+	widget = gtk_label_new(label);
+	gtk_widget_show(widget);
+	gtk_widget_set_valign(widget, GTK_ALIGN_START);
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	if (setting_name)
+		gtk_widget_set_name(widget, setting_name);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, row, 1, 1);
+
+	widget = remmina_public_create_combo_map(list, value, FALSE, gfe->priv->plugin->domain);
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, 1, row, 1, 1);
+
+	return widget;
+}
+
+static GtkWidget *remmina_file_editor_create_combo(RemminaFileEditor *gfe, GtkWidget *grid,
+						   gint row, gint col, const gchar *label, const gchar *list,
+						   const gchar *value, gchar *setting_name)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget;
+
+	widget = gtk_label_new(label);
+	gtk_widget_show(widget);
+	gtk_widget_set_valign(widget, GTK_ALIGN_START);
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, row, 1, 1);
+
+	widget = remmina_public_create_combo_entry(list, value, FALSE);
+	gtk_widget_show(widget);
+	gtk_widget_set_hexpand(widget, TRUE);
+	if (setting_name)
+		gtk_widget_set_name(widget, setting_name);
+	gtk_grid_attach(GTK_GRID(grid), widget, 1, row, 1, 1);
+
+	return widget;
+}
+
+static GtkWidget *remmina_file_editor_create_check(RemminaFileEditor *gfe, GtkWidget *grid,
+						   gint row, gint top, const gchar *label, gboolean value,
+						   gchar *setting_name)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget;
+	widget = gtk_check_button_new_with_label(label);
+	gtk_widget_show(widget);
+	if (setting_name)
+		gtk_widget_set_name(widget, setting_name);
+	gtk_grid_attach(GTK_GRID(grid), widget, top, row, 1, 1);
+
+	if (value)
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE);
+
+	return widget;
+}
+
+/**
+ * Create checkbox + gtk_file_chooser for open files and select folders
+ *
+ * The code is wrong, because if the checkbox is not active, the value should be set to NULL
+ * and remove it from the remmina file. The problem is that this function knows nothing about
+ * the remmina file.
+ * This should be rewritten in a more generic way
+ * Please use REMMINA_PROTOCOL_SETTING_TYPE_TEXT
+ */
+static GtkWidget *
+remmina_file_editor_create_chooser(RemminaFileEditor *gfe, GtkWidget *grid, gint row, gint col, const gchar *label,
+				   const gchar *value, gint type, gchar *setting_name)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *check;
+	GtkWidget *widget;
+	GtkWidget *hbox;
+
+	widget = gtk_label_new(label);
+	gtk_widget_show(widget);
+	gtk_widget_set_valign(widget, GTK_ALIGN_START);
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, row, 1, 1);
+
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+	gtk_widget_show(hbox);
+	gtk_grid_attach(GTK_GRID(grid), hbox, 1, row, 1, 1);
+
+	check = gtk_check_button_new();
+	gtk_widget_show(check);
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), (value && value[0] == '/'));
+	gtk_box_pack_start(GTK_BOX(hbox), check, FALSE, FALSE, 0);
+
+	widget = gtk_file_chooser_button_new(label, type);
+	if (setting_name)
+		gtk_widget_set_name(widget, setting_name);
+	gtk_widget_show(widget);
+	if (value)
+		gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(widget), value);
+	gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
+
+	g_signal_connect(G_OBJECT(check), "toggled", G_CALLBACK(remmina_file_editor_button_on_toggled), widget);
+	remmina_file_editor_button_on_toggled(GTK_TOGGLE_BUTTON(check), widget);
+
+	return widget;
+}
+
+// used to filter out invalid characters for REMMINA_PROTOCOL_SETTING_TYPE_INT
+void remmina_file_editor_int_setting_filter(GtkEditable *editable, const gchar *text,
+					    gint length, gint *position, gpointer data)
+{
+	for (int i = 0; i < length; i++) {
+		if (!isdigit(text[i]) && text[i] != '-') {
+			g_signal_stop_emission_by_name(G_OBJECT(editable), "insert-text");
+			return;
+		}
+	}
+}
+
+// used to filter out invalid characters for REMMINA_PROTOCOL_SETTING_TYPE_DOUBLE
+// '.' and ',' can't be used interchangeably! It depends on the language setting
+// of the user.
+void remmina_file_editor_double_setting_filter(GtkEditable *editable, const gchar *text,
+					       gint length, gint *position, gpointer data)
+{
+	for (int i = 0; i < length; i++) {
+		if (!isdigit(text[i]) && text[i] != '-' && text[i] != '.' && text[i] != ',') {
+			g_signal_stop_emission_by_name(G_OBJECT(editable), "insert-text");
+			return;
+		}
+	}
+}
+
+static GtkWidget *remmina_file_editor_create_int(RemminaFileEditor *gfe, GtkWidget *grid,
+						 gint row, gint col, const gchar *label, const gint value,
+						 gint left, gint right, gchar *setting_name)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget;
+
+	widget = gtk_label_new(label);
+	gtk_widget_show(widget);
+#if GTK_CHECK_VERSION(3, 12, 0)
+	gtk_widget_set_margin_start(widget, left);
+	gtk_widget_set_margin_end(widget, right);
+#else
+	gtk_widget_set_margin_left(widget, left);
+	gtk_widget_set_margin_right(widget, right);
+#endif
+	gtk_widget_set_valign(widget, GTK_ALIGN_START);
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	gtk_grid_attach(GTK_GRID(grid), widget, col, row, 1, 1);
+
+	widget = gtk_entry_new();
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, col + 1, row, 1, 1);
+	gtk_entry_set_max_length(GTK_ENTRY(widget), 300);
+	gtk_widget_set_hexpand(widget, TRUE);
+	if (setting_name)
+		gtk_widget_set_name(widget, setting_name);
+
+	// Convert int to str.
+	int length = snprintf(NULL, 0, "%d", value) + 1; // +1 '\0' byte
+	char *str = malloc(length);
+	snprintf(str, length, "%d", value);
+
+	gtk_entry_set_text(GTK_ENTRY(widget), str);
+	free(str);
+
+	g_signal_connect(G_OBJECT(widget), "insert-text",
+			 G_CALLBACK(remmina_file_editor_int_setting_filter), NULL);
+
+	return widget;
+}
+
+static GtkWidget *remmina_file_editor_create_double(RemminaFileEditor *gfe,
+						    GtkWidget *grid, gint row, gint col,
+						    const gchar *label, gdouble value, gint left,
+						    gint right, gchar *setting_name)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget;
+
+	widget = gtk_label_new(label);
+	gtk_widget_show(widget);
+#if GTK_CHECK_VERSION(3, 12, 0)
+	gtk_widget_set_margin_start(widget, left);
+	gtk_widget_set_margin_end(widget, right);
+#else
+	gtk_widget_set_margin_left(widget, left);
+	gtk_widget_set_margin_right(widget, right);
+#endif
+	gtk_widget_set_valign(widget, GTK_ALIGN_START);
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	gtk_grid_attach(GTK_GRID(grid), widget, col, row, 1, 1);
+
+	widget = gtk_entry_new();
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, col + 1, row, 1, 1);
+	gtk_entry_set_max_length(GTK_ENTRY(widget), 300);
+	gtk_widget_set_hexpand(widget, TRUE);
+	if (setting_name)
+		gtk_widget_set_name(widget, setting_name);
+
+	// Convert double to str.
+	int length = snprintf(NULL, 0, "%.8g", value) + 1; // +1 '\0' byte
+	char *str = malloc(length);
+	snprintf(str, length, "%f", value);
+
+	gtk_entry_set_text(GTK_ENTRY(widget), str);
+	free(str);
+
+	g_signal_connect(G_OBJECT(widget), "insert-text",
+			 G_CALLBACK(remmina_file_editor_double_setting_filter), NULL);
+
+	return widget;
+}
+
+
+
+static void remmina_file_editor_create_settings(RemminaFileEditor *gfe, GtkWidget *grid,
+						const RemminaProtocolSetting *settings)
+{
+	TRACE_CALL(__func__);
+	RemminaFileEditorPriv *priv = gfe->priv;
+	GtkWidget *widget;
+	gint grid_row = 0;
+	gint grid_column = 0;
+	gchar **strarr;
+	gchar *setting_name;
+	const gchar *escaped;
+
+	while (settings->type != REMMINA_PROTOCOL_SETTING_TYPE_END) {
+		setting_name = (gchar *)(remmina_plugin_manager_get_canonical_setting_name(settings));
+		switch (settings->type) {
+		case REMMINA_PROTOCOL_SETTING_TYPE_SERVER:
+			remmina_file_editor_create_server(gfe, settings, grid, grid_row);
+			break;
+
+		case REMMINA_PROTOCOL_SETTING_TYPE_PASSWORD:
+			widget = remmina_file_editor_create_password(gfe, grid, grid_row, 0,
+								     g_dgettext(priv->plugin->domain, settings->label),
+								     remmina_file_get_string(priv->remmina_file, setting_name),
+								     setting_name);
+			g_hash_table_insert(priv->setting_widgets, setting_name, widget);
+			grid_row++;
+			break;
+
+		case REMMINA_PROTOCOL_SETTING_TYPE_RESOLUTION:
+			remmina_file_editor_create_resolution(gfe, settings, grid, grid_row);
+			grid_row ++;
+			break;
+
+		case REMMINA_PROTOCOL_SETTING_TYPE_ASSISTANCE:
+			remmina_file_editor_create_assistance(gfe, settings, grid, grid_row);
+			grid_row += 3;
+			break;
+
+		case REMMINA_PROTOCOL_SETTING_TYPE_KEYMAP:
+			strarr = remmina_pref_keymap_groups();
+			priv->keymap_combo = remmina_file_editor_create_select(gfe, grid,
+									       grid_row + 1, 0,
+									       _("Keyboard mapping"), (const gpointer *)strarr,
+									       remmina_file_get_string(priv->remmina_file, "keymap"),
+									       setting_name);
+			g_strfreev(strarr);
+			grid_row++;
+			break;
+
+		case REMMINA_PROTOCOL_SETTING_TYPE_TEXT:
+			widget = remmina_file_editor_create_text(gfe, grid, grid_row, 0,
+								 g_dgettext(priv->plugin->domain, settings->label),
+								 remmina_file_get_string(priv->remmina_file, setting_name),
+								 setting_name);
+			g_hash_table_insert(priv->setting_widgets, setting_name, widget);
+			if (settings->opt2)
+				gtk_widget_set_tooltip_text(widget, _((const gchar *)settings->opt2));
+			grid_row++;
+			break;
+
+		case REMMINA_PROTOCOL_SETTING_TYPE_TEXTAREA:
+			escaped = remmina_file_get_string(priv->remmina_file, setting_name);
+			escaped = g_uri_unescape_string(escaped, NULL);
+			widget = remmina_file_editor_create_textarea(gfe, grid, grid_row, 0,
+								     g_dgettext(priv->plugin->domain, settings->label), escaped,
+								     setting_name);
+			g_hash_table_insert(priv->setting_widgets, setting_name, widget);
+			grid_row++;
+			break;
+
+		case REMMINA_PROTOCOL_SETTING_TYPE_SELECT:
+			widget = remmina_file_editor_create_select(gfe, grid, grid_row, 0,
+								   g_dgettext(priv->plugin->domain, settings->label),
+								   (const gpointer *)settings->opt1,
+								   remmina_file_get_string(priv->remmina_file, setting_name),
+								   setting_name);
+			g_hash_table_insert(priv->setting_widgets, setting_name, widget);
+			if (settings->opt2)
+				gtk_widget_set_tooltip_text(widget, _((const gchar *)settings->opt2));
+			break;
+
+		case REMMINA_PROTOCOL_SETTING_TYPE_COMBO:
+			widget = remmina_file_editor_create_combo(gfe, grid, grid_row, 0,
+								  g_dgettext(priv->plugin->domain, settings->label),
+								  (const gchar *)settings->opt1,
+								  remmina_file_get_string(priv->remmina_file, setting_name),
+								  setting_name);
+			g_hash_table_insert(priv->setting_widgets, setting_name, widget);
+			if (settings->opt2)
+				gtk_widget_set_tooltip_text(widget, _((const gchar *)settings->opt2));
+			break;
+
+		case REMMINA_PROTOCOL_SETTING_TYPE_CHECK:
+			widget = remmina_file_editor_create_check(gfe, grid, grid_row, grid_column,
+								  g_dgettext(priv->plugin->domain, settings->label),
+								  remmina_file_get_int(priv->remmina_file, setting_name, FALSE),
+								  setting_name);
+			g_hash_table_insert(priv->setting_widgets, setting_name, widget);
+			if (settings->opt2)
+				gtk_widget_set_tooltip_text(widget, _((const gchar *)settings->opt2));
+			break;
+
+		case REMMINA_PROTOCOL_SETTING_TYPE_FILE:
+			widget = remmina_file_editor_create_chooser(gfe, grid, grid_row, 0,
+								    g_dgettext(priv->plugin->domain, settings->label),
+								    remmina_file_get_string(priv->remmina_file, setting_name),
+								    GTK_FILE_CHOOSER_ACTION_OPEN, setting_name);
+			g_hash_table_insert(priv->setting_widgets, setting_name, widget);
+			if (settings->opt2)
+				gtk_widget_set_tooltip_text(widget, _((const gchar *)settings->opt2));
+			break;
+
+		case REMMINA_PROTOCOL_SETTING_TYPE_FOLDER:
+			widget = remmina_file_editor_create_chooser(gfe, grid, grid_row, 0,
+								    g_dgettext(priv->plugin->domain, settings->label),
+								    remmina_file_get_string(priv->remmina_file, setting_name),
+								    GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
+								    setting_name);
+			g_hash_table_insert(priv->setting_widgets, setting_name, widget);
+			if (settings->opt2)
+				gtk_widget_set_tooltip_text(widget, _((const gchar *)settings->opt2));
+			break;
+		case REMMINA_PROTOCOL_SETTING_TYPE_INT:
+			widget = remmina_file_editor_create_int(gfe, grid, grid_row, 0,
+								g_dgettext(priv->plugin->domain, settings->label),
+								remmina_file_get_int(priv->remmina_file, setting_name, 0),
+								0, 40, setting_name);
+			g_hash_table_insert(priv->setting_widgets, setting_name, widget);
+			if (settings->opt2)
+				gtk_widget_set_tooltip_text(widget, _((const gchar *)settings->opt2));
+			grid_row++;
+			break;
+		case REMMINA_PROTOCOL_SETTING_TYPE_DOUBLE:
+			widget = remmina_file_editor_create_double(gfe, grid, grid_row, 0,
+								   g_dgettext(priv->plugin->domain, settings->label),
+								   remmina_file_get_double(priv->remmina_file, setting_name, 0.0f),
+								   0, 40, setting_name);
+			g_hash_table_insert(priv->setting_widgets, setting_name, widget);
+			if (settings->opt2)
+				gtk_widget_set_tooltip_text(widget, _((const gchar *)settings->opt2));
+			grid_row++;
+			break;
+
+		default:
+			break;
+		}
+		/* If the setting wants compactness, move to the next column */
+		if (settings->compact)
+			grid_column++;
+		/* Add a new settings row and move to the first column
+		 * if the setting doesn’t want the compactness
+		 * or we already have two columns */
+		if (!settings->compact || grid_column > 1) {
+			grid_row++;
+			grid_column = 0;
+		}
+		settings++;
+	}
+}
+
+static void remmina_file_editor_create_behavior_tab(RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+	RemminaFileEditorPriv *priv = gfe->priv;
+	GtkWidget *grid;
+	GtkWidget *widget;
+	const gchar *cs;
+
+	/* The Behavior tab (implementation) */
+	grid = remmina_file_editor_create_notebook_tab(gfe, NULL, _("Behavior"), 20, 2);
+
+	/* Execute Command frame */
+	remmina_public_create_group(GTK_GRID(grid), _("Execute a Command"), 0, 1, 2);
+
+	/* PRE connection command */
+	cs = remmina_file_get_string(priv->remmina_file, "precommand");
+	widget = remmina_file_editor_create_text2(gfe, grid, 2, 0, _("Before connecting"), cs, 24, 26, "precommand");
+	priv->behavior_precommand_entry = widget;
+	gtk_entry_set_placeholder_text(GTK_ENTRY(widget), _("command %h %u %t %U %p %g --option"));
+	gtk_widget_set_tooltip_markup(widget, _(cmd_tips));
+
+	/* POST connection command */
+	cs = remmina_file_get_string(priv->remmina_file, "postcommand");
+	widget = remmina_file_editor_create_text2(gfe, grid, 3, 0, _("After connecting"), cs, 24, 16, "postcommand");
+	priv->behavior_postcommand_entry = widget;
+	gtk_entry_set_placeholder_text(GTK_ENTRY(widget), _("/path/to/command -opt1 arg %h %u %t -opt2 %U %p %g"));
+	gtk_widget_set_tooltip_markup(widget, _(cmd_tips));
+
+	/* Startup frame */
+	remmina_public_create_group(GTK_GRID(grid), _("Start-up"), 4, 1, 2);
+
+	/* Autostart profile option */
+	priv->behavior_autostart_check = remmina_file_editor_create_check(gfe, grid, 6, 1, _("Auto-start this profile"),
+									  remmina_file_get_int(priv->remmina_file, "enable-autostart", FALSE), "enable-autostart");
+
+	/* Startup frame */
+	remmina_public_create_group(GTK_GRID(grid), _("Connection profile security"), 8, 1, 2);
+
+	/* Autostart profile option */
+	priv->behavior_lock_check = remmina_file_editor_create_check(gfe, grid, 10, 1, _("Require password to connect or edit the profile"),
+								     remmina_file_get_int(priv->remmina_file, "profile-lock", FALSE), "profile-lock");
+
+									 /* Startup frame */
+	remmina_public_create_group(GTK_GRID(grid), _("Unexpected disconnect"), 12, 1, 2);
+
+	/* Autostart profile option */
+	priv->behavior_disconnect = remmina_file_editor_create_check(gfe, grid, 16, 1, _("Keep window from closing if not disconnected by Remmina"),
+								     remmina_file_get_int(priv->remmina_file, "disconnect-prompt", FALSE), "disconnect-prompt");
+}
+
+#ifdef HAVE_LIBSSH
+static gpointer ssh_tunnel_auth_list[] =
+{
+	"0", N_("Password"),
+	"1", N_("SSH identity file"),
+	"2", N_("SSH agent"),
+	"3", N_("Public key (automatic)"),
+	"4", N_("Kerberos (GSSAPI)"),
+	NULL
+};
+#endif
+
+static void remmina_file_editor_create_ssh_tunnel_tab(RemminaFileEditor *gfe, RemminaProtocolSSHSetting ssh_setting)
+{
+	TRACE_CALL(__func__);
+#ifdef HAVE_LIBSSH
+	RemminaFileEditorPriv *priv = gfe->priv;
+	GtkWidget *grid;
+	GtkWidget *widget;
+	const gchar *cs;
+	gchar *s;
+	gchar *p;
+	gint row = 0;
+
+	if (ssh_setting == REMMINA_PROTOCOL_SSH_SETTING_NONE)
+		return;
+
+	/* The SSH tab (implementation) */
+	grid = remmina_file_editor_create_notebook_tab(gfe, NULL,
+						       _("SSH Tunnel"), 9, 3);
+	widget = gtk_toggle_button_new_with_label(_("Enable SSH tunnel"));
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, row, 1, 1);
+	g_signal_connect(G_OBJECT(widget), "toggled",
+			 G_CALLBACK(remmina_file_editor_ssh_tunnel_enabled_check_on_toggled), gfe);
+	priv->ssh_tunnel_enabled_check = widget;
+
+	widget = gtk_check_button_new_with_label(_("Tunnel via loopback address"));
+	gtk_grid_attach(GTK_GRID(grid), widget, 1, row, 2, 1);
+	priv->ssh_tunnel_loopback_check = widget;
+
+	// 1
+	row++;
+	/* SSH Server group */
+
+	switch (ssh_setting) {
+	case REMMINA_PROTOCOL_SSH_SETTING_TUNNEL:
+		s = g_strdup_printf(_("Same server at port %i"), DEFAULT_SSH_PORT);
+		widget = gtk_radio_button_new_with_label(NULL, s);
+		g_free(s);
+		gtk_grid_attach(GTK_GRID(grid), widget, 0, row, 3, 1);
+		priv->ssh_tunnel_server_default_radio = widget;
+		// 2
+		row++;
+
+		widget = gtk_radio_button_new_with_label_from_widget(
+			GTK_RADIO_BUTTON(priv->ssh_tunnel_server_default_radio), _("Custom"));
+		gtk_grid_attach(GTK_GRID(grid), widget, 0, row, 1, 1);
+		g_signal_connect(G_OBJECT(widget), "toggled",
+				 G_CALLBACK(remmina_file_editor_ssh_tunnel_server_custom_radio_on_toggled), gfe);
+		priv->ssh_tunnel_server_custom_radio = widget;
+
+		widget = gtk_entry_new();
+		gtk_entry_set_max_length(GTK_ENTRY(widget), 100);
+		gtk_widget_set_tooltip_markup(widget, _(server_tips2));
+		gtk_grid_attach(GTK_GRID(grid), widget, 1, row, 2, 1);
+		priv->ssh_tunnel_server_entry = widget;
+		// 3
+		row++;
+		break;
+
+	case REMMINA_PROTOCOL_SSH_SETTING_REVERSE_TUNNEL:
+		priv->ssh_tunnel_server_default_radio = NULL;
+		priv->ssh_tunnel_server_custom_radio = NULL;
+
+		priv->ssh_tunnel_server_entry = remmina_file_editor_create_text(gfe, grid, 1, 0,
+										_("Server"), NULL, "ssh_reverse_tunnel_server");
+		gtk_widget_set_tooltip_markup(priv->ssh_tunnel_server_entry, _(server_tips));
+		// 2
+		row++;
+		break;
+	case REMMINA_PROTOCOL_SSH_SETTING_SSH:
+	case REMMINA_PROTOCOL_SSH_SETTING_SFTP:
+		priv->ssh_tunnel_server_default_radio = NULL;
+		priv->ssh_tunnel_server_custom_radio = NULL;
+		priv->ssh_tunnel_server_entry = NULL;
+
+		break;
+
+	default:
+		break;
+	}
+
+	/* This is not used? */
+	p = remmina_public_combo_get_active_text(GTK_COMBO_BOX(priv->protocol_combo));
+	if (ssh_setting == REMMINA_PROTOCOL_SSH_SETTING_SFTP) {
+		widget = remmina_file_editor_create_text(gfe, grid, row, 1,
+							 _("Start-up path"), NULL, "start-up-path");
+		cs = remmina_file_get_string(priv->remmina_file, "execpath");
+		gtk_entry_set_text(GTK_ENTRY(widget), cs ? cs : "");
+		g_hash_table_insert(priv->setting_widgets, "execpath", widget);
+		// 2
+		row++;
+	}
+
+	/* SSH Authentication frame */
+	remmina_public_create_group(GTK_GRID(grid), _("SSH Authentication"), row, 6, 1);
+	// 5
+	row += 2;
+
+	priv->ssh_tunnel_auth_combo = remmina_file_editor_create_select(gfe, grid, row, 0,
+									_("Authentication type"),
+									(const gpointer *)ssh_tunnel_auth_list,
+									remmina_file_get_string(priv->remmina_file, "ssh_tunnel_auth"), "ssh_tunnel_auth");
+	row++;
+
+	if (ssh_setting == REMMINA_PROTOCOL_SSH_SETTING_TUNNEL ||
+	    ssh_setting == REMMINA_PROTOCOL_SSH_SETTING_REVERSE_TUNNEL) {
+		priv->ssh_tunnel_username_entry =
+			remmina_file_editor_create_text(gfe, grid, row, 0,
+							_("Username"), NULL, "ssh_tunnel_username");
+		// 5
+		row++;
+	}
+
+	widget = remmina_file_editor_create_password(gfe, grid, row, 0,
+						     _("Password"),
+						     remmina_file_get_string(priv->remmina_file, "ssh_tunnel_password"),
+						     "ssh_tunnel_password");
+	priv->ssh_tunnel_auth_password = widget;
+	row++;
+
+	priv->ssh_tunnel_privatekey_chooser = remmina_file_editor_create_chooser(gfe, grid, row, 0,
+										 _("SSH private key file"),
+										 remmina_file_get_string(priv->remmina_file, "ssh_tunnel_privatekey"),
+										 GTK_FILE_CHOOSER_ACTION_OPEN, "ssh_tunnel_privatekey");
+	row++;
+
+	priv->ssh_tunnel_certfile_chooser = remmina_file_editor_create_chooser(gfe, grid, row, 0,
+									       _("SSH certificate file"),
+									       remmina_file_get_string(priv->remmina_file, "ssh_tunnel_certfile"),
+									       GTK_FILE_CHOOSER_ACTION_OPEN, "ssh_tunnel_certfile");
+	row++;
+
+	widget = gtk_label_new(_("Password to unlock private key"));
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, row, 1, 1);
+	widget = gtk_entry_new();
+	gtk_grid_attach(GTK_GRID(grid), widget, 1, row, 2, 1);
+	gtk_entry_set_max_length(GTK_ENTRY(widget), 300);
+	gtk_entry_set_visibility(GTK_ENTRY(widget), FALSE);
+	gtk_widget_set_hexpand(widget, TRUE);
+	priv->ssh_tunnel_passphrase = widget;
+	row++;
+
+	/* Set the values */
+	cs = remmina_file_get_string(priv->remmina_file, "ssh_tunnel_server");
+	if (ssh_setting == REMMINA_PROTOCOL_SSH_SETTING_TUNNEL) {
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->ssh_tunnel_enabled_check),
+					     remmina_file_get_int(priv->remmina_file, "ssh_tunnel_enabled", FALSE));
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->ssh_tunnel_loopback_check),
+					     remmina_file_get_int(priv->remmina_file, "ssh_tunnel_loopback", FALSE));
+
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cs ? priv->ssh_tunnel_server_custom_radio : priv->ssh_tunnel_server_default_radio), TRUE);
+		gtk_entry_set_text(GTK_ENTRY(priv->ssh_tunnel_server_entry),
+				   cs ? cs : "");
+	} else if (ssh_setting == REMMINA_PROTOCOL_SSH_SETTING_REVERSE_TUNNEL) {
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->ssh_tunnel_enabled_check),
+					     remmina_file_get_int(priv->remmina_file, "ssh_tunnel_enabled", FALSE));
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->ssh_tunnel_loopback_check),
+					     remmina_file_get_int(priv->remmina_file, "ssh_tunnel_loopback", FALSE));
+		gtk_entry_set_text(GTK_ENTRY(priv->ssh_tunnel_server_entry),
+				   cs ? cs : "");
+	}
+
+	remmina_file_editor_ssh_tunnel_enabled_check_on_toggled(NULL, gfe, ssh_setting);
+	gtk_widget_show_all(grid);
+	g_free(p);
+#endif
+}
+
+static void remmina_file_editor_create_all_settings(RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+	RemminaFileEditorPriv *priv = gfe->priv;
+	GtkWidget *grid;
+
+	static const RemminaProtocolSetting notes_settings[] =
+	{
+		{ REMMINA_PROTOCOL_SETTING_TYPE_TEXTAREA, "notes_text", NULL, FALSE, NULL, NULL },
+		{ REMMINA_PROTOCOL_SETTING_TYPE_END,	  NULL,		NULL, FALSE, NULL, NULL }
+	};
+
+	remmina_file_editor_create_notebook_container(gfe);
+
+	/* The Basic tab */
+	if (priv->plugin->basic_settings) {
+		grid = remmina_file_editor_create_notebook_tab(gfe, NULL, _("Basic"), 20, 2);
+		remmina_file_editor_create_settings(gfe, grid, priv->plugin->basic_settings);
+	}
+
+	/* The Advanced tab */
+	if (priv->plugin->advanced_settings) {
+		grid = remmina_file_editor_create_notebook_tab(gfe, NULL, _("Advanced"), 20, 2);
+		remmina_file_editor_create_settings(gfe, grid, priv->plugin->advanced_settings);
+	}
+
+	/* The Behavior tab */
+	remmina_file_editor_create_behavior_tab(gfe);
+
+	/* The SSH tab */
+	remmina_file_editor_create_ssh_tunnel_tab(gfe, priv->plugin->ssh_setting);
+
+	/* Notes tab */
+	grid = remmina_file_editor_create_notebook_tab(gfe, NULL, _("Notes"), 1, 1);
+	remmina_file_editor_create_settings(gfe, grid, notes_settings);
+}
+
+static void remmina_file_editor_protocol_combo_on_changed(GtkComboBox *combo, RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+	RemminaFileEditorPriv *priv = gfe->priv;
+	gchar *protocol;
+
+	if (priv->config_container) {
+		gtk_widget_destroy(priv->config_container);
+		priv->config_container = NULL;
+		gtk_widget_destroy(priv->config_viewport);
+		priv->config_viewport = NULL;
+		gtk_widget_destroy(priv->config_scrollable);
+		priv->config_scrollable = NULL;
+	}
+
+	priv->server_combo = NULL;
+	priv->resolution_iws_radio = NULL;
+	priv->resolution_auto_radio = NULL;
+	priv->resolution_custom_radio = NULL;
+	priv->resolution_custom_combo = NULL;
+	priv->keymap_combo = NULL;
+
+	priv->ssh_tunnel_enabled_check = NULL;
+	priv->ssh_tunnel_loopback_check = NULL;
+	priv->ssh_tunnel_server_default_radio = NULL;
+	priv->ssh_tunnel_server_custom_radio = NULL;
+	priv->ssh_tunnel_server_entry = NULL;
+	priv->ssh_tunnel_username_entry = NULL;
+	priv->ssh_tunnel_auth_combo = NULL;
+	priv->ssh_tunnel_auth_password = NULL;
+	priv->ssh_tunnel_privatekey_chooser = NULL;
+	priv->ssh_tunnel_certfile_chooser = NULL;
+
+	g_hash_table_remove_all(priv->setting_widgets);
+
+	protocol = remmina_public_combo_get_active_text(combo);
+	if (protocol) {
+		priv->plugin = (RemminaProtocolPlugin *)remmina_plugin_manager_get_plugin(REMMINA_PLUGIN_TYPE_PROTOCOL,
+											  protocol);
+		g_free(protocol);
+		remmina_file_editor_create_all_settings(gfe);
+	}
+}
+
+static void remmina_file_editor_save_behavior_tab(RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+	RemminaFileEditorPriv *priv = gfe->priv;
+
+	remmina_file_set_string(priv->remmina_file, "precommand", gtk_entry_get_text(GTK_ENTRY(priv->behavior_precommand_entry)));
+	remmina_file_set_string(priv->remmina_file, "postcommand", gtk_entry_get_text(GTK_ENTRY(priv->behavior_postcommand_entry)));
+
+	gboolean autostart_enabled = (priv->behavior_autostart_check ? gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->behavior_autostart_check)) : FALSE);
+	remmina_file_set_int(priv->remmina_file, "enable-autostart", autostart_enabled);
+	gboolean lock_enabled = (priv->behavior_lock_check ? gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->behavior_lock_check)) : FALSE);
+	remmina_file_set_int(priv->remmina_file, "profile-lock", lock_enabled);
+	gboolean disconect_prompt = (priv->behavior_disconnect ? gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->behavior_disconnect)) : FALSE);
+	remmina_file_set_int(priv->remmina_file, "disconnect-prompt", disconect_prompt);
+}
+
+static void remmina_file_editor_save_ssh_tunnel_tab(RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+	RemminaFileEditorPriv *priv = gfe->priv;
+	gboolean ssh_tunnel_enabled;
+	int ssh_tunnel_auth;
+
+	ssh_tunnel_enabled = (priv->ssh_tunnel_enabled_check ? gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->ssh_tunnel_enabled_check)) : FALSE);
+	remmina_file_set_int(priv->remmina_file,
+			     "ssh_tunnel_loopback",
+			     (priv->ssh_tunnel_loopback_check ? gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->ssh_tunnel_loopback_check)) : FALSE));
+	remmina_file_set_int(priv->remmina_file, "ssh_tunnel_enabled", ssh_tunnel_enabled);
+	remmina_file_set_string(priv->remmina_file, "ssh_tunnel_auth",
+				remmina_public_combo_get_active_text(GTK_COMBO_BOX(priv->ssh_tunnel_auth_combo)));
+	remmina_file_set_string(priv->remmina_file, "ssh_tunnel_username",
+				(ssh_tunnel_enabled ? gtk_entry_get_text(GTK_ENTRY(priv->ssh_tunnel_username_entry)) : NULL));
+	remmina_file_set_string(
+		priv->remmina_file,
+		"ssh_tunnel_server",
+		(ssh_tunnel_enabled && priv->ssh_tunnel_server_entry && (priv->ssh_tunnel_server_custom_radio == NULL || gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->ssh_tunnel_server_custom_radio))) ? gtk_entry_get_text(GTK_ENTRY(priv->ssh_tunnel_server_entry)) : NULL));
+
+	ssh_tunnel_auth = gtk_combo_box_get_active(GTK_COMBO_BOX(priv->ssh_tunnel_auth_combo));
+
+	remmina_file_set_int(
+		priv->remmina_file,
+		"ssh_tunnel_auth",
+		ssh_tunnel_auth);
+	
+	// If box is unchecked for private key and certfile file choosers,
+	// set the string to NULL in the remmina file 
+	if (gtk_widget_get_sensitive(priv->ssh_tunnel_privatekey_chooser)) {
+		remmina_file_set_string(
+		priv->remmina_file,
+		"ssh_tunnel_privatekey",
+		(priv->ssh_tunnel_privatekey_chooser ? gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(priv->ssh_tunnel_privatekey_chooser)) : NULL));
+	}
+	else {
+		remmina_file_set_string(priv->remmina_file, "ssh_tunnel_privatekey", NULL);
+	}
+	
+	if (gtk_widget_get_sensitive(priv->ssh_tunnel_certfile_chooser)) {
+		remmina_file_set_string(
+			priv->remmina_file,
+			"ssh_tunnel_certfile",
+			(priv->ssh_tunnel_certfile_chooser ? gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(priv->ssh_tunnel_certfile_chooser)) : NULL));
+	}
+	else {
+		remmina_file_set_string(priv->remmina_file, "ssh_tunnel_certfile", NULL);
+	}
+
+	remmina_file_set_string(
+		priv->remmina_file,
+		"ssh_tunnel_password",
+		(ssh_tunnel_enabled && (ssh_tunnel_auth == SSH_AUTH_PASSWORD)) ? gtk_entry_get_text(GTK_ENTRY(priv->ssh_tunnel_auth_password)) : NULL);
+
+	remmina_file_set_string(
+		priv->remmina_file,
+		"ssh_tunnel_passphrase",
+		(ssh_tunnel_enabled && (ssh_tunnel_auth == SSH_AUTH_PUBLICKEY || ssh_tunnel_auth == SSH_AUTH_AUTO_PUBLICKEY)) ? gtk_entry_get_text(GTK_ENTRY(priv->ssh_tunnel_passphrase)) : NULL);
+}
+
+static gboolean remmina_file_editor_validate_settings(RemminaFileEditor *	gfe,
+						      gchar *			setting_name_to_validate,
+						      gconstpointer		value,
+						      GError **			err)
+{
+	if (!setting_name_to_validate || !value || !gfe) {
+		if (!setting_name_to_validate) {
+			g_critical(_("(%s: %i): Can't validate setting '%s' since 'value' or 'gfe' "
+				     "are NULL!"),
+				   __func__, __LINE__, setting_name_to_validate);
+		} else {
+			g_critical(_("(%s: %i): Can't validate user input since "
+				     "'setting_name_to_validate', 'value' or 'gfe' are NULL!"),
+				   __func__, __LINE__);
+		}
+		g_set_error(err, 1, 1, _("Internal error."));
+		return FALSE;
+	}
+
+	if (strcmp(setting_name_to_validate, "notes_text") == 0) {
+		// Not a plugin setting. Bail out early.
+		return TRUE;
+	}
+
+	const RemminaProtocolSetting *setting_iter;
+	RemminaProtocolPlugin *protocol_plugin;
+	RemminaFileEditorPriv *priv = gfe->priv;
+	protocol_plugin = priv->plugin;
+
+	setting_iter = protocol_plugin->basic_settings;
+	if (setting_iter) {
+		// gboolean found = FALSE;
+		while (setting_iter->type != REMMINA_PROTOCOL_SETTING_TYPE_END) {
+			if (setting_iter->name == NULL) {
+				g_error("Internal error: a setting name in protocol plugin %s is "
+					"null. Please fix RemminaProtocolSetting struct content.",
+					protocol_plugin->name);
+			} else if ((gchar *)setting_name_to_validate) {
+				if (strcmp((gchar *)setting_name_to_validate, setting_iter->name) == 0) {
+					// found = TRUE;
+
+					gpointer validator_data = setting_iter->validator_data;
+					GCallback validator = setting_iter->validator;
+
+					// Default behaviour is that everything is valid,
+					// except a validator is given and its returned GError is not NULL.
+					GError *err_ret = NULL;
+
+					g_debug("Checking setting '%s' for validation.", setting_iter->name);
+					if (validator != NULL) {
+						// Looks weird but it calls the setting's validator
+						// function using setting_name_to_validate, value and
+						// validator_data as parameters and it returns a GError*.
+						err_ret = ((GError * (*)(gpointer, gconstpointer, gpointer)) validator)(setting_name_to_validate, value, validator_data);
+					}
+
+					if (err_ret) {
+						g_debug("it has a validator function and it had an error!");
+						// pass err (returned value) to function caller.
+						*err = err_ret;
+						return FALSE;
+					}
+
+					break;
+				}
+			}
+			setting_iter++;
+		}
+
+		// if (!found) {
+		// 	 TOO VERBOSE:
+		// 	 g_warning("%s is not a plugin setting!", setting_name_to_validate);
+		// }
+	}
+
+	return TRUE;
+}
+
+static GError *remmina_file_editor_update_settings(RemminaFileEditor *	gfe,
+						   GtkWidget **		failed_widget)
+{
+	TRACE_CALL(__func__);
+	RemminaFileEditorPriv *priv = gfe->priv;
+	GHashTableIter iter;
+	gpointer key;
+	gpointer widget;
+	GtkTextBuffer *buffer;
+	gchar *escaped, *unescaped;
+	GtkTextIter start, end;
+
+	GError *err = NULL;
+	*failed_widget = NULL;
+
+	g_hash_table_iter_init(&iter, priv->setting_widgets);
+	while (g_hash_table_iter_next(&iter, &key, &widget)) {
+		
+		// We don't want to save or validate grayed-out settings.
+		// If widget is a file chooser, it was made not sensitive because
+		// the box was unchecked. In that case, don't continue. The 
+		// relevant file strings will be set to NULL in the remmina file.
+		if (!gtk_widget_get_sensitive(GTK_WIDGET(widget)) && !GTK_IS_FILE_CHOOSER(widget)) {
+			g_debug("Grayed-out setting-widget '%s' will not be saved.",
+			gtk_widget_get_name(widget));
+			continue;
+		}
+
+		if (GTK_IS_ENTRY(widget)) {
+			const gchar *value = gtk_entry_get_text(GTK_ENTRY(widget));
+
+			if (!remmina_file_editor_validate_settings(gfe, (gchar *)key, value, &err)) {
+				// Error while validating!
+				// err should be set now.
+				*failed_widget = widget;
+				break;
+			}
+
+			remmina_file_set_string(priv->remmina_file, (gchar *)key, value);
+		} else if (GTK_IS_TEXT_VIEW(widget)) {
+			buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
+			gtk_text_buffer_get_start_iter(buffer, &start);
+			gtk_text_buffer_get_end_iter(buffer, &end);
+			unescaped = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
+			escaped = g_uri_escape_string(unescaped, NULL, TRUE);
+
+			if (!remmina_file_editor_validate_settings(gfe, (gchar *)key, escaped, &err)) {
+				// Error while validating!
+				// err should be set now.
+				*failed_widget = widget;
+				break;
+			}
+
+			remmina_file_set_string(priv->remmina_file, (gchar *)key, escaped);
+			g_free(escaped);
+		} else if (GTK_IS_COMBO_BOX(widget)) {
+			gchar *value = remmina_public_combo_get_active_text(GTK_COMBO_BOX(widget));
+
+			if (!remmina_file_editor_validate_settings(gfe, (gchar *)key, value, &err)) {
+				// Error while validating!
+				// err should be set now.
+				*failed_widget = widget;
+				break;
+			}
+
+			remmina_file_set_string(priv->remmina_file, (gchar *)key, value);
+		} else if (GTK_IS_FILE_CHOOSER(widget)) {
+			gchar *value = gtk_widget_get_sensitive(GTK_WIDGET(widget)) ? gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(widget)) : NULL;
+
+			if (!gtk_widget_get_sensitive(GTK_WIDGET(widget))) {
+				remmina_file_set_string(priv->remmina_file, (gchar *)key, value);
+				continue;
+			}
+
+			if (!remmina_file_editor_validate_settings(gfe, (gchar *)key, value, &err)) {
+				// Error while validating!
+				// err should be set now.
+				g_free(value);
+				*failed_widget = widget;
+				break;
+			}
+
+			remmina_file_set_string(priv->remmina_file, (gchar *)key, value);
+			g_free(value);
+		} else if (GTK_IS_TOGGLE_BUTTON(widget)) {
+			gboolean value = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
+
+			if (!remmina_file_editor_validate_settings(gfe, (gchar *)key, &value, &err)) {
+				// Error while validating!
+				// err should be set now.
+				*failed_widget = widget;
+				break;
+			}
+
+			remmina_file_set_int(priv->remmina_file, (gchar *)key, value);
+		}
+	}
+
+	if (err) {
+		return err;
+	}
+
+	return NULL;
+}
+
+static GError *remmina_file_editor_update(RemminaFileEditor *	gfe,
+					  GtkWidget **		failed_widget)
+{
+	TRACE_CALL(__func__);
+	int res_w, res_h;
+	gchar *custom_resolution;
+	RemminaProtocolWidgetResolutionMode res_mode;
+
+	RemminaFileEditorPriv *priv = gfe->priv;
+
+	remmina_file_set_string(priv->remmina_file, "name", gtk_entry_get_text(GTK_ENTRY(priv->name_entry)));
+
+	remmina_file_set_string(priv->remmina_file, "labels", gtk_entry_get_text(GTK_ENTRY(priv->labels_entry)));
+
+	remmina_file_set_string(priv->remmina_file, "group",
+				(priv->group_combo ? remmina_public_combo_get_active_text(GTK_COMBO_BOX(priv->group_combo)) : NULL));
+
+	remmina_file_set_string(priv->remmina_file, "protocol",
+				remmina_public_combo_get_active_text(GTK_COMBO_BOX(priv->protocol_combo)));
+
+	remmina_file_set_string(priv->remmina_file, "server",
+				(priv->server_combo ? remmina_public_combo_get_active_text(GTK_COMBO_BOX(priv->server_combo)) : NULL));
+
+	if (priv->resolution_auto_radio) {
+		if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->resolution_auto_radio))) {
+			/* Resolution is set to auto (which means: Use client fullscreen resolution, aka use client resolution) */
+			res_w = res_h = 0;
+			res_mode = RES_USE_CLIENT;
+		} else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->resolution_iws_radio))) {
+			/* Resolution is set to initial window size */
+			res_w = res_h = 0;
+			res_mode = RES_USE_INITIAL_WINDOW_SIZE;
+		} else {
+			/* Resolution is set to a value from the list */
+			custom_resolution = remmina_public_combo_get_active_text(GTK_COMBO_BOX(priv->resolution_custom_combo));
+			if (remmina_public_split_resolution_string(custom_resolution, &res_w, &res_h))
+				res_mode = RES_USE_CUSTOM;
+			else
+				res_mode = RES_USE_INITIAL_WINDOW_SIZE;
+			g_free(custom_resolution);
+		}
+		remmina_file_set_int(priv->remmina_file, "resolution_mode", res_mode);
+		remmina_file_set_int(priv->remmina_file, "resolution_width", res_w);
+		remmina_file_set_int(priv->remmina_file, "resolution_height", res_h);
+	}
+
+	if (priv->assistance_toggle){
+		if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->assistance_toggle))) {
+			remmina_file_set_string(priv->remmina_file, "assistance_file", gtk_entry_get_text(GTK_ENTRY(priv->assistance_file)));
+			remmina_file_set_string(priv->remmina_file, "assistance_pass", gtk_entry_get_text(GTK_ENTRY(priv->assistance_password)));
+			remmina_file_set_int(priv->remmina_file, "assistance_mode", 1);
+		}else{
+			remmina_file_set_int(priv->remmina_file, "assistance_mode", 0);
+		}
+		
+	}
+
+	if (priv->keymap_combo)
+		remmina_file_set_string(priv->remmina_file, "keymap",
+					remmina_public_combo_get_active_text(GTK_COMBO_BOX(priv->keymap_combo)));
+
+	remmina_file_editor_save_behavior_tab(gfe);
+	remmina_file_editor_save_ssh_tunnel_tab(gfe);
+	return remmina_file_editor_update_settings(gfe, failed_widget);
+}
+
+static void remmina_file_editor_on_default(GtkWidget *button, RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+	RemminaFile *gf;
+	GtkWidget *dialog;
+
+	GtkWidget *failed_widget = NULL;
+	GError *err = remmina_file_editor_update(gfe, &failed_widget);
+	if (err) {
+		g_warning(_("Couldn't validate user input. %s"), err->message);
+		remmina_file_editor_show_validation_error_popup(gfe, failed_widget, err);
+		return;
+	}
+
+	gf = remmina_file_dup(gfe->priv->remmina_file);
+
+	remmina_file_set_filename(gf, remmina_pref_file);
+
+	/* Clear properties that should never be default */
+	remmina_file_set_string(gf, "name", NULL);
+	remmina_file_set_string(gf, "server", NULL);
+	remmina_file_set_string(gf, "password", NULL);
+	remmina_file_set_string(gf, "precommand", NULL);
+	remmina_file_set_string(gf, "postcommand", NULL);
+
+	remmina_file_set_string(gf, "ssh_tunnel_server", NULL);
+	remmina_file_set_string(gf, "ssh_tunnel_password", NULL);
+	remmina_file_set_string(gf, "ssh_tunnel_passphrase", NULL);
+
+	remmina_file_save(gf);
+	remmina_file_free(gf);
+
+	dialog = gtk_message_dialog_new(GTK_WINDOW(gfe), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO,
+					GTK_BUTTONS_OK, _("Default settings saved."));
+	gtk_dialog_run(GTK_DIALOG(dialog));
+	gtk_widget_destroy(dialog);
+}
+
+static void remmina_file_editor_on_save(GtkWidget *button, RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+
+	GtkWidget *failed_widget = NULL;
+	GError *err = remmina_file_editor_update(gfe, &failed_widget);
+	if (err) {
+		g_warning(_("Couldn't validate user input. %s"), err->message);
+		remmina_file_editor_show_validation_error_popup(gfe, failed_widget, err);
+		return;
+	}
+
+	remmina_file_editor_file_save(gfe);
+
+	remmina_file_save(gfe->priv->remmina_file);
+	remmina_icon_populate_menu();
+
+	gtk_widget_destroy(GTK_WIDGET(gfe));
+}
+
+static void remmina_file_editor_on_connect(GtkWidget *button, RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+	RemminaFile *gf;
+
+	GtkWidget *failed_widget = NULL;
+	GError *err = remmina_file_editor_update(gfe, &failed_widget);
+	if (err) {
+		g_warning(_("Couldn't validate user input. %s"), err->message);
+		remmina_file_editor_show_validation_error_popup(gfe, failed_widget, err);
+		return;
+	}
+
+	gf = remmina_file_dup(gfe->priv->remmina_file);
+	/* Put server into name for "Quick Connect" */
+	if (remmina_file_get_filename(gf) == NULL)
+		remmina_file_set_string(gf, "name", remmina_file_get_string(gf, "server"));
+	gtk_widget_destroy(GTK_WIDGET(gfe));
+	gf->prevent_saving = TRUE;
+	rcw_open_from_file(gf);
+}
+
+static void remmina_file_editor_on_save_connect(GtkWidget *button, RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+	/** @TODO: Call remmina_file_editor_on_save */
+	RemminaFile *gf;
+
+	GtkWidget *failed_widget = NULL;
+	GError *err = remmina_file_editor_update(gfe, &failed_widget);
+	if (err) {
+		g_warning(_("Couldn't validate user input. %s"), err->message);
+		remmina_file_editor_show_validation_error_popup(gfe, failed_widget, err);
+		return;
+	}
+
+	remmina_file_editor_file_save(gfe);
+
+	remmina_file_save(gfe->priv->remmina_file);
+	remmina_icon_populate_menu();
+
+	gf = remmina_file_dup(gfe->priv->remmina_file);
+	/* Put server into name for Quick Connect */
+	if (remmina_file_get_filename(gf) == NULL)
+		remmina_file_set_string(gf, "name", remmina_file_get_string(gf, "server"));
+	gtk_widget_destroy(GTK_WIDGET(gfe));
+	rcw_open_from_file(gf);
+}
+
+static void remmina_file_editor_on_cancel(GtkWidget *button, RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+	gtk_widget_destroy(GTK_WIDGET(gfe));
+}
+
+static void remmina_file_editor_init(RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+	RemminaFileEditorPriv *priv;
+	GtkWidget *widget;
+
+	priv = g_new0(RemminaFileEditorPriv, 1);
+	gfe->priv = priv;
+
+	/* Create the editor dialog */
+	gtk_window_set_title(GTK_WINDOW(gfe), _("Remote Connection Profile"));
+
+	widget = gtk_dialog_add_button(GTK_DIALOG(gfe), (_("_Cancel")), GTK_RESPONSE_CANCEL);
+	g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_file_editor_on_cancel), gfe);
+
+	/* Default button */
+	widget = gtk_dialog_add_button(GTK_DIALOG(gfe), (_("Save as Default")), GTK_RESPONSE_OK);
+	gtk_widget_set_tooltip_text(GTK_WIDGET(widget), _("Use the current settings as the default for all new connection profiles"));
+	g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_file_editor_on_default), gfe);
+
+	widget = gtk_dialog_add_button(GTK_DIALOG(gfe), (_("_Save")), GTK_RESPONSE_APPLY);
+	g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_file_editor_on_save), gfe);
+	gtk_widget_set_sensitive(widget, FALSE);
+	priv->save_button = widget;
+
+	widget = gtk_dialog_add_button(GTK_DIALOG(gfe), (_("Connect")), GTK_RESPONSE_ACCEPT);
+	g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_file_editor_on_connect), gfe);
+
+	widget = gtk_dialog_add_button(GTK_DIALOG(gfe), (_("_Save and Connect")), GTK_RESPONSE_OK);
+	gtk_widget_set_can_default(widget, TRUE);
+	g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_file_editor_on_save_connect), gfe);
+
+	gtk_dialog_set_default_response(GTK_DIALOG(gfe), GTK_RESPONSE_OK);
+	gtk_window_set_default_size(GTK_WINDOW(gfe), 800, 600);
+
+	g_signal_connect(G_OBJECT(gfe), "destroy", G_CALLBACK(remmina_file_editor_destroy), NULL);
+	g_signal_connect(G_OBJECT(gfe), "realize", G_CALLBACK(remmina_file_editor_on_realize), NULL);
+
+	priv->setting_widgets = g_hash_table_new(g_str_hash, g_str_equal);
+
+	remmina_widget_pool_register(GTK_WIDGET(gfe));
+}
+
+static gboolean remmina_file_editor_iterate_protocol(gchar *protocol, RemminaPlugin *plugin, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaFileEditor *gfe = REMMINA_FILE_EDITOR(data);
+	GtkListStore *store;
+	GtkTreeIter iter;
+	gboolean first;
+
+	store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(gfe->priv->protocol_combo)));
+
+	first = !gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter);
+
+	gtk_list_store_append(store, &iter);
+	gtk_list_store_set(store, &iter, 0, protocol, 1, g_dgettext(plugin->domain, plugin->description), 2,
+			   ((RemminaProtocolPlugin *)plugin)->icon_name, -1);
+
+	if (first || g_strcmp0(protocol, remmina_file_get_string(gfe->priv->remmina_file, "protocol")) == 0)
+		gtk_combo_box_set_active_iter(GTK_COMBO_BOX(gfe->priv->protocol_combo), &iter);
+
+	return FALSE;
+}
+
+void remmina_file_editor_check_profile(RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+	RemminaFileEditorPriv *priv;
+
+	priv = gfe->priv;
+	gtk_widget_set_sensitive(priv->group_combo, TRUE);
+	gtk_widget_set_sensitive(priv->save_button, TRUE);
+}
+
+static void remmina_file_editor_entry_on_changed(GtkEditable *editable, RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+	RemminaFileEditorPriv *priv;
+
+	priv = gfe->priv;
+	if (remmina_file_get_filename(priv->remmina_file) == NULL) {
+		remmina_file_generate_filename(priv->remmina_file);
+		/* TODO: Probably to be removed */
+		remmina_file_editor_check_profile(gfe);
+	} else {
+		remmina_file_delete(remmina_file_get_filename(priv->remmina_file));
+		remmina_file_generate_filename(priv->remmina_file);
+		remmina_file_editor_check_profile(gfe);
+	}
+}
+
+void remmina_file_editor_file_save(RemminaFileEditor *gfe)
+{
+	TRACE_CALL(__func__);
+	RemminaFileEditorPriv *priv;
+
+	priv = gfe->priv;
+	if (remmina_file_get_filename(priv->remmina_file) == NULL) {
+		remmina_file_generate_filename(priv->remmina_file);
+	} else {
+		remmina_file_delete(remmina_file_get_filename(priv->remmina_file));
+		remmina_file_generate_filename(priv->remmina_file);
+	}
+}
+
+GtkWidget *remmina_file_editor_new_from_file(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	RemminaFileEditor *gfe;
+	RemminaFileEditorPriv *priv;
+	GtkWidget *grid;
+	GtkWidget *widget;
+	gchar *groups;
+	gchar *s;
+	const gchar *cs;
+
+	gfe = REMMINA_FILE_EDITOR(g_object_new(REMMINA_TYPE_FILE_EDITOR, NULL));
+	priv = gfe->priv;
+	priv->remmina_file = remminafile;
+
+	if (remmina_file_get_filename(remminafile) == NULL)
+		gtk_dialog_set_response_sensitive(GTK_DIALOG(gfe), GTK_RESPONSE_APPLY, FALSE);
+
+	/* Create the "Profile" group on the top (for name and protocol) */
+	grid = gtk_grid_new();
+	gtk_widget_show(grid);
+	gtk_grid_set_row_spacing(GTK_GRID(grid), 4);
+	gtk_grid_set_column_spacing(GTK_GRID(grid), 8);
+	gtk_grid_set_column_homogeneous(GTK_GRID(grid), TRUE);
+	gtk_container_set_border_width(GTK_CONTAINER(grid), 8);
+	gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(gfe))), grid, FALSE, FALSE, 2);
+
+	// remmina_public_create_group(GTK_GRID(grid), _("Profile"), 0, 4, 3);
+
+	gboolean profile_file_exists = (remmina_file_get_filename(remminafile) != NULL);
+
+	/* Profile: Name */
+	widget = gtk_label_new(_("Name"));
+	gtk_widget_show(widget);
+	gtk_widget_set_valign(widget, GTK_ALIGN_START);
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, 3, 2, 1);
+	gtk_grid_set_column_spacing(GTK_GRID(grid), 10);
+
+	widget = gtk_entry_new();
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, 1, 3, 3, 1);
+	gtk_entry_set_max_length(GTK_ENTRY(widget), 100);
+	priv->name_entry = widget;
+
+	if (!profile_file_exists) {
+		gtk_entry_set_text(GTK_ENTRY(widget), _("Quick Connect"));
+#if GTK_CHECK_VERSION(3, 16, 0)
+		gtk_entry_grab_focus_without_selecting(GTK_ENTRY(widget));
+#endif
+		g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(remmina_file_editor_entry_on_changed), gfe);
+	} else {
+		cs = remmina_file_get_string(remminafile, "name");
+		gtk_entry_set_text(GTK_ENTRY(widget), cs ? cs : "");
+	}
+
+	/* Profile: Group */
+	widget = gtk_label_new(_("Group"));
+	gtk_widget_show(widget);
+	gtk_widget_set_valign(widget, GTK_ALIGN_START);
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, 6, 2, 1);
+
+	groups = remmina_file_manager_get_groups();
+	priv->group_combo = remmina_public_create_combo_entry(groups, remmina_file_get_string(remminafile, "group"), FALSE);
+	g_free(groups);
+	gtk_widget_show(priv->group_combo);
+	gtk_grid_attach(GTK_GRID(grid), priv->group_combo, 1, 6, 3, 1);
+	gtk_widget_set_sensitive(priv->group_combo, FALSE);
+
+	s = g_strdup_printf(_("Use '%s' as subgroup delimiter"), "/");
+	gtk_widget_set_tooltip_text(priv->group_combo, s);
+	g_free(s);
+
+	/* Profile: Labels */
+	widget = gtk_label_new(_("Labels"));
+	gtk_widget_show(widget);
+	gtk_widget_set_valign(widget, GTK_ALIGN_START);
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, 9, 2, 1);
+	gtk_grid_set_column_spacing(GTK_GRID(grid), 10);
+
+	widget = gtk_entry_new();
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, 1, 9, 3, 1);
+	gtk_entry_set_max_length(GTK_ENTRY(widget), 255);
+	priv->labels_entry = widget;
+
+	if (!profile_file_exists) {
+		gtk_widget_set_tooltip_text(widget, _("Label1,Label2"));
+#if GTK_CHECK_VERSION(3, 16, 0)
+		gtk_entry_grab_focus_without_selecting(GTK_ENTRY(widget));
+#endif
+		g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(remmina_file_editor_entry_on_changed), gfe);
+	} else {
+		cs = remmina_file_get_string(remminafile, "labels");
+		gtk_entry_set_text(GTK_ENTRY(widget), cs ? cs : "");
+	}
+
+	/* Profile: Protocol */
+	widget = gtk_label_new(_("Protocol"));
+	gtk_widget_show(widget);
+	gtk_widget_set_valign(widget, GTK_ALIGN_START);
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, 12, 2, 1);
+
+	widget = remmina_public_create_combo(TRUE);
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, 1, 12, 3, 1);
+	priv->protocol_combo = widget;
+	remmina_plugin_manager_for_each_plugin(REMMINA_PLUGIN_TYPE_PROTOCOL, remmina_file_editor_iterate_protocol, gfe);
+	g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(remmina_file_editor_protocol_combo_on_changed), gfe);
+
+	/* Create the "Preference" frame */
+	widget = gtk_event_box_new();
+	gtk_widget_show(widget);
+	gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(gfe))), widget, TRUE, TRUE, 2);
+	priv->config_box = widget;
+
+	priv->config_container = NULL;
+	priv->config_scrollable = NULL;
+
+	remmina_file_editor_protocol_combo_on_changed(GTK_COMBO_BOX(priv->protocol_combo), gfe);
+
+	remmina_file_editor_check_profile(gfe);
+
+	return GTK_WIDGET(gfe);
+}
+
+GtkWidget *remmina_file_editor_new(void)
+{
+	TRACE_CALL(__func__);
+	return remmina_file_editor_new_full(NULL, NULL);
+}
+
+GtkWidget *remmina_file_editor_new_full(const gchar *server, const gchar *protocol)
+{
+	TRACE_CALL(__func__);
+	RemminaFile *remminafile;
+
+	remminafile = remmina_file_new();
+	if (server)
+		remmina_file_set_string(remminafile, "server", server);
+	if (protocol)
+		remmina_file_set_string(remminafile, "protocol", protocol);
+
+	return remmina_file_editor_new_from_file(remminafile);
+}
+
+GtkWidget *remmina_file_editor_new_copy(const gchar *filename)
+{
+	TRACE_CALL(__func__);
+	RemminaFile *remminafile;
+	GtkWidget *dialog;
+
+	remminafile = remmina_file_copy(filename);
+
+	if (remminafile) {
+		return remmina_file_editor_new_from_file(remminafile);
+	} else {
+		dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
+						_("Could not find the file “%s”."), filename);
+		gtk_dialog_run(GTK_DIALOG(dialog));
+		gtk_widget_destroy(dialog);
+		return NULL;
+	}
+}
+
+GtkWidget *remmina_file_editor_new_from_filename(const gchar *filename)
+{
+	TRACE_CALL(__func__);
+	RemminaFile *remminafile;
+
+	remminafile = remmina_file_manager_load_file(filename);
+	if (remminafile) {
+		if (remmina_file_get_int(remminafile, "profile-lock", FALSE) && remmina_unlock_new(remmina_main_get_window()) == 0)
+			return NULL;
+		return remmina_file_editor_new_from_file(remminafile);
+	} else {
+		GtkWidget *dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
+							   _("Could not find the file “%s”."), filename);
+		gtk_dialog_run(GTK_DIALOG(dialog));
+		gtk_widget_destroy(dialog);
+		return NULL;
+	}
+}
diff --git a/src/remmina_file_editor.h b/src/remmina_file_editor.h
new file mode 100644
index 0000000..baf034a
--- /dev/null
+++ b/src/remmina_file_editor.h
@@ -0,0 +1,80 @@
+/*
+ * 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.
+ *
+ */
+
+#pragma once
+
+#include <stdarg.h>
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#include "remmina_file.h"
+
+G_BEGIN_DECLS
+
+#define REMMINA_TYPE_FILE_EDITOR               (remmina_file_editor_get_type())
+#define REMMINA_FILE_EDITOR(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), REMMINA_TYPE_FILE_EDITOR, RemminaFileEditor))
+#define REMMINA_FILE_EDITOR_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), REMMINA_TYPE_FILE_EDITOR, RemminaFileEditorClass))
+#define REMMINA_IS_FILE_EDITOR(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), REMMINA_TYPE_FILE_EDITOR))
+#define REMMINA_IS_FILE_EDITOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), REMMINA_TYPE_FILE_EDITOR))
+#define REMMINA_FILE_EDITOR_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), REMMINA_TYPE_FILE_EDITOR, RemminaFileEditorClass))
+
+typedef struct _RemminaFileEditorPriv RemminaFileEditorPriv;
+
+typedef struct _RemminaFileEditor {
+	GtkDialog		dialog;
+
+	RemminaFileEditorPriv * priv;
+} RemminaFileEditor;
+
+typedef struct _RemminaFileEditorClass {
+	GtkDialogClass parent_class;
+} RemminaFileEditorClass;
+
+GType remmina_file_editor_get_type(void)
+G_GNUC_CONST;
+
+/* Base constructor */
+GtkWidget *remmina_file_editor_new_from_file(RemminaFile *remminafile);
+/* Create new file */
+GtkWidget *remmina_file_editor_new(void);
+GtkWidget *remmina_file_editor_new_full(const gchar *server, const gchar *protocol);
+GtkWidget *remmina_file_editor_new_copy(const gchar *filename);
+/* Open existing file */
+GtkWidget *remmina_file_editor_new_from_filename(const gchar *filename);
+void remmina_file_editor_check_profile(RemminaFileEditor *gfe);
+void remmina_file_editor_file_save(RemminaFileEditor *gfe);
+
+G_END_DECLS
diff --git a/src/remmina_file_manager.c b/src/remmina_file_manager.c
new file mode 100644
index 0000000..10a3022
--- /dev/null
+++ b/src/remmina_file_manager.c
@@ -0,0 +1,372 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009-2010 Vic Lee
+ * Copyright (C) 2014-2015 Antenore Gatta, Fabio Castelli, Giovanni Panozzo
+ * Copyright (C) 2016-2023 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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 <errno.h>
+#include <gtk/gtk.h>
+#include <string.h>
+
+#include "remmina_log.h"
+#include "remmina_public.h"
+#include "remmina_pref.h"
+#include "remmina_string_array.h"
+#include "remmina_plugin_manager.h"
+#include "remmina_file_manager.h"
+#include "remmina/remmina_trace_calls.h"
+
+static gchar *remminadir;
+static gchar *cachedir;
+
+/**
+ * Return datadir_path from pref or first found data dir as per XDG specs.
+ *
+ * The returned string must be freed by the caller with g_free
+ */
+gchar *remmina_file_get_datadir(void)
+{
+	TRACE_CALL(__func__);
+	const gchar *dir = ".remmina";
+	int i;
+
+	/* From preferences, datadir_path */
+	remminadir = remmina_pref_get_value("datadir_path");
+	if (remminadir != NULL && strlen(remminadir) > 0)
+		if (g_file_test(remminadir, G_FILE_TEST_IS_DIR))
+			return remminadir;
+	g_free(remminadir), remminadir = NULL;
+	/* Legacy ~/.remmina */
+	remminadir = g_build_path("/", g_get_home_dir(), dir, NULL);
+	if (g_file_test(remminadir, G_FILE_TEST_IS_DIR))
+		return remminadir;
+	g_free(remminadir), remminadir = NULL;
+	/* ~/.local/share/remmina */
+	remminadir = g_build_path("/", g_get_user_data_dir(), "remmina", NULL);
+	if (g_file_test(remminadir, G_FILE_TEST_IS_DIR))
+		return remminadir;
+	g_free(remminadir), remminadir = NULL;
+	/* /usr/local/share/remmina */
+	const gchar *const *dirs = g_get_system_data_dirs();
+
+	g_free(remminadir), remminadir = NULL;
+	for (i = 0; dirs[i] != NULL; ++i) {
+		remminadir = g_build_path("/", dirs[i], "remmina", NULL);
+		if (g_file_test(remminadir, G_FILE_TEST_IS_DIR))
+			return remminadir;
+		g_free(remminadir), remminadir = NULL;
+	}
+	/* The last case we use  the home ~/.local/share/remmina */
+	remminadir = g_build_path("/", g_get_user_data_dir(), "remmina", NULL);
+	return remminadir;
+}
+
+/** @todo remmina_pref_file_do_copy and remmina_file_manager_do_copy to remmina_files_copy */
+static gboolean remmina_file_manager_do_copy(const char *src_path, const char *dst_path)
+{
+	GFile *src = g_file_new_for_path(src_path), *dst = g_file_new_for_path(dst_path);
+	/* We don’t overwrite the target if it exists */
+	const gboolean ok = g_file_copy(src, dst, G_FILE_COPY_NONE, NULL, NULL, NULL, NULL);
+
+	g_object_unref(dst);
+	g_object_unref(src);
+
+	return ok;
+}
+
+/**
+ * It creates the Remmina data and cache folders
+ *
+ * If it finds the legacy ~/.remmina folder it copies the connection profiles into the new folder.
+ *
+ * If it finds default profiles in the XDG_DATA_DIRS it copies the profiles into the user data-folder.
+ */
+void remmina_file_manager_init(void)
+{
+	TRACE_CALL(__func__);
+	GDir *dir;
+	const gchar *legacy = ".remmina";
+	const gchar *filename;
+	int i;
+
+	/* Get and create the XDG_DATA_HOME directory */
+	remminadir = remmina_pref_get_value("datadir_path");
+	if (g_mkdir_with_parents(remminadir, 0750) == 0) {
+		REMMINA_DEBUG("Initialized the \"%s\" data folder", remminadir);
+		g_free(remminadir), remminadir = NULL;
+	} else {
+		g_free(remminadir), remminadir = NULL;
+		/* Get and create the XDG_DATA_HOME directory */
+		remminadir = g_build_path("/", g_get_user_data_dir(), "remmina", NULL);
+		if (g_mkdir_with_parents(remminadir, 0750) == 0)
+			REMMINA_DEBUG("Initialized the \"%s\" data folder", remminadir);
+		else
+			REMMINA_CRITICAL("Cannot create the \"%s\" data folder", remminadir);
+		g_free(remminadir), remminadir = NULL;
+	}
+	/* Create the XDG_CACHE_HOME directory */
+	cachedir = g_build_path("/", g_get_user_cache_dir(), "remmina", NULL);
+	g_mkdir_with_parents(cachedir, 0750);
+	g_free(cachedir), cachedir = NULL;
+	/* Empty legacy ~/.remmina */
+	remminadir = g_build_path("/", g_get_home_dir(), legacy, NULL);
+	if (g_file_test(remminadir, G_FILE_TEST_IS_DIR)) {
+		dir = g_dir_open(remminadir, 0, NULL);
+		while ((filename = g_dir_read_name(dir)) != NULL) {
+			remmina_file_manager_do_copy(
+				g_build_path("/", remminadir, filename, NULL),
+				g_build_path("/", g_get_user_data_dir(),
+					     "remmina", filename, NULL));
+		}
+		g_dir_close(dir);
+	}
+
+	/* XDG_DATA_DIRS, i.e. /usr/local/share/remmina */
+	const gchar *const *dirs = g_get_system_data_dirs();
+
+	g_free(remminadir), remminadir = NULL;
+	for (i = 0; dirs[i] != NULL; ++i) {
+		remminadir = g_build_path("/", dirs[i], "remmina", NULL);
+		if (g_file_test(remminadir, G_FILE_TEST_IS_DIR)) {
+			dir = g_dir_open(remminadir, 0, NULL);
+			while ((filename = g_dir_read_name(dir)) != NULL) {
+				remmina_file_manager_do_copy(
+					g_build_path("/", remminadir, filename, NULL),
+					g_build_path("/", g_get_user_data_dir(),
+						     "remmina", filename, NULL));
+			}
+		}
+		g_free(remminadir), remminadir = NULL;
+	}
+	/* At last we make sure we use XDG_USER_DATA */
+	if (remminadir != NULL)
+		g_free(remminadir), remminadir = NULL;
+}
+
+gint remmina_file_manager_iterate(GFunc func, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gchar filename[MAX_PATH_LEN];
+	GDir *dir;
+	const gchar *name;
+	RemminaFile *remminafile;
+	gint items_count = 0;
+	gchar *remmina_data_dir;
+
+	remmina_data_dir = remmina_file_get_datadir();
+	dir = g_dir_open(remmina_data_dir, 0, NULL);
+
+	if (dir) {
+		while ((name = g_dir_read_name(dir)) != NULL) {
+			if (!g_str_has_suffix(name, ".remmina"))
+				continue;
+			g_snprintf(filename, MAX_PATH_LEN, "%s/%s",
+				   remmina_data_dir, name);
+			remminafile = remmina_file_load(filename);
+			if (remminafile) {
+				(*func)(remminafile, user_data);
+				remmina_file_free(remminafile);
+				items_count++;
+			}
+		}
+		g_dir_close(dir);
+	}
+	g_free(remmina_data_dir);
+	return items_count;
+}
+
+gchar *remmina_file_manager_get_groups(void)
+{
+	TRACE_CALL(__func__);
+	gchar filename[MAX_PATH_LEN];
+	GDir *dir;
+	const gchar *name;
+	RemminaFile *remminafile;
+	RemminaStringArray *array;
+	const gchar *group;
+	gchar *groups;
+	gchar *remmina_data_dir;
+
+	remmina_data_dir = remmina_file_get_datadir();
+	array = remmina_string_array_new();
+
+	dir = g_dir_open(remmina_data_dir, 0, NULL);
+
+	if (dir == NULL)
+		return 0;
+	while ((name = g_dir_read_name(dir)) != NULL) {
+		if (!g_str_has_suffix(name, ".remmina"))
+			continue;
+		g_snprintf(filename, MAX_PATH_LEN, "%s/%s", remmina_data_dir, name);
+		remminafile = remmina_file_load(filename);
+		if (remminafile) {
+			group = remmina_file_get_string(remminafile, "group");
+			if (group && remmina_string_array_find(array, group) < 0)
+				remmina_string_array_add(array, group);
+			remmina_file_free(remminafile);
+		}
+	}
+	g_dir_close(dir);
+	remmina_string_array_sort(array);
+	groups = remmina_string_array_to_string(array);
+	remmina_string_array_free(array);
+	g_free(remmina_data_dir);
+	return groups;
+}
+
+static void remmina_file_manager_add_group(GNode *node, const gchar *group)
+{
+	TRACE_CALL(__func__);
+	gint cmp;
+	gchar *p1;
+	gchar *p2;
+	GNode *child;
+	gboolean found;
+	RemminaGroupData *data;
+
+	if (node == NULL)
+		return;
+
+	if (group == NULL || group[0] == '\0')
+		return;
+
+	p1 = g_strdup(group);
+	p2 = strchr(p1, '/');
+
+	if (p2)
+		*p2++ = '\0';
+
+	found = FALSE;
+
+	for (child = g_node_first_child(node); child; child = g_node_next_sibling(child)) {
+		cmp = g_strcmp0(((RemminaGroupData *)child->data)->name, p1);
+
+		if (cmp == 0) {
+			found = TRUE;
+			break;
+		}
+
+		if (cmp > 0)
+			break;
+	}
+
+	if (!found) {
+		data = g_new0(RemminaGroupData, 1);
+		data->name = p1;
+		if (node->data)
+			data->group = g_strdup_printf("%s/%s", ((RemminaGroupData *)node->data)->group, p1);
+		else
+			data->group = g_strdup(p1);
+		if (child)
+			child = g_node_insert_data_before(node, child, data);
+		else
+			child = g_node_append_data(node, data);
+	}
+	remmina_file_manager_add_group(child, p2);
+
+	if (found)
+		g_free(p1);
+}
+
+GNode *remmina_file_manager_get_group_tree(void)
+{
+	TRACE_CALL(__func__);
+	gchar filename[MAX_PATH_LEN];
+	GDir *dir;
+	g_autofree gchar *datadir = NULL;
+	const gchar *name;
+	RemminaFile *remminafile;
+	const gchar *group;
+	GNode *root;
+
+	root = g_node_new(NULL);
+
+	datadir = g_strdup(remmina_file_get_datadir());
+	dir = g_dir_open(datadir, 0, NULL);
+
+	if (dir == NULL)
+		return root;
+	while ((name = g_dir_read_name(dir)) != NULL) {
+		if (!g_str_has_suffix(name, ".remmina"))
+			continue;
+		g_snprintf(filename, MAX_PATH_LEN, "%s/%s", datadir, name);
+		remminafile = remmina_file_load(filename);
+		if (remminafile) {
+			group = remmina_file_get_string(remminafile, "group");
+			remmina_file_manager_add_group(root, group);
+			remmina_file_free(remminafile);
+		}
+	}
+	g_dir_close(dir);
+	return root;
+}
+
+void remmina_file_manager_free_group_tree(GNode *node)
+{
+	TRACE_CALL(__func__);
+	RemminaGroupData *data;
+	GNode *child;
+
+	if (!node)
+		return;
+	data = (RemminaGroupData *)node->data;
+	if (data) {
+		g_free(data->name);
+		g_free(data->group);
+		g_free(data);
+		node->data = NULL;
+	}
+	for (child = g_node_first_child(node); child; child = g_node_next_sibling(child))
+		remmina_file_manager_free_group_tree(child);
+	g_node_unlink(node);
+}
+
+RemminaFile *remmina_file_manager_load_file(const gchar *filename)
+{
+	TRACE_CALL(__func__);
+	RemminaFile *remminafile = NULL;
+	RemminaFilePlugin *plugin;
+	gchar *p;
+
+	if ((p = strrchr(filename, '.')) != NULL && g_strcmp0(p + 1, "remmina") == 0) {
+		remminafile = remmina_file_load(filename);
+	} else {
+		plugin = remmina_plugin_manager_get_import_file_handler(filename);
+		if (plugin)
+			remminafile = plugin->import_func(plugin, filename);
+	}
+	return remminafile;
+}
diff --git a/src/remmina_file_manager.h b/src/remmina_file_manager.h
new file mode 100644
index 0000000..08535e3
--- /dev/null
+++ b/src/remmina_file_manager.h
@@ -0,0 +1,61 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009-2010 Vic Lee
+ * Copyright (C) 2017-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.
+ *
+ */
+
+#pragma once
+
+#include "remmina_file.h"
+
+G_BEGIN_DECLS
+
+typedef struct _RemminaGroupData {
+	gchar * name;
+	gchar * group;
+	gchar * datetime;
+	gchar * labels;
+} RemminaGroupData;
+
+/* Initialize */
+gchar *remmina_file_get_datadir(void);
+void remmina_file_manager_init(void);
+/* Iterate all .remmina connections in the home directory */
+gint remmina_file_manager_iterate(GFunc func, gpointer user_data);
+/* Get a list of groups */
+gchar *remmina_file_manager_get_groups(void);
+GNode *remmina_file_manager_get_group_tree(void);
+void remmina_file_manager_free_group_tree(GNode *node);
+/* Load or import a file */
+RemminaFile *remmina_file_manager_load_file(const gchar *filename);
+
+G_END_DECLS
diff --git a/src/remmina_ftp_client.c b/src/remmina_ftp_client.c
new file mode 100644
index 0000000..294f2db
--- /dev/null
+++ b/src/remmina_ftp_client.c
@@ -0,0 +1,1276 @@
+/*
+ * 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.
+ *
+ */
+
+#define _FILE_OFFSET_BITS 64
+
+#include <gdk/gdk.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+#include "config.h"
+#include "remmina_public.h"
+#include "remmina_pref.h"
+#include "remmina_marshals.h"
+#include "remmina_ftp_client.h"
+#include "remmina_masterthread_exec.h"
+#include "remmina/remmina_trace_calls.h"
+
+/* -------------------- RemminaCellRendererPixbuf ----------------------- */
+/* A tiny cell renderer that extends the default pixbuf cell render to accept activation */
+
+#define REMMINA_TYPE_CELL_RENDERER_PIXBUF \
+	(remmina_cell_renderer_pixbuf_get_type())
+#define REMMINA_CELL_RENDERER_PIXBUF(obj) \
+	(G_TYPE_CHECK_INSTANCE_CAST((obj), REMMINA_TYPE_CELL_RENDERER_PIXBUF, RemminaCellRendererPixbuf))
+#define REMMINA_CELL_RENDERER_PIXBUF_CLASS(klass) \
+	(G_TYPE_CHECK_CLASS_CAST((klass), REMMINA_TYPE_CELL_RENDERER_PIXBUF, RemminaCellRendererPixbufClass))
+#define REMMINA_IS_CELL_RENDERER_PIXBUF(obj) \
+	(G_TYPE_CHECK_INSTANCE_TYPE((obj), REMMINA_TYPE_CELL_RENDERER_PIXBUF))
+
+typedef struct _RemminaCellRendererPixbuf {
+	GtkCellRendererPixbuf renderer;
+} RemminaCellRendererPixbuf;
+
+typedef struct _RemminaCellRendererPixbufClass {
+	GtkCellRendererPixbufClass parent_class;
+
+	void (*activate)(RemminaCellRendererPixbuf * renderer);
+} RemminaCellRendererPixbufClass;
+
+GType remmina_cell_renderer_pixbuf_get_type(void)
+G_GNUC_CONST;
+
+G_DEFINE_TYPE(RemminaCellRendererPixbuf, remmina_cell_renderer_pixbuf, GTK_TYPE_CELL_RENDERER_PIXBUF)
+
+static guint remmina_cell_renderer_pixbuf_signals[1] =
+{ 0 };
+
+static gboolean remmina_cell_renderer_pixbuf_activate(GtkCellRenderer *renderer, GdkEvent *event, GtkWidget *widget,
+						      const gchar *path, const GdkRectangle *background_area, const GdkRectangle *cell_area,
+						      GtkCellRendererState flags)
+{
+	TRACE_CALL(__func__);
+	g_signal_emit(G_OBJECT(renderer), remmina_cell_renderer_pixbuf_signals[0], 0, path);
+	return TRUE;
+}
+
+static void remmina_cell_renderer_pixbuf_class_init(RemminaCellRendererPixbufClass *klass)
+{
+	TRACE_CALL(__func__);
+	GtkCellRendererClass *renderer_class = GTK_CELL_RENDERER_CLASS(klass);
+
+	renderer_class->activate = remmina_cell_renderer_pixbuf_activate;
+
+	remmina_cell_renderer_pixbuf_signals[0] = g_signal_new("activate", G_TYPE_FROM_CLASS(klass),
+		G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaCellRendererPixbufClass, activate), NULL,
+		NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
+}
+
+static void remmina_cell_renderer_pixbuf_init(RemminaCellRendererPixbuf *renderer)
+{
+	TRACE_CALL(__func__);
+	g_object_set(G_OBJECT(renderer), "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
+}
+
+static GtkCellRenderer*
+remmina_cell_renderer_pixbuf_new(void)
+{
+	TRACE_CALL(__func__);
+	GtkCellRenderer *renderer;
+
+	renderer = GTK_CELL_RENDERER(g_object_new(REMMINA_TYPE_CELL_RENDERER_PIXBUF, NULL));
+	return renderer;
+}
+
+/* --------------------- RemminaFTPClient ----------------------------*/
+G_DEFINE_TYPE( RemminaFTPClient, remmina_ftp_client, GTK_TYPE_GRID)
+
+#define BUSY_CURSOR \
+	if (GDK_IS_WINDOW(gtk_widget_get_window(GTK_WIDGET(client)))) \
+	{ \
+		gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(client)), gdk_cursor_new_for_display(gdk_display_get_default(), GDK_WATCH)); \
+		gdk_display_flush(gdk_display_get_default()); \
+	}
+
+#define NORMAL_CURSOR \
+	if (GDK_IS_WINDOW(gtk_widget_get_window(GTK_WIDGET(client)))) \
+	{ \
+		gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(client)), NULL); \
+	}
+
+struct _RemminaFTPClientPriv {
+	GtkWidget *directory_combo;
+	GtkWidget *vpaned;
+
+	GtkTreeModel *file_list_model;
+	GtkTreeModel *file_list_filter;
+	GtkTreeModel *file_list_sort;
+	GtkWidget *file_list_view;
+	gboolean file_list_show_hidden;
+
+	GtkTreeModel *task_list_model;
+	GtkWidget *task_list_view;
+
+	gchar *current_directory;
+	gchar *working_directory;
+
+	GtkWidget *file_action_widgets[10];
+	gboolean sensitive;
+	gboolean overwrite_all;
+	gboolean resume_all;
+};
+
+static gint remmina_ftp_client_taskid = 1;
+
+enum {
+	OPEN_DIR_SIGNAL, NEW_TASK_SIGNAL, CANCEL_TASK_SIGNAL, DELETE_FILE_SIGNAL, LAST_SIGNAL
+};
+
+static guint remmina_ftp_client_signals[LAST_SIGNAL] =
+{ 0 };
+
+static void remmina_ftp_client_class_init(RemminaFTPClientClass *klass)
+{
+	TRACE_CALL(__func__);
+	remmina_ftp_client_signals[OPEN_DIR_SIGNAL] = g_signal_new("open-dir", G_TYPE_FROM_CLASS(klass),
+		G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaFTPClientClass, open_dir), NULL, NULL,
+		g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
+	remmina_ftp_client_signals[NEW_TASK_SIGNAL] = g_signal_new("new-task", G_TYPE_FROM_CLASS(klass),
+		G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaFTPClientClass, new_task), NULL, NULL,
+		g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+	remmina_ftp_client_signals[CANCEL_TASK_SIGNAL] = g_signal_new("cancel-task", G_TYPE_FROM_CLASS(klass),
+		G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaFTPClientClass, cancel_task), NULL, NULL,
+		remmina_marshal_BOOLEAN__INT, G_TYPE_BOOLEAN, 1, G_TYPE_INT);
+	remmina_ftp_client_signals[DELETE_FILE_SIGNAL] = g_signal_new("delete-file", G_TYPE_FROM_CLASS(klass),
+		G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaFTPClientClass, delete_file), NULL, NULL,
+		remmina_marshal_BOOLEAN__INT_STRING, G_TYPE_BOOLEAN, 2, G_TYPE_INT, G_TYPE_STRING);
+}
+
+static void remmina_ftp_client_destroy(RemminaFTPClient *client, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*)client->priv;
+	g_free(priv->current_directory);
+	g_free(priv->working_directory);
+	g_free(priv);
+}
+
+static void remmina_ftp_client_cell_data_filetype_pixbuf(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model,
+							 GtkTreeIter *iter, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gint type;
+
+	/* Same as REMMINA_FTP_TASK_COLUMN_TYPE */
+	gtk_tree_model_get(model, iter, REMMINA_FTP_FILE_COLUMN_TYPE, &type, -1);
+
+	switch (type) {
+	case REMMINA_FTP_FILE_TYPE_DIR:
+		g_object_set(renderer, "icon-name", "folder", NULL);
+		break;
+	case REMMINA_FTP_FILE_TYPE_LINK:
+		g_object_set(renderer, "icon-name", "emblem-symbolic-link", NULL);
+		break;
+	default:
+		g_object_set(renderer, "icon-name", "text-x-generic", NULL);
+		break;
+	}
+}
+
+static void remmina_ftp_client_cell_data_progress_pixbuf(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model,
+							 GtkTreeIter *iter, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gint tasktype, status;
+
+	gtk_tree_model_get(model, iter, REMMINA_FTP_TASK_COLUMN_TASKTYPE, &tasktype, REMMINA_FTP_TASK_COLUMN_STATUS, &status,
+		-1);
+
+	switch (status) {
+	case REMMINA_FTP_TASK_STATUS_WAIT:
+		g_object_set(renderer, "icon-name", "media-playback-pause", NULL);
+		break;
+	case REMMINA_FTP_TASK_STATUS_RUN:
+		g_object_set(renderer, "icon-name",
+			(tasktype == REMMINA_FTP_TASK_TYPE_UPLOAD ? "go-up" : "go-down"), NULL);
+		break;
+	case REMMINA_FTP_TASK_STATUS_FINISH:
+		g_object_set(renderer, "icon-name", "emblem-default", NULL);
+		break;
+	case REMMINA_FTP_TASK_STATUS_ERROR:
+		g_object_set(renderer, "icon-name", "emblem-unreadable", NULL);
+		break;
+	}
+}
+
+static gchar*
+remmina_ftp_client_size_to_str(gfloat size)
+{
+	TRACE_CALL(__func__);
+
+	return g_format_size_full((guint64)size, G_FORMAT_SIZE_IEC_UNITS);
+}
+
+static void remmina_ftp_client_cell_data_size(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model,
+					      GtkTreeIter *iter, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gfloat size;
+	gchar *str;
+
+	gtk_tree_model_get(model, iter, REMMINA_FTP_FILE_COLUMN_SIZE, &size, -1);
+
+	str = remmina_ftp_client_size_to_str(size);
+	g_object_set(renderer, "text", str, NULL);
+	g_object_set(renderer, "xalign", 1.0, NULL);
+	g_free(str);
+}
+
+static void remmina_ftp_client_cell_data_permission(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model,
+						    GtkTreeIter *iter, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gint permission;
+	gchar buf[11];
+
+	gtk_tree_model_get(model, iter, REMMINA_FTP_FILE_COLUMN_PERMISSION, &permission, -1);
+
+	buf[0] = ((permission & 040000) ? 'd' : '-');
+	buf[1] = ((permission & 0400) ? 'r' : '-');
+	buf[2] = ((permission & 0200) ? 'w' : '-');
+	buf[3] = ((permission & 0100) ? 'x' : '-');
+	buf[4] = ((permission & 040) ? 'r' : '-');
+	buf[5] = ((permission & 020) ? 'w' : '-');
+	buf[6] = ((permission & 010) ? 'x' : '-');
+	buf[7] = ((permission & 04) ? 'r' : '-');
+	buf[8] = ((permission & 02) ? 'w' : '-');
+	buf[9] = ((permission & 01) ? 'x' : '-');
+	buf[10] = '\0';
+
+	g_object_set(renderer, "text", buf, NULL);
+}
+
+static void remmina_ftp_client_cell_data_modified(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model,
+						    GtkTreeIter *iter, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gint32 modified = 0;
+	GDateTime *datetime;
+	gchar* str;
+
+	gtk_tree_model_get(model, iter, REMMINA_FTP_FILE_COLUMN_MODIFIED, &modified, -1);    
+
+	datetime = g_date_time_new_from_unix_local(modified);
+	str = g_date_time_format(datetime, "\%Y-\%m-\%d \%H:\%M:\%S");
+
+	g_object_set(renderer, "text", str, NULL);
+
+	g_date_time_unref(datetime);
+	g_free(str);
+}
+
+static void remmina_ftp_client_cell_data_size_progress(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model,
+						       GtkTreeIter *iter, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gint status;
+	gfloat size, donesize;
+	gchar *strsize, *strdonesize, *str;
+
+	gtk_tree_model_get(model, iter, REMMINA_FTP_TASK_COLUMN_STATUS, &status, REMMINA_FTP_TASK_COLUMN_SIZE, &size,
+		REMMINA_FTP_TASK_COLUMN_DONESIZE, &donesize, -1);
+
+	if (status == REMMINA_FTP_TASK_STATUS_FINISH) {
+		str = remmina_ftp_client_size_to_str(size);
+	}else  {
+		strsize = remmina_ftp_client_size_to_str(size);
+		strdonesize = remmina_ftp_client_size_to_str(donesize);
+		str = g_strdup_printf("%s / %s", strdonesize, strsize);
+		g_free(strsize);
+		g_free(strdonesize);
+	}
+
+	g_object_set(renderer, "text", str, NULL);
+	g_object_set(renderer, "xalign", 1.0, NULL);
+	g_free(str);
+}
+
+static void remmina_ftp_client_cell_data_progress(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model,
+						  GtkTreeIter *iter, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gint status;
+	gfloat size, donesize;
+	gint progress;
+
+	gtk_tree_model_get(model, iter, REMMINA_FTP_TASK_COLUMN_STATUS, &status, REMMINA_FTP_TASK_COLUMN_SIZE, &size,
+		REMMINA_FTP_TASK_COLUMN_DONESIZE, &donesize, -1);
+	if (status == REMMINA_FTP_TASK_STATUS_FINISH) {
+		progress = 100;
+	}else  {
+		if (size <= 1) {
+			progress = 0;
+		}else  {
+			progress = (gint)(donesize / size * 100);
+			if (progress > 99)
+				progress = 99;
+		}
+	}
+	g_object_set(renderer, "value", progress, NULL);
+}
+
+static void remmina_ftp_client_open_dir(RemminaFTPClient *client, const gchar *dir)
+{
+	TRACE_CALL(__func__);
+	BUSY_CURSOR
+	g_signal_emit(G_OBJECT(client), remmina_ftp_client_signals[OPEN_DIR_SIGNAL], 0, dir);
+	NORMAL_CURSOR
+}
+
+static void remmina_ftp_client_dir_on_activate(GtkWidget *widget, RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	remmina_ftp_client_open_dir(client, gtk_entry_get_text(GTK_ENTRY(widget)));
+}
+
+static void remmina_ftp_client_dir_on_changed(GtkWidget *widget, RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *entry = gtk_bin_get_child(GTK_BIN(widget));
+
+	if (!gtk_widget_is_focus(entry)) {
+		gtk_widget_grab_focus(entry);
+		/* If the text was changed but the entry is not the focus, it should be changed by the drop-down list.
+		   Not sure this will always work in the future, but it works right now :) */
+		remmina_ftp_client_open_dir(client, gtk_entry_get_text(GTK_ENTRY(entry)));
+	}
+}
+
+static void remmina_ftp_client_set_file_action_sensitive(RemminaFTPClient *client, gboolean sensitive)
+{
+	TRACE_CALL(__func__);
+	gint i;
+	for (i = 0; client->priv->file_action_widgets[i]; i++) {
+		gtk_widget_set_sensitive(client->priv->file_action_widgets[i], sensitive);
+	}
+	client->priv->sensitive = sensitive;
+}
+
+static void remmina_ftp_client_file_selection_on_changed(GtkTreeSelection *selection, RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	GList *list;
+
+	list = gtk_tree_selection_get_selected_rows(selection, NULL);
+	remmina_ftp_client_set_file_action_sensitive(client, (list ? TRUE : FALSE));
+	g_list_free(list);
+}
+
+static gchar*
+remmina_ftp_client_get_download_dir(RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*)client->priv;
+	GtkFileChooserNative *dialog;
+	gchar *localdir = NULL;
+
+	dialog = gtk_file_chooser_native_new(_("Choose download location"),
+		GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(client))), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
+		_("_OK"), _("_Cancel"));
+	if (priv->working_directory) {
+		gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), priv->working_directory);
+	}
+	if (gtk_native_dialog_run(GTK_NATIVE_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
+		g_free(priv->working_directory);
+		priv->working_directory = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(dialog));
+		localdir = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
+	}
+	gtk_native_dialog_destroy(GTK_NATIVE_DIALOG(dialog));
+	return localdir;
+}
+
+static void remmina_ftp_client_download(RemminaFTPClient *client, GtkTreeIter *piter, const gchar *localdir)
+{
+	TRACE_CALL(__func__);
+	RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*)client->priv;
+	GtkListStore *store = GTK_LIST_STORE(priv->task_list_model);
+	GtkTreeIter iter;
+	gint type;
+	gchar *name;
+	gfloat size;
+
+	gtk_tree_model_get(priv->file_list_sort, piter, REMMINA_FTP_FILE_COLUMN_TYPE, &type, REMMINA_FTP_FILE_COLUMN_NAME,
+		&name, REMMINA_FTP_FILE_COLUMN_SIZE, &size, -1);
+
+	gtk_list_store_append(store, &iter);
+	gtk_list_store_set(store, &iter, REMMINA_FTP_TASK_COLUMN_TYPE, type, REMMINA_FTP_TASK_COLUMN_NAME, name,
+		REMMINA_FTP_TASK_COLUMN_SIZE, size, REMMINA_FTP_TASK_COLUMN_TASKID, remmina_ftp_client_taskid++,
+		REMMINA_FTP_TASK_COLUMN_TASKTYPE, REMMINA_FTP_TASK_TYPE_DOWNLOAD, REMMINA_FTP_TASK_COLUMN_REMOTEDIR,
+		priv->current_directory, REMMINA_FTP_TASK_COLUMN_LOCALDIR, localdir, REMMINA_FTP_TASK_COLUMN_STATUS,
+		REMMINA_FTP_TASK_STATUS_WAIT, REMMINA_FTP_TASK_COLUMN_DONESIZE, 0.0, REMMINA_FTP_TASK_COLUMN_TOOLTIP,
+		NULL, -1);
+
+	g_free(name);
+
+	g_signal_emit(G_OBJECT(client), remmina_ftp_client_signals[NEW_TASK_SIGNAL], 0);
+}
+
+static gboolean remmina_ftp_client_task_list_on_query_tooltip(GtkWidget *widget, gint x, gint y, gboolean keyboard_tip,
+							      GtkTooltip *tooltip, RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*)client->priv;
+	GtkTreeIter iter;
+	GtkTreePath *path = NULL;
+	gchar *tmp;
+
+	if (!gtk_tree_view_get_tooltip_context(GTK_TREE_VIEW(priv->task_list_view), &x, &y, keyboard_tip, NULL, &path, &iter)) {
+		return FALSE;
+	}
+
+	gtk_tree_model_get(priv->task_list_model, &iter, REMMINA_FTP_TASK_COLUMN_TOOLTIP, &tmp, -1);
+	if (!tmp)
+		return FALSE;
+
+	gtk_tooltip_set_text(tooltip, tmp);
+
+	gtk_tree_view_set_tooltip_row(GTK_TREE_VIEW(priv->task_list_view), tooltip, path);
+
+	gtk_tree_path_free(path);
+	g_free(tmp);
+
+	return TRUE;
+}
+
+static void remmina_ftp_client_action_parent(GObject *object, RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	remmina_ftp_client_open_dir(client, "..");
+}
+
+static void remmina_ftp_client_action_home(GObject *object, RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	remmina_ftp_client_open_dir(client, NULL);
+}
+
+static void remmina_ftp_client_action_refresh(GObject *object, RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	remmina_ftp_client_open_dir(client, ".");
+}
+
+static void remmina_ftp_client_action_download(GObject *object, RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*)client->priv;
+	GtkTreeSelection *selection;
+	gchar *localdir;
+	GList *list, *list_iter;
+	GtkTreeIter iter;
+
+	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->file_list_view));
+	if (!selection)
+		return;
+	list = gtk_tree_selection_get_selected_rows(selection, NULL);
+	if (!list)
+		return;
+
+	localdir = remmina_ftp_client_get_download_dir(client);
+	if (!localdir) {
+		g_list_free(list);
+		return;
+	}
+
+	list_iter = g_list_first(list);
+	while (list_iter) {
+		gtk_tree_model_get_iter(priv->file_list_sort, &iter, (GtkTreePath*)list_iter->data);
+		remmina_ftp_client_download(client, &iter, localdir);
+		list_iter = g_list_next(list_iter);
+	}
+	g_list_free(list);
+	g_free(localdir);
+}
+
+static void remmina_ftp_client_action_delete(GObject *object, RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*)client->priv;
+	GtkWidget *dialog;
+	GtkTreeSelection *selection;
+	GList *list, *list_iter;
+	GtkTreeIter iter;
+	gint type;
+	gchar *name;
+	gchar *path;
+	gint response;
+	gboolean ret = TRUE;
+
+	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->file_list_view));
+	if (!selection)
+		return;
+	list = gtk_tree_selection_get_selected_rows(selection, NULL);
+	if (!list)
+		return;
+
+	dialog = gtk_message_dialog_new(GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(client))), GTK_DIALOG_MODAL,
+		GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, _("Are you sure to delete the selected files on server?"));
+	response = gtk_dialog_run(GTK_DIALOG(dialog));
+	gtk_widget_destroy(dialog);
+	if (response != GTK_RESPONSE_YES)
+		return;
+
+	BUSY_CURSOR
+
+		list_iter = g_list_first(list);
+	while (list_iter) {
+		gtk_tree_model_get_iter(priv->file_list_sort, &iter, (GtkTreePath*)list_iter->data);
+
+		gtk_tree_model_get(priv->file_list_sort, &iter, REMMINA_FTP_FILE_COLUMN_TYPE, &type,
+			REMMINA_FTP_FILE_COLUMN_NAME, &name, -1);
+
+		path = remmina_public_combine_path(priv->current_directory, name);
+		g_signal_emit(G_OBJECT(client), remmina_ftp_client_signals[DELETE_FILE_SIGNAL], 0, type, path, &ret);
+		g_free(name);
+		g_free(path);
+		if (!ret)
+			break;
+
+		list_iter = g_list_next(list_iter);
+	}
+	g_list_free(list);
+
+	NORMAL_CURSOR
+
+	if (ret) {
+		remmina_ftp_client_action_refresh(object, client);
+	}
+}
+
+static void remmina_ftp_client_upload_folder_on_toggled(GtkToggleButton *togglebutton, GtkWidget *widget)
+{
+	TRACE_CALL(__func__);
+	gtk_file_chooser_set_action(
+		GTK_FILE_CHOOSER(widget),
+		gtk_toggle_button_get_active(togglebutton) ?
+		GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER : GTK_FILE_CHOOSER_ACTION_OPEN);
+}
+
+static void remmina_ftp_client_action_upload(GObject *object, RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*)client->priv;
+	GtkListStore *store = GTK_LIST_STORE(priv->task_list_model);
+	GtkTreeIter iter;
+	GtkWidget *dialog;
+	GtkWidget *upload_folder_check;
+	gint type;
+	GSList *files = NULL;
+	GSList *element;
+	gchar *path;
+	gchar *dir, *name;
+	struct stat st;
+
+	dialog = gtk_file_chooser_dialog_new(_("Choose a file to upload"),
+		GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(client))), GTK_FILE_CHOOSER_ACTION_OPEN, _("_Cancel"),
+		GTK_RESPONSE_CANCEL, _("Upload"), GTK_RESPONSE_ACCEPT, NULL);
+	gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
+	if (priv->working_directory) {
+		gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), priv->working_directory);
+	}
+	upload_folder_check = gtk_check_button_new_with_label(_("Upload folder"));
+	gtk_widget_show(upload_folder_check);
+	g_signal_connect(G_OBJECT(upload_folder_check), "toggled", G_CALLBACK(remmina_ftp_client_upload_folder_on_toggled),
+		dialog);
+	gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dialog), upload_folder_check);
+	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
+		g_free(priv->working_directory);
+		priv->working_directory = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(dialog));
+		files = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
+	}
+	type = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(upload_folder_check)) ?
+	       REMMINA_FTP_FILE_TYPE_DIR : REMMINA_FTP_FILE_TYPE_FILE;
+	gtk_widget_destroy(dialog);
+	if (!files)
+		return;
+
+	for (element = files; element; element = element->next) {
+		path = (gchar*)element->data;
+
+		if (g_stat(path, &st) < 0)
+			continue;
+
+		name = g_strrstr(path, "/");
+		if (name) {
+			*name++ = '\0';
+			dir = path;
+		}else  {
+			name = path;
+			dir = NULL;
+		}
+
+		gtk_list_store_append(store, &iter);
+		gtk_list_store_set(store, &iter, REMMINA_FTP_TASK_COLUMN_TYPE, type, REMMINA_FTP_TASK_COLUMN_NAME, name,
+			REMMINA_FTP_TASK_COLUMN_SIZE, (gfloat)st.st_size, REMMINA_FTP_TASK_COLUMN_TASKID,
+			remmina_ftp_client_taskid++, REMMINA_FTP_TASK_COLUMN_TASKTYPE, REMMINA_FTP_TASK_TYPE_UPLOAD,
+			REMMINA_FTP_TASK_COLUMN_REMOTEDIR, priv->current_directory, REMMINA_FTP_TASK_COLUMN_LOCALDIR,
+			dir, REMMINA_FTP_TASK_COLUMN_STATUS, REMMINA_FTP_TASK_STATUS_WAIT,
+			REMMINA_FTP_TASK_COLUMN_DONESIZE, 0.0, REMMINA_FTP_TASK_COLUMN_TOOLTIP, NULL, -1);
+
+		g_free(path);
+	}
+
+	g_slist_free(files);
+
+	g_signal_emit(G_OBJECT(client), remmina_ftp_client_signals[NEW_TASK_SIGNAL], 0);
+}
+
+static void remmina_ftp_client_popup_menu(RemminaFTPClient *client, GdkEventButton *event)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *menu;
+	GtkWidget *menuitem;
+	GtkWidget *image;
+
+	menu = gtk_menu_new();
+
+	menuitem = gtk_menu_item_new_with_label(_("Download"));
+	gtk_widget_show(menuitem);
+	image = gtk_image_new_from_icon_name("org.remmina.Remmina-document-save-symbolic", GTK_ICON_SIZE_MENU);
+	gtk_widget_show(image);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
+	g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(remmina_ftp_client_action_download), client);
+
+	menuitem = gtk_menu_item_new_with_label(_("Upload"));
+	gtk_widget_show(menuitem);
+	image = gtk_image_new_from_icon_name("org.remmina.Remmina-document-send-symbolic", GTK_ICON_SIZE_MENU);
+	gtk_widget_show(image);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
+	g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(remmina_ftp_client_action_upload), client);
+
+	menuitem = gtk_menu_item_new_with_mnemonic(_("_Delete"));
+	gtk_widget_show(menuitem);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
+	g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(remmina_ftp_client_action_delete), client);
+
+#if GTK_CHECK_VERSION(3, 22, 0)
+	gtk_menu_popup_at_pointer(GTK_MENU(menu), (GdkEvent*)event);
+#else
+	gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, event->button, event->time);
+#endif
+}
+
+static gboolean remmina_ftp_client_file_list_on_button_press(GtkWidget *widget, GdkEventButton *event, RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*)client->priv;
+	GList *list;
+	GtkTreeIter iter;
+	gint type;
+	gchar *name;
+	gchar *localdir;
+
+	if (event->button == 3) {
+		remmina_ftp_client_popup_menu(client, event);
+	}else if (event->button == 1 && event->type == GDK_2BUTTON_PRESS) {
+		list = gtk_tree_selection_get_selected_rows(
+			gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->file_list_view)), NULL);
+		if (list) {
+			gtk_tree_model_get_iter(priv->file_list_sort, &iter, (GtkTreePath*)list->data);
+			gtk_tree_model_get(priv->file_list_sort, &iter, REMMINA_FTP_FILE_COLUMN_TYPE, &type,
+				REMMINA_FTP_FILE_COLUMN_NAME, &name, -1);
+			switch (type) {
+			case REMMINA_FTP_FILE_TYPE_DIR:
+				remmina_ftp_client_open_dir(client, name);
+				break;
+			case REMMINA_FTP_FILE_TYPE_LINK:
+				remmina_ftp_client_open_dir(client, name);
+				break;
+			case REMMINA_FTP_FILE_TYPE_FILE:
+			default:
+				localdir = remmina_ftp_client_get_download_dir(client);
+				if (localdir) {
+					remmina_ftp_client_download(client, &iter, localdir);
+					g_free(localdir);
+				}
+				break;
+			}
+			g_list_free(list);
+			g_free(name);
+		}
+	}
+
+	return FALSE;
+}
+
+static void remmina_ftp_client_task_list_cell_on_activate(GtkCellRenderer *renderer, gchar *path, RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*)client->priv;
+	GtkTreeIter iter;
+	GtkTreePath *treepath;
+	gint taskid;
+	gboolean ret = FALSE;
+
+	treepath = gtk_tree_path_new_from_string(path);
+	gtk_tree_model_get_iter(priv->task_list_model, &iter, treepath);
+	gtk_tree_path_free(treepath);
+
+	gtk_tree_model_get(priv->task_list_model, &iter, REMMINA_FTP_TASK_COLUMN_TASKID, &taskid, -1);
+
+	g_signal_emit(G_OBJECT(client), remmina_ftp_client_signals[CANCEL_TASK_SIGNAL], 0, taskid, &ret);
+
+	if (ret) {
+		gtk_list_store_remove(GTK_LIST_STORE(priv->task_list_model), &iter);
+	}
+}
+
+static GtkWidget* remmina_ftp_client_create_toolbar(RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *box;
+	GtkWidget *button;
+	gint i = 0;
+
+	box = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
+	gtk_button_box_set_layout(GTK_BUTTON_BOX(box), GTK_BUTTONBOX_START);
+	gtk_grid_attach(GTK_GRID(client), box, 0, 0, 1, 1);
+
+	button = gtk_button_new_with_label(_("Home"));
+	gtk_widget_set_tooltip_text(button, _("Go to home folder"));
+	gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 0);
+	g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remmina_ftp_client_action_home), client);
+
+	button = gtk_button_new_with_label(_("Up"));
+	gtk_widget_set_tooltip_text(button, _("Go to parent folder"));
+	gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 0);
+	g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remmina_ftp_client_action_parent), client);
+
+	button = gtk_button_new_with_label(_("Refresh"));
+	gtk_widget_set_tooltip_text(button, _("Refresh current folder"));
+	gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 0);
+	g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remmina_ftp_client_action_refresh), client);
+
+	button = gtk_button_new_with_label(_("Download"));
+	gtk_widget_set_tooltip_text(button, _("Download from server"));
+	gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 0);
+	g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remmina_ftp_client_action_download), client);
+
+	client->priv->file_action_widgets[i++] = button;
+
+	button = gtk_button_new_with_label(_("Upload"));
+	gtk_widget_set_tooltip_text(button, _("Upload to server"));
+	gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 0);
+	g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remmina_ftp_client_action_upload), client);
+
+	button = gtk_button_new_with_label(_("Delete"));
+	gtk_widget_set_tooltip_text(button, _("Delete files on server"));
+	gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 0);
+	g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remmina_ftp_client_action_delete), client);
+
+	client->priv->file_action_widgets[i++] = button;
+	gtk_widget_show_all(box);
+
+	return box;
+}
+
+void remmina_ftp_client_set_show_hidden(RemminaFTPClient *client, gboolean show_hidden)
+{
+	TRACE_CALL(__func__);
+	client->priv->file_list_show_hidden = show_hidden;
+	gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(client->priv->file_list_filter));
+}
+
+static gboolean remmina_ftp_client_filter_visible_func(GtkTreeModel *model, GtkTreeIter *iter, RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	gchar *name;
+	gboolean result = TRUE;
+
+	if (client->priv->file_list_show_hidden)
+		return TRUE;
+
+	gtk_tree_model_get(model, iter, REMMINA_FTP_FILE_COLUMN_NAME, &name, -1);
+	if (name && name[0] == '.') {
+		result = FALSE;
+	}
+	g_free(name);
+	return result;
+}
+
+/* Set the overwrite_all status */
+void remmina_ftp_client_set_overwrite_status(RemminaFTPClient *client, gboolean status)
+{
+	TRACE_CALL(__func__);
+	client->priv->overwrite_all = status;
+}
+
+/* Get the overwrite_all status */
+gboolean remmina_ftp_client_get_overwrite_status(RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	return client->priv->overwrite_all;
+}
+
+/* Set the resume status */
+void remmina_ftp_client_set_resume_status(RemminaFTPClient *client, gboolean status)
+{
+	TRACE_CALL(__func__);
+	client->priv->resume_all = status;
+}
+
+/* Get the resume status */
+gboolean remmina_ftp_client_get_resume_status(RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	return client->priv->resume_all;
+}
+
+
+static void remmina_ftp_client_init(RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	RemminaFTPClientPriv *priv;
+	GtkWidget *vpaned;
+	GtkWidget *toolbar;
+	GtkWidget *scrolledwindow;
+	GtkWidget *widget;
+	GtkCellRenderer *renderer;
+	GtkTreeViewColumn *column;
+	GtkWidget *vbox;
+
+	priv = g_new0(RemminaFTPClientPriv, 1);
+	client->priv = priv;
+
+	/* Initialize overwrite status to FALSE */
+	client->priv->overwrite_all = FALSE;
+	/* Initialize resume status to FALSE */
+	client->priv->resume_all = FALSE;
+
+	/* Main container */
+	gtk_widget_set_vexpand(GTK_WIDGET(client), TRUE);
+	gtk_widget_set_hexpand(GTK_WIDGET(client), TRUE);
+
+	/* Toolbar */
+	toolbar = remmina_ftp_client_create_toolbar(client);
+	gtk_widget_set_hexpand(toolbar, TRUE);
+
+	/* The Paned to separate File List and Task List */
+	vpaned = gtk_paned_new(GTK_ORIENTATION_VERTICAL);
+	gtk_widget_set_vexpand(GTK_WIDGET(vpaned), TRUE);
+	gtk_widget_set_hexpand(GTK_WIDGET(vpaned), TRUE);
+	gtk_widget_show(vpaned);
+	gtk_grid_attach_next_to(GTK_GRID(client), vpaned, toolbar, GTK_POS_BOTTOM, 1, 1);
+
+	priv->vpaned = vpaned;
+
+	/* Remote */
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+	gtk_widget_show(vbox);
+	gtk_paned_pack1(GTK_PANED(vpaned), vbox, TRUE, FALSE);
+
+	/* Remote Directory */
+	widget = gtk_combo_box_text_new_with_entry();
+	gtk_widget_show(widget);
+	gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), "/");
+	gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0);
+
+	priv->directory_combo = widget;
+
+	/* Remote File List */
+	scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
+	gtk_widget_show(scrolledwindow);
+	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
+	gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0);
+
+	widget = gtk_tree_view_new();
+	gtk_widget_show(widget);
+	gtk_container_add(GTK_CONTAINER(scrolledwindow), widget);
+
+	gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(widget)), GTK_SELECTION_MULTIPLE);
+
+	priv->file_list_view = widget;
+
+	/* Remote File List - Columns */
+	column = gtk_tree_view_column_new();
+	gtk_tree_view_column_set_title(column, _("Filename"));
+	gtk_tree_view_column_set_expand(column, TRUE);
+	gtk_tree_view_column_set_resizable(column, TRUE);
+	gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_NAME_SORT);
+	renderer = gtk_cell_renderer_pixbuf_new();
+	gtk_tree_view_column_pack_start(column, renderer, FALSE);
+	gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_filetype_pixbuf, NULL, NULL);
+	renderer = gtk_cell_renderer_text_new();
+	gtk_tree_view_column_pack_start(column, renderer, FALSE);
+	gtk_tree_view_column_add_attribute(column, renderer, "text", REMMINA_FTP_FILE_COLUMN_NAME);
+	gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
+
+	renderer = gtk_cell_renderer_text_new();
+	column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, NULL);
+	gtk_tree_view_column_set_alignment(column, 1.0);
+	gtk_tree_view_column_set_resizable(column, TRUE);
+	gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_size, NULL, NULL);
+	gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_SIZE);
+	gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
+
+	renderer = gtk_cell_renderer_text_new();
+	column = gtk_tree_view_column_new_with_attributes(_("User"), renderer, "text", REMMINA_FTP_FILE_COLUMN_USER, NULL);
+	gtk_tree_view_column_set_resizable(column, TRUE);
+	gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_USER);
+	gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
+
+	renderer = gtk_cell_renderer_text_new();
+	column = gtk_tree_view_column_new_with_attributes(_("Group"), renderer, "text", REMMINA_FTP_FILE_COLUMN_GROUP, NULL);
+	gtk_tree_view_column_set_resizable(column, TRUE);
+	gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_GROUP);
+	gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
+
+	renderer = gtk_cell_renderer_text_new();
+	column = gtk_tree_view_column_new_with_attributes(_("Permission"), renderer, "text", REMMINA_FTP_FILE_COLUMN_PERMISSION,
+		NULL);
+	gtk_tree_view_column_set_resizable(column, TRUE);
+	gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_permission, NULL, NULL);
+	gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_PERMISSION);
+	gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
+
+	renderer = gtk_cell_renderer_text_new();
+	column = gtk_tree_view_column_new_with_attributes(_("Modified"), renderer, "text", REMMINA_FTP_FILE_COLUMN_MODIFIED,
+		NULL);
+	gtk_tree_view_column_set_resizable(column, TRUE);
+	gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_modified, NULL, NULL);
+	gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_MODIFIED);
+	gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
+
+	/* Remote File List - Model */
+	priv->file_list_model = GTK_TREE_MODEL(
+		gtk_list_store_new(REMMINA_FTP_FILE_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_STRING,
+			G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING));
+
+	priv->file_list_filter = gtk_tree_model_filter_new(priv->file_list_model, NULL);
+	gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(priv->file_list_filter),
+		(GtkTreeModelFilterVisibleFunc)remmina_ftp_client_filter_visible_func, client, NULL);
+
+	priv->file_list_sort = gtk_tree_model_sort_new_with_model(priv->file_list_filter);
+	gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(priv->file_list_sort), REMMINA_FTP_FILE_COLUMN_NAME_SORT,
+		GTK_SORT_ASCENDING);
+	gtk_tree_view_set_model(GTK_TREE_VIEW(priv->file_list_view), priv->file_list_sort);
+
+	/* Task List */
+	scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
+	gtk_widget_show(scrolledwindow);
+	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
+	gtk_paned_pack2(GTK_PANED(vpaned), scrolledwindow, FALSE, TRUE);
+
+	widget = gtk_tree_view_new();
+	gtk_widget_show(widget);
+	gtk_container_add(GTK_CONTAINER(scrolledwindow), widget);
+	g_object_set(widget, "has-tooltip", TRUE, NULL);
+
+	priv->task_list_view = widget;
+
+	/* Task List - Columns */
+	column = gtk_tree_view_column_new();
+	gtk_tree_view_column_set_title(column, _("Filename"));
+	gtk_tree_view_column_set_resizable(column, TRUE);
+	gtk_tree_view_column_set_expand(column, TRUE);
+	gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_NAME);
+	renderer = gtk_cell_renderer_pixbuf_new();
+	gtk_tree_view_column_pack_start(column, renderer, FALSE);
+	gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_progress_pixbuf, NULL, NULL);
+	renderer = gtk_cell_renderer_pixbuf_new();
+	gtk_tree_view_column_pack_start(column, renderer, FALSE);
+	gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_filetype_pixbuf, NULL, NULL);
+	renderer = gtk_cell_renderer_text_new();
+	gtk_tree_view_column_pack_start(column, renderer, FALSE);
+	gtk_tree_view_column_add_attribute(column, renderer, "text", REMMINA_FTP_FILE_COLUMN_NAME);
+	gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
+
+	renderer = gtk_cell_renderer_text_new();
+	column = gtk_tree_view_column_new_with_attributes(_("Remote"), renderer, "text", REMMINA_FTP_TASK_COLUMN_REMOTEDIR,
+		NULL);
+	gtk_tree_view_column_set_resizable(column, TRUE);
+	gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_REMOTEDIR);
+	gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
+
+	renderer = gtk_cell_renderer_text_new();
+	column = gtk_tree_view_column_new_with_attributes(_("Local"), renderer, "text", REMMINA_FTP_TASK_COLUMN_LOCALDIR, NULL);
+	gtk_tree_view_column_set_resizable(column, TRUE);
+	gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_LOCALDIR);
+	gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
+
+	renderer = gtk_cell_renderer_text_new();
+	column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, NULL);
+	gtk_tree_view_column_set_alignment(column, 1.0);
+	gtk_tree_view_column_set_resizable(column, TRUE);
+	gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_size_progress, NULL, NULL);
+	gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_SIZE);
+	gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
+
+	renderer = gtk_cell_renderer_progress_new();
+	column = gtk_tree_view_column_new_with_attributes(_("Progress"), renderer, NULL);
+	gtk_tree_view_column_set_resizable(column, TRUE);
+	gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_progress, NULL, NULL);
+	gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
+
+	renderer = remmina_cell_renderer_pixbuf_new();
+	column = gtk_tree_view_column_new_with_attributes(NULL, renderer, NULL);
+	g_object_set(G_OBJECT(renderer), "icon-name", "process-stop", NULL);
+	gtk_tree_view_column_set_resizable(column, FALSE);
+	gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
+
+	g_signal_connect(G_OBJECT(renderer), "activate", G_CALLBACK(remmina_ftp_client_task_list_cell_on_activate), client);
+
+	/* Task List - Model */
+	priv->task_list_model = GTK_TREE_MODEL(
+		gtk_list_store_new(REMMINA_FTP_TASK_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_INT,
+			G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_FLOAT, G_TYPE_STRING));
+	gtk_tree_view_set_model(GTK_TREE_VIEW(priv->task_list_view), priv->task_list_model);
+
+	/* Setup the internal signals */
+	g_signal_connect(G_OBJECT(client), "destroy", G_CALLBACK(remmina_ftp_client_destroy), NULL);
+	g_signal_connect(G_OBJECT(gtk_bin_get_child(GTK_BIN(priv->directory_combo))), "activate",
+		G_CALLBACK(remmina_ftp_client_dir_on_activate), client);
+	g_signal_connect(G_OBJECT(priv->directory_combo), "changed", G_CALLBACK(remmina_ftp_client_dir_on_changed), client);
+	g_signal_connect(G_OBJECT(priv->file_list_view), "button-press-event",
+		G_CALLBACK(remmina_ftp_client_file_list_on_button_press), client);
+	g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->file_list_view))), "changed",
+		G_CALLBACK(remmina_ftp_client_file_selection_on_changed), client);
+	g_signal_connect(G_OBJECT(priv->task_list_view), "query-tooltip",
+		G_CALLBACK(remmina_ftp_client_task_list_on_query_tooltip), client);
+}
+
+GtkWidget*
+remmina_ftp_client_new(void)
+{
+	TRACE_CALL(__func__);
+	RemminaFTPClient *client;
+
+	client = REMMINA_FTP_CLIENT(g_object_new(REMMINA_TYPE_FTP_CLIENT, NULL));
+
+	return GTK_WIDGET(client);
+}
+
+void remmina_ftp_client_save_state(RemminaFTPClient *client, RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	gint pos;
+
+	pos = gtk_paned_get_position(GTK_PANED(client->priv->vpaned));
+	remmina_file_set_int(remminafile, "ftp_vpanedpos", pos);
+}
+
+void remmina_ftp_client_load_state(RemminaFTPClient *client, RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	gint pos;
+	GtkAllocation a;
+
+	pos = remmina_file_get_int(remminafile, "ftp_vpanedpos", 0);
+	if (pos) {
+		gtk_widget_get_allocation(client->priv->vpaned, &a);
+		if (a.height > 0 && pos > a.height - 60) {
+			pos = a.height - 60;
+		}
+		gtk_paned_set_position(GTK_PANED(client->priv->vpaned), pos);
+	}
+}
+
+void remmina_ftp_client_clear_file_list(RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*)client->priv;
+
+	gtk_list_store_clear(GTK_LIST_STORE(priv->file_list_model));
+	remmina_ftp_client_set_file_action_sensitive(client, FALSE);
+}
+
+void remmina_ftp_client_add_file(RemminaFTPClient *client, ...)
+{
+	TRACE_CALL(__func__);
+	RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*)client->priv;
+	GtkListStore *store = GTK_LIST_STORE(priv->file_list_model);
+	GtkTreeIter iter;
+	va_list args;
+	gint type;
+	gchar *name;
+	gchar *ptr;
+
+	va_start(args, client);
+	gtk_list_store_append(store, &iter);
+	gtk_list_store_set_valist(store, &iter, args);
+	va_end(args);
+
+	gtk_tree_model_get(GTK_TREE_MODEL(store), &iter,
+		REMMINA_FTP_FILE_COLUMN_TYPE, &type,
+		REMMINA_FTP_FILE_COLUMN_NAME, &name,
+		-1);
+
+	ptr = g_strdup_printf("%i%s", type, name);
+	gtk_list_store_set(store, &iter, REMMINA_FTP_FILE_COLUMN_NAME_SORT, ptr, -1);
+	g_free(ptr);
+	g_free(name);
+}
+
+void remmina_ftp_client_set_dir(RemminaFTPClient *client, const gchar *dir)
+{
+	TRACE_CALL(__func__);
+	RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*)client->priv;
+	GtkTreeModel *model;
+	GtkTreeIter iter;
+	gboolean ret;
+	gchar *t;
+
+	if (priv->current_directory && g_strcmp0(priv->current_directory, dir) == 0)
+		return;
+
+	model = gtk_combo_box_get_model(GTK_COMBO_BOX(priv->directory_combo));
+	for (ret = gtk_tree_model_get_iter_first(model, &iter); ret; ret = gtk_tree_model_iter_next(model, &iter)) {
+		gtk_tree_model_get(model, &iter, 0, &t, -1);
+		if (g_strcmp0(t, dir) == 0) {
+			gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
+			g_free(t);
+			break;
+		}
+		g_free(t);
+	}
+
+	gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(priv->directory_combo), dir);
+	gtk_combo_box_set_active(GTK_COMBO_BOX(priv->directory_combo), 0);
+
+	g_free(priv->current_directory);
+	priv->current_directory = g_strdup(dir);
+}
+
+gchar*
+remmina_ftp_client_get_dir(RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*)client->priv;
+
+	return g_strdup(priv->current_directory);
+}
+
+RemminaFTPTask*
+remmina_ftp_client_get_waiting_task(RemminaFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*)client->priv;
+	GtkTreePath *path;
+	GtkTreeIter iter;
+	RemminaFTPTask task;
+
+	if ( !remmina_masterthread_exec_is_main_thread() ) {
+		/* Allow the execution of this function from a non main thread */
+		RemminaMTExecData *d;
+		RemminaFTPTask* retval;
+		d = (RemminaMTExecData*)g_malloc( sizeof(RemminaMTExecData) );
+		d->func = FUNC_FTP_CLIENT_GET_WAITING_TASK;
+		d->p.ftp_client_get_waiting_task.client = client;
+		remmina_masterthread_exec_and_wait(d);
+		retval = d->p.ftp_client_get_waiting_task.retval;
+		g_free(d);
+		return retval;
+	}
+
+	if (!gtk_tree_model_get_iter_first(priv->task_list_model, &iter))
+		return NULL;
+
+	while (1) {
+		gtk_tree_model_get(priv->task_list_model, &iter, REMMINA_FTP_TASK_COLUMN_TYPE, &task.type,
+			REMMINA_FTP_TASK_COLUMN_NAME, &task.name, REMMINA_FTP_TASK_COLUMN_SIZE, &task.size,
+			REMMINA_FTP_TASK_COLUMN_TASKID, &task.taskid, REMMINA_FTP_TASK_COLUMN_TASKTYPE, &task.tasktype,
+			REMMINA_FTP_TASK_COLUMN_REMOTEDIR, &task.remotedir, REMMINA_FTP_TASK_COLUMN_LOCALDIR,
+			&task.localdir, REMMINA_FTP_TASK_COLUMN_STATUS, &task.status, REMMINA_FTP_TASK_COLUMN_DONESIZE,
+			&task.donesize, REMMINA_FTP_TASK_COLUMN_TOOLTIP, &task.tooltip, -1);
+		if (task.status == REMMINA_FTP_TASK_STATUS_WAIT) {
+			path = gtk_tree_model_get_path(priv->task_list_model, &iter);
+			task.rowref = gtk_tree_row_reference_new(priv->task_list_model, path);
+			gtk_tree_path_free(path);
+#if GLIB_CHECK_VERSION(2,68,0)
+			return (RemminaFTPTask*)g_memdup2(&task, sizeof(RemminaFTPTask));
+#else
+			return (RemminaFTPTask*)g_memdup(&task, sizeof(RemminaFTPTask));
+#endif
+		}
+		if (!gtk_tree_model_iter_next(priv->task_list_model, &iter))
+			break;
+	}
+
+	return NULL;
+}
+
+void remmina_ftp_client_update_task(RemminaFTPClient *client, RemminaFTPTask* task)
+{
+	TRACE_CALL(__func__);
+	RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*)client->priv;
+	GtkListStore *store = GTK_LIST_STORE(priv->task_list_model);
+	GtkTreePath *path;
+	GtkTreeIter iter;
+
+	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_FTP_CLIENT_UPDATE_TASK;
+		d->p.ftp_client_update_task.client = client;
+		d->p.ftp_client_update_task.task = task;
+		remmina_masterthread_exec_and_wait(d);
+		g_free(d);
+		return;
+	}
+
+
+
+	path = gtk_tree_row_reference_get_path(task->rowref);
+	if (path == NULL)
+		return;
+	gtk_tree_model_get_iter(priv->task_list_model, &iter, path);
+	gtk_tree_path_free(path);
+	gtk_list_store_set(store, &iter, REMMINA_FTP_TASK_COLUMN_SIZE, task->size, REMMINA_FTP_TASK_COLUMN_STATUS, task->status,
+		REMMINA_FTP_TASK_COLUMN_DONESIZE, task->donesize, REMMINA_FTP_TASK_COLUMN_TOOLTIP, task->tooltip, -1);
+}
+
+void remmina_ftp_task_free(RemminaFTPTask *task)
+{
+	TRACE_CALL(__func__);
+	if (task) {
+		g_free(task->name);
+		g_free(task->remotedir);
+		g_free(task->localdir);
+		g_free(task->tooltip);
+		g_free(task);
+	}
+}
+
diff --git a/src/remmina_ftp_client.h b/src/remmina_ftp_client.h
new file mode 100644
index 0000000..0b73c91
--- /dev/null
+++ b/src/remmina_ftp_client.h
@@ -0,0 +1,158 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009-2010 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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include "remmina_file.h"
+
+G_BEGIN_DECLS
+
+#define REMMINA_TYPE_FTP_CLIENT               (remmina_ftp_client_get_type())
+#define REMMINA_FTP_CLIENT(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), REMMINA_TYPE_FTP_CLIENT, RemminaFTPClient))
+#define REMMINA_FTP_CLIENT_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), REMMINA_TYPE_FTP_CLIENT, RemminaFTPClientClass))
+#define REMMINA_IS_FTP_CLIENT(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), REMMINA_TYPE_FTP_CLIENT))
+#define REMMINA_IS_FTP_CLIENT_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), REMMINA_TYPE_FTP_CLIENT))
+#define REMMINA_FTP_CLIENT_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), REMMINA_TYPE_FTP_CLIENT, RemminaFTPClientClass))
+
+typedef struct _RemminaFTPClientPriv RemminaFTPClientPriv;
+
+typedef struct _RemminaFTPClient {
+	GtkBox			vbox;
+
+	RemminaFTPClientPriv *	priv;
+} RemminaFTPClient;
+
+typedef struct _RemminaFTPClientClass {
+	GtkBoxClass parent_class;
+
+	void (*open_dir)(RemminaFTPClient *client);
+	void (*new_task)(RemminaFTPClient *client);
+	void (*cancel_task)(RemminaFTPClient *client);
+	void (*delete_file)(RemminaFTPClient *client);
+} RemminaFTPClientClass;
+
+GType remmina_ftp_client_get_type(void)
+G_GNUC_CONST;
+
+enum {
+	REMMINA_FTP_FILE_TYPE_DIR,
+	REMMINA_FTP_FILE_TYPE_FILE,
+	REMMINA_FTP_FILE_TYPE_LINK,
+	REMMINA_FTP_FILE_N_TYPES,
+};
+
+enum {
+	REMMINA_FTP_FILE_COLUMN_TYPE,
+	REMMINA_FTP_FILE_COLUMN_NAME,
+	REMMINA_FTP_FILE_COLUMN_SIZE,
+	REMMINA_FTP_FILE_COLUMN_USER,
+	REMMINA_FTP_FILE_COLUMN_GROUP,
+	REMMINA_FTP_FILE_COLUMN_PERMISSION,
+	REMMINA_FTP_FILE_COLUMN_MODIFIED,
+	REMMINA_FTP_FILE_COLUMN_NAME_SORT, /* Auto populate */
+	REMMINA_FTP_FILE_N_COLUMNS
+};
+
+enum {
+	REMMINA_FTP_TASK_TYPE_DOWNLOAD, REMMINA_FTP_TASK_TYPE_UPLOAD, REMMINA_FTP_TASK_N_TYPES
+};
+
+enum {
+	REMMINA_FTP_TASK_STATUS_WAIT,
+	REMMINA_FTP_TASK_STATUS_RUN,
+	REMMINA_FTP_TASK_STATUS_FINISH,
+	REMMINA_FTP_TASK_STATUS_ERROR,
+	REMMINA_FTP_TASK_N_STATUSES
+};
+
+enum {
+	REMMINA_FTP_TASK_COLUMN_TYPE,
+	REMMINA_FTP_TASK_COLUMN_NAME,
+	REMMINA_FTP_TASK_COLUMN_SIZE,
+	REMMINA_FTP_TASK_COLUMN_TASKID,
+	REMMINA_FTP_TASK_COLUMN_TASKTYPE,
+	REMMINA_FTP_TASK_COLUMN_REMOTEDIR,
+	REMMINA_FTP_TASK_COLUMN_LOCALDIR,
+	REMMINA_FTP_TASK_COLUMN_STATUS,
+	REMMINA_FTP_TASK_COLUMN_DONESIZE,
+	REMMINA_FTP_TASK_COLUMN_TOOLTIP,
+	REMMINA_FTP_TASK_N_COLUMNS
+};
+
+typedef struct _RemminaFTPTask {
+	/* Read-only */
+	gint			type;
+	gchar *			name;
+	gint			taskid;
+	gint			tasktype;
+	gchar *			remotedir;
+	gchar *			localdir;
+	GtkTreeRowReference *	rowref;
+	/* Updatable */
+	gfloat			size;
+	gint			status;
+	gfloat			donesize;
+	gchar *			tooltip;
+} RemminaFTPTask;
+
+GtkWidget *remmina_ftp_client_new(void);
+
+void remmina_ftp_client_save_state(RemminaFTPClient *client, RemminaFile *remminafile);
+void remmina_ftp_client_load_state(RemminaFTPClient *client, RemminaFile *remminafile);
+
+void remmina_ftp_client_set_show_hidden(RemminaFTPClient *client, gboolean show_hidden);
+void remmina_ftp_client_clear_file_list(RemminaFTPClient *client);
+/* column, value, …, -1 */
+void remmina_ftp_client_add_file(RemminaFTPClient *client, ...);
+/* Set the current directory. Should be called by opendir signal handler */
+void remmina_ftp_client_set_dir(RemminaFTPClient *client, const gchar *dir);
+/* Get the current directory as newly allocated string */
+gchar *remmina_ftp_client_get_dir(RemminaFTPClient *client);
+/* Get the next waiting task */
+RemminaFTPTask *remmina_ftp_client_get_waiting_task(RemminaFTPClient *client);
+/* Update the task */
+void remmina_ftp_client_update_task(RemminaFTPClient *client, RemminaFTPTask *task);
+/* Free the RemminaFTPTask object */
+void remmina_ftp_task_free(RemminaFTPTask *task);
+/* Get/Set Set overwrite_all status */
+void remmina_ftp_client_set_overwrite_status(RemminaFTPClient *client, gboolean status);
+gboolean remmina_ftp_client_get_overwrite_status(RemminaFTPClient *client);
+/* Get/Set Set resume_all status */
+void remmina_ftp_client_set_resume_status(RemminaFTPClient *client, gboolean status);
+gboolean remmina_ftp_client_get_resume_status(RemminaFTPClient *client);
+
+G_END_DECLS
diff --git a/src/remmina_icon.c b/src/remmina_icon.c
new file mode 100644
index 0000000..15d98ac
--- /dev/null
+++ b/src/remmina_icon.c
@@ -0,0 +1,491 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010 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 <glib/gi18n.h>
+
+#include "remmina_icon.h"
+
+#ifdef HAVE_LIBAPPINDICATOR
+#  ifdef HAVE_AYATANA_LIBAPPINDICATOR
+#    include <libayatana-appindicator/app-indicator.h>
+#  else
+#    include <libappindicator/app-indicator.h>
+#  endif
+#include "remmina_widget_pool.h"
+#include "remmina_pref.h"
+#include "remmina_exec.h"
+#ifdef HAVE_LIBAVAHI_CLIENT
+#include "remmina_avahi.h"
+#endif
+#include "remmina_applet_menu_item.h"
+#include "remmina_applet_menu.h"
+#include "rcw.h"
+#include "remmina_log.h"
+#include "remmina/remmina_trace_calls.h"
+#include "remmina_sysinfo.h"
+
+typedef struct _RemminaIcon {
+	AppIndicator *	icon;
+	gboolean	indicator_connected;
+#ifdef HAVE_LIBAVAHI_CLIENT
+	RemminaAvahi *	avahi;
+#endif
+	guint32		popup_time;
+	gchar *		autostart_file;
+} RemminaIcon;
+
+static RemminaIcon remmina_icon =
+{ 0 };
+
+void remmina_icon_destroy(void)
+{
+	TRACE_CALL(__func__);
+	if (remmina_icon.icon) {
+		app_indicator_set_status(remmina_icon.icon, APP_INDICATOR_STATUS_PASSIVE);
+		remmina_icon.icon = NULL;
+	}
+#ifdef HAVE_LIBAVAHI_CLIENT
+	if (remmina_icon.avahi) {
+		remmina_avahi_free(remmina_icon.avahi);
+		remmina_icon.avahi = NULL;
+	}
+#endif
+	if (remmina_icon.autostart_file) {
+		g_free(remmina_icon.autostart_file);
+		remmina_icon.autostart_file = NULL;
+	}
+}
+
+static void remmina_icon_main(void)
+{
+	TRACE_CALL(__func__);
+	remmina_exec_command(REMMINA_COMMAND_MAIN, NULL);
+}
+
+static void remmina_icon_preferences(void)
+{
+	TRACE_CALL(__func__);
+	remmina_exec_command(REMMINA_COMMAND_PREF, "2");
+}
+
+static void remmina_icon_about(void)
+{
+	TRACE_CALL(__func__);
+	remmina_exec_command(REMMINA_COMMAND_ABOUT, NULL);
+}
+
+#ifdef HAVE_LIBAVAHI_CLIENT
+static void remmina_icon_enable_avahi(GtkCheckMenuItem *checkmenuitem, gpointer data)
+{
+	TRACE_CALL(__func__);
+	if (!remmina_icon.avahi)
+		return;
+
+	if (gtk_check_menu_item_get_active(checkmenuitem)) {
+		remmina_pref.applet_enable_avahi = TRUE;
+		if (!remmina_icon.avahi->started)
+			remmina_avahi_start(remmina_icon.avahi);
+	} else {
+		remmina_pref.applet_enable_avahi = FALSE;
+		remmina_avahi_stop(remmina_icon.avahi);
+	}
+	remmina_pref_save();
+}
+#endif
+
+static void remmina_icon_populate_additional_menu_item(GtkWidget *menu)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *menuitem;
+
+
+#ifdef HAVE_LIBAVAHI_CLIENT
+
+	menuitem = gtk_separator_menu_item_new();
+	gtk_widget_show(menuitem);
+	gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menuitem);
+
+	menuitem = gtk_check_menu_item_new_with_label(_("Enable Service Discovery"));
+	if (remmina_pref.applet_enable_avahi)
+		gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE);
+	gtk_widget_show(menuitem);
+	g_signal_connect(G_OBJECT(menuitem), "toggled", G_CALLBACK(remmina_icon_enable_avahi), NULL);
+	gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menuitem);
+
+
+#endif
+
+	menuitem = gtk_separator_menu_item_new();
+	gtk_widget_show(menuitem);
+	gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menuitem);
+
+	menuitem = gtk_menu_item_new_with_mnemonic(_("_Quit"));
+	gtk_widget_show(menuitem);
+	gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menuitem);
+	g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(remmina_exec_exitremmina_one_confirm), NULL);
+
+	menuitem = gtk_menu_item_new_with_mnemonic(_("_About"));
+	gtk_widget_show(menuitem);
+	gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menuitem);
+	g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(remmina_icon_about), NULL);
+
+	menuitem = gtk_menu_item_new_with_mnemonic(_("_Preferences"));
+	gtk_widget_show(menuitem);
+	gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menuitem);
+	g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(remmina_icon_preferences), NULL);
+
+	menuitem = gtk_menu_item_new_with_label(_("Open Main Window"));
+	gtk_widget_show(menuitem);
+	gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menuitem);
+	g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(remmina_icon_main), NULL);
+
+
+}
+
+static void remmina_icon_on_launch_item(RemminaAppletMenu *menu, RemminaAppletMenuItem *menuitem, gpointer data)
+{
+	TRACE_CALL(__func__);
+	gchar *s;
+
+	switch (menuitem->item_type) {
+	case REMMINA_APPLET_MENU_ITEM_NEW:
+		remmina_exec_command(REMMINA_COMMAND_NEW, NULL);
+		break;
+	case REMMINA_APPLET_MENU_ITEM_FILE:
+		remmina_exec_command(REMMINA_COMMAND_CONNECT, menuitem->filename);
+		break;
+	case REMMINA_APPLET_MENU_ITEM_DISCOVERED:
+		s = g_strdup_printf("%s,%s", menuitem->protocol, menuitem->name);
+		remmina_exec_command(REMMINA_COMMAND_NEW, s);
+		g_free(s);
+		break;
+	}
+}
+
+static void remmina_icon_on_edit_item(RemminaAppletMenu *menu, RemminaAppletMenuItem *menuitem, gpointer data)
+{
+	TRACE_CALL(__func__);
+	gchar *s;
+
+	switch (menuitem->item_type) {
+	case REMMINA_APPLET_MENU_ITEM_NEW:
+		remmina_exec_command(REMMINA_COMMAND_NEW, NULL);
+		break;
+	case REMMINA_APPLET_MENU_ITEM_FILE:
+		remmina_exec_command(REMMINA_COMMAND_EDIT, menuitem->filename);
+		break;
+	case REMMINA_APPLET_MENU_ITEM_DISCOVERED:
+		s = g_strdup_printf("%s,%s", menuitem->protocol, menuitem->name);
+		remmina_exec_command(REMMINA_COMMAND_NEW, s);
+		g_free(s);
+		break;
+	}
+}
+
+static void remmina_icon_populate_extra_menu_item(GtkWidget *menu)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *menuitem;
+	gboolean new_ontop;
+
+	new_ontop = remmina_pref.applet_new_ontop;
+
+#ifdef HAVE_LIBAVAHI_CLIENT
+	GHashTableIter iter;
+	gchar *tmp;
+	/* Iterate all discovered services from Avahi */
+	if (remmina_icon.avahi) {
+		g_hash_table_iter_init(&iter, remmina_icon.avahi->discovered_services);
+		while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&tmp)) {
+			menuitem = remmina_applet_menu_item_new(REMMINA_APPLET_MENU_ITEM_DISCOVERED, tmp);
+			gtk_widget_show(menuitem);
+			remmina_applet_menu_add_item(REMMINA_APPLET_MENU(menu), REMMINA_APPLET_MENU_ITEM(menuitem));
+		}
+	}
+#endif
+
+	/* New Connection */
+	menuitem = remmina_applet_menu_item_new(REMMINA_APPLET_MENU_ITEM_NEW);
+	gtk_widget_show(menuitem);
+	remmina_applet_menu_register_item(REMMINA_APPLET_MENU(menu), REMMINA_APPLET_MENU_ITEM(menuitem));
+	if (new_ontop)
+		gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menuitem);
+	else
+		gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
+
+	g_signal_connect(G_OBJECT(menu), "launch-item", G_CALLBACK(remmina_icon_on_launch_item), NULL);
+	g_signal_connect(G_OBJECT(menu), "edit-item", G_CALLBACK(remmina_icon_on_edit_item), NULL);
+}
+
+void
+remmina_icon_populate_menu(void)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *menu;
+	GtkWidget *menuitem;
+
+	if (remmina_icon.icon && !remmina_pref.disable_tray_icon) {
+		menu = remmina_applet_menu_new();
+		app_indicator_set_menu(remmina_icon.icon, GTK_MENU(menu));
+
+		remmina_applet_menu_set_hide_count(REMMINA_APPLET_MENU(menu), remmina_pref.applet_hide_count);
+		remmina_applet_menu_populate(REMMINA_APPLET_MENU(menu));
+		
+
+		menuitem = gtk_separator_menu_item_new();
+		gtk_widget_show(menuitem);
+		gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
+
+		remmina_icon_populate_additional_menu_item(menu);
+		remmina_icon_populate_extra_menu_item(menu);
+	}
+}
+
+static void remmina_icon_save_autostart_file(GKeyFile *gkeyfile)
+{
+	TRACE_CALL(__func__);
+	gchar *content;
+	gsize length;
+
+	content = g_key_file_to_data(gkeyfile, &length, NULL);
+	if (remmina_icon.autostart_file != NULL) {
+		g_file_set_contents(remmina_icon.autostart_file, content, length, NULL);
+	}
+	else {
+		REMMINA_WARNING("Cannot save remmina icon autostart file. Uncheck Preferences -> Applet -> No Tray Icon to recreate it.");
+	}
+	g_free(content);
+}
+
+static void remmina_icon_create_autostart_file(void)
+{
+	TRACE_CALL(__func__);
+	if (g_file_test(remmina_icon.autostart_file, G_FILE_TEST_EXISTS))
+		return;
+
+	GKeyFile *gkeyfile;
+
+	gkeyfile = g_key_file_new();
+	g_key_file_set_string(gkeyfile, "Desktop Entry", "Version", "1.0");
+	// TRANSLATORS: Applet name as per the Freedesktop Desktop entry specification https://specifications.freedesktop.org/desktop-entry-spec/latest/
+	g_key_file_set_string(gkeyfile, "Desktop Entry", "Name", _("Remmina Applet"));
+	// TRANSLATORS: Applet comment/description as per the Freedesktop Desktop entry specification https://specifications.freedesktop.org/desktop-entry-spec/latest/
+	g_key_file_set_string(gkeyfile, "Desktop Entry", "Comment", _("Connect to remote desktops through the applet menu"));
+	g_key_file_set_string(gkeyfile, "Desktop Entry", "Icon", REMMINA_APP_ID);
+	if (getenv("FLATPAK_ID")){
+		g_key_file_set_string(gkeyfile, "Desktop Entry", "Exec", "flatpak run org.remmina.Remmina -i");
+	}
+	else{
+		g_key_file_set_string(gkeyfile, "Desktop Entry", "Exec", "remmina -i");
+	}
+	g_key_file_set_boolean(gkeyfile, "Desktop Entry", "Terminal", FALSE);
+	g_key_file_set_string(gkeyfile, "Desktop Entry", "Type", "Application");
+	g_key_file_set_boolean(gkeyfile, "Desktop Entry", "Hidden", FALSE);
+	remmina_icon_save_autostart_file(gkeyfile);
+	g_key_file_free(gkeyfile);
+}
+
+/**
+ * Determine whenever the Remmina icon is available.
+ * Return TRUE if a remmina_icon (status indicator/systray menu) is
+ * available and shown to the user, so the user can continue
+ * its work without the remmina main window.
+ * @return TRUE if the Remmina icon is available.
+ */
+gboolean remmina_icon_is_available(void)
+{
+	TRACE_CALL(__func__);
+
+	if (!remmina_icon.icon)
+		return FALSE;
+	if (remmina_pref.disable_tray_icon)
+		return FALSE;
+
+	if (remmina_icon.indicator_connected == FALSE) {
+		REMMINA_DEBUG("Indicator is not connected to panel, thus it cannot be displayed.");
+		return FALSE;
+	} else {
+		REMMINA_DEBUG("Indicator is connected to panel, thus it can be displayed.");
+		return TRUE;
+	}
+	/** Special treatment under GNOME Shell
+	 * Remmina > v1.4.18 won't be shipped in distributions with GNOME Shell <= 3.18
+	 * therefore checking the the GNOME Shell version is useless.
+	 * We just return TRUE
+	 */
+	return TRUE;
+}
+
+static void
+remmina_icon_connection_changed_cb(AppIndicator *indicator, gboolean connected, gpointer data)
+{
+	TRACE_CALL(__func__);
+	REMMINA_DEBUG("Indicator connection changed to: %d", connected);
+	remmina_icon.indicator_connected = connected;
+}
+
+void remmina_icon_init(void)
+{
+	TRACE_CALL(__func__);
+
+	gchar remmina_panel[29];
+	gboolean sni_supported;
+
+	g_stpcpy(remmina_panel, "org.remmina.Remmina-status");
+
+	/* Print on stdout the availability of appindicators on DBUS */
+	sni_supported = remmina_sysinfo_is_appindicator_available();
+
+	g_autofree gchar *wmname = g_ascii_strdown(remmina_sysinfo_get_wm_name(), -1);
+	//TRANSLATORS: These are Linux desktop components to show icons in the system tray, after the “ there's the Desktop Name (like GNOME).
+	g_autofree gchar *msg = g_strconcat(
+		_("StatusNotifier/Appindicator support in “"),
+		wmname,
+		"”:",
+		NULL);
+
+	if (sni_supported) {
+		//TRANSLATORS: %s is a placeholder for "StatusNotifier/Appindicator suppor in “DESKTOP NAME”: "
+		REMMINA_INFO(_("%s your desktop does support it"), msg);
+		//TRANSLATORS: %s is a placeholder for "StatusNotifier/Appindicator suppor in “DESKTOP NAME”: "
+		REMMINA_INFO(_("%s and Remmina has built-in (compiled) support for libappindicator."), msg);
+	} else {
+		//TRANSLATORS: %s is a placeholder for "StatusNotifier/Appindicator suppor in “DESKTOP NAME”: "
+		REMMINA_INFO(_("%s not supported natively by your Desktop Environment. libappindicator will try to fallback to GtkStatusIcon/xembed"), msg);
+	}
+	if (g_strrstr(wmname, "mate") != NULL)
+		//TRANSLATORS: %s is a placeholder for "StatusNotifier/Appindicator suppor in “DESKTOP NAME”: "
+		REMMINA_INFO(_("%s You may need to install, and use XApp Status Applet"), msg);
+	if (g_strrstr(wmname, "kde") != NULL)
+		//TRANSLATORS: %s is a placeholder for "StatusNotifier/Appindicator suppor in “DESKTOP NAME”: "
+		REMMINA_INFO(_("%s You may need to install, and use KStatusNotifierItem"), msg);
+	if (g_strrstr(wmname, "plasma") != NULL)
+		//TRANSLATORS: %s is a placeholder for "StatusNotifier/Appindicator suppor in “DESKTOP NAME”: "
+		REMMINA_INFO(_("%s You may need to install, and use XEmbed SNI Proxy"), msg);
+	if (g_strrstr(wmname, "gnome") != NULL)
+		//TRANSLATORS: %s is a placeholder for "StatusNotifier/Appindicator suppor in “DESKTOP NAME”: "
+		REMMINA_INFO(_("%s You may need to install, and use Gnome Shell Extension Appindicator"), msg);
+
+	if (!remmina_icon.icon && !remmina_pref.disable_tray_icon) {
+		remmina_icon.icon = app_indicator_new("remmina-icon", remmina_panel, APP_INDICATOR_CATEGORY_APPLICATION_STATUS);
+		app_indicator_set_status(remmina_icon.icon, APP_INDICATOR_STATUS_ACTIVE);
+		app_indicator_set_title(remmina_icon.icon, "Remmina");
+		remmina_icon_populate_menu();
+	} else if (remmina_icon.icon) {
+		app_indicator_set_status(remmina_icon.icon, remmina_pref.disable_tray_icon ?
+					 APP_INDICATOR_STATUS_PASSIVE : APP_INDICATOR_STATUS_ACTIVE);
+		/* With libappindicator we can also change the icon on the fly */
+		app_indicator_set_icon(remmina_icon.icon, remmina_panel);
+	}
+	remmina_icon.indicator_connected = TRUE;
+#ifdef HAVE_LIBAVAHI_CLIENT
+	if (!remmina_icon.avahi)
+		remmina_icon.avahi = remmina_avahi_new();
+	if (remmina_icon.avahi) {
+		if (remmina_pref.applet_enable_avahi) {
+			if (!remmina_icon.avahi->started)
+				remmina_avahi_start(remmina_icon.avahi);
+		} else {
+			remmina_avahi_stop(remmina_icon.avahi);
+		}
+	}
+#endif
+	if (!remmina_icon.autostart_file && !remmina_pref.disable_tray_icon) {
+		remmina_icon.autostart_file = g_strdup_printf("%s/.config/autostart/remmina-applet.desktop", g_get_home_dir());
+		remmina_icon_create_autostart_file();
+	}
+	// "connected" property means a visible indicator, otherwise could be hidden. or fall back to GtkStatusIcon
+	if (remmina_icon.icon)
+		g_signal_connect(G_OBJECT(remmina_icon.icon), "connection-changed", G_CALLBACK(remmina_icon_connection_changed_cb), NULL);
+	//g_object_get(G_OBJECT(remmina_icon.icon), "connected", &remmina_icon.indicator_connected, NULL);
+}
+
+gboolean remmina_icon_is_autostart(void)
+{
+	TRACE_CALL(__func__);
+	GKeyFile *gkeyfile;
+	gboolean b;
+
+	gkeyfile = g_key_file_new();
+
+	if (remmina_icon.autostart_file != NULL) {
+		g_key_file_load_from_file(gkeyfile, remmina_icon.autostart_file, G_KEY_FILE_NONE, NULL);
+	}
+	else {
+		REMMINA_WARNING("Cannot load remmina icon autostart file. Uncheck Preferences -> Applet -> No Tray Icon to recreate it.");
+	}
+
+	b = !g_key_file_get_boolean(gkeyfile, "Desktop Entry", "Hidden", NULL);
+	g_key_file_free(gkeyfile);
+	return b;
+}
+
+void remmina_icon_set_autostart(gboolean autostart)
+{
+	TRACE_CALL(__func__);
+	GKeyFile *gkeyfile;
+	gboolean b;
+
+	if (remmina_icon.autostart_file != NULL) {
+		gkeyfile = g_key_file_new();
+		g_key_file_load_from_file(gkeyfile, remmina_icon.autostart_file, G_KEY_FILE_NONE, NULL);
+		b = !g_key_file_get_boolean(gkeyfile, "Desktop Entry", "Hidden", NULL);
+		if (b != autostart) {
+			g_key_file_set_boolean(gkeyfile, "Desktop Entry", "Hidden", !autostart);
+			/* Refresh it in case translation is updated */
+			// TRANSLATORS: Applet Name as per the Freedesktop Desktop entry specification https://specifications.freedesktop.org/desktop-entry-spec/latest/
+			g_key_file_set_string(gkeyfile, "Desktop Entry", "Name", _("Remmina Applet"));
+			// TRANSLATORS: Applet comment/description as per the Freedesktop Desktop entry specification https://specifications.freedesktop.org/desktop-entry-spec/latest/
+			g_key_file_set_string(gkeyfile, "Desktop Entry", "Comment", _("Connect to remote desktops through the applet menu"));
+			remmina_icon_save_autostart_file(gkeyfile);
+			g_key_file_free(gkeyfile);
+		}
+	}
+	else {
+		REMMINA_WARNING("Cannot load remmina icon autostart file. Uncheck Preferences -> Applet -> No Tray Icon to recreate it.");
+	}
+}
+
+#else
+void remmina_icon_init(void) {};
+void remmina_icon_destroy(void) {};
+gboolean remmina_icon_is_available(void) {return FALSE;};
+void remmina_icon_populate_menu(void) {};
+void remmina_icon_set_autostart(gboolean autostart) {} ;
+gboolean remmina_icon_is_autostart(void) {return FALSE;};
+#endif
diff --git a/src/remmina_icon.h b/src/remmina_icon.h
new file mode 100644
index 0000000..9de1836
--- /dev/null
+++ b/src/remmina_icon.h
@@ -0,0 +1,49 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010 Vic Lee
+ * Copyright (C) 2017-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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+void remmina_icon_init(void);
+gboolean remmina_icon_is_autostart(void);
+void remmina_icon_set_autostart(gboolean autostart);
+void remmina_icon_populate_menu(void);
+void remmina_icon_destroy(void);
+gboolean remmina_icon_is_available(void);
+
+G_END_DECLS
diff --git a/src/remmina_info.c b/src/remmina_info.c
new file mode 100644
index 0000000..704ef3a
--- /dev/null
+++ b/src/remmina_info.c
@@ -0,0 +1,1328 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2016-2023 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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.
+ *
+ */
+
+/**
+ * @file remmina_info.c
+ * @brief Remmina usage statistics module.
+ * @author Antenore Gatta and Giovanni Panozzo
+ * @date 12 Feb 2018
+ *
+ * Since October 29, 2021 data is not collected nor sent to remmina.org anymore. All the
+ * code intended to send data has been removed. The following documentation
+ * has to be kept for those with versions of Remmina older than 1.4.22.
+ *
+ * When Remmina starts asks the user to share some usage statistics
+ * with the Remmina developers. As per the opt-in model
+ * (https://en.wikipedia.org/wiki/Opt-in_email), without the consent of the user,
+ * no data will be collected.
+ * Additionally a user can ask, at any moment, that any data linked to their
+ * profile to be deleted, and can change the Remmina settings to stop
+ * collecting and sharing usage statistics.
+ *
+ * All the data are encrypted at client side using RSA, through the OpenSSL
+ * libraries, and decrypted offline to maximize security.
+ *
+ * The following example show which kind of data are collected.
+ *
+ * @code
+ * {
+ *
+ *    "UID": "P0M20TXN03DWF4-9a1e6da2ad"
+ *    "REMMINAVERSION": {
+ *        "version": "1.2.0-rcgit-26"
+ *        "git_revision": "9c5c4805"
+ *        "snap_build": 0
+ *    }
+ *    "SYSTEM": {
+ *        "kernel_name": "Linux"
+ *        "kernel_release": "4.14.11-200.fc26.x86_64"
+ *        "kernel_arch": "x86_64"
+ *        "lsb_distributor": "Fedora"
+ *        "lsb_distro_description": "Fedora release 26 (Twenty Six)"
+ *        "lsb_distro_release": "26"
+ *        "lsb_distro_codename": "TwentySix"
+ *        "etc_release": "Fedora release 26 (Twenty Six)"
+ *    }
+ *    "GTKVERSION": {
+ *        "major": 3
+ *        "minor": 22
+ *        "micro": 21
+ *    }
+ *    "GTKBACKEND": "X11"
+ *    "WINDOWMANAGER": {
+ *        "window_manager": "GNOME i3-gnome"
+ *    }
+ *    "APPINDICATOR": {
+ *        "appindicator_supported": 0
+ *        "appindicator_compiled": 1
+ *        "icon_is_active": 1
+ *        "appindicator_type": "AppIndicator on GtkStatusIcon/xembed"
+ *    }
+ *    "PROFILES": {
+ *        "profile_count": 457
+ *        "SSH": 431
+ *        "NX": 1
+ *        "RDP": 7
+ *        "TERMINAL": 2
+ *        "X2GO": 5
+ *        "SFTP": 4
+ *        "PYTHON_SIMPLE": 4
+ *        "SPICE": 3
+ *        "DATE_SSH": "20180209"
+ *        "DATE_NX": ""
+ *        "DATE_RDP": "20180208"
+ *        "DATE_TERMINAL": ""
+ *        "DATE_X2GO": ""
+ *        "DATE_SFTP": ""
+ *        "DATE_PYTHON_SIMPLE": ""
+ *        "DATE_SPICE": ""
+ *    }
+ *    "ENVIRONMENT": {
+ *        "language": "en_US.utf8"
+ *    }
+ *    "ACTIVESECRETPLUGIN": {
+ *        "plugin_name": "kwallet"
+ *    }
+ *    "HASPRIMARYPASSWORD": {
+ *        "primary_password_status": "OFF"
+ *    }
+ *
+ * }
+ * @endcode
+ *
+ * All of these data are solely transmitted to understand:
+ *  - On which type of system Remmina is used
+ *	- Operating System
+ *	- Architecture (32/64bit)
+ *	- Linux distributor or OS vendor
+ *  - Desktop Environment type.
+ *  - Main library versions installed on the system in use by Remmina.
+ *  - Protocols used
+ *  - Last time each protocol has been used (globally).
+ *
+ * @see https://www.remmina.org for more info.
+ */
+
+#include "config.h"
+#include <string.h>
+#include <sys/utsname.h>
+#include <unistd.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+#include <gtk/gtk.h>
+
+
+#include "remmina.h"
+#include "remmina_file.h"
+#include "remmina_file_manager.h"
+#include "remmina_icon.h"
+#include "remmina_log.h"
+#include "remmina_pref.h"
+#include "remmina_curl_connector.h"
+#include "remmina_sysinfo.h"
+#include "remmina_utils.h"
+#include "remmina_scheduler.h"
+#include "remmina_public.h"
+#include "remmina_main.h"
+#include "remmina/remmina_trace_calls.h"
+#include "remmina_plugin_manager.h"
+
+#ifdef GDK_WINDOWING_WAYLAND
+	#include <gdk/gdkwayland.h>
+#endif
+#ifdef GDK_WINDOWING_X11
+	#include <gdk/gdkx.h>
+#endif
+#include "remmina_info.h"
+
+#define MAX_ENV_LEN	10000
+
+gboolean info_disable_stats = 1;
+gboolean info_disable_news = 1;
+gboolean info_disable_tip = 1;
+
+
+struct ProfilesData {
+	GHashTable *proto_count;
+	GHashTable *proto_date;
+	const gchar *protocol;          /** Key in the proto_count hash table.*/
+	const gchar *pdatestr;          /** Date in string format in the proto_date hash table. */
+	gint pcount;
+	gchar datestr;
+};
+
+#if !JSON_CHECK_VERSION(1, 2, 0)
+	#define json_node_unref(x) json_node_free(x)
+#endif
+
+/* Timers */
+#define INFO_PERIODIC_CHECK_1ST_MS 1000
+#define INFO_PERIODIC_CHECK_INTERVAL_MS 86400000
+
+#define PERIODIC_UPLOAD_URL "https://info.remmina.org/info/upload_stats"
+#define INFO_REQUEST_URL "https://info.remmina.org/info/handshake"
+
+ 
+static RemminaInfoDialog *remmina_info_dialog;
+#define GET_OBJ(object_name) gtk_builder_get_object(remmina_info_dialog->builder, object_name)
+
+typedef struct {
+	gboolean send_stats;
+	JsonNode *statsroot;
+} sc_tdata;
+
+JsonNode *remmina_info_stats_get_uid()
+{
+	TRACE_CALL(__func__);
+	JsonNode *r;
+	GChecksum *chs;
+	const gchar *uname, *hname;
+	const gchar *uid_suffix;
+	gchar *uid_prefix;
+	gchar *uid;
+
+	/** @warning this function is usually executed on a dedicated thread,
+	 * not on the main thread
+	 */
+
+	if (remmina_pref.info_uid_prefix == NULL || remmina_pref.info_uid_prefix[0] == 0) {
+		/* Generate a new UUID_PREFIX for this installation */
+		uid_prefix = remmina_gen_random_uuid();
+		if (remmina_pref.info_uid_prefix) {
+			g_free(remmina_pref.info_uid_prefix);
+		}
+		remmina_pref.info_uid_prefix = uid_prefix;
+		remmina_pref_save();
+	}
+
+	uname = g_get_user_name();
+	hname = g_get_host_name();
+	chs = g_checksum_new(G_CHECKSUM_SHA256);
+	g_checksum_update(chs, (const guchar *)uname, strlen(uname));
+	g_checksum_update(chs, (const guchar *)hname, strlen(hname));
+	uid_suffix = g_checksum_get_string(chs);
+
+	uid = g_strdup_printf("%s-%.10s", remmina_pref.info_uid_prefix, uid_suffix);
+	g_checksum_free(chs);
+
+	r = json_node_alloc();
+	json_node_init_string(r, uid);
+
+	g_free(uid);
+
+	return r;
+}
+
+JsonNode *remmina_info_stats_get_os_info()
+{
+	TRACE_CALL(__func__);
+	JsonBuilder *b;
+	JsonNode *r;
+
+	gchar *kernel_name;
+	gchar *kernel_release;
+	gchar *kernel_arch;
+	gchar *id;
+	gchar *description;
+	GHashTable *etc_release;
+	gchar *release;
+	gchar *codename;
+	GHashTableIter iter;
+	gchar *key, *value;
+	gchar *mage;
+
+	/** @warning this function is usually executed on a dedicated thread,
+	 * not on the main thread */
+	b = json_builder_new();
+	if (b == NULL) {
+		return NULL;
+	}
+	json_builder_begin_object(b);
+
+	json_builder_set_member_name(b, "kernel_name");
+	kernel_name = remmina_utils_get_kernel_name();
+	if (!kernel_name || kernel_name[0] == '\0') {
+		json_builder_add_null_value(b);
+	}else {
+		json_builder_add_string_value(b, kernel_name);
+	}
+	g_free(kernel_name);
+
+	json_builder_set_member_name(b, "kernel_release");
+	kernel_release = remmina_utils_get_kernel_release();
+	if (!kernel_release || kernel_release[0] == '\0') {
+		json_builder_add_null_value(b);
+	}else {
+		json_builder_add_string_value(b, kernel_release);
+	}
+	g_free(kernel_release);
+
+	json_builder_set_member_name(b, "kernel_arch");
+	kernel_arch = remmina_utils_get_kernel_arch();
+	if (!kernel_arch || kernel_arch[0] == '\0') {
+		json_builder_add_null_value(b);
+	}else {
+		json_builder_add_string_value(b, kernel_arch);
+	}
+	g_free(kernel_arch);
+
+	json_builder_set_member_name(b, "lsb_distributor");
+	id = remmina_utils_get_lsb_id();
+	if (!id || id[0] == '\0') {
+		json_builder_add_null_value(b);
+	}else {
+		json_builder_add_string_value(b, id);
+	}
+	g_free(id);
+
+	json_builder_set_member_name(b, "lsb_distro_description");
+	description = remmina_utils_get_lsb_description();
+	if (!description || description[0] == '\0') {
+		json_builder_add_null_value(b);
+	}else {
+		json_builder_add_string_value(b, description);
+	}
+	g_free(description);
+
+	json_builder_set_member_name(b, "lsb_distro_release");
+	release = remmina_utils_get_lsb_release();
+	if (!release || release[0] == '\0') {
+		json_builder_add_null_value(b);
+	}else {
+		json_builder_add_string_value(b, release);
+	}
+	g_free(release);
+
+	json_builder_set_member_name(b, "lsb_distro_codename");
+	codename = remmina_utils_get_lsb_codename();
+	if (!codename || codename[0] == '\0') {
+		json_builder_add_null_value(b);
+	}else {
+		json_builder_add_string_value(b, codename);
+	}
+	g_free(codename);
+
+	etc_release = remmina_utils_get_etc_release();
+	json_builder_set_member_name(b, "etc_release");
+	if (etc_release) {
+		json_builder_begin_object(b);
+		g_hash_table_iter_init (&iter, etc_release);
+		while (g_hash_table_iter_next (&iter, (gpointer)&key, (gpointer)&value)) {
+			json_builder_set_member_name(b, key);
+			json_builder_add_string_value(b, value);
+		}
+		json_builder_end_object(b);
+		g_hash_table_remove_all(etc_release);
+		g_hash_table_unref(etc_release);
+	}else {
+		json_builder_add_null_value(b);
+	}
+
+	mage = remmina_utils_get_mage();
+	json_builder_set_member_name(b, "mage");
+	json_builder_add_string_value(b, mage);
+	g_free(mage);
+
+
+	/** @todo Add other means to identify a release name/description
+	 *        to cover as much OS as possible, like /etc/issue
+	 */
+
+	json_builder_end_object(b);
+	r = json_builder_get_root(b);
+	g_object_unref(b);
+	return r;
+}
+
+/**
+ * Gets the following user environment:
+ *   - Gets the user’s locale (or NULL by default) corresponding to LC_ALL.
+ *
+ * @return a JSON Node structure containing the user’s environment.
+ */
+JsonNode *remmina_info_stats_get_user_env()
+{
+	TRACE_CALL(__func__);
+	JsonBuilder *b;
+	JsonNode *r;
+
+	gchar *language;
+	gchar **environment;
+	gchar **uenv;
+	gchar *str;
+	gsize env_len = 0;
+
+	language = remmina_utils_get_lang();
+
+	b = json_builder_new();
+	if (b == NULL) {
+		return NULL;
+	}
+
+	environment = g_get_environ();
+	uenv = environment;
+
+	json_builder_begin_object(b);
+	json_builder_set_member_name(b, "language");
+	json_builder_add_string_value(b, language);
+
+	gchar *safe_ptr;
+	while (*uenv && env_len <= MAX_ENV_LEN) {
+		str = strtok_r(*uenv, "=", &safe_ptr);
+		if (str != NULL) {
+			env_len += strlen(str);
+			json_builder_set_member_name(b, str);
+		}
+		str = strtok_r(NULL, "\n", &safe_ptr);
+		if (str != NULL) {
+			env_len += strlen(str);
+			json_builder_add_string_value(b, str);
+		}
+		else{
+			json_builder_add_string_value(b, "");
+		}
+		uenv++;
+	}
+
+	json_builder_end_object(b);
+	r = json_builder_get_root(b);
+	g_object_unref(b);
+	g_strfreev(environment);
+	return r;
+}
+
+JsonNode *remmina_info_stats_get_host() {
+
+	TRACE_CALL(__func__);
+	JsonBuilder *b;
+	JsonNode *r;
+
+	gchar *logical, *physical;
+
+	b = json_builder_new();
+	if (b == NULL) {
+		return NULL;
+	}
+
+	json_builder_begin_object(b);
+	json_builder_set_member_name(b, "host");
+	logical = remmina_utils_get_logical();
+	if (!logical || logical[0] == '\0') {
+		json_builder_add_null_value(b);
+	}
+	else {
+		json_builder_add_string_value(b, logical);
+	}
+	g_free(logical);
+
+	json_builder_set_member_name(b, "hw");
+	physical = remmina_utils_get_link();
+	if (!physical || physical[0] == '\0') {
+		json_builder_add_null_value(b);
+	}
+	else {
+		json_builder_add_string_value(b, physical);
+	}
+	g_free(physical);
+
+	json_builder_end_object(b);
+	r = json_builder_get_root(b);
+	g_object_unref(b);
+	return r;
+}
+
+JsonNode *remmina_info_stats_get_version()
+{
+	TRACE_CALL(__func__);
+	JsonBuilder *b;
+	JsonNode *r;
+	gchar *flatpak_info;
+
+	/** @warning this function is usually executed on a dedicated thread,
+	 * not on the main thread */
+
+	b = json_builder_new();
+	if (b == NULL) {
+		return NULL;
+	}
+	json_builder_begin_object(b);
+	json_builder_set_member_name(b, "version");
+	json_builder_add_string_value(b, VERSION);
+	json_builder_set_member_name(b, "git_revision");
+	json_builder_add_string_value(b, REMMINA_GIT_REVISION);
+	json_builder_set_member_name(b, "snap_build");
+#ifdef SNAP_BUILD
+	json_builder_add_int_value(b, 1);
+#else
+	json_builder_add_int_value(b, 0);
+#endif
+
+	/**
+	 * Detect if Remmina is running under Flatpak
+	 */
+	json_builder_set_member_name(b, "flatpak_build");
+	/* Flatpak sandbox should contain the file ${XDG_RUNTIME_DIR}/flatpak-info */
+	flatpak_info = g_build_filename(g_get_user_runtime_dir(), "flatpak-info", NULL);
+	if (g_file_test(flatpak_info, G_FILE_TEST_EXISTS)) {
+		json_builder_add_int_value(b, 1);
+	} else {
+		json_builder_add_int_value(b, 0);
+	}
+	g_free(flatpak_info);
+
+	json_builder_end_object(b);
+	r = json_builder_get_root(b);
+	g_object_unref(b);
+	return r;
+}
+
+JsonNode *remmina_info_stats_get_gtk_version()
+{
+	TRACE_CALL(__func__);
+	JsonBuilder *b;
+	JsonNode *r;
+
+	/** @warning this function is usually executed on a dedicated thread,
+	 * not on the main thread
+	 */
+
+	b = json_builder_new();
+	if (b == NULL) {
+		return NULL;
+	}
+
+	json_builder_begin_object(b);
+	json_builder_set_member_name(b, "major");
+	json_builder_add_int_value(b, gtk_get_major_version());
+	json_builder_set_member_name(b, "minor");
+	json_builder_add_int_value(b, gtk_get_minor_version());
+	json_builder_set_member_name(b, "micro");
+	json_builder_add_int_value(b, gtk_get_micro_version());
+	json_builder_end_object(b);
+	r = json_builder_get_root(b);
+	g_object_unref(b);
+	return r;
+}
+
+JsonNode *remmina_info_stats_get_gtk_backend()
+{
+	TRACE_CALL(__func__);
+	JsonNode *r;
+	GdkDisplay *disp;
+	gchar *bkend;
+
+	/** @warning this function is usually executed on a dedicated thread,
+	 * not on the main thread
+	 */
+
+	disp = gdk_display_get_default();
+
+#ifdef GDK_WINDOWING_WAYLAND
+	if (GDK_IS_WAYLAND_DISPLAY(disp)) {
+		bkend = "Wayland";
+	}else
+#endif
+#ifdef GDK_WINDOWING_X11
+	if (GDK_IS_X11_DISPLAY(disp)) {
+		bkend = "X11";
+	}   else
+#endif
+	bkend = "n/a";
+
+	r = json_node_alloc();
+	json_node_init_string(r, bkend);
+
+	return r;
+
+}
+
+JsonNode *remmina_info_stats_get_wm_name()
+{
+	TRACE_CALL(__func__);
+	JsonBuilder *b;
+	JsonNode *r;
+	gchar *wmver;
+	gchar *wmname;
+
+	b = json_builder_new();
+	if (b == NULL) {
+		return NULL;
+	}
+
+	json_builder_begin_object(b);
+
+	json_builder_set_member_name(b, "window_manager");
+
+	/** We try to get the GNOME Shell version */
+	wmver = remmina_sysinfo_get_gnome_shell_version();
+	if (!wmver || wmver[0] == '\0') {
+	}else {
+		json_builder_add_string_value(b, "GNOME Shell");
+		json_builder_set_member_name(b, "gnome_shell_ver");
+		json_builder_add_string_value(b, wmver);
+		goto end;
+	}
+	g_free(wmver);
+
+	wmname = remmina_sysinfo_get_wm_name();
+	if (!wmname || wmname[0] == '\0') {
+		json_builder_add_string_value(b, "n/a");
+	}else {
+		json_builder_add_string_value(b, wmname);
+	}
+	g_free(wmname);
+
+ end:
+	json_builder_end_object(b);
+	r = json_builder_get_root(b);
+	g_object_unref(b);
+	return r;
+}
+
+JsonNode *remmina_info_stats_get_indicator()
+{
+	TRACE_CALL(__func__);
+	JsonBuilder *b;
+	JsonNode *r;
+	gboolean sni;           /** Support for StatusNotifier or AppIndicator */
+
+	b = json_builder_new();
+	if (b == NULL) {
+		return NULL;
+	}
+
+	json_builder_begin_object(b);
+
+	json_builder_set_member_name(b, "appindicator_supported");
+	sni = remmina_sysinfo_is_appindicator_available();
+	if (sni) {
+		/** StatusNotifier/Appindicator supported by desktop */
+		json_builder_add_int_value(b, 1);
+		json_builder_set_member_name(b, "appindicator_compiled");
+#ifdef HAVE_LIBAPPINDICATOR
+		/** libappindicator is compiled in remmina. */
+		json_builder_add_int_value(b, 1);
+#else
+		/** Remmina not compiled with -DWITH_APPINDICATOR=on */
+		json_builder_add_int_value(b, 0);
+#endif
+	}
+	else{
+		/** StatusNotifier/Appindicator NOT supported by desktop */
+		json_builder_add_int_value(b, 0);
+	}
+	
+	json_builder_set_member_name(b, "icon_is_active");
+	if (remmina_icon_is_available()) {
+		/** Remmina icon is active */
+		json_builder_add_int_value(b, 1);
+		json_builder_set_member_name(b, "appindicator_type");
+#ifdef HAVE_LIBAPPINDICATOR
+		/** libappindicator fallback to GtkStatusIcon/xembed"); */
+		json_builder_add_string_value(b, "AppIndicator on GtkStatusIcon/xembed");
+#else
+		/** Remmina fallback to GtkStatusIcon/xembed */
+		json_builder_add_string_value(b, "Remmina icon on GtkStatusIcon/xembed");
+#endif
+	}else {
+		/** Remmina icon is NOT active */
+		json_builder_add_int_value(b, 0);
+	}
+	json_builder_end_object(b);
+	r = json_builder_get_root(b);
+	g_object_unref(b);
+	return r;
+}
+
+/**
+ * Given a remmina file, fills a structure containing profiles keys/value tuples.
+ *
+ * This is used as a callback function with remmina_file_manager_iterate.
+ * @todo Move this in a separate file.
+ */
+static void remmina_info_profiles_get_data(RemminaFile *remminafile, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+
+	gint count = 0;
+	gpointer pcount, kpo;
+	gpointer pdate;
+	gchar *hday, *hmonth, *hyear;
+	gchar *pday, *pmonth, *pyear;
+
+	GDateTime *prof_gdate;          /** Source date -> from profile */
+	GDateTime *pdata_gdate;          /** Destination date -> The date in the pdata structure */
+
+	struct ProfilesData* pdata;
+	pdata = (struct ProfilesData*)user_data;
+
+	pdata->protocol = remmina_file_get_string(remminafile, "protocol");
+	//pdata->pdatestr = remmina_file_get_string(remminafile, "last_success");
+	const gchar *last_success = remmina_file_get_string(remminafile, "last_success");
+
+	prof_gdate = pdata_gdate = NULL;
+	if (last_success && last_success[0] != '\0' && strlen(last_success) >= 6) {
+		pyear = g_strdup_printf("%.4s", last_success);
+		pmonth = g_strdup_printf("%.2s", last_success + 4);
+		pday = g_strdup_printf("%.2s", last_success + 6);
+		prof_gdate = g_date_time_new_local(
+				atoi(pyear),
+				atoi(pmonth),
+				atoi(pday), 0, 0, 0);
+		g_free(pyear);
+		g_free(pmonth);
+		g_free(pday);
+	}
+
+
+	if (pdata->protocol && pdata->protocol[0] != '\0') {
+		if (g_hash_table_lookup_extended(pdata->proto_count, pdata->protocol, &kpo, &pcount)) {
+			count = GPOINTER_TO_INT(pcount) + 1;
+		}else {
+			count = 1;
+			g_hash_table_insert(pdata->proto_count, g_strdup(pdata->protocol), GINT_TO_POINTER(count));
+		}
+		g_hash_table_replace(pdata->proto_count, g_strdup(pdata->protocol), GINT_TO_POINTER(count));
+		pdate = NULL;
+		if (g_hash_table_lookup_extended(pdata->proto_date, pdata->protocol, NULL, &pdate)) {
+
+			pdata_gdate = NULL;
+			if (pdate && strlen(pdate) >= 6) {
+				pdata->pdatestr = g_strdup(pdate);
+				hyear = g_strdup_printf("%.4s", (char*)pdate);
+				hmonth = g_strdup_printf("%.2s", (char*)pdate + 4);
+				hday = g_strdup_printf("%.2s", (char*)pdate + 6);
+				pdata_gdate = g_date_time_new_local(
+						atoi(hyear),
+						atoi(hmonth),
+						atoi(hday), 0, 0, 0);
+				g_free(hyear);
+				g_free(hmonth);
+				g_free(hday);
+			}
+
+			/** When both date in the hash and in the profile are valid we compare the date */
+			if (prof_gdate != NULL && pdata_gdate != NULL ) {
+				gint res = g_date_time_compare( pdata_gdate, prof_gdate );
+				/** If the date in the hash less than the date in the profile, we take the latter */
+				if (res < 0 ) {
+					g_hash_table_replace(pdata->proto_date, g_strdup(pdata->protocol), g_strdup(last_success));
+				} else {
+					g_hash_table_replace(pdata->proto_date, g_strdup(pdata->protocol), g_strdup(pdata->pdatestr));
+				}
+
+			}
+			/** If the date in the profile is NOT valid and the date in the hash is valid we keep the latter */
+			if (prof_gdate == NULL && pdata_gdate != NULL) {
+				g_hash_table_replace(pdata->proto_date, g_strdup(pdata->protocol), g_strdup(pdata->pdatestr));
+			}
+
+			/** If the date in the hash is NOT valid and the date in the profile is valid we keep the latter */
+			if (prof_gdate != NULL && pdata_gdate == NULL) {
+				g_hash_table_replace(pdata->proto_date, g_strdup(pdata->protocol), g_strdup(last_success));
+			}
+			/** If both date are NULL, we insert NULL for that protocol */
+			if ((prof_gdate == NULL && pdata_gdate == NULL) && pdata->pdatestr) {
+				g_hash_table_replace(pdata->proto_date, g_strdup(pdata->protocol), NULL);
+			}
+		} else {
+			/** If there is not the protocol in the hash, we add it */
+			/** If the date in the profile is not NULL we use it */
+			if (pdata->pdatestr) {
+				g_hash_table_replace(pdata->proto_date, g_strdup(pdata->protocol), g_strdup(pdata->pdatestr));
+			}else {
+				/** Otherwise we set it to NULL */
+				g_hash_table_replace(pdata->proto_date, g_strdup(pdata->protocol), NULL);
+			}
+		}
+	}
+	if (pdata_gdate)
+		g_date_time_unref(pdata_gdate);
+	if (prof_gdate)
+		g_date_time_unref(prof_gdate);
+}
+
+/**
+ * Add a JSON member profile_count with a child for each protocol used by the user.
+ * Count how many profiles are in use and for each protocol in use counts of how many
+ * profiles that uses such protocol.
+ *
+ * The data can be expressed as follows:
+ *
+ * | PROTO  | PROF COUNT |
+ * |:-------|-----------:|
+ * | RDP    |  2560      |
+ * | SPICE  |  334       |
+ * | SSH    |  1540      |
+ * | VNC    |  2         |
+ *
+ * | PROTO  | LAST USED |
+ * |:-------|----------:|
+ * | RDP    |  20180129 |
+ * | SPICE  |  20171122 |
+ * | SSH    |  20180111 |
+ *
+ * @return a JSON Node structure containing the protocol usage statistics.
+ *
+ */
+JsonNode *remmina_info_stats_get_profiles()
+{
+	TRACE_CALL(__func__);
+
+	JsonBuilder *b;
+	JsonNode *r;
+	gchar *s;
+
+	gint profiles_count;
+	GHashTableIter pcountiter, pdateiter;
+	gpointer pcountkey, pcountvalue;
+	gpointer pdatekey, pdatevalue;
+
+	struct ProfilesData *pdata;
+	pdata = g_malloc0(sizeof(struct ProfilesData));
+	if (pdata == NULL) {
+		return NULL;
+	}
+
+	b = json_builder_new();
+	if (b == NULL) {
+		g_free(pdata);
+		return NULL;
+	}
+	 
+	json_builder_begin_object(b);
+
+	json_builder_set_member_name(b, "profile_count");
+
+	/** @warning this function is usually executed on a dedicated thread,
+	 * not on the main thread */
+
+	pdata->proto_date = g_hash_table_new_full(g_str_hash, g_str_equal,
+		(GDestroyNotify)g_free, (GDestroyNotify)g_free);
+	pdata->proto_count = g_hash_table_new_full(g_str_hash, g_str_equal,
+		(GDestroyNotify)g_free, NULL);
+
+	profiles_count = remmina_file_manager_iterate(
+		(GFunc)remmina_info_profiles_get_data,
+		(gpointer)pdata);
+
+	json_builder_add_int_value(b, profiles_count);
+
+	g_hash_table_iter_init(&pcountiter, pdata->proto_count);
+	while (g_hash_table_iter_next(&pcountiter, &pcountkey, &pcountvalue)) {
+		json_builder_set_member_name(b, (gchar*)pcountkey);
+		json_builder_add_int_value(b, GPOINTER_TO_INT(pcountvalue));
+	}
+
+	g_hash_table_iter_init(&pdateiter, pdata->proto_date);
+	while (g_hash_table_iter_next(&pdateiter, &pdatekey, &pdatevalue)) {
+		s = g_strdup_printf("DATE_%s", (gchar*)pdatekey);
+		json_builder_set_member_name(b, s);
+		g_free(s);
+		json_builder_add_string_value(b, (gchar*)pdatevalue);
+	}
+
+	json_builder_end_object(b);
+	r = json_builder_get_root(b);
+	g_object_unref(b);
+
+	g_hash_table_remove_all(pdata->proto_date);
+	g_hash_table_unref(pdata->proto_date);
+	g_hash_table_remove_all(pdata->proto_count);
+	g_hash_table_unref(pdata->proto_count);
+
+	g_free(pdata);
+
+	return r;
+}
+
+/**
+ * Add a JSON member ACTIVESECRETPLUGIN which shows the current secret plugin in use by Remmina.
+ *
+ * @return a JSON Node structure containing the secret plugin in use
+ *
+ */
+JsonNode *remmina_info_stats_get_secret_plugin()
+{
+	TRACE_CALL(__func__);
+
+	JsonBuilder *b;
+	JsonNode *r;
+	RemminaSecretPlugin *secret_plugin;
+	secret_plugin = remmina_plugin_manager_get_secret_plugin();
+
+	b = json_builder_new();
+	if (b == NULL) {
+		return NULL;
+	}
+
+	json_builder_begin_object(b);
+
+	if (secret_plugin && secret_plugin->is_service_available) {
+		json_builder_set_member_name(b, "plugin_name");
+		json_builder_add_string_value(b, secret_plugin->name);
+	}
+	json_builder_end_object(b);
+	r = json_builder_get_root(b);
+	g_object_unref(b);
+
+	return r;
+}
+
+/**
+ * Add a JSON member HASPRIMARYPASSWORD which shows the status of the master password.
+ *
+ * @return a JSON Node structure containing the status of the primary password
+ *
+ */
+JsonNode *remmina_info_stats_get_primary_password_status()
+{
+	TRACE_CALL(__func__);
+
+	JsonBuilder *b;
+	JsonNode *r;
+
+	b = json_builder_new();
+	if (b == NULL) {
+		return NULL;
+	}
+
+	json_builder_begin_object(b);
+
+	json_builder_set_member_name(b, "primary_password_status");
+	if (remmina_pref_get_boolean("use_primary_password")) {
+		json_builder_add_string_value(b, "ON");
+	} else {
+		json_builder_add_string_value(b, "OFF");
+	}
+
+	json_builder_end_object(b);
+	r = json_builder_get_root(b);
+	g_object_unref(b);
+
+	return r;
+}
+
+/**
+ * Add a json member KIOSK which shows the status of the kiosk.
+ *
+ * @return a JSON Node structure containing the status of the primary password
+ *
+ */
+JsonNode *remmina_info_stats_get_kiosk_mode()
+{
+	TRACE_CALL(__func__);
+
+	JsonBuilder *b;
+	JsonNode *r;
+
+	b = json_builder_new();
+	if (b == NULL) {
+		return NULL;
+	}
+
+	json_builder_begin_object(b);
+
+	json_builder_set_member_name(b, "kiosk_status");
+	if (!kioskmode && kioskmode == FALSE) {
+		json_builder_add_string_value(b, "OFF");
+	}else {
+		json_builder_add_string_value(b, "ON");
+	}
+
+	json_builder_end_object(b);
+	r = json_builder_get_root(b);
+	g_object_unref(b);
+
+	return r;
+}
+
+JsonNode *remmina_info_stats_get_python()
+{
+	TRACE_CALL(__func__);
+	JsonBuilder *b;
+	JsonNode *r;
+	gchar *version;
+
+	version = remmina_utils_get_python();
+	b = json_builder_new();
+	if(b != NULL)
+	{
+		json_builder_begin_object(b);
+		json_builder_set_member_name(b, "version");
+		if (!version || version[0] == '\0') {
+			json_builder_add_null_value(b);
+		} else {
+			json_builder_add_string_value(b, version);
+		}
+		
+		json_builder_end_object(b);
+		r = json_builder_get_root(b);
+		g_object_unref(b);
+		return r;
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+/**
+ * Get all statistics in JSON format to send periodically to the server.
+ * The caller should free the returned buffer with g_free()
+ * @warning This function is usually executed on a dedicated thread,
+ * not on the main thread.
+ * @return a pointer to the JSON string.
+ */
+JsonNode *remmina_info_stats_get_all()
+{
+	TRACE_CALL(__func__);
+	JsonBuilder *b;
+	JsonNode *n;
+
+	b = json_builder_new();
+	if (b == NULL) {
+		return NULL;
+	}
+	 
+	json_builder_begin_object(b);
+
+	n = remmina_info_stats_get_uid();
+	json_builder_set_member_name(b, "UID");
+	json_builder_add_value(b, n);
+
+	n = remmina_info_stats_get_version();
+	json_builder_set_member_name(b, "REMMINAVERSION");
+	json_builder_add_value(b, n);
+
+	n = remmina_info_stats_get_os_info();
+	json_builder_set_member_name(b, "SYSTEM");
+	json_builder_add_value(b, n);
+
+	n = remmina_info_stats_get_user_env();
+	json_builder_set_member_name(b, "ENVIRONMENT");
+	json_builder_add_value(b, n);
+
+	n = remmina_info_stats_get_gtk_version();
+	json_builder_set_member_name(b, "GTKVERSION");
+	json_builder_add_value(b, n);
+
+	n = remmina_info_stats_get_gtk_backend();
+	json_builder_set_member_name(b, "GTKBACKEND");
+	json_builder_add_value(b, n);
+
+	n = remmina_info_stats_get_wm_name();
+	json_builder_set_member_name(b, "WINDOWMANAGER");
+	json_builder_add_value(b, n);
+
+	n = remmina_info_stats_get_indicator();
+	json_builder_set_member_name(b, "APPINDICATOR");
+	json_builder_add_value(b, n);
+
+	n = remmina_info_stats_get_profiles();
+	json_builder_set_member_name(b, "PROFILES");
+	json_builder_add_value(b, n);
+
+	n = remmina_info_stats_get_secret_plugin();
+	json_builder_set_member_name(b, "ACTIVESECRETPLUGIN");
+	json_builder_add_value(b, n);
+
+	n = remmina_info_stats_get_primary_password_status();
+	json_builder_set_member_name(b, "HASPRIMARYPASSWORD");
+	json_builder_add_value(b, n);
+
+	n = remmina_info_stats_get_kiosk_mode();
+	json_builder_set_member_name(b, "KIOSK");
+	json_builder_add_value(b, n);
+
+	n = remmina_info_stats_get_python();
+	json_builder_set_member_name(b, "PYTHON");
+	json_builder_add_value(b, n);
+
+	n = remmina_info_stats_get_host();
+	json_builder_set_member_name(b, "HOST");
+	json_builder_add_value(b, n);
+
+	json_builder_end_object(b);
+	n = json_builder_get_root(b);
+	g_object_unref(b);
+
+	return n;
+}
+
+void remmina_info_schedule()
+{
+	sc_tdata *data;
+
+	data = g_malloc(sizeof(sc_tdata));
+	if (data == NULL) {
+		return;
+	}
+	data->send_stats = !info_disable_stats;
+
+	remmina_scheduler_setup(remmina_info_periodic_check,
+			data,
+			INFO_PERIODIC_CHECK_1ST_MS,
+			INFO_PERIODIC_CHECK_INTERVAL_MS);
+}
+
+static void remmina_info_close_clicked(GtkButton *btn, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	if (remmina_info_dialog->dialog) {
+		gtk_widget_destroy(GTK_WIDGET(remmina_info_dialog->dialog));
+	}
+	remmina_info_dialog->dialog = NULL;
+	g_free(remmina_info_dialog);
+	remmina_info_dialog = NULL;
+}
+
+static gboolean remmina_info_dialog_deleted(GtkButton *btn, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gtk_widget_destroy(GTK_WIDGET(remmina_info_dialog->dialog));
+	remmina_info_dialog->dialog = NULL;
+	g_free(remmina_info_dialog);
+	remmina_info_dialog = NULL;
+
+	return FALSE;
+}
+
+
+
+gboolean remmina_info_show_response(gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	GtkWindow * parent = remmina_main_get_window();
+	remmina_info_dialog = g_new0(RemminaInfoDialog, 1);
+	remmina_info_dialog->retval = 1;
+
+	RemminaInfoMessage *message = (RemminaInfoMessage*)user_data;
+
+	remmina_info_dialog->builder = remmina_public_gtk_builder_new_from_resource("/org/remmina/Remmina/src/../data/ui/remmina_info.glade");
+	remmina_info_dialog->dialog = GTK_DIALOG(gtk_builder_get_object(remmina_info_dialog->builder, "RemminaInfoDialog"));
+
+	remmina_info_dialog->remmina_info_text_view = GTK_TEXT_VIEW(GET_OBJ("remmina_info_text_view"));
+	remmina_info_dialog->remmina_info_label = GTK_LABEL(GET_OBJ("remmina_info_label"));
+
+	remmina_info_dialog->remmina_info_button_close = GTK_BUTTON(GET_OBJ("remmina_info_button_close"));
+	gtk_widget_set_can_default(GTK_WIDGET(remmina_info_dialog->remmina_info_button_close), TRUE);
+	gtk_widget_grab_default(GTK_WIDGET(remmina_info_dialog->remmina_info_button_close));
+
+	gtk_label_set_markup(remmina_info_dialog->remmina_info_label, message->info_string);
+
+	g_signal_connect(remmina_info_dialog->remmina_info_button_close, "clicked",
+			 G_CALLBACK(remmina_info_close_clicked), (gpointer)remmina_info_dialog);
+	g_signal_connect(remmina_info_dialog->dialog, "close",
+			 G_CALLBACK(remmina_info_close_clicked), NULL);
+	g_signal_connect(remmina_info_dialog->dialog, "delete-event",
+			 G_CALLBACK(remmina_info_dialog_deleted), NULL);
+
+	/* Connect signals */
+	gtk_builder_connect_signals(remmina_info_dialog->builder, NULL);
+
+	/* Show the modal news dialog */
+	gtk_widget_show_all(GTK_WIDGET(remmina_info_dialog->dialog));
+	gtk_window_present(GTK_WINDOW(remmina_info_dialog->dialog));
+	if (parent) {
+		gtk_window_set_transient_for(GTK_WINDOW(remmina_info_dialog->dialog), parent);
+	}
+	gtk_window_set_modal(GTK_WINDOW(remmina_info_dialog->dialog), TRUE);
+	gtk_window_set_title(GTK_WINDOW(remmina_info_dialog->dialog), message->title_string);
+	g_free(message);
+	return FALSE;
+}
+
+
+/**
+ * Post request to info server
+ * 
+ * @return gboolean 
+ */
+static gboolean remmina_info_stats_collector_done(gpointer data)
+{
+	JsonNode *n;
+	JsonGenerator *g;
+	gchar *unenc_s, *enc_s;
+	JsonBuilder *b;
+	JsonObject *o;
+	gchar *uid;
+	JsonNode *root;
+
+	root = (JsonNode *)data;
+	if (root == NULL) {
+		return G_SOURCE_REMOVE;
+	}
+
+	n = root;
+
+	if ((o = json_node_get_object(n)) == NULL) {
+		g_free(data);
+		return G_SOURCE_REMOVE;
+	}
+
+	uid = g_strdup(json_object_get_string_member(o, "UID"));
+
+	g = json_generator_new();
+	json_generator_set_root(g, n);
+	json_node_unref(n);
+	unenc_s = json_generator_to_data(g, NULL);
+	g_object_unref(g);
+
+	EVP_PKEY *remmina_pubkey = remmina_get_pubkey(RSA_KEYTYPE, remmina_RSA_PubKey_v1);
+	if (remmina_pubkey == NULL) {
+		g_free(uid);
+		g_free(unenc_s);
+		return G_SOURCE_REMOVE;
+	}
+	enc_s = remmina_rsa_encrypt_string(remmina_pubkey, unenc_s);
+	if (enc_s == NULL) {
+		g_free(uid);
+		g_free(unenc_s);
+		return G_SOURCE_REMOVE;
+	}
+	
+	b = json_builder_new();
+	if (b == NULL) {
+		return G_SOURCE_REMOVE;
+	}
+
+
+	EVP_PKEY_free(remmina_pubkey);
+	json_builder_begin_object(b);
+	json_builder_set_member_name(b, "keyversion");
+	json_builder_add_int_value(b, 1);
+	json_builder_set_member_name(b, "encdata");
+	json_builder_add_string_value(b, enc_s);
+	json_builder_set_member_name(b, "UID");
+	json_builder_add_string_value(b, uid);
+	json_builder_set_member_name(b, "news_enabled");
+	json_builder_add_int_value(b, TRUE ? 0 : 1);
+	json_builder_set_member_name(b, "stats_enabled");
+	json_builder_add_int_value(b, TRUE ? 0 : 1);
+	json_builder_set_member_name(b, "tip_enabled");
+	json_builder_add_int_value(b, TRUE ? 0 : 1);
+
+
+	json_builder_end_object(b);
+	n = json_builder_get_root(b);
+
+	g_free(unenc_s);
+	g_object_unref(b);
+	g_free(uid);
+	g_free(enc_s);
+
+	g = json_generator_new();
+	json_generator_set_root(g, n);
+	enc_s = json_generator_to_data(g, NULL);
+	g_object_unref(g);
+
+	remmina_curl_compose_message(enc_s, "POST",  PERIODIC_UPLOAD_URL, NULL);
+
+	json_node_unref(n);
+
+	return G_SOURCE_REMOVE;
+}
+
+/**
+ * Collect stats and notify when collection is done
+ * 
+ * @return gpointer
+ */
+gpointer remmina_info_stats_collector()
+{
+	JsonNode *n;
+
+	n = remmina_info_stats_get_all();
+
+	/* Stats collecting is done. Notify main thread calling
+	 * remmina_info_stats_collector_done() */
+	g_idle_add(remmina_info_stats_collector_done, n);
+
+	return NULL;
+}
+
+void remmina_info_request(gpointer data)
+{
+	// send initial handshake here, in a callback decide how to handle response
+
+	JsonNode *n;
+	JsonGenerator *g;
+	gchar *enc_s;
+	JsonBuilder *b;
+	const gchar *uid = "000000";
+
+	n = remmina_info_stats_get_uid();
+	if (n != NULL){
+		uid = json_node_get_string(n);
+	}
+
+	b = json_builder_new();
+	if (b == NULL) {
+		return;
+	}
+
+	json_builder_begin_object(b);
+	json_builder_set_member_name(b, "keyversion");
+	json_builder_add_int_value(b, 1);
+	json_builder_set_member_name(b, "UID");
+	json_builder_add_string_value(b, uid);
+	json_builder_set_member_name(b, "news_enabled");
+	json_builder_add_int_value(b, info_disable_news ? 0 : 1);
+	json_builder_set_member_name(b, "stats_enabled");
+	json_builder_add_int_value(b, info_disable_stats ? 0 : 1);
+	json_builder_set_member_name(b, "tip_enabled");
+	json_builder_add_int_value(b, info_disable_tip ? 0 : 1);
+
+
+	json_builder_end_object(b);
+	n = json_builder_get_root(b);
+
+	g_object_unref(b);
+
+
+	g = json_generator_new();
+	json_generator_set_root(g, n);
+	enc_s = json_generator_to_data(g, NULL);
+	g_object_unref(g);
+	remmina_curl_compose_message(enc_s, "POST", INFO_REQUEST_URL, NULL);
+	json_node_unref(n);
+}
+
+gboolean remmina_info_periodic_check(gpointer user_data)
+{
+	remmina_info_request(user_data);
+	return G_SOURCE_CONTINUE;
+}
diff --git a/src/remmina_info.h b/src/remmina_info.h
new file mode 100644
index 0000000..09fe698
--- /dev/null
+++ b/src/remmina_info.h
@@ -0,0 +1,71 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2016-2023 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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.
+ *
+ */
+
+#pragma once
+
+#include <glib.h>
+#include "json-glib/json-glib.h"
+
+G_BEGIN_DECLS
+
+JsonNode *remmina_info_stats_get_all(void);
+JsonNode *remmina_info_stats_get_os_info(void);
+JsonNode *remmina_info_stats_get_python(void);
+JsonNode *remmina_info_stats_get_uid(void);
+gboolean  remmina_info_show_response(gpointer user_data);
+gpointer remmina_info_stats_collector();
+gboolean remmina_info_periodic_check(gpointer user_data);
+void remmina_info_schedule(void);
+
+typedef struct _RemminaInfoDialog
+{
+    GtkBuilder *builder;
+    GtkDialog  *dialog;
+
+    GtkTextView *remmina_info_text_view;
+    GtkLabel    *remmina_info_label;
+    GtkButton   *remmina_info_button_close;
+    
+    gint retval;
+} RemminaInfoDialog;
+
+typedef struct _RemminaInfoMessage
+{
+    const gchar *info_string;
+    const gchar *title_string;
+
+} RemminaInfoMessage;
+
+G_END_DECLS
diff --git a/src/remmina_key_chooser.c b/src/remmina_key_chooser.c
new file mode 100644
index 0000000..69a87c7
--- /dev/null
+++ b/src/remmina_key_chooser.c
@@ -0,0 +1,146 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009-2010 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 <glib/gi18n.h>
+#include "remmina_key_chooser.h"
+#include "remmina_public.h"
+#include "remmina/remmina_trace_calls.h"
+
+/* Handle key-presses on the GtkEventBox */
+static gboolean remmina_key_chooser_dialog_on_key_press(GtkWidget *widget, GdkEventKey *event, RemminaKeyChooserArguments *arguments)
+{
+	TRACE_CALL(__func__);
+	if (!arguments->use_modifiers || !event->is_modifier) {
+		arguments->state = event->state;
+		arguments->keyval = gdk_keyval_to_lower(event->keyval);
+		gtk_dialog_response(GTK_DIALOG(gtk_widget_get_toplevel(widget)),
+			event->keyval == GDK_KEY_Escape ? GTK_RESPONSE_CANCEL : GTK_RESPONSE_OK);
+	}
+	return TRUE;
+}
+
+/* User option to use key modifiers when selecting keyboard shortcuts */
+void remmina_key_chooser_dialog_set_option_modifier(GtkWidget *widget, gboolean state, RemminaKeyChooserArguments *arguments)
+{
+	TRACE_CALL(__func__);
+	gtk_switch_set_state(GTK_SWITCH(widget), state);
+	arguments->use_modifiers = state;
+}
+
+/* Show a key chooser dialog and return the keyval for the selected key */
+RemminaKeyChooserArguments* remmina_key_chooser_new(GtkWindow *parent_window, gboolean use_modifiers)
+{
+	TRACE_CALL(__func__);
+	GtkBuilder *builder = remmina_public_gtk_builder_new_from_resource ("/org/remmina/Remmina/src/../data/ui/remmina_key_chooser.glade");
+	GtkDialog *dialog;
+	RemminaKeyChooserArguments *arguments;
+	arguments = g_new0(RemminaKeyChooserArguments, 1);
+	arguments->state = 0;
+	arguments->use_modifiers = use_modifiers;
+
+	/* Setup the dialog */
+	dialog = GTK_DIALOG(gtk_builder_get_object(builder, "KeyChooserDialog"));
+	gtk_window_set_transient_for(GTK_WINDOW(dialog), parent_window);
+
+	/* Connect the key modifier switch signal */
+	g_signal_connect(gtk_builder_get_object(builder, "switch_option_key_modifier"), "state-set",
+		G_CALLBACK(remmina_key_chooser_dialog_set_option_modifier), arguments);
+	
+	/* Connect the GtkEventBox signal */
+	g_signal_connect(gtk_builder_get_object(builder, "eventbox_key_chooser"), "key-press-event",
+		G_CALLBACK(remmina_key_chooser_dialog_on_key_press), arguments);
+			
+	/* Show the dialog and destroy it after the use */
+	arguments->response = gtk_dialog_run(dialog);
+	gtk_widget_destroy(GTK_WIDGET(dialog));
+	/* The delete button set the keyval 0 */
+	if (arguments->response == GTK_RESPONSE_REJECT)
+		arguments->keyval = 0;
+	return arguments;
+}
+
+/* Get the uppercase character value of a keyval */
+gchar* remmina_key_chooser_get_value(guint keyval, guint state)
+{
+	TRACE_CALL(__func__);
+
+	if (!keyval)
+		return g_strdup(KEY_CHOOSER_NONE);
+
+	return g_strdup_printf("%s%s%s%s%s%s%s",
+		(state & GDK_SHIFT_MASK) ? KEY_MODIFIER_SHIFT : "",
+		(state & GDK_CONTROL_MASK) ? KEY_MODIFIER_CTRL : "",
+		(state & GDK_MOD1_MASK) ? KEY_MODIFIER_ALT : "",
+		(state & GDK_SUPER_MASK) ? KEY_MODIFIER_SUPER : "",
+		(state & GDK_HYPER_MASK) ? KEY_MODIFIER_HYPER : "",
+		(state & GDK_META_MASK) ? KEY_MODIFIER_META : "",
+		gdk_keyval_name(gdk_keyval_to_upper(keyval)));
+}
+
+/* Get the keyval of a (lowercase) character value */
+guint remmina_key_chooser_get_keyval(const gchar *value)
+{
+	TRACE_CALL(__func__);
+	gchar *patterns[] =
+	{
+		KEY_MODIFIER_SHIFT,
+		KEY_MODIFIER_CTRL,
+		KEY_MODIFIER_ALT,
+		KEY_MODIFIER_SUPER,
+		KEY_MODIFIER_HYPER,
+		KEY_MODIFIER_META,
+		NULL
+	};
+	gint i;
+	gchar *tmpvalue;
+	gchar *newvalue;
+	guint keyval;
+
+	if (g_strcmp0(value, KEY_CHOOSER_NONE) == 0)
+		return 0;
+
+	/* Remove any modifier text before to get the keyval */
+	newvalue = g_strdup(value);
+	for (i = 0; i < g_strv_length(patterns); i++) {
+		tmpvalue = remmina_public_str_replace(newvalue, patterns[i], "");
+		g_free(newvalue);
+		newvalue = g_strdup(tmpvalue);
+		g_free(tmpvalue);
+	}
+	keyval = gdk_keyval_to_lower(gdk_keyval_from_name(newvalue));
+	g_free(newvalue);
+	return keyval;
+}
diff --git a/src/remmina_key_chooser.h b/src/remmina_key_chooser.h
new file mode 100644
index 0000000..a236932
--- /dev/null
+++ b/src/remmina_key_chooser.h
@@ -0,0 +1,64 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010 Vic Lee
+ * Copyright (C) 2017-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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+#define KEY_MODIFIER_SHIFT _("Shift+")
+#define KEY_MODIFIER_CTRL _("Ctrl+")
+#define KEY_MODIFIER_ALT _("Alt+")
+#define KEY_MODIFIER_SUPER _("Super+")
+#define KEY_MODIFIER_HYPER _("Hyper+")
+#define KEY_MODIFIER_META _("Meta+")
+#define KEY_CHOOSER_NONE _("<None>")
+
+typedef struct _RemminaKeyChooserArguments {
+	guint		keyval;
+	guint		state;
+	gboolean	use_modifiers;
+	gint		response;
+} RemminaKeyChooserArguments;
+
+G_BEGIN_DECLS
+
+/* Show a key chooser dialog and return the keyval for the selected key */
+RemminaKeyChooserArguments *remmina_key_chooser_new(GtkWindow *parent_window, gboolean use_modifiers);
+/* Get the uppercase character value of a keyval */
+gchar *remmina_key_chooser_get_value(guint keyval, guint state);
+/* Get the keyval of a (lowercase) character value */
+guint remmina_key_chooser_get_keyval(const gchar *value);
+
+G_END_DECLS
diff --git a/src/remmina_log.c b/src/remmina_log.c
new file mode 100644
index 0000000..be855cc
--- /dev/null
+++ b/src/remmina_log.c
@@ -0,0 +1,505 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010 Vic Lee
+ * Copyright (C) 2014-2015 Antenore Gatta, Fabio Castelli, Giovanni Panozzo
+ * Copyright (C) 2016-2023 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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 <gtk/gtk.h>
+#include <glib/gi18n.h>
+#include "remmina_public.h"
+#include "remmina_pref.h"
+#include "remmina_log.h"
+#include "remmina_info.h"
+#include "remmina/remmina_trace_calls.h"
+
+gboolean logstart;
+
+/***** Define the log window GUI *****/
+#define REMMINA_TYPE_LOG_WINDOW               (remmina_log_window_get_type())
+#define REMMINA_LOG_WINDOW(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), REMMINA_TYPE_LOG_WINDOW, RemminaLogWindow))
+#define REMMINA_LOG_WINDOW_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), REMMINA_TYPE_LOG_WINDOW, RemminaLogWindowClass))
+#define REMMINA_IS_LOG_WINDOW(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), REMMINA_TYPE_LOG_WINDOW))
+#define REMMINA_IS_LOG_WINDOW_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), REMMINA_TYPE_LOG_WINDOW))
+#define REMMINA_LOG_WINDOW_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), REMMINA_TYPE_LOG_WINDOW, RemminaLogWindowClass))
+
+typedef struct _RemminaLogWindow {
+	GtkWindow window;
+
+	GtkWidget *log_view;
+	GtkTextBuffer *log_buffer;
+} RemminaLogWindow;
+
+typedef struct _RemminaLogWindowClass {
+	GtkWindowClass parent_class;
+} RemminaLogWindowClass;
+
+GType remmina_log_window_get_type(void)
+G_GNUC_CONST;
+
+G_DEFINE_TYPE(RemminaLogWindow, remmina_log_window, GTK_TYPE_WINDOW)
+
+void remmina_log_stats()
+{
+	TRACE_CALL(__func__);
+	JsonNode *n;
+
+	n = remmina_info_stats_get_all();
+	if (n != NULL) {
+
+		JsonGenerator *g = json_generator_new();
+		json_generator_set_pretty (g, TRUE);
+		json_generator_set_root(g, n);
+		json_node_unref(n);
+		g_autofree gchar *s = json_generator_to_data(g, NULL);	// s=serialized stats
+		REMMINA_DEBUG("STATS: JSON data%s\n", s);
+		g_object_unref(g);
+	}
+}
+
+static void remmina_log_window_class_init(RemminaLogWindowClass *klass)
+{
+	TRACE_CALL(__func__);
+}
+
+/* We will always only have one log window per instance */
+static GtkWidget *log_window = NULL;
+
+static GtkWidget*
+remmina_log_window_new(void)
+{
+	TRACE_CALL(__func__);
+	return GTK_WIDGET(g_object_new(REMMINA_TYPE_LOG_WINDOW, NULL));
+}
+
+static void remmina_log_end(GtkWidget *widget, gpointer data)
+{
+	TRACE_CALL(__func__);
+	log_window = NULL;
+}
+
+static void remmina_log_start_stop (GtkSwitch *logswitch, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	logstart = !logstart;
+}
+
+void remmina_log_start(void)
+{
+	TRACE_CALL(__func__);
+	if (log_window) {
+		gtk_window_present(GTK_WINDOW(log_window));
+	}else  {
+		log_window = remmina_log_window_new();
+		gtk_window_set_default_size(GTK_WINDOW(log_window), 640, 480);
+		gtk_window_set_resizable (GTK_WINDOW(log_window), TRUE);
+		gtk_window_set_decorated (GTK_WINDOW(log_window), TRUE);
+
+		/* Header bar */
+		GtkWidget *header = gtk_header_bar_new ();
+		gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (header), TRUE);
+		gtk_header_bar_set_title (GTK_HEADER_BAR (header), _("Remmina debugging window"));
+		gtk_header_bar_set_has_subtitle (GTK_HEADER_BAR (header), FALSE);
+		/* Stats */
+		GtkWidget *getstat = gtk_button_new ();
+		gtk_widget_set_tooltip_text (getstat, _("Paste system info in the Remmina debugging window"));
+		GIcon *icon = g_themed_icon_new ("edit-paste-symbolic");
+		GtkWidget *image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_BUTTON);
+		g_object_unref (icon);
+		gtk_container_add (GTK_CONTAINER (getstat), image);
+		gtk_header_bar_pack_start (GTK_HEADER_BAR (header), getstat);
+		/* Start logging */
+		GtkWidget *start = gtk_switch_new ();
+		logstart = TRUE;
+		gtk_switch_set_active (GTK_SWITCH(start), logstart);
+		gtk_widget_set_valign (start, GTK_ALIGN_CENTER);
+		gtk_header_bar_pack_start (GTK_HEADER_BAR (header), start);
+
+		gtk_window_set_titlebar (GTK_WINDOW (log_window), header);
+
+		g_signal_connect(getstat, "button-press-event", G_CALLBACK(remmina_log_stats), NULL);
+		g_signal_connect(start, "notify::active", G_CALLBACK(remmina_log_start_stop), NULL);
+		g_signal_connect(G_OBJECT(log_window), "destroy", G_CALLBACK(remmina_log_end), NULL);
+		gtk_widget_show_all(log_window);
+	}
+
+	remmina_log_print(_("This window can help you find connection problems.\n"
+		"You can stop and start the logging at any moment using the On/Off switch.\n"
+		"The stats button (Ctrl+T), can be useful to gather system info you may share when reporting a bug.\n"
+		"There is more info about debugging Remmina on https://gitlab.com/Remmina/Remmina/-/wikis/Usage/Remmina-debugging\n"
+		));
+}
+
+gboolean remmina_log_running(void)
+{
+	TRACE_CALL(__func__);
+	return (log_window != NULL);
+}
+
+static gboolean remmina_log_scroll_to_end(gpointer data)
+{
+	TRACE_CALL(__func__);
+	GtkTextIter iter;
+
+	if (log_window) {
+		gtk_text_buffer_get_end_iter(REMMINA_LOG_WINDOW(log_window)->log_buffer, &iter);
+		gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(REMMINA_LOG_WINDOW(log_window)->log_view), &iter, 0.0, FALSE, 0.0,
+			0.0);
+	}
+	return FALSE;
+}
+
+static gboolean remmina_log_print_real(gpointer data)
+{
+	TRACE_CALL(__func__);
+	GtkTextIter iter;
+
+	if (log_window && logstart) {
+		gtk_text_buffer_get_end_iter(REMMINA_LOG_WINDOW(log_window)->log_buffer, &iter);
+		gtk_text_buffer_insert(REMMINA_LOG_WINDOW(log_window)->log_buffer, &iter, (const gchar*)data, -1);
+		IDLE_ADD(remmina_log_scroll_to_end, NULL);
+	}
+	g_free(data);
+	return FALSE;
+}
+
+// Only prints into Remmina's own debug window. (Not stdout!)
+// See _remmina_{debug, info, error, critical, warning}
+void remmina_log_print(const gchar *text)
+{
+	TRACE_CALL(__func__);
+	if (!log_window)
+		return;
+
+	IDLE_ADD(remmina_log_print_real, g_strdup(text));
+}
+
+void remmina_log_file_append(gchar *text) {
+	gchar *log_filename = g_build_filename(g_get_tmp_dir(), LOG_FILE_NAME, NULL);
+	FILE *log_file = fopen(log_filename, "a");
+	g_free(log_filename);
+	
+	if (log_file != NULL)
+	{
+		gchar* text_log = g_strconcat(text, "\n", NULL);
+		fwrite(text_log, sizeof(char), strlen(text_log), log_file);
+		fclose(log_file);
+		g_free(text_log);
+	}
+}
+
+void _remmina_info(const gchar *fmt, ...)
+{
+	TRACE_CALL(__func__);
+
+	va_list args;
+	g_autofree gchar *text;
+	va_start(args, fmt);
+	text = g_strdup_vprintf(fmt, args);
+	va_end(args);
+
+	// Append text to remmina_log_file.log
+	remmina_log_file_append(text);
+
+	// always appends newline
+	g_info ("%s", text);
+
+	g_autofree gchar *buf_tmp = g_strconcat(text, "\n", NULL);
+	/* freed in remmina_log_print_real */
+	gchar *bufn = g_strconcat("(INFO) - ", buf_tmp, NULL);
+
+	if (!log_window) {
+		free(bufn);
+		return;
+	}
+	IDLE_ADD(remmina_log_print_real, bufn);
+}
+
+void _remmina_message(const gchar *fmt, ...)
+{
+	TRACE_CALL(__func__);
+
+	va_list args;
+	g_autofree gchar *text;
+	va_start(args, fmt);
+	text = g_strdup_vprintf(fmt, args);
+	va_end(args);
+
+	// Append text to remmina_log_file.log
+	remmina_log_file_append(text);
+
+	// always appends newline
+	g_message ("%s", text);
+
+	if (!log_window) {
+		return;
+	}
+
+	g_autofree gchar *buf_tmp = g_strconcat(text, "\n", NULL);
+	/* freed in remmina_log_print_real */
+	gchar *bufn = g_strconcat("(MESSAGE) - ", buf_tmp, NULL);
+
+	IDLE_ADD(remmina_log_print_real, bufn);
+}
+
+/**
+ * Print a string in the Remmina Debug Windows and in the terminal.
+ * The string will be visible in the terminal if G_MESSAGES_DEBUG=remmina
+ * Variadic function of REMMINA_DEBUG
+ */
+void _remmina_debug(const gchar *fun, const gchar *fmt, ...)
+{
+	TRACE_CALL(__func__);
+
+	va_list args;
+	gchar *text;
+	va_start(args, fmt);
+	text = g_strdup_vprintf(fmt, args);
+	va_end(args);
+
+	// Append text to remmina_log_file.log
+	remmina_log_file_append(text);
+
+	g_autofree gchar *buf = g_strconcat("(", fun, ") - ", text, NULL);
+	g_free(text);
+
+	// always appends newline
+	g_debug ("%s", buf);
+
+	if (!log_window) {
+		return;
+	}
+
+	g_autofree gchar *buf_tmp = g_strconcat(buf, "\n", NULL);
+	/* freed in remmina_log_print_real */
+	gchar *bufn = g_strconcat("(DEBUG) - ", buf_tmp, NULL);
+
+	IDLE_ADD(remmina_log_print_real, bufn);
+}
+
+void _remmina_warning(const gchar *fun, const gchar *fmt, ...)
+{
+	TRACE_CALL(__func__);
+
+	va_list args;
+	gchar *text;
+	va_start(args, fmt);
+	text = g_strdup_vprintf(fmt, args);
+	va_end(args);
+
+	// Append text to remmina_log_file.log
+	remmina_log_file_append(text);
+
+	g_autofree gchar *buf = g_strconcat("(", fun, ") - ", text, NULL);
+	g_free(text);
+
+	// always appends newline
+	g_warning ("%s", buf);
+
+	if (!log_window) {
+		return;
+	}
+
+	g_autofree gchar *buf_tmp = g_strconcat(buf, "\n", NULL);
+	/* freed in remmina_log_print_real */
+	gchar *bufn = g_strconcat("(WARN) - ", buf_tmp, NULL);
+
+	IDLE_ADD(remmina_log_print_real, bufn);
+}
+
+void _remmina_audit(const gchar *fun, const gchar *fmt, ...)
+{
+	TRACE_CALL(__func__);
+	va_list args;
+	va_start(args, fmt);
+	gchar *text = g_strdup_vprintf(fmt, args);
+	va_end(args);
+
+	// Append text to remmina_log_file.log
+	remmina_log_file_append(text);
+
+#if GLIB_CHECK_VERSION(2,62,0)
+	GDateTime* tv = g_date_time_new_now_local();
+	gchar *isodate = g_date_time_format_iso8601(tv);
+	g_date_time_unref(tv);
+#else
+	GTimeVal tv;
+	g_get_current_time(&tv);
+	gchar *isodate = g_time_val_to_iso8601(&tv);
+#endif
+
+	g_autofree gchar *buf = g_strdup("");
+
+	if (isodate) {
+
+		buf = g_strconcat(
+				"[", isodate, "] - ",
+				g_get_host_name (),
+				" - ",
+				g_get_user_name (),
+				" - ",
+				text,
+				NULL);
+
+	}
+
+	g_free(text);
+	if (remmina_pref_get_boolean("audit"))
+		_remmina_message(buf);
+	else
+		_remmina_debug(fun, buf);
+}
+
+// !!! Calling this function will crash Remmina !!!
+// !!! purposefully and send a trap signal !!!
+void _remmina_error(const gchar *fun, const gchar *fmt, ...)
+{
+	TRACE_CALL(__func__);
+
+	va_list args;
+	gchar *text;
+	va_start(args, fmt);
+	text = g_strdup_vprintf(fmt, args);
+	va_end(args);
+
+	// Append text to remmina_log_file.log
+	remmina_log_file_append(text);
+
+	g_autofree gchar *buf = g_strconcat("(", fun, ") - ", text, NULL);
+	g_free(text);
+
+	// always appends newline
+	g_error ("%s", buf);
+
+	if (!log_window) {
+		return;
+	}
+
+	g_autofree gchar *buf_tmp = g_strconcat(buf, "\n", NULL);
+	/* freed in remmina_log_print_real */
+	gchar *bufn = g_strconcat("(ERROR) - ", buf_tmp, NULL);
+
+	IDLE_ADD(remmina_log_print_real, bufn);
+}
+
+void _remmina_critical(const gchar *fun, const gchar *fmt, ...)
+{
+	TRACE_CALL(__func__);
+
+	va_list args;
+	gchar *text;
+	va_start(args, fmt);
+	text = g_strdup_vprintf(fmt, args);
+	va_end(args);
+
+	// Append text to remmina_log_file.log
+	remmina_log_file_append(text);
+
+	g_autofree gchar *buf = g_strconcat("(", fun, ") - ", text, NULL);
+	g_free(text);
+
+	// always appends newline
+	g_critical ("%s", buf);
+
+	if (!log_window) {
+		return;
+	}
+
+	g_autofree gchar *buf_tmp = g_strconcat(buf, "\n", NULL);
+	/* freed in remmina_log_print_real */
+	gchar *bufn = g_strconcat("(CRIT) - ", buf_tmp, NULL);
+
+	IDLE_ADD(remmina_log_print_real, bufn);
+}
+
+// Only prints into Remmina's own debug window. (Not stdout!)
+// See _remmina_{message, info, debug warning, error, critical}
+void remmina_log_printf(const gchar *fmt, ...)
+{
+	TRACE_CALL(__func__);
+	va_list args;
+	gchar *text;
+
+	if (!log_window) return;
+
+	va_start(args, fmt);
+	text = g_strdup_vprintf(fmt, args);
+	va_end(args);
+
+	IDLE_ADD(remmina_log_print_real, text);
+}
+
+static gboolean remmina_log_on_keypress(GtkWidget *widget, GdkEvent *event, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+
+	if (!log_window)
+		return FALSE;
+
+	GdkEventKey *e = (GdkEventKey *)event;
+
+	if ((e->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK) {
+		if (e->keyval == GDK_KEY_t) {
+			remmina_log_stats();
+		}
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+static void remmina_log_window_init(RemminaLogWindow *logwin)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *scrolledwindow;
+	GtkWidget *widget;
+
+	gtk_container_set_border_width(GTK_CONTAINER(logwin), 4);
+
+	scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
+	gtk_widget_show(scrolledwindow);
+	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
+	gtk_container_add(GTK_CONTAINER(logwin), scrolledwindow);
+
+	widget = gtk_text_view_new();
+	gtk_widget_show(widget);
+	gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(widget), GTK_WRAP_WORD_CHAR);
+	gtk_text_view_set_editable(GTK_TEXT_VIEW(widget), FALSE);
+	gtk_text_view_set_monospace(GTK_TEXT_VIEW(widget), TRUE);
+	gtk_container_add(GTK_CONTAINER(scrolledwindow), widget);
+	logwin->log_view = widget;
+	logwin->log_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
+
+	g_signal_connect(G_OBJECT(logwin->log_view), "key-press-event", G_CALLBACK(remmina_log_on_keypress), (gpointer)logwin);
+}
+
diff --git a/src/remmina_log.h b/src/remmina_log.h
new file mode 100644
index 0000000..d3d4a75
--- /dev/null
+++ b/src/remmina_log.h
@@ -0,0 +1,66 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010 Vic Lee
+ * Copyright (C) 2017-2023 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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.
+ *
+ */
+
+#pragma once
+
+#include <stdarg.h>
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+#define LOG_FILE_NAME "remmina_log_file.log"
+#define REMMINA_INFO(fmt, ...)     _remmina_info(fmt, ## __VA_ARGS__)
+#define REMMINA_MESSAGE(fmt, ...)  _remmina_message(fmt, ## __VA_ARGS__)
+#define REMMINA_DEBUG(fmt, ...)    _remmina_debug(__func__, fmt, ## __VA_ARGS__)
+#define REMMINA_WARNING(fmt, ...)  _remmina_warning(__func__, fmt, ## __VA_ARGS__)
+#define REMMINA_AUDIT(fmt, ...)    _remmina_audit(__func__, fmt, ## __VA_ARGS__)
+#define REMMINA_ERROR(fmt, ...)    _remmina_error(__func__, fmt, ## __VA_ARGS__)
+#define REMMINA_CRITICAL(fmt, ...) _remmina_critical(__func__, fmt, ## __VA_ARGS__)
+
+void remmina_log_start(void);
+gboolean remmina_log_running(void);
+void remmina_log_print(const gchar *text);
+void remmina_log_file_append(gchar *text);
+void _remmina_info(const gchar *fmt, ...);
+void _remmina_message(const gchar *fmt, ...);
+void _remmina_debug(const gchar *fun, const gchar *fmt, ...);
+void _remmina_warning(const gchar *fun, const gchar *fmt, ...);
+void _remmina_audit(const gchar *fun, const gchar *fmt, ...);
+void _remmina_error(const gchar *fun, const gchar *fmt, ...);
+void _remmina_critical(const gchar *fun, const gchar *fmt, ...);
+void remmina_log_printf(const gchar *fmt, ...);
+
+G_END_DECLS
diff --git a/src/remmina_main.c b/src/remmina_main.c
new file mode 100644
index 0000000..81c78f3
--- /dev/null
+++ b/src/remmina_main.c
@@ -0,0 +1,1844 @@
+/*
+ * 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-2022 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2022-2023 Antenore Gatta, Giovanni Panozzo, Hiroyuki Tanaka
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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 <ctype.h>
+#include <gio/gio.h>
+#ifndef __APPLE__
+#include <gio/gdesktopappinfo.h>
+#endif
+#include <gdk/gdkkeysyms.h>
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#include "remmina.h"
+#include "remmina_string_array.h"
+#include "remmina_public.h"
+#include "remmina_file.h"
+#include "remmina_file_manager.h"
+#include "remmina_file_editor.h"
+#include "rcw.h"
+#include "remmina_about.h"
+#include "remmina_pref.h"
+#include "remmina_pref_dialog.h"
+#include "remmina_widget_pool.h"
+#include "remmina_plugin_manager.h"
+#include "remmina_bug_report.h"
+#include "remmina_log.h"
+#include "remmina_icon.h"
+#include "remmina_main.h"
+#include "remmina_exec.h"
+#include "remmina_mpchange.h"
+#include "remmina_external_tools.h"
+#include "remmina_unlock.h"
+#include "remmina/remmina_trace_calls.h"
+
+static RemminaMain *remminamain;
+
+#define RM_GET_OBJECT(object_name) gtk_builder_get_object(remminamain->builder, object_name)
+
+enum {
+	PROTOCOL_COLUMN,
+	NAME_COLUMN,
+	GROUP_COLUMN,
+	SERVER_COLUMN,
+	PLUGIN_COLUMN,
+	DATE_COLUMN,
+	FILENAME_COLUMN,
+	LABELS_COLUMN,
+	NOTES_COLUMN,
+	N_COLUMNS
+};
+
+static
+const gchar *supported_mime_types[] = {
+	"x-scheme-handler/rdp",
+	"x-scheme-handler/spice",
+	"x-scheme-handler/vnc",
+	"x-scheme-handler/remmina",
+	"application/x-remmina",
+	NULL
+};
+
+static GActionEntry app_actions[] = {
+	{ "about",	 remmina_main_on_action_application_about,	 NULL, NULL, NULL },
+	{ "default",	 remmina_main_on_action_application_default,	 NULL, NULL, NULL },
+	{ "mpchange",	 remmina_main_on_action_application_mpchange,	 NULL, NULL, NULL },
+	{ "plugins",	 remmina_main_on_action_application_plugins,	 NULL, NULL, NULL },
+	{ "preferences", remmina_main_on_action_application_preferences, "i",  NULL, NULL },
+	{ "bug_report",  remmina_main_on_action_application_bug_report, NULL, NULL, NULL},
+	{ "dark",	 remmina_main_on_action_application_dark_theme,	 NULL, NULL, NULL },
+	{ "debug",	 remmina_main_on_action_help_debug,		 NULL, NULL, NULL },
+	{ "community",	 remmina_main_on_action_help_community,		 NULL, NULL, NULL },
+	{ "donations",	 remmina_main_on_action_help_donations,		 NULL, NULL, NULL },
+	{ "homepage",	 remmina_main_on_action_help_homepage,		 NULL, NULL, NULL },
+	{ "wiki",	 remmina_main_on_action_help_wiki,		 NULL, NULL, NULL },
+	{ "quit",	 remmina_main_on_action_application_quit,	 NULL, NULL, NULL },
+};
+
+static GActionEntry main_actions[] = {
+	{ "connect",  remmina_main_on_action_connection_connect,	NULL, NULL, NULL },
+	{ "copy",     remmina_main_on_action_connection_copy,		NULL, NULL, NULL },
+	{ "delete",   remmina_main_on_action_connection_delete,		NULL, NULL, NULL },
+	{ "delete_multiple", remmina_main_on_action_connection_delete_multiple, NULL, NULL, NULL },
+	{ "edit",     remmina_main_on_action_connection_edit,		NULL, NULL, NULL },
+	{ "exttools", remmina_main_on_action_connection_external_tools, NULL, NULL, NULL },
+	{ "new",      remmina_main_on_action_connection_new,		NULL, NULL, NULL },
+	{ "export",   remmina_main_on_action_tools_export,		NULL, NULL, NULL },
+	{ "import",   remmina_main_on_action_tools_import,		NULL, NULL, NULL },
+	{ "expand",   remmina_main_on_action_expand,			NULL, NULL, NULL },
+	{ "collapse", remmina_main_on_action_collapse,			NULL, NULL, NULL },
+	{ "search",   remmina_main_on_action_search_toggle,		NULL, NULL, NULL },
+};
+
+static GtkTargetEntry remmina_drop_types[] =
+{
+	{ "text/uri-list", 0, 1 }
+};
+
+static char *quick_connect_plugin_list[] =
+{
+	"RDP", "VNC", "SSH", "NX", "SPICE", "X2GO"
+};
+
+/**
+ * Save the Remmina Main Window size to assure the main geometry at each restart
+ */
+static void remmina_main_save_size(void)
+{
+	TRACE_CALL(__func__);
+	if ((gdk_window_get_state(gtk_widget_get_window(GTK_WIDGET(remminamain->window))) & GDK_WINDOW_STATE_MAXIMIZED) == 0) {
+		gtk_window_get_size(remminamain->window, &remmina_pref.main_width, &remmina_pref.main_height);
+		remmina_pref.main_maximize = FALSE;
+	} else {
+		remmina_pref.main_maximize = TRUE;
+	}
+}
+
+static void remmina_main_save_expanded_group_func(GtkTreeView *tree_view, GtkTreePath *path, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	GtkTreeIter iter;
+	gchar *group;
+
+	gtk_tree_model_get_iter(remminamain->priv->file_model_sort, &iter, path);
+	gtk_tree_model_get(remminamain->priv->file_model_sort, &iter, GROUP_COLUMN, &group, -1);
+	if (group) {
+		remmina_string_array_add(remminamain->priv->expanded_group, group);
+		g_free(group);
+	}
+}
+
+static void remmina_main_save_expanded_group(void)
+{
+	TRACE_CALL(__func__);
+	if (GTK_IS_TREE_STORE(remminamain->priv->file_model)) {
+		if (remminamain->priv->expanded_group)
+			remmina_string_array_free(remminamain->priv->expanded_group);
+		remminamain->priv->expanded_group = remmina_string_array_new();
+		gtk_tree_view_map_expanded_rows(remminamain->tree_files_list,
+						(GtkTreeViewMappingFunc)remmina_main_save_expanded_group_func, NULL);
+	}
+}
+
+/**
+ * Save the Remmina Main Window size and the expanded group before to close Remmina.
+ * This function uses remmina_main_save_size and remmina_main_save_expanded_group.
+ */
+void remmina_main_save_before_destroy()
+{
+	TRACE_CALL(__func__);
+	if (!remminamain || !remminamain->window)
+		return;
+
+	remmina_main_save_size();
+	remmina_main_save_expanded_group();
+	g_free(remmina_pref.expanded_group);
+	remmina_pref.expanded_group = remmina_string_array_to_string(remminamain->priv->expanded_group);
+	remmina_pref_save();
+}
+
+void remmina_main_destroy()
+{
+	TRACE_CALL(__func__);
+
+	if (remminamain) {
+		if (remminamain->window)
+			gtk_widget_destroy(GTK_WIDGET(remminamain->window));
+
+		g_object_unref(remminamain->builder);
+		remmina_string_array_free(remminamain->priv->expanded_group);
+		remminamain->priv->expanded_group = NULL;
+		if (remminamain->priv->file_model)
+			g_object_unref(G_OBJECT(remminamain->priv->file_model));
+		g_object_unref(G_OBJECT(remminamain->priv->file_model_filter));
+		g_free(remminamain->priv->selected_filename);
+		g_free(remminamain->priv->selected_name);
+		g_free(remminamain->priv);
+		g_free(remminamain);
+		remminamain = NULL;
+	}
+}
+
+/**
+ * Try to exit remmina after a delete window event
+ */
+static gboolean remmina_main_dexit(gpointer data)
+{
+	TRACE_CALL(__func__);
+	remmina_application_condexit(REMMINA_CONDEXIT_ONMAINWINDELETE);
+	return FALSE;
+}
+
+gboolean remmina_main_on_delete_event(GtkWidget *widget, GdkEvent *event, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	remmina_main_save_before_destroy();
+
+	g_idle_add(remmina_main_dexit, NULL);
+
+	return FALSE;
+}
+
+gboolean remmina_main_idle_destroy(gpointer data)
+{
+	TRACE_CALL(__func__);
+
+	if (remminamain)
+		remmina_main_destroy();
+
+	return G_SOURCE_REMOVE;
+}
+
+/**
+ * Called when the remminamain->window widget is destroyed (glade event handler)
+ */
+void remmina_main_on_destroy_event()
+{
+	TRACE_CALL(__func__);
+
+	if (remminamain) {
+		/* Invalidate remminamain->window to avoid multiple destructions */
+		remminamain->window = NULL;
+		/* Destroy remminamain struct, later. We can't destroy
+		 *      important objects like the builder now */
+		g_idle_add(remmina_main_idle_destroy, NULL);
+	}
+}
+
+static void remmina_main_clear_selection_data(void)
+{
+	TRACE_CALL(__func__);
+	g_free(remminamain->priv->selected_filename);
+	g_free(remminamain->priv->selected_name);
+	remminamain->priv->selected_filename = NULL;
+	remminamain->priv->selected_name = NULL;
+}
+
+#ifdef SNAP_BUILD
+
+static void remmina_main_show_snap_welcome()
+{
+	GtkBuilder *dlgbuilder = NULL;
+	GtkWidget *dlg;
+	GtkWindow *parent;
+	int result;
+	static gboolean shown_once = FALSE;
+	gboolean need_snap_interface_connections = FALSE;
+	GtkWidget *dsa;
+	RemminaSecretPlugin *remmina_secret_plugin;
+
+	if (shown_once)
+		return;
+	else
+		shown_once = TRUE;
+
+	g_print("Remmina is compiled as a SNAP package.\n");
+	remmina_secret_plugin = remmina_plugin_manager_get_secret_plugin();
+	if (remmina_secret_plugin == NULL) {
+		g_print("  but we can’t find the secret plugin inside the SNAP.\n");
+		need_snap_interface_connections = TRUE;
+	} else {
+		if (!remmina_secret_plugin->is_service_available(remmina_secret_plugin)) {
+			g_print("  but we can’t access a secret service. Secret service or SNAP interface connection is missing.\n");
+			need_snap_interface_connections = TRUE;
+		}
+	}
+
+	if (need_snap_interface_connections && !remmina_pref.prevent_snap_welcome_message) {
+		dlgbuilder = remmina_public_gtk_builder_new_from_resource("/org/remmina/Remmina/src/../data/ui/remmina_snap_info_dialog.glade");
+		dsa = GTK_WIDGET(gtk_builder_get_object(dlgbuilder, "dontshowagain"));
+		if (dlgbuilder) {
+			parent = remmina_main_get_window();
+			dlg = GTK_WIDGET(gtk_builder_get_object(dlgbuilder, "SnapInfoDlg"));
+			if (parent)
+				gtk_window_set_transient_for(GTK_WINDOW(dlg), parent);
+			gtk_builder_connect_signals(dlgbuilder, NULL);
+			result = gtk_dialog_run(GTK_DIALOG(dlg));
+			if (result == 1) {
+				remmina_pref.prevent_snap_welcome_message = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dsa));
+				remmina_pref_save();
+			}
+			gtk_widget_destroy(dlg);
+			g_object_unref(dlgbuilder);
+		}
+	}
+}
+#endif
+
+
+static gboolean remmina_main_selection_func(GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path,
+					    gboolean path_currently_selected, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	guint context_id;
+	GtkTreeIter iter;
+	gchar buf[1000];
+
+	if (path_currently_selected)
+		return TRUE;
+
+	if (!gtk_tree_model_get_iter(model, &iter, path))
+		return TRUE;
+
+	remmina_main_clear_selection_data();
+
+	gtk_tree_model_get(model, &iter,
+			   NAME_COLUMN, &remminamain->priv->selected_name,
+			   FILENAME_COLUMN, &remminamain->priv->selected_filename,
+			   -1);
+
+	context_id = gtk_statusbar_get_context_id(remminamain->statusbar_main, "status");
+	gtk_statusbar_pop(remminamain->statusbar_main, context_id);
+	if (remminamain->priv->selected_filename) {
+		g_snprintf(buf, sizeof(buf), "%s (%s)", remminamain->priv->selected_name, remminamain->priv->selected_filename);
+		gtk_statusbar_push(remminamain->statusbar_main, context_id, buf);
+	} else {
+		gtk_statusbar_push(remminamain->statusbar_main, context_id, remminamain->priv->selected_name);
+	}
+
+	return TRUE;
+}
+
+static void remmina_main_load_file_list_callback(RemminaFile *remminafile, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	GtkTreeIter iter;
+	GtkListStore *store;
+
+	store = GTK_LIST_STORE(user_data);
+	gchar *datetime;
+
+	datetime = remmina_file_get_datetime(remminafile);
+	gtk_list_store_append(store, &iter);
+	gtk_list_store_set(store, &iter,
+			   PROTOCOL_COLUMN, remmina_file_get_icon_name(remminafile),
+			   NAME_COLUMN, remmina_file_get_string(remminafile, "name"),
+			   NOTES_COLUMN, g_uri_unescape_string(remmina_file_get_string(remminafile, "notes_text"), NULL),
+			   GROUP_COLUMN, remmina_file_get_string(remminafile, "group"),
+			   SERVER_COLUMN, remmina_file_get_string(remminafile, "server"),
+			   PLUGIN_COLUMN, remmina_file_get_string(remminafile, "protocol"),
+			   DATE_COLUMN, datetime,
+			   FILENAME_COLUMN, remmina_file_get_filename(remminafile),
+			   LABELS_COLUMN, remmina_file_get_string(remminafile, "labels"),
+			   -1);
+	g_free(datetime);
+}
+
+static gboolean remmina_main_load_file_tree_traverse(GNode *node, GtkTreeStore *store, GtkTreeIter *parent)
+{
+	TRACE_CALL(__func__);
+	GtkTreeIter *iter;
+	RemminaGroupData *data;
+	GNode *child;
+
+	iter = NULL;
+	if (node->data) {
+		data = (RemminaGroupData *)node->data;
+		iter = g_new0(GtkTreeIter, 1);
+		gtk_tree_store_append(store, iter, parent);
+		gtk_tree_store_set(store, iter,
+				   PROTOCOL_COLUMN, "folder-symbolic",
+				   NAME_COLUMN, data->name,
+				   GROUP_COLUMN, data->group,
+				   DATE_COLUMN, data->datetime,
+				   FILENAME_COLUMN, NULL,
+				   LABELS_COLUMN, data->labels,
+				   -1);
+	}
+	for (child = g_node_first_child(node); child; child = g_node_next_sibling(child))
+		remmina_main_load_file_tree_traverse(child, store, iter);
+	g_free(iter);
+	return FALSE;
+}
+
+static void remmina_main_load_file_tree_group(GtkTreeStore *store)
+{
+	TRACE_CALL(__func__);
+	GNode *root;
+
+	root = remmina_file_manager_get_group_tree();
+	remmina_main_load_file_tree_traverse(root, store, NULL);
+	remmina_file_manager_free_group_tree(root);
+}
+
+static void remmina_main_expand_group_traverse(GtkTreeIter *iter)
+{
+	TRACE_CALL(__func__);
+	GtkTreeModel *tree;
+	gboolean ret;
+	gchar *group, *filename;
+	GtkTreeIter child;
+	GtkTreePath *path;
+
+	tree = remminamain->priv->file_model_sort;
+	ret = TRUE;
+	while (ret) {
+		gtk_tree_model_get(tree, iter, GROUP_COLUMN, &group, FILENAME_COLUMN, &filename, -1);
+		if (filename == NULL) {
+			if (remmina_string_array_find(remminamain->priv->expanded_group, group) >= 0) {
+				path = gtk_tree_model_get_path(tree, iter);
+				gtk_tree_view_expand_row(remminamain->tree_files_list, path, FALSE);
+				gtk_tree_path_free(path);
+			}
+			if (gtk_tree_model_iter_children(tree, &child, iter))
+				remmina_main_expand_group_traverse(&child);
+		}
+		g_free(group);
+		g_free(filename);
+
+		ret = gtk_tree_model_iter_next(tree, iter);
+	}
+}
+
+static void remmina_main_expand_group(void)
+{
+	TRACE_CALL(__func__);
+	GtkTreeIter iter;
+
+	if (gtk_tree_model_get_iter_first(remminamain->priv->file_model_sort, &iter))
+		remmina_main_expand_group_traverse(&iter);
+}
+
+static gboolean remmina_main_load_file_tree_find(GtkTreeModel *tree, GtkTreeIter *iter, const gchar *match_group)
+{
+	TRACE_CALL(__func__);
+	gboolean ret, match;
+	gchar *group, *filename;
+	GtkTreeIter child;
+
+	match = FALSE;
+	ret = TRUE;
+	while (ret) {
+		gtk_tree_model_get(tree, iter, GROUP_COLUMN, &group, FILENAME_COLUMN, &filename, -1);
+		match = (filename == NULL && g_strcmp0(group, match_group) == 0);
+		g_free(group);
+		g_free(filename);
+		if (match)
+			break;
+		if (gtk_tree_model_iter_children(tree, &child, iter)) {
+			match = remmina_main_load_file_tree_find(tree, &child, match_group);
+			if (match) {
+				memcpy(iter, &child, sizeof(GtkTreeIter));
+				break;
+			}
+		}
+		ret = gtk_tree_model_iter_next(tree, iter);
+	}
+	return match;
+}
+
+static void remmina_main_load_file_tree_callback(RemminaFile *remminafile, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	GtkTreeIter iter, child;
+	GtkTreeStore *store;
+	gboolean found;
+	gchar *datetime = NULL;
+
+	store = GTK_TREE_STORE(user_data);
+
+	found = FALSE;
+	if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter))
+		found = remmina_main_load_file_tree_find(GTK_TREE_MODEL(store), &iter,
+							 remmina_file_get_string(remminafile, "group"));
+
+	datetime = remmina_file_get_datetime(remminafile);
+	//REMMINA_DEBUG("The date is %s", datetime);
+	gtk_tree_store_append(store, &child, (found ? &iter : NULL));
+	gtk_tree_store_set(store, &child,
+			   PROTOCOL_COLUMN, remmina_file_get_icon_name(remminafile),
+			   NAME_COLUMN, remmina_file_get_string(remminafile, "name"),
+			   NOTES_COLUMN, g_uri_unescape_string(remmina_file_get_string(remminafile, "notes_text"), NULL),
+			   GROUP_COLUMN, remmina_file_get_string(remminafile, "group"),
+			   SERVER_COLUMN, remmina_file_get_string(remminafile, "server"),
+			   PLUGIN_COLUMN, remmina_file_get_string(remminafile, "protocol"),
+			   DATE_COLUMN, datetime,
+			   FILENAME_COLUMN, remmina_file_get_filename(remminafile),
+			   LABELS_COLUMN, remmina_file_get_string(remminafile, "labels"),
+			   -1);
+	g_free(datetime);
+}
+
+static void remmina_main_file_model_on_sort(GtkTreeSortable *sortable, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gint columnid;
+	GtkSortType order;
+
+	gtk_tree_sortable_get_sort_column_id(sortable, &columnid, &order);
+	remmina_pref.main_sort_column_id = columnid;
+	remmina_pref.main_sort_order = order;
+	remmina_pref_save();
+}
+
+static gboolean remmina_main_filter_visible_func(GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gchar *text;
+	gchar *protocol, *name, *labels, *group, *server, *plugin, *date, *s;
+	gboolean result = TRUE;
+
+	text = g_ascii_strdown(gtk_entry_get_text(remminamain->entry_quick_connect_server), -1);
+	if (text && text[0]) {
+		gtk_tree_model_get(model, iter,
+				   PROTOCOL_COLUMN, &protocol,
+				   NAME_COLUMN, &name,
+				   GROUP_COLUMN, &group,
+				   SERVER_COLUMN, &server,
+				   PLUGIN_COLUMN, &plugin,
+				   DATE_COLUMN, &date,
+				   LABELS_COLUMN, &labels,
+				   -1);
+		if (g_strcmp0(protocol, "folder-symbolic") != 0) {
+			s = g_ascii_strdown(name ? name : "", -1);
+			g_free(name);
+			name = s;
+			s = g_ascii_strdown(group ? group : "", -1);
+			g_free(group);
+			group = s;
+			s = g_ascii_strdown(server ? server : "", -1);
+			g_free(server);
+			server = s;
+			s = g_ascii_strdown(plugin ? plugin : "", -1);
+			g_free(plugin);
+			plugin = s;
+			s = g_ascii_strdown(date ? date : "", -1);
+			g_free(date);
+			date = s;
+			result = (strstr(name, text) || strstr(group, text) || strstr(server, text) || strstr(plugin, text) || strstr(date, text));
+
+			// Filter by labels
+
+			s = g_ascii_strdown(labels ? labels : "", -1);
+			g_free(labels);
+			labels = s;
+
+			if (strlen(labels) > 0) {
+				gboolean labels_result  = TRUE;
+				gchar    **labels_array = g_strsplit(labels, ",", -1);
+				gchar    **text_array   = g_strsplit(text, ",", -1);
+
+				for (int t = 0; (NULL != text_array[t]); t++) {
+					if (0 == strlen(text_array[t])) {
+						continue;
+					}
+
+					gboolean text_result = FALSE;
+
+					for (int l = 0; (NULL != labels_array[l]); l++) {
+						if (0 == strlen(labels_array[l])) {
+							continue;
+						}
+
+						text_result = (text_result || strstr(labels_array[l], text_array[t]));
+
+						if (text_result) {
+							break;
+						}
+					}
+
+					labels_result = (labels_result && text_result);
+
+					if (!labels_result) {
+						break;
+					}
+				}
+
+				result = (result || labels_result);
+
+				g_strfreev(labels_array);
+				g_strfreev(text_array);
+			}
+		}
+		g_free(protocol);
+		g_free(name);
+		g_free(labels);
+		g_free(group);
+		g_free(server);
+		g_free(plugin);
+		g_free(date);
+	}
+	g_free(text);
+	return result;
+}
+
+static void remmina_main_select_file(const gchar *filename)
+{
+	TRACE_CALL(__func__);
+	GtkTreeIter iter;
+	GtkTreePath *path;
+	gchar *item_filename;
+	gboolean cmp;
+
+	if (!gtk_tree_model_get_iter_first(remminamain->priv->file_model_sort, &iter))
+		return;
+
+	while (TRUE) {
+		gtk_tree_model_get(remminamain->priv->file_model_sort, &iter, FILENAME_COLUMN, &item_filename, -1);
+		cmp = g_strcmp0(item_filename, filename);
+		g_free(item_filename);
+		if (cmp == 0) {
+			gtk_tree_selection_select_iter(gtk_tree_view_get_selection(remminamain->tree_files_list),
+						       &iter);
+			path = gtk_tree_model_get_path(remminamain->priv->file_model_sort, &iter);
+			gtk_tree_view_scroll_to_cell(remminamain->tree_files_list, path, NULL, TRUE, 0.5, 0.0);
+			gtk_tree_path_free(path);
+			return;
+		}
+		if (!gtk_tree_model_iter_next(remminamain->priv->file_model_sort, &iter))
+			return;
+	}
+}
+
+static void remmina_main_load_files()
+{
+	TRACE_CALL(__func__);
+	gint items_count;
+	gchar buf[200];
+	guint context_id;
+	gint view_file_mode;
+	gboolean always_show_notes;
+	char *save_selected_filename;
+	GtkTreeModel *newmodel;
+	const gchar *neticon;
+	const gchar *connection_tooltip;
+
+	save_selected_filename = g_strdup(remminamain->priv->selected_filename);
+	remmina_main_save_expanded_group();
+
+	view_file_mode = remmina_pref.view_file_mode;
+	if (remminamain->priv->override_view_file_mode_to_list)
+		view_file_mode = REMMINA_VIEW_FILE_LIST;
+
+	switch (remmina_pref.view_file_mode) {
+	case REMMINA_VIEW_FILE_TREE:
+		gtk_toggle_button_set_active(remminamain->view_toggle_button, FALSE);
+		break;
+	case REMMINA_VIEW_FILE_LIST:
+	default:
+		gtk_toggle_button_set_active(remminamain->view_toggle_button, TRUE);
+		break;
+	}
+
+	switch (view_file_mode) {
+	case REMMINA_VIEW_FILE_TREE:
+		/* Create new GtkTreeStore model */
+		newmodel = GTK_TREE_MODEL(gtk_tree_store_new(9, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING));
+		/* Hide the Group column in the tree view mode */
+		gtk_tree_view_column_set_visible(remminamain->column_files_list_group, FALSE);
+		/* Load groups first */
+		remmina_main_load_file_tree_group(GTK_TREE_STORE(newmodel));
+		/* Load files list */
+		items_count = remmina_file_manager_iterate((GFunc)remmina_main_load_file_tree_callback, (gpointer)newmodel);
+		break;
+
+	case REMMINA_VIEW_FILE_LIST:
+	default:
+		/* Create new GtkListStore model */
+		newmodel = GTK_TREE_MODEL(gtk_list_store_new(9, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING));
+		/* Show the Group column in the list view mode */
+		gtk_tree_view_column_set_visible(remminamain->column_files_list_group, TRUE);
+		/* Load files list */
+		items_count = remmina_file_manager_iterate((GFunc)remmina_main_load_file_list_callback, (gpointer)newmodel);
+		break;
+	}
+
+	/* Set note column visibility*/
+	always_show_notes = remmina_pref.always_show_notes;
+	if (!always_show_notes){
+		gtk_tree_view_column_set_visible(remminamain->column_files_list_notes, FALSE);
+	}
+
+	/* Unset old model */
+	gtk_tree_view_set_model(remminamain->tree_files_list, NULL);
+
+	/* Destroy the old model and save the new one */
+	remminamain->priv->file_model = newmodel;
+
+	/* Create a sorted filtered model based on newmodel and apply it to the TreeView */
+	remminamain->priv->file_model_filter = gtk_tree_model_filter_new(remminamain->priv->file_model, NULL);
+	gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(remminamain->priv->file_model_filter),
+					       (GtkTreeModelFilterVisibleFunc)remmina_main_filter_visible_func, NULL, NULL);
+	remminamain->priv->file_model_sort = gtk_tree_model_sort_new_with_model(remminamain->priv->file_model_filter);
+	gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(remminamain->priv->file_model_sort),
+					     remmina_pref.main_sort_column_id,
+					     remmina_pref.main_sort_order);
+	gtk_tree_view_set_model(remminamain->tree_files_list, remminamain->priv->file_model_sort);
+	g_signal_connect(G_OBJECT(remminamain->priv->file_model_sort), "sort-column-changed",
+			 G_CALLBACK(remmina_main_file_model_on_sort), NULL);
+	remmina_main_expand_group();
+	/* Select the file previously selected */
+	if (save_selected_filename) {
+		remmina_main_select_file(save_selected_filename);
+		g_free(save_selected_filename);
+	}
+	gtk_tree_view_column_set_widget(remminamain->column_files_list_date, NULL);
+
+	GtkWidget *label = gtk_tree_view_column_get_button(remminamain->column_files_list_date);
+
+	gtk_widget_set_tooltip_text(GTK_WIDGET(label),
+				    _("The latest successful connection attempt, or a pre-computed date"));
+	/* Show in the status bar the total number of connections found */
+	g_snprintf(buf, sizeof(buf), ngettext("Total %i item.", "Total %i items.", items_count), items_count);
+	context_id = gtk_statusbar_get_context_id(remminamain->statusbar_main, "status");
+	gtk_statusbar_pop(remminamain->statusbar_main, context_id);
+	gtk_statusbar_push(remminamain->statusbar_main, context_id, buf);
+
+	remmina_network_monitor_status (remminamain->monitor);
+	if (remminamain->monitor->connected){
+		neticon = g_strdup("network-transmit-receive-symbolic");
+		connection_tooltip = g_strdup(_("Network status: fully online"));
+	} else {
+		neticon = g_strdup("network-offline-symbolic");
+		connection_tooltip = g_strdup(_("Network status: offline"));
+	}
+
+	if (GTK_IS_WIDGET(remminamain->network_icon))
+		gtk_widget_destroy(remminamain->network_icon);
+	GIcon *icon = g_themed_icon_new (neticon);
+	remminamain->network_icon = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_BUTTON);
+	gtk_widget_set_tooltip_text (remminamain->network_icon, connection_tooltip);
+
+	g_object_unref (icon);
+
+	gtk_box_pack_start (GTK_BOX(remminamain->statusbar_main), remminamain->network_icon, FALSE, FALSE, 0);
+	gtk_widget_show (remminamain->network_icon);
+
+}
+
+void remmina_main_load_files_cb(GtkEntry *entry, char *string, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	remmina_main_load_files();
+}
+
+void remmina_main_on_action_connection_connect(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+
+	RemminaFile *remminafile;
+
+	if (!remminamain->priv->selected_filename)
+		return;
+
+	remminafile = remmina_file_load(remminamain->priv->selected_filename);
+
+	if (remminafile == NULL)
+		return;
+
+	if (remmina_pref_get_boolean("use_primary_password")
+			&& remmina_pref_get_boolean("lock_connect")
+			&& remmina_unlock_new(remminamain->window) == 0)
+		return;
+	if (remmina_file_get_int (remminafile, "profile-lock", FALSE) == 1
+			&& remmina_unlock_new(remminamain->window) == 0)
+		return;
+
+	remmina_file_touch(remminafile);
+	rcw_open_from_filename(remminamain->priv->selected_filename);
+
+	remmina_file_free(remminafile);
+}
+
+void remmina_main_on_action_connection_external_tools(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	if (!remminamain->priv->selected_filename)
+		return;
+
+	remmina_external_tools_from_filename(remminamain, remminamain->priv->selected_filename);
+}
+
+static void remmina_main_file_editor_destroy(GtkWidget *widget, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+
+	if (!remminamain)
+		return;
+	remmina_main_load_files();
+}
+
+void remmina_main_on_action_application_mpchange(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaFile *remminafile;
+
+	const gchar *username;
+	const gchar *domain;
+	const gchar *group;
+	const gchar *gatewayusername;
+	const gchar *gatewaydomain;
+
+	username = domain = group = gatewayusername = gatewaydomain = "";
+
+	remminafile = NULL;
+
+	if (remmina_pref_get_boolean("use_primary_password")
+			&& remmina_pref_get_boolean("lock_edit")
+			&& remmina_unlock_new(remminamain->window) == 0)
+		return;
+
+	if (remminamain->priv->selected_filename) {
+		remminafile = remmina_file_load(remminamain->priv->selected_filename);
+		if (remminafile != NULL) {
+			username = remmina_file_get_string(remminafile, "username");
+			domain = remmina_file_get_string(remminafile, "domain");
+			group = remmina_file_get_string(remminafile, "group");
+			gatewayusername = remmina_file_get_string(remminafile, "gateway_username");
+			gatewaydomain = remmina_file_get_string(remminafile, "gateway_domain");
+		}
+	}
+
+	remmina_mpchange_schedule(TRUE, group, domain, username, "", gatewayusername, gatewaydomain, "");
+
+	if (remminafile != NULL)
+		remmina_file_free(remminafile);
+}
+
+void remmina_main_on_action_connection_new(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	if (kioskmode && kioskmode == TRUE)
+		return;
+	GtkWidget *widget;
+
+	remmina_plugin_manager_get_available_plugins();
+	if (remmina_pref_get_boolean("use_primary_password")
+			&& remmina_pref_get_boolean("lock_edit")
+			&& remmina_unlock_new(remminamain->window) == 0)
+		return;
+
+	widget = remmina_file_editor_new();
+	g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(remmina_main_file_editor_destroy), remminamain);
+	gtk_window_set_transient_for(GTK_WINDOW(widget), remminamain->window);
+	gtk_widget_show(widget);
+	remmina_main_load_files();
+}
+
+static gboolean remmina_main_search_key_event(GtkWidget *search_entry, GdkEventKey *event, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	if (event->keyval == GDK_KEY_Escape) {
+		gtk_entry_set_text(remminamain->entry_quick_connect_server, "");
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(RM_GET_OBJECT("search_toggle")), FALSE);
+		return TRUE;
+	}
+	return FALSE;
+}
+
+static gboolean remmina_main_tree_row_activated(GtkTreeView *tree, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	if (gtk_tree_view_row_expanded(tree, path))
+		gtk_tree_view_collapse_row(tree, path);
+	else
+		gtk_tree_view_expand_row(tree, path, FALSE);
+	return TRUE;
+}
+
+void remmina_main_on_view_toggle()
+{
+	if (gtk_toggle_button_get_active(remminamain->view_toggle_button)) {
+		if (remmina_pref.view_file_mode != REMMINA_VIEW_FILE_LIST) {
+			remmina_pref.view_file_mode = REMMINA_VIEW_FILE_LIST;
+			gtk_entry_set_text(remminamain->entry_quick_connect_server, "");
+			remmina_pref_save();
+			remmina_main_load_files();
+		}
+	} else {
+		if (remmina_pref.view_file_mode != REMMINA_VIEW_FILE_TREE) {
+			remmina_pref.view_file_mode = REMMINA_VIEW_FILE_TREE;
+			gtk_entry_set_text(remminamain->entry_quick_connect_server, "");
+			remmina_pref_save();
+			remmina_main_load_files();
+		}
+	}
+}
+
+void remmina_main_on_action_connection_copy(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget;
+
+	if (remmina_pref_get_boolean("use_primary_password")
+			&& remmina_unlock_new(remminamain->window) == 0)
+		return;
+
+	if (!remminamain->priv->selected_filename)
+		return;
+
+	RemminaFile *remminafile = remmina_file_load(remminamain->priv->selected_filename);
+
+	if (((remmina_pref_get_boolean("lock_edit")
+				&& remmina_pref_get_boolean("use_primary_password"))
+				|| remmina_file_get_int (remminafile, "profile-lock", FALSE))
+			&& remmina_unlock_new(remminamain->window) == 0)
+		return;
+
+	if (remminafile) {
+		remmina_file_free(remminafile);
+		remminafile = NULL;
+	}
+
+	widget = remmina_file_editor_new_copy(remminamain->priv->selected_filename);
+	if (widget) {
+		g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(remmina_main_file_editor_destroy), remminamain);
+		gtk_window_set_transient_for(GTK_WINDOW(widget), remminamain->window);
+		gtk_widget_show(widget);
+	}
+	/* Select the file previously selected */
+	if (remminamain->priv->selected_filename)
+		remmina_main_select_file(remminamain->priv->selected_filename);
+}
+
+void remmina_main_on_action_connection_edit(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget;
+
+	if (!remminamain->priv->selected_filename)
+		return;
+
+	RemminaFile *remminafile = remmina_file_load(remminamain->priv->selected_filename);
+
+	if (remmina_pref_get_boolean("use_primary_password")
+			&& (remmina_pref_get_boolean("lock_edit")
+				|| remmina_file_get_int (remminafile, "profile-lock", FALSE))
+			&& remmina_unlock_new(remminamain->window) == 0)
+		return;
+
+	if (remminafile) {
+		remmina_file_free(remminafile);
+		remminafile = NULL;
+	}
+
+	widget = remmina_file_editor_new_from_filename(remminamain->priv->selected_filename);
+	if (widget) {
+		gtk_window_set_transient_for(GTK_WINDOW(widget), remminamain->window);
+		gtk_widget_show(widget);
+	}
+/* Select the file previously selected */
+	if (remminamain->priv->selected_filename)
+		remmina_main_select_file(remminamain->priv->selected_filename);
+}
+
+void remmina_main_on_action_connection_delete(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *dialog;
+
+	if (!remminamain->priv->selected_filename)
+		return;
+
+	RemminaFile *remminafile = remmina_file_load(remminamain->priv->selected_filename);
+
+	if (((remmina_pref_get_boolean("lock_edit")
+				&& remmina_pref_get_boolean("use_primary_password"))
+				|| remmina_file_get_int (remminafile, "profile-lock", FALSE))
+			&& remmina_unlock_new(remminamain->window) == 0)
+		return;
+
+	if (remminafile) {
+		remmina_file_free(remminafile);
+		remminafile = NULL;
+	}
+
+	dialog = gtk_message_dialog_new(remminamain->window, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
+					_("Are you sure you want to delete “%s”?"), remminamain->priv->selected_name);
+	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_YES) {
+		gchar *delfilename = g_strdup(remminamain->priv->selected_filename);
+		remmina_file_delete(delfilename);
+		g_free(delfilename), delfilename = NULL;
+		remmina_icon_populate_menu();
+		remmina_main_load_files();
+	}
+	gtk_widget_destroy(dialog);
+	remmina_main_clear_selection_data();
+}
+
+void remmina_main_on_action_connection_delete_multiple(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *dialog;
+	GtkTreeSelection *sel = gtk_tree_view_get_selection(remminamain->tree_files_list);
+	GtkTreeModel *model = gtk_tree_view_get_model(remminamain->tree_files_list);
+	GList *list = gtk_tree_selection_get_selected_rows(sel, &model);
+	gchar *file_to_delete;
+
+	dialog = gtk_message_dialog_new(remminamain->window, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
+				_("Are you sure you want to delete the selected files?"));
+
+	// Delete files if Yes is clicked
+	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_YES) {
+		while (list) {
+			GtkTreePath *path = list->data;
+			GtkTreeIter iter;
+			
+			if (!gtk_tree_model_get_iter(model, &iter, path)) {
+				GtkWidget *dialog_warning;
+				dialog_warning = gtk_message_dialog_new(remminamain->window, GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, 
+					_("Failed to delete files!"));
+				gtk_dialog_run(GTK_DIALOG(dialog_warning));
+				gtk_widget_destroy(dialog_warning);
+				gtk_widget_destroy(dialog);
+				remmina_main_clear_selection_data();
+				return;
+			}
+
+			gtk_tree_model_get(model, &iter, 
+					FILENAME_COLUMN, &file_to_delete, -1);
+
+			RemminaFile *remminafile = remmina_file_load(file_to_delete);
+
+			if (((remmina_pref_get_boolean("lock_edit")
+					&& remmina_pref_get_boolean("use_primary_password"))
+					|| remmina_file_get_int (remminafile, "profile-lock", FALSE))
+				&& remmina_unlock_new(remminamain->window) == 0)
+				return;
+
+			if (remminafile) {
+				remmina_file_free(remminafile);
+				remminafile = NULL;
+			}
+
+			gchar *delfilename = g_strdup(file_to_delete);
+			remmina_file_delete(delfilename);
+			g_free(delfilename), delfilename = NULL;
+			remmina_icon_populate_menu();
+			remmina_main_load_files();
+			list = g_list_next(list);
+		}
+	}
+	
+	gtk_widget_destroy(dialog);
+	remmina_main_clear_selection_data();
+}
+
+void remmina_main_on_accel_application_preferences(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	GVariant *v = g_variant_new("i", 0);
+
+	remmina_main_on_action_application_preferences(NULL, v, NULL);
+}
+
+void remmina_main_reload_preferences()
+{
+	GtkSettings *settings;
+	settings = gtk_settings_get_default();
+	g_object_set(settings, "gtk-application-prefer-dark-theme", remmina_pref.dark_theme, NULL);
+	if (remminamain) {
+		if(remmina_pref.hide_searchbar){
+			gtk_toggle_button_set_active(remminamain->search_toggle, FALSE);
+		}
+		else{
+			gtk_toggle_button_set_active(remminamain->search_toggle, TRUE);
+		}
+		gtk_tree_view_column_set_visible(remminamain->column_files_list_notes, remmina_pref.always_show_notes);
+	}
+}
+
+void remmina_main_on_action_application_preferences(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+
+	REMMINA_DEBUG("Opening the preferences");
+	gint32 tab_num;
+
+	if (param) {
+		REMMINA_DEBUG("Parameter passed to preferences of type %s", g_variant_get_type_string(param));
+		tab_num = g_variant_get_int32(param);
+		REMMINA_DEBUG("We got a parameter for the preferences: %d", tab_num);
+	} else {
+		tab_num = 0;
+	}
+
+	if (remmina_pref_get_boolean("use_primary_password")
+			&& remmina_unlock_new(remminamain->window) == 0)
+		return;
+
+	GtkWidget *widget = remmina_pref_dialog_new(tab_num, remminamain->window);
+
+	gtk_widget_show(widget);	
+}
+
+void remmina_main_on_action_application_default(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+#ifndef __APPLE__
+	g_autoptr(GError) error = NULL;
+	GDesktopAppInfo *desktop_info;
+	GAppInfo *info = NULL;
+	g_autofree gchar *id = g_strconcat(REMMINA_APP_ID, ".desktop", NULL);
+	int i;
+
+	desktop_info = g_desktop_app_info_new(id);
+	if (!desktop_info)
+		return;
+
+	info = G_APP_INFO(desktop_info);
+
+	for (i = 0; supported_mime_types[i]; i++) {
+		if (!g_app_info_set_as_default_for_type(info, supported_mime_types[i], &error))
+			g_warning("Failed to set '%s' as the default application for secondary content type '%s': %s",
+				  g_app_info_get_name(info), supported_mime_types[i], error->message);
+		else
+			g_debug("Set '%s' as the default application for '%s'",
+				g_app_info_get_name(info),
+				supported_mime_types[i]);
+	}
+#endif
+}
+
+void remmina_main_on_action_application_quit(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	// Called by quit signal in remmina_main.glade
+	TRACE_CALL(__func__);
+	g_debug("Quit intercept");
+	remmina_application_condexit(REMMINA_CONDEXIT_ONQUIT);
+}
+
+void remmina_main_on_date_column_sort_clicked()
+{
+	if (remmina_pref.view_file_mode != REMMINA_VIEW_FILE_LIST) {
+		remmina_pref.view_file_mode = REMMINA_VIEW_FILE_LIST;
+		gtk_entry_set_text(remminamain->entry_quick_connect_server, "");
+		remmina_pref_save();
+		remmina_main_load_files();
+	}
+}
+
+void remmina_main_toggle_password_view(GtkWidget *widget, gpointer data)
+{
+	GtkWindow *mainwindow;
+	gboolean visible = gtk_entry_get_visibility(GTK_ENTRY(widget));
+
+	mainwindow = remmina_main_get_window();
+	if (remmina_pref_get_boolean("use_primary_password") && remmina_pref_get_boolean("lock_view_passwords") && remmina_unlock_new(mainwindow) == 0)
+		return;
+
+	if (visible) {
+		gtk_entry_set_visibility(GTK_ENTRY(widget), FALSE);
+		gtk_entry_set_icon_from_icon_name(GTK_ENTRY(widget), GTK_ENTRY_ICON_SECONDARY, "org.remmina.Remmina-password-reveal-symbolic");
+	} else {
+		gtk_entry_set_visibility(GTK_ENTRY(widget), TRUE);
+		gtk_entry_set_icon_from_icon_name(GTK_ENTRY(widget), GTK_ENTRY_ICON_SECONDARY, "org.remmina.Remmina-password-conceal-symbolic");
+	}
+}
+
+static void remmina_main_import_file_list(GSList *files)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *dlg;
+	GSList *element;
+	gchar *path;
+	RemminaFilePlugin *plugin;
+	GString *err;
+	RemminaFile *remminafile = NULL;
+	gboolean imported;
+
+	err = g_string_new(NULL);
+	imported = FALSE;
+	for (element = files; element; element = element->next) {
+		path = (gchar *)element->data;
+		plugin = remmina_plugin_manager_get_import_file_handler(path);
+		if (plugin && (remminafile = plugin->import_func(plugin, path)) != NULL && remmina_file_get_string(remminafile, "name")) {
+			remmina_file_generate_filename(remminafile);
+			remmina_file_save(remminafile);
+			imported = TRUE;
+		} else {
+			g_string_append(err, path);
+			g_string_append_c(err, '\n');
+		}
+		if (remminafile) {
+			remmina_file_free(remminafile);
+			remminafile = NULL;
+		}
+		g_free(path);
+	}
+	g_slist_free(files);
+	if (err->len > 0) {
+		// TRANSLATORS: The placeholder %s is an error message
+		dlg = gtk_message_dialog_new(remminamain->window, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
+					     _("Unable to import:\n%s"), err->str);
+		g_signal_connect(G_OBJECT(dlg), "response", G_CALLBACK(gtk_widget_destroy), NULL);
+		gtk_widget_show(dlg);
+	}
+	g_string_free(err, TRUE);
+	if (imported)
+		remmina_main_load_files();
+}
+
+static void remmina_main_action_tools_import_on_response(GtkNativeDialog *dialog, gint response_id, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	GSList *files;
+
+	if (response_id == GTK_RESPONSE_ACCEPT) {
+		files = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
+		remmina_main_import_file_list(files);
+	}
+	gtk_native_dialog_destroy(dialog);
+}
+
+static void remmina_set_file_chooser_filters(GtkFileChooser *chooser)
+{
+	GtkFileFilter *filter;
+
+	g_return_if_fail(GTK_IS_FILE_CHOOSER(chooser));
+
+	filter = gtk_file_filter_new();
+	gtk_file_filter_set_name(filter, _("RDP Files"));
+	gtk_file_filter_add_pattern(filter, "*.rdp");
+	gtk_file_filter_add_pattern(filter, "*.rdpx");
+	gtk_file_filter_add_pattern(filter, "*.RDP");
+	gtk_file_filter_add_pattern(filter, "*.RDPX");
+	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(chooser), filter);
+	gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(chooser), filter);
+
+	filter = gtk_file_filter_new();
+	gtk_file_filter_set_name(filter, _("All Files"));
+	gtk_file_filter_add_pattern(filter, "*");
+	gtk_file_chooser_add_filter(chooser, filter);
+}
+
+void remmina_main_on_action_tools_import(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	GtkFileChooserNative *chooser;
+
+	chooser = gtk_file_chooser_native_new(_("Import"), remminamain->window,
+					      GTK_FILE_CHOOSER_ACTION_OPEN, _("Import"), _("_Cancel"));
+	gtk_native_dialog_set_modal(GTK_NATIVE_DIALOG(chooser), TRUE);
+	remmina_set_file_chooser_filters(GTK_FILE_CHOOSER(chooser));
+	gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(chooser), TRUE);
+	g_signal_connect(chooser, "response", G_CALLBACK(remmina_main_action_tools_import_on_response), NULL);
+	gtk_native_dialog_show(GTK_NATIVE_DIALOG(chooser));
+}
+
+static void on_export_save_response (GtkFileChooserNative *dialog, int response, RemminaFile *remminafile)
+{
+	if (response == GTK_RESPONSE_ACCEPT) {
+		RemminaFilePlugin *plugin = remmina_plugin_manager_get_export_file_handler(remminafile);
+		if (plugin){
+			gchar *path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
+			plugin->export_func(plugin, remminafile, path);
+			g_free(path);
+		}
+	}
+	remmina_file_free(remminafile);
+	gtk_native_dialog_destroy(GTK_NATIVE_DIALOG(dialog));
+}
+
+void remmina_main_on_action_tools_export(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaFilePlugin *plugin;
+	RemminaFile *remminafile;
+	GtkWidget *dialog;
+	GtkFileChooserNative *chooser;
+	gchar *export_name;
+
+	if (!remminamain->priv->selected_filename) {
+		dialog = gtk_message_dialog_new(remminamain->window, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
+						_("Select the connection profile."));
+		g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(gtk_widget_destroy), NULL);
+		gtk_widget_show(dialog);
+		return;
+	}
+
+	remminafile = remmina_file_load(remminamain->priv->selected_filename);
+	if (remminafile == NULL) {
+		dialog = gtk_message_dialog_new(remminamain->window, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
+						_("Remmina couldn't export."));
+		g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(gtk_widget_destroy), NULL);
+		gtk_widget_show(dialog);
+		return;
+	}
+
+	plugin = remmina_plugin_manager_get_export_file_handler(remminafile);
+	if (plugin) {
+		chooser = gtk_file_chooser_native_new(plugin->export_hints, remminamain->window,
+						      GTK_FILE_CHOOSER_ACTION_SAVE, _("_Save"), _("_Cancel"));
+		gtk_native_dialog_set_modal(GTK_NATIVE_DIALOG(chooser), TRUE);
+		remmina_set_file_chooser_filters(GTK_FILE_CHOOSER(chooser));
+		gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(chooser), TRUE);
+		export_name = g_strdup_printf("%s.rdp", remminamain->priv->selected_name);
+		gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(chooser), export_name);
+		g_free(export_name);
+		g_signal_connect(chooser, "response", G_CALLBACK(on_export_save_response), remminafile);
+		gtk_native_dialog_show(GTK_NATIVE_DIALOG(chooser));
+	} else
+	{
+		remmina_file_free(remminafile);
+		dialog = gtk_message_dialog_new(remminamain->window, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
+						_("This protocol does not support exporting."));
+		g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(gtk_widget_destroy), NULL);
+		gtk_widget_show(dialog);
+		return;
+	}
+}
+
+void remmina_main_on_action_application_plugins(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	remmina_plugin_manager_get_available_plugins();
+	remmina_plugin_manager_show(remminamain->window);
+}
+
+void remmina_main_on_action_application_dark_theme(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	GtkSettings *settings;
+
+	settings = gtk_settings_get_default();
+
+	if (gtk_switch_get_active(remminamain->switch_dark_mode))
+		remmina_pref.dark_theme = 1;
+	else
+		remmina_pref.dark_theme = 0;
+	remmina_pref_save();
+
+	g_object_set(settings, "gtk-application-prefer-dark-theme", remmina_pref.dark_theme, NULL);
+}
+
+void remmina_main_on_action_help_homepage(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	g_app_info_launch_default_for_uri("https://www.remmina.org", NULL, NULL);
+}
+
+void remmina_main_on_action_help_wiki(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	g_app_info_launch_default_for_uri("https://gitlab.com/Remmina/Remmina/wikis/home", NULL, NULL);
+}
+
+void remmina_main_on_action_help_community(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	g_app_info_launch_default_for_uri("https://remmina.org/community", NULL, NULL);
+}
+
+void remmina_main_on_action_help_donations(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	g_app_info_launch_default_for_uri("https://www.remmina.org/donations", NULL, NULL);
+}
+
+void remmina_main_on_action_help_debug(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	remmina_log_start();
+}
+
+void remmina_main_on_action_application_about(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	remmina_about_open(remminamain->window);
+};
+
+void remmina_main_on_action_application_bug_report(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	remmina_bug_report_open(remminamain->window);
+};
+
+static gboolean is_empty(const gchar *s)
+{
+	if (s == NULL)
+		return TRUE;
+	while (*s != 0) {
+		if (!isspace((unsigned char)*s))
+			return FALSE;
+		s++;
+	}
+	return TRUE;
+}
+
+static gboolean remmina_main_quickconnect(void)
+{
+	TRACE_CALL(__func__);
+	RemminaFile *remminafile;
+	gchar *server;
+	gchar *server_trimmed;
+	gchar *qcp;
+
+
+	/* Save quick connect protocol if different from the previous one */
+	qcp = gtk_combo_box_text_get_active_text(remminamain->combo_quick_connect_protocol);
+	if (qcp && strcmp(qcp, remmina_pref.last_quickconnect_protocol) != 0) {
+		g_free(remmina_pref.last_quickconnect_protocol);
+		remmina_pref.last_quickconnect_protocol = g_strdup(qcp);
+		remmina_pref_save();
+	}
+
+	remminafile = remmina_file_new();
+	server = g_strdup(gtk_entry_get_text(remminamain->entry_quick_connect_server));
+	if (g_hostname_to_ascii(server) == NULL)
+		return FALSE;
+	/* If server contain /, e.g. vnc://, it won't connect
+	 * We could search for an array of invalid characters, but
+	 * it's better to find a way to correctly parse and validate addresses
+	 */
+	if (g_strrstr(server, "/") != NULL)
+		return FALSE;
+	//if (g_str_has_suffix (server, "/"))
+	//return FALSE;
+	if (is_empty(server))
+		return FALSE;
+
+	/* check if server is an IP address and trim whitespace if so */
+	server_trimmed = g_strdup(server);
+	g_strstrip(server_trimmed);
+	gchar **strings = g_strsplit(server_trimmed, ":", 2);
+
+	if (strings[0] != NULL)
+		if (g_hostname_is_ip_address(strings[0]))
+			g_stpcpy(server, server_trimmed);
+
+	remmina_file_set_string(remminafile, "sound", "off");
+	remmina_file_set_string(remminafile, "server", server);
+	remmina_file_set_string(remminafile, "name", server);
+	remmina_file_set_string(remminafile, "protocol", qcp);
+	g_free(server);
+	g_free(server_trimmed);
+	g_free(qcp);
+
+	rcw_open_from_file(remminafile);
+
+	return FALSE;
+}
+
+gboolean remmina_main_quickconnect_on_click(GtkWidget *widget, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	if (!kioskmode && kioskmode == FALSE)
+		return remmina_main_quickconnect();
+	return FALSE;
+}
+
+/* Select all the text inside the quick search box if there is anything */
+void remmina_main_quick_search_enter(GtkWidget *widget, gpointer user_data)
+{
+	if (gtk_entry_get_text(remminamain->entry_quick_connect_server))
+		gtk_editable_select_region(GTK_EDITABLE(remminamain->entry_quick_connect_server), 0, -1);
+}
+
+void remmina_main_on_action_collapse(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	gtk_tree_view_collapse_all(remminamain->tree_files_list);
+}
+
+void remmina_main_on_action_search_toggle(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	REMMINA_DEBUG("Search toggle triggered");
+
+	gboolean toggle_status = gtk_toggle_button_get_active(remminamain->search_toggle);
+
+	gtk_search_bar_set_search_mode(remminamain->search_bar, toggle_status);
+	if (toggle_status) {
+		REMMINA_DEBUG("Search toggle is active");
+		gtk_widget_grab_focus(GTK_WIDGET(remminamain->entry_quick_connect_server));
+	} else {
+		REMMINA_DEBUG("Search toggle is not active, focus is tree_files_list");
+		gtk_widget_grab_focus(GTK_WIDGET(remminamain->tree_files_list));
+	}
+}
+
+void remmina_main_on_accel_search_toggle(RemminaMain *remminamain)
+{
+	TRACE_CALL(__func__);
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(remminamain->search_toggle), TRUE);
+}
+
+void remmina_main_on_action_expand(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	gtk_tree_view_expand_all(remminamain->tree_files_list);
+}
+
+/* Handle double click on a row in the connections list */
+void remmina_main_file_list_on_row_activated(GtkTreeView *tree, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+/* If a connection was selected then execute the default action */
+	if (remminamain->priv->selected_filename) {
+		switch (remmina_pref.default_action) {
+		case REMMINA_ACTION_EDIT:
+			remmina_main_on_action_connection_edit(NULL, NULL, NULL);
+			break;
+		case REMMINA_ACTION_CONNECT:
+		default:
+			remmina_main_on_action_connection_connect(NULL, NULL, NULL);
+			break;
+		}
+	}
+}
+
+/* Show the popup menu by the right button mouse click */
+gboolean remmina_main_file_list_on_button_press(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	if (event->button == MOUSE_BUTTON_RIGHT) {
+		if (!kioskmode && kioskmode == FALSE) {
+#if GTK_CHECK_VERSION(3, 22, 0)
+			// For now, if more than one selected row, display only a delete menu option
+			if (gtk_tree_selection_count_selected_rows(gtk_tree_view_get_selection(remminamain->tree_files_list)) > 1) {
+				gtk_menu_popup_at_pointer(GTK_MENU(remminamain->menu_popup_delete_rc), (GdkEvent *)event);
+				return GDK_EVENT_STOP;
+			}
+			else {
+				gtk_menu_popup_at_pointer(GTK_MENU(remminamain->menu_popup), (GdkEvent *)event);
+			}
+#else
+			gtk_menu_popup(remminamain->menu_popup, NULL, NULL, NULL, NULL, event->button, event->time);
+#endif
+		}
+	}
+	return FALSE;
+}
+
+/* Show the popup menu by the menu key */
+gboolean remmina_main_file_list_on_key_press(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	if (event->keyval == GDK_KEY_Menu) {
+#if GTK_CHECK_VERSION(3, 22, 0)
+		gtk_menu_popup_at_widget(GTK_MENU(remminamain->menu_popup), widget,
+					 GDK_GRAVITY_CENTER, GDK_GRAVITY_CENTER,
+					 (GdkEvent *)event);
+#else
+		gtk_menu_popup(remminamain->menu_popup, NULL, NULL, NULL, NULL, 0, event->time);
+#endif
+	}
+	return FALSE;
+}
+
+void remmina_main_quick_search_on_icon_press(GtkEntry *entry, GtkEntryIconPosition icon_pos, GdkEvent *event, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	if (icon_pos == GTK_ENTRY_ICON_SECONDARY)
+		gtk_entry_set_text(entry, "");
+}
+
+void remmina_main_quick_search_on_changed(GtkEditable *editable, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	/* If a search text was input then temporary set the file mode to list */
+	if (gtk_entry_get_text_length(remminamain->entry_quick_connect_server)) {
+		if (GTK_IS_TREE_STORE(remminamain->priv->file_model)) {
+			/* File view mode changed, put it to override and reload list */
+			remminamain->priv->override_view_file_mode_to_list = TRUE;
+			remmina_main_load_files();
+		}
+	} else {
+		if (remminamain->priv->override_view_file_mode_to_list) {
+			/* File view mode changed, put it to default (disable override) and reload list */
+			remminamain->priv->override_view_file_mode_to_list = FALSE;
+			remmina_main_load_files();
+		}
+	}
+	gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(remminamain->priv->file_model_filter));
+}
+
+void remmina_main_on_drag_data_received(GtkWidget *widget, GdkDragContext *drag_context, gint x, gint y,
+					GtkSelectionData *data, guint info, guint time, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gchar **uris;
+	GSList *files = NULL;
+	gint i;
+
+	uris = g_uri_list_extract_uris((const gchar *)gtk_selection_data_get_data(data));
+	for (i = 0; uris[i]; i++) {
+		if (strncmp(uris[i], "file://", 7) != 0)
+			continue;
+		files = g_slist_append(files, g_strdup(uris[i] + 7));
+	}
+	g_strfreev(uris);
+	remmina_main_import_file_list(files);
+}
+
+/* Add a new menuitem to the Tools menu */
+static gboolean remmina_main_add_tool_plugin(gchar *name, RemminaPlugin *plugin, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	RemminaToolPlugin *tool_plugin = (RemminaToolPlugin *)plugin;
+	GtkWidget *menuitem = gtk_menu_item_new_with_label(plugin->description);
+
+	gtk_widget_show(menuitem);
+	gtk_menu_shell_append(GTK_MENU_SHELL(remminamain->menu_popup_full), menuitem);
+	g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(tool_plugin->exec_func), tool_plugin);
+	return FALSE;
+}
+
+gboolean remmina_main_on_window_state_event(GtkWidget *widget, GdkEventWindowState *event, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	return FALSE;
+}
+
+/* Remmina main window initialization */
+static void remmina_main_init(void)
+{
+	TRACE_CALL(__func__);
+	int i, qcp_idx, qcp_actidx;
+	char *name;
+	GtkSettings *settings;
+
+	REMMINA_DEBUG("Initializing the Remmina main window");
+	/* Switch to a dark theme if the user enabled it */
+	settings = gtk_settings_get_default();
+	g_object_set(settings, "gtk-application-prefer-dark-theme", remmina_pref.dark_theme, NULL);
+
+	REMMINA_DEBUG ("Initializing monitor");
+	remminamain->monitor = remmina_network_monitor_new();
+
+	remminamain->priv->expanded_group = remmina_string_array_new_from_string(remmina_pref.expanded_group);
+	if (!kioskmode && kioskmode == FALSE)
+		gtk_window_set_title(remminamain->window, _("Remmina Remote Desktop Client"));
+	else
+		gtk_window_set_title(remminamain->window, _("Remmina Kiosk"));
+	if (!kioskmode && kioskmode == FALSE) {
+		gtk_window_set_default_size(remminamain->window, remmina_pref.main_width, remmina_pref.main_height);
+		if (remmina_pref.main_maximize)
+			gtk_window_maximize(remminamain->window);
+	}
+	/* Honor global preferences Search Bar visibility */
+	if (remmina_pref.hide_searchbar)
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(RM_GET_OBJECT("search_toggle")), FALSE);
+
+	/* Add a GtkMenuItem to the Tools menu for each plugin of type REMMINA_PLUGIN_TYPE_TOOL */
+	remmina_plugin_manager_for_each_plugin(REMMINA_PLUGIN_TYPE_TOOL, remmina_main_add_tool_plugin, remminamain);
+
+	/* Add available quick connect protocols to remminamain->combo_quick_connect_protocol */
+	qcp_idx = qcp_actidx = 0;
+	for (i = 0; i < sizeof(quick_connect_plugin_list) / sizeof(quick_connect_plugin_list[0]); i++) {
+		name = quick_connect_plugin_list[i];
+		if (remmina_plugin_manager_get_plugin(REMMINA_PLUGIN_TYPE_PROTOCOL, name)) {
+			gtk_combo_box_text_append(remminamain->combo_quick_connect_protocol, name, name);
+			if (remmina_pref.last_quickconnect_protocol != NULL && strcmp(name, remmina_pref.last_quickconnect_protocol) == 0)
+				qcp_actidx = qcp_idx;
+			qcp_idx++;
+		}
+	}
+	gtk_combo_box_set_active(GTK_COMBO_BOX(remminamain->combo_quick_connect_protocol), qcp_actidx);
+
+	/* Connect the group accelerators to the GtkWindow */
+	//gtk_window_add_accel_group(remminamain->window, remminamain->accelgroup_shortcuts);
+	/* Set the Quick Connection */
+	gtk_entry_set_activates_default(remminamain->entry_quick_connect_server, TRUE);
+	/* Set the TreeView for the files list */
+	gtk_tree_selection_set_select_function(
+		gtk_tree_view_get_selection(remminamain->tree_files_list),
+		remmina_main_selection_func, NULL, NULL);
+	/** @todo Set entry_quick_connect_server as default search entry. Weirdly. This does not work yet. */
+	gtk_tree_view_set_search_entry(remminamain->tree_files_list, GTK_ENTRY(remminamain->entry_quick_connect_server));
+	if (remmina_pref.hide_searchbar)
+		gtk_widget_grab_focus(GTK_WIDGET(remminamain->tree_files_list));
+	/* Load the files list */
+	remmina_main_load_files();
+
+	/* Drag-n-drop support */
+	gtk_drag_dest_set(GTK_WIDGET(remminamain->window), GTK_DEST_DEFAULT_ALL, remmina_drop_types, 1, GDK_ACTION_COPY);
+
+	/* Finish initialization */
+	remminamain->priv->initialized = TRUE;
+
+	/* Register the window in remmina_widget_pool with GType=GTK_WINDOW and TAG=remmina-main-window */
+	g_object_set_data(G_OBJECT(remminamain->window), "tag", "remmina-main-window");
+	remmina_widget_pool_register(GTK_WIDGET(remminamain->window));
+}
+
+/* Signal handler for "show" on remminamain->window */
+void remmina_main_on_show(GtkWidget *w, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+#ifdef SNAP_BUILD
+	remmina_main_show_snap_welcome();
+#endif
+}
+
+/* RemminaMain instance */
+GtkWidget *remmina_main_new(void)
+{
+	TRACE_CALL(__func__);
+	GSimpleActionGroup *actions;
+	GtkAccelGroup *accel_group = NULL;
+
+	remminamain = g_new0(RemminaMain, 1);
+	remminamain->priv = g_new0(RemminaMainPriv, 1);
+	/* Assign UI widgets to the private members */
+	remminamain->builder = remmina_public_gtk_builder_new_from_resource("/org/remmina/Remmina/src/../data/ui/remmina_main.glade");
+	remminamain->window = GTK_WINDOW(RM_GET_OBJECT("RemminaMain"));
+	if (kioskmode && kioskmode == TRUE) {
+		gtk_window_set_position(remminamain->window, GTK_WIN_POS_CENTER_ALWAYS);
+		gtk_window_set_default_size(remminamain->window, 800, 400);
+		gtk_window_set_resizable(remminamain->window, FALSE);
+	}
+	/* New Button */
+	remminamain->button_new = GTK_BUTTON(RM_GET_OBJECT("button_new"));
+	if (kioskmode && kioskmode == TRUE)
+		gtk_widget_set_sensitive(GTK_WIDGET(remminamain->button_new), FALSE);
+	/* Search bar */
+	remminamain->search_toggle = GTK_TOGGLE_BUTTON(RM_GET_OBJECT("search_toggle"));
+	remminamain->search_bar = GTK_SEARCH_BAR(RM_GET_OBJECT("search_bar"));
+	/* view mode list/tree */
+	remminamain->view_toggle_button = GTK_TOGGLE_BUTTON(RM_GET_OBJECT("view_toggle_button"));
+	if (kioskmode && kioskmode == TRUE)
+		gtk_widget_set_sensitive(GTK_WIDGET(remminamain->view_toggle_button), FALSE);
+
+	/* Menu widgets */
+	remminamain->menu_popup = GTK_MENU(RM_GET_OBJECT("menu_popup"));
+	remminamain->menu_header_button = GTK_MENU_BUTTON(RM_GET_OBJECT("menu_header_button"));
+	remminamain->menu_popup_full = GTK_MENU(RM_GET_OBJECT("menu_popup_full"));
+	remminamain->menu_popup_delete_rc = GTK_MENU(RM_GET_OBJECT("menu_popup_delete_rc"));
+	if (kioskmode && kioskmode == TRUE) {
+		gtk_widget_set_sensitive(GTK_WIDGET(remminamain->menu_popup_full), FALSE);
+		gtk_widget_set_sensitive(GTK_WIDGET(remminamain->menu_header_button), FALSE);
+	}
+	/* View mode radios */
+	remminamain->menuitem_view_mode_list = GTK_RADIO_MENU_ITEM(RM_GET_OBJECT("menuitem_view_mode_list"));
+	remminamain->menuitem_view_mode_tree = GTK_RADIO_MENU_ITEM(RM_GET_OBJECT("menuitem_view_mode_tree"));
+	/* Quick connect objects */
+	remminamain->box_quick_connect = GTK_BOX(RM_GET_OBJECT("box_quick_connect"));
+	remminamain->combo_quick_connect_protocol = GTK_COMBO_BOX_TEXT(RM_GET_OBJECT("combo_quick_connect_protocol"));
+	if (kioskmode && kioskmode == TRUE)
+		gtk_widget_set_sensitive(GTK_WIDGET(remminamain->combo_quick_connect_protocol), FALSE);
+	remminamain->entry_quick_connect_server = GTK_ENTRY(RM_GET_OBJECT("entry_quick_connect_server"));
+	/* Other widgets */
+	remminamain->tree_files_list = GTK_TREE_VIEW(RM_GET_OBJECT("tree_files_list"));
+	remminamain->column_files_list_name = GTK_TREE_VIEW_COLUMN(RM_GET_OBJECT("column_files_list_name"));
+	remminamain->column_files_list_group = GTK_TREE_VIEW_COLUMN(RM_GET_OBJECT("column_files_list_group"));
+	remminamain->column_files_list_server = GTK_TREE_VIEW_COLUMN(RM_GET_OBJECT("column_files_list_server"));
+	remminamain->column_files_list_plugin = GTK_TREE_VIEW_COLUMN(RM_GET_OBJECT("column_files_list_plugin"));
+	remminamain->column_files_list_date = GTK_TREE_VIEW_COLUMN(RM_GET_OBJECT("column_files_list_date"));
+	remminamain->column_files_list_notes = GTK_TREE_VIEW_COLUMN(RM_GET_OBJECT("column_files_list_notes"));
+	gtk_tree_view_column_set_fixed_width(remminamain->column_files_list_notes, 100);
+	remminamain->statusbar_main = GTK_STATUSBAR(RM_GET_OBJECT("statusbar_main"));
+	/* signals */
+	g_signal_connect(remminamain->entry_quick_connect_server, "key-release-event", G_CALLBACK(remmina_main_search_key_event), NULL);
+	g_signal_connect(remminamain->tree_files_list, "row-activated", G_CALLBACK(remmina_main_tree_row_activated), NULL);
+	/* Non widget objects */
+	actions = g_simple_action_group_new();
+	g_action_map_add_action_entries(G_ACTION_MAP(actions), app_actions, G_N_ELEMENTS(app_actions), remminamain->window);
+	gtk_widget_insert_action_group(GTK_WIDGET(remminamain->window), "app", G_ACTION_GROUP(actions));
+	g_action_map_add_action_entries(G_ACTION_MAP(actions), main_actions, G_N_ELEMENTS(main_actions), remminamain->window);
+	gtk_widget_insert_action_group(GTK_WIDGET(remminamain->window), "main", G_ACTION_GROUP(actions));
+	g_object_unref(actions);
+	/* Accelerators */
+	accel_group = gtk_accel_group_new();
+	gtk_window_add_accel_group(remminamain->window, accel_group);
+	gtk_accel_group_connect(accel_group, GDK_KEY_Q, GDK_CONTROL_MASK, 0,
+				g_cclosure_new_swap(G_CALLBACK(remmina_main_on_action_application_quit), NULL, NULL));
+	// TODO: This crash remmina because the function doesn't receive the parameter we expect
+	gtk_accel_group_connect(accel_group, GDK_KEY_P, GDK_CONTROL_MASK, 0,
+				g_cclosure_new_swap(G_CALLBACK(remmina_main_on_accel_application_preferences), NULL, NULL));
+	gtk_accel_group_connect(accel_group, GDK_KEY_F, GDK_CONTROL_MASK, 0,
+				g_cclosure_new_swap(G_CALLBACK(remmina_main_on_accel_search_toggle), remminamain, NULL));
+
+	/* Connect signals */
+	gtk_builder_connect_signals(remminamain->builder, NULL);
+	/* Initialize the window and load the preferences */
+	remmina_main_init();
+	return GTK_WIDGET(remminamain->window);
+}
+
+GtkWindow *remmina_main_get_window()
+{
+	if (!remminamain)
+		return NULL;
+	if (!remminamain->priv)
+		return NULL;
+	if (!remminamain->priv->initialized)
+		return NULL;
+	remminamain->window = GTK_WINDOW(RM_GET_OBJECT("RemminaMain"));
+	return remminamain->window;
+}
+
+void remmina_main_update_file_datetime(RemminaFile *file)
+{
+	if (!remminamain)
+		return;
+	remmina_main_load_files();
+}
+
+void remmina_main_show_dialog(GtkMessageType msg, GtkButtonsType buttons, const gchar* message) {
+	GtkWidget *dialog;
+
+	if (remminamain->window) {
+		dialog = gtk_message_dialog_new(remminamain->window, GTK_DIALOG_MODAL, msg, buttons, "%s", message);
+		gtk_dialog_run(GTK_DIALOG(dialog));
+		gtk_widget_destroy(dialog);
+	}
+}
+
+void remmina_main_show_warning_dialog(const gchar *message) {
+    GtkWidget *dialog;
+
+    if (remminamain->window) {
+        dialog = gtk_message_dialog_new(remminamain->window, GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE,
+                                        message, g_get_application_name());
+        gtk_dialog_run(GTK_DIALOG(dialog));
+        gtk_widget_destroy(dialog);
+    }
+}
\ No newline at end of file
diff --git a/src/remmina_main.h b/src/remmina_main.h
new file mode 100644
index 0000000..f112b77
--- /dev/null
+++ b/src/remmina_main.h
@@ -0,0 +1,146 @@
+/*
+ * 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-2022 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2022-2023 Antenore Gatta, Giovanni Panozzo, Hiroyuki Tanaka
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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.
+ *
+ */
+
+#pragma once
+
+#include "remmina_file.h"
+#include "remmina_monitor.h"
+#include <gtk/gtk.h>
+
+#include "remmina_string_array.h"
+
+typedef struct _RemminaMainPriv RemminaMainPriv;
+
+typedef struct _RemminaMain {
+	GtkBuilder *		builder;
+	GtkWindow *		window;
+	/* Menu widgets */
+	GtkMenu *		menu_popup;
+	GtkMenuButton *		menu_header_button;
+	GtkMenu *		menu_popup_full;
+	GtkMenu *       menu_popup_delete_rc;
+	GtkRadioMenuItem *	menuitem_view_mode_list;
+	GtkRadioMenuItem *	menuitem_view_mode_tree;
+	GtkMenuItem *		menuitem_connection_quit;
+	/* Button new */
+	GtkButton *		button_new;
+	GtkButton *		button_make_default;
+	/* Search bar objects */
+	GtkToggleButton *	search_toggle;
+	GtkSwitch *		switch_dark_mode;
+	GtkToggleButton *	view_toggle_button;
+	GtkToggleButton *	ustats_toggle;
+	GtkSearchBar *		search_bar;
+	/* Quick connect objects */
+	GtkBox *		box_quick_connect;
+	GtkComboBoxText *	combo_quick_connect_protocol;
+	GtkEntry *		entry_quick_connect_server;
+	GtkButton *		button_quick_connect;
+	/* Other widgets */
+	GtkTreeView *		tree_files_list;
+	GtkTreeViewColumn *	column_files_list_name;
+	GtkTreeViewColumn *	column_files_list_group;
+	GtkTreeViewColumn *	column_files_list_server;
+	GtkTreeViewColumn *	column_files_list_plugin;
+	GtkTreeViewColumn *	column_files_list_date;
+	GtkTreeViewColumn *	column_files_list_notes;
+	GtkStatusbar *		statusbar_main;
+	GtkWidget *		network_icon;
+	/* Non widget objects */
+	GtkAccelGroup *		accelgroup_shortcuts;
+	RemminaMainPriv *	priv;
+	RemminaMonitor *	monitor;
+} RemminaMain;
+
+struct _RemminaMainPriv {
+	GtkTreeModel *		file_model;
+	GtkTreeModel *		file_model_filter;
+	GtkTreeModel *		file_model_sort;
+
+	gboolean		initialized;
+
+	gchar *			selected_filename;
+	gchar *			selected_name;
+	gboolean		override_view_file_mode_to_list;
+	RemminaStringArray *	expanded_group;
+};
+
+G_BEGIN_DECLS
+
+/* Create the remminamain struct and the remmina main Remmina window */
+GtkWidget *remmina_main_new(void);
+/* Get the current main GTK window or NULL if not initialized */
+GtkWindow *remmina_main_get_window(void);
+
+void remmina_main_update_file_datetime(RemminaFile *file);
+
+void remmina_main_destroy(void);
+void remmina_main_on_destroy_event(void);
+void remmina_main_save_before_destroy(void);
+
+void remmina_main_show_dialog(GtkMessageType msg, GtkButtonsType buttons, const gchar* message);
+void remmina_main_show_warning_dialog(const gchar *message);
+void remmina_main_on_action_application_about(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_application_bug_report(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_application_default(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_application_mpchange(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_application_plugins(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_application_dark_theme(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_application_preferences(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_application_quit(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_connection_connect(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_connection_copy(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_connection_delete(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_connection_delete_multiple(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_connection_edit(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_connection_external_tools(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_connection_new(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_help_community(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_help_debug(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_help_donations(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_help_homepage(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_help_wiki(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_tools_export(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_tools_import(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_expand(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_collapse(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_on_action_search_toggle(GSimpleAction *action, GVariant *param, gpointer data);
+void remmina_main_toggle_password_view(GtkWidget *widget, gpointer data);
+void remmina_main_reload_preferences();
+
+G_END_DECLS
diff --git a/src/remmina_marshals.c b/src/remmina_marshals.c
new file mode 100644
index 0000000..2fe355e
--- /dev/null
+++ b/src/remmina_marshals.c
@@ -0,0 +1,161 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009-2011 Vic Lee
+ * Copyright (C) 2011 Marc-Andre Moreau
+ * 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        <glib-object.h>
+#include "remmina/remmina_trace_calls.h"
+
+#ifdef G_ENABLE_DEBUG
+#define g_marshal_value_peek_boolean(v)  g_value_get_boolean(v)
+#define g_marshal_value_peek_char(v)     g_value_get_char(v)
+#define g_marshal_value_peek_uchar(v)    g_value_get_uchar(v)
+#define g_marshal_value_peek_int(v)      g_value_get_int(v)
+#define g_marshal_value_peek_uint(v)     g_value_get_uint(v)
+#define g_marshal_value_peek_long(v)     g_value_get_long(v)
+#define g_marshal_value_peek_ulong(v)    g_value_get_ulong(v)
+#define g_marshal_value_peek_int64(v)    g_value_get_int64(v)
+#define g_marshal_value_peek_uint64(v)   g_value_get_uint64(v)
+#define g_marshal_value_peek_enum(v)     g_value_get_enum(v)
+#define g_marshal_value_peek_flags(v)    g_value_get_flags(v)
+#define g_marshal_value_peek_float(v)    g_value_get_float(v)
+#define g_marshal_value_peek_double(v)   g_value_get_double(v)
+#define g_marshal_value_peek_string(v)   (char*)g_value_get_string(v)
+#define g_marshal_value_peek_param(v)    g_value_get_param(v)
+#define g_marshal_value_peek_boxed(v)    g_value_get_boxed(v)
+#define g_marshal_value_peek_pointer(v)  g_value_get_pointer(v)
+#define g_marshal_value_peek_object(v)   g_value_get_object(v)
+#else /* !G_ENABLE_DEBUG */
+/* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
+ *          Do not access GValues directly in your code. Instead, use the
+ *          g_value_get_*() functions
+ */
+#define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
+#define g_marshal_value_peek_char(v)     (v)->data[0].v_int
+#define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
+#define g_marshal_value_peek_int(v)      (v)->data[0].v_int
+#define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
+#define g_marshal_value_peek_long(v)     (v)->data[0].v_long
+#define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
+#define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
+#define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
+#define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
+#define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
+#define g_marshal_value_peek_float(v)    (v)->data[0].v_float
+#define g_marshal_value_peek_double(v)   (v)->data[0].v_double
+#define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
+#define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
+#define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
+#define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
+#define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
+#endif /* !G_ENABLE_DEBUG */
+
+/* BOOLEAN:INT (remminamarshals.list:4) */
+void
+remmina_marshal_BOOLEAN__INT(GClosure     *closure,
+			     GValue       *return_value G_GNUC_UNUSED,
+			     guint n_param_values,
+			     const GValue *param_values,
+			     gpointer invocation_hint G_GNUC_UNUSED,
+			     gpointer marshal_data)
+{
+	TRACE_CALL(__func__);
+	typedef gboolean (*GMarshalFunc_BOOLEAN__INT) (gpointer data1,
+						       gint arg_1,
+						       gpointer data2);
+	register GMarshalFunc_BOOLEAN__INT callback;
+	register GCClosure *cc = (GCClosure*)closure;
+	register gpointer data1, data2;
+	gboolean v_return;
+
+	g_return_if_fail(return_value != NULL);
+	g_return_if_fail(n_param_values == 2);
+
+	if (G_CCLOSURE_SWAP_DATA(closure)) {
+		data1 = closure->data;
+		data2 = g_value_peek_pointer(param_values + 0);
+	}else  {
+		data1 = g_value_peek_pointer(param_values + 0);
+		data2 = closure->data;
+	}
+	callback = (GMarshalFunc_BOOLEAN__INT)(marshal_data ? marshal_data : cc->callback);
+
+	v_return = callback(data1,
+		g_marshal_value_peek_int(param_values + 1)
+		,
+		data2);
+
+	g_value_set_boolean(return_value, v_return);
+}
+
+/* BOOLEAN:INT,STRING (remminamarshals.list:5) */
+void
+remmina_marshal_BOOLEAN__INT_STRING(GClosure *closure,
+				    GValue *return_value G_GNUC_UNUSED,
+				    guint n_param_values,
+				    const GValue *param_values,
+				    gpointer invocation_hint G_GNUC_UNUSED,
+				    gpointer marshal_data)
+{
+	TRACE_CALL(__func__);
+	typedef gboolean (*GMarshalFunc_BOOLEAN__INT_STRING) (gpointer data1,
+							      gint arg_1,
+							      gpointer arg_2,
+							      gpointer data2);
+	register GMarshalFunc_BOOLEAN__INT_STRING callback;
+	register GCClosure *cc = (GCClosure*)closure;
+	register gpointer data1, data2;
+	gboolean v_return;
+
+	g_return_if_fail(return_value != NULL);
+	g_return_if_fail(n_param_values == 3);
+
+	if (G_CCLOSURE_SWAP_DATA(closure)) {
+		data1 = closure->data;
+		data2 = g_value_peek_pointer(param_values + 0);
+	}else  {
+		data1 = g_value_peek_pointer(param_values + 0);
+		data2 = closure->data;
+	}
+	callback = (GMarshalFunc_BOOLEAN__INT_STRING)(marshal_data ? marshal_data : cc->callback);
+
+	v_return = callback(data1,
+		g_marshal_value_peek_int(param_values + 1),
+		g_marshal_value_peek_string(param_values + 2),
+		data2);
+
+	g_value_set_boolean(return_value, v_return);
+}
+
diff --git a/src/remmina_marshals.h b/src/remmina_marshals.h
new file mode 100644
index 0000000..4cd1d98
--- /dev/null
+++ b/src/remmina_marshals.h
@@ -0,0 +1,50 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * 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.
+ *
+ */
+
+#ifndef __remmina_marshal_MARSHAL_H__
+#define __remmina_marshal_MARSHAL_H__
+
+#include        <glib-object.h>
+
+G_BEGIN_DECLS
+
+/* BOOLEAN:INT (remminamarshals.list:4) */
+extern void remmina_marshal_BOOLEAN__INT(GClosure *closure, GValue *return_value, guint n_param_values, const GValue *param_values, gpointer invocation_hint, gpointer marshal_data);
+
+/* BOOLEAN:INT,STRING (remminamarshals.list:5) */
+extern void remmina_marshal_BOOLEAN__INT_STRING(GClosure *closure, GValue *return_value, guint n_param_values, const GValue *param_values, gpointer invocation_hint, gpointer marshal_data);
+
+G_END_DECLS
+
+#endif /* __remmina_marshal_MARSHAL_H__ */
diff --git a/src/remmina_marshals.list b/src/remmina_marshals.list
new file mode 100644
index 0000000..ba3e432
--- /dev/null
+++ b/src/remmina_marshals.list
@@ -0,0 +1,6 @@
+# Use glib-genmarshal to generate remminamarshals.h and remminamarshals.c:
+# $ glib-genmarshal --header --prefix=remmina_marshal remminamarshals.list > remminamarshals.h
+# $ glib-genmarshal --body --prefix=remmina_marshal remminamarshals.list > remminamarshals.c
+BOOLEAN:INT
+BOOLEAN:INT,STRING
+
diff --git a/src/remmina_masterthread_exec.c b/src/remmina_masterthread_exec.c
new file mode 100644
index 0000000..97c2ffe
--- /dev/null
+++ b/src/remmina_masterthread_exec.c
@@ -0,0 +1,151 @@
+/*
+ * 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.
+ *
+ */
+
+/* Support for execution on main thread of some GTK related
+ * functions (due to threads deprecations in GTK) */
+
+#include <gtk/gtk.h>
+
+#include "remmina_masterthread_exec.h"
+
+static pthread_t gMainThreadID;
+
+static gboolean remmina_masterthread_exec_callback(RemminaMTExecData *d)
+{
+
+	/* This function is called on main GTK Thread via gdk_threads_add_idlde()
+	 * from remmina_masterthread_exec_and_wait() */
+
+	if (!d->cancelled) {
+		switch (d->func) {
+		case FUNC_INIT_SAVE_CRED:
+			remmina_protocol_widget_save_cred(d->p.init_save_creds.gp);
+			break;
+		case FUNC_CHAT_RECEIVE:
+			remmina_protocol_widget_chat_receive(d->p.chat_receive.gp, d->p.chat_receive.text);
+			break;
+		case FUNC_FILE_GET_STRING:
+			d->p.file_get_string.retval = remmina_file_get_string( d->p.file_get_string.remminafile, d->p.file_get_string.setting );
+			break;
+		case FUNC_FILE_SET_STRING:
+			remmina_file_set_string( d->p.file_set_string.remminafile, d->p.file_set_string.setting, d->p.file_set_string.value );
+			break;
+		case FUNC_GTK_LABEL_SET_TEXT:
+			gtk_label_set_text( d->p.gtk_label_set_text.label, d->p.gtk_label_set_text.str );
+			break;
+		case FUNC_FTP_CLIENT_UPDATE_TASK:
+			remmina_ftp_client_update_task( d->p.ftp_client_update_task.client, d->p.ftp_client_update_task.task );
+			break;
+		case FUNC_FTP_CLIENT_GET_WAITING_TASK:
+			d->p.ftp_client_get_waiting_task.retval = remmina_ftp_client_get_waiting_task( d->p.ftp_client_get_waiting_task.client );
+			break;
+		case FUNC_PROTOCOLWIDGET_EMIT_SIGNAL:
+			remmina_protocol_widget_emit_signal(d->p.protocolwidget_emit_signal.gp, d->p.protocolwidget_emit_signal.signal_name);
+			break;
+		case FUNC_PROTOCOLWIDGET_MPPROGRESS:
+			d->p.protocolwidget_mpprogress.ret_mp = remmina_protocol_widget_mpprogress(d->p.protocolwidget_mpprogress.cnnobj, d->p.protocolwidget_mpprogress.message,
+				d->p.protocolwidget_mpprogress.response_callback, d->p.protocolwidget_mpprogress.response_callback_data);
+			break;
+		case FUNC_PROTOCOLWIDGET_MPDESTROY:
+			remmina_protocol_widget_mpdestroy(d->p.protocolwidget_mpdestroy.cnnobj, d->p.protocolwidget_mpdestroy.mp);
+			break;
+		case FUNC_PROTOCOLWIDGET_MPSHOWRETRY:
+			remmina_protocol_widget_panel_show_retry(d->p.protocolwidget_mpshowretry.gp);
+			break;
+		case FUNC_PROTOCOLWIDGET_PANELSHOWLISTEN:
+			remmina_protocol_widget_panel_show_listen(d->p.protocolwidget_panelshowlisten.gp, d->p.protocolwidget_panelshowlisten.port);
+			break;
+		case FUNC_SFTP_CLIENT_CONFIRM_RESUME:
+#ifdef HAVE_LIBSSH
+			d->p.sftp_client_confirm_resume.retval = remmina_sftp_client_confirm_resume( d->p.sftp_client_confirm_resume.client,
+				d->p.sftp_client_confirm_resume.path );
+#endif
+			break;
+		case FUNC_VTE_TERMINAL_SET_ENCODING_AND_PTY:
+#if defined (HAVE_LIBSSH) && defined (HAVE_LIBVTE)
+			remmina_plugin_ssh_vte_terminal_set_encoding_and_pty( d->p.vte_terminal_set_encoding_and_pty.terminal,
+				d->p.vte_terminal_set_encoding_and_pty.codeset,
+				d->p.vte_terminal_set_encoding_and_pty.master,
+				d->p.vte_terminal_set_encoding_and_pty.slave);
+#endif
+			break;
+
+		}
+		pthread_mutex_lock(&d->pt_mutex);
+		d->complete = TRUE;
+		pthread_cond_signal(&d->pt_cond);
+		pthread_mutex_unlock(&d->pt_mutex);
+	}else  {
+		/* thread has been cancelled, so we must free d memory here */
+		g_free(d);
+	}
+	return G_SOURCE_REMOVE;
+}
+
+static void remmina_masterthread_exec_cleanup_handler(gpointer data)
+{
+	RemminaMTExecData *d = data;
+
+	d->cancelled = TRUE;
+}
+
+void remmina_masterthread_exec_and_wait(RemminaMTExecData *d)
+{
+	d->cancelled = FALSE;
+	d->complete = FALSE;
+	pthread_cleanup_push(remmina_masterthread_exec_cleanup_handler, (void*)d);
+	pthread_mutex_init(&d->pt_mutex, NULL);
+	pthread_cond_init(&d->pt_cond, NULL);
+	gdk_threads_add_idle((GSourceFunc)remmina_masterthread_exec_callback, (gpointer)d);
+	pthread_mutex_lock(&d->pt_mutex);
+	while (!d->complete)
+		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);
+}
+
+void remmina_masterthread_exec_save_main_thread_id()
+{
+	/* To be called from main thread at startup */
+	gMainThreadID = pthread_self();
+}
+
+gboolean remmina_masterthread_exec_is_main_thread()
+{
+	return pthread_equal(gMainThreadID, pthread_self()) != 0;
+}
+
diff --git a/src/remmina_masterthread_exec.h b/src/remmina_masterthread_exec.h
new file mode 100644
index 0000000..622f4af
--- /dev/null
+++ b/src/remmina_masterthread_exec.h
@@ -0,0 +1,136 @@
+/*
+ * 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 <pthread.h>
+#include "remmina_protocol_widget.h"
+#include "remmina_sftp_client.h"
+#include "remmina_ftp_client.h"
+#include "remmina_ssh_plugin.h"
+
+typedef struct remmina_masterthread_exec_data {
+	enum { FUNC_GTK_LABEL_SET_TEXT,
+	       FUNC_INIT_SAVE_CRED, FUNC_CHAT_RECEIVE,
+	       FUNC_FILE_GET_STRING, FUNC_FILE_SET_STRING,
+	       FUNC_FTP_CLIENT_UPDATE_TASK, FUNC_FTP_CLIENT_GET_WAITING_TASK,
+	       FUNC_SFTP_CLIENT_CONFIRM_RESUME,
+	       FUNC_PROTOCOLWIDGET_EMIT_SIGNAL,
+	       FUNC_PROTOCOLWIDGET_MPPROGRESS,
+	       FUNC_PROTOCOLWIDGET_MPDESTROY,
+	       FUNC_PROTOCOLWIDGET_MPSHOWRETRY,
+	       FUNC_PROTOCOLWIDGET_PANELSHOWLISTEN,
+	       FUNC_VTE_TERMINAL_SET_ENCODING_AND_PTY } func;
+
+	union {
+		struct {
+			GtkLabel *	label;
+			const gchar *	str;
+		} gtk_label_set_text;
+		struct {
+			RemminaProtocolWidget *gp;
+		} init_save_creds;
+		struct {
+			RemminaProtocolWidget * gp;
+			const gchar *		text;
+		} chat_receive;
+		struct {
+			RemminaFile *	remminafile;
+			const gchar *	setting;
+			const gchar *	retval;
+		} file_get_string;
+		struct {
+			RemminaFile *	remminafile;
+			const gchar *	setting;
+			const gchar *	value;
+		} file_set_string;
+		struct {
+			RemminaFTPClient *	client;
+			RemminaFTPTask *	task;
+		} ftp_client_update_task;
+		struct {
+			RemminaFTPClient *	client;
+			RemminaFTPTask *	retval;
+		} ftp_client_get_waiting_task;
+		struct {
+			RemminaProtocolWidget * gp;
+			const gchar *		signal_name;
+		} protocolwidget_emit_signal;
+		struct {
+			RemminaConnectionObject *	cnnobj;
+			const gchar *			message;
+			RemminaMessagePanelCallback	response_callback;
+			gpointer			response_callback_data;
+			RemminaMessagePanel *		ret_mp;
+		} protocolwidget_mpprogress;
+		struct {
+			RemminaConnectionObject *	cnnobj;
+			RemminaMessagePanel *		mp;
+		} protocolwidget_mpdestroy;
+		struct {
+			RemminaProtocolWidget *gp;
+		} protocolwidget_mpshowretry;
+		struct {
+			RemminaProtocolWidget * gp;
+			int			port;
+		} protocolwidget_panelshowlisten;
+#ifdef HAVE_LIBSSH
+		struct {
+			RemminaSFTPClient *	client;
+			const gchar *		path;
+			gint			retval;
+		} sftp_client_confirm_resume;
+#endif
+#ifdef HAVE_LIBVTE
+		struct {
+			VteTerminal *	terminal;
+			const char *	codeset;
+			int		master;
+			int		slave;
+		} vte_terminal_set_encoding_and_pty;
+#endif
+	} p;
+
+	/* Mutex for thread synchronization */
+	pthread_mutex_t pt_mutex;
+	pthread_cond_t	pt_cond;
+	/* Flag to catch cancellations */
+	gboolean	cancelled;
+	gboolean	complete;
+} RemminaMTExecData;
+
+void remmina_masterthread_exec_and_wait(RemminaMTExecData *d);
+
+void remmina_masterthread_exec_save_main_thread_id(void);
+gboolean remmina_masterthread_exec_is_main_thread(void);
diff --git a/src/remmina_message_panel.c b/src/remmina_message_panel.c
new file mode 100644
index 0000000..460f212
--- /dev/null
+++ b/src/remmina_message_panel.c
@@ -0,0 +1,801 @@
+/*
+ * 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 <glib/gi18n.h>
+#include "config.h"
+#include "remmina_public.h"
+#include "remmina_widget_pool.h"
+#include "remmina_main.h"
+#include "remmina_message_panel.h"
+#include "remmina_masterthread_exec.h"
+#include "remmina/remmina_trace_calls.h"
+
+
+typedef struct
+{
+
+	RemminaMessagePanelCallback response_callback;
+	void *response_callback_data;
+	GtkWidget *w[REMMINA_MESSAGE_PANEL_MAXWIDGETID];
+
+} RemminaMessagePanelPrivate;
+G_DEFINE_TYPE_WITH_PRIVATE (RemminaMessagePanel, remmina_message_panel, GTK_TYPE_BOX)
+
+
+enum {
+  RESPONSE,
+  LAST_SIGNAL
+};
+
+static guint messagepanel_signals[LAST_SIGNAL];
+
+static const gchar btn_response_key[] = "btn_response";
+
+static void remmina_message_panel_init (RemminaMessagePanel *mp)
+{
+	TRACE_CALL(__func__);
+}
+
+static void remmina_message_panel_class_init(RemminaMessagePanelClass *class)
+{
+	TRACE_CALL(__func__);
+	// class->transform_text = my_app_label_real_transform_text;
+
+	messagepanel_signals[RESPONSE] =
+		g_signal_new ("response",
+			G_OBJECT_CLASS_TYPE (class),
+			G_SIGNAL_RUN_LAST,
+			G_STRUCT_OFFSET (RemminaMessagePanelClass, response),
+			NULL, NULL,
+			NULL,
+			G_TYPE_NONE, 1,
+			G_TYPE_INT);
+}
+
+RemminaMessagePanel *remmina_message_panel_new()
+{
+	TRACE_CALL(__func__);
+	RemminaMessagePanelPrivate *priv;
+	RemminaMessagePanel* mp;
+	mp = (RemminaMessagePanel*)g_object_new(REMMINA_TYPE_MESSAGE_PANEL,
+		"orientation", GTK_ORIENTATION_VERTICAL,
+		"spacing", 0,
+		NULL);
+
+	priv = remmina_message_panel_get_instance_private(mp);
+
+	priv->response_callback = NULL;
+	priv->response_callback_data = NULL;
+
+	/* Set widget class, for CSS styling */
+	// gtk_widget_set_name(GTK_WIDGET(mp), "remmina-cw-message-panel");
+	gtk_style_context_add_class(gtk_widget_get_style_context(GTK_WIDGET(mp)), "message_panel");
+	gtk_style_context_add_class(gtk_widget_get_style_context(GTK_WIDGET(mp)), "background");
+
+	return mp;
+}
+
+static void remmina_message_panel_button_clicked_callback(
+	GtkButton *button, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	RemminaMessagePanel *mp = (RemminaMessagePanel*)user_data;
+	RemminaMessagePanelPrivate *priv = remmina_message_panel_get_instance_private(mp);
+
+	gint btn_data;
+
+	btn_data = (gint)((gint64)g_object_get_data(G_OBJECT(button), btn_response_key));
+
+	/* Calls the callback, if defined */
+	if (priv->response_callback != NULL)
+		(*priv->response_callback)(priv->response_callback_data, btn_data);
+
+}
+
+void remmina_message_panel_setup_progress(RemminaMessagePanel *mp, const gchar *message, RemminaMessagePanelCallback response_callback, gpointer response_callback_data)
+{
+	/*
+	 * Setup a message panel to show a spinner, a message like "Connecting…",
+	 * and a button to cancel the action in progress
+	 *
+	 */
+
+	TRACE_CALL(__func__);
+	GtkBox *hbox;
+	GtkWidget *w;
+	RemminaMessagePanelPrivate *priv = remmina_message_panel_get_instance_private(mp);
+
+	if ( !remmina_masterthread_exec_is_main_thread() ) {
+		printf("WARNING: %s called in a subthread. This should not happen.\n", __func__);
+		raise(SIGINT);
+	}
+
+	hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
+
+	/* A spinner */
+	w = gtk_spinner_new();
+	gtk_box_pack_start(hbox, w, FALSE, FALSE, 0);
+	gtk_spinner_start(GTK_SPINNER(w));
+
+	/* A message */
+	w = gtk_label_new(message);
+	gtk_box_pack_start(hbox, w, TRUE, TRUE, 0);
+
+	priv->response_callback = response_callback;
+	priv->response_callback_data = response_callback_data;
+
+	/* A button to cancel the action. The cancel button is available
+	 * only when a response_callback function is defined. */
+	if (response_callback) {
+		w = gtk_button_new_with_label(_("Cancel"));
+		gtk_box_pack_end(hbox, w, FALSE, FALSE, 0);
+		g_object_set_data(G_OBJECT(w), btn_response_key, (void *)GTK_RESPONSE_CANCEL);
+		g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(remmina_message_panel_button_clicked_callback), mp);
+	}
+
+	gtk_box_pack_start(GTK_BOX(mp), GTK_WIDGET(hbox), TRUE, TRUE, 0);
+
+	gtk_widget_show_all(GTK_WIDGET(mp));
+
+}
+
+void remmina_message_panel_setup_message(RemminaMessagePanel *mp, const gchar *message, RemminaMessagePanelCallback response_callback, gpointer response_callback_data)
+{
+	/*
+	 * Setup a message panel to a message to read like "Cannot connect…",
+	 * and a button to close the panel
+	 *
+	 */
+
+	TRACE_CALL(__func__);
+	GtkBox *hbox;
+	GtkWidget *w;
+	RemminaMessagePanelPrivate *priv = remmina_message_panel_get_instance_private(mp);
+
+	if ( !remmina_masterthread_exec_is_main_thread() ) {
+		printf("WARNING: %s called in a subthread. This should not happen.\n", __func__);
+	}
+
+	hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
+
+	/* A message */
+	w = gtk_label_new(message);
+	gtk_box_pack_start(hbox, w, TRUE, TRUE, 0);
+
+	/* A button to confirm reading */
+	w = gtk_button_new_with_label(_("Close"));
+	gtk_box_pack_end(hbox, w, FALSE, FALSE, 0);
+
+	priv->response_callback = response_callback;
+	priv->response_callback_data = response_callback_data;
+
+	g_object_set_data(G_OBJECT(w), btn_response_key, (void *)GTK_RESPONSE_OK);
+	g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(remmina_message_panel_button_clicked_callback), mp);
+
+	gtk_box_pack_start(GTK_BOX(mp), GTK_WIDGET(hbox), TRUE, TRUE, 0);
+
+	gtk_widget_show_all(GTK_WIDGET(mp));
+
+}
+
+void remmina_message_panel_setup_question(RemminaMessagePanel *mp, const gchar *message, RemminaMessagePanelCallback response_callback, gpointer response_callback_data)
+{
+	/*
+	 * Setup a message panel to a message to read like "Do you accept ?",
+	 * and a pair of button for Yes and No
+	 * message is an HTML string
+	 * Callback will receive GTK_RESPONSE_NO for No, GTK_RESPONSE_YES for Yes
+	 *
+	 */
+
+	TRACE_CALL(__func__);
+	GtkWidget *grid;
+	GtkWidget *bbox;
+	GtkWidget *w;
+	RemminaMessagePanelPrivate *priv = remmina_message_panel_get_instance_private(mp);
+
+	if ( !remmina_masterthread_exec_is_main_thread() ) {
+		printf("WARNING: %s called in a subthread. This should not happen. Raising SIGINT for debugging.\n", __func__);
+		raise(SIGINT);
+	}
+
+	/* Create grid */
+	grid = gtk_grid_new();
+	gtk_widget_set_halign(GTK_WIDGET(grid), GTK_ALIGN_CENTER);
+	gtk_widget_set_valign(GTK_WIDGET(grid), GTK_ALIGN_CENTER);
+	gtk_widget_show(grid);
+	gtk_grid_set_row_spacing(GTK_GRID(grid), 6);
+	gtk_grid_set_column_spacing(GTK_GRID(grid), 6);
+
+	/* A message, in HTML format */
+	w = gtk_label_new(NULL);
+	gtk_label_set_markup(GTK_LABEL(w), message);
+
+	gtk_widget_set_halign(GTK_WIDGET(w), GTK_ALIGN_START);
+	gtk_widget_set_valign(GTK_WIDGET(w), GTK_ALIGN_FILL);
+	gtk_widget_set_margin_top (GTK_WIDGET(w), 18);
+	gtk_widget_set_margin_bottom (GTK_WIDGET(w), 9);
+	gtk_widget_set_margin_start (GTK_WIDGET(w), 18);
+	gtk_widget_set_margin_end (GTK_WIDGET(w), 18);
+	gtk_widget_show(w);
+	gtk_grid_attach(GTK_GRID(grid), w, 0, 0, 2, 1);
+
+	/* A button for yes and one for no */
+	bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
+	gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_START);
+	gtk_grid_attach(GTK_GRID(grid), bbox, 0, 1, 1, 1);
+	w = gtk_button_new_with_label(_("Yes"));
+	gtk_widget_set_valign(GTK_WIDGET(w), GTK_ALIGN_CENTER);
+	g_object_set_data(G_OBJECT(w), btn_response_key, (void *)GTK_RESPONSE_YES);
+
+	g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(remmina_message_panel_button_clicked_callback), mp);
+	gtk_container_add(GTK_CONTAINER(bbox), w);
+
+	w = gtk_button_new_with_label(_("No"));
+	gtk_widget_set_valign(GTK_WIDGET(w), GTK_ALIGN_CENTER);
+	g_object_set_data(G_OBJECT(w), btn_response_key, (void *)GTK_RESPONSE_NO);
+
+	priv->response_callback = response_callback;
+	priv->response_callback_data = response_callback_data;
+
+	g_signal_connect(G_OBJECT(w), "clicked", G_CALLBACK(remmina_message_panel_button_clicked_callback), mp);
+	gtk_container_add(GTK_CONTAINER(bbox), w);
+
+	gtk_box_pack_start(GTK_BOX(mp), GTK_WIDGET(grid), TRUE, TRUE, 0);
+
+	gtk_widget_show_all(GTK_WIDGET(mp));
+
+}
+
+void remmina_message_panel_setup_auth(RemminaMessagePanel *mp, RemminaMessagePanelCallback response_callback, gpointer response_callback_data, const gchar *title, const gchar *password_prompt, unsigned flags)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *grid;
+	GtkWidget *password_entry;
+	GtkWidget *username_entry;
+	GtkWidget *domain_entry;
+	GtkWidget *save_password_switch;
+	GtkWidget *widget;
+	GtkWidget *bbox;
+	GtkWidget *button_ok;
+	GtkWidget *button_cancel;
+	int grid_row;
+
+	RemminaMessagePanelPrivate *priv = remmina_message_panel_get_instance_private(mp);
+
+	if ( !remmina_masterthread_exec_is_main_thread() ) {
+		printf("WARNING: %s called in a subthread. This should not happen. Raising SIGINT to debug.\n", __func__);
+		raise(SIGINT);
+	}
+
+	/* Create grid */
+	grid = gtk_grid_new();
+	gtk_widget_set_halign(GTK_WIDGET(grid), GTK_ALIGN_CENTER);
+	gtk_widget_set_valign(GTK_WIDGET(grid), GTK_ALIGN_CENTER);
+	gtk_widget_show(grid);
+	gtk_grid_set_row_spacing(GTK_GRID(grid), 6);
+	gtk_grid_set_column_spacing(GTK_GRID(grid), 6);
+	//gtk_grid_set_column_homogeneous(GTK_GRID(grid), TRUE);
+
+	/* Entries */
+
+	grid_row = 0;
+	widget = gtk_label_new(title);
+	gtk_style_context_add_class(gtk_widget_get_style_context(widget), "title_label");
+	gtk_widget_set_halign(GTK_WIDGET(widget), GTK_ALIGN_START);
+	gtk_widget_set_valign(GTK_WIDGET(widget), GTK_ALIGN_FILL);
+	gtk_widget_set_margin_top (GTK_WIDGET(widget), 18);
+	gtk_widget_set_margin_bottom (GTK_WIDGET(widget), 9);
+	gtk_widget_set_margin_start (GTK_WIDGET(widget), 18);
+	gtk_widget_set_margin_end (GTK_WIDGET(widget), 18);
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, grid_row, 3, 1);
+	grid_row++;
+
+
+	if (flags & REMMINA_MESSAGE_PANEL_FLAG_USERNAME) {
+		widget = gtk_label_new(_("Username"));
+		gtk_widget_set_halign(GTK_WIDGET(widget), GTK_ALIGN_START);
+		gtk_widget_set_valign(GTK_WIDGET(widget), GTK_ALIGN_CENTER);
+		gtk_widget_set_margin_top (GTK_WIDGET(widget), 9);
+		gtk_widget_set_margin_bottom (GTK_WIDGET(widget), 3);
+		gtk_widget_set_margin_start (GTK_WIDGET(widget), 18);
+		gtk_widget_set_margin_end (GTK_WIDGET(widget), 6);
+		gtk_widget_show(widget);
+		gtk_grid_attach(GTK_GRID(grid), widget, 0, grid_row, 1, 1);
+
+		username_entry = gtk_entry_new();
+		// gtk_style_context_add_class(gtk_widget_get_style_context(username_entry), "panel_entry");
+		gtk_widget_set_halign(GTK_WIDGET(username_entry), GTK_ALIGN_FILL);
+		gtk_widget_set_valign(GTK_WIDGET(username_entry), GTK_ALIGN_FILL);
+		gtk_widget_set_margin_top (GTK_WIDGET(username_entry), 9);
+		gtk_widget_set_margin_bottom (GTK_WIDGET(username_entry), 3);
+		gtk_widget_set_margin_start (GTK_WIDGET(username_entry), 6);
+		gtk_widget_set_margin_end (GTK_WIDGET(username_entry), 18);
+		//gtk_entry_set_activates_default (GTK_ENTRY(username_entry), TRUE);
+		gtk_grid_attach(GTK_GRID(grid), username_entry, 1, grid_row, 2, 1);
+		gtk_entry_set_max_length(GTK_ENTRY(username_entry), 100);
+
+		if (flags & REMMINA_MESSAGE_PANEL_FLAG_USERNAME_READONLY) {
+			g_object_set(username_entry, "editable", FALSE, NULL);
+		}
+
+		/*
+		if (default_username && default_username[0] != '\0') {
+			gtk_entry_set_text(GTK_ENTRY(username_entry), default_username);
+		}
+		*/
+		grid_row++;
+	} else {
+		username_entry = NULL;
+	}
+
+	/* The password/key field */
+	widget = gtk_label_new(password_prompt);
+	gtk_widget_set_halign(GTK_WIDGET(widget), GTK_ALIGN_START);
+	gtk_widget_set_margin_top (GTK_WIDGET(widget), 3);
+	gtk_widget_set_margin_bottom (GTK_WIDGET(widget), 3);
+	gtk_widget_set_margin_start (GTK_WIDGET(widget), 18);
+	gtk_widget_set_margin_end (GTK_WIDGET(widget), 6);
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, grid_row, 1, 1);
+
+	password_entry = gtk_entry_new();
+	gtk_widget_set_halign(GTK_WIDGET(password_entry), GTK_ALIGN_FILL);
+	gtk_widget_set_valign(GTK_WIDGET(password_entry), GTK_ALIGN_FILL);
+	gtk_widget_set_margin_top (GTK_WIDGET(password_entry), 3);
+	gtk_widget_set_margin_bottom (GTK_WIDGET(password_entry), 3);
+	gtk_widget_set_margin_start (GTK_WIDGET(password_entry), 6);
+	gtk_widget_set_margin_end (GTK_WIDGET(password_entry), 18);
+	gtk_entry_set_activates_default (GTK_ENTRY(password_entry), TRUE);
+	gtk_grid_attach(GTK_GRID(grid), password_entry, 1, grid_row, 2, 1);
+	gtk_entry_set_max_length(GTK_ENTRY(password_entry), 0);
+	gtk_entry_set_visibility(GTK_ENTRY(password_entry), FALSE);
+	gtk_entry_set_icon_from_icon_name(GTK_ENTRY(password_entry), GTK_ENTRY_ICON_SECONDARY, "org.remmina.Remmina-password-reveal-symbolic");
+	gtk_entry_set_icon_activatable(GTK_ENTRY(password_entry), GTK_ENTRY_ICON_SECONDARY, TRUE);
+	g_signal_connect(password_entry, "icon-press", G_CALLBACK(remmina_main_toggle_password_view), NULL);
+
+	grid_row++;
+
+	if (flags & REMMINA_MESSAGE_PANEL_FLAG_DOMAIN) {
+		widget = gtk_label_new(_("Domain"));
+		gtk_widget_set_halign(GTK_WIDGET(widget), GTK_ALIGN_START);
+		gtk_widget_set_margin_top (GTK_WIDGET(widget), 3);
+		gtk_widget_set_margin_bottom (GTK_WIDGET(widget), 3);
+		gtk_widget_set_margin_start (GTK_WIDGET(widget), 18);
+		gtk_widget_set_margin_end (GTK_WIDGET(widget), 6);
+		gtk_widget_show(widget);
+		gtk_grid_attach(GTK_GRID(grid), widget, 0, grid_row, 1, 1);
+
+		domain_entry = gtk_entry_new();
+		gtk_widget_set_halign(GTK_WIDGET(domain_entry), GTK_ALIGN_FILL);
+		gtk_widget_set_valign(GTK_WIDGET(domain_entry), GTK_ALIGN_FILL);
+		gtk_widget_set_margin_top (GTK_WIDGET(domain_entry), 3);
+		gtk_widget_set_margin_bottom (GTK_WIDGET(domain_entry), 3);
+		gtk_widget_set_margin_start (GTK_WIDGET(domain_entry), 6);
+		gtk_widget_set_margin_end (GTK_WIDGET(domain_entry), 18);
+                gtk_entry_set_activates_default (GTK_ENTRY(domain_entry), TRUE);
+		gtk_widget_show(domain_entry);
+		gtk_grid_attach(GTK_GRID(grid), domain_entry, 1, grid_row, 2, 1);
+		gtk_entry_set_max_length(GTK_ENTRY(domain_entry), 100);
+		/* if (default_domain && default_domain[0] != '\0') {
+			gtk_entry_set_text(GTK_ENTRY(domain_entry), default_domain);
+		} */
+		grid_row ++;
+	} else {
+		domain_entry = NULL;
+	}
+
+
+	widget = gtk_label_new(_("Save password"));
+	gtk_widget_set_halign(GTK_WIDGET(widget), GTK_ALIGN_START);
+	gtk_widget_set_margin_top (GTK_WIDGET(widget), 9);
+	gtk_widget_set_margin_bottom (GTK_WIDGET(widget), 9);
+	gtk_widget_set_margin_start (GTK_WIDGET(widget), 18);
+	gtk_widget_set_margin_end (GTK_WIDGET(widget), 6);
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, grid_row, 1, 1);
+	save_password_switch = gtk_switch_new();
+	gtk_widget_set_halign(GTK_WIDGET(save_password_switch), GTK_ALIGN_START);
+	gtk_widget_set_valign(GTK_WIDGET(save_password_switch), GTK_ALIGN_FILL);
+	gtk_widget_set_margin_top (GTK_WIDGET(save_password_switch), 9);
+	gtk_widget_set_margin_bottom (GTK_WIDGET(save_password_switch), 9);
+	gtk_widget_set_margin_start (GTK_WIDGET(save_password_switch), 6);
+	gtk_widget_set_margin_end (GTK_WIDGET(save_password_switch), 18);
+	gtk_grid_attach(GTK_GRID(grid), save_password_switch, 1, grid_row, 2, 1);
+	if (flags & REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD) {
+		gtk_switch_set_active(GTK_SWITCH(save_password_switch), TRUE);
+	}else  {
+		gtk_switch_set_active(GTK_SWITCH(save_password_switch), FALSE);
+		gtk_widget_set_sensitive(GTK_WIDGET(save_password_switch), FALSE);
+	}
+	grid_row ++;
+
+	/* Buttons, ok and cancel */
+	bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
+	gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_EDGE);
+	gtk_box_set_spacing (GTK_BOX (bbox), 40);
+	gtk_widget_set_margin_top (GTK_WIDGET(bbox), 9);
+	gtk_widget_set_margin_bottom (GTK_WIDGET(bbox), 18);
+	gtk_widget_set_margin_start (GTK_WIDGET(bbox), 18);
+	gtk_widget_set_margin_end (GTK_WIDGET(bbox), 18);
+	button_ok = gtk_button_new_with_label(_("_OK"));
+	gtk_button_set_use_underline(GTK_BUTTON(button_ok), TRUE);
+	gtk_widget_set_can_default(button_ok, TRUE);
+	gtk_container_add (GTK_CONTAINER (bbox), button_ok);
+	/* Buttons, ok and cancel */
+	button_cancel = gtk_button_new_with_label(_("_Cancel"));
+	gtk_button_set_use_underline(GTK_BUTTON(button_cancel), TRUE);
+	gtk_container_add (GTK_CONTAINER (bbox), button_cancel);
+	gtk_grid_attach(GTK_GRID(grid), bbox, 0, grid_row, 3, 1);
+	/* Pack it into the panel */
+	gtk_box_pack_start(GTK_BOX(mp), grid, TRUE, TRUE, 4);
+
+	priv->w[REMMINA_MESSAGE_PANEL_USERNAME] = username_entry;
+	priv->w[REMMINA_MESSAGE_PANEL_PASSWORD] = password_entry;
+	priv->w[REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD] = save_password_switch;
+	priv->w[REMMINA_MESSAGE_PANEL_DOMAIN] = domain_entry;
+	priv->w[REMMINA_MESSAGE_PANEL_BUTTONTOFOCUS] = button_ok;
+
+	priv->response_callback = response_callback;
+	priv->response_callback_data = response_callback_data;
+
+	if (username_entry) g_signal_connect_swapped (username_entry, "activate", (GCallback)gtk_widget_grab_focus, password_entry);
+	g_signal_connect_swapped (password_entry, "activate", (GCallback)gtk_widget_grab_focus, button_ok);
+	g_object_set_data(G_OBJECT(button_cancel), btn_response_key, (void *)GTK_RESPONSE_CANCEL);
+	g_signal_connect(G_OBJECT(button_cancel), "clicked", G_CALLBACK(remmina_message_panel_button_clicked_callback), mp);
+	g_object_set_data(G_OBJECT(button_ok), btn_response_key, (void *)GTK_RESPONSE_OK);
+	g_signal_connect(G_OBJECT(button_ok), "clicked", G_CALLBACK(remmina_message_panel_button_clicked_callback), mp);
+}
+
+void remmina_message_panel_setup_auth_x509(RemminaMessagePanel *mp, RemminaMessagePanelCallback response_callback, gpointer response_callback_data)
+{
+	TRACE_CALL(__func__);
+
+	GtkWidget *grid;
+	GtkWidget *widget;
+	GtkWidget *bbox;
+	GtkWidget *button_ok;
+	GtkWidget *button_cancel;
+	GtkWidget *cacert_file;
+	GtkWidget *cacrl_file;
+	GtkWidget *clientcert_file;
+	GtkWidget *clientkey_file;
+	int grid_row;
+
+	RemminaMessagePanelPrivate *priv = remmina_message_panel_get_instance_private(mp);
+
+	if ( !remmina_masterthread_exec_is_main_thread() ) {
+		printf("WARNING: %s called in a subthread. This should not happen. Raising SIGINT to debug.\n", __func__);
+		raise(SIGINT);
+	}
+
+	/* Create grid */
+	grid = gtk_grid_new();
+	gtk_widget_set_halign(GTK_WIDGET(grid), GTK_ALIGN_CENTER);
+	gtk_widget_set_valign(GTK_WIDGET(grid), GTK_ALIGN_CENTER);
+	gtk_widget_show(grid);
+	gtk_grid_set_row_spacing(GTK_GRID(grid), 6);
+	gtk_grid_set_column_spacing(GTK_GRID(grid), 6);
+
+	/* Entries */
+	grid_row = 0;
+	widget = gtk_label_new(_("Enter certificate authentication files"));
+	gtk_style_context_add_class(gtk_widget_get_style_context(widget), "title_label");
+	gtk_widget_set_halign(GTK_WIDGET(widget), GTK_ALIGN_START);
+	gtk_widget_set_valign(GTK_WIDGET(widget), GTK_ALIGN_FILL);
+	gtk_widget_set_margin_top (GTK_WIDGET(widget), 18);
+	gtk_widget_set_margin_bottom (GTK_WIDGET(widget), 9);
+	gtk_widget_set_margin_start (GTK_WIDGET(widget), 18);
+	gtk_widget_set_margin_end (GTK_WIDGET(widget), 18);
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, grid_row, 3, 1);
+	grid_row++;
+
+	const gchar *lbl_cacert = _("CA Certificate File");
+	widget = gtk_label_new(lbl_cacert);
+	gtk_widget_set_halign(GTK_WIDGET(widget), GTK_ALIGN_START);
+	gtk_widget_set_valign(GTK_WIDGET(widget), GTK_ALIGN_CENTER);
+	gtk_widget_set_margin_top (GTK_WIDGET(widget), 9);
+	gtk_widget_set_margin_bottom (GTK_WIDGET(widget), 3);
+	gtk_widget_set_margin_start (GTK_WIDGET(widget), 18);
+	gtk_widget_set_margin_end (GTK_WIDGET(widget), 6);
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, grid_row, 1, 1);
+	cacert_file = gtk_file_chooser_button_new(lbl_cacert, GTK_FILE_CHOOSER_ACTION_OPEN);
+	// gtk_style_context_add_class(gtk_widget_get_style_context(username_entry), "panel_entry");
+	gtk_widget_show(cacert_file);
+	gtk_widget_set_halign(GTK_WIDGET(cacert_file), GTK_ALIGN_FILL);
+	gtk_widget_set_valign(GTK_WIDGET(cacert_file), GTK_ALIGN_FILL);
+	gtk_widget_set_margin_top (GTK_WIDGET(cacert_file), 9);
+	gtk_widget_set_margin_bottom (GTK_WIDGET(cacert_file), 3);
+	gtk_widget_set_margin_start (GTK_WIDGET(cacert_file), 6);
+	gtk_widget_set_margin_end (GTK_WIDGET(cacert_file), 18);
+	gtk_grid_attach(GTK_GRID(grid), cacert_file, 1, grid_row, 2, 1);
+	grid_row++;
+
+	const gchar *lbl_cacrl = _("CA CRL File");
+	widget = gtk_label_new(lbl_cacrl);
+	gtk_widget_set_halign(GTK_WIDGET(widget), GTK_ALIGN_START);
+	gtk_widget_set_valign(GTK_WIDGET(widget), GTK_ALIGN_CENTER);
+	gtk_widget_set_margin_top (GTK_WIDGET(widget), 9);
+	gtk_widget_set_margin_bottom (GTK_WIDGET(widget), 3);
+	gtk_widget_set_margin_start (GTK_WIDGET(widget), 18);
+	gtk_widget_set_margin_end (GTK_WIDGET(widget), 6);
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, grid_row, 1, 1);
+	cacrl_file = gtk_file_chooser_button_new(lbl_cacrl, GTK_FILE_CHOOSER_ACTION_OPEN);
+	// gtk_style_context_add_class(gtk_widget_get_style_context(username_entry), "panel_entry");
+	gtk_widget_show(cacrl_file);
+	gtk_widget_set_halign(GTK_WIDGET(cacrl_file), GTK_ALIGN_FILL);
+	gtk_widget_set_valign(GTK_WIDGET(cacrl_file), GTK_ALIGN_FILL);
+	gtk_widget_set_margin_top (GTK_WIDGET(cacrl_file), 9);
+	gtk_widget_set_margin_bottom (GTK_WIDGET(cacrl_file), 3);
+	gtk_widget_set_margin_start (GTK_WIDGET(cacrl_file), 6);
+	gtk_widget_set_margin_end (GTK_WIDGET(cacrl_file), 18);
+	gtk_grid_attach(GTK_GRID(grid), cacrl_file, 1, grid_row, 2, 1);
+	grid_row++;
+
+	const gchar *lbl_clicert = _("Client Certificate File");
+	widget = gtk_label_new(lbl_clicert);
+	gtk_widget_set_halign(GTK_WIDGET(widget), GTK_ALIGN_START);
+	gtk_widget_set_valign(GTK_WIDGET(widget), GTK_ALIGN_CENTER);
+	gtk_widget_set_margin_top (GTK_WIDGET(widget), 9);
+	gtk_widget_set_margin_bottom (GTK_WIDGET(widget), 3);
+	gtk_widget_set_margin_start (GTK_WIDGET(widget), 18);
+	gtk_widget_set_margin_end (GTK_WIDGET(widget), 6);
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, grid_row, 1, 1);
+	clientcert_file = gtk_file_chooser_button_new(lbl_clicert, GTK_FILE_CHOOSER_ACTION_OPEN);
+	// gtk_style_context_add_class(gtk_widget_get_style_context(username_entry), "panel_entry");
+	gtk_widget_show(clientcert_file);
+	gtk_widget_set_halign(GTK_WIDGET(clientcert_file), GTK_ALIGN_FILL);
+	gtk_widget_set_valign(GTK_WIDGET(clientcert_file), GTK_ALIGN_FILL);
+	gtk_widget_set_margin_top (GTK_WIDGET(clientcert_file), 9);
+	gtk_widget_set_margin_bottom (GTK_WIDGET(clientcert_file), 3);
+	gtk_widget_set_margin_start (GTK_WIDGET(clientcert_file), 6);
+	gtk_widget_set_margin_end (GTK_WIDGET(clientcert_file), 18);
+	gtk_grid_attach(GTK_GRID(grid), clientcert_file, 1, grid_row, 2, 1);
+	grid_row++;
+
+	const gchar *lbl_clikey = _("Client Certificate Key");
+	widget = gtk_label_new(lbl_clikey);
+	gtk_widget_set_halign(GTK_WIDGET(widget), GTK_ALIGN_START);
+	gtk_widget_set_valign(GTK_WIDGET(widget), GTK_ALIGN_CENTER);
+	gtk_widget_set_margin_top (GTK_WIDGET(widget), 9);
+	gtk_widget_set_margin_bottom (GTK_WIDGET(widget), 3);
+	gtk_widget_set_margin_start (GTK_WIDGET(widget), 18);
+	gtk_widget_set_margin_end (GTK_WIDGET(widget), 6);
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, grid_row, 1, 1);
+	clientkey_file = gtk_file_chooser_button_new(lbl_clikey, GTK_FILE_CHOOSER_ACTION_OPEN);
+	// gtk_style_context_add_class(gtk_widget_get_style_context(username_entry), "panel_entry");
+	gtk_widget_show(clientkey_file);
+	gtk_widget_set_halign(GTK_WIDGET(clientkey_file), GTK_ALIGN_FILL);
+	gtk_widget_set_valign(GTK_WIDGET(clientkey_file), GTK_ALIGN_FILL);
+	gtk_widget_set_margin_top (GTK_WIDGET(clientkey_file), 9);
+	gtk_widget_set_margin_bottom (GTK_WIDGET(clientkey_file), 3);
+	gtk_widget_set_margin_start (GTK_WIDGET(clientkey_file), 6);
+	gtk_widget_set_margin_end (GTK_WIDGET(clientkey_file), 18);
+	gtk_grid_attach(GTK_GRID(grid), clientkey_file, 1, grid_row, 2, 1);
+	grid_row++;
+
+	/* Buttons, ok and cancel */
+	bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
+	gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_EDGE);
+	gtk_box_set_spacing (GTK_BOX (bbox), 40);
+	gtk_widget_set_margin_top (GTK_WIDGET(bbox), 9);
+	gtk_widget_set_margin_bottom (GTK_WIDGET(bbox), 18);
+	gtk_widget_set_margin_start (GTK_WIDGET(bbox), 18);
+	gtk_widget_set_margin_end (GTK_WIDGET(bbox), 18);
+	button_ok = gtk_button_new_with_label(_("_OK"));
+	gtk_widget_set_can_default (button_ok, TRUE);
+
+	gtk_button_set_use_underline(GTK_BUTTON(button_ok), TRUE);
+	//gtk_widget_show(button_ok);
+	gtk_container_add (GTK_CONTAINER (bbox), button_ok);
+	//gtk_grid_attach(GTK_GRID(grid), button_ok, 0, grid_row, 1, 1);
+	/* Buttons, ok and cancel */
+	button_cancel = gtk_button_new_with_label(_("_Cancel"));
+	gtk_button_set_use_underline(GTK_BUTTON(button_cancel), TRUE);
+	//gtk_widget_show(button_cancel);
+	gtk_container_add (GTK_CONTAINER (bbox), button_cancel);
+	gtk_grid_attach(GTK_GRID(grid), bbox, 0, grid_row, 3, 1);
+	/* Pack it into the panel */
+	gtk_box_pack_start(GTK_BOX(mp), grid, TRUE, TRUE, 4);
+
+	priv->response_callback = response_callback;
+	priv->response_callback_data = response_callback_data;
+
+	priv->w[REMMINA_MESSAGE_PANEL_CACERTFILE] = cacert_file;
+	priv->w[REMMINA_MESSAGE_PANEL_CACRLFILE] = cacrl_file;
+	priv->w[REMMINA_MESSAGE_PANEL_CLIENTCERTFILE] = clientcert_file;
+	priv->w[REMMINA_MESSAGE_PANEL_CLIENTKEYFILE] = clientkey_file;
+	priv->w[REMMINA_MESSAGE_PANEL_BUTTONTOFOCUS] = button_ok;
+
+	g_object_set_data(G_OBJECT(button_cancel), btn_response_key, (void *)GTK_RESPONSE_CANCEL);
+	g_signal_connect(G_OBJECT(button_cancel), "clicked", G_CALLBACK(remmina_message_panel_button_clicked_callback), mp);
+	g_object_set_data(G_OBJECT(button_ok), btn_response_key, (void *)GTK_RESPONSE_OK);
+	g_signal_connect(G_OBJECT(button_ok), "clicked", G_CALLBACK(remmina_message_panel_button_clicked_callback), mp);
+
+}
+
+void remmina_message_panel_focus_auth_entry(RemminaMessagePanel *mp)
+{
+	TRACE_CALL(__func__);
+
+	RemminaMessagePanelPrivate *priv;
+	GtkWidget *w;
+	const gchar *username;
+
+	if (mp == NULL)
+		return;
+	priv = remmina_message_panel_get_instance_private(mp);
+
+	/* Activate default button */
+	w = priv->w[REMMINA_MESSAGE_PANEL_BUTTONTOFOCUS];
+	if (w && G_TYPE_CHECK_INSTANCE_TYPE(w, gtk_button_get_type()))
+		gtk_widget_grab_default(w);
+
+	w = priv->w[REMMINA_MESSAGE_PANEL_USERNAME];
+	if (w == NULL)
+	{
+		w = priv->w[REMMINA_MESSAGE_PANEL_PASSWORD];
+	}else {
+		username = gtk_entry_get_text(GTK_ENTRY(w));
+		if (username[0] != 0)
+			w = priv->w[REMMINA_MESSAGE_PANEL_PASSWORD];
+	}
+	if (w == NULL)
+		return;
+
+	if (!G_TYPE_CHECK_INSTANCE_TYPE(w, gtk_entry_get_type()))
+		return;
+
+	gtk_widget_grab_focus(w);
+}
+
+void remmina_message_panel_field_set_string(RemminaMessagePanel *mp, int entryid, const gchar *text)
+{
+	RemminaMessagePanelPrivate *priv;
+
+	if (mp == NULL)
+		return;
+	priv = remmina_message_panel_get_instance_private(mp);
+
+	if (priv->w[entryid] == NULL)
+		return;
+	if (!G_TYPE_CHECK_INSTANCE_TYPE(priv->w[entryid], gtk_entry_get_type()))
+		return;
+
+	gtk_entry_set_text(GTK_ENTRY(priv->w[entryid]), text != NULL ? text : "");
+}
+
+gchar* remmina_message_panel_field_get_string(RemminaMessagePanel *mp, int entryid)
+{
+	TRACE_CALL(__func__);
+
+	RemminaMessagePanelPrivate *priv;
+
+	if (mp == NULL)
+		return NULL;
+	priv = remmina_message_panel_get_instance_private(mp);
+
+	if (priv->w[entryid] == NULL)
+		return NULL;
+	if (!G_TYPE_CHECK_INSTANCE_TYPE(priv->w[entryid], gtk_entry_get_type()))
+		return NULL;
+
+	return g_strdup(gtk_entry_get_text(GTK_ENTRY(priv->w[entryid])));
+}
+
+void remmina_message_panel_field_set_switch(RemminaMessagePanel *mp, int entryid, gboolean state)
+{
+	TRACE_CALL(__func__);
+
+	RemminaMessagePanelPrivate *priv;
+
+	if (mp == NULL)
+		return;
+	priv = remmina_message_panel_get_instance_private(mp);
+
+	if (priv->w[entryid] == NULL)
+		return;
+	if (!G_TYPE_CHECK_INSTANCE_TYPE(priv->w[entryid], gtk_switch_get_type()))
+		return;
+
+	gtk_switch_set_state(GTK_SWITCH(priv->w[entryid]), state);
+}
+
+gboolean remmina_message_panel_field_get_switch_state(RemminaMessagePanel *mp, int entryid)
+{
+	TRACE_CALL(__func__);
+
+	RemminaMessagePanelPrivate *priv;
+
+	if (mp == NULL)
+		return FALSE;
+	priv = remmina_message_panel_get_instance_private(mp);
+
+	if (priv->w[entryid] == NULL)
+		return FALSE;
+	if (!G_TYPE_CHECK_INSTANCE_TYPE(priv->w[entryid], gtk_switch_get_type()))
+		return FALSE;
+
+	return gtk_switch_get_state(GTK_SWITCH(priv->w[entryid]));
+}
+
+
+void remmina_message_panel_field_set_filename(RemminaMessagePanel *mp, int entryid, const gchar *filename)
+{
+	TRACE_CALL(__func__);
+
+	RemminaMessagePanelPrivate *priv;
+
+	if (mp == NULL)
+		return;
+	priv = remmina_message_panel_get_instance_private(mp);
+	if (priv->w[entryid] == NULL)
+		return;
+	if (!G_TYPE_CHECK_INSTANCE_TYPE(priv->w[entryid], gtk_file_chooser_button_get_type()))
+		return;
+
+	gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(priv->w[entryid]), filename);
+}
+
+gchar* remmina_message_panel_field_get_filename(RemminaMessagePanel *mp, int entryid)
+{
+	TRACE_CALL(__func__);
+
+	RemminaMessagePanelPrivate *priv;
+
+	if (mp == NULL)
+		return NULL;
+	priv = remmina_message_panel_get_instance_private(mp);
+
+	if (priv->w[entryid] == NULL)
+		return NULL;
+	if (!G_TYPE_CHECK_INSTANCE_TYPE(priv->w[entryid], gtk_file_chooser_button_get_type()))
+		return NULL;
+
+	return gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(priv->w[entryid]));
+}
+
+void remmina_message_panel_response(RemminaMessagePanel *mp, gint response_id)
+{
+	g_signal_emit(mp, messagepanel_signals[RESPONSE], 0, response_id);
+}
+
diff --git a/src/remmina_message_panel.h b/src/remmina_message_panel.h
new file mode 100644
index 0000000..2b85879
--- /dev/null
+++ b/src/remmina_message_panel.h
@@ -0,0 +1,85 @@
+/*
+ * 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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define REMMINA_TYPE_MESSAGE_PANEL             (remmina_message_panel_get_type())
+G_DECLARE_DERIVABLE_TYPE(RemminaMessagePanel, remmina_message_panel, REMMINA, MESSAGE_PANEL, GtkBox)
+
+struct _RemminaMessagePanelClass {
+	GtkBoxClass	parent_class;
+	void		(*response) (RemminaMessagePanel *mp, gint response_id);
+};
+
+
+/* Widgets ID for dialog fields */
+enum {
+	REMMINA_MESSAGE_PANEL_USERNAME=1,
+	REMMINA_MESSAGE_PANEL_PASSWORD,
+	REMMINA_MESSAGE_PANEL_DOMAIN,
+	REMMINA_MESSAGE_PANEL_SAVEPASSWORD,
+	REMMINA_MESSAGE_PANEL_BUTTONTOFOCUS,
+	REMMINA_MESSAGE_PANEL_CACERTFILE,
+	REMMINA_MESSAGE_PANEL_CACRLFILE,
+	REMMINA_MESSAGE_PANEL_CLIENTCERTFILE,
+	REMMINA_MESSAGE_PANEL_CLIENTKEYFILE,
+	REMMINA_MESSAGE_PANEL_MAXWIDGETID
+};
+
+/* Callback function type to receive buttons notification */
+typedef void (*RemminaMessagePanelCallback)(void *user_data, int button);
+
+RemminaMessagePanel *remmina_message_panel_new(void);
+void remmina_message_panel_setup_progress(RemminaMessagePanel *mp, const gchar *message, RemminaMessagePanelCallback response_callback, gpointer response_callback_data);
+void remmina_message_panel_setup_message(RemminaMessagePanel *mp, const gchar *message, RemminaMessagePanelCallback response_callback, gpointer response_callback_data);
+void remmina_message_panel_setup_question(RemminaMessagePanel *mp, const gchar *message, RemminaMessagePanelCallback response_callback, gpointer response_callback_data);
+void remmina_message_panel_setup_auth(RemminaMessagePanel *mp, RemminaMessagePanelCallback response_callback, gpointer response_callback_data, const gchar *title, const gchar *password_prompt, unsigned flags);
+void remmina_message_panel_setup_auth_x509(RemminaMessagePanel *mp, RemminaMessagePanelCallback response_callback, gpointer response_callback_data);
+void remmina_message_panel_focus_auth_entry(RemminaMessagePanel *mp);
+void remmina_message_panel_field_set_string(RemminaMessagePanel *mp, int entryid, const gchar *text);
+gchar *remmina_message_panel_field_get_string(RemminaMessagePanel *mp, int entryid);
+void remmina_message_panel_field_set_switch(RemminaMessagePanel *mp, int entryid, gboolean state);
+gboolean remmina_message_panel_field_get_switch_state(RemminaMessagePanel *mp, int entryid);
+void remmina_message_panel_field_set_filename(RemminaMessagePanel *mp, int entryid, const gchar *filename);
+gchar *remmina_message_panel_field_get_filename(RemminaMessagePanel *mp, int entryid);
+void remmina_message_panel_response(RemminaMessagePanel *mp, gint response_id);
+
+
+G_END_DECLS
diff --git a/src/remmina_monitor.c b/src/remmina_monitor.c
new file mode 100644
index 0000000..2b57e7d
--- /dev/null
+++ b/src/remmina_monitor.c
@@ -0,0 +1,229 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2016-2023 Antenore Gatta
+ *
+ * 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 "remmina_monitor.h"
+#include "remmina_log.h"
+#include "remmina_public.h"
+#include "remmina/remmina_trace_calls.h"
+
+RemminaMonitor *rm_monitor;
+
+static void remmina_monitor_can_reach_cb (GNetworkMonitor *netmonitor, GAsyncResult *result, RemminaMonitor *monitor)
+{
+	g_autoptr (GError) error = NULL;
+
+	gchar *status = NULL;
+
+	gboolean is_reachable = g_network_monitor_can_reach_finish (netmonitor, result, &error);
+
+	const gchar *addr_tostr = g_strdup(g_socket_connectable_to_string (monitor->addr));
+	//gchar *value = (gchar *)g_hash_table_lookup (monitor->server_status, addr_tostr);
+
+	if (is_reachable) {
+
+		REMMINA_DEBUG ("Network object %s is reachable", g_socket_connectable_to_string (monitor->addr));
+		status = g_strdup ("online");
+
+	} else {
+
+		REMMINA_DEBUG ("Network object %s is not reachable", g_socket_connectable_to_string (monitor->addr));
+		status = g_strdup ("offline");
+	}
+
+	if (g_hash_table_replace (monitor->server_status, g_strdup(addr_tostr), g_strdup(status))) {
+		REMMINA_DEBUG ("Inserting %s -> %s", addr_tostr, status);
+	} else {
+		REMMINA_DEBUG ("Replacing %s -> %s", addr_tostr, status);
+	}
+
+	/* Cannot use remminafile here because is freed by remmina_file_manager_iterate */
+	//if (remminafile)
+		//remmina_file_set_state_int (remminafile, "reachable", reachable);
+	g_free (status);
+}
+
+gchar *remmina_monitor_can_reach(RemminaFile *remminafile, RemminaMonitor *monitor)
+{
+	TRACE_CALL(__func__);
+
+	const gchar *server;
+	const gchar *ssh_tunnel_server;
+	const gchar *addr_tostr = NULL;
+	gchar *status = NULL;
+	gchar *ssh_tunnel_host, *srv_host;
+	gint netmonit, srv_port, ssh_tunnel_port;
+	const gchar *protocol;
+	gint default_port = 0;
+
+
+	if (!remminafile) {
+		status = g_strdup ("I/O Error");
+		REMMINA_DEBUG (status);
+		return NULL;
+	}
+
+	netmonit = remmina_file_get_int(remminafile, "enable-netmonit", FALSE);
+
+	if (!netmonit) {
+		status = g_strdup ("Monitoring disabled");
+		REMMINA_DEBUG (status);
+		return NULL;
+	}
+
+	protocol = remmina_file_get_string (remminafile, "protocol");
+
+	if (protocol && protocol[0] != '\0') {
+		REMMINA_DEBUG ("Evaluating protocol %s for monitoring", protocol);
+		if (g_strcmp0("RDP", protocol) == 0)
+			default_port = 3389;
+		if (g_strcmp0("VNC", protocol) == 0)
+			default_port = 5900;
+		if (g_strcmp0("GVNC", protocol) == 0)
+			default_port = 5900;
+		if (g_strcmp0("SPICE", protocol) == 0)
+			default_port = 5900;
+		if (g_strcmp0("WWW", protocol) == 0)
+			default_port = 443;
+		if (g_strcmp0("X2GO", protocol) == 0)
+			default_port = 22;
+		if (g_strcmp0("SSH", protocol) == 0)
+			default_port = 22;
+		if (g_strcmp0("SFTP", protocol) == 0)
+			default_port = 22;
+		if (g_strcmp0("EXEC", protocol) == 0)
+			default_port = -1;
+
+		if (default_port == 0) {
+			status = g_strdup ("Unknown protocol");
+			REMMINA_DEBUG (status);
+			return NULL;
+		}
+		if (default_port < 0) {
+			status = g_strdup ("Cannot monitor");
+			REMMINA_DEBUG (status);
+			return NULL;
+		}
+
+		ssh_tunnel_server = remmina_file_get_string(remminafile, "ssh_tunnel_server");
+		if (remmina_file_get_int(remminafile, "ssh_tunnel_enabled", FALSE)) {
+			remmina_public_get_server_port(ssh_tunnel_server, 22, &ssh_tunnel_host, &ssh_tunnel_port);
+			monitor->addr = g_network_address_new (ssh_tunnel_host, ssh_tunnel_port);
+			g_free(ssh_tunnel_host), ssh_tunnel_host = NULL;
+		} else {
+			server = remmina_file_get_string(remminafile, "server");
+			remmina_public_get_server_port(server, default_port, &srv_host, &srv_port);
+			monitor->addr = g_network_address_new (srv_host, srv_port);
+			g_free(srv_host), srv_host = NULL;
+		}
+		addr_tostr = g_strdup(g_socket_connectable_to_string (monitor->addr));
+
+		REMMINA_DEBUG ("addr is %s", addr_tostr);
+		if (monitor->connected && netmonit) {
+			REMMINA_DEBUG ("Testing for %s", addr_tostr);
+			g_network_monitor_can_reach_async (
+					monitor->netmonitor,
+					monitor->addr,
+					NULL,
+					(GAsyncReadyCallback) remmina_monitor_can_reach_cb,
+					monitor);
+		}
+
+
+		status = (gchar *)g_hash_table_lookup (monitor->server_status, addr_tostr);
+		//if (!status)
+			//g_hash_table_insert (monitor->server_status, g_strdup(addr_tostr), "offline");
+
+	}
+
+	if (!status) {
+		return g_strdup(addr_tostr);
+	} else
+		return status;
+
+	//g_free(ssh_tunnel_host), ssh_tunnel_host = NULL;
+	//g_free(srv_host), srv_host = NULL;
+	//g_free(dest), dest = NULL;
+
+}
+
+gboolean remmina_network_monitor_status (RemminaMonitor *rm_monitor)
+{
+	TRACE_CALL(__func__);
+
+	gboolean status = g_network_monitor_get_connectivity (rm_monitor->netmonitor);
+
+	rm_monitor->server_status = g_hash_table_new_full(
+			g_str_hash,
+			g_str_equal,
+			(GDestroyNotify)g_free,
+			(GDestroyNotify)g_free);
+
+	switch (status)
+	{
+		case G_NETWORK_CONNECTIVITY_LOCAL:
+			REMMINA_DEBUG ("G_NETWORK_CONNECTIVITY_LOCAL");
+			rm_monitor->connected = FALSE;
+			break;
+
+		case G_NETWORK_CONNECTIVITY_LIMITED:
+			REMMINA_DEBUG ("G_NETWORK_CONNECTIVITY_LIMITED");
+			rm_monitor->connected = FALSE;
+			break;
+
+		case G_NETWORK_CONNECTIVITY_PORTAL:
+			REMMINA_DEBUG ("G_NETWORK_CONNECTIVITY_PORTAL");
+			rm_monitor->connected = FALSE;
+			break;
+
+		case G_NETWORK_CONNECTIVITY_FULL:
+			REMMINA_DEBUG ("G_NETWORK_CONNECTIVITY_FULL");
+			rm_monitor->connected = TRUE;
+			break;
+	}
+
+	return status;
+}
+
+
+RemminaMonitor *remmina_network_monitor_new ()
+{
+	TRACE_CALL(__func__);
+
+	rm_monitor = g_new0(RemminaMonitor, 1);
+
+	rm_monitor->netmonitor = g_network_monitor_get_default ();
+
+	return rm_monitor;
+}
diff --git a/src/remmina_monitor.h b/src/remmina_monitor.h
new file mode 100644
index 0000000..1ccb47b
--- /dev/null
+++ b/src/remmina_monitor.h
@@ -0,0 +1,57 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2016-2023 Antenore Gatta
+ *
+ * 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.
+ *
+ */
+
+#pragma once
+
+#include <glib/gi18n.h>
+#include <glib-object.h>
+#include <gio/gio.h>
+
+#include "remmina_file.h"
+
+typedef struct _RemminaMonitor {
+    GNetworkMonitor *		netmonitor;
+    gboolean			connected;
+    GSocketConnectable *	addr;
+    gboolean			reachable;
+    GHashTable *		server_status;
+} RemminaMonitor;
+
+G_BEGIN_DECLS
+
+gboolean remmina_network_monitor_status (RemminaMonitor *rm_monitor);
+RemminaMonitor *remmina_network_monitor_new ();
+gchar *remmina_monitor_can_reach(RemminaFile *remminafile, RemminaMonitor *monitor);
+
+G_END_DECLS
diff --git a/src/remmina_mpchange.c b/src/remmina_mpchange.c
new file mode 100644
index 0000000..a5266b8
--- /dev/null
+++ b/src/remmina_mpchange.c
@@ -0,0 +1,518 @@
+/*
+ * 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 <gtk/gtk.h>
+#include <glib/gi18n.h>
+#include "config.h"
+#include "remmina_mpchange.h"
+#include "remmina_file.h"
+#include "remmina_file_manager.h"
+#include "remmina_pref.h"
+#include "remmina_public.h"
+#include "remmina_main.h"
+#include "remmina_plugin_manager.h"
+#include "remmina_log.h"
+#include "remmina/remmina_trace_calls.h"
+
+#define GET_DIALOG_OBJECT(object_name) gtk_builder_get_object(bu, object_name)
+
+struct mpchanger_params {
+	gchar *username;        // New username
+	gchar *domain;          // New domain
+	gchar *password;        // New password
+	gchar *group;
+	gchar *gatewayusername;
+	gchar *gatewaydomain;
+	gchar *gatewaypassword;
+
+	GtkEntry *eGroup, *eUsername, *eDomain, *ePassword1, *ePassword2;
+	GtkEntry *eGatewayUsername, *eGatewayDomain, *eGatewayPassword1, *eGatewayPassword2;
+	GtkListStore* store;
+	GtkDialog* dialog;
+	GtkTreeView* table;
+	GtkButton* btnDoChange;
+	GtkLabel* statusLabel;
+
+	GtkTreeIter iter;
+	int changed_passwords_count;
+	guint sid;
+	guint searchentrychange_timeout_source_id;
+};
+
+enum {
+	COL_F = 0,
+	COL_NAME,
+	COL_GROUP,
+	COL_USERNAME,
+	COL_GATEWAY_USERNAME,
+	COL_FILENAME,
+	NUM_COLS
+};
+
+static gboolean remmina_mpchange_fieldcompare(const gchar *needle, const gchar *haystack, int *matchcount)
+{
+	TRACE_CALL(__func__);
+
+	if (needle[0] == 0) {
+		(*matchcount)++;
+		return TRUE;
+	}
+
+	if (haystack[0] == 0 || strstr(haystack, needle) == NULL){
+		return FALSE;
+	}
+	
+	(*matchcount)++;
+	return TRUE;
+
+}
+
+static void remmina_mpchange_file_list_callback(RemminaFile *remminafile, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	GtkListStore* store;
+	GtkTreeIter iter;
+	int matchcount;
+	const gchar *username, *domain, *group, *gatewayusername, *gatewaydomain;
+
+	gchar* s;
+	gchar* t;
+	struct mpchanger_params* mpcp;
+
+	mpcp = (struct mpchanger_params*)user_data;
+	store = GTK_LIST_STORE(mpcp->store);
+
+
+	username = remmina_file_get_string(remminafile, "username");
+	domain = remmina_file_get_string(remminafile, "domain");
+	group = remmina_file_get_string(remminafile, "group");
+	gatewayusername = remmina_file_get_string(remminafile, "gateway_username");
+	gatewaydomain = remmina_file_get_string(remminafile, "gateway_domain");
+
+	if (username == NULL)
+		username = "";
+
+	if (domain == NULL)
+		domain = "";
+
+	if (group == NULL)
+		group = "";
+
+	if (gatewayusername == NULL)
+		gatewayusername = "";
+
+	if (gatewaydomain == NULL)
+		gatewaydomain = "";
+
+	matchcount = 0;
+	if (!remmina_mpchange_fieldcompare(mpcp->username, username, &matchcount))
+		return;
+	if (!remmina_mpchange_fieldcompare(mpcp->domain, domain, &matchcount))
+		return;
+	if (!remmina_mpchange_fieldcompare(mpcp->group, group, &matchcount))
+		return;
+	if (!remmina_mpchange_fieldcompare(mpcp->gatewayusername, gatewayusername, &matchcount))
+		return;
+	if (!remmina_mpchange_fieldcompare(mpcp->gatewaydomain, gatewaydomain, &matchcount))
+		return;
+
+	gtk_list_store_append(store, &iter);
+	s = g_strdup_printf("%s\\%s", domain, username);
+	t = g_strdup_printf("%s\\%s", gatewaydomain, gatewayusername);
+	gtk_list_store_set(store, &iter,
+		COL_F, matchcount >= 5 ? TRUE : FALSE,
+		COL_NAME, remmina_file_get_string(remminafile, "name"),
+		COL_GROUP, group,
+		COL_USERNAME,   s,
+		COL_GATEWAY_USERNAME,   t,
+		COL_FILENAME, remminafile->filename,
+		-1);
+	g_free(s);
+	g_free(t);
+
+}
+
+static void remmina_mpchange_checkbox_toggle(GtkCellRendererToggle *cell, gchar *path_string, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	GtkTreeIter iter;
+	struct mpchanger_params* mpcp = (struct mpchanger_params*)user_data;
+	GtkTreePath *path;
+
+	gboolean a = gtk_cell_renderer_toggle_get_active(cell);
+	path = gtk_tree_path_new_from_string(path_string);
+	gtk_tree_model_get_iter(GTK_TREE_MODEL(mpcp->store), &iter, path);
+	gtk_tree_path_free(path);
+	gtk_list_store_set(mpcp->store, &iter, COL_F, !a, -1);
+}
+
+static void remmina_mpchange_dochange(gchar* fname, struct mpchanger_params* mpcp)
+{
+	TRACE_CALL(__func__);
+
+	RemminaFile* remminafile;
+
+	remminafile = remmina_file_load(fname);
+	if (remminafile) {
+		if(mpcp->password[0] != 0){
+			remmina_file_store_secret_plugin_password(remminafile, "password", mpcp->password);
+		}
+		if(mpcp->gatewaypassword[0] != 0){
+			remmina_file_store_secret_plugin_password(remminafile, "gateway_password", mpcp->gatewaypassword);
+		}
+		remmina_file_free(remminafile);
+		mpcp->changed_passwords_count++;
+	}
+
+}
+
+static void enable_inputs(struct mpchanger_params* mpcp, gboolean ena)
+{
+	gtk_widget_set_sensitive(GTK_WIDGET(mpcp->eGroup), ena);
+	gtk_widget_set_sensitive(GTK_WIDGET(mpcp->eUsername), ena);
+	gtk_widget_set_sensitive(GTK_WIDGET(mpcp->eDomain), ena);
+	gtk_widget_set_sensitive(GTK_WIDGET(mpcp->ePassword1), ena);
+	gtk_widget_set_sensitive(GTK_WIDGET(mpcp->ePassword2), ena);
+	gtk_widget_set_sensitive(GTK_WIDGET(mpcp->eGatewayUsername), ena);
+	gtk_widget_set_sensitive(GTK_WIDGET(mpcp->eGatewayDomain), ena);
+	gtk_widget_set_sensitive(GTK_WIDGET(mpcp->eGatewayPassword1), ena);
+	gtk_widget_set_sensitive(GTK_WIDGET(mpcp->eGatewayPassword2), ena);
+	gtk_widget_set_sensitive(GTK_WIDGET(mpcp->btnDoChange), ena);
+	gtk_widget_set_sensitive(GTK_WIDGET(mpcp->table), ena);
+}
+
+static gboolean changenext(gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	struct mpchanger_params* mpcp = (struct mpchanger_params*)user_data;
+	gchar* fname;
+	gboolean sel;
+
+	gtk_tree_model_get(GTK_TREE_MODEL(mpcp->store), &mpcp->iter, COL_F, &sel, -1);
+	gtk_tree_model_get(GTK_TREE_MODEL(mpcp->store), &mpcp->iter, COL_FILENAME, &fname, -1);
+	if (sel) {
+		remmina_mpchange_dochange(fname, mpcp);
+	}
+	g_free(fname);
+
+	if (gtk_tree_model_iter_next(GTK_TREE_MODEL(mpcp->store), &mpcp->iter)) {
+		return G_SOURCE_CONTINUE;
+	}else  {
+		gtk_dialog_response(mpcp->dialog, 1);
+		mpcp->sid = 0;
+		return G_SOURCE_REMOVE;
+	}
+}
+
+static void remmina_mpchange_dochange_clicked(GtkButton *btn, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	struct mpchanger_params* mpcp = (struct mpchanger_params*)user_data;
+	const gchar *passwd1, *passwd2, *gatewaypasswd1, *gatewaypasswd2;
+
+	if (mpcp->searchentrychange_timeout_source_id) {
+		g_source_remove(mpcp->searchentrychange_timeout_source_id);
+		mpcp->searchentrychange_timeout_source_id = 0;
+	}
+
+	if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(mpcp->store), &mpcp->iter))
+		return;
+
+	passwd1 = gtk_entry_get_text(mpcp->ePassword1);
+	passwd2 = gtk_entry_get_text(mpcp->ePassword2);
+
+	if (g_strcmp0(passwd1, passwd2) != 0) {
+		GtkWidget *msgDialog;
+		msgDialog = gtk_message_dialog_new(GTK_WINDOW(mpcp->dialog),
+			GTK_DIALOG_DESTROY_WITH_PARENT,
+			GTK_MESSAGE_ERROR,
+			GTK_BUTTONS_CLOSE,
+			_("The passwords do not match"));
+		gtk_dialog_run(GTK_DIALOG(msgDialog));
+		gtk_widget_destroy(msgDialog);
+		return;
+	}
+	gatewaypasswd1 = gtk_entry_get_text(mpcp->eGatewayPassword1);
+	gatewaypasswd2 = gtk_entry_get_text(mpcp->eGatewayPassword2);
+	if (g_strcmp0(gatewaypasswd1, gatewaypasswd2) != 0) {
+		GtkWidget *msgDialog;
+		msgDialog = gtk_message_dialog_new(GTK_WINDOW(mpcp->dialog),
+			GTK_DIALOG_DESTROY_WITH_PARENT,
+			GTK_MESSAGE_ERROR,
+			GTK_BUTTONS_CLOSE,
+			_("The Gateway passwords do not match"));
+		gtk_dialog_run(GTK_DIALOG(msgDialog));
+		gtk_widget_destroy(msgDialog);
+		return;
+	}
+
+	g_free(mpcp->password);
+	mpcp->password = g_strdup(passwd1);
+	mpcp->changed_passwords_count = 0;
+
+	g_free(mpcp->gatewaypassword);
+	mpcp->gatewaypassword = g_strdup(gatewaypasswd1);
+	mpcp->changed_passwords_count = 0;
+
+	gtk_label_set_text(mpcp->statusLabel, _("Resetting passwords, please wait…"));
+
+	enable_inputs(mpcp, FALSE);
+	mpcp->sid = g_idle_add(changenext, (gpointer)mpcp);
+
+}
+
+static gboolean remmina_mpchange_searchfield_changed_to(gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	struct mpchanger_params *mpcp = (struct mpchanger_params *)user_data;
+	const gchar *s;
+
+	if (mpcp->searchentrychange_timeout_source_id) {
+		g_source_remove(mpcp->searchentrychange_timeout_source_id);
+		mpcp->searchentrychange_timeout_source_id = 0;
+	}
+
+	s = gtk_entry_get_text(mpcp->eGroup);
+	g_free(mpcp->group);
+	mpcp->group = g_strdup(s);
+
+	s = gtk_entry_get_text(mpcp->eDomain);
+	g_free(mpcp->domain);
+	mpcp->domain = g_strdup(s);
+
+	s = gtk_entry_get_text(mpcp->eUsername);
+	g_free(mpcp->username);
+	mpcp->username = g_strdup(s);
+
+	s = gtk_entry_get_text(mpcp->eGatewayDomain);
+	g_free(mpcp->gatewaydomain);
+	mpcp->gatewaydomain = g_strdup(s);
+
+	s = gtk_entry_get_text(mpcp->eGatewayUsername);
+	g_free(mpcp->gatewayusername);
+	mpcp->gatewayusername = g_strdup(s);
+
+	if (mpcp->store != NULL) {
+		gtk_tree_view_set_model(mpcp->table, NULL);
+	}
+	mpcp->store = gtk_list_store_new(NUM_COLS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
+
+	if (mpcp->group[0] != 0 || mpcp->domain[0] != 0 || mpcp->username[0] != 0 || mpcp->gatewayusername[0] != 0 || mpcp->gatewaydomain[0] != 0)
+		remmina_file_manager_iterate((GFunc)remmina_mpchange_file_list_callback, (gpointer)mpcp);
+
+	gtk_tree_view_set_model(mpcp->table, GTK_TREE_MODEL(mpcp->store));
+
+	return G_SOURCE_CONTINUE;       // Source already remove at the beginning
+
+}
+
+static void remmina_mpchange_searchfield_changed(GtkSearchEntry *se, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	struct mpchanger_params *mpcp = (struct mpchanger_params *)user_data;
+
+	if (mpcp->searchentrychange_timeout_source_id) {
+		g_source_remove(mpcp->searchentrychange_timeout_source_id);
+		mpcp->searchentrychange_timeout_source_id = 0;
+	}
+
+	mpcp->searchentrychange_timeout_source_id = g_timeout_add(500, remmina_mpchange_searchfield_changed_to, user_data);
+}
+
+
+static void remmina_mpchange_stopsearch(GtkSearchEntry *entry, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	/* The stop-search signal is emitted when pressing Esc on a GtkSearchEntry. We end the dialog. */
+	struct mpchanger_params *mpcp = (struct mpchanger_params *)user_data;
+	gtk_dialog_response(mpcp->dialog, 1);
+}
+
+static gboolean remmina_file_multipasswd_changer_mt(gpointer d)
+{
+	TRACE_CALL(__func__);
+	struct mpchanger_params *mpcp = d;
+	GtkBuilder* bu;
+	GtkDialog* dialog;
+	GtkWindow* mainwindow;
+	GtkCellRendererToggle *toggle;
+	RemminaSecretPlugin *secret_plugin;
+	char *initerror;
+
+	mainwindow = remmina_main_get_window();
+
+	/* The multiple password changer works only when a secrecy plugin is available */
+	initerror = NULL;
+	secret_plugin = remmina_plugin_manager_get_secret_plugin();
+	if (secret_plugin == NULL) {
+		initerror = _("The multi password changer requires a secrecy plugin.\n");
+	}else {
+		if (!secret_plugin->is_service_available(secret_plugin)) {
+			initerror = _("The multi password changer requires a secrecy service.\n");
+		}
+	}
+	if (initerror) {
+		GtkWidget *msgDialog;
+		msgDialog = gtk_message_dialog_new(mainwindow, GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
+			"%s", initerror);
+		gtk_dialog_run(GTK_DIALOG(msgDialog));
+		gtk_widget_destroy(msgDialog);
+		return FALSE;
+	}
+
+
+	bu = remmina_public_gtk_builder_new_from_resource("/org/remmina/Remmina/src/../data/ui/remmina_mpc.glade");
+	if (!bu) {
+		REMMINA_DEBUG("Unable to load the multiple password changer Glade file interface\n");
+		return FALSE;
+	}
+
+	dialog = GTK_DIALOG(gtk_builder_get_object(bu, "MPCDialog"));
+	mpcp->dialog = dialog;
+	if (mainwindow)
+		gtk_window_set_transient_for(GTK_WINDOW(dialog), mainwindow);
+
+
+	mpcp->eGroup = GTK_ENTRY(GET_DIALOG_OBJECT("groupEntry"));
+	gtk_entry_set_text(mpcp->eGroup, mpcp->group);
+	g_signal_connect(G_OBJECT(mpcp->eGroup), "changed", G_CALLBACK(remmina_mpchange_searchfield_changed), (gpointer)mpcp);
+	g_signal_connect(G_OBJECT(mpcp->eGroup), "stop-search", G_CALLBACK(remmina_mpchange_stopsearch), (gpointer)mpcp);
+
+	mpcp->eUsername = GTK_ENTRY(GET_DIALOG_OBJECT("usernameEntry"));
+	gtk_entry_set_text(mpcp->eUsername, mpcp->username);
+	g_signal_connect(G_OBJECT(mpcp->eUsername), "changed", G_CALLBACK(remmina_mpchange_searchfield_changed), (gpointer)mpcp);
+
+	mpcp->eGatewayUsername = GTK_ENTRY(GET_DIALOG_OBJECT("gatewayUsernameEntry"));
+	gtk_entry_set_text(mpcp->eGatewayUsername, mpcp->gatewayusername);
+	g_signal_connect(G_OBJECT(mpcp->eGatewayUsername), "changed", G_CALLBACK(remmina_mpchange_searchfield_changed), (gpointer)mpcp);
+
+	mpcp->eDomain = GTK_ENTRY(GET_DIALOG_OBJECT("domainEntry"));
+	gtk_entry_set_text(mpcp->eDomain, mpcp->domain);
+	g_signal_connect(G_OBJECT(mpcp->eDomain), "changed", G_CALLBACK(remmina_mpchange_searchfield_changed), (gpointer)mpcp);
+
+	mpcp->eGatewayDomain = GTK_ENTRY(GET_DIALOG_OBJECT("gatewayDomainEntry"));
+	gtk_entry_set_text(mpcp->eGatewayDomain, mpcp->gatewaydomain);
+	g_signal_connect(G_OBJECT(mpcp->eGatewayDomain), "changed", G_CALLBACK(remmina_mpchange_searchfield_changed), (gpointer)mpcp);
+
+	mpcp->ePassword1 = GTK_ENTRY(GET_DIALOG_OBJECT("password1Entry"));
+	gtk_entry_set_text(mpcp->ePassword1, mpcp->password);
+
+	mpcp->eGatewayPassword1 = GTK_ENTRY(GET_DIALOG_OBJECT("gatewayPassword1Entry"));
+	gtk_entry_set_text(mpcp->eGatewayPassword1, mpcp->gatewaypassword);
+
+	mpcp->ePassword2 = GTK_ENTRY(GET_DIALOG_OBJECT("password2Entry"));
+	gtk_entry_set_text(mpcp->ePassword2, mpcp->password);
+
+	mpcp->eGatewayPassword2 = GTK_ENTRY(GET_DIALOG_OBJECT("gatewayPassword2Entry"));
+	gtk_entry_set_text(mpcp->eGatewayPassword2, mpcp->gatewaypassword);
+
+	mpcp->statusLabel = GTK_LABEL(GET_DIALOG_OBJECT("statusLabel"));
+	
+
+
+
+	mpcp->store = NULL;
+
+	mpcp->table = GTK_TREE_VIEW(GET_DIALOG_OBJECT("profchangelist"));
+
+	/* Fire a fake searchfield changed, so a new list store is created */
+	remmina_mpchange_searchfield_changed(NULL, (gpointer)mpcp);
+
+	toggle = GTK_CELL_RENDERER_TOGGLE(GET_DIALOG_OBJECT("cellrenderertoggle1"));
+	g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(remmina_mpchange_checkbox_toggle), (gpointer)mpcp);
+
+	mpcp->btnDoChange = GTK_BUTTON(GET_DIALOG_OBJECT("btnDoChange"));
+	g_signal_connect(mpcp->btnDoChange, "clicked", G_CALLBACK(remmina_mpchange_dochange_clicked), (gpointer)mpcp);
+
+	gtk_dialog_run(dialog);
+	gtk_widget_destroy(GTK_WIDGET(dialog));
+
+	if (mpcp->sid) {
+		g_source_remove(mpcp->sid);
+		mpcp->sid = 0;
+	}
+
+	if (mpcp->searchentrychange_timeout_source_id) {
+		g_source_remove(mpcp->searchentrychange_timeout_source_id);
+		mpcp->searchentrychange_timeout_source_id = 0;
+	}
+
+	if (mpcp->changed_passwords_count) {
+		GtkWidget *msgDialog;
+		msgDialog = gtk_message_dialog_new(GTK_WINDOW(mpcp->dialog),
+			GTK_DIALOG_DESTROY_WITH_PARENT,
+			GTK_MESSAGE_INFO,
+			GTK_BUTTONS_OK,
+			ngettext("%d password changed.", "%d passwords changed.", mpcp->changed_passwords_count), mpcp->changed_passwords_count);
+		gtk_dialog_run(GTK_DIALOG(msgDialog));
+		gtk_widget_destroy(msgDialog);
+	}
+
+	// Free data
+	g_free(mpcp->username);
+	g_free(mpcp->password);
+	g_free(mpcp->domain);
+	g_free(mpcp->group);
+	g_free(mpcp->gatewayusername);
+	g_free(mpcp->gatewaypassword);
+	g_free(mpcp->gatewaydomain);
+	g_free(mpcp);
+	return FALSE;
+}
+
+
+void
+remmina_mpchange_schedule(gboolean has_domain, const gchar *group, const gchar *domain, const gchar *username, const gchar *password, const gchar *gatewayusername, const gchar *gatewaydomain, const gchar *gatewaypassword)
+{
+	// We could also be called in a subthread after a successful connection
+	// (not currently implemented)
+	// So we just schedule the multipassword changer to be executed on
+	// the main thread
+
+	TRACE_CALL(__func__);
+	struct mpchanger_params *mpcp;
+
+	mpcp = g_malloc0(sizeof(struct mpchanger_params));
+	mpcp->username = g_strdup(username);
+	mpcp->password = g_strdup(password);
+	mpcp->domain = g_strdup(domain);
+	mpcp->group = g_strdup(group);
+	mpcp->gatewayusername = g_strdup(gatewayusername);
+	mpcp->gatewaypassword = g_strdup(gatewaypassword);
+	mpcp->gatewaydomain = g_strdup(gatewaydomain);
+	gdk_threads_add_idle(remmina_file_multipasswd_changer_mt, (gpointer)mpcp);
+
+}
diff --git a/src/remmina_mpchange.h b/src/remmina_mpchange.h
new file mode 100644
index 0000000..95c2417
--- /dev/null
+++ b/src/remmina_mpchange.h
@@ -0,0 +1,45 @@
+/*
+ * 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 "remmina/types.h"
+
+#pragma once
+
+G_BEGIN_DECLS
+
+
+/* Schedule the multipassword change confirmation dialog to be executed ASAP */
+void remmina_mpchange_schedule(gboolean has_domain, const gchar *group, const gchar *domain, const gchar *username, const gchar *password, const gchar *gatewayusername, const gchar *gatewaydomain, const gchar *gatewaypassword);
\ No newline at end of file
diff --git a/src/remmina_passwd.c b/src/remmina_passwd.c
new file mode 100644
index 0000000..debc2bb
--- /dev/null
+++ b/src/remmina_passwd.c
@@ -0,0 +1,163 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * 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 <stdlib.h>
+
+#include <glib/gi18n.h>
+
+#include "config.h"
+#include "remmina_public.h"
+#include "remmina_log.h"
+#include "remmina_sodium.h"
+#include "remmina_passwd.h"
+#include "remmina/remmina_trace_calls.h"
+
+static RemminaPasswdDialog *remmina_passwd_dialog;
+#define GET_OBJ(object_name) gtk_builder_get_object(remmina_passwd_dialog->builder, object_name)
+
+void remmina_passwd_repwd_on_changed(GtkEditable *editable, RemminaPasswdDialog *dialog)
+{
+	TRACE_CALL(__func__);
+	GtkCssProvider *provider;
+	const gchar *color;
+	const gchar *password;
+	const gchar *verify;
+	gboolean sensitive = FALSE;
+
+	provider = gtk_css_provider_new();
+
+	password = gtk_entry_get_text(remmina_passwd_dialog->entry_password);
+	verify = gtk_entry_get_text(remmina_passwd_dialog->entry_verify);
+	if (g_strcmp0(password, verify) == 0) {
+		color = g_strdup("green");
+		sensitive = TRUE;
+	} else
+		color = g_strdup("red");
+
+	gtk_widget_set_sensitive (GTK_WIDGET(remmina_passwd_dialog->button_submit), sensitive);
+
+	if (verify == NULL || verify[0] == '\0')
+		color = g_strdup("inherit");
+
+	gtk_css_provider_load_from_data(provider,
+					g_strdup_printf(
+						".entry_verify {\n"
+						"  color: %s;\n"
+						"}\n"
+						, color)
+					, -1, NULL);
+	gtk_style_context_add_provider_for_screen(gdk_screen_get_default(),
+						  GTK_STYLE_PROVIDER(provider),
+						  GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+
+	gtk_widget_queue_draw(GTK_WIDGET(remmina_passwd_dialog->entry_verify));
+	g_object_unref(provider);
+}
+
+static void remmina_passwd_password_activate(GtkEntry *entry, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+
+	 gtk_widget_grab_focus(GTK_WIDGET(remmina_passwd_dialog->entry_verify));
+
+}
+
+static void remmina_passwd_cancel_clicked(GtkButton *btn, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gtk_dialog_response (remmina_passwd_dialog->dialog, GTK_RESPONSE_CANCEL);
+}
+
+static void remmina_passwd_submit_clicked(GtkButton *btn, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	remmina_passwd_dialog->password = gtk_entry_get_text(
+			GTK_ENTRY(remmina_passwd_dialog->entry_verify));
+	gtk_dialog_response (remmina_passwd_dialog->dialog, GTK_RESPONSE_ACCEPT);
+}
+
+gboolean remmina_passwd(GtkWindow *parent, gchar **unlock_password)
+{
+	TRACE_CALL(__func__);
+
+	remmina_passwd_dialog = g_new0(RemminaPasswdDialog, 1);
+	gboolean rc = FALSE;
+
+	remmina_passwd_dialog->builder = remmina_public_gtk_builder_new_from_resource("/org/remmina/Remmina/src/../data/ui/remmina_passwd.glade");
+	remmina_passwd_dialog->dialog = GTK_DIALOG(GET_OBJ("RemminaPasswdDialog"));
+	if (parent)
+		gtk_window_set_transient_for(GTK_WINDOW(remmina_passwd_dialog->dialog), parent);
+
+	remmina_passwd_dialog->entry_password = GTK_ENTRY(GET_OBJ("entry_password"));
+	remmina_passwd_dialog->entry_verify = GTK_ENTRY(GET_OBJ("entry_verify"));
+	gtk_entry_set_activates_default(GTK_ENTRY(remmina_passwd_dialog->entry_verify), TRUE);
+	remmina_passwd_dialog->button_submit = GTK_BUTTON(GET_OBJ("button_submit"));
+	gtk_widget_set_can_default(GTK_WIDGET(remmina_passwd_dialog->button_submit), TRUE);
+	gtk_widget_grab_default(GTK_WIDGET(remmina_passwd_dialog->button_submit));
+	remmina_passwd_dialog->button_cancel = GTK_BUTTON(GET_OBJ("button_cancel"));
+
+	g_signal_connect(remmina_passwd_dialog->entry_password, "activate",
+			 G_CALLBACK(remmina_passwd_password_activate), (gpointer)remmina_passwd_dialog);
+	g_signal_connect(remmina_passwd_dialog->button_submit, "clicked",
+			 G_CALLBACK(remmina_passwd_submit_clicked), (gpointer)remmina_passwd_dialog);
+	g_signal_connect(remmina_passwd_dialog->button_cancel, "clicked",
+			 G_CALLBACK(remmina_passwd_cancel_clicked), (gpointer)remmina_passwd_dialog);
+
+	/* Connect signals */
+	gtk_builder_connect_signals(remmina_passwd_dialog->builder, NULL);
+
+	int result = gtk_dialog_run(remmina_passwd_dialog->dialog);
+	switch (result)
+	{
+		case GTK_RESPONSE_ACCEPT:
+#if SODIUM_VERSION_INT >= 90200
+			//REMMINA_DEBUG ("Password before encryption: %s", remmina_passwd_dialog->password);
+			*unlock_password = remmina_sodium_pwhash_str(remmina_passwd_dialog->password);
+#else
+			*unlock_password = g_strdup(remmina_passwd_dialog->password);
+#endif
+			//REMMINA_DEBUG ("Password after encryption is: %s", *unlock_password);
+			remmina_passwd_dialog->password = NULL;
+			rc = TRUE;
+			break;
+		default:
+			remmina_passwd_dialog->password = NULL;
+			*unlock_password = NULL;
+			rc = FALSE;
+			break;
+	}
+	gtk_widget_destroy(GTK_WIDGET(remmina_passwd_dialog->dialog));
+	remmina_passwd_dialog->dialog = NULL;
+	return rc;
+}
diff --git a/src/remmina_passwd.h b/src/remmina_passwd.h
new file mode 100644
index 0000000..6abeb91
--- /dev/null
+++ b/src/remmina_passwd.h
@@ -0,0 +1,58 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2017-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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+#include <glib.h>
+
+typedef struct _RemminaPasswdDialog {
+	GtkBuilder *	builder;
+	GtkDialog *	dialog;
+
+	GtkEntry *	entry_password;
+	GtkEntry *	entry_verify;
+	GtkButton *	button_submit;
+	GtkButton *	button_cancel;
+
+	const gchar *	password;
+
+} RemminaPasswdDialog;
+
+
+G_BEGIN_DECLS
+
+gboolean remmina_passwd(GtkWindow *parent, gchar **password_setting);
+
+G_END_DECLS
diff --git a/src/remmina_plugin_manager.c b/src/remmina_plugin_manager.c
new file mode 100644
index 0000000..60c0bee
--- /dev/null
+++ b/src/remmina_plugin_manager.c
@@ -0,0 +1,1555 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010-2011 Vic Lee
+ * Copyright (C) 2014-2015 Antenore Gatta, Fabio Castelli, Giovanni Panozzo
+ * Copyright (C) 2016-2023 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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 <glib/gi18n.h>
+#include <gmodule.h>
+#include <json-glib/json-glib.h>
+#ifdef GDK_WINDOWING_X11
+#include <gdk/gdkx.h>
+#elif defined(GDK_WINDOWING_WAYLAND)
+#include <gdk/gdkwayland.h>
+#endif
+#include "remmina_public.h"
+#include "remmina_main.h"
+#include "remmina_file_manager.h"
+#include "remmina_pref.h"
+#include "remmina_info.h"
+#include "remmina_protocol_widget.h"
+#include "remmina_log.h"
+#include "remmina_widget_pool.h"
+#include "rcw.h"
+#include "remmina_plugin_manager.h"
+#include "remmina_plugin_native.h"
+#include "remmina_public.h"
+#include "remmina_masterthread_exec.h"
+#include "remmina/remmina_trace_calls.h"
+#include "remmina_curl_connector.h"
+#include "remmina_utils.h"
+#include "remmina_unlock.h"
+
+static GPtrArray* remmina_plugin_table = NULL;
+
+static GPtrArray* remmina_available_plugin_table = NULL;
+
+static GtkDialog* remmina_plugin_window = NULL;
+
+static SignalData* remmina_plugin_signal_data = NULL;
+
+/* A GHashTable of GHashTables where to store the names of the encrypted settings */
+static GHashTable *encrypted_settings_cache = NULL;
+
+/* There can be only one secret plugin loaded */
+static RemminaSecretPlugin *remmina_secret_plugin = NULL;
+
+
+
+// TRANSLATORS: "Language Wrapper" is a wrapper for plugins written in other programmin languages (Python in this context)
+static const gchar *remmina_plugin_type_name[] =
+{ N_("Protocol"), N_("Entry"), N_("File"), N_("Tool"), N_("Preference"), N_("Secret"), N_("Language Wrapper"), NULL };
+
+static gint remmina_plugin_manager_compare_func(RemminaPlugin **a, RemminaPlugin **b)
+{
+	TRACE_CALL(__func__);
+	return g_strcmp0((*a)->name, (*b)->name);
+}
+
+static void htdestroy(gpointer ht)
+{
+	g_hash_table_unref(ht);
+}
+
+static void init_settings_cache(RemminaPlugin *plugin)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolPlugin *protocol_plugin;
+	const RemminaProtocolSetting* setting_iter;
+	GHashTable *pht;
+
+	/* This code make a encrypted setting cache only for protocol plugins */
+
+	if (plugin->type != REMMINA_PLUGIN_TYPE_PROTOCOL) {
+		return;
+	}
+
+	if (encrypted_settings_cache == NULL)
+		encrypted_settings_cache = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, htdestroy);
+
+	if (!(pht = g_hash_table_lookup(encrypted_settings_cache, plugin->name))) {
+		pht = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
+		g_hash_table_insert(encrypted_settings_cache, g_strdup(plugin->name), pht);
+	}
+
+	/* Some settings are encrypted "by name" */
+	/* g_hash_table_insert(pht, g_strdup("proxy_password"), (gpointer)TRUE); */
+
+	g_hash_table_insert(pht, g_strdup("ssh_tunnel_password"), (gpointer)TRUE);
+	g_hash_table_insert(pht, g_strdup("ssh_tunnel_passphrase"), (gpointer)TRUE);
+
+	/* ssh_password is no longer used starting from remmina 1.4.
+	 * But we MUST mark it as encrypted setting, or the migration procedure will fail */
+	g_hash_table_insert(pht, g_strdup("ssh_password"), (gpointer)TRUE);
+
+	/* Other settings are encrypted because of their type */
+	protocol_plugin = (RemminaProtocolPlugin *)plugin;
+	setting_iter = protocol_plugin->basic_settings;
+	if (setting_iter) {
+		while (setting_iter->type != REMMINA_PROTOCOL_SETTING_TYPE_END) {
+			if (setting_iter->type == REMMINA_PROTOCOL_SETTING_TYPE_PASSWORD)
+				g_hash_table_insert(pht, g_strdup(remmina_plugin_manager_get_canonical_setting_name(setting_iter)), (gpointer)TRUE);
+			setting_iter++;
+		}
+	}
+	setting_iter = protocol_plugin->advanced_settings;
+	if (setting_iter) {
+		while (setting_iter->type != REMMINA_PROTOCOL_SETTING_TYPE_END) {
+			if (setting_iter->type == REMMINA_PROTOCOL_SETTING_TYPE_PASSWORD)
+				g_hash_table_insert(pht, g_strdup(remmina_plugin_manager_get_canonical_setting_name(setting_iter)), (gpointer)TRUE);
+			setting_iter++;
+		}
+	}
+
+}
+
+static gboolean remmina_plugin_manager_register_plugin(RemminaPlugin *plugin)
+{
+	TRACE_CALL(__func__);
+	if (plugin->type == REMMINA_PLUGIN_TYPE_SECRET) {
+		REMMINA_DEBUG("Remmina plugin %s (type=%s) has been registered, but is not yet initialized/activated. "
+			"The initialization order is %d.", plugin->name,
+			_(remmina_plugin_type_name[plugin->type]),
+			((RemminaSecretPlugin*)plugin)->init_order);
+	}
+	init_settings_cache(plugin);
+
+	g_ptr_array_add(remmina_plugin_table, plugin);
+	g_ptr_array_sort(remmina_plugin_table, (GCompareFunc)remmina_plugin_manager_compare_func);
+	return TRUE;
+}
+
+gboolean remmina_gtksocket_available()
+{
+	GdkDisplayManager* dm;
+	GdkDisplay* d;
+	gboolean available;
+
+	dm = gdk_display_manager_get();
+	d = gdk_display_manager_get_default_display(dm);
+	available = FALSE;
+
+#ifdef GDK_WINDOWING_X11
+	if (GDK_IS_X11_DISPLAY(d)) {
+		/* GtkSocket support is available only under X.Org */
+		available = TRUE;
+	}
+#endif
+	return available;
+}
+
+RemminaPluginService remmina_plugin_manager_service =
+{
+	remmina_plugin_manager_register_plugin,
+	remmina_protocol_widget_get_width,
+	remmina_protocol_widget_set_width,
+	remmina_protocol_widget_get_height,
+	remmina_protocol_widget_set_height,
+	remmina_protocol_widget_get_current_scale_mode,
+	remmina_protocol_widget_get_expand,
+	remmina_protocol_widget_set_expand,
+	remmina_protocol_widget_has_error,
+	remmina_protocol_widget_set_error,
+	remmina_protocol_widget_is_closed,
+	remmina_protocol_widget_get_file,
+	remmina_protocol_widget_emit_signal,
+	remmina_protocol_widget_register_hostkey,
+	remmina_protocol_widget_start_direct_tunnel,
+	remmina_protocol_widget_start_reverse_tunnel,
+	remmina_protocol_widget_start_xport_tunnel,
+	remmina_protocol_widget_set_display,
+	remmina_protocol_widget_signal_connection_closed,
+	remmina_protocol_widget_signal_connection_opened,
+	remmina_protocol_widget_update_align,
+	remmina_protocol_widget_lock_dynres,
+	remmina_protocol_widget_unlock_dynres,
+	remmina_protocol_widget_desktop_resize,
+	remmina_protocol_widget_panel_auth,
+	remmina_protocol_widget_panel_new_certificate,
+	remmina_protocol_widget_panel_changed_certificate,
+	remmina_protocol_widget_get_username,
+	remmina_protocol_widget_get_password,
+	remmina_protocol_widget_get_domain,
+	remmina_protocol_widget_get_savepassword,
+	remmina_protocol_widget_panel_authx509,
+	remmina_protocol_widget_get_cacert,
+	remmina_protocol_widget_get_cacrl,
+	remmina_protocol_widget_get_clientcert,
+	remmina_protocol_widget_get_clientkey,
+	remmina_protocol_widget_save_cred,
+	remmina_protocol_widget_panel_show_listen,
+	remmina_protocol_widget_panel_show_retry,
+	remmina_protocol_widget_panel_show,
+	remmina_protocol_widget_panel_hide,
+	remmina_protocol_widget_ssh_exec,
+	remmina_protocol_widget_chat_open,
+	remmina_protocol_widget_chat_close,
+	remmina_protocol_widget_chat_receive,
+	remmina_protocol_widget_send_keys_signals,
+
+	remmina_file_get_datadir,
+
+	remmina_file_new,
+	remmina_file_get_filename,
+	remmina_file_set_string,
+	remmina_file_get_string,
+	remmina_file_get_secret,
+	remmina_file_set_int,
+	remmina_file_get_int,
+	remmina_file_get_double,
+	remmina_file_unsave_passwords,
+
+	remmina_pref_set_value,
+	remmina_pref_get_value,
+	remmina_pref_get_scale_quality,
+	remmina_pref_get_sshtunnel_port,
+	remmina_pref_get_ssh_loglevel,
+	remmina_pref_get_ssh_parseconfig,
+	remmina_pref_keymap_get_table,
+	remmina_pref_keymap_get_keyval,
+
+	_remmina_info,
+	_remmina_message,
+	_remmina_debug,
+	_remmina_warning,
+	_remmina_audit,
+	_remmina_error,
+	_remmina_critical,
+	remmina_log_print,
+	remmina_log_printf,
+
+	remmina_widget_pool_register,
+
+	rcw_open_from_file_full,
+	remmina_public_open_unix_sock,
+	remmina_public_get_server_port,
+	remmina_masterthread_exec_is_main_thread,
+	remmina_gtksocket_available,
+	remmina_protocol_widget_get_profile_remote_width,
+	remmina_protocol_widget_get_profile_remote_height,
+	remmina_protocol_widget_get_name,
+	remmina_protocol_widget_get_width,
+	remmina_protocol_widget_get_height,
+	remmina_protocol_widget_set_width,
+	remmina_protocol_widget_set_height,
+	remmina_protocol_widget_get_current_scale_mode,
+	remmina_protocol_widget_get_expand,
+	remmina_protocol_widget_set_expand,
+	remmina_protocol_widget_set_error,
+	remmina_protocol_widget_has_error,
+	remmina_protocol_widget_gtkviewport,
+	remmina_protocol_widget_is_closed,
+	remmina_protocol_widget_get_file,
+	remmina_protocol_widget_panel_auth,
+	remmina_protocol_widget_register_hostkey,
+	remmina_protocol_widget_start_direct_tunnel,
+	remmina_protocol_widget_start_reverse_tunnel,
+	remmina_protocol_widget_send_keys_signals,
+	remmina_protocol_widget_chat_receive,
+	remmina_protocol_widget_panel_hide,
+	remmina_protocol_widget_chat_open,
+	remmina_protocol_widget_ssh_exec,
+	remmina_protocol_widget_panel_show,
+	remmina_protocol_widget_panel_show_retry,
+	remmina_protocol_widget_start_xport_tunnel,
+	remmina_protocol_widget_set_display,
+	remmina_protocol_widget_signal_connection_closed,
+	remmina_protocol_widget_signal_connection_opened,
+	remmina_protocol_widget_update_align,
+	remmina_protocol_widget_unlock_dynres,
+	remmina_protocol_widget_desktop_resize,
+	remmina_protocol_widget_panel_new_certificate,
+	remmina_protocol_widget_panel_changed_certificate,
+	remmina_protocol_widget_get_username,
+	remmina_protocol_widget_get_password,
+	remmina_protocol_widget_get_domain,
+	remmina_protocol_widget_get_savepassword,
+	remmina_protocol_widget_panel_authx509,
+	remmina_protocol_widget_get_cacert,
+	remmina_protocol_widget_get_cacrl,
+	remmina_protocol_widget_get_clientcert,
+	remmina_protocol_widget_get_clientkey,
+	remmina_protocol_widget_save_cred,
+	remmina_protocol_widget_panel_show_listen,
+	remmina_widget_pool_register,
+	rcw_open_from_file_full,
+	remmina_main_show_dialog,
+	remmina_main_get_window,
+	remmina_unlock_new,
+};
+
+const char *get_filename_ext(const char *filename) {
+	const char* last = strrchr(filename, '/');
+    const char *dot = strrchr(last, '.');
+    if(!dot || dot == filename) return "";
+    return dot + 1;
+}
+
+static gint compare_secret_plugin_init_order(gconstpointer a, gconstpointer b)
+{
+	RemminaSecretPlugin *sa, *sb;
+
+	sa = (RemminaSecretPlugin*)a;
+	sb = (RemminaSecretPlugin*)b;
+
+	if (sa->init_order > sb->init_order)
+		return 1;
+	else if (sa->init_order < sb->init_order)
+		return -1;
+	return 0;
+}
+
+gchar* remmina_plugin_manager_create_alt_plugin_dir()
+{
+	gchar *plugin_dir;
+	plugin_dir = g_build_path("/", g_get_user_config_dir(), "remmina", "plugins", NULL);
+
+	if (g_file_test(plugin_dir, G_FILE_TEST_IS_DIR)) {
+		// Do nothing, directory already exists
+	}
+	else
+	{
+		gint result = g_mkdir_with_parents(plugin_dir, 0755);
+		if (result != 0)
+		{
+			plugin_dir = NULL;
+		}
+	}
+	return plugin_dir;
+}
+
+
+void remmina_plugin_manager_load_plugins(GPtrArray *plugin_dirs, int array_size)
+{
+	TRACE_CALL(__func__);
+	GDir *dir;
+	const gchar *name, *ptr;
+	gchar *fullpath;
+	RemminaPlugin *plugin;
+	RemminaSecretPlugin *sp;
+	guint i, j;
+	GSList *secret_plugins;
+	GSList *sple;
+	GPtrArray *alternative_language_plugins;
+	GPtrArray *loaded_plugins = g_ptr_array_new();
+	alternative_language_plugins = g_ptr_array_new();
+	char* plugin_dir = NULL;
+
+	for (i = 0; i < array_size; i++){
+		plugin_dir = g_ptr_array_remove_index(plugin_dirs, 0);
+		if (plugin_dir){
+			dir = g_dir_open(plugin_dir, 0, NULL);
+
+			if (dir == NULL){
+				continue;
+			}
+			while ((name = g_dir_read_name(dir)) != NULL) {
+				if ((ptr = strrchr(name, '.')) == NULL)
+					continue;
+				ptr++;
+				fullpath = g_strconcat(plugin_dir, "/", name, NULL);
+				if (!remmina_plugin_manager_loader_supported(ptr)) {
+					g_ptr_array_add(alternative_language_plugins, g_strconcat(plugin_dir, "/", name, NULL));
+					g_free(fullpath);
+					continue;
+				}
+				if (!g_ptr_array_find_with_equal_func(loaded_plugins, name, g_str_equal, NULL)){
+					if (remmina_plugin_native_load(&remmina_plugin_manager_service, fullpath)){
+						g_ptr_array_add(loaded_plugins, g_strdup(name));
+					}
+				}
+				
+				g_free(fullpath);
+			}
+			g_dir_close(dir);
+		}
+	}
+	
+
+	while (alternative_language_plugins->len > 0) {
+		gboolean has_loaded = FALSE;
+		gchar* name = (gchar*)g_ptr_array_remove_index(alternative_language_plugins, 0);
+		const gchar* ext = get_filename_ext(name);
+		char* filename = strrchr(name, '/');
+
+		for (j = 0; j < remmina_plugin_table->len && !has_loaded; j++) {
+			plugin = (RemminaPlugin*)g_ptr_array_index(remmina_plugin_table, j);
+			if (plugin->type == REMMINA_PLUGIN_TYPE_LANGUAGE_WRAPPER) {
+				RemminaLanguageWrapperPlugin* wrapper_plugin = (RemminaLanguageWrapperPlugin*)plugin;
+				const gchar** supported_extention = wrapper_plugin->supported_extentions;
+				while (*supported_extention) {
+					if (g_str_equal(*supported_extention, ext)) {
+						if (!g_ptr_array_find_with_equal_func(loaded_plugins, name, g_str_equal, NULL)){
+							has_loaded = wrapper_plugin->load(wrapper_plugin, name);
+							if (has_loaded) {
+								if (filename){
+									g_ptr_array_add(loaded_plugins, filename);
+								}
+								break;
+							}
+						}
+					}
+					supported_extention++;
+				}
+				if (has_loaded) break;
+			}
+		}
+
+		if (!has_loaded) {
+			g_print("%s: Skip unsupported file type '%s'\n", name, ext);
+		}
+
+		g_free(name);
+	}
+
+	/* Now all secret plugins needs to initialize, following their init_order.
+	 * The 1st plugin which will initialize correctly will be
+	 * the default remmina_secret_plugin */
+
+	if (remmina_secret_plugin)
+		g_print("Internal ERROR: remmina_secret_plugin must be null here\n");
+
+	secret_plugins = NULL;
+	for (i = 0; i < remmina_plugin_table->len; i++) {
+		plugin = (RemminaPlugin*)g_ptr_array_index(remmina_plugin_table, i);
+		if (plugin->type == REMMINA_PLUGIN_TYPE_SECRET) {
+			secret_plugins = g_slist_insert_sorted(secret_plugins, (gpointer)plugin, compare_secret_plugin_init_order);
+		}
+	}
+
+	sple = secret_plugins;
+	while(sple != NULL) {
+		sp = (RemminaSecretPlugin*)sple->data;
+		if (sp->init(sp)) {
+			REMMINA_DEBUG("The %s secret plugin has been initialized and it will be your default secret plugin",
+				sp->name);
+			remmina_secret_plugin = sp;
+			break;
+		}
+		sple = sple->next;
+	}
+
+	g_slist_free(secret_plugins);
+	g_ptr_array_free(alternative_language_plugins, TRUE);
+	g_ptr_array_free(loaded_plugins, TRUE);
+}
+
+void remmina_plugin_manager_init()
+{
+	TRACE_CALL(__func__);
+
+	gchar* alternative_dir;
+
+	remmina_plugin_table = g_ptr_array_new();
+	remmina_available_plugin_table = g_ptr_array_new();
+	GPtrArray *plugin_dirs = g_ptr_array_new();
+	int array_size = 1;
+	
+	if (!g_module_supported()) {
+		g_print("Dynamic loading of plugins is not supported on this platform!\n");
+		return;
+	}
+	alternative_dir = remmina_plugin_manager_create_alt_plugin_dir();
+
+	if(alternative_dir != NULL){
+		g_ptr_array_add(plugin_dirs, alternative_dir);
+		array_size += 1;
+		
+	}
+	g_ptr_array_add(plugin_dirs, REMMINA_RUNTIME_PLUGINDIR);
+	remmina_plugin_manager_load_plugins(plugin_dirs, array_size);
+
+
+	if (alternative_dir){
+		g_free(alternative_dir);
+	}
+
+	if (plugin_dirs != NULL) {
+		g_ptr_array_free(plugin_dirs, TRUE);
+	}
+}
+
+/*
+ * Creates a JsonNode with all the installed plugin names and version
+ *
+ * @returns NULL if there is an error creating the json builder object. Otherwise, return the JsonNode object with the plugin data.
+ *
+ */
+JsonNode *remmina_plugin_manager_get_installed_plugins()
+{
+	TRACE_CALL(__func__);
+	JsonBuilder *b;
+	JsonNode *r;
+	RemminaPlugin *plugin;
+	guint i;
+
+	b = json_builder_new();
+	if(b != NULL)
+	{
+		json_builder_begin_object(b);
+
+		for (i = 0; i < remmina_plugin_table->len; i++) {
+			plugin = (RemminaPlugin*)g_ptr_array_index(remmina_plugin_table, i);
+			json_builder_set_member_name(b, plugin->name);
+			json_builder_add_string_value(b, plugin->version);
+		}
+		json_builder_end_object(b);
+		r = json_builder_get_root(b);
+		g_object_unref(b);
+
+		return r;
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+gboolean remmina_plugin_manager_is_python_wrapper_installed()
+{
+	gchar* name = "Python Wrapper";
+	RemminaPlugin *plugin;
+
+	for(int i = 0; i < remmina_plugin_table->len; i++) {
+		plugin = (RemminaPlugin*)g_ptr_array_index(remmina_plugin_table, i);
+		if(g_strcmp0(plugin->name, name) == 0)
+		{
+			return TRUE;
+		}
+	}
+	return FALSE;
+}
+
+/*
+ * Creates a JsonNode with some environment data as well as the installed plugins
+ *
+ * @returns NULL if there is an error creating the json builder object. Otherwise, return the JsonNode object with the plugin data.
+ *
+ */
+JsonNode *remmina_plugin_manager_plugin_stats_get_all()
+{
+	JsonNode *n;
+	gchar *unenc_p, *enc_p, *uid;
+	JsonGenerator *g;
+	JsonBuilder *b_inner, *b_outer;
+
+	b_outer = json_builder_new();
+	if (b_outer == NULL) {
+		g_object_unref(b_outer);
+		return NULL;
+	}
+	json_builder_begin_object(b_outer);
+
+	b_inner = json_builder_new();
+	if(b_inner != NULL)
+	{
+		json_builder_begin_object(b_inner);
+
+		//get architecture and python version to determine what plugins are compatible 
+		n = remmina_info_stats_get_os_info();
+		json_builder_set_member_name(b_inner, "OS_INFO");
+		json_builder_add_value(b_inner, n);
+
+		n = remmina_info_stats_get_python();
+		json_builder_set_member_name(b_inner, "PYTHON");
+		json_builder_add_value(b_inner, n);
+
+		n = remmina_info_stats_get_uid();
+		uid = g_strdup(json_node_get_string(n));
+		json_builder_set_member_name(b_outer, "UID");
+		json_builder_add_string_value(b_outer, uid);
+
+		n = remmina_plugin_manager_get_installed_plugins();
+		json_builder_set_member_name(b_inner, "PLUGINS");
+		json_builder_add_value(b_inner, n);
+
+		json_builder_end_object(b_inner);
+
+		n = json_builder_get_root(b_inner);
+		g_object_unref(b_inner);
+
+		g = json_generator_new();
+		json_generator_set_root(g, n);
+		unenc_p = json_generator_to_data(g, NULL);
+
+
+		enc_p = g_base64_encode((guchar *)unenc_p, strlen(unenc_p));
+		if (enc_p == NULL) {
+			g_object_unref(b_outer);
+			g_object_unref(g);
+			g_free(uid);
+			g_free(unenc_p);
+			return NULL;
+		}
+
+
+		json_builder_set_member_name(b_outer, "encdata");
+		json_builder_add_string_value(b_outer, enc_p);
+
+		if(remmina_plugin_manager_is_python_wrapper_installed() == TRUE) {
+			json_builder_set_member_name(b_outer, "pywrapper_installed");
+			json_builder_add_boolean_value(b_outer, TRUE);
+		} else {
+			json_builder_set_member_name(b_outer, "pywrapper_installed");
+			json_builder_add_boolean_value(b_outer, FALSE);
+		}
+
+		json_builder_end_object(b_outer);
+		n = json_builder_get_root(b_outer);
+		g_object_unref(b_outer);
+
+		g_free(enc_p);
+		g_object_unref(g);
+		g_free(unenc_p);
+		g_free(uid);
+
+		return n;
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+gboolean remmina_plugin_manager_loader_supported(const char *filetype) {
+	TRACE_CALL(__func__);
+	return g_str_equal(G_MODULE_SUFFIX, filetype);
+}
+
+RemminaPlugin* remmina_plugin_manager_get_plugin(RemminaPluginType type, const gchar *name)
+{
+	TRACE_CALL(__func__);
+	RemminaPlugin *plugin;
+	guint i;
+
+	for (i = 0; i < remmina_plugin_table->len; i++) {
+		plugin = (RemminaPlugin*)g_ptr_array_index(remmina_plugin_table, i);
+		if (plugin->type == type && g_strcmp0(plugin->name, name) == 0) {
+			return plugin;
+		}
+	}
+	return NULL;
+}
+
+const gchar *remmina_plugin_manager_get_canonical_setting_name(const RemminaProtocolSetting* setting)
+{
+	if (setting->name == NULL) {
+		if (setting->type == REMMINA_PROTOCOL_SETTING_TYPE_SERVER)
+			return "server";
+		if (setting->type == REMMINA_PROTOCOL_SETTING_TYPE_PASSWORD)
+			return "password";
+		if (setting->type == REMMINA_PROTOCOL_SETTING_TYPE_RESOLUTION)
+			return "resolution";
+		if (setting->type == REMMINA_PROTOCOL_SETTING_TYPE_ASSISTANCE)
+			return "assistance_mode";
+		return "missing_setting_name_into_plugin_RemminaProtocolSetting";
+	}
+	return setting->name;
+}
+
+void remmina_plugin_manager_for_each_plugin(RemminaPluginType type, RemminaPluginFunc func, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaPlugin *plugin;
+	guint i;
+
+	for (i = 0; i < remmina_plugin_table->len; i++) {
+		plugin = (RemminaPlugin*)g_ptr_array_index(remmina_plugin_table, i);
+		if (plugin->type == type) {
+			func((gchar*)plugin->name, plugin, data);
+		}
+	}
+}
+
+/* A copy of remmina_plugin_manager_show and remmina_plugin_manager_show_for_each
+ * This is because we want to print the list of plugins, and their versions, to the standard output
+ * with the remmina command line option --full-version instead of using the plugins widget
+ ** @todo Investigate to use only GListStore and than pass the elements to be shown to 2 separate
+ *       functions
+ * WARNING: GListStore is supported only from GLib 2.44 */
+static gboolean remmina_plugin_manager_show_for_each_stdout(RemminaPlugin *plugin)
+{
+	TRACE_CALL(__func__);
+
+	g_print("%-20s%-16s%-64s%-10s\n", plugin->name,
+		_(remmina_plugin_type_name[plugin->type]),
+		g_dgettext(plugin->domain, plugin->description),
+		plugin->version);
+	return FALSE;
+}
+
+void remmina_plugin_manager_show_stdout()
+{
+	TRACE_CALL(__func__);
+	g_print("%-20s%-16s%-64s%-10s\n", "NAME", "TYPE", "DESCRIPTION", "PLUGIN AND LIBRARY VERSION");
+	g_ptr_array_foreach(remmina_plugin_table, (GFunc)remmina_plugin_manager_show_for_each_stdout, NULL);
+}
+
+static gboolean remmina_plugin_manager_show_for_each(RemminaPlugin *plugin, GtkListStore *store)
+{
+	TRACE_CALL(__func__);
+	GtkTreeIter iter;
+
+	gtk_list_store_append(store, &iter);
+	gtk_list_store_set(store, &iter, 0, FALSE, 1, plugin->name, 2, _(remmina_plugin_type_name[plugin->type]), 3,
+		g_dgettext(plugin->domain, plugin->description), 4, "Installed", 5, plugin->version, -1);
+	
+	return FALSE;
+}
+
+static gboolean remmina_plugin_manager_show_for_each_available(RemminaPlugin *plugin, GtkListStore *store)
+{
+	TRACE_CALL(__func__);
+	GtkTreeIter iter;
+
+	gtk_list_store_append(store, &iter);
+
+	gtk_list_store_set(store, &iter, 0, FALSE, 1, plugin->name, 2, _(remmina_plugin_type_name[plugin->type]), 3,
+		g_dgettext(plugin->domain, plugin->description), 4, "Available", 5, plugin->version, -1);
+		
+	return FALSE;
+}
+
+void result_dialog_cleanup(GtkDialog * dialog, gint response_id, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gtk_widget_destroy(GTK_WIDGET(dialog));
+
+	gtk_widget_hide(remmina_plugin_signal_data->label);
+	gtk_spinner_stop(GTK_SPINNER(remmina_plugin_signal_data->spinner));
+	gtk_widget_set_visible(remmina_plugin_signal_data->spinner, FALSE);
+}
+
+void remmina_plugin_manager_download_result_dialog(GtkDialog * dialog, gchar * message)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *child_dialog, *content_area, *label;
+
+	child_dialog = gtk_dialog_new_with_buttons(_("Plugin Download"), GTK_WINDOW(dialog), GTK_DIALOG_MODAL, _("_OK"), 1, NULL);
+	content_area = gtk_dialog_get_content_area (GTK_DIALOG (child_dialog));
+	label = gtk_label_new(message);
+	remmina_plugin_signal_data->downloading = FALSE;
+
+	gtk_window_set_default_size(GTK_WINDOW(child_dialog), 500, 50);
+	gtk_container_add(GTK_CONTAINER (content_area), label);
+	g_signal_connect(G_OBJECT(child_dialog), "response", G_CALLBACK(result_dialog_cleanup), NULL);
+	gtk_widget_show_all(child_dialog);
+}
+
+void remmina_plugin_manager_toggle_checkbox(GtkCellRendererToggle * cell, gchar * path, GtkListStore * model)
+{
+	TRACE_CALL(__func__);
+	GtkTreeIter iter;
+	gboolean active;
+
+	active = gtk_cell_renderer_toggle_get_active (cell);
+
+	gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (model), &iter, path);
+	if (active) {
+		gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(cell), 0.5, 0.5);
+		gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, FALSE, -1);
+	}
+	else {
+		gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(cell), 0.5, 0.5);
+		gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, TRUE, -1);
+	}
+
+}
+
+/*
+ * Appends json objects that have been deserialized from the response string.
+ *
+ * @returns void but modifies @data_array by appending plugins to it. It is the caller's responsibility to free @data_array
+ * and its underlying elements.
+ */
+void remmina_append_json_objects_from_response_str(JsonReader *reader, GArray* data_array)
+{
+	TRACE_CALL(__func__);
+
+	int plugin_array_index = 0;
+
+	while (json_reader_read_element(reader, plugin_array_index)) {
+		if (plugin_array_index >= MAX_PLUGINS_ALLOWED_TO_DOWNLOAD) {
+			break;
+		}
+		/* This is the current plugin we are building from the deserialized response string. */
+		RemminaServerPluginResponse *current_plugin = g_malloc(sizeof(RemminaServerPluginResponse));
+		if (current_plugin == NULL) {
+			plugin_array_index += 1;
+			continue;
+		}
+
+		json_reader_read_member(reader, "name");
+
+		current_plugin->name = g_strdup(json_reader_get_string_value(reader));
+		json_reader_end_member(reader);
+		if (g_utf8_strlen(current_plugin->name, -1) > MAX_PLUGIN_NAME_SIZE) { // -1 indicates null terminated str.
+			g_free(current_plugin);
+			plugin_array_index += 1;
+			continue; // continue attempting to deserialize the rest of the server response.
+		}
+
+		json_reader_read_member(reader, "version");
+		current_plugin->version =  g_strdup(json_reader_get_string_value(reader));
+		json_reader_end_member(reader);
+
+		json_reader_read_member(reader, "filename");
+		current_plugin->file_name = g_strdup(json_reader_get_string_value(reader));
+		json_reader_end_member(reader);
+
+		json_reader_read_member(reader, "data");
+		const gchar* data = json_reader_get_string_value(reader);
+
+
+		/* Because the data is in the form \'\bdata\' and we only want data, we must remove three characters
+		and then add one more character at the end for NULL, which is (1 + total_length - 3). */
+		current_plugin->data = g_malloc(1 + g_utf8_strlen(data, -1) - 3);
+		if (current_plugin->data == NULL) {
+			g_free(current_plugin);
+			plugin_array_index += 1;
+			continue;
+		}
+
+		/* remove \'\b and \' */
+		g_strlcpy((char*)current_plugin->data, data + 2, g_utf8_strlen(data, -1) - 2);
+		json_reader_end_member(reader);
+
+		json_reader_read_member(reader, "signature");
+		if (json_reader_get_string_value(reader) != NULL)
+		{
+			current_plugin->signature = (guchar*) g_strdup(json_reader_get_string_value(reader));
+		}
+		else
+		{
+			g_free(current_plugin);
+			plugin_array_index += 1;
+			continue; // continue attempting to deserialize the rest of the server response.
+		}
+		json_reader_end_member(reader);
+
+		g_array_append_val(data_array, current_plugin);
+		plugin_array_index += 1;
+
+		json_reader_end_element(reader); // end inspection of this plugin element
+	}
+
+}
+
+GFile* remmina_create_plugin_file(const gchar* plugin_name, const gchar* plugin_version)
+{
+	gchar file_name[MAX_PLUGIN_NAME_SIZE];
+	gchar *plugin_dir;
+
+	if (g_utf8_strlen(plugin_name, -1) > MAX_PLUGIN_NAME_SIZE) {
+		return NULL;
+	}
+
+
+	if (plugin_version != NULL){
+		plugin_dir = g_build_path("/", "/tmp", NULL);
+		snprintf(file_name, MAX_PLUGIN_NAME_SIZE, "%s/%s_%s", plugin_dir, plugin_name, plugin_version);
+	}
+	else{
+		plugin_dir = g_build_path("/", g_get_user_config_dir(), "remmina", "plugins", NULL);
+		snprintf(file_name, MAX_PLUGIN_NAME_SIZE, "%s/%s", plugin_dir, plugin_name);
+	}
+	GFile* plugin_file = g_file_new_for_path(file_name);
+	
+	if (plugin_dir != NULL) {
+		g_free(plugin_dir);
+	}
+	
+	return plugin_file;
+}
+
+gchar* remmina_plugin_manager_get_selected_plugin_list_str(GArray *selected_plugins)
+{
+	gchar *plugin_list = NULL;
+
+	for(guint i = 0; i < selected_plugins->len; i++)
+	{
+		gchar *plugin = g_array_index(selected_plugins, gchar*, i);
+
+		if (i == 0)
+		{
+			plugin_list = g_strdup(plugin);
+		}
+		else
+		{
+			plugin_list = g_strconcat(plugin_list, ", ", plugin, NULL);
+		}
+
+	}
+	return plugin_list;
+}
+
+gboolean remmina_attempt_to_write_plugin_data_to_disk(RemminaServerPluginResponse *plugin)
+{
+	gsize decoded_len = 0;
+	guchar *decoded = g_base64_decode((gchar*) plugin->data, &decoded_len);
+
+	if (decoded == NULL) {
+		return FALSE;
+	}
+
+	gsize signature_len = 0;
+	guchar * decoded_signature = g_base64_decode((gchar*) plugin->signature, &signature_len);
+	if (decoded_signature == NULL) {
+		g_free(decoded);
+		return FALSE;
+	}
+
+	/* Create path write temporary plugin */
+	GFile* plugin_file = remmina_create_plugin_file(plugin->file_name, plugin->version);
+	if (plugin_file == NULL) {
+		g_free(decoded);
+		g_free(decoded_signature);
+		return FALSE;
+	}
+
+	/* Convert the base64 into inflated memory */
+	gsize bytes_converted = remmina_decompress_from_memory_to_file(decoded, (int) decoded_len, plugin_file);
+
+	/* Don't attempt to write file if we can't inflate anything. */
+	if (bytes_converted <= 0) {
+		g_free(decoded);
+		g_free(decoded_signature);
+		g_file_delete(plugin_file, NULL, NULL);
+		g_object_unref(plugin_file);
+		return FALSE;
+	}
+	/* Verify the signature given to us by the server*/
+	gboolean passed = remmina_verify_plugin_signature(decoded_signature, plugin_file, bytes_converted, signature_len); 
+
+	if (!passed) {
+		g_free(decoded);
+		g_free(decoded_signature);
+		g_file_delete(plugin_file, NULL, NULL);
+		g_object_unref(plugin_file);
+		return FALSE;
+	}
+
+	/* Create path to store plugin */
+	GFile* plugin_file_final = remmina_create_plugin_file(plugin->file_name, NULL);
+	if (plugin_file == NULL) {
+		g_free(decoded);
+		g_free(decoded_signature);
+		g_file_delete(plugin_file, NULL, NULL);
+		g_object_unref(plugin_file);
+		return FALSE;
+	}
+
+	GError *error = NULL; // Error for testing
+	GFileOutputStream *g_output_stream = g_file_replace(plugin_file_final, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &error);
+	if (error !=NULL) {
+		g_free(decoded);
+		g_free(decoded_signature);
+		g_file_delete(plugin_file, NULL, NULL);
+		g_object_unref(plugin_file);
+		g_file_delete(plugin_file_final, NULL, NULL);
+		g_object_unref(plugin_file_final);
+		return FALSE;
+	}
+
+	GFileIOStream *tmp_file_stream = (GFileIOStream*)g_file_read(plugin_file, NULL, NULL);
+	g_output_stream_splice((GOutputStream*)g_output_stream, (GInputStream*)tmp_file_stream, G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, NULL, NULL);
+	GFileInfo* info = g_file_query_info(plugin_file_final, G_FILE_ATTRIBUTE_STANDARD_SIZE, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, NULL);
+	gsize bytes_written = g_file_info_get_size(info);
+
+	/* Delete temporary file */
+	g_file_delete(plugin_file, NULL, NULL);
+
+	if (bytes_written != bytes_converted) {
+		g_object_unref(info);
+		g_free(decoded);
+		g_free(decoded_signature);
+		g_file_delete(plugin_file_final, NULL, NULL);
+		g_object_unref(plugin_file_final);
+		return FALSE;
+	}
+
+	if (info != NULL) {
+		g_object_unref(info);
+	}
+	g_free(decoded);
+	g_free(decoded_signature);
+	g_object_unref(g_output_stream);
+	g_object_unref(plugin_file);
+	return TRUE;
+}
+
+
+gboolean remmina_plugin_manager_parse_plugin_list(gpointer user_data)
+{
+	int index = 0;
+	JsonReader* reader = (JsonReader*)user_data;
+	if (!json_reader_read_element(reader, 0)) {
+		return FALSE;
+	}
+	if (json_reader_read_member(reader, "LIST")){
+		while (json_reader_read_element(reader, index)) {
+
+			RemminaPlugin *available_plugin = g_malloc (sizeof(RemminaPlugin));
+
+			json_reader_read_member(reader, "name");
+
+			available_plugin->name = g_strdup(json_reader_get_string_value(reader));
+
+			json_reader_end_member(reader);
+			json_reader_read_member(reader, "description");
+
+			available_plugin->description = g_strdup(json_reader_get_string_value(reader));
+
+			json_reader_end_member(reader);
+			json_reader_read_member(reader, "version");
+
+			available_plugin->version = g_strdup(json_reader_get_string_value(reader));
+
+			json_reader_end_member(reader);
+			json_reader_read_member(reader, "type");
+
+			const char *type = json_reader_get_string_value(reader);
+			if (g_strcmp0(type, "protocol") == 0)
+			{
+				available_plugin->type=REMMINA_PLUGIN_TYPE_PROTOCOL;
+			}
+			else if(g_strcmp0(type, "entry") == 0)
+			{
+				available_plugin->type=REMMINA_PLUGIN_TYPE_ENTRY;
+			}
+			else if(g_strcmp0(type, "tool") == 0)
+			{
+				available_plugin->type=REMMINA_PLUGIN_TYPE_TOOL;
+			}
+			else if(g_strcmp0(type,"pref") == 0)
+			{
+				available_plugin->type=REMMINA_PLUGIN_TYPE_PREF;
+			}
+			else if(g_strcmp0(type, "secret") == 0)
+			{
+				available_plugin->type=REMMINA_PLUGIN_TYPE_SECRET;
+			}
+			else if(g_strcmp0(type, "language_wrapper") == 0)
+			{
+				available_plugin->type=REMMINA_PLUGIN_TYPE_LANGUAGE_WRAPPER;
+			}
+			else if(g_strcmp0(type, "file") == 0)
+			{
+				available_plugin->type=REMMINA_PLUGIN_TYPE_FILE;
+			}
+			else
+			{
+				available_plugin->type=REMMINA_PLUGIN_TYPE_PREF;
+			}
+
+			json_reader_end_member(reader);
+			json_reader_read_member(reader, "domain");
+
+			available_plugin->domain = g_strdup(json_reader_get_string_value(reader));
+
+			json_reader_end_member(reader);
+
+			if(remmina_plugin_manager_verify_duplicate_plugins(available_plugin) == FALSE)
+			{
+				g_ptr_array_add(remmina_available_plugin_table, available_plugin);
+			}
+
+			json_reader_end_element(reader);
+
+			index = index + 1;
+
+		}
+	}
+	json_reader_end_member(reader);
+	json_reader_end_element(reader);
+	g_object_unref(reader);
+	return FALSE;
+}
+
+
+
+gboolean remmina_plugin_manager_download_plugins(gpointer user_data)
+{
+	int success_count = 0;
+	guint i;
+	JsonReader* reader = (JsonReader*)user_data;
+	if (!json_reader_read_element(reader, 0)) {
+		return FALSE;
+	}
+
+	GArray* data_array = g_array_new(FALSE, FALSE, sizeof(RemminaServerPluginResponse *));
+	if (json_reader_read_member(reader, "PLUGINS")){
+		remmina_append_json_objects_from_response_str(reader, data_array);
+
+		for (i = 0; i < data_array->len; i+=1) {
+			RemminaServerPluginResponse *plugin = g_array_index(data_array, RemminaServerPluginResponse *, i);
+			if (remmina_attempt_to_write_plugin_data_to_disk(plugin)) {
+				success_count += 1;
+			}
+		}
+
+		if (remmina_plugin_window != NULL && remmina_plugin_signal_data != NULL && remmina_plugin_signal_data->downloading == TRUE){
+			if(success_count == data_array->len)
+			{
+				remmina_plugin_manager_download_result_dialog(remmina_plugin_window, "Plugin download successful! Please reboot Remmina in order to apply changes.\n");
+			}
+			else if((success_count < data_array->len) && (success_count != 0))
+			{
+				remmina_plugin_manager_download_result_dialog(remmina_plugin_window, "Plugin download partially successful! Please reboot Remmina in order to apply changes.\n");
+			}
+			else
+			{
+				remmina_plugin_manager_download_result_dialog(remmina_plugin_window, "Plugin download failed.\n");
+			}
+			
+		}
+
+	}
+
+	g_array_free(data_array, TRUE); //Passing in free_segment TRUE frees the underlying elements as well as the array. 
+	json_reader_end_member(reader);
+	json_reader_end_element(reader);
+	g_object_unref(reader);
+
+	return FALSE;
+}
+
+
+/*
+ * Creates request to download selected plugins from the server
+ *
+ */
+void remmina_plugin_manager_plugin_request(GArray *selected_plugins)
+{
+	TRACE_CALL(__func__);
+	gchar *formdata, *encdata, *plugin_list, *uid;
+	JsonGenerator *g;
+	JsonObject *o;
+	JsonBuilder *b;
+
+	JsonNode *n = remmina_plugin_manager_plugin_stats_get_all();
+
+	if (n == NULL || (o = json_node_get_object(n)) == NULL)
+	{
+		formdata = "{\"UID\":\"\"}";
+	}
+	else
+	{
+		b = json_builder_new();
+
+		if(b != NULL)
+		{
+			json_builder_begin_object(b);
+
+			uid = g_strdup(json_object_get_string_member(o, "UID"));
+
+			json_builder_set_member_name(b, "UID");
+			json_builder_add_string_value(b, uid);
+
+			encdata = g_strdup(json_object_get_string_member(o, "encdata"));
+
+			json_builder_set_member_name(b, "encdata");
+			json_builder_add_string_value(b, encdata);
+
+			plugin_list = remmina_plugin_manager_get_selected_plugin_list_str(selected_plugins);
+
+			json_builder_set_member_name(b, "selected_plugins");
+			json_builder_add_string_value(b, plugin_list);
+
+			json_builder_set_member_name(b, "keyversion");
+			json_builder_add_int_value(b, 1);
+
+			json_builder_end_object(b);
+			n = json_builder_get_root(b);
+			g_object_unref(b);
+
+			g = json_generator_new();
+			json_generator_set_root(g, n);
+			formdata = json_generator_to_data(g, NULL);
+
+			g_object_unref(g);
+
+			if(plugin_list != NULL)
+			{
+				g_free(plugin_list);
+			}
+
+			json_node_free(n);
+			g_free(encdata);
+			g_free(uid);
+		}
+		else
+		{
+			json_node_free(n);
+			formdata = "{\"UID\":\"\"}";
+		}
+	}
+	remmina_curl_compose_message(formdata, "POST", DOWNLOAD_URL, NULL);
+
+
+}
+
+
+gboolean remmina_plugin_manager_verify_duplicate_plugins(RemminaPlugin *available_plugin)
+{
+	RemminaPlugin *plugin;
+	gsize i;
+	for (i = 0; i < remmina_plugin_table->len; i++) {
+		plugin = (RemminaPlugin*)g_ptr_array_index(remmina_plugin_table, i);
+		if ((g_strcmp0(plugin->name, available_plugin->name) == 0) && (g_strcmp0(plugin->version, available_plugin->version) == 0))
+		{
+			return TRUE;
+		}
+	}
+	for (i = 0; i < remmina_available_plugin_table->len; i++) {
+		plugin = (RemminaPlugin*)g_ptr_array_index(remmina_available_plugin_table, i);
+		if ((g_strcmp0(plugin->name, available_plugin->name) == 0) && (g_strcmp0(plugin->version, available_plugin->version) == 0))
+		{
+			return TRUE;
+		}
+	}
+	return FALSE;
+}
+
+
+void* remmina_plugin_manager_get_available_plugins()
+{
+	TRACE_CALL(__func__);
+
+	gchar *formdata;
+	JsonGenerator *g;
+
+	JsonNode *n = remmina_plugin_manager_plugin_stats_get_all();
+
+	if (n == NULL)
+	{
+		formdata = "{}";
+	}
+	else
+	{
+		g = json_generator_new();
+		json_generator_set_root(g, n);
+		formdata = json_generator_to_data(g, NULL);
+		g_object_unref(g);
+		json_node_free(n);
+	}
+	remmina_curl_compose_message(formdata, "POST", LIST_URL, NULL);
+	return NULL;
+}
+
+void remmina_plugin_manager_on_response(GtkDialog * dialog, gint response_id, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	SignalData *data = remmina_plugin_signal_data;
+
+	GtkListStore *store = data->store;
+	GtkWidget *label = data->label;
+	GtkWidget *spinner = data->spinner;
+
+	GtkTreeIter iter;
+	gboolean found = TRUE;
+
+	if (response_id == ON_DOWNLOAD){
+		found = FALSE;
+		data->downloading = TRUE;
+		if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter)) {
+			GArray* name_array = g_array_new(FALSE, FALSE, sizeof(gchar*));
+			do {
+				gboolean value;
+				gchar *available, *name;
+				gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 0, &value, -1);
+				gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 1, &name, -1);
+				gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 4, &available, -1);
+
+				if(value){
+					if(g_strcmp0(available, "Installed") == 0){
+						REMMINA_DEBUG("%s is already installed", name);
+					}
+					else{
+						REMMINA_DEBUG("%s can be installed!", name);
+						found = TRUE;
+						gchar *c_name = g_strdup(name);
+
+						g_array_append_val(name_array, c_name);
+
+						gtk_widget_set_visible(spinner, TRUE);
+						if (gtk_widget_get_visible(label)) {
+							continue;
+						} else {
+							gtk_widget_show(label);
+							gtk_spinner_start(GTK_SPINNER(spinner));
+						}
+					}
+				}
+				g_free(available);
+				g_free(name);
+			} while (gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter));
+			if (name_array->len > 0) {
+				remmina_plugin_manager_plugin_request(name_array);
+				g_array_free(name_array, TRUE); // free the array and element data
+
+			}
+		}
+	}
+	else{
+		gtk_widget_destroy(GTK_WIDGET(dialog));
+		remmina_plugin_window = NULL;
+	}
+	if (found == FALSE){
+		remmina_plugin_manager_download_result_dialog(remmina_plugin_window, "No plugins selected for download\n");
+	}
+}
+
+void remmina_plugin_manager_show(GtkWindow *parent)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *dialog;
+	GtkWidget *scrolledwindow;
+	GtkWidget *tree, *available_tree;
+	GtkWidget *label = gtk_label_new("Downloading...");
+	GtkCellRenderer *renderer;
+	GtkTreeViewColumn *column;
+	GtkListStore *store, *available_store;
+	SignalData* data = NULL;
+
+	if (remmina_plugin_signal_data == NULL){
+		data = malloc(sizeof(SignalData));
+	}
+	else{
+		data = remmina_plugin_signal_data;
+
+	}
+
+	if (remmina_plugin_window == NULL){
+		dialog = gtk_dialog_new_with_buttons(_("Plugins"), parent, GTK_DIALOG_DESTROY_WITH_PARENT, _("_Download"), 1, _("Close"), 2, NULL);
+		GtkWidget *spinner = gtk_spinner_new();
+
+		gtk_window_set_default_size(GTK_WINDOW(dialog), 800, 600);
+
+		scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
+		gtk_widget_show(scrolledwindow);
+		gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+		gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), scrolledwindow, TRUE, TRUE, 0);
+
+		tree = gtk_tree_view_new();
+		available_tree = gtk_tree_view_new();
+		GtkWidget* tree_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+		gtk_container_add(GTK_CONTAINER(scrolledwindow), tree_box);
+
+		gtk_box_pack_end(GTK_BOX(tree_box), available_tree, TRUE, TRUE, 0);
+		GtkLabel *label_available = (GtkLabel*)gtk_label_new("Available");
+		GtkLabel *label_installed = (GtkLabel*)gtk_label_new("Installed");
+		gtk_widget_set_halign(GTK_WIDGET(label_available), GTK_ALIGN_START);
+		gtk_widget_set_halign(GTK_WIDGET(label_installed), GTK_ALIGN_START);
+		gtk_box_pack_end(GTK_BOX(tree_box), GTK_WIDGET(label_available), TRUE, TRUE, 1);
+		gtk_box_pack_end(GTK_BOX(tree_box), tree, TRUE, TRUE, 10);
+		gtk_box_pack_end(GTK_BOX(tree_box), GTK_WIDGET(label_installed), TRUE, TRUE, 1);
+		
+		gtk_widget_show(tree);
+		gtk_widget_show(available_tree);
+		gtk_widget_show(tree_box);
+		gtk_widget_show(GTK_WIDGET(label_available));
+		gtk_widget_show(GTK_WIDGET(label_installed));
+
+		store = gtk_list_store_new(6, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
+		available_store = gtk_list_store_new(6, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
+
+		g_ptr_array_foreach(remmina_plugin_table, (GFunc)remmina_plugin_manager_show_for_each, store);
+		g_ptr_array_foreach(remmina_available_plugin_table, (GFunc)remmina_plugin_manager_show_for_each_available, available_store);
+		gtk_tree_view_set_model(GTK_TREE_VIEW(tree), GTK_TREE_MODEL(store));
+		gtk_tree_view_set_model(GTK_TREE_VIEW(available_tree), GTK_TREE_MODEL(available_store));
+
+		renderer = gtk_cell_renderer_toggle_new();
+		column = gtk_tree_view_column_new_with_attributes(_("Install"), renderer, "active", 0, NULL);
+		gtk_tree_view_column_set_resizable(column, TRUE);
+		gtk_tree_view_column_set_sort_column_id(column, 0);
+		gtk_tree_view_append_column(GTK_TREE_VIEW(available_tree), column);
+		g_signal_connect (renderer, "toggled", G_CALLBACK (remmina_plugin_manager_toggle_checkbox), available_store);
+
+		renderer = gtk_cell_renderer_text_new();
+		column = gtk_tree_view_column_new_with_attributes(_("Name"), renderer, "text", 1, NULL);
+		gtk_tree_view_column_set_resizable(column, TRUE);
+		gtk_tree_view_column_set_sort_column_id(column, 0);
+		gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
+		renderer = gtk_cell_renderer_text_new();
+		column = gtk_tree_view_column_new_with_attributes(_("Name"), renderer, "text", 1, NULL);
+		gtk_tree_view_column_set_resizable(column, TRUE);
+		gtk_tree_view_column_set_sort_column_id(column, 0);
+		gtk_tree_view_append_column(GTK_TREE_VIEW(available_tree), column);
+
+		renderer = gtk_cell_renderer_text_new();
+		column = gtk_tree_view_column_new_with_attributes(_("Type"), renderer, "text", 2, NULL);
+		gtk_tree_view_column_set_resizable(column, TRUE);
+		gtk_tree_view_column_set_sort_column_id(column, 1);
+		gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
+		renderer = gtk_cell_renderer_text_new();
+		column = gtk_tree_view_column_new_with_attributes(_("Type"), renderer, "text", 2, NULL);
+		gtk_tree_view_column_set_resizable(column, TRUE);
+		gtk_tree_view_column_set_sort_column_id(column, 1);
+		gtk_tree_view_append_column(GTK_TREE_VIEW(available_tree), column);
+
+		renderer = gtk_cell_renderer_text_new();
+		column = gtk_tree_view_column_new_with_attributes(_("Description"), renderer, "text", 3, NULL);
+		gtk_tree_view_column_set_resizable(column, TRUE);
+		gtk_tree_view_column_set_sort_column_id(column, 2);
+		gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
+		renderer = gtk_cell_renderer_text_new();
+		column = gtk_tree_view_column_new_with_attributes(_("Description"), renderer, "text", 3, NULL);
+		gtk_tree_view_column_set_resizable(column, TRUE);
+		gtk_tree_view_column_set_sort_column_id(column, 2);
+		gtk_tree_view_append_column(GTK_TREE_VIEW(available_tree), column);
+
+
+		renderer = gtk_cell_renderer_text_new();
+		column = gtk_tree_view_column_new_with_attributes(_("Version"), renderer, "text", 5, NULL);
+		gtk_tree_view_column_set_resizable(column, TRUE);
+		gtk_tree_view_column_set_sort_column_id(column, 4);
+		gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
+		renderer = gtk_cell_renderer_text_new();
+		column = gtk_tree_view_column_new_with_attributes(_("Version"), renderer, "text", 5, NULL);
+		gtk_tree_view_column_set_resizable(column, TRUE);
+		gtk_tree_view_column_set_sort_column_id(column, 4);
+		gtk_tree_view_append_column(GTK_TREE_VIEW(available_tree), column);
+
+		data->store = available_store;
+		data->label = label;
+		data->spinner = spinner;
+		data->downloading = FALSE;
+
+		g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(remmina_plugin_manager_on_response), data);
+
+		gtk_box_pack_end(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), label, FALSE, FALSE, 0);
+		gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), spinner, FALSE, FALSE, 0);
+
+	}
+	else {
+		return;
+	}
+	remmina_plugin_window = (GtkDialog*)dialog;
+	remmina_plugin_signal_data = data;
+
+	gtk_widget_show(GTK_WIDGET(dialog));
+}
+
+RemminaFilePlugin* remmina_plugin_manager_get_import_file_handler(const gchar *file)
+{
+	TRACE_CALL(__func__);
+	RemminaFilePlugin *plugin;
+	gsize i;
+
+	for (i = 0; i < remmina_plugin_table->len; i++) {
+		plugin = (RemminaFilePlugin*)g_ptr_array_index(remmina_plugin_table, i);
+
+		if (plugin->type != REMMINA_PLUGIN_TYPE_FILE)
+			continue;
+
+		if (plugin->import_test_func(plugin, file)) {
+			return plugin;
+		}
+	}
+	return NULL;
+}
+
+RemminaFilePlugin* remmina_plugin_manager_get_export_file_handler(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	RemminaFilePlugin *plugin;
+	guint i;
+
+	for (i = 0; i < remmina_plugin_table->len; i++) {
+		plugin = (RemminaFilePlugin*)g_ptr_array_index(remmina_plugin_table, i);
+		if (plugin->type != REMMINA_PLUGIN_TYPE_FILE)
+			continue;
+		if (plugin->export_test_func(plugin, remminafile)) {
+			return plugin;
+		}
+	}
+	return NULL;
+}
+
+RemminaSecretPlugin* remmina_plugin_manager_get_secret_plugin(void)
+{
+	TRACE_CALL(__func__);
+	return remmina_secret_plugin;
+}
+
+gboolean remmina_plugin_manager_query_feature_by_type(RemminaPluginType ptype, const gchar* name, RemminaProtocolFeatureType ftype)
+{
+	TRACE_CALL(__func__);
+	const RemminaProtocolFeature *feature;
+	RemminaProtocolPlugin* plugin;
+
+	plugin = (RemminaProtocolPlugin*)remmina_plugin_manager_get_plugin(ptype, name);
+
+	if (plugin == NULL) {
+		return FALSE;
+	}
+
+	for (feature = plugin->features; feature && feature->type; feature++) {
+		if (feature->type == ftype)
+			return TRUE;
+	}
+	return FALSE;
+}
+
+gboolean remmina_plugin_manager_is_encrypted_setting(RemminaProtocolPlugin *pp, const char *setting)
+{
+	TRACE_CALL(__func__);
+	GHashTable *pht;
+
+	if (encrypted_settings_cache == NULL)
+		return FALSE;
+
+	if (!(pht = g_hash_table_lookup(encrypted_settings_cache, pp->name)))
+		return FALSE;
+
+	if (!g_hash_table_lookup(pht, setting))
+		return FALSE;
+
+	return TRUE;
+}
diff --git a/src/remmina_plugin_manager.h b/src/remmina_plugin_manager.h
new file mode 100644
index 0000000..5400f2a
--- /dev/null
+++ b/src/remmina_plugin_manager.h
@@ -0,0 +1,103 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010 Vic Lee
+ * Copyright (C) 2014-2015 Antenore Gatta, Fabio Castelli, Giovanni Panozzo
+ * Copyright (C) 2016-2023 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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.
+ *
+ */
+
+#pragma once
+
+#include "remmina/plugin.h"
+#include "json-glib/json-glib.h"
+
+
+#define DOWNLOAD_URL "https://plugins.remmina.org/plugins/plugin_download"
+#define LIST_URL "https://plugins.remmina.org/plugins/get_list"
+
+#define ON_DOWNLOAD 1
+#define ON_CLOSE 2
+#define FAIL 0
+#define PARTIAL_SUCCESS 1
+#define SUCCESS 2
+#define MAX_PLUGIN_NAME_SIZE 100
+#define MAX_PLUGINS_ALLOWED_TO_DOWNLOAD 20
+
+G_BEGIN_DECLS
+
+typedef gboolean (*RemminaPluginFunc)(gchar *name, RemminaPlugin *plugin, gpointer data);
+
+void remmina_plugin_manager_init(void);
+JsonNode *remmina_plugin_manager_get_installed_plugins(void);
+RemminaPlugin *remmina_plugin_manager_get_plugin(RemminaPluginType type, const gchar *name);
+gboolean remmina_plugin_manager_query_feature_by_type(RemminaPluginType ptype, const gchar *name, RemminaProtocolFeatureType ftype);
+void remmina_plugin_manager_for_each_plugin(RemminaPluginType type, RemminaPluginFunc func, gpointer data);
+void remmina_plugin_manager_show(GtkWindow *parent);
+void remmina_plugin_manager_for_each_plugin_stdout(RemminaPluginType type, RemminaPluginFunc func, gpointer data);
+void remmina_plugin_manager_show_stdout();
+void* remmina_plugin_manager_get_available_plugins();
+gboolean remmina_plugin_manager_parse_plugin_list(gpointer user_data);
+gboolean remmina_plugin_manager_download_plugins(gpointer user_data);
+RemminaFilePlugin *remmina_plugin_manager_get_import_file_handler(const gchar *file);
+RemminaFilePlugin *remmina_plugin_manager_get_export_file_handler(RemminaFile *remminafile);
+RemminaSecretPlugin *remmina_plugin_manager_get_secret_plugin(void);
+const gchar *remmina_plugin_manager_get_canonical_setting_name(const RemminaProtocolSetting *setting);
+gboolean remmina_plugin_manager_is_encrypted_setting(RemminaProtocolPlugin *pp, const char *setting);
+gboolean remmina_gtksocket_available();
+gboolean remmina_plugin_manager_verify_duplicate_plugins(RemminaPlugin *test_plugin);
+void remmina_plugin_manager_toggle_checkbox(GtkCellRendererToggle *cell, gchar *path, GtkListStore *model);
+void remmina_plugin_manager_on_response(GtkDialog *dialog, gint response_id, gpointer user_data);
+void remmina_append_json_objects_from_response_str(JsonReader* response_str, GArray* data_array);
+guint remmina_plugin_manager_deserialize_plugin_response(GArray *name_array);
+gboolean remmina_attempt_to_write_plugin_data_to_disk(RemminaServerPluginResponse *plugin);
+GFile* remmina_create_plugin_file(const gchar* plugin_name, const gchar* plugin_version);
+JsonNode *remmina_plugin_manager_plugin_stats_get_all(void);
+extern RemminaPluginService remmina_plugin_manager_service;
+
+typedef gboolean (*RemminaPluginLoaderFunc)(RemminaPluginService*, const gchar* name);
+
+typedef struct {
+    char* filetype;
+    RemminaPluginLoaderFunc func;
+}  RemminaPluginLoader;
+
+typedef struct {
+    GtkWidget *label;
+    GtkListStore *store;
+    GtkWidget *spinner;
+    gboolean downloading;
+} SignalData;
+
+gboolean remmina_plugin_manager_loader_supported(const char *filetype);
+void remmina_plugin_manager_add_loader(char *filetype, RemminaPluginLoaderFunc func);
+
+G_END_DECLS
diff --git a/src/remmina_plugin_native.c b/src/remmina_plugin_native.c
new file mode 100644
index 0000000..a5b9682
--- /dev/null
+++ b/src/remmina_plugin_native.c
@@ -0,0 +1,95 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * 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 <glib/gi18n.h>
+#include <gio/gio.h>
+#include <string.h>
+
+#ifdef GDK_WINDOWING_X11
+#include <gdk/gdkx.h>
+#elif defined(GDK_WINDOWING_WAYLAND)
+#include <gdk/gdkwayland.h>
+#endif
+
+#include "remmina_public.h"
+#include "remmina_file_manager.h"
+#include "remmina_pref.h"
+#include "remmina_protocol_widget.h"
+#include "remmina_log.h"
+#include "remmina_widget_pool.h"
+#include "rcw.h"
+#include "remmina_public.h"
+#include "remmina_plugin_native.h"
+#include "remmina_masterthread_exec.h"
+#include "remmina/remmina_trace_calls.h"
+
+gboolean remmina_plugin_native_load(RemminaPluginService* service, const char* name)
+{
+	TRACE_CALL(__func__);
+	GModule* module;
+	RemminaPluginEntryFunc entry;
+
+	//Python plugins cannot be lazy loaded, so hande their loading seperately
+	if (strstr(name, "remmina-plugin-python_wrapper") != NULL ){
+		module = g_module_open(name, 0);
+	}
+	else{
+		module = g_module_open(name, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);
+	}
+
+	if (!module)
+	{
+		g_print("Failed to load plugin: %s.\n", name);
+		g_print("Error: %s\n", g_module_error());
+		return FALSE;
+	}
+
+	if (!g_module_symbol(module, "remmina_plugin_entry", (gpointer*)&entry))
+	{
+		g_print("Failed to locate plugin entry: %s.\n", name);
+		return FALSE;
+	}
+
+	if (!entry(service))
+	{
+		g_print("Plugin entry returned false: %s.\n", name);
+		return FALSE;
+	}
+
+	return TRUE;
+	/* We don’t close the module because we will need it throughout the process lifetime */
+}
diff --git a/src/remmina_plugin_native.h b/src/remmina_plugin_native.h
new file mode 100644
index 0000000..b36a763
--- /dev/null
+++ b/src/remmina_plugin_native.h
@@ -0,0 +1,45 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * 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.
+ *
+ */
+
+#pragma once
+
+#include "remmina_plugin_manager.h"
+
+G_BEGIN_DECLS
+
+typedef gboolean (* RemminaPluginMain)(gchar* name);
+
+gboolean remmina_plugin_native_load(RemminaPluginService* service, const char* name);
+
+G_END_DECLS
diff --git a/src/remmina_pref.c b/src/remmina_pref.c
new file mode 100644
index 0000000..a839e66
--- /dev/null
+++ b/src/remmina_pref.c
@@ -0,0 +1,1252 @@
+/*
+ * 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-2022 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2022-2023 Antenore Gatta, Giovanni Panozzo, Hiroyuki Tanaka
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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 <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/utsname.h>
+
+#include <glib/gstdio.h>
+#include <gdk/gdkkeysyms.h>
+#include <gtk/gtk.h>
+
+#include "remmina_sodium.h"
+
+#include "remmina_public.h"
+#include "remmina_string_array.h"
+#include "remmina_pref.h"
+#include "remmina_log.h"
+#include "remmina/remmina_trace_calls.h"
+
+const gchar *default_resolutions = "640x480,800x600,1024x768,1152x864,1280x960,1400x1050,1920x1080";
+const gchar *default_keystrokes = "Send hello world§hello world\\n";
+
+extern gboolean info_disable_stats;
+extern gboolean info_disable_news;
+extern gboolean info_disable_tip;
+
+gchar *remmina_keymap_file;
+static GHashTable *remmina_keymap_table = NULL;
+
+/* We could customize this further if there are more requirements */
+static const gchar *default_keymap_data = "# Please check gdk/gdkkeysyms.h for a full list of all key names or hex key values\n"
+					  "\n"
+					  "[Map Meta Keys]\n"
+					  "Super_L = Meta_L\n"
+					  "Super_R = Meta_R\n"
+					  "Meta_L = Super_L\n"
+					  "Meta_R = Super_R\n";
+
+static void remmina_pref_gen_secret(void)
+{
+	TRACE_CALL(__func__);
+	guchar s[32];
+	gint i;
+	GKeyFile *gkeyfile;
+	g_autofree gchar *content = NULL;
+	gsize length;
+
+	for (i = 0; i < 32; i++)
+		s[i] = (guchar)(randombytes_uniform(257));
+	remmina_pref.secret = g_base64_encode(s, 32);
+
+	gkeyfile = g_key_file_new();
+	g_key_file_load_from_file(gkeyfile, remmina_pref_file, G_KEY_FILE_NONE, NULL);
+	g_key_file_set_string(gkeyfile, "remmina_pref", "secret", remmina_pref.secret);
+	content = g_key_file_to_data(gkeyfile, &length, NULL);
+	g_file_set_contents(remmina_pref_file, content, length, NULL);
+
+	g_key_file_free(gkeyfile);
+}
+
+static guint remmina_pref_get_keyval_from_str(const gchar *str)
+{
+	TRACE_CALL(__func__);
+	guint k;
+
+	if (!str)
+		return 0;
+
+	k = gdk_keyval_from_name(str);
+	if (!k)
+		if (sscanf(str, "%x", &k) < 1)
+			k = 0;
+	return k;
+}
+
+static void remmina_pref_init_keymap(void)
+{
+	TRACE_CALL(__func__);
+	GKeyFile *gkeyfile;
+	gchar **groups;
+	gchar **gptr;
+	gchar **keys;
+	gchar **kptr;
+	gsize nkeys;
+	g_autofree gchar *value = NULL;
+	guint *table;
+	guint *tableptr;
+	guint k1, k2;
+
+	if (remmina_keymap_table)
+		g_hash_table_destroy(remmina_keymap_table);
+	remmina_keymap_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
+
+	gkeyfile = g_key_file_new();
+	if (!g_key_file_load_from_file(gkeyfile, remmina_keymap_file, G_KEY_FILE_NONE, NULL)) {
+		if (!g_key_file_load_from_data(gkeyfile, default_keymap_data, strlen(default_keymap_data), G_KEY_FILE_NONE,
+					       NULL)) {
+			g_print("Failed to initialize keymap table\n");
+			g_key_file_free(gkeyfile);
+			return;
+		}
+	}
+
+	groups = g_key_file_get_groups(gkeyfile, NULL);
+	gptr = groups;
+	while (*gptr) {
+		keys = g_key_file_get_keys(gkeyfile, *gptr, &nkeys, NULL);
+		table = g_new0(guint, nkeys * 2 + 1);
+		g_hash_table_insert(remmina_keymap_table, g_strdup(*gptr), table);
+
+		kptr = keys;
+		tableptr = table;
+		while (*kptr) {
+			k1 = remmina_pref_get_keyval_from_str(*kptr);
+			if (k1) {
+				value = g_key_file_get_string(gkeyfile, *gptr, *kptr, NULL);
+				k2 = remmina_pref_get_keyval_from_str(value);
+				*tableptr++ = k1;
+				*tableptr++ = k2;
+			}
+			kptr++;
+		}
+		g_strfreev(keys);
+		gptr++;
+	}
+	g_strfreev(groups);
+	g_key_file_free(gkeyfile);
+}
+
+/** @todo remmina_pref_file_do_copy and remmina_file_manager_do_copy to remmina_files_copy */
+static gboolean remmina_pref_file_do_copy(const char *src_path, const char *dst_path)
+{
+	GFile *src = g_file_new_for_path(src_path), *dst = g_file_new_for_path(dst_path);
+	/* We don’t overwrite the target if it exists, because overwrite is not set */
+	const gboolean ok = g_file_copy(src, dst, G_FILE_COPY_NONE, NULL, NULL, NULL, NULL);
+
+	g_object_unref(dst);
+	g_object_unref(src);
+
+	return ok;
+}
+
+void remmina_pref_file_load_colors(GKeyFile *gkeyfile, RemminaColorPref *color_pref)
+{
+	const struct {
+		const char *	name;
+		char **		setting;
+		char *		fallback;
+	} colors[] = {
+		{ "background",		  &color_pref->background,	     "#d5ccba" },
+		{ "cursor",		  &color_pref->cursor,		     "#45373c" },
+		{ "cursor_foreground",	  &color_pref->cursor_foreground,    "#d5ccba" },
+		{ "highlight",		  &color_pref->highlight,	     "#45373c" },
+		{ "highlight_foreground", &color_pref->highlight_foreground, "#d5ccba" },
+		{ "colorBD",		  &color_pref->colorBD,		     "#45373c" },
+		{ "foreground",		  &color_pref->foreground,	     "#45373c" },
+		{ "color0",		  &color_pref->color0,		     "#20111b" },
+		{ "color1",		  &color_pref->color1,		     "#be100e" },
+		{ "color2",		  &color_pref->color2,		     "#858162" },
+		{ "color3",		  &color_pref->color3,		     "#eaa549" },
+		{ "color4",		  &color_pref->color4,		     "#426a79" },
+		{ "color5",		  &color_pref->color5,		     "#97522c" },
+		{ "color6",		  &color_pref->color6,		     "#989a9c" },
+		{ "color7",		  &color_pref->color7,		     "#968c83" },
+		{ "color8",		  &color_pref->color8,		     "#5e5252" },
+		{ "color9",		  &color_pref->color9,		     "#be100e" },
+		{ "color10",		  &color_pref->color10,		     "#858162" },
+		{ "color11",		  &color_pref->color11,		     "#eaa549" },
+		{ "color12",		  &color_pref->color12,		     "#426a79" },
+		{ "color13",		  &color_pref->color13,		     "#97522c" },
+		{ "color14",		  &color_pref->color14,		     "#989a9c" },
+		{ "color15",		  &color_pref->color15,		     "#d5ccba" },
+	};
+
+	int i;
+
+	for (i = 0; i < (sizeof(colors) / sizeof(colors[0])); i++) {
+		if (g_key_file_has_key(gkeyfile, "ssh_colors", colors[i].name, NULL))
+			*colors[i].setting = g_key_file_get_string(gkeyfile, "ssh_colors", colors[i].name,
+								   NULL);
+		else
+			*colors[i].setting = colors[i].fallback;
+	}
+}
+
+extern gboolean disablenews;
+extern gboolean disablestats;
+
+void remmina_pref_init(void)
+{
+	TRACE_CALL(__func__);
+	GKeyFile *gkeyfile;
+	gchar *remmina_dir, *remmina_pref_path, *user_config_path;
+	const gchar *filename = "remmina.pref";
+	const gchar *colors_filename = "remmina.colors";
+	g_autofree gchar *remmina_colors_file = NULL;
+	GDir *dir;
+	const gchar *legacy = ".remmina";
+	int i;
+
+	remmina_dir = g_build_path("/", g_get_user_config_dir(), "remmina", NULL);
+	/* Create the XDG_CONFIG_HOME directory */
+	g_mkdir_with_parents(remmina_dir, 0750);
+
+	g_free(remmina_dir), remmina_dir = NULL;
+	/* Legacy ~/.remmina we copy the existing remmina.pref file inside
+	 * XDG_CONFIG_HOME */
+	remmina_dir = g_build_path("/", g_get_home_dir(), legacy, NULL);
+	if (g_file_test(remmina_dir, G_FILE_TEST_IS_DIR)) {
+		dir = g_dir_open(remmina_dir, 0, NULL);
+		remmina_pref_path = g_build_path("/", remmina_dir, filename, NULL);
+		user_config_path = g_build_path("/", g_get_user_config_dir(),
+				     "remmina", filename, NULL);
+		remmina_pref_file_do_copy(remmina_pref_path, user_config_path);
+		g_dir_close(dir);
+		g_free(remmina_pref_path);
+		g_free(user_config_path);
+	}
+
+	/* /usr/local/etc/remmina */
+	const gchar *const *dirs = g_get_system_config_dirs();
+
+	g_free(remmina_dir), remmina_dir = NULL;
+	for (i = 0; dirs[i] != NULL; ++i) {
+		remmina_dir = g_build_path("/", dirs[i], "remmina", NULL);
+		if (g_file_test(remmina_dir, G_FILE_TEST_IS_DIR)) {
+			dir = g_dir_open(remmina_dir, 0, NULL);
+			while ((filename = g_dir_read_name(dir)) != NULL) {
+				remmina_pref_path = g_build_path("/", remmina_dir, filename, NULL);
+				user_config_path = g_build_path("/", g_get_user_config_dir(),
+							"remmina", filename, NULL);
+				remmina_pref_file_do_copy(remmina_pref_path, user_config_path);
+				g_free(remmina_pref_path);
+				g_free(user_config_path);
+			}
+			g_free(remmina_dir), remmina_dir = NULL;
+			g_dir_close(dir);
+		}
+	}
+	
+	/* The last case we use  the home ~/.config/remmina */
+	if (remmina_dir != NULL)
+		g_free(remmina_dir), remmina_dir = NULL;
+	remmina_dir = g_build_path("/", g_get_user_config_dir(),
+				   "remmina", NULL);
+
+	remmina_pref_file = g_strdup_printf("%s/remmina.pref", remmina_dir);
+	/* remmina.colors */
+	remmina_colors_file = g_strdup_printf("%s/%s", remmina_dir, colors_filename);
+
+	remmina_keymap_file = g_strdup_printf("%s/remmina.keymap", remmina_dir);
+
+	g_free(remmina_dir);
+
+	gkeyfile = g_key_file_new();
+
+	g_key_file_load_from_file(gkeyfile, remmina_pref_file, G_KEY_FILE_NONE, NULL);
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "save_view_mode", NULL))
+		remmina_pref.save_view_mode = g_key_file_get_boolean(gkeyfile, "remmina_pref", "save_view_mode", NULL);
+	else
+		remmina_pref.save_view_mode = TRUE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "confirm_close", NULL))
+		remmina_pref.confirm_close = g_key_file_get_boolean(gkeyfile, "remmina_pref", "confirm_close", NULL);
+	else
+		remmina_pref.confirm_close = TRUE;
+
+	if (extrahardening)
+		remmina_pref.confirm_close = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "use_master_password", NULL)) {
+		remmina_pref.use_primary_password = g_key_file_get_boolean(gkeyfile, "remmina_pref", "use_master_password", NULL);
+	} else if (g_key_file_has_key(gkeyfile, "remmina_pref", "use_primary_password", NULL))
+		remmina_pref.use_primary_password = g_key_file_get_boolean(gkeyfile, "remmina_pref", "use_primary_password", NULL);
+	else
+		remmina_pref.use_primary_password = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "unlock_timeout", NULL))
+		remmina_pref.unlock_timeout = g_key_file_get_integer(gkeyfile, "remmina_pref", "unlock_timeout", NULL);
+	else
+		remmina_pref.unlock_timeout = 300;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "unlock_password", NULL))
+		remmina_pref.unlock_password = g_key_file_get_string(gkeyfile, "remmina_pref", "unlock_password", NULL);
+	else
+		remmina_pref.unlock_password = g_strdup("");
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "lock_connect", NULL))
+		remmina_pref.lock_connect = g_key_file_get_boolean(gkeyfile, "remmina_pref", "lock_connect", NULL);
+	else
+		remmina_pref.lock_connect = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "lock_edit", NULL))
+		remmina_pref.lock_edit = g_key_file_get_boolean(gkeyfile, "remmina_pref", "lock_edit", NULL);
+	else
+		remmina_pref.lock_edit = FALSE;
+
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "lock_view_passwords", NULL))
+		remmina_pref.lock_view_passwords = g_key_file_get_boolean(gkeyfile, "remmina_pref", "lock_view_passwords", NULL);
+	else
+		remmina_pref.lock_view_passwords = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "enc_mode", NULL))
+		remmina_pref.enc_mode = g_key_file_get_integer(gkeyfile, "remmina_pref", "enc_mode", NULL);
+	else
+		remmina_pref.enc_mode = 1;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "audit", NULL))
+		remmina_pref.audit = g_key_file_get_boolean(gkeyfile, "remmina_pref", "audit", NULL);
+	else
+		remmina_pref.audit = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "trust_all", NULL))
+		remmina_pref.trust_all = g_key_file_get_boolean(gkeyfile, "remmina_pref", "trust_all", NULL);
+	else
+		remmina_pref.trust_all = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "fullscreen_on_auto", NULL))
+		remmina_pref.fullscreen_on_auto = g_key_file_get_boolean(gkeyfile, "remmina_pref", "fullscreen_on_auto", NULL);
+	else
+		remmina_pref.fullscreen_on_auto = TRUE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "floating_toolbar_placement", NULL))
+		remmina_pref.floating_toolbar_placement = g_key_file_get_integer(gkeyfile, "remmina_pref", "floating_toolbar_placement", NULL);
+	else
+		remmina_pref.floating_toolbar_placement = FLOATING_TOOLBAR_PLACEMENT_TOP;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "prevent_snap_welcome_message", NULL))
+		remmina_pref.prevent_snap_welcome_message = g_key_file_get_boolean(gkeyfile, "remmina_pref", "prevent_snap_welcome_message", NULL);
+	else
+		remmina_pref.prevent_snap_welcome_message = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "last_quickconnect_protocol", NULL))
+		remmina_pref.last_quickconnect_protocol = g_key_file_get_string(gkeyfile, "remmina_pref", "last_quickconnect_protocol", NULL);
+	else
+		remmina_pref.last_quickconnect_protocol = g_strdup("");
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "toolbar_placement", NULL))
+		remmina_pref.toolbar_placement = g_key_file_get_integer(gkeyfile, "remmina_pref", "toolbar_placement", NULL);
+	else
+		remmina_pref.toolbar_placement = TOOLBAR_PLACEMENT_LEFT;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "always_show_tab", NULL))
+		remmina_pref.always_show_tab = g_key_file_get_boolean(gkeyfile, "remmina_pref", "always_show_tab", NULL);
+	else
+		remmina_pref.always_show_tab = TRUE;
+
+	if (extrahardening)
+		remmina_pref.always_show_tab = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "always_show_notes", NULL))
+		remmina_pref.always_show_notes = g_key_file_get_boolean(gkeyfile, "remmina_pref", "always_show_notes", NULL);
+	else
+		remmina_pref.always_show_notes = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "hide_connection_toolbar", NULL))
+		remmina_pref.hide_connection_toolbar = g_key_file_get_boolean(gkeyfile, "remmina_pref",
+									      "hide_connection_toolbar", NULL);
+	else
+		remmina_pref.hide_connection_toolbar = FALSE;
+
+	if (disabletoolbar)
+		remmina_pref.hide_connection_toolbar = TRUE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "hide_searchbar", NULL))
+		remmina_pref.hide_searchbar = g_key_file_get_boolean(gkeyfile, "remmina_pref",
+								     "hide_searchbar", NULL);
+	else
+		remmina_pref.hide_searchbar = FALSE;
+
+	if (extrahardening)
+		remmina_pref.hide_searchbar = TRUE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "default_action", NULL))
+		remmina_pref.default_action = g_key_file_get_integer(gkeyfile, "remmina_pref", "default_action", NULL);
+	else
+		remmina_pref.default_action = REMMINA_ACTION_CONNECT;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "scale_quality", NULL))
+		remmina_pref.scale_quality = g_key_file_get_integer(gkeyfile, "remmina_pref", "scale_quality", NULL);
+	else
+		remmina_pref.scale_quality = GDK_INTERP_HYPER;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "hide_toolbar", NULL))
+		remmina_pref.hide_toolbar = g_key_file_get_boolean(gkeyfile, "remmina_pref", "hide_toolbar", NULL);
+	else
+		remmina_pref.hide_toolbar = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "small_toolbutton", NULL))
+		remmina_pref.small_toolbutton = g_key_file_get_boolean(gkeyfile, "remmina_pref", "small_toolbutton", NULL);
+	else
+		remmina_pref.small_toolbutton = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "view_file_mode", NULL))
+		remmina_pref.view_file_mode = g_key_file_get_integer(gkeyfile, "remmina_pref", "view_file_mode", NULL);
+	else
+		remmina_pref.view_file_mode = REMMINA_VIEW_FILE_LIST;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "resolutions", NULL))
+		remmina_pref.resolutions = g_key_file_get_string(gkeyfile, "remmina_pref", "resolutions", NULL);
+	else
+		remmina_pref.resolutions = g_strdup(default_resolutions);
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "keystrokes", NULL))
+		remmina_pref.keystrokes = g_key_file_get_string(gkeyfile, "remmina_pref", "keystrokes", NULL);
+	else
+		remmina_pref.keystrokes = g_strdup(default_keystrokes);
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "main_width", NULL))
+		remmina_pref.main_width = MAX(600, g_key_file_get_integer(gkeyfile, "remmina_pref", "main_width", NULL));
+	else
+		remmina_pref.main_width = 600;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "main_height", NULL))
+		remmina_pref.main_height = MAX(400, g_key_file_get_integer(gkeyfile, "remmina_pref", "main_height", NULL));
+	else
+		remmina_pref.main_height = 400;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "main_maximize", NULL))
+		remmina_pref.main_maximize = g_key_file_get_boolean(gkeyfile, "remmina_pref", "main_maximize", NULL);
+	else
+		remmina_pref.main_maximize = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "main_sort_column_id", NULL))
+		remmina_pref.main_sort_column_id = g_key_file_get_integer(gkeyfile, "remmina_pref", "main_sort_column_id",
+									  NULL);
+	else
+		remmina_pref.main_sort_column_id = 1;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "main_sort_order", NULL))
+		remmina_pref.main_sort_order = g_key_file_get_integer(gkeyfile, "remmina_pref", "main_sort_order", NULL);
+	else
+		remmina_pref.main_sort_order = 0;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "expanded_group", NULL))
+		remmina_pref.expanded_group = g_key_file_get_string(gkeyfile, "remmina_pref", "expanded_group", NULL);
+	else
+		remmina_pref.expanded_group = g_strdup("");
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "toolbar_pin_down", NULL))
+		remmina_pref.toolbar_pin_down = g_key_file_get_boolean(gkeyfile, "remmina_pref", "toolbar_pin_down", NULL);
+	else
+		remmina_pref.toolbar_pin_down = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "ssh_loglevel", NULL))
+		remmina_pref.ssh_loglevel = g_key_file_get_integer(gkeyfile, "remmina_pref", "ssh_loglevel", NULL);
+	else
+		remmina_pref.ssh_loglevel = DEFAULT_SSH_LOGLEVEL;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "deny_screenshot_clipboard", NULL))
+		remmina_pref.deny_screenshot_clipboard = g_key_file_get_boolean(gkeyfile, "remmina_pref", "deny_screenshot_clipboard", NULL);
+	else
+		remmina_pref.deny_screenshot_clipboard = TRUE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "datadir_path", NULL))
+		remmina_pref.datadir_path = g_key_file_get_string(gkeyfile, "remmina_pref", "datadir_path", NULL);
+	else
+		remmina_pref.datadir_path = g_strdup("");
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "remmina_file_name", NULL))
+		remmina_pref.remmina_file_name = g_key_file_get_string(gkeyfile, "remmina_pref", "remmina_file_name", NULL);
+	else
+		remmina_pref.remmina_file_name = g_strdup("%G_%P_%N_%h");
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "screenshot_path", NULL)) {
+		remmina_pref.screenshot_path = g_key_file_get_string(gkeyfile, "remmina_pref", "screenshot_path", NULL);
+	} else {
+		remmina_pref.screenshot_path = g_get_user_special_dir(G_USER_DIRECTORY_PICTURES);
+		if (remmina_pref.screenshot_path == NULL)
+			remmina_pref.screenshot_path = g_get_home_dir();
+	}
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "screenshot_name", NULL))
+		remmina_pref.screenshot_name = g_key_file_get_string(gkeyfile, "remmina_pref", "screenshot_name", NULL);
+	else
+		remmina_pref.screenshot_name = g_strdup("remmina_%p_%h_%Y%m%d-%H%M%S");
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "ssh_parseconfig", NULL))
+		remmina_pref.ssh_parseconfig = g_key_file_get_boolean(gkeyfile, "remmina_pref", "ssh_parseconfig", NULL);
+	else
+		remmina_pref.ssh_parseconfig = DEFAULT_SSH_PARSECONFIG;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "sshtunnel_port", NULL))
+		remmina_pref.sshtunnel_port = g_key_file_get_integer(gkeyfile, "remmina_pref", "sshtunnel_port", NULL);
+	else
+		remmina_pref.sshtunnel_port = DEFAULT_SSHTUNNEL_PORT;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "ssh_tcp_keepidle", NULL))
+		remmina_pref.ssh_tcp_keepidle = g_key_file_get_integer(gkeyfile, "remmina_pref", "ssh_tcp_keepidle", NULL);
+	else
+		remmina_pref.ssh_tcp_keepidle = SSH_SOCKET_TCP_KEEPIDLE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "ssh_tcp_keepintvl", NULL))
+		remmina_pref.ssh_tcp_keepintvl = g_key_file_get_integer(gkeyfile, "remmina_pref", "ssh_tcp_keepintvl", NULL);
+	else
+		remmina_pref.ssh_tcp_keepintvl = SSH_SOCKET_TCP_KEEPINTVL;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "ssh_tcp_keepcnt", NULL))
+		remmina_pref.ssh_tcp_keepcnt = g_key_file_get_integer(gkeyfile, "remmina_pref", "ssh_tcp_keepcnt", NULL);
+	else
+		remmina_pref.ssh_tcp_keepcnt = SSH_SOCKET_TCP_KEEPCNT;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "ssh_tcp_usrtimeout", NULL))
+		remmina_pref.ssh_tcp_usrtimeout = g_key_file_get_integer(gkeyfile, "remmina_pref", "ssh_tcp_usrtimeout", NULL);
+	else
+		remmina_pref.ssh_tcp_usrtimeout = SSH_SOCKET_TCP_USER_TIMEOUT;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "applet_new_ontop", NULL))
+		remmina_pref.applet_new_ontop = g_key_file_get_boolean(gkeyfile, "remmina_pref", "applet_new_ontop", NULL);
+	else
+		remmina_pref.applet_new_ontop = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "applet_hide_count", NULL))
+		remmina_pref.applet_hide_count = g_key_file_get_boolean(gkeyfile, "remmina_pref", "applet_hide_count", NULL);
+	else
+		remmina_pref.applet_hide_count = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "applet_enable_avahi", NULL))
+		remmina_pref.applet_enable_avahi = g_key_file_get_boolean(gkeyfile, "remmina_pref", "applet_enable_avahi",
+									  NULL);
+	else
+		remmina_pref.applet_enable_avahi = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "disable_tray_icon", NULL))
+		remmina_pref.disable_tray_icon = g_key_file_get_boolean(gkeyfile, "remmina_pref", "disable_tray_icon", NULL);
+	else
+		remmina_pref.disable_tray_icon = FALSE;
+
+	if (disabletrayicon)
+		remmina_pref.disable_tray_icon = TRUE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "dark_theme", NULL))
+		remmina_pref.dark_theme = g_key_file_get_boolean(gkeyfile, "remmina_pref", "dark_theme", NULL);
+	else
+		remmina_pref.dark_theme = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "list_refresh_workaround", NULL))
+		remmina_pref.list_refresh_workaround = g_key_file_get_boolean(gkeyfile, "remmina_pref", "list_refresh_workaround", NULL);
+	else
+		remmina_pref.list_refresh_workaround = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "grab_color_switch", NULL))
+		remmina_pref.grab_color_switch = g_key_file_get_boolean(gkeyfile, "remmina_pref", "grab_color_switch", NULL);
+	else
+		remmina_pref.grab_color_switch = FALSE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "grab_color", NULL))
+		remmina_pref.grab_color = g_key_file_get_string(gkeyfile, "remmina_pref", "grab_color", NULL);
+	else
+		remmina_pref.grab_color = "#00ff00";
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "recent_maximum", NULL))
+		remmina_pref.recent_maximum = g_key_file_get_integer(gkeyfile, "remmina_pref", "recent_maximum", NULL);
+	else
+		remmina_pref.recent_maximum = 10;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "default_mode", NULL))
+		remmina_pref.default_mode = g_key_file_get_integer(gkeyfile, "remmina_pref", "default_mode", NULL);
+	else
+		remmina_pref.default_mode = 0;
+
+	if (fullscreen)
+		remmina_pref.default_mode = VIEWPORT_FULLSCREEN_MODE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "tab_mode", NULL))
+		remmina_pref.tab_mode = g_key_file_get_integer(gkeyfile, "remmina_pref", "tab_mode", NULL);
+	else
+		remmina_pref.tab_mode = 0;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "fullscreen_toolbar_visibility", NULL))
+		remmina_pref.fullscreen_toolbar_visibility = g_key_file_get_integer(gkeyfile, "remmina_pref", "fullscreen_toolbar_visibility", NULL);
+	else
+		remmina_pref.fullscreen_toolbar_visibility = FLOATING_TOOLBAR_VISIBILITY_PEEKING;
+
+	if (disabletoolbar)
+		remmina_pref.fullscreen_toolbar_visibility = FLOATING_TOOLBAR_VISIBILITY_DISABLE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "auto_scroll_step", NULL))
+		remmina_pref.auto_scroll_step = g_key_file_get_integer(gkeyfile, "remmina_pref", "auto_scroll_step", NULL);
+	else
+		remmina_pref.auto_scroll_step = 10;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "hostkey", NULL))
+		remmina_pref.hostkey = g_key_file_get_integer(gkeyfile, "remmina_pref", "hostkey", NULL);
+	else
+		remmina_pref.hostkey = GDK_KEY_Control_R;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "shortcutkey_fullscreen", NULL))
+		remmina_pref.shortcutkey_fullscreen = g_key_file_get_integer(gkeyfile, "remmina_pref", "shortcutkey_fullscreen",
+									     NULL);
+	else
+		remmina_pref.shortcutkey_fullscreen = GDK_KEY_f;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "shortcutkey_autofit", NULL))
+		remmina_pref.shortcutkey_autofit = g_key_file_get_integer(gkeyfile, "remmina_pref", "shortcutkey_autofit",
+									  NULL);
+	else
+		remmina_pref.shortcutkey_autofit = GDK_KEY_1;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "shortcutkey_nexttab", NULL))
+		remmina_pref.shortcutkey_nexttab = g_key_file_get_integer(gkeyfile, "remmina_pref", "shortcutkey_nexttab",
+									  NULL);
+	else
+		remmina_pref.shortcutkey_nexttab = GDK_KEY_Right;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "shortcutkey_prevtab", NULL))
+		remmina_pref.shortcutkey_prevtab = g_key_file_get_integer(gkeyfile, "remmina_pref", "shortcutkey_prevtab",
+									  NULL);
+	else
+		remmina_pref.shortcutkey_prevtab = GDK_KEY_Left;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "shortcutkey_scale", NULL))
+		remmina_pref.shortcutkey_scale = g_key_file_get_integer(gkeyfile, "remmina_pref", "shortcutkey_scale", NULL);
+	else
+		remmina_pref.shortcutkey_scale = GDK_KEY_s;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "shortcutkey_clipboard", NULL))
+		remmina_pref.shortcutkey_clipboard = g_key_file_get_integer(gkeyfile, "remmina_pref", "shortcutkey_clipboard", NULL);
+	else
+		remmina_pref.shortcutkey_clipboard = GDK_KEY_b;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "shortcutkey_viewonly", NULL))
+		remmina_pref.shortcutkey_viewonly = g_key_file_get_integer(gkeyfile, "remmina_pref", "shortcutkey_viewonly", NULL);
+	else
+		remmina_pref.shortcutkey_viewonly = GDK_KEY_m;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "shortcutkey_multimon", NULL))
+		remmina_pref.shortcutkey_multimon = g_key_file_get_integer(gkeyfile, "remmina_pref", "shortcutkey_multimon", NULL);
+	else
+		remmina_pref.shortcutkey_multimon = GDK_KEY_Page_Up;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "shortcutkey_grab", NULL))
+		remmina_pref.shortcutkey_grab = g_key_file_get_integer(gkeyfile, "remmina_pref", "shortcutkey_grab", NULL);
+	else
+		remmina_pref.shortcutkey_grab = GDK_KEY_Control_R;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "shortcutkey_minimize", NULL))
+		remmina_pref.shortcutkey_minimize = g_key_file_get_integer(gkeyfile, "remmina_pref", "shortcutkey_minimize", NULL);
+	else
+		remmina_pref.shortcutkey_minimize = GDK_KEY_F9;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "shortcutkey_screenshot", NULL))
+		remmina_pref.shortcutkey_screenshot = g_key_file_get_integer(gkeyfile, "remmina_pref", "shortcutkey_screenshot", NULL);
+	else
+		remmina_pref.shortcutkey_screenshot = GDK_KEY_F12;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "shortcutkey_disconnect", NULL))
+		remmina_pref.shortcutkey_disconnect = g_key_file_get_integer(gkeyfile, "remmina_pref", "shortcutkey_disconnect",
+									     NULL);
+	else
+		remmina_pref.shortcutkey_disconnect = GDK_KEY_F4;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "shortcutkey_toolbar", NULL))
+		remmina_pref.shortcutkey_toolbar = g_key_file_get_integer(gkeyfile, "remmina_pref", "shortcutkey_toolbar",
+									  NULL);
+	else
+		remmina_pref.shortcutkey_toolbar = GDK_KEY_t;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "secret", NULL))
+		remmina_pref.secret = g_key_file_get_string(gkeyfile, "remmina_pref", "secret", NULL);
+	else
+		remmina_pref.secret = NULL;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "uid", NULL))
+		remmina_pref.uid = g_key_file_get_string(gkeyfile, "remmina_pref", "uid", NULL);
+	else
+		remmina_pref.uid = NULL;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "vte_font", NULL))
+		remmina_pref.vte_font = g_key_file_get_string(gkeyfile, "remmina_pref", "vte_font", NULL);
+	else
+		remmina_pref.vte_font = 0;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "vte_allow_bold_text", NULL))
+		remmina_pref.vte_allow_bold_text = g_key_file_get_boolean(gkeyfile, "remmina_pref", "vte_allow_bold_text",
+									  NULL);
+	else
+		remmina_pref.vte_allow_bold_text = TRUE;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "vte_lines", NULL))
+		remmina_pref.vte_lines = g_key_file_get_integer(gkeyfile, "remmina_pref", "vte_lines", NULL);
+	else
+		remmina_pref.vte_lines = 512;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "vte_shortcutkey_copy", NULL))
+		remmina_pref.vte_shortcutkey_copy = g_key_file_get_integer(gkeyfile, "remmina_pref", "vte_shortcutkey_copy",
+									   NULL);
+	else
+		remmina_pref.vte_shortcutkey_copy = GDK_KEY_c;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "vte_shortcutkey_paste", NULL))
+		remmina_pref.vte_shortcutkey_paste = g_key_file_get_integer(gkeyfile, "remmina_pref", "vte_shortcutkey_paste",
+									    NULL);
+	else
+		remmina_pref.vte_shortcutkey_paste = GDK_KEY_v;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "vte_shortcutkey_select_all", NULL))
+		remmina_pref.vte_shortcutkey_select_all = g_key_file_get_integer(gkeyfile, "remmina_pref", "vte_shortcutkey_select_all",
+										 NULL);
+	else
+		remmina_pref.vte_shortcutkey_select_all = GDK_KEY_a;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "vte_shortcutkey_increase_font", NULL))
+		remmina_pref.vte_shortcutkey_increase_font = g_key_file_get_integer(gkeyfile, "remmina_pref", "vte_shortcutkey_increase_font",
+										    NULL);
+	else
+		remmina_pref.vte_shortcutkey_increase_font = GDK_KEY_Page_Up;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "vte_shortcutkey_decrease_font", NULL))
+		remmina_pref.vte_shortcutkey_decrease_font = g_key_file_get_integer(gkeyfile, "remmina_pref", "vte_shortcutkey_decrease_font",
+										    NULL);
+	else
+		remmina_pref.vte_shortcutkey_decrease_font = GDK_KEY_Page_Down;
+
+	if (g_key_file_has_key(gkeyfile, "remmina_pref", "vte_shortcutkey_search_text", NULL))
+		remmina_pref.vte_shortcutkey_search_text = g_key_file_get_integer(gkeyfile, "remmina_pref", "vte_shortcutkey_search_text",
+										  NULL);
+	else
+		remmina_pref.vte_shortcutkey_search_text = GDK_KEY_g;
+
+	remmina_pref_file_load_colors(gkeyfile, &remmina_pref.color_pref);
+
+	if (g_key_file_has_key(gkeyfile, "remmina_info", "periodic_news_last_checksum", NULL)) {
+		remmina_pref.periodic_news_last_checksum = g_key_file_get_string(gkeyfile, "remmina_info", "periodic_news_last_checksum", NULL);
+	}
+	else {
+		remmina_pref.periodic_news_last_checksum = NULL;
+	}
+
+	if (disablenews) {
+		info_disable_news = 1;
+	}
+	else if (g_key_file_has_key(gkeyfile, "remmina_info", "periodic_news_permitted", NULL)) {
+		remmina_pref.disable_news = !g_key_file_get_boolean(gkeyfile, "remmina_info", "periodic_news_permitted", NULL);
+		info_disable_news = remmina_pref.disable_news;
+	}
+	else {
+		remmina_pref.disable_news = TRUE;
+		info_disable_news = remmina_pref.disable_news;
+	}
+
+	if (disablestats) {
+		info_disable_stats = 1;
+	}
+	else if (g_key_file_has_key(gkeyfile, "remmina_info", "periodic_usage_stats_permitted", NULL)) {
+		remmina_pref.disable_stats = !g_key_file_get_boolean(gkeyfile, "remmina_info", "periodic_usage_stats_permitted", NULL);
+		info_disable_stats = remmina_pref.disable_stats;
+	}
+	else {
+		remmina_pref.disable_stats = TRUE;
+		info_disable_stats = remmina_pref.disable_stats;
+	}
+
+	if (g_key_file_has_key(gkeyfile, "remmina_info", "disable_tip", NULL)) {
+		remmina_pref.disable_tip = g_key_file_get_boolean(gkeyfile, "remmina_info", "disable_tip", NULL);
+		info_disable_tip = remmina_pref.disable_tip;
+	}
+	else {
+		remmina_pref.disable_tip = TRUE;
+		info_disable_tip = remmina_pref.disable_tip;
+	}
+
+	#ifdef DISABLE_NEWS
+	info_disable_news = 1;
+	remmina_pref.disable_news = TRUE;
+	#endif
+
+	#ifdef DISABLE_STATS
+	info_disable_stats = 1;
+	remmina_pref.disable_stats = TRUE;
+	#endif
+
+	#ifdef DISABLE_TIP
+	info_disable_tip = 1;
+	remmina_pref.disable_tip = TRUE;
+	#endif
+
+
+	if (g_key_file_has_key(gkeyfile, "remmina_info", "info_uid_prefix", NULL)) {
+		remmina_pref.info_uid_prefix = g_key_file_get_string(gkeyfile, "remmina_info", "info_uid_prefix", NULL);
+	}
+	else {
+		remmina_pref.info_uid_prefix = NULL;
+	}
+
+
+	/* If we have a color scheme file, we switch to it, GIO will merge it in the
+	 * remmina.pref file */
+	if (g_file_test(remmina_colors_file, G_FILE_TEST_IS_REGULAR)) {
+		g_key_file_load_from_file(gkeyfile, remmina_colors_file, G_KEY_FILE_NONE, NULL);
+		g_remove(remmina_colors_file);
+	}
+
+	/* Default settings */
+	if (!g_key_file_has_key(gkeyfile, "remmina", "name", NULL)) {
+		g_key_file_set_string(gkeyfile, "remmina", "name", "");
+		g_key_file_set_integer(gkeyfile, "remmina", "ignore-tls-errors", 1);
+		g_key_file_set_integer(gkeyfile, "remmina", "enable-plugins", 1);
+		remmina_pref_save();
+	}
+
+	g_key_file_free(gkeyfile);
+
+	if (remmina_pref.secret == NULL)
+		remmina_pref_gen_secret();
+
+	remmina_pref_init_keymap();
+}
+
+gboolean remmina_pref_is_rw(void)
+{
+	TRACE_CALL(__func__);
+	if (access(remmina_pref_file, W_OK) == 0)
+		return TRUE;
+	else
+		return FALSE;
+	return FALSE;
+}
+
+gboolean remmina_pref_save(void)
+{
+	TRACE_CALL(__func__);
+
+	if (remmina_pref_is_rw() == FALSE) {
+		g_debug("remmina.pref is not writable, returning");
+		return FALSE;
+	}
+	GKeyFile *gkeyfile;
+	GError *error = NULL;
+	g_autofree gchar *content = NULL;
+	gsize length;
+
+	gkeyfile = g_key_file_new();
+
+	g_key_file_load_from_file(gkeyfile, remmina_pref_file, G_KEY_FILE_NONE, NULL);
+
+	g_key_file_set_string(gkeyfile, "remmina_pref", "datadir_path", remmina_pref.datadir_path);
+	g_key_file_set_string(gkeyfile, "remmina_pref", "remmina_file_name", remmina_pref.remmina_file_name);
+	g_key_file_set_string(gkeyfile, "remmina_pref", "screenshot_path", remmina_pref.screenshot_path);
+	g_key_file_set_string(gkeyfile, "remmina_pref", "screenshot_name", remmina_pref.screenshot_name);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "deny_screenshot_clipboard", remmina_pref.deny_screenshot_clipboard);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "save_view_mode", remmina_pref.save_view_mode);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "confirm_close", remmina_pref.confirm_close);
+	if (g_key_file_remove_key(gkeyfile, "remmina_pref", "use_master_password", NULL))
+		REMMINA_DEBUG("use_master_password removed…");
+	else
+		REMMINA_INFO("use_master_password already migrated");
+#if SODIUM_VERSION_INT >= 90200
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "use_primary_password", remmina_pref.use_primary_password);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "unlock_timeout", remmina_pref.unlock_timeout);
+	g_key_file_set_string(gkeyfile, "remmina_pref", "unlock_password", remmina_pref.unlock_password);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "lock_connect", remmina_pref.lock_connect);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "lock_edit", remmina_pref.lock_edit);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "lock_view_passwords", remmina_pref.lock_view_passwords);
+#else
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "use_primary_password", FALSE);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "unlock_timeout", 0);
+	g_key_file_set_string(gkeyfile, "remmina_pref", "unlock_password", g_strdup(""));
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "lock_connect", FALSE);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "lock_edit", FALSE);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "lock_view_passwords", FALSE);
+#endif
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "enc_mode", remmina_pref.enc_mode);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "audit", remmina_pref.audit);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "trust_all", remmina_pref.trust_all);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "floating_toolbar_placement", remmina_pref.floating_toolbar_placement);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "toolbar_placement", remmina_pref.toolbar_placement);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "prevent_snap_welcome_message", remmina_pref.prevent_snap_welcome_message);
+	g_key_file_set_string(gkeyfile, "remmina_pref", "last_quickconnect_protocol", remmina_pref.last_quickconnect_protocol);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "fullscreen_on_auto", remmina_pref.fullscreen_on_auto);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "always_show_tab", remmina_pref.always_show_tab);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "always_show_notes", remmina_pref.always_show_notes);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "hide_connection_toolbar", remmina_pref.hide_connection_toolbar);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "hide_searchbar", remmina_pref.hide_searchbar);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "default_action", remmina_pref.default_action);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "scale_quality", remmina_pref.scale_quality);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "ssh_loglevel", remmina_pref.ssh_loglevel);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "ssh_parseconfig", remmina_pref.ssh_parseconfig);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "hide_toolbar", remmina_pref.hide_toolbar);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "small_toolbutton", remmina_pref.small_toolbutton);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "view_file_mode", remmina_pref.view_file_mode);
+	g_key_file_set_string(gkeyfile, "remmina_pref", "resolutions", remmina_pref.resolutions);
+	g_key_file_set_string(gkeyfile, "remmina_pref", "keystrokes", remmina_pref.keystrokes);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "main_width", remmina_pref.main_width);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "main_height", remmina_pref.main_height);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "main_maximize", remmina_pref.main_maximize);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "main_sort_column_id", remmina_pref.main_sort_column_id);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "main_sort_order", remmina_pref.main_sort_order);
+	g_key_file_set_string(gkeyfile, "remmina_pref", "expanded_group", remmina_pref.expanded_group);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "toolbar_pin_down", remmina_pref.toolbar_pin_down);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "sshtunnel_port", remmina_pref.sshtunnel_port);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "ssh_tcp_keepidle", remmina_pref.ssh_tcp_keepidle);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "ssh_tcp_keepintvl", remmina_pref.ssh_tcp_keepintvl);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "ssh_tcp_keepcnt", remmina_pref.ssh_tcp_keepcnt);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "ssh_tcp_usrtimeout", remmina_pref.ssh_tcp_usrtimeout);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "applet_new_ontop", remmina_pref.applet_new_ontop);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "applet_hide_count", remmina_pref.applet_hide_count);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "applet_enable_avahi", remmina_pref.applet_enable_avahi);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "disable_tray_icon", remmina_pref.disable_tray_icon);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "dark_theme", remmina_pref.dark_theme);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "recent_maximum", remmina_pref.recent_maximum);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "default_mode", remmina_pref.default_mode);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "tab_mode", remmina_pref.tab_mode);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "fullscreen_toolbar_visibility", remmina_pref.fullscreen_toolbar_visibility);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "auto_scroll_step", remmina_pref.auto_scroll_step);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "hostkey", remmina_pref.hostkey);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "shortcutkey_fullscreen", remmina_pref.shortcutkey_fullscreen);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "shortcutkey_autofit", remmina_pref.shortcutkey_autofit);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "shortcutkey_nexttab", remmina_pref.shortcutkey_nexttab);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "shortcutkey_prevtab", remmina_pref.shortcutkey_prevtab);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "shortcutkey_scale", remmina_pref.shortcutkey_scale);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "shortcutkey_clipboard", remmina_pref.shortcutkey_clipboard);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "shortcutkey_grab", remmina_pref.shortcutkey_grab);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "shortcutkey_multimon", remmina_pref.shortcutkey_multimon);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "shortcutkey_viewonly", remmina_pref.shortcutkey_viewonly);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "shortcutkey_screenshot", remmina_pref.shortcutkey_screenshot);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "shortcutkey_minimize", remmina_pref.shortcutkey_minimize);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "shortcutkey_disconnect", remmina_pref.shortcutkey_disconnect);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "shortcutkey_toolbar", remmina_pref.shortcutkey_toolbar);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "vte_shortcutkey_copy", remmina_pref.vte_shortcutkey_copy);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "vte_shortcutkey_paste", remmina_pref.vte_shortcutkey_paste);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "vte_shortcutkey_select_all", remmina_pref.vte_shortcutkey_select_all);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "vte_shortcutkey_increase_font", remmina_pref.vte_shortcutkey_increase_font);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "vte_shortcutkey_decrease_font", remmina_pref.vte_shortcutkey_decrease_font);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "vte_shortcutkey_search_text", remmina_pref.vte_shortcutkey_search_text);
+	g_key_file_set_string(gkeyfile, "remmina_pref", "vte_font", remmina_pref.vte_font ? remmina_pref.vte_font : "");
+	g_key_file_set_string(gkeyfile, "remmina_pref", "grab_color", remmina_pref.grab_color ? remmina_pref.grab_color : "");
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "grab_color_switch", remmina_pref.grab_color_switch);
+	g_key_file_set_boolean(gkeyfile, "remmina_pref", "vte_allow_bold_text", remmina_pref.vte_allow_bold_text);
+	g_key_file_set_integer(gkeyfile, "remmina_pref", "vte_lines", remmina_pref.vte_lines);
+	g_key_file_set_string(gkeyfile, "ssh_colors", "background", remmina_pref.color_pref.background ? remmina_pref.color_pref.background : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "cursor", remmina_pref.color_pref.cursor ? remmina_pref.color_pref.cursor : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "cursor_foreground", remmina_pref.color_pref.cursor_foreground ? remmina_pref.color_pref.cursor_foreground : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "highlight", remmina_pref.color_pref.highlight ? remmina_pref.color_pref.highlight : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "highlight_foreground", remmina_pref.color_pref.highlight_foreground ? remmina_pref.color_pref.highlight_foreground : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "colorBD", remmina_pref.color_pref.colorBD ? remmina_pref.color_pref.colorBD : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "foreground", remmina_pref.color_pref.foreground ? remmina_pref.color_pref.foreground : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "color0", remmina_pref.color_pref.color0 ? remmina_pref.color_pref.color0 : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "color1", remmina_pref.color_pref.color1 ? remmina_pref.color_pref.color1 : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "color2", remmina_pref.color_pref.color2 ? remmina_pref.color_pref.color2 : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "color3", remmina_pref.color_pref.color3 ? remmina_pref.color_pref.color3 : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "color4", remmina_pref.color_pref.color4 ? remmina_pref.color_pref.color4 : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "color5", remmina_pref.color_pref.color5 ? remmina_pref.color_pref.color5 : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "color6", remmina_pref.color_pref.color6 ? remmina_pref.color_pref.color6 : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "color7", remmina_pref.color_pref.color7 ? remmina_pref.color_pref.color7 : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "color8", remmina_pref.color_pref.color8 ? remmina_pref.color_pref.color8 : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "color9", remmina_pref.color_pref.color9 ? remmina_pref.color_pref.color9 : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "color10", remmina_pref.color_pref.color10 ? remmina_pref.color_pref.color10 : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "color11", remmina_pref.color_pref.color11 ? remmina_pref.color_pref.color11 : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "color12", remmina_pref.color_pref.color12 ? remmina_pref.color_pref.color12 : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "color13", remmina_pref.color_pref.color13 ? remmina_pref.color_pref.color13 : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "color14", remmina_pref.color_pref.color14 ? remmina_pref.color_pref.color14 : "");
+	g_key_file_set_string(gkeyfile, "ssh_colors", "color15", remmina_pref.color_pref.color15 ? remmina_pref.color_pref.color15 : "");
+	g_key_file_set_boolean(gkeyfile, "remmina_info", "periodic_news_permitted", !remmina_pref.disable_news);
+	g_key_file_set_string(gkeyfile, "remmina_info", "periodic_news_last_checksum", remmina_pref.periodic_news_last_checksum ? remmina_pref.periodic_news_last_checksum: "");
+	g_key_file_set_boolean(gkeyfile, "remmina_info", "periodic_usage_stats_permitted", !remmina_pref.disable_stats);
+	g_key_file_set_string(gkeyfile, "remmina_info", "info_uid_prefix", remmina_pref.info_uid_prefix ? remmina_pref.info_uid_prefix : "");
+	g_key_file_set_boolean(gkeyfile, "remmina_info", "disable_tip", remmina_pref.disable_tip);
+
+	/* Default settings */
+	g_key_file_set_string(gkeyfile, "remmina", "name", "");
+	g_key_file_set_integer(gkeyfile, "remmina", "ignore-tls-errors", 1);
+
+	content = g_key_file_to_data(gkeyfile, &length, NULL);
+	g_file_set_contents(remmina_pref_file, content, length, &error);
+
+	if (error != NULL) {
+		g_warning("remmina_pref_save error: %s", error->message);
+		g_clear_error(&error);
+		g_key_file_free(gkeyfile);
+		return FALSE;
+	}
+	g_key_file_free(gkeyfile);
+	return TRUE;
+}
+
+void remmina_pref_add_recent(const gchar *protocol, const gchar *server)
+{
+	TRACE_CALL(__func__);
+	RemminaStringArray *array;
+	GKeyFile *gkeyfile;
+	gchar key[20];
+	g_autofree gchar *val = NULL;
+	g_autofree gchar *content = NULL;
+	gsize length;
+
+	if (remmina_pref.recent_maximum <= 0 || server == NULL || server[0] == 0)
+		return;
+
+	/* Load original value into memory */
+	gkeyfile = g_key_file_new();
+
+	g_key_file_load_from_file(gkeyfile, remmina_pref_file, G_KEY_FILE_NONE, NULL);
+
+	g_snprintf(key, sizeof(key), "recent_%s", protocol);
+	array = remmina_string_array_new_from_allocated_string(g_key_file_get_string(gkeyfile, "remmina_pref", key, NULL));
+
+	/* Add the new value */
+	remmina_string_array_remove(array, server);
+	while (array->len >= remmina_pref.recent_maximum)
+		remmina_string_array_remove_index(array, 0);
+	remmina_string_array_add(array, server);
+
+	/* Save */
+	val = remmina_string_array_to_string(array);
+	g_key_file_set_string(gkeyfile, "remmina_pref", key, val);
+
+	content = g_key_file_to_data(gkeyfile, &length, NULL);
+	g_file_set_contents(remmina_pref_file, content, length, NULL);
+
+	g_key_file_free(gkeyfile);
+}
+
+gchar *
+remmina_pref_get_recent(const gchar *protocol)
+{
+	TRACE_CALL(__func__);
+	GKeyFile *gkeyfile;
+	gchar key[20];
+	gchar *val = NULL;
+
+	gkeyfile = g_key_file_new();
+
+	g_key_file_load_from_file(gkeyfile, remmina_pref_file, G_KEY_FILE_NONE, NULL);
+
+	g_snprintf(key, sizeof(key), "recent_%s", protocol);
+	val = g_key_file_get_string(gkeyfile, "remmina_pref", key, NULL);
+
+	g_key_file_free(gkeyfile);
+
+	return val;
+}
+
+void remmina_pref_clear_recent(void)
+{
+	TRACE_CALL(__func__);
+	GKeyFile *gkeyfile;
+	gchar **keys;
+	gint i;
+	g_autofree gchar *content = NULL;
+	gsize length;
+
+	gkeyfile = g_key_file_new();
+
+	g_key_file_load_from_file(gkeyfile, remmina_pref_file, G_KEY_FILE_NONE, NULL);
+	keys = g_key_file_get_keys(gkeyfile, "remmina_pref", NULL, NULL);
+	if (keys) {
+		for (i = 0; keys[i]; i++)
+			if (strncmp(keys[i], "recent_", 7) == 0)
+				g_key_file_set_string(gkeyfile, "remmina_pref", keys[i], "");
+		g_strfreev(keys);
+	}
+
+	content = g_key_file_to_data(gkeyfile, &length, NULL);
+	g_file_set_contents(remmina_pref_file, content, length, NULL);
+
+	g_key_file_free(gkeyfile);
+}
+
+guint *remmina_pref_keymap_get_table(const gchar *keymap)
+{
+	TRACE_CALL(__func__);
+
+	if (!keymap || keymap[0] == '\0')
+		return NULL;
+
+	return (guint *)g_hash_table_lookup(remmina_keymap_table, keymap);
+}
+
+guint remmina_pref_keymap_get_keyval(const gchar *keymap, guint keyval)
+{
+	TRACE_CALL(__func__);
+	guint *table;
+	gint i;
+
+	if (!keymap || keymap[0] == '\0')
+		return keyval;
+
+	table = (guint *)g_hash_table_lookup(remmina_keymap_table, keymap);
+	if (!table)
+		return keyval;
+	for (i = 0; table[i] > 0; i += 2)
+		if (table[i] == keyval)
+			return table[i + 1];
+	return keyval;
+}
+
+gchar **
+remmina_pref_keymap_groups(void)
+{
+	TRACE_CALL(__func__);
+	GList *list;
+	guint len;
+	gchar **keys;
+	guint i;
+
+	list = g_hash_table_get_keys(remmina_keymap_table);
+	len = g_list_length(list);
+
+	keys = g_new0(gchar *, (len + 1) * 2 + 1);
+	keys[0] = g_strdup("");
+	keys[1] = g_strdup("");
+	for (i = 0; i < len; i++) {
+		keys[(i + 1) * 2] = g_strdup((gchar *)g_list_nth_data(list, i));
+		keys[(i + 1) * 2 + 1] = g_strdup((gchar *)g_list_nth_data(list, i));
+	}
+	g_list_free(list);
+
+	return keys;
+}
+
+gint remmina_pref_get_scale_quality(void)
+{
+	TRACE_CALL(__func__);
+	/* Paranoid programming */
+	if (remmina_pref.scale_quality < 0)
+		remmina_pref.scale_quality = 0;
+	return remmina_pref.scale_quality;
+}
+
+gint remmina_pref_get_ssh_loglevel(void)
+{
+	TRACE_CALL(__func__);
+	return remmina_pref.ssh_loglevel;
+}
+
+gboolean remmina_pref_get_ssh_parseconfig(void)
+{
+	TRACE_CALL(__func__);
+	return remmina_pref.ssh_parseconfig;
+}
+
+gint remmina_pref_get_sshtunnel_port(void)
+{
+	TRACE_CALL(__func__);
+	return remmina_pref.sshtunnel_port;
+}
+
+gint remmina_pref_get_ssh_tcp_keepidle(void)
+{
+	TRACE_CALL(__func__);
+	return remmina_pref.ssh_tcp_keepidle;
+}
+
+gint remmina_pref_get_ssh_tcp_keepintvl(void)
+{
+	TRACE_CALL(__func__);
+	return remmina_pref.ssh_tcp_keepintvl;
+}
+
+gint remmina_pref_get_ssh_tcp_keepcnt(void)
+{
+	TRACE_CALL(__func__);
+	return remmina_pref.ssh_tcp_keepcnt;
+}
+
+gint remmina_pref_get_ssh_tcp_usrtimeout(void)
+{
+	TRACE_CALL(__func__);
+	return remmina_pref.ssh_tcp_usrtimeout;
+}
+
+void remmina_pref_set_value(const gchar *key, const gchar *value)
+{
+	TRACE_CALL(__func__);
+	GKeyFile *gkeyfile;
+	gsize length;
+
+	gkeyfile = g_key_file_new();
+	if (g_key_file_load_from_file(gkeyfile, remmina_pref_file, G_KEY_FILE_NONE, NULL)) {
+		g_key_file_set_string(gkeyfile, "remmina_pref", key, value);
+		gchar *content = g_key_file_to_data(gkeyfile, &length, NULL);
+		if (g_file_set_contents(remmina_pref_file, content, length, NULL)) {
+			g_free(content);
+		} else {
+			REMMINA_WARNING("Cannot save Remmina preferences");
+			REMMINA_WARNING("Key was \"%s\", and value \"%s\"", key, value);
+		}
+		g_key_file_free(gkeyfile);
+	} else {
+		REMMINA_WARNING("Cannot load Remmina preferences file");
+	}
+}
+
+gchar *remmina_pref_get_value(const gchar *key)
+{
+	TRACE_CALL(__func__);
+	GKeyFile *gkeyfile;
+	gchar *value = NULL;
+
+	gkeyfile = g_key_file_new();
+	g_key_file_load_from_file(gkeyfile, remmina_pref_file, G_KEY_FILE_NONE, NULL);
+	value = g_key_file_get_string(gkeyfile, "remmina_pref", key, NULL);
+	g_key_file_free(gkeyfile);
+
+	return value;
+}
+
+gboolean remmina_pref_get_boolean(const gchar *key)
+{
+	TRACE_CALL(__func__);
+	GKeyFile *gkeyfile;
+	gboolean value;
+
+	gkeyfile = g_key_file_new();
+	g_key_file_load_from_file(gkeyfile, remmina_pref_file, G_KEY_FILE_NONE, NULL);
+	value = g_key_file_get_boolean(gkeyfile, "remmina_pref", key, NULL);
+	g_key_file_free(gkeyfile);
+
+	return value;
+}
diff --git a/src/remmina_pref.h b/src/remmina_pref.h
new file mode 100644
index 0000000..a0be42f
--- /dev/null
+++ b/src/remmina_pref.h
@@ -0,0 +1,295 @@
+/*
+ * 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-2022 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2022-2023 Antenore Gatta, Giovanni Panozzo, Hiroyuki Tanaka
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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.
+ *
+ */
+
+#pragma once
+#include <gtk/gtk.h>
+#include "remmina_sodium.h"
+
+#ifdef HAVE_LIBGCRYPT
+#include <gcrypt.h>
+#endif
+
+
+/*
+ * Remmina Preference Loader
+ */
+
+G_BEGIN_DECLS
+
+enum {
+	REMMINA_VIEW_FILE_LIST,
+	REMMINA_VIEW_FILE_TREE
+};
+
+enum {
+	REMMINA_ACTION_CONNECT	= 0,
+	REMMINA_ACTION_EDIT	= 1
+};
+
+enum {
+	UNDEFINED_MODE			= 0,
+	SCROLLED_WINDOW_MODE		= 1,
+	FULLSCREEN_MODE			= 2,
+	SCROLLED_FULLSCREEN_MODE	= 3,
+	VIEWPORT_FULLSCREEN_MODE	= 4
+};
+
+enum {
+	FLOATING_TOOLBAR_PLACEMENT_TOP		= 0,
+	FLOATING_TOOLBAR_PLACEMENT_BOTTOM	= 1
+};
+
+enum {
+	TOOLBAR_PLACEMENT_TOP		= 0,
+	TOOLBAR_PLACEMENT_RIGHT		= 1,
+	TOOLBAR_PLACEMENT_BOTTOM	= 2,
+	TOOLBAR_PLACEMENT_LEFT		= 3
+};
+
+enum {
+	REMMINA_TAB_BY_GROUP	= 0,
+	REMMINA_TAB_BY_PROTOCOL = 1,
+	REMMINA_TAB_ALL		= 2,
+	REMMINA_TAB_NONE	= 3
+};
+
+/* Remember to add the id 0, 4 and 5 in the remmina pref editor */
+enum {
+	RM_ENC_MODE_SECRET		= 0, /* Using libsecret */
+	RM_ENC_MODE_SODIUM_INTERACTIVE	= 1, /* Using libsodium */
+	RM_ENC_MODE_SODIUM_MODERATE	= 2, /* Using libsodium */
+	RM_ENC_MODE_SODIUM_SENSITIVE	= 3, /* Using libsodium */
+	RM_ENC_MODE_GCRYPT		= 4, /* Using GCrypt */
+	RM_ENC_MODE_NONE		= 5  /* No encryption */
+};
+
+enum {
+	FLOATING_TOOLBAR_VISIBILITY_PEEKING	= 0,
+	FLOATING_TOOLBAR_VISIBILITY_INVISIBLE	= 1, //"Invisible" corresponds to the "Hidden" option in the drop-down
+	FLOATING_TOOLBAR_VISIBILITY_DISABLE	= 2
+};
+
+typedef struct _RemminaColorPref {
+	/* Color palette for VTE terminal */
+	gchar * background;
+	gchar * cursor;
+	gchar * cursor_foreground;
+	gchar * highlight;
+	gchar * highlight_foreground;
+	gchar * colorBD;
+	gchar * foreground;
+	gchar * color0;
+	gchar * color1;
+	gchar * color2;
+	gchar * color3;
+	gchar * color4;
+	gchar * color5;
+	gchar * color6;
+	gchar * color7;
+	gchar * color8;
+	gchar * color9;
+	gchar * color10;
+	gchar * color11;
+	gchar * color12;
+	gchar * color13;
+	gchar * color14;
+	gchar * color15;
+} RemminaColorPref;
+
+typedef struct _RemminaPref {
+	/* In RemminaPrefDialog options tab */
+	const gchar *		datadir_path;
+	const gchar *		remmina_file_name;
+	const gchar *		screenshot_path;
+	gboolean		deny_screenshot_clipboard;
+	const gchar *		screenshot_name;
+	gboolean		save_view_mode;
+	gint			default_action;
+	gint			scale_quality;
+	gint			auto_scroll_step;
+	gint			recent_maximum;
+	gchar *			resolutions;
+	gchar *			keystrokes;
+	gboolean		confirm_close;
+	/* In RemminaPrefDialog appearance tab */
+	gboolean		dark_theme;
+	gboolean		list_refresh_workaround;
+	gboolean		fullscreen_on_auto;
+	gboolean		always_show_tab;
+	gboolean		always_show_notes;
+	gboolean		hide_connection_toolbar;
+	gboolean		hide_searchbar;
+	gint			default_mode;
+	gint			tab_mode;
+	gint			fullscreen_toolbar_visibility;
+	const gchar *		grab_color;
+	gboolean		grab_color_switch;
+	/* In RemminaPrefDialog applet tab */
+	gboolean		applet_new_ontop;
+	gboolean		applet_hide_count;
+	gboolean		disable_tray_icon;
+	/* In RemminaPrefDialog SSH Option tab */
+	gint			ssh_loglevel;
+	gboolean		ssh_parseconfig;
+	gint			sshtunnel_port;
+	gint			ssh_tcp_keepidle;
+	gint			ssh_tcp_keepintvl;
+	gint			ssh_tcp_keepcnt;
+	gint			ssh_tcp_usrtimeout;
+	/* In RemminaPrefDialog keyboard tab */
+	guint			hostkey;
+	guint			shortcutkey_fullscreen;
+	guint			shortcutkey_autofit;
+	guint			shortcutkey_prevtab;
+	guint			shortcutkey_clipboard;
+	guint			shortcutkey_nexttab;
+	guint			shortcutkey_dynres;
+	guint			shortcutkey_scale;
+	guint			shortcutkey_multimon;
+	guint			shortcutkey_grab;
+	guint			shortcutkey_viewonly;
+	guint			shortcutkey_screenshot;
+	guint			shortcutkey_minimize;
+	guint			shortcutkey_disconnect;
+	guint			shortcutkey_toolbar;
+	/* In RemminaPrefDialog security tab */
+	gboolean		use_primary_password;
+	const gchar *		unlock_password;
+	const gchar *		unlock_repassword;
+	gint			unlock_timeout;
+	gboolean		lock_connect;
+	gboolean		lock_edit;
+	gboolean		lock_view_passwords;
+	gint			enc_mode;
+	gboolean		audit;
+	gboolean		trust_all;
+	/* In RemminaPrefDialog terminal tab */
+	gchar *			vte_font;
+	gboolean		vte_allow_bold_text;
+	gboolean		vte_system_colors;
+	gint			vte_lines;
+	guint			vte_shortcutkey_copy;
+	guint			vte_shortcutkey_paste;
+	guint			vte_shortcutkey_select_all;
+	guint			vte_shortcutkey_increase_font;
+	guint			vte_shortcutkey_decrease_font;
+	guint			vte_shortcutkey_search_text;
+	/* In View menu */
+	gboolean		hide_toolbar;
+	gboolean		small_toolbutton;
+	gint			view_file_mode;
+	/* In tray icon */
+	gboolean		applet_enable_avahi;
+	/* Auto */
+	gint			main_width;
+	gint			main_height;
+	gboolean		main_maximize;
+	gint			main_sort_column_id;
+	gint			main_sort_order;
+	gchar *			expanded_group;
+	gboolean		toolbar_pin_down;
+	gint			floating_toolbar_placement;
+	gint			toolbar_placement;
+	gboolean		prevent_snap_welcome_message;
+	gchar *			last_quickconnect_protocol;
+
+	/* Crypto */
+	gchar *			secret;
+
+	/* UID */
+	gchar *			uid;
+
+	RemminaColorPref	color_pref;
+
+	/* Usage stats */
+	gboolean		disable_stats;
+	gchar *			info_uid_prefix;
+
+	/* Remmina news */
+	gboolean 		disable_news;
+	gchar * 		periodic_news_last_checksum;
+
+	gboolean 		disable_tip;
+
+} RemminaPref;
+
+#define DEFAULT_SSH_PARSECONFIG TRUE
+#define DEFAULT_SSHTUNNEL_PORT 4732
+#define DEFAULT_SSH_PORT 22
+#define DEFAULT_SSH_LOGLEVEL 1
+#define SSH_SOCKET_TCP_KEEPIDLE 20
+#define SSH_SOCKET_TCP_KEEPINTVL 10
+#define SSH_SOCKET_TCP_KEEPCNT 3
+#define SSH_SOCKET_TCP_USER_TIMEOUT 60000 // 60 seconds
+
+extern const gchar *default_resolutions;
+extern gchar *remmina_pref_file;
+extern gchar *remmina_colors_file;
+extern RemminaPref remmina_pref;
+extern gboolean disabletoolbar;
+extern gboolean fullscreen;
+extern gboolean extrahardening;
+extern gboolean disabletrayicon;
+
+void remmina_pref_init(void);
+gboolean remmina_pref_is_rw(void);
+gboolean remmina_pref_save(void);
+
+void remmina_pref_add_recent(const gchar *protocol, const gchar *server);
+gchar *remmina_pref_get_recent(const gchar *protocol);
+void remmina_pref_clear_recent(void);
+
+guint *remmina_pref_keymap_get_table(const gchar *keymap);
+guint remmina_pref_keymap_get_keyval(const gchar *keymap, guint keyval);
+gchar **remmina_pref_keymap_groups(void);
+
+gint remmina_pref_get_scale_quality(void);
+gint remmina_pref_get_ssh_loglevel(void);
+gboolean remmina_pref_get_ssh_parseconfig(void);
+gint remmina_pref_get_sshtunnel_port(void);
+void remmina_pref_file_load_colors(GKeyFile *gkeyfile, RemminaColorPref *color_pref);
+gint remmina_pref_get_ssh_tcp_keepidle(void);
+gint remmina_pref_get_ssh_tcp_keepintvl(void);
+gint remmina_pref_get_ssh_tcp_keepcnt(void);
+gint remmina_pref_get_ssh_tcp_usrtimeout(void);
+
+void remmina_pref_set_value(const gchar *key, const gchar *value);
+gchar *remmina_pref_get_value(const gchar *key);
+gboolean remmina_pref_get_boolean(const gchar *key);
+
+G_END_DECLS
diff --git a/src/remmina_pref_dialog.c b/src/remmina_pref_dialog.c
new file mode 100644
index 0000000..ab85f0d
--- /dev/null
+++ b/src/remmina_pref_dialog.c
@@ -0,0 +1,883 @@
+/*
+ * 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-2022 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2022-2023 Antenore Gatta, Giovanni Panozzo, Hiroyuki Tanaka
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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 <gtk/gtk.h>
+#include <glib/gi18n.h>
+#include <stdlib.h>
+#include "config.h"
+#if defined (HAVE_LIBSSH) && defined (HAVE_LIBVTE)
+#include <vte/vte.h>
+#endif
+#include "remmina_log.h"
+#include "remmina_file_manager.h"
+#include "remmina_sodium.h"
+#include "remmina_passwd.h"
+#include "remmina_public.h"
+#include "remmina_main.h"
+#include "remmina_string_list.h"
+#include "remmina_widget_pool.h"
+#include "remmina_key_chooser.h"
+#include "remmina_plugin_manager.h"
+#include "remmina_icon.h"
+#include "remmina_pref.h"
+#include "remmina_pref_dialog.h"
+#include "remmina/remmina_trace_calls.h"
+
+static RemminaPrefDialog *remmina_pref_dialog;
+
+#define GET_OBJECT(object_name) gtk_builder_get_object(remmina_pref_dialog->builder, object_name)
+
+static GActionEntry pref_actions[] = {
+	{ "close", remmina_pref_dialog_on_action_close, NULL, NULL, NULL },
+};
+
+
+/* Show a key chooser dialog */
+void remmina_pref_dialog_on_key_chooser(GtkWidget *widget, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	RemminaKeyChooserArguments *arguments;
+
+	g_return_if_fail(GTK_IS_BUTTON(widget));
+
+	arguments = remmina_key_chooser_new(GTK_WINDOW(remmina_pref_dialog->dialog), FALSE);
+	if (arguments->response != GTK_RESPONSE_CANCEL && arguments->response != GTK_RESPONSE_DELETE_EVENT) {
+		gchar *val = remmina_key_chooser_get_value(arguments->keyval, arguments->state);
+		gtk_button_set_label(GTK_BUTTON(widget), val);
+		g_free(val);
+	}
+	g_free(arguments);
+}
+
+/* Show the available resolutions list dialog */
+void remmina_pref_on_button_resolutions_clicked(GtkWidget *widget, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	GtkDialog *dialog = remmina_string_list_new(FALSE, NULL);
+
+	remmina_string_list_set_validation_func(remmina_public_resolution_validation_func);
+	remmina_string_list_set_text(remmina_pref.resolutions, TRUE);
+	remmina_string_list_set_titles(_("Resolutions"), _("Configure the available resolutions"));
+	gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(remmina_pref_dialog->dialog));
+	gtk_dialog_run(dialog);
+	g_free(remmina_pref.resolutions);
+	remmina_pref.resolutions = remmina_string_list_get_text();
+	gtk_widget_destroy(GTK_WIDGET(dialog));
+}
+
+/* Re-initialize the remmina_pref_init to reload the color scheme when a color scheme
+ * file is selected*/
+void remmina_pref_on_color_scheme_selected(GtkWidget *widget, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gchar *sourcepath;
+	gchar *remmina_dir;
+	gchar *destpath;
+	GFile *source;
+	GFile *destination;
+
+	sourcepath = gtk_file_chooser_get_filename(remmina_pref_dialog->button_term_cs);
+	source = g_file_new_for_path(sourcepath);
+
+	remmina_dir = g_build_path("/", g_get_user_config_dir(), "remmina", NULL);
+	/* /home/foo/.config/remmina */
+	destpath = g_strdup_printf("%s/remmina.colors", remmina_dir);
+	destination = g_file_new_for_path(destpath);
+
+	if (g_file_test(sourcepath, G_FILE_TEST_IS_REGULAR)) {
+		g_file_copy(source,
+			    destination,
+			    G_FILE_COPY_OVERWRITE,
+			    NULL,
+			    NULL,
+			    NULL,
+			    NULL);
+		/* Here we should reinitialize the widget */
+		gtk_file_chooser_set_file(remmina_pref_dialog->button_term_cs, source, NULL);
+	}
+	g_free(sourcepath);
+	g_free(remmina_dir);
+	g_free(destpath);
+	g_object_unref(source);
+}
+
+void remmina_pref_dialog_clear_recent(GtkWidget *widget, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	GtkDialog *dialog;
+
+	remmina_pref_clear_recent();
+	dialog = GTK_DIALOG(gtk_message_dialog_new(GTK_WINDOW(remmina_pref_dialog->dialog),
+						   GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
+						   _("Recent lists cleared.")));
+	gtk_dialog_run(dialog);
+	gtk_widget_destroy(GTK_WIDGET(dialog));
+}
+
+/* Configure custom keystrokes to send to the plugins */
+void remmina_pref_on_button_keystrokes_clicked(GtkWidget *widget, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	GtkDialog *dialog = remmina_string_list_new(TRUE, STRING_DELIMITOR2);
+
+	remmina_string_list_set_text(remmina_pref.keystrokes, TRUE);
+	remmina_string_list_set_titles(_("Keystrokes"), _("Configure the keystrokes"));
+	gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(remmina_pref_dialog->dialog));
+	gtk_dialog_run(dialog);
+	g_free(remmina_pref.keystrokes);
+	remmina_pref.keystrokes = remmina_string_list_get_text();
+	gtk_widget_destroy(GTK_WIDGET(dialog));
+}
+
+void remmina_prefdiag_on_grab_color_activated(GtkSwitch *widget, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	//REMMINA_DEBUG ("entry_grab_color %d", gtk_switch_get_active(widget));
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->entry_grab_color), gtk_switch_get_active(widget));
+}
+
+/* connect to notify::active or toggled (in this case ::toggled */
+void remmina_prefdiag_on_use_password_activated(GtkSwitch *sw, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	//REMMINA_DEBUG ("Use Primary Password %d", gtk_switch_get_active(sw));
+	if (gtk_switch_get_active(sw)) {
+		//REMMINA_DEBUG ("use_password activated");
+		gchar *unlock_password = NULL;
+		unlock_password = g_strdup(remmina_pref_get_value("unlock_password"));
+		gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->switch_security_lock_connect), TRUE);
+		gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->switch_security_lock_edit), TRUE);
+		gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->switch_security_lock_view_passwords), TRUE);
+		//REMMINA_DEBUG ("Password from preferences is: %s", unlock_password);
+		if (unlock_password == NULL || unlock_password[0] == '\0') {
+			if (remmina_passwd(GTK_WINDOW(remmina_pref_dialog->dialog), &unlock_password)) {
+			//REMMINA_DEBUG ("Password is: %s", unlock_password);
+				remmina_pref_set_value("unlock_password", g_strdup(unlock_password));
+				remmina_pref.unlock_password = g_strdup(unlock_password);
+			} else {
+				remmina_pref.unlock_password = "";
+				remmina_pref_set_value("unlock_password", "");
+			}
+		}
+		g_free(unlock_password), unlock_password = NULL;
+	} else {
+		//REMMINA_DEBUG ("use_password deactivated");
+		gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->switch_security_lock_connect), FALSE);
+		gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->switch_security_lock_edit), FALSE);
+				gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->switch_security_lock_view_passwords), FALSE);
+		remmina_pref.unlock_password = "";
+		remmina_pref_set_value("unlock_password", "");
+	}
+}
+
+void remmina_pref_dialog_on_action_close(GSimpleAction *action, GVariant *param, gpointer data)
+{
+	TRACE_CALL(__func__);
+	gtk_widget_destroy(GTK_WIDGET(remmina_pref_dialog->dialog));
+	/* Reload to use new preferences */
+	remmina_main_reload_preferences();
+}
+
+void remmina_pref_dialog_on_close_clicked(GtkWidget *widget, RemminaPrefDialog *dialog)
+{
+	TRACE_CALL(__func__);
+	gtk_widget_destroy(GTK_WIDGET(remmina_pref_dialog->dialog));
+}
+
+void remmina_pref_on_dialog_destroy(GtkWidget *widget, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gboolean b;
+	GdkRGBA color;
+	gboolean rebuild_remmina_icon = FALSE;
+
+	remmina_pref.datadir_path = gtk_file_chooser_get_filename(remmina_pref_dialog->filechooserbutton_options_datadir_path);
+	if (remmina_pref.datadir_path == NULL)
+		remmina_pref.datadir_path = g_strdup("");
+	remmina_pref.remmina_file_name = gtk_entry_get_text(remmina_pref_dialog->entry_options_file_name);
+	remmina_pref.screenshot_path = gtk_file_chooser_get_filename(remmina_pref_dialog->filechooserbutton_options_screenshots_path);
+	remmina_pref.screenshot_name = gtk_entry_get_text(remmina_pref_dialog->entry_options_screenshot_name);
+	remmina_pref.deny_screenshot_clipboard = gtk_switch_get_active(GTK_SWITCH(remmina_pref_dialog->switch_options_deny_screenshot_clipboard));
+	remmina_pref.save_view_mode = gtk_switch_get_active(GTK_SWITCH(remmina_pref_dialog->switch_options_remember_last_view_mode));
+	remmina_pref.confirm_close = gtk_switch_get_active(GTK_SWITCH(remmina_pref_dialog->switch_options_confirm_close));
+	remmina_pref.use_primary_password = gtk_switch_get_active(GTK_SWITCH(remmina_pref_dialog->switch_security_use_primary_password));
+	remmina_pref.lock_connect = gtk_switch_get_active(GTK_SWITCH(remmina_pref_dialog->switch_security_lock_connect));
+	remmina_pref.lock_edit = gtk_switch_get_active(GTK_SWITCH(remmina_pref_dialog->switch_security_lock_edit));
+	remmina_pref.lock_view_passwords = gtk_switch_get_active(GTK_SWITCH(remmina_pref_dialog->switch_security_lock_view_passwords));
+	remmina_pref.enc_mode = gtk_combo_box_get_active(remmina_pref_dialog->comboboxtext_security_enc_method);
+	remmina_pref.audit = gtk_switch_get_active(GTK_SWITCH(remmina_pref_dialog->switch_security_audit));
+	remmina_pref.trust_all = gtk_switch_get_active(GTK_SWITCH(remmina_pref_dialog->switch_security_trust_all));
+	remmina_pref.screenshot_path = gtk_file_chooser_get_filename(remmina_pref_dialog->filechooserbutton_options_screenshots_path);
+	remmina_pref.fullscreen_on_auto = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_appearance_fullscreen_on_auto));
+	remmina_pref.always_show_tab = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_appearance_show_tabs));
+	remmina_pref.always_show_notes = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_appearance_show_notes));
+	remmina_pref.hide_connection_toolbar = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_appearance_hide_toolbar));
+	remmina_pref.hide_searchbar = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_appearance_hide_searchbar));
+	remmina_pref.disable_news = gtk_switch_get_active(GTK_SWITCH(remmina_pref_dialog->switch_disable_news));
+	remmina_pref.disable_stats = gtk_switch_get_active(GTK_SWITCH(remmina_pref_dialog->switch_disable_stats));
+	remmina_pref.disable_tip = gtk_switch_get_active(GTK_SWITCH(remmina_pref_dialog->switch_disable_tip));
+	remmina_pref.default_action = gtk_combo_box_get_active(remmina_pref_dialog->comboboxtext_options_double_click);
+	remmina_pref.default_mode = gtk_combo_box_get_active(remmina_pref_dialog->comboboxtext_appearance_view_mode);
+	remmina_pref.tab_mode = gtk_combo_box_get_active(remmina_pref_dialog->comboboxtext_appearance_tab_interface);
+	remmina_pref.fullscreen_toolbar_visibility = gtk_combo_box_get_active(remmina_pref_dialog->comboboxtext_appearance_fullscreen_toolbar_visibility);
+	remmina_pref.scale_quality = gtk_combo_box_get_active(remmina_pref_dialog->comboboxtext_options_scale_quality);
+	remmina_pref.ssh_loglevel = gtk_combo_box_get_active(remmina_pref_dialog->comboboxtext_options_ssh_loglevel);
+	remmina_pref.sshtunnel_port = atoi(gtk_entry_get_text(remmina_pref_dialog->entry_options_ssh_port));
+	if (remmina_pref.sshtunnel_port <= 0)
+		remmina_pref.sshtunnel_port = DEFAULT_SSHTUNNEL_PORT;
+	remmina_pref.ssh_tcp_keepidle = atoi(gtk_entry_get_text(remmina_pref_dialog->entry_options_ssh_tcp_keepidle));
+	if (remmina_pref.ssh_tcp_keepidle <= 0)
+		remmina_pref.ssh_tcp_keepidle = SSH_SOCKET_TCP_KEEPIDLE;
+	remmina_pref.ssh_tcp_keepintvl = atoi(gtk_entry_get_text(remmina_pref_dialog->entry_options_ssh_tcp_keepintvl));
+	if (remmina_pref.ssh_tcp_keepintvl <= 0)
+		remmina_pref.ssh_tcp_keepintvl = SSH_SOCKET_TCP_KEEPINTVL;
+	remmina_pref.ssh_tcp_keepcnt = atoi(gtk_entry_get_text(remmina_pref_dialog->entry_options_ssh_tcp_keepcnt));
+	if (remmina_pref.ssh_tcp_keepcnt <= 0)
+		remmina_pref.ssh_tcp_keepcnt = SSH_SOCKET_TCP_KEEPCNT;
+	remmina_pref.ssh_tcp_usrtimeout = atoi(gtk_entry_get_text(remmina_pref_dialog->entry_options_ssh_tcp_usrtimeout));
+	if (remmina_pref.ssh_tcp_usrtimeout <= 0)
+		remmina_pref.ssh_tcp_usrtimeout = SSH_SOCKET_TCP_USER_TIMEOUT;
+	remmina_pref.ssh_parseconfig = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_options_ssh_parseconfig));
+#if SODIUM_VERSION_INT >= 90200
+	remmina_pref.unlock_timeout = atoi(gtk_entry_get_text(remmina_pref_dialog->unlock_timeout));
+	if (remmina_pref.unlock_timeout < 0)
+		remmina_pref.unlock_timeout = 0;
+#endif
+
+	remmina_pref.auto_scroll_step = atoi(gtk_entry_get_text(remmina_pref_dialog->entry_options_scroll));
+	if (remmina_pref.auto_scroll_step < 10)
+		remmina_pref.auto_scroll_step = 10;
+	else if (remmina_pref.auto_scroll_step > 500)
+		remmina_pref.auto_scroll_step = 500;
+
+	remmina_pref.recent_maximum = atoi(gtk_entry_get_text(remmina_pref_dialog->entry_options_recent_items));
+	if (remmina_pref.recent_maximum < 0)
+		remmina_pref.recent_maximum = 0;
+
+	remmina_pref.applet_new_ontop = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_applet_new_connection_on_top));
+	remmina_pref.applet_hide_count = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_applet_hide_totals));
+	b = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_dark_theme));
+	if (remmina_pref.dark_theme != b) {
+		remmina_pref.dark_theme = b;
+		rebuild_remmina_icon = TRUE;
+	}
+
+	remmina_pref.grab_color_switch = gtk_switch_get_active(remmina_pref_dialog->switch_appearance_grab_color);
+	remmina_pref.grab_color = gtk_entry_get_text(remmina_pref_dialog->entry_grab_color);
+
+	b = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_applet_disable_tray));
+	if (remmina_pref.disable_tray_icon != b) {
+		remmina_pref.disable_tray_icon = b;
+		rebuild_remmina_icon = TRUE;
+	}
+	if (b)
+		b = FALSE;
+	else
+		b = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_applet_start_in_tray));
+	remmina_icon_set_autostart(b);
+
+	if (rebuild_remmina_icon) {
+		remmina_icon_init();
+		remmina_icon_populate_menu();
+	}
+
+	remmina_pref.hostkey = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_host_key));
+	remmina_pref.shortcutkey_fullscreen = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_fullscreen));
+	remmina_pref.shortcutkey_autofit = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_auto_fit));
+	remmina_pref.shortcutkey_prevtab = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_switch_tab_left));
+	remmina_pref.shortcutkey_nexttab = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_switch_tab_right));
+	remmina_pref.shortcutkey_scale = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_scaled));
+	remmina_pref.shortcutkey_clipboard = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_clipboard));
+	remmina_pref.shortcutkey_multimon = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_multimon));
+	remmina_pref.shortcutkey_grab = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_grab_keyboard));
+	remmina_pref.shortcutkey_screenshot = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_screenshot));
+	remmina_pref.shortcutkey_viewonly = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_viewonly));
+	remmina_pref.shortcutkey_minimize = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_minimize));
+	remmina_pref.shortcutkey_disconnect = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_disconnect));
+	remmina_pref.shortcutkey_toolbar = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_toolbar));
+
+	g_free(remmina_pref.vte_font);
+	if (gtk_switch_get_active(GTK_SWITCH(remmina_pref_dialog->switch_terminal_font_system)))
+		remmina_pref.vte_font = NULL;
+	else
+		remmina_pref.vte_font = g_strdup(gtk_font_chooser_get_font(GTK_FONT_CHOOSER(remmina_pref_dialog->fontbutton_terminal_font)));
+	remmina_pref.vte_allow_bold_text = gtk_switch_get_active(GTK_SWITCH(remmina_pref_dialog->switch_terminal_bold));
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_foreground), &color);
+	remmina_pref.color_pref.foreground = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_background), &color);
+	remmina_pref.color_pref.background = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_cursor), &color);
+	remmina_pref.color_pref.cursor = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_cursor_foreground), &color);
+	remmina_pref.color_pref.cursor_foreground = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_highlight), &color);
+	remmina_pref.color_pref.highlight = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_highlight_foreground), &color);
+	remmina_pref.color_pref.highlight_foreground = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_colorBD), &color);
+	remmina_pref.color_pref.colorBD = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color0), &color);
+	remmina_pref.color_pref.color0 = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color1), &color);
+	remmina_pref.color_pref.color1 = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color2), &color);
+	remmina_pref.color_pref.color2 = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color3), &color);
+	remmina_pref.color_pref.color3 = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color4), &color);
+	remmina_pref.color_pref.color4 = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color5), &color);
+	remmina_pref.color_pref.color5 = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color6), &color);
+	remmina_pref.color_pref.color6 = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color7), &color);
+	remmina_pref.color_pref.color7 = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color8), &color);
+	remmina_pref.color_pref.color8 = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color9), &color);
+	remmina_pref.color_pref.color9 = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color10), &color);
+	remmina_pref.color_pref.color10 = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color11), &color);
+	remmina_pref.color_pref.color11 = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color12), &color);
+	remmina_pref.color_pref.color12 = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color13), &color);
+	remmina_pref.color_pref.color13 = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color14), &color);
+	remmina_pref.color_pref.color14 = gdk_rgba_to_string(&color);
+	gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color15), &color);
+	remmina_pref.color_pref.color15 = gdk_rgba_to_string(&color);
+	remmina_pref.vte_lines = atoi(gtk_entry_get_text(remmina_pref_dialog->entry_scrollback_lines));
+	remmina_pref.vte_shortcutkey_copy = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_copy));
+	remmina_pref.vte_shortcutkey_paste = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_paste));
+	remmina_pref.vte_shortcutkey_select_all = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_select_all));
+	remmina_pref.vte_shortcutkey_increase_font = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_increase_font));
+	remmina_pref.vte_shortcutkey_decrease_font = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_decrease_font));
+	remmina_pref.vte_shortcutkey_search_text = remmina_key_chooser_get_keyval(gtk_button_get_label(remmina_pref_dialog->button_keyboard_search_text));
+
+	remmina_pref_save();
+	remmina_pref_init();
+
+	remmina_pref_dialog->dialog = NULL;
+}
+
+static gboolean remmina_pref_dialog_add_pref_plugin(gchar *name, RemminaPlugin *plugin, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	RemminaPrefPlugin *pref_plugin;
+	GtkWidget *vbox;
+	GtkWidget *widget;
+
+	pref_plugin = (RemminaPrefPlugin *)plugin;
+
+	widget = gtk_label_new(pref_plugin->pref_label);
+	gtk_widget_set_halign(widget, GTK_ALIGN_START);
+	gtk_widget_show(widget);
+
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+	gtk_widget_show(vbox);
+	gtk_notebook_append_page(GTK_NOTEBOOK(remmina_pref_dialog->notebook_preferences), vbox, widget);
+
+	widget = pref_plugin->get_pref_body(pref_plugin);
+	gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0);
+
+	return FALSE;
+}
+
+void remmina_pref_dialog_vte_font_on_toggled(GtkSwitch *widget, RemminaPrefDialog *dialog)
+{
+	TRACE_CALL(__func__);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->fontbutton_terminal_font), !gtk_switch_get_active(widget));
+}
+
+void remmina_pref_dialog_disable_tray_icon_on_toggled(GtkWidget *widget, RemminaPrefDialog *dialog)
+{
+	TRACE_CALL(__func__);
+	gboolean b;
+
+	b = !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
+
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->checkbutton_applet_start_in_tray), b);
+}
+
+/* Helper function for remmina_pref_dialog_init() */
+static void remmina_pref_dialog_set_button_label(GtkButton *button, guint keyval)
+{
+	gchar *val;
+
+	val = remmina_key_chooser_get_value(keyval, 0);
+	gtk_button_set_label(button, val);
+	g_free(val);
+}
+
+/* Remmina preferences initialization */
+static void remmina_pref_dialog_init(void)
+{
+	TRACE_CALL(__func__);
+	gchar buf[100];
+	GdkRGBA color;
+
+#if !defined (HAVE_LIBSSH) || !defined (HAVE_LIBVTE)
+	GtkWidget *align;
+#endif
+
+#if !defined (HAVE_LIBVTE)
+	align = GTK_WIDGET(GET_OBJECT("alignment_terminal"));
+	gtk_widget_set_sensitive(align, FALSE);
+#endif
+
+#if !defined (HAVE_LIBSSH)
+	align = GTK_WIDGET(GET_OBJECT("alignment_ssh"));
+	gtk_widget_set_sensitive(align, FALSE);
+#endif
+
+	gtk_switch_set_active(GTK_SWITCH(remmina_pref_dialog->switch_options_remember_last_view_mode), remmina_pref.save_view_mode);
+	gtk_switch_set_active(GTK_SWITCH(remmina_pref_dialog->switch_options_confirm_close), remmina_pref.confirm_close);
+#if SODIUM_VERSION_INT >= 90200
+	gtk_switch_set_active(GTK_SWITCH(remmina_pref_dialog->switch_security_use_primary_password), remmina_pref.use_primary_password);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->switch_security_use_primary_password), TRUE);
+	gtk_switch_set_active(GTK_SWITCH(remmina_pref_dialog->switch_security_lock_connect), remmina_pref.lock_connect);
+	gtk_switch_set_active(GTK_SWITCH(remmina_pref_dialog->switch_security_lock_edit), remmina_pref.lock_edit);
+	gtk_switch_set_active(GTK_SWITCH(remmina_pref_dialog->switch_security_lock_view_passwords), remmina_pref.lock_view_passwords);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->unlock_timeout), TRUE);
+#else
+	gtk_switch_set_active(GTK_SWITCH(remmina_pref_dialog->switch_security_use_primary_password), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->switch_security_use_primary_password), FALSE);
+	// TRANSLATORS: Do not translate libsodium, is the name of a library
+	gtk_widget_set_tooltip_text(GTK_WIDGET(remmina_pref_dialog->switch_security_use_primary_password), _("libsodium >= 1.9.0 is required to use Primary Password"));
+	gtk_switch_set_active(GTK_SWITCH(remmina_pref_dialog->switch_security_lock_connect), FALSE);
+	gtk_switch_set_active(GTK_SWITCH(remmina_pref_dialog->switch_security_lock_edit), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->unlock_timeout), FALSE);
+#endif
+	gtk_switch_set_active(GTK_SWITCH(remmina_pref_dialog->switch_security_audit), remmina_pref.audit);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->switch_security_audit), TRUE);
+	if (remmina_pref.remmina_file_name != NULL)
+		gtk_entry_set_text(remmina_pref_dialog->entry_options_file_name, remmina_pref.remmina_file_name);
+	else
+		gtk_entry_set_text(remmina_pref_dialog->entry_options_file_name, "%G_%P_%N_%h.remmina");
+
+	gtk_switch_set_active(GTK_SWITCH(remmina_pref_dialog->switch_security_trust_all), remmina_pref.trust_all);
+
+	gtk_switch_set_active(GTK_SWITCH(remmina_pref_dialog->switch_options_deny_screenshot_clipboard), remmina_pref.deny_screenshot_clipboard);
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_appearance_fullscreen_on_auto), remmina_pref.fullscreen_on_auto);
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_appearance_show_tabs), remmina_pref.always_show_tab);
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_appearance_show_notes), remmina_pref.always_show_notes);
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_appearance_hide_toolbar), remmina_pref.hide_connection_toolbar);
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_appearance_hide_searchbar), remmina_pref.hide_searchbar);
+
+	gtk_switch_set_active(GTK_SWITCH(remmina_pref_dialog->switch_disable_news), remmina_pref.disable_news);
+#ifdef DISABLE_NEWS
+	gtk_widget_hide(GTK_WIDGET(remmina_pref_dialog->switch_disable_news));
+	gtk_widget_hide(GTK_WIDGET(remmina_pref_dialog->label_disable_news));
+#endif
+
+	gtk_switch_set_active(GTK_SWITCH(remmina_pref_dialog->switch_disable_stats), remmina_pref.disable_stats);
+#ifdef DISABLE_STATS
+	gtk_widget_hide(GTK_WIDGET(remmina_pref_dialog->switch_disable_stats));
+	gtk_widget_hide(GTK_WIDGET(remmina_pref_dialog->label_disable_stats));
+#endif
+
+#ifdef DISABLE_TIP
+	gtk_widget_hide(GTK_WIDGET(remmina_pref_dialog->switch_disable_tip));
+	gtk_widget_hide(GTK_WIDGET(remmina_pref_dialog->label_disable_tip));
+#endif
+	gtk_switch_set_active(GTK_SWITCH(remmina_pref_dialog->switch_disable_tip), remmina_pref.disable_tip);
+
+	g_snprintf(buf, sizeof(buf), "%i", remmina_pref.sshtunnel_port);
+	gtk_entry_set_text(remmina_pref_dialog->entry_options_ssh_port, buf);
+	g_snprintf(buf, sizeof(buf), "%i", remmina_pref.ssh_tcp_keepidle);
+	gtk_entry_set_text(remmina_pref_dialog->entry_options_ssh_tcp_keepidle, buf);
+	g_snprintf(buf, sizeof(buf), "%i", remmina_pref.ssh_tcp_keepintvl);
+	gtk_entry_set_text(remmina_pref_dialog->entry_options_ssh_tcp_keepintvl, buf);
+	g_snprintf(buf, sizeof(buf), "%i", remmina_pref.ssh_tcp_keepcnt);
+	gtk_entry_set_text(remmina_pref_dialog->entry_options_ssh_tcp_keepcnt, buf);
+	g_snprintf(buf, sizeof(buf), "%i", remmina_pref.ssh_tcp_usrtimeout);
+	gtk_entry_set_text(remmina_pref_dialog->entry_options_ssh_tcp_usrtimeout, buf);
+	g_snprintf(buf, sizeof(buf), "%i", remmina_pref.auto_scroll_step);
+	gtk_entry_set_text(remmina_pref_dialog->entry_options_scroll, buf);
+	g_snprintf(buf, sizeof(buf), "%i", remmina_pref.recent_maximum);
+	gtk_entry_set_text(remmina_pref_dialog->entry_options_recent_items, buf);
+
+#ifdef HAVE_LIBAPPINDICATOR
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_applet_new_connection_on_top), remmina_pref.applet_new_ontop);
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_applet_hide_totals), remmina_pref.applet_hide_count);
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_applet_disable_tray), remmina_pref.disable_tray_icon);
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_dark_theme), remmina_pref.dark_theme);
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_applet_start_in_tray), remmina_icon_is_autostart());
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->checkbutton_applet_start_in_tray), !remmina_pref.disable_tray_icon);
+#else
+	remmina_pref.disable_tray_icon = TRUE;
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_dark_theme), remmina_pref.dark_theme);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->checkbutton_applet_new_connection_on_top), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->checkbutton_applet_hide_totals), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->checkbutton_applet_disable_tray), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->checkbutton_applet_start_in_tray), FALSE);
+#endif
+
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_host_key, remmina_pref.hostkey);
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_fullscreen, remmina_pref.shortcutkey_fullscreen);
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_auto_fit, remmina_pref.shortcutkey_autofit);
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_switch_tab_left, remmina_pref.shortcutkey_prevtab);
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_switch_tab_right, remmina_pref.shortcutkey_nexttab);
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_scaled, remmina_pref.shortcutkey_scale);
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_clipboard, remmina_pref.shortcutkey_clipboard);
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_multimon, remmina_pref.shortcutkey_multimon);
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_grab_keyboard, remmina_pref.shortcutkey_grab);
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_screenshot, remmina_pref.shortcutkey_screenshot);
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_viewonly, remmina_pref.shortcutkey_viewonly);
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_minimize, remmina_pref.shortcutkey_minimize);
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_disconnect, remmina_pref.shortcutkey_disconnect);
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_toolbar, remmina_pref.shortcutkey_toolbar);
+
+	if (!(remmina_pref.vte_font && remmina_pref.vte_font[0]))
+		gtk_switch_set_active(GTK_SWITCH(remmina_pref_dialog->switch_terminal_font_system), TRUE);
+	if (remmina_pref.vte_font && remmina_pref.vte_font[0]) {
+		gtk_font_chooser_set_font(GTK_FONT_CHOOSER(remmina_pref_dialog->fontbutton_terminal_font), remmina_pref.vte_font);
+	} else {
+		gtk_font_chooser_set_font(GTK_FONT_CHOOSER(remmina_pref_dialog->fontbutton_terminal_font), "Monospace 12");
+		gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->fontbutton_terminal_font), FALSE);
+	}
+	gtk_switch_set_active(GTK_SWITCH(remmina_pref_dialog->switch_terminal_bold), remmina_pref.vte_allow_bold_text);
+
+	/* Foreground color option */
+	gdk_rgba_parse(&color, remmina_pref.color_pref.foreground);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_foreground), &color);
+	/* Background color option */
+	gdk_rgba_parse(&color, remmina_pref.color_pref.background);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_background), &color);
+	/* Cursor color option */
+	gdk_rgba_parse(&color, remmina_pref.color_pref.cursor);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_cursor), &color);
+	gdk_rgba_parse(&color, remmina_pref.color_pref.cursor_foreground);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_cursor_foreground), &color);
+	/* Highlight color option */
+	gdk_rgba_parse(&color, remmina_pref.color_pref.highlight);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_highlight), &color);
+	gdk_rgba_parse(&color, remmina_pref.color_pref.highlight_foreground);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_highlight_foreground), &color);
+	/* Bold color option */
+	gdk_rgba_parse(&color, remmina_pref.color_pref.colorBD);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_colorBD), &color);
+	/* 16 colors */
+	gdk_rgba_parse(&color, remmina_pref.color_pref.color0);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color0), &color);
+	gdk_rgba_parse(&color, remmina_pref.color_pref.color1);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color1), &color);
+	gdk_rgba_parse(&color, remmina_pref.color_pref.color2);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color2), &color);
+	gdk_rgba_parse(&color, remmina_pref.color_pref.color3);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color3), &color);
+	gdk_rgba_parse(&color, remmina_pref.color_pref.color4);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color4), &color);
+	gdk_rgba_parse(&color, remmina_pref.color_pref.color5);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color5), &color);
+	gdk_rgba_parse(&color, remmina_pref.color_pref.color6);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color6), &color);
+	gdk_rgba_parse(&color, remmina_pref.color_pref.color7);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color7), &color);
+	gdk_rgba_parse(&color, remmina_pref.color_pref.color8);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color8), &color);
+	gdk_rgba_parse(&color, remmina_pref.color_pref.color9);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color9), &color);
+	gdk_rgba_parse(&color, remmina_pref.color_pref.color10);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color10), &color);
+	gdk_rgba_parse(&color, remmina_pref.color_pref.color11);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color11), &color);
+	gdk_rgba_parse(&color, remmina_pref.color_pref.color12);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color12), &color);
+	gdk_rgba_parse(&color, remmina_pref.color_pref.color13);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color13), &color);
+	gdk_rgba_parse(&color, remmina_pref.color_pref.color14);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color14), &color);
+	gdk_rgba_parse(&color, remmina_pref.color_pref.color15);
+	gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(remmina_pref_dialog->colorbutton_color15), &color);
+#if defined (HAVE_LIBSSH) && defined (HAVE_LIBVTE)
+#if !VTE_CHECK_VERSION(0, 38, 0)
+	/* Disable color scheme buttons if old version of VTE */
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_cursor), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_cursor_foreground), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_highlight), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_highlight_foreground), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_colorBD), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_color0), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_color1), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_color2), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_color3), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_color4), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_color5), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_color6), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_color7), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_color8), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_color9), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_color10), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_color11), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_color12), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_color13), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_color14), FALSE);
+	gtk_widget_set_sensitive(GTK_WIDGET(remmina_pref_dialog->colorbutton_color15), FALSE);
+#endif
+#endif
+
+	g_snprintf(buf, sizeof(buf), "%i", remmina_pref.vte_lines);
+	gtk_entry_set_text(remmina_pref_dialog->entry_scrollback_lines, buf);
+
+#if SODIUM_VERSION_INT >= 90200
+	g_snprintf(buf, sizeof(buf), "%i", remmina_pref.unlock_timeout);
+	gtk_entry_set_text(remmina_pref_dialog->unlock_timeout, buf);
+#endif
+
+	gtk_combo_box_set_active(remmina_pref_dialog->comboboxtext_options_double_click, remmina_pref.default_action);
+	gtk_combo_box_set_active(remmina_pref_dialog->comboboxtext_appearance_view_mode, remmina_pref.default_mode);
+	gtk_combo_box_set_active(remmina_pref_dialog->comboboxtext_appearance_tab_interface, remmina_pref.tab_mode);
+	gtk_combo_box_set_active(remmina_pref_dialog->comboboxtext_security_enc_method, remmina_pref.enc_mode);
+	gtk_combo_box_set_active(remmina_pref_dialog->comboboxtext_appearance_fullscreen_toolbar_visibility, remmina_pref.fullscreen_toolbar_visibility);
+	gtk_combo_box_set_active(remmina_pref_dialog->comboboxtext_options_scale_quality, remmina_pref.scale_quality);
+	gtk_combo_box_set_active(remmina_pref_dialog->comboboxtext_options_ssh_loglevel, remmina_pref.ssh_loglevel);
+	if (remmina_pref.datadir_path != NULL && strlen(remmina_pref.datadir_path) > 0)
+		gtk_file_chooser_set_filename(remmina_pref_dialog->filechooserbutton_options_datadir_path, remmina_pref.datadir_path);
+	else
+		gtk_file_chooser_set_filename(remmina_pref_dialog->filechooserbutton_options_datadir_path, remmina_file_get_datadir());
+	if (remmina_pref.remmina_file_name != NULL)
+		gtk_entry_set_text(remmina_pref_dialog->entry_options_file_name, remmina_pref.remmina_file_name);
+	else
+		gtk_entry_set_text(remmina_pref_dialog->entry_options_file_name, "%G_%P_%N_%h.remmina");
+
+	if (remmina_pref.screenshot_path != NULL)
+		gtk_file_chooser_set_filename(remmina_pref_dialog->filechooserbutton_options_screenshots_path, remmina_pref.screenshot_path);
+	else
+		gtk_file_chooser_set_filename(remmina_pref_dialog->filechooserbutton_options_screenshots_path, g_get_home_dir());
+	if (remmina_pref.screenshot_name != NULL)
+		gtk_entry_set_text(remmina_pref_dialog->entry_options_screenshot_name, remmina_pref.screenshot_name);
+	else
+		gtk_entry_set_text(remmina_pref_dialog->entry_options_screenshot_name, "remmina_%p_%h_%Y%m%d-%H%M%S");
+
+	gtk_switch_set_active(remmina_pref_dialog->switch_appearance_grab_color, remmina_pref.grab_color_switch);
+	if (remmina_pref.grab_color != NULL)
+		gtk_entry_set_text(remmina_pref_dialog->entry_grab_color, remmina_pref.grab_color);
+	else
+		gtk_entry_set_text(remmina_pref_dialog->entry_options_file_name, "#00FF00");
+
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(remmina_pref_dialog->checkbutton_options_ssh_parseconfig), remmina_pref.ssh_parseconfig);
+
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_copy, remmina_pref.vte_shortcutkey_copy);
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_paste, remmina_pref.vte_shortcutkey_paste);
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_select_all, remmina_pref.vte_shortcutkey_select_all);
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_increase_font, remmina_pref.vte_shortcutkey_increase_font);
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_decrease_font, remmina_pref.vte_shortcutkey_decrease_font);
+	remmina_pref_dialog_set_button_label(remmina_pref_dialog->button_keyboard_search_text, remmina_pref.vte_shortcutkey_search_text);
+
+	remmina_plugin_manager_for_each_plugin(REMMINA_PLUGIN_TYPE_PREF, remmina_pref_dialog_add_pref_plugin, remmina_pref_dialog->dialog);
+
+	g_signal_connect(G_OBJECT(remmina_pref_dialog->dialog), "destroy", G_CALLBACK(remmina_pref_on_dialog_destroy), NULL);
+
+	g_object_set_data(G_OBJECT(remmina_pref_dialog->dialog), "tag", "remmina-pref-dialog");
+	remmina_widget_pool_register(GTK_WIDGET(remmina_pref_dialog->dialog));
+}
+
+/* RemminaPrefDialog instance */
+GtkWidget *remmina_pref_dialog_new(gint default_tab, GtkWindow *parent)
+{
+	TRACE_CALL(__func__);
+	GSimpleActionGroup *actions;
+	GtkAccelGroup *accel_group = NULL;
+
+	remmina_pref_dialog = g_new0(RemminaPrefDialog, 1);
+	remmina_pref_dialog->priv = g_new0(RemminaPrefDialogPriv, 1);
+
+	remmina_pref_dialog->builder = remmina_public_gtk_builder_new_from_resource("/org/remmina/Remmina/src/../data/ui/remmina_preferences.glade");
+	remmina_pref_dialog->dialog = GTK_WIDGET(gtk_builder_get_object(remmina_pref_dialog->builder, "RemminaPrefDialog"));
+	if (parent)
+		gtk_window_set_transient_for(GTK_WINDOW(remmina_pref_dialog->dialog), parent);
+
+	remmina_pref_dialog->notebook_preferences = GTK_NOTEBOOK(GET_OBJECT("notebook_preferences"));
+
+	remmina_pref_dialog->filechooserbutton_options_datadir_path = GTK_FILE_CHOOSER(GET_OBJECT("filechooserbutton_options_datadir_path"));
+	remmina_pref_dialog->entry_options_file_name = GTK_ENTRY(GET_OBJECT("entry_options_file_name"));
+	remmina_pref_dialog->filechooserbutton_options_screenshots_path = GTK_FILE_CHOOSER(GET_OBJECT("filechooserbutton_options_screenshots_path"));
+	remmina_pref_dialog->entry_options_screenshot_name = GTK_ENTRY(GET_OBJECT("entry_options_screenshot_name"));
+	remmina_pref_dialog->switch_options_deny_screenshot_clipboard = GTK_SWITCH(GET_OBJECT("switch_options_deny_screenshot_clipboard"));
+	remmina_pref_dialog->switch_options_remember_last_view_mode = GTK_SWITCH(GET_OBJECT("switch_options_remember_last_view_mode"));
+	remmina_pref_dialog->switch_options_confirm_close = GTK_SWITCH(GET_OBJECT("switch_options_confirm_close"));
+	remmina_pref_dialog->switch_security_use_primary_password = GTK_SWITCH(GET_OBJECT("switch_security_use_primary_password"));
+	remmina_pref_dialog->unlock_timeout = GTK_ENTRY(GET_OBJECT("unlock_timeout"));
+	remmina_pref_dialog->switch_security_lock_connect = GTK_SWITCH(GET_OBJECT("switch_security_lock_connect"));
+	remmina_pref_dialog->switch_security_lock_edit = GTK_SWITCH(GET_OBJECT("switch_security_lock_edit"));
+	remmina_pref_dialog->switch_security_lock_view_passwords = GTK_SWITCH(GET_OBJECT("switch_security_lock_view_passwords"));
+	remmina_pref_dialog->comboboxtext_security_enc_method = GTK_COMBO_BOX(GET_OBJECT("comboboxtext_security_enc_method"));
+
+	remmina_pref_dialog->switch_security_audit = GTK_SWITCH(GET_OBJECT("switch_security_audit"));
+	remmina_pref_dialog->switch_security_trust_all = GTK_SWITCH(GET_OBJECT("switch_security_trust_all"));
+	remmina_pref_dialog->checkbutton_options_save_settings = GTK_CHECK_BUTTON(GET_OBJECT("checkbutton_options_save_settings"));
+	remmina_pref_dialog->checkbutton_appearance_fullscreen_on_auto = GTK_CHECK_BUTTON(GET_OBJECT("checkbutton_appearance_fullscreen_on_auto"));
+	remmina_pref_dialog->checkbutton_appearance_show_tabs = GTK_CHECK_BUTTON(GET_OBJECT("checkbutton_appearance_show_tabs"));
+	remmina_pref_dialog->checkbutton_appearance_show_notes = GTK_CHECK_BUTTON(GET_OBJECT("checkbutton_appearance_show_notes"));
+	remmina_pref_dialog->checkbutton_appearance_hide_toolbar = GTK_CHECK_BUTTON(GET_OBJECT("checkbutton_appearance_hide_toolbar"));
+	remmina_pref_dialog->checkbutton_appearance_hide_searchbar = GTK_CHECK_BUTTON(GET_OBJECT("checkbutton_appearance_hide_searchbar"));
+
+	remmina_pref_dialog->switch_disable_news = GTK_SWITCH(GET_OBJECT("switch_disable_news"));
+	remmina_pref_dialog->switch_disable_stats = GTK_SWITCH(GET_OBJECT("switch_disable_stats"));
+	remmina_pref_dialog->switch_disable_tip = GTK_SWITCH(GET_OBJECT("switch_disable_tip"));
+	remmina_pref_dialog->label_disable_news = GTK_LABEL(GET_OBJECT("remmina_info_disable_news_label"));
+	remmina_pref_dialog->label_disable_stats = GTK_LABEL(GET_OBJECT("remmina_info_disable_stats_label"));
+	remmina_pref_dialog->label_disable_tip = GTK_LABEL(GET_OBJECT("remmina_info_disable_tip"));
+
+	remmina_pref_dialog->comboboxtext_options_double_click = GTK_COMBO_BOX(GET_OBJECT("comboboxtext_options_double_click"));
+	remmina_pref_dialog->comboboxtext_appearance_view_mode = GTK_COMBO_BOX(GET_OBJECT("comboboxtext_appearance_view_mode"));
+	remmina_pref_dialog->comboboxtext_appearance_tab_interface = GTK_COMBO_BOX(GET_OBJECT("comboboxtext_appearance_tab_interface"));
+	remmina_pref_dialog->comboboxtext_appearance_fullscreen_toolbar_visibility = GTK_COMBO_BOX(GET_OBJECT("comboboxtext_appearance_fullscreen_toolbar_visibility"));
+	remmina_pref_dialog->comboboxtext_options_scale_quality = GTK_COMBO_BOX(GET_OBJECT("comboboxtext_options_scale_quality"));
+	remmina_pref_dialog->checkbutton_options_ssh_parseconfig = GTK_CHECK_BUTTON(GET_OBJECT("checkbutton_options_ssh_parseconfig"));
+	remmina_pref_dialog->comboboxtext_options_ssh_loglevel = GTK_COMBO_BOX(GET_OBJECT("comboboxtext_options_ssh_loglevel"));
+	remmina_pref_dialog->entry_options_ssh_port = GTK_ENTRY(GET_OBJECT("entry_options_ssh_port"));
+	remmina_pref_dialog->entry_options_ssh_tcp_keepidle = GTK_ENTRY(GET_OBJECT("entry_options_ssh_tcp_keepidle"));
+	remmina_pref_dialog->entry_options_ssh_tcp_keepintvl = GTK_ENTRY(GET_OBJECT("entry_options_ssh_tcp_keepintvl"));
+	remmina_pref_dialog->entry_options_ssh_tcp_keepcnt = GTK_ENTRY(GET_OBJECT("entry_options_ssh_tcp_keepcnt"));
+	remmina_pref_dialog->entry_options_ssh_tcp_usrtimeout = GTK_ENTRY(GET_OBJECT("entry_options_ssh_tcp_usrtimeout"));
+	remmina_pref_dialog->entry_options_scroll = GTK_ENTRY(GET_OBJECT("entry_options_scroll"));
+	remmina_pref_dialog->entry_options_recent_items = GTK_ENTRY(GET_OBJECT("entry_options_recent_items"));
+	remmina_pref_dialog->entry_grab_color = GTK_ENTRY(GET_OBJECT("entry_grab_color"));
+	remmina_pref_dialog->switch_appearance_grab_color = GTK_SWITCH(GET_OBJECT("switch_appearance_grab_color"));
+	remmina_pref_dialog->button_options_recent_items_clear = GTK_BUTTON(GET_OBJECT("button_options_recent_items_clear"));
+
+	remmina_pref_dialog->checkbutton_applet_new_connection_on_top = GTK_CHECK_BUTTON(GET_OBJECT("checkbutton_applet_new_connection_on_top"));
+	remmina_pref_dialog->checkbutton_applet_hide_totals = GTK_CHECK_BUTTON(GET_OBJECT("checkbutton_applet_hide_totals"));
+	remmina_pref_dialog->checkbutton_applet_disable_tray = GTK_CHECK_BUTTON(GET_OBJECT("checkbutton_applet_disable_tray"));
+	remmina_pref_dialog->checkbutton_dark_theme = GTK_CHECK_BUTTON(GET_OBJECT("checkbutton_dark_theme"));
+	remmina_pref_dialog->checkbutton_applet_start_in_tray = GTK_CHECK_BUTTON(GET_OBJECT("checkbutton_applet_start_in_tray"));
+
+	remmina_pref_dialog->button_keyboard_host_key = GTK_BUTTON(GET_OBJECT("button_keyboard_host_key"));
+	remmina_pref_dialog->button_keyboard_fullscreen = GTK_BUTTON(GET_OBJECT("button_keyboard_fullscreen"));
+	remmina_pref_dialog->button_keyboard_auto_fit = GTK_BUTTON(GET_OBJECT("button_keyboard_auto_fit"));
+	remmina_pref_dialog->button_keyboard_switch_tab_left = GTK_BUTTON(GET_OBJECT("button_keyboard_switch_tab_left"));
+	remmina_pref_dialog->button_keyboard_switch_tab_right = GTK_BUTTON(GET_OBJECT("button_keyboard_switch_tabright"));
+	remmina_pref_dialog->button_keyboard_scaled = GTK_BUTTON(GET_OBJECT("button_keyboard_scaled"));
+	remmina_pref_dialog->button_keyboard_clipboard = GTK_BUTTON(GET_OBJECT("button_keyboard_clipboard"));
+	remmina_pref_dialog->button_keyboard_grab_keyboard = GTK_BUTTON(GET_OBJECT("button_keyboard_grab_keyboard"));
+	remmina_pref_dialog->button_keyboard_multimon = GTK_BUTTON(GET_OBJECT("button_keyboard_multimon"));
+	remmina_pref_dialog->button_keyboard_screenshot = GTK_BUTTON(GET_OBJECT("button_keyboard_screenshot"));
+	remmina_pref_dialog->button_keyboard_viewonly = GTK_BUTTON(GET_OBJECT("button_keyboard_viewonly"));
+	remmina_pref_dialog->button_keyboard_minimize = GTK_BUTTON(GET_OBJECT("button_keyboard_minimize"));
+	remmina_pref_dialog->button_keyboard_disconnect = GTK_BUTTON(GET_OBJECT("button_keyboard_disconnect"));
+	remmina_pref_dialog->button_keyboard_toolbar = GTK_BUTTON(GET_OBJECT("button_keyboard_toolbar"));
+
+	remmina_pref_dialog->switch_terminal_font_system = GTK_SWITCH(GET_OBJECT("switch_terminal_font_system"));
+	remmina_pref_dialog->fontbutton_terminal_font = GTK_FONT_BUTTON(GET_OBJECT("fontbutton_terminal_font"));
+	remmina_pref_dialog->switch_terminal_bold = GTK_SWITCH(GET_OBJECT("switch_terminal_bold"));
+	remmina_pref_dialog->entry_scrollback_lines = GTK_ENTRY(GET_OBJECT("entry_scrollback_lines"));
+	remmina_pref_dialog->button_keyboard_copy = GTK_BUTTON(GET_OBJECT("button_keyboard_copy"));
+	remmina_pref_dialog->button_keyboard_paste = GTK_BUTTON(GET_OBJECT("button_keyboard_paste"));
+	remmina_pref_dialog->button_keyboard_select_all = GTK_BUTTON(GET_OBJECT("button_keyboard_select_all"));
+	remmina_pref_dialog->button_keyboard_increase_font = GTK_BUTTON(GET_OBJECT("button_keyboard_increase_font"));
+	remmina_pref_dialog->button_keyboard_decrease_font = GTK_BUTTON(GET_OBJECT("button_keyboard_decrease_font"));
+	remmina_pref_dialog->button_keyboard_search_text = GTK_BUTTON(GET_OBJECT("button_keyboard_search_text"));
+	remmina_pref_dialog->label_terminal_foreground = GTK_LABEL(GET_OBJECT("label_terminal_foreground"));
+	remmina_pref_dialog->colorbutton_foreground = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_foreground"));
+	remmina_pref_dialog->label_terminal_background = GTK_LABEL(GET_OBJECT("label_terminal_background"));
+	remmina_pref_dialog->colorbutton_background = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_background"));
+	remmina_pref_dialog->label_terminal_cursor_color = GTK_LABEL(GET_OBJECT("label_terminal_cursor_color"));
+	remmina_pref_dialog->colorbutton_cursor = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_cursor"));
+	remmina_pref_dialog->colorbutton_cursor_foreground = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_cursor_foreground"));
+	remmina_pref_dialog->colorbutton_highlight = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_highlight"));
+	remmina_pref_dialog->colorbutton_highlight_foreground = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_highlight_foreground"));
+	remmina_pref_dialog->label_terminal_bold_color = GTK_LABEL(GET_OBJECT("label_terminal_bold_color"));
+	remmina_pref_dialog->colorbutton_colorBD = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_colorBD"));
+	remmina_pref_dialog->label_terminal_normal_colors = GTK_LABEL(GET_OBJECT("label_terminal_normal_colors"));
+	remmina_pref_dialog->colorbutton_color0 = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_color0"));
+	remmina_pref_dialog->colorbutton_color1 = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_color1"));
+	remmina_pref_dialog->colorbutton_color2 = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_color2"));
+	remmina_pref_dialog->colorbutton_color3 = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_color3"));
+	remmina_pref_dialog->colorbutton_color4 = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_color4"));
+	remmina_pref_dialog->colorbutton_color5 = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_color5"));
+	remmina_pref_dialog->colorbutton_color6 = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_color6"));
+	remmina_pref_dialog->colorbutton_color7 = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_color7"));
+	remmina_pref_dialog->label_terminal_bright_colors = GTK_LABEL(GET_OBJECT("label_terminal_bright_colors"));
+	remmina_pref_dialog->colorbutton_color8 = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_color8"));
+	remmina_pref_dialog->colorbutton_color9 = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_color9"));
+	remmina_pref_dialog->colorbutton_color10 = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_color10"));
+	remmina_pref_dialog->colorbutton_color11 = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_color11"));
+	remmina_pref_dialog->colorbutton_color12 = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_color12"));
+	remmina_pref_dialog->colorbutton_color13 = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_color13"));
+	remmina_pref_dialog->colorbutton_color14 = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_color14"));
+	remmina_pref_dialog->colorbutton_color15 = GTK_COLOR_BUTTON(GET_OBJECT("colorbutton_color15"));
+#if defined (HAVE_LIBSSH) && defined (HAVE_LIBVTE)
+#if VTE_CHECK_VERSION(0, 38, 0)
+	const gchar *remmina_dir;
+	gchar *destpath;
+	remmina_dir = g_build_path("/", g_get_user_config_dir(), "remmina", NULL);
+	destpath = g_strdup_printf("%s/remmina.colors", remmina_dir);
+	remmina_pref_dialog->button_term_cs = GTK_FILE_CHOOSER(GET_OBJECT("button_term_cs"));
+	const gchar *fc_tooltip_text = g_strconcat(_("Picking a terminal colouring file replaces the file: "),
+						   "\n",
+						   destpath,
+						   "\n",
+						   _("This file contains the “Custom” terminal colour scheme selectable from the “Advanced” tab of terminal connections and editable in the “Terminal” tab in the settings."),
+						   NULL);
+	gtk_widget_set_tooltip_text(GTK_WIDGET(remmina_pref_dialog->button_term_cs), fc_tooltip_text);
+	gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(remmina_pref_dialog->button_term_cs), REMMINA_RUNTIME_TERM_CS_DIR);
+	g_free(destpath);
+#endif
+#endif
+	/* Non widget objects */
+	actions = g_simple_action_group_new();
+	g_action_map_add_action_entries(G_ACTION_MAP(actions), pref_actions, G_N_ELEMENTS(pref_actions), remmina_pref_dialog->dialog);
+	gtk_widget_insert_action_group(GTK_WIDGET(remmina_pref_dialog->dialog), "pref", G_ACTION_GROUP(actions));
+	g_action_map_add_action_entries(G_ACTION_MAP(actions), pref_actions, G_N_ELEMENTS(pref_actions), remmina_pref_dialog->dialog);
+	g_object_unref(actions);
+	/* Accelerators */
+	accel_group = gtk_accel_group_new();
+	gtk_window_add_accel_group(GTK_WINDOW(remmina_pref_dialog->dialog), accel_group);
+	gtk_accel_group_connect(accel_group, GDK_KEY_Q, GDK_CONTROL_MASK, 0,
+				g_cclosure_new_swap(G_CALLBACK(remmina_pref_dialog_on_action_close), NULL, NULL));
+
+	/* Connect signals */
+	gtk_builder_connect_signals(remmina_pref_dialog->builder, NULL);
+	/* Initialize the window and load the preferences */
+	remmina_pref_dialog_init();
+
+	if (default_tab > 0)
+		gtk_notebook_set_current_page(remmina_pref_dialog->notebook_preferences, default_tab);
+	return remmina_pref_dialog->dialog;
+}
+
+GtkWidget *remmina_pref_dialog_get_dialog()
+{
+	if (!remmina_pref_dialog)
+		return NULL;
+	return remmina_pref_dialog->dialog;
+}
diff --git a/src/remmina_pref_dialog.h b/src/remmina_pref_dialog.h
new file mode 100644
index 0000000..04af8c9
--- /dev/null
+++ b/src/remmina_pref_dialog.h
@@ -0,0 +1,180 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009-2011 Vic Lee
+ * Copyright (C) 2017-2022 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2022-2023 Antenore Gatta, Giovanni Panozzo, Hiroyuki Tanaka
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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.
+ *
+ */
+
+#pragma once
+#include <gtk/gtk.h>
+
+/*
+ * Remmina Preferences Dialog
+ */
+
+typedef struct _RemminaPrefDialogPriv {
+	GtkWidget *resolutions_list;
+} RemminaPrefDialogPriv;
+
+typedef struct _RemminaPrefDialog {
+	GtkBuilder *		builder;
+	GtkWidget *		dialog;
+	GtkNotebook *		notebook_preferences;
+
+	GtkFileChooser *	filechooserbutton_options_datadir_path;
+	GtkEntry *		entry_options_file_name;
+	GtkFileChooser *	filechooserbutton_options_screenshots_path;
+	GtkEntry *		entry_options_screenshot_name;
+	GtkSwitch *		switch_appearance_grab_color;
+	GtkSwitch *		switch_options_deny_screenshot_clipboard;
+	GtkSwitch *		switch_options_remember_last_view_mode;
+	GtkSwitch *		switch_options_confirm_close;
+	GtkSwitch *		switch_security_use_primary_password;
+	GtkEntry *		unlock_timeout;
+	GtkSwitch *		switch_security_lock_connect;
+	GtkSwitch *		switch_security_lock_edit;
+	GtkSwitch *		switch_security_lock_view_passwords;
+	GtkSwitch *		switch_security_audit;
+	GtkSwitch *		switch_security_trust_all;
+	GtkSwitch *		switch_disable_news;
+	GtkSwitch *		switch_disable_stats;
+	GtkSwitch *		switch_disable_tip;
+	GtkLabel *		label_disable_news;
+	GtkLabel *		label_disable_stats;
+	GtkLabel *		label_disable_tip;
+	GtkCheckButton *	checkbutton_options_save_settings;
+	GtkCheckButton *	checkbutton_appearance_fullscreen_on_auto;
+	GtkCheckButton *	checkbutton_appearance_show_tabs;
+	GtkCheckButton *	checkbutton_appearance_show_notes;
+	GtkCheckButton *	checkbutton_appearance_hide_toolbar;
+	GtkCheckButton *	checkbutton_appearance_hide_searchbar;
+	GtkComboBox *		comboboxtext_options_double_click;
+	GtkComboBox *		comboboxtext_appearance_view_mode;
+	GtkComboBox *		comboboxtext_appearance_tab_interface;
+	GtkComboBox *		comboboxtext_options_scale_quality;
+	GtkComboBox *		comboboxtext_options_ssh_loglevel;
+	GtkComboBox *		comboboxtext_appearance_fullscreen_toolbar_visibility;
+	GtkComboBox *		comboboxtext_security_enc_method;
+	GtkCheckButton *	checkbutton_options_ssh_parseconfig;
+	GtkEntry *		entry_options_ssh_port;
+	GtkEntry *		entry_options_ssh_tcp_keepidle;
+	GtkEntry *		entry_options_ssh_tcp_keepintvl;
+	GtkEntry *		entry_options_ssh_tcp_keepcnt;
+	GtkEntry *		entry_options_ssh_tcp_usrtimeout;
+	GtkEntry *		entry_options_scroll;
+	GtkEntry *		entry_options_recent_items;
+	GtkEntry *		entry_grab_color;
+	GtkButton *		button_options_recent_items_clear;
+	GtkButton *		button_options_resolutions;
+
+	GtkCheckButton *	checkbutton_applet_new_connection_on_top;
+	GtkCheckButton *	checkbutton_applet_hide_totals;
+	GtkCheckButton *	checkbutton_applet_disable_tray;
+	GtkCheckButton *	checkbutton_dark_theme;
+	GtkCheckButton *	checkbutton_applet_start_in_tray;
+
+	GtkButton *		button_keyboard_host_key;
+	GtkButton *		button_keyboard_fullscreen;
+	GtkButton *		button_keyboard_auto_fit;
+	GtkButton *		button_keyboard_switch_tab_left;
+	GtkButton *		button_keyboard_switch_tab_right;
+	GtkButton *		button_keyboard_scaled;
+	GtkButton *		button_keyboard_clipboard;
+	GtkButton *		button_keyboard_multimon;
+	GtkButton *		button_keyboard_grab_keyboard;
+	GtkButton *		button_keyboard_screenshot;
+	GtkButton *		button_keyboard_viewonly;
+	GtkButton *		button_keyboard_minimize;
+	GtkButton *		button_keyboard_disconnect;
+	GtkButton *		button_keyboard_toolbar;
+
+	GtkSwitch *		switch_terminal_font_system;
+	GtkFontButton *		fontbutton_terminal_font;
+	GtkSwitch *		switch_terminal_bold;
+	GtkLabel *		label_terminal_foreground;
+	GtkColorButton *	colorbutton_foreground;
+	GtkLabel *		label_terminal_background;
+	GtkColorButton *	colorbutton_background;
+	GtkEntry *		entry_scrollback_lines;
+	GtkButton *		button_keyboard_copy;
+	GtkButton *		button_keyboard_paste;
+	GtkButton *		button_keyboard_select_all;
+	GtkButton *		button_keyboard_increase_font;
+	GtkButton *		button_keyboard_decrease_font;
+	GtkButton *		button_keyboard_search_text;
+	GtkLabel *		label_terminal_cursor_color;
+	GtkLabel *		label_terminal_bold_color;
+	GtkLabel *		label_terminal_normal_colors;
+	GtkLabel *		label_terminal_bright_colors;
+	GtkColorButton *	colorbutton_cursor;
+	GtkColorButton *	colorbutton_cursor_foreground;
+	GtkColorButton *	colorbutton_highlight;
+	GtkColorButton *	colorbutton_highlight_foreground;
+	GtkColorButton *	colorbutton_colorBD;
+	GtkColorButton *	colorbutton_color0;
+	GtkColorButton *	colorbutton_color1;
+	GtkColorButton *	colorbutton_color2;
+	GtkColorButton *	colorbutton_color3;
+	GtkColorButton *	colorbutton_color4;
+	GtkColorButton *	colorbutton_color5;
+	GtkColorButton *	colorbutton_color6;
+	GtkColorButton *	colorbutton_color7;
+	GtkColorButton *	colorbutton_color8;
+	GtkColorButton *	colorbutton_color9;
+	GtkColorButton *	colorbutton_color10;
+	GtkColorButton *	colorbutton_color11;
+	GtkColorButton *	colorbutton_color12;
+	GtkColorButton *	colorbutton_color13;
+	GtkColorButton *	colorbutton_color14;
+	GtkColorButton *	colorbutton_color15;
+	GtkFileChooser *	button_term_cs;
+
+	RemminaPrefDialogPriv * priv;
+} RemminaPrefDialog;
+
+enum {
+	REMMINA_PREF_OPTIONS_TAB	= 0,
+	REMMINA_PREF_APPEARANCE		= 1,
+	REMMINA_PREF_APPLET_TAB		= 2
+};
+
+G_BEGIN_DECLS
+
+/* RemminaPrefDialog instance */
+GtkWidget *remmina_pref_dialog_new(gint default_tab, GtkWindow *parent);
+/* Get the current PrefDialog or NULL if not initialized */
+GtkWidget *remmina_pref_dialog_get_dialog(void);
+void remmina_prefdiag_unlock_repwd_on_changed(GtkEditable *editable, RemminaPrefDialog *dialog);
+void remmina_pref_dialog_on_action_close(GSimpleAction *action, GVariant *param, gpointer data);
+
+G_END_DECLS
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;
+}
diff --git a/src/remmina_protocol_widget.h b/src/remmina_protocol_widget.h
new file mode 100644
index 0000000..6047a0d
--- /dev/null
+++ b/src/remmina_protocol_widget.h
@@ -0,0 +1,187 @@
+/*
+ * 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.
+ *
+ */
+
+#pragma once
+
+#include "rcw.h"
+#include "remmina_file.h"
+#include "remmina_ssh.h"
+
+G_BEGIN_DECLS
+
+#define REMMINA_PROTOCOL_FEATURE_TOOL_SSH  -1
+#define REMMINA_PROTOCOL_FEATURE_TOOL_SFTP -2
+
+#define REMMINA_TYPE_PROTOCOL_WIDGET                  (remmina_protocol_widget_get_type())
+#define REMMINA_PROTOCOL_WIDGET(obj)                  (G_TYPE_CHECK_INSTANCE_CAST((obj), REMMINA_TYPE_PROTOCOL_WIDGET, RemminaProtocolWidget))
+#define REMMINA_PROTOCOL_WIDGET_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST((klass), REMMINA_TYPE_PROTOCOL_WIDGET, RemminaProtocolWidgetClass))
+#define REMMINA_IS_PROTOCOL_WIDGET(obj)               (G_TYPE_CHECK_INSTANCE_TYPE((obj), REMMINA_TYPE_PROTOCOL_WIDGET))
+#define REMMINA_IS_PROTOCOL_WIDGET_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE((klass), REMMINA_TYPE_PROTOCOL_WIDGET))
+#define REMMINA_PROTOCOL_WIDGET_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS((obj), REMMINA_TYPE_PROTOCOL_WIDGET, RemminaProtocolWidgetClass))
+
+typedef struct _RemminaProtocolWidgetPriv RemminaProtocolWidgetPriv;
+typedef struct _RemminaProtocolPlugin RemminaProtocolPlugin;
+
+struct _RemminaProtocolWidget {
+	GtkEventBox			event_box;
+	RemminaConnectionObject *	cnnobj;
+	RemminaProtocolWidgetPriv *	priv;
+	RemminaProtocolPlugin * plugin;
+};
+
+struct _RemminaProtocolWidgetClass {
+	GtkEventBoxClass	parent_class;
+
+	void			(*connect)(RemminaProtocolWidget *gp);
+	void			(*disconnect)(RemminaProtocolWidget *gp);
+	void			(*desktop_resize)(RemminaProtocolWidget *gp);
+	void			(*update_align)(RemminaProtocolWidget *gp);
+	void			(*lock_dynres)(RemminaProtocolWidget *gp);
+	void			(*unlock_dynres)(RemminaProtocolWidget *gp);
+};
+
+GType remmina_protocol_widget_get_type(void)
+G_GNUC_CONST;
+
+GtkWindow* remmina_protocol_widget_get_gtkwindow(RemminaProtocolWidget *gp);
+GtkWidget* remmina_protocol_widget_gtkviewport(RemminaProtocolWidget *gp);
+
+GtkWidget *remmina_protocol_widget_new(void);
+void remmina_protocol_widget_setup(RemminaProtocolWidget *gp, RemminaFile *remminafile, RemminaConnectionObject *cnnobj);
+
+const gchar* remmina_protocol_widget_get_name(RemminaProtocolWidget *gp);
+gint remmina_protocol_widget_get_width(RemminaProtocolWidget *gp);
+void remmina_protocol_widget_set_width(RemminaProtocolWidget *gp, gint width);
+gint remmina_protocol_widget_get_height(RemminaProtocolWidget *gp);
+void remmina_protocol_widget_set_height(RemminaProtocolWidget *gp, gint height);
+gint remmina_protocol_widget_get_profile_remote_width(RemminaProtocolWidget *gp);
+gint remmina_protocol_widget_get_profile_remote_height(RemminaProtocolWidget *gp);
+gint remmina_protocol_widget_get_multimon(RemminaProtocolWidget *gp);
+
+RemminaScaleMode remmina_protocol_widget_get_current_scale_mode(RemminaProtocolWidget *gp);
+void remmina_protocol_widget_set_current_scale_mode(RemminaProtocolWidget *gp, RemminaScaleMode scalemode);
+gboolean remmina_protocol_widget_get_expand(RemminaProtocolWidget *gp);
+void remmina_protocol_widget_set_expand(RemminaProtocolWidget *gp, gboolean expand);
+gboolean remmina_protocol_widget_has_error(RemminaProtocolWidget *gp);
+const gchar *remmina_protocol_widget_get_error_message(RemminaProtocolWidget *gp);
+void remmina_protocol_widget_set_error(RemminaProtocolWidget *gp, const gchar *fmt, ...);
+gboolean remmina_protocol_widget_is_closed(RemminaProtocolWidget *gp);
+RemminaFile *remmina_protocol_widget_get_file(RemminaProtocolWidget *gp);
+
+void remmina_protocol_widget_open_connection(RemminaProtocolWidget *gp);
+void remmina_protocol_widget_close_connection(RemminaProtocolWidget *gp);
+void remmina_protocol_widget_signal_connection_closed(RemminaProtocolWidget *gp);
+void remmina_protocol_widget_signal_connection_opened(RemminaProtocolWidget *gp);
+void remmina_protocol_widget_update_align(RemminaProtocolWidget *gp);
+void remmina_protocol_widget_lock_dynres(RemminaProtocolWidget *gp);
+void remmina_protocol_widget_unlock_dynres(RemminaProtocolWidget *gp);
+void remmina_protocol_widget_desktop_resize(RemminaProtocolWidget *gp);
+void remmina_protocol_widget_grab_focus(RemminaProtocolWidget *gp);
+const RemminaProtocolFeature *remmina_protocol_widget_get_features(RemminaProtocolWidget *gp);
+gboolean remmina_protocol_widget_query_feature_by_type(RemminaProtocolWidget *gp, RemminaProtocolFeatureType type);
+gboolean remmina_protocol_widget_query_feature_by_ref(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature);
+void remmina_protocol_widget_call_feature_by_type(RemminaProtocolWidget *gp, RemminaProtocolFeatureType type, gint id);
+void remmina_protocol_widget_call_feature_by_ref(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature);
+/* Provide thread-safe way to emit signals */
+void remmina_protocol_widget_emit_signal(RemminaProtocolWidget *gp, const gchar *signal_name);
+void remmina_protocol_widget_register_hostkey(RemminaProtocolWidget *gp, GtkWidget *widget);
+
+typedef gboolean (*RemminaHostkeyFunc)(RemminaProtocolWidget *gp, guint keyval, gboolean release);
+void remmina_protocol_widget_set_hostkey_func(RemminaProtocolWidget *gp, RemminaHostkeyFunc func);
+
+gboolean remmina_protocol_widget_ssh_exec(RemminaProtocolWidget *gp, gboolean wait, const gchar *fmt, ...);
+
+/* Start a SSH tunnel if it’s enabled. Returns a newly allocated string indicating:
+ * 1. The actual destination (host:port) if SSH tunnel is disable
+ * 2. The tunnel local destination (127.0.0.1:port) if SSH tunnel is enabled
+ */
+gchar *remmina_protocol_widget_start_direct_tunnel(RemminaProtocolWidget *gp, gint default_port, gboolean port_plus);
+
+gboolean remmina_protocol_widget_start_reverse_tunnel(RemminaProtocolWidget *gp, gint local_port);
+gboolean remmina_protocol_widget_start_xport_tunnel(RemminaProtocolWidget *gp, RemminaXPortTunnelInitFunc init_func);
+void remmina_protocol_widget_set_display(RemminaProtocolWidget *gp, gint display);
+
+/* Extension for remmina_protocol_widget_panel_authuserpwd() not currently exported to plugins */
+gint remmina_protocol_widget_panel_authuserpwd_ssh_tunnel(RemminaProtocolWidget *gp, gboolean want_domain, gboolean allow_password_saving);
+
+/* Dialog panel API used by the plugins */
+
+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);
+gint remmina_protocol_widget_panel_new_certificate(RemminaProtocolWidget *gp, const gchar *subject, const gchar *issuer, const gchar *fingerprint);
+gint remmina_protocol_widget_panel_changed_certificate(RemminaProtocolWidget *gp, const gchar *subject, const gchar *issuer, const gchar *new_fingerprint, const gchar *old_fingerprint);
+gint remmina_protocol_widget_panel_question_yesno(RemminaProtocolWidget *gp, const char *msg);
+
+void remmina_protocol_widget_panel_show(RemminaProtocolWidget *gp);
+void remmina_protocol_widget_panel_hide(RemminaProtocolWidget *gp);
+void remmina_protocol_widget_panel_destroy(RemminaProtocolWidget *gp);
+gint remmina_protocol_widget_panel_authx509(RemminaProtocolWidget *gp);
+void remmina_protocol_widget_panel_show_listen(RemminaProtocolWidget *gp, gint port);
+void remmina_protocol_widget_panel_show_retry(RemminaProtocolWidget *gp);
+
+void remmina_protocol_widget_save_cred(RemminaProtocolWidget *gp);
+
+gchar *remmina_protocol_widget_get_username(RemminaProtocolWidget *gp);
+gchar *remmina_protocol_widget_get_password(RemminaProtocolWidget *gp);
+gchar *remmina_protocol_widget_get_domain(RemminaProtocolWidget *gp);
+gboolean remmina_protocol_widget_get_savepassword(RemminaProtocolWidget *gp);
+gchar *remmina_protocol_widget_get_cacert(RemminaProtocolWidget *gp);
+gchar *remmina_protocol_widget_get_cacrl(RemminaProtocolWidget *gp);
+gchar *remmina_protocol_widget_get_clientcert(RemminaProtocolWidget *gp);
+gchar *remmina_protocol_widget_get_clientkey(RemminaProtocolWidget *gp);
+
+void remmina_protocol_widget_chat_open(RemminaProtocolWidget *gp, const gchar *name, void (*on_send)(RemminaProtocolWidget *gp, const gchar *text), void (*on_destroy)(RemminaProtocolWidget *gp));
+void remmina_protocol_widget_chat_close(RemminaProtocolWidget *gp);
+void remmina_protocol_widget_chat_receive(RemminaProtocolWidget *gp, const gchar *text);
+void remmina_protocol_widget_send_keys_signals(GtkWidget *widget, const guint *keyvals, int keyvals_length, GdkEventType action);
+/* Check if the plugin accepts keystrokes */
+gboolean remmina_protocol_widget_plugin_receives_keystrokes(RemminaProtocolWidget *gp);
+/* Send to the plugin some keystrokes */
+void remmina_protocol_widget_send_keystrokes(RemminaProtocolWidget *gp, GtkMenuItem *widget);
+void remmina_protocol_widget_send_clipboard(RemminaProtocolWidget *gp, GObject *widget);
+/* Take screenshot of plugin */
+gboolean remmina_protocol_widget_plugin_screenshot(RemminaProtocolWidget *gp, RemminaPluginScreenshotData *rpsd);
+/* Deal with the remimna connection window map/unmap events */
+gboolean remmina_protocol_widget_map_event(RemminaProtocolWidget *gp);
+gboolean remmina_protocol_widget_unmap_event(RemminaProtocolWidget *gp);
+
+void remmina_protocol_widget_update_remote_resolution(RemminaProtocolWidget *gp);
+
+/* Functions to support execution of GTK code on master thread */
+RemminaMessagePanel *remmina_protocol_widget_mpprogress(RemminaConnectionObject *cnnobj, const gchar *msg, RemminaMessagePanelCallback response_callback, gpointer response_callback_data);
+void remmina_protocol_widget_mpdestroy(RemminaConnectionObject *cnnobj, RemminaMessagePanel *mp);
+
+
+G_END_DECLS
diff --git a/src/remmina_public.c b/src/remmina_public.c
new file mode 100644
index 0000000..cdb40a7
--- /dev/null
+++ b/src/remmina_public.c
@@ -0,0 +1,735 @@
+/*
+ * 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 <glib/gi18n.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_SYS_UN_H
+#include <sys/un.h>
+#endif
+#ifdef GDK_WINDOWING_X11
+#include <gdk/gdkx.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#elif defined(GDK_WINDOWING_WAYLAND)
+#include <gdk/gdkwayland.h>
+#endif
+#include "remmina_public.h"
+#include "remmina/remmina_trace_calls.h"
+
+GtkWidget*
+remmina_public_create_combo_entry(const gchar *text, const gchar *def, gboolean descending)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *combo;
+	gboolean found;
+	gchar *buf, *ptr1, *ptr2;
+	gint i;
+
+	//g_debug("text: %s\n", text);
+	//g_debug("def: %s\n", def);
+
+	combo = gtk_combo_box_text_new_with_entry();
+	found = FALSE;
+
+	if (text && text[0] != '\0') {
+		buf = g_strdup(text);
+		ptr1 = buf;
+		i = 0;
+		while (ptr1 && *ptr1 != '\0') {
+			ptr2 = strchr(ptr1, CHAR_DELIMITOR);
+			if (ptr2)
+				*ptr2++ = '\0';
+
+			if (descending) {
+				gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(combo), ptr1);
+				if (!found && g_strcmp0(ptr1, def) == 0) {
+					gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
+					found = TRUE;
+				}
+			}else  {
+				gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), ptr1);
+				if (!found && g_strcmp0(ptr1, def) == 0) {
+					gtk_combo_box_set_active(GTK_COMBO_BOX(combo), i);
+					found = TRUE;
+				}
+			}
+
+			ptr1 = ptr2;
+			i++;
+		}
+
+		g_free(buf);
+	}
+
+	if (!found && def && def[0] != '\0') {
+		gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(combo))), def);
+	}
+
+	return combo;
+}
+
+GtkWidget*
+remmina_public_create_combo_text_d(const gchar *text, const gchar *def, const gchar *empty_choice)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *combo;
+	GtkListStore *store;
+	GtkCellRenderer *text_renderer;
+
+	store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
+	combo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
+
+	text_renderer = gtk_cell_renderer_text_new();
+	gtk_cell_layout_pack_end(GTK_CELL_LAYOUT(combo), text_renderer, TRUE);
+	gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(combo), text_renderer, "text", 1);
+
+	remmina_public_load_combo_text_d(combo, text, def, empty_choice);
+
+	return combo;
+}
+
+void remmina_public_load_combo_text_d(GtkWidget *combo, const gchar *text, const gchar *def, const gchar *empty_choice)
+{
+	TRACE_CALL(__func__);
+	GtkListStore *store;
+	GtkTreeIter iter;
+	gint i;
+	gchar *buf, *ptr1, *ptr2;
+
+	store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(combo)));
+	gtk_list_store_clear(store);
+
+	i = 0;
+
+	if (empty_choice) {
+		gtk_list_store_append(store, &iter);
+		gtk_list_store_set(store, &iter, 0, "", 1, empty_choice, -1);
+		gtk_combo_box_set_active(GTK_COMBO_BOX(combo), i);
+		i++;
+	}
+
+	if (text == NULL || text[0] == '\0')
+		return;
+
+	buf = g_strdup(text);
+	ptr1 = buf;
+	while (ptr1 && *ptr1 != '\0') {
+		ptr2 = strchr(ptr1, CHAR_DELIMITOR);
+		if (ptr2)
+			*ptr2++ = '\0';
+
+		gtk_list_store_append(store, &iter);
+		gtk_list_store_set(store, &iter, 0, ptr1, 1, ptr1, -1);
+
+		if (i == 0 || g_strcmp0(ptr1, def) == 0) {
+			gtk_combo_box_set_active(GTK_COMBO_BOX(combo), i);
+		}
+
+		i++;
+		ptr1 = ptr2;
+	}
+
+	g_free(buf);
+}
+
+GtkWidget*
+remmina_public_create_combo(gboolean use_icon)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *combo;
+	GtkListStore *store;
+	GtkCellRenderer *renderer;
+
+	if (use_icon) {
+		store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
+	}else  {
+		store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
+	}
+	combo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
+	gtk_widget_set_hexpand(combo, TRUE);
+
+	if (use_icon) {
+		renderer = gtk_cell_renderer_pixbuf_new();
+		gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer, FALSE);
+		gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(combo), renderer, "icon-name", 2);
+	}
+	renderer = gtk_cell_renderer_text_new();
+	gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer, TRUE);
+	gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(combo), renderer, "text", 1);
+	if (use_icon)
+		g_object_set(G_OBJECT(renderer), "xpad", 5, NULL);
+
+	return combo;
+}
+
+GtkWidget*
+remmina_public_create_combo_map(const gpointer *key_value_list, const gchar *def, gboolean use_icon, const gchar *domain)
+{
+	TRACE_CALL(__func__);
+	gint i;
+	GtkWidget *combo;
+	GtkListStore *store;
+	GtkTreeIter iter;
+
+	combo = remmina_public_create_combo(use_icon);
+	store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(combo)));
+
+	for (i = 0; key_value_list[i]; i += (use_icon ? 3 : 2)) {
+		gtk_list_store_append(store, &iter);
+		gtk_list_store_set(
+			store,
+			&iter,
+			0,
+			key_value_list[i],
+			1,
+			key_value_list[i + 1] && ((char*)key_value_list[i + 1])[0] ?
+			g_dgettext(domain, key_value_list[i + 1]) : "", -1);
+		if (use_icon) {
+			gtk_list_store_set(store, &iter, 2, key_value_list[i + 2], -1);
+		}
+		if (i == 0 || g_strcmp0(key_value_list[i], def) == 0) {
+			gtk_combo_box_set_active(GTK_COMBO_BOX(combo), i / (use_icon ? 3 : 2));
+		}
+	}
+	return combo;
+}
+
+GtkWidget*
+remmina_public_create_combo_mapint(const gpointer *key_value_list, gint def, gboolean use_icon, const gchar *domain)
+{
+	TRACE_CALL(__func__);
+	gchar buf[20];
+	g_snprintf(buf, sizeof(buf), "%i", def);
+	return remmina_public_create_combo_map(key_value_list, buf, use_icon, domain);
+}
+
+void remmina_public_create_group(GtkGrid *grid, const gchar *group, gint row, gint rows, gint cols)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget;
+	gchar *str;
+
+	widget = gtk_label_new(NULL);
+	gtk_widget_show(widget);
+	gtk_widget_set_halign(GTK_WIDGET(widget), GTK_ALIGN_START);
+	gtk_widget_set_valign(GTK_WIDGET(widget), GTK_ALIGN_CENTER);
+	str = g_markup_printf_escaped("<b>%s</b>", group);
+	gtk_label_set_markup(GTK_LABEL(widget), str);
+	g_free(str);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, row, 1, 2);
+
+	widget = gtk_label_new(NULL);
+	gtk_widget_show(widget);
+	gtk_grid_attach(GTK_GRID(grid), widget, 0, row + 1, 1, 1);
+}
+
+gchar*
+remmina_public_combo_get_active_text(GtkComboBox *combo)
+{
+	TRACE_CALL(__func__);
+	GtkTreeModel *model;
+	GtkTreeIter iter;
+	gchar *s;
+
+	if (GTK_IS_COMBO_BOX_TEXT(combo)) {
+		return gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo));
+	}
+
+	if (!gtk_combo_box_get_active_iter(combo, &iter))
+		return NULL;
+
+	model = gtk_combo_box_get_model(combo);
+	gtk_tree_model_get(model, &iter, 0, &s, -1);
+
+	return s;
+}
+
+#if !GTK_CHECK_VERSION(3, 22, 0)
+void remmina_public_popup_position(GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget;
+	gint tx, ty;
+	GtkAllocation allocation;
+
+	widget = GTK_WIDGET(user_data);
+	if (gtk_widget_get_window(widget) == NULL) {
+		*x = 0;
+		*y = 0;
+		*push_in = TRUE;
+		return;
+	}
+	gdk_window_get_origin(gtk_widget_get_window(widget), &tx, &ty);
+	gtk_widget_get_allocation(widget, &allocation);
+	/* I’m unsure why the author made the check about a GdkWindow inside the
+	 * widget argument. This function generally is called passing by a ToolButton
+	 * which hasn’t any GdkWindow, therefore the positioning is wrong
+	 * I think the gtk_widget_get_has_window() check should be removed
+	 *
+	 * While leaving the previous check intact I’m checking also if the provided
+	 * widget is a GtkToggleToolButton and position the menu accordingly. */
+	if (gtk_widget_get_has_window(widget) ||
+	    g_strcmp0(gtk_widget_get_name(widget), "GtkToggleToolButton") == 0) {
+		tx += allocation.x;
+		ty += allocation.y;
+	}
+
+	*x = tx;
+	*y = ty + allocation.height - 1;
+	*push_in = TRUE;
+}
+#endif
+
+gchar*
+remmina_public_combine_path(const gchar *path1, const gchar *path2)
+{
+	TRACE_CALL(__func__);
+	if (!path1 || path1[0] == '\0')
+		return g_strdup(path2);
+	if (path1[strlen(path1) - 1] == '/')
+		return g_strdup_printf("%s%s", path1, path2);
+	return g_strdup_printf("%s/%s", path1, path2);
+}
+
+//static int remmina_public_open_unix_sock(const char *unixsock, GError **error)
+gint remmina_public_open_unix_sock(const char *unixsock)
+{
+    struct sockaddr_un addr;
+    int fd;
+
+    if (strlen(unixsock) + 1 > sizeof(addr.sun_path)) {
+        //g_set_error(error, REMMINA_ERROR, REMMINA_ERROR_FAILED,
+                    g_debug(_("Address is too long for UNIX socket_path: %s"), unixsock);
+        return -1;
+    }
+
+    memset(&addr, 0, sizeof addr);
+    addr.sun_family = AF_UNIX;
+    strcpy(addr.sun_path, unixsock);
+
+    if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
+        //g_set_error(error, REMMINA_ERROR, REMMINA_ERROR_FAILED,
+                    g_debug(_("Creating UNIX socket failed: %s"), g_strerror(errno));
+        return -1;
+    }
+
+    if (connect(fd, (struct sockaddr *)&addr, sizeof addr) < 0) {
+        //g_set_error(error, REMMINA_ERROR, REMMINA_ERROR_FAILED,
+                    g_debug(_("Connecting to UNIX socket failed: %s"), g_strerror(errno));
+        close(fd);
+        return -1;
+    }
+
+    return fd;
+}
+
+void remmina_public_get_server_port_old(const gchar *server, gint defaultport, gchar **host, gint *port)
+{
+	TRACE_CALL(__func__);
+	gchar *str, *ptr, *ptr2;
+
+	str = g_strdup(server);
+
+	if (str) {
+		/* [server]:port format */
+		ptr = strchr(str, '[');
+		if (ptr) {
+			ptr++;
+			ptr2 = strchr(ptr, ']');
+			if (ptr2) {
+				*ptr2++ = '\0';
+				if (*ptr2 == ':')
+					defaultport = atoi(ptr2 + 1);
+			}
+			if (host)
+				*host = g_strdup(ptr);
+			if (port)
+				*port = defaultport;
+			g_free(str);
+			g_debug ("(%s) - host: %s", __func__, *host);
+			g_debug ("(%s) - port: %d", __func__, *port);
+			return;
+		}
+
+		/* server:port format, IPv6 cannot use this format */
+		ptr = strchr(str, ':');
+		if (ptr) {
+			ptr2 = strchr(ptr + 1, ':');
+			if (ptr2 == NULL) {
+				*ptr++ = '\0';
+				defaultport = atoi(ptr);
+			}
+			/* More than one ':' means this is IPv6 address. Treat it as a whole address */
+		}
+	}
+
+	if (host)
+		*host = str;
+	else
+		g_free(str);
+	if (port)
+		*port = defaultport;
+
+	g_debug ("(%s) - host: %s", __func__, *host);
+	g_debug ("(%s) - port: %d", __func__, *port);
+}
+
+void remmina_public_get_server_port(const gchar *server, gint defaultport, gchar **host, gint *port)
+{
+	TRACE_CALL(__func__);
+
+	const gchar *nul_terminated_server = NULL;
+	if (server != NULL) {
+		if(strstr(g_strdup(server), "ID:") != NULL) {
+			g_debug ("(%s) - Using remmina_public_get_server_port_old to parse the repeater ID", __func__);
+			remmina_public_get_server_port_old (server, defaultport, host, port);
+			return;
+		}
+
+		GNetworkAddress *address;
+		GError *err = NULL;
+
+		nul_terminated_server = g_strdup (server);
+		g_debug ("(%s) - Parsing server: %s, default port: %d", __func__, server, defaultport);
+		address = (GNetworkAddress*)g_network_address_parse ((const gchar *)nul_terminated_server, defaultport, &err);
+
+		if (address == NULL) {
+			g_debug ("(%s) - Error converting server string: %s, with error: %s", __func__, nul_terminated_server, err->message);
+			*host = NULL;
+			if (err)
+				g_error_free(err);
+		} else {
+
+			*host = g_strdup(g_network_address_get_hostname (address));
+			*port = g_network_address_get_port (address);
+		}
+	} else
+		*host = NULL;
+
+	if (port == 0)
+		*port = defaultport;
+
+	g_debug ("(%s) - host: %s", __func__, *host);
+	g_debug ("(%s) - port: %d", __func__, *port);
+
+	return;
+}
+
+gboolean remmina_public_get_xauth_cookie(const gchar *display, gchar **msg)
+{
+	TRACE_CALL(__func__);
+	gchar buf[200];
+	gchar *out = NULL;
+	gchar *ptr;
+	GError *error = NULL;
+	gboolean ret;
+
+	if (!display)
+		display = gdk_display_get_name(gdk_display_get_default());
+
+	g_snprintf(buf, sizeof(buf), "xauth list %s", display);
+	ret = g_spawn_command_line_sync(buf, &out, NULL, NULL, &error);
+	if (ret) {
+		if ((ptr = g_strrstr(out, "MIT-MAGIC-COOKIE-1")) == NULL) {
+			*msg = g_strdup_printf("xauth returns %s", out);
+			ret = FALSE;
+		}else  {
+			ptr += 19;
+			while (*ptr == ' ')
+				ptr++;
+			*msg = g_strndup(ptr, 32);
+		}
+		g_free(out);
+	}else  {
+		*msg = g_strdup(error->message);
+	}
+	return ret;
+}
+
+gint remmina_public_open_xdisplay(const gchar *disp)
+{
+	TRACE_CALL(__func__);
+	gchar *display;
+	gchar *ptr;
+	gint port;
+	struct sockaddr_un addr;
+	gint sock = -1;
+
+	display = g_strdup(disp);
+	ptr = g_strrstr(display, ":");
+	if (ptr) {
+		*ptr++ = '\0';
+		/* Assume you are using a local display… might need to implement remote display in the future */
+		if (display[0] == '\0' || strcmp(display, "unix") == 0) {
+			port = atoi(ptr);
+			sock = socket(AF_UNIX, SOCK_STREAM, 0);
+			if (sock >= 0) {
+				memset(&addr, 0, sizeof(addr));
+				addr.sun_family = AF_UNIX;
+				snprintf(addr.sun_path, sizeof(addr.sun_path), X_UNIX_SOCKET, port);
+				if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
+					close(sock);
+					sock = -1;
+				}
+			}
+		}
+	}
+
+	g_free(display);
+	return sock;
+}
+
+/* Find hardware keycode for the requested keyval */
+guint16 remmina_public_get_keycode_for_keyval(GdkKeymap *keymap, guint keyval)
+{
+	TRACE_CALL(__func__);
+	GdkKeymapKey *keys = NULL;
+	gint length = 0;
+	guint16 keycode = 0;
+
+	if (gdk_keymap_get_entries_for_keyval(keymap, keyval, &keys, &length)) {
+		keycode = keys[0].keycode;
+		g_free(keys);
+	}
+	return keycode;
+}
+
+/* Check if the requested keycode is a key modifier */
+gboolean remmina_public_get_modifier_for_keycode(GdkKeymap *keymap, guint16 keycode)
+{
+	TRACE_CALL(__func__);
+	//g_return_val_if_fail(keycode > 0, FALSE);
+	if (keycode > 0) return FALSE;
+#ifdef GDK_WINDOWING_X11
+	return gdk_x11_keymap_key_is_modifier(keymap, keycode);
+#else
+	return FALSE;
+#endif
+}
+
+/* Load a GtkBuilder object from a filename */
+GtkBuilder* remmina_public_gtk_builder_new_from_file(gchar *filename)
+{
+	TRACE_CALL(__func__);
+	GError *err = NULL;
+	gchar *ui_path = g_strconcat(REMMINA_RUNTIME_UIDIR, G_DIR_SEPARATOR_S, filename, NULL);
+	GtkBuilder *builder = gtk_builder_new();
+	gtk_builder_add_from_file(builder, ui_path, &err);
+	if (err != NULL) {
+		g_print("Error adding build from file. Error: %s", err->message);
+		g_error_free(err);
+	}
+	g_free(ui_path);
+	return builder;
+}
+
+/* Load a GtkBuilder object from a resource */
+GtkBuilder* remmina_public_gtk_builder_new_from_resource(gchar *resource)
+{
+	TRACE_CALL(__func__);
+	GError *err = NULL;
+	GtkBuilder *builder = gtk_builder_new();
+	gtk_builder_add_from_resource (builder, resource, &err);
+	//GtkBuilder *builder = gtk_builder_new_from_resource (resource);
+	if (err != NULL) {
+		g_print("Error adding build from resource. Error: %s", err->message);
+		g_error_free(err);
+	}
+	return builder;
+}
+
+/* Change parent container for a widget
+ * If possible use this function instead of the deprecated gtk_widget_reparent */
+void remmina_public_gtk_widget_reparent(GtkWidget *widget, GtkContainer *container)
+{
+	TRACE_CALL(__func__);
+	g_object_ref(widget);
+	gtk_container_remove(GTK_CONTAINER(gtk_widget_get_parent(widget)), widget);
+	gtk_container_add(container, widget);
+	g_object_unref(widget);
+}
+
+/* Validate the inserted value for a new resolution */
+gboolean remmina_public_resolution_validation_func(const gchar *new_str, gchar **error)
+{
+	TRACE_CALL(__func__);
+	gint i;
+	gint width, height;
+	gboolean splitted;
+	gboolean result;
+
+	width = 0;
+	height = 0;
+	splitted = FALSE;
+	result = TRUE;
+	for (i = 0; new_str[i] != '\0'; i++) {
+		if (new_str[i] == 'x') {
+			if (splitted) {
+				result = FALSE;
+				break;
+			}
+			splitted = TRUE;
+			continue;
+		}
+		if (new_str[i] < '0' || new_str[i] > '9') {
+			result = FALSE;
+			break;
+		}
+		if (splitted) {
+			height = 1;
+		}else  {
+			width = 1;
+		}
+	}
+
+	if (width == 0 || height == 0)
+		result = FALSE;
+
+	if (!result)
+		*error = g_strdup(_("Please enter format 'widthxheight'."));
+	return result;
+}
+
+/* Used to send desktop notifications */
+void remmina_public_send_notification(const gchar *notification_id,
+				      const gchar *notification_title, const gchar *notification_message)
+{
+	TRACE_CALL(__func__);
+
+	g_autoptr(GNotification) n = NULL;
+	gint priority = G_NOTIFICATION_PRIORITY_NORMAL;
+
+	n = g_notification_new(notification_title);
+	g_notification_set_body(n, notification_message);
+	if (g_strcmp0 (notification_id, "remmina-security-trust-all-id") == 0) {
+		g_debug ("remmina_public_send_notification: We got a remmina-security-trust-all-id notification");
+		priority = G_NOTIFICATION_PRIORITY_HIGH;
+		/** parameter 5 is the tab index for the security tab in the preferences
+		 * TODO: Do not hardcode the parameter
+		 * TODO: Do not hardcode implement DBus interface correctly of this won't work*/
+		g_notification_set_default_action_and_target (n, "app.preferences", "i", 5);
+		g_notification_add_button_with_target (n, _("Change security settings"), "app.preferences", "i", 5);
+	}
+#if GLIB_CHECK_VERSION(2, 42, 0)
+	g_notification_set_priority(n, priority);
+#endif
+	g_application_send_notification(g_application_get_default(), notification_id, n);
+}
+
+/* Replaces all occurrences of search in a new copy of string by replacement. */
+gchar* remmina_public_str_replace(const gchar *string, const gchar *search, const gchar *replacement)
+{
+	TRACE_CALL(__func__);
+	gchar *str, **arr;
+
+	g_return_val_if_fail(string != NULL, NULL);
+	g_return_val_if_fail(search != NULL, NULL);
+
+	if (replacement == NULL)
+		replacement = "";
+
+	arr = g_strsplit(string, search, -1);
+	if (arr != NULL && arr[0] != NULL)
+		str = g_strjoinv(replacement, arr);
+	else
+		str = g_strdup(string);
+
+	g_strfreev(arr);
+	return str;
+}
+
+/* Replaces all occurrences of search in a new copy of string by replacement
+ * and overwrites the original string */
+gchar* remmina_public_str_replace_in_place(gchar *string, const gchar *search, const gchar *replacement)
+{
+	TRACE_CALL(__func__);
+	gchar *new_string = remmina_public_str_replace(string, search, replacement);
+	string = g_strdup(new_string);
+	g_free(new_string);
+	return string;
+}
+
+int remmina_public_split_resolution_string(const char *resolution_string, int *w, int *h)
+{
+	int lw, lh;
+
+	if (resolution_string == NULL || resolution_string[0] == 0)
+		return 0;
+	if (sscanf(resolution_string, "%dx%d", &lw, &lh) != 2)
+		return 0;
+	*w = lw;
+	*h = lh;
+	return 1;
+}
+
+/* Return TRUE if current gtk version library in use is greater or equal than
+ * the required major.minor.micro */
+gboolean remmina_gtk_check_version(guint major, guint minor, guint micro)
+{
+	guint rtmajor, rtminor, rtmicro;
+	rtmajor = gtk_get_major_version();
+	if (rtmajor > major) {
+		return TRUE;
+	}else if (rtmajor == major) {
+		rtminor = gtk_get_minor_version();
+		if (rtminor > minor) {
+			return TRUE;
+		}else if (rtminor == minor) {
+			rtmicro = gtk_get_micro_version();
+			if (rtmicro >= micro) {
+				return TRUE;
+			}else {
+				return FALSE;
+			}
+		}else {
+			return FALSE;
+		}
+	}else {
+		return FALSE;
+	}
+}
diff --git a/src/remmina_public.h b/src/remmina_public.h
new file mode 100644
index 0000000..49ad2fc
--- /dev/null
+++ b/src/remmina_public.h
@@ -0,0 +1,126 @@
+/*
+ * 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.
+ *
+ */
+
+#pragma once
+
+#include "config.h"
+#include <gtk/gtk.h>
+
+#define IDLE_ADD        gdk_threads_add_idle
+#define TIMEOUT_ADD     gdk_threads_add_timeout
+#define CANCEL_ASYNC    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); pthread_testcancel();
+#define CANCEL_DEFER    pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
+
+#define THREADS_ENTER _Pragma("GCC error \"THREADS_ENTER has been deprecated in Remmina 1.2\"")
+#define THREADS_LEAVE _Pragma("GCC error \"THREADS_LEAVE has been deprecated in Remmina 1.2\"")
+
+
+#define MAX_PATH_LEN 255
+
+#define MAX_X_DISPLAY_NUMBER 99
+#define X_UNIX_SOCKET "/tmp/.X11-unix/X%d"
+
+#define CHAR_DELIMITOR ','
+#define STRING_DELIMITOR ","
+#define STRING_DELIMITOR2 "§"
+
+#define MOUSE_BUTTON_LEFT 1
+#define MOUSE_BUTTON_MIDDLE 2
+#define MOUSE_BUTTON_RIGHT 3
+
+/* Bind a template widget to its class member and callback */
+#define BIND_TEMPLATE_CHILD(wc, type, action, callback) \
+	gtk_widget_class_bind_template_child(wc, type, action); \
+	gtk_widget_class_bind_template_callback(wc, callback);
+
+G_BEGIN_DECLS
+
+/* items is separated by STRING_DELIMTOR */
+GtkWidget *remmina_public_create_combo_entry(const gchar *text, const gchar *def, gboolean descending);
+GtkWidget *remmina_public_create_combo_text_d(const gchar *text, const gchar *def, const gchar *empty_choice);
+void remmina_public_load_combo_text_d(GtkWidget *combo, const gchar *text, const gchar *def, const gchar *empty_choice);
+GtkWidget *remmina_public_create_combo(gboolean use_icon);
+GtkWidget *remmina_public_create_combo_map(const gpointer *key_value_list, const gchar *def, gboolean use_icon, const gchar *domain);
+GtkWidget *remmina_public_create_combo_mapint(const gpointer *key_value_list, gint def, gboolean use_icon, const gchar *domain);
+
+void remmina_public_create_group(GtkGrid *grid, const gchar *group, gint row, gint rows, gint cols);
+
+gchar *remmina_public_combo_get_active_text(GtkComboBox *combo);
+
+#if !GTK_CHECK_VERSION(3, 22, 0)
+/* A function for gtk_menu_popup to get the position right below the widget specified by user_data */
+void remmina_public_popup_position(GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer user_data);
+#endif
+
+/* Combine two paths into one by correctly handling trailing slash. Return newly allocated string */
+gchar *remmina_public_combine_path(const gchar *path1, const gchar *path2);
+
+/**
+ * Return a file descriptor handle for a unix socket
+ * @return a file descriptor (socket) or -1
+ *
+ * */
+gint remmina_public_open_unix_sock(const char *unixsock);
+
+/* Parse a server entry with server name and port */
+void remmina_public_get_server_port_old(const gchar *server, gint defaultport, gchar **host, gint *port);
+void remmina_public_get_server_port(const gchar *server, gint defaultport, gchar **host, gint *port);
+
+/* X */
+gboolean remmina_public_get_xauth_cookie(const gchar *display, gchar **msg);
+gint remmina_public_open_xdisplay(const gchar *disp);
+
+/* Find hardware keycode for the requested keyval */
+guint16 remmina_public_get_keycode_for_keyval(GdkKeymap *keymap, guint keyval);
+/* Check if the requested keycode is a key modifier */
+gboolean remmina_public_get_modifier_for_keycode(GdkKeymap *keymap, guint16 keycode);
+/* Load a GtkBuilder object from a filename */
+GtkBuilder *remmina_public_gtk_builder_new_from_file(gchar *filename);
+/* Load a GtkBuilder object from a resource */
+GtkBuilder *remmina_public_gtk_builder_new_from_resource(gchar *resource);
+/* Change parent container for a widget */
+void remmina_public_gtk_widget_reparent(GtkWidget *widget, GtkContainer *container);
+/* Used to send desktop notifications */
+void remmina_public_send_notification(const gchar *notification_id, const gchar *notification_title, const gchar *notification_message);
+/* Validate the inserted value for a new resolution */
+gboolean remmina_public_resolution_validation_func(const gchar *new_str, gchar **error);
+/* Replaces all occurrences of search in a new copy of string by replacement. */
+gchar *remmina_public_str_replace(const gchar *string, const gchar *search, const gchar *replacement);
+/* Replaces all occurrences of search in a new copy of string by replacement
+ * and overwrites the original string */
+gchar *remmina_public_str_replace_in_place(gchar *string, const gchar *search, const gchar *replacement);
+int remmina_public_split_resolution_string(const char *resolution_string, int *w, int *h);
+gboolean remmina_gtk_check_version(guint major, guint minor, guint micro);
diff --git a/src/remmina_scheduler.c b/src/remmina_scheduler.c
new file mode 100644
index 0000000..bdabc71
--- /dev/null
+++ b/src/remmina_scheduler.c
@@ -0,0 +1,90 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * 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 <stdlib.h>
+#include <gio/gio.h>
+#include <glib/gi18n.h>
+#include <string.h>
+#include "remmina_scheduler.h"
+#include "remmina/remmina_trace_calls.h"
+
+static gboolean remmina_scheduler_periodic_check(gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	rsSchedData *rssd = (rsSchedData *)user_data;
+
+	rssd->count++;
+	if (rssd->cb_func_ptr(rssd->cb_func_data) == G_SOURCE_REMOVE) {
+		g_free(rssd);
+		return G_SOURCE_REMOVE;
+	}
+	if (rssd->count <= 1) {
+		rssd->source = g_timeout_add_full(G_PRIORITY_LOW,
+						  rssd->interval,
+						  remmina_scheduler_periodic_check,
+						  rssd,
+						  NULL);
+		return G_SOURCE_REMOVE;
+	}
+	return G_SOURCE_CONTINUE;
+}
+
+void *remmina_scheduler_setup(GSourceFunc	cb,
+			      gpointer		cb_data,
+			      guint		first_interval,
+			      guint		interval)
+{
+	TRACE_CALL(__func__);
+	rsSchedData *rssd;
+	rssd = g_malloc(sizeof(rsSchedData));
+	rssd->cb_func_ptr = cb;
+	rssd->cb_func_data = cb_data;
+	rssd->interval = interval;
+	rssd->count = 0;
+	rssd->source = g_timeout_add_full(G_PRIORITY_LOW,
+					  first_interval,
+					  remmina_scheduler_periodic_check,
+					  rssd,
+					  NULL);
+	return (void *)rssd;
+}
+
+void remmina_schedluer_remove(void *s)
+{
+	TRACE_CALL(__func__);
+	rsSchedData *rssd = (rsSchedData *)s;
+	g_source_remove(rssd->source);
+	g_free(rssd);
+}
diff --git a/src/remmina_scheduler.h b/src/remmina_scheduler.h
new file mode 100644
index 0000000..10809a4
--- /dev/null
+++ b/src/remmina_scheduler.h
@@ -0,0 +1,51 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * 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.
+ *
+ */
+
+#pragma once
+
+#include <glib.h>
+
+typedef struct {
+	GSourceFunc	cb_func_ptr;
+	gpointer	cb_func_data;
+	guint		interval;
+	guint		source;
+	guint		count;
+} rsSchedData;
+
+G_BEGIN_DECLS
+
+void *remmina_scheduler_setup(GSourceFunc cb, gpointer cb_data, guint first_interval, guint interval);
+
+G_END_DECLS
diff --git a/src/remmina_scrolled_viewport.c b/src/remmina_scrolled_viewport.c
new file mode 100644
index 0000000..cb858e8
--- /dev/null
+++ b/src/remmina_scrolled_viewport.c
@@ -0,0 +1,218 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009 - 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 <gtk/gtk.h>
+#include "config.h"
+#include "remmina_scrolled_viewport.h"
+#include "remmina_pref.h"
+#include "remmina_log.h"
+#include "remmina/remmina_trace_calls.h"
+
+G_DEFINE_TYPE( RemminaScrolledViewport, remmina_scrolled_viewport, GTK_TYPE_EVENT_BOX)
+
+static void remmina_scrolled_viewport_get_preferred_width(GtkWidget* widget, gint* minimum_width, gint* natural_width)
+{
+	TRACE_CALL(__func__);
+	/* Just return a fake small size, so gtk_window_fullscreen() will not fail
+	 * because our content is too big*/
+	if (minimum_width != NULL) *minimum_width = 100;
+	if (natural_width != NULL) *natural_width = 100;
+}
+
+static void remmina_scrolled_viewport_get_preferred_height(GtkWidget* widget, gint* minimum_height, gint* natural_height)
+{
+	TRACE_CALL(__func__);
+	/* Just return a fake small size, so gtk_window_fullscreen() will not fail
+	 * because our content is too big*/
+	if (minimum_height != NULL) *minimum_height = 100;
+	if (natural_height != NULL) *natural_height = 100;
+}
+
+/* Event handler when mouse move on borders
+ * Note that this handler may repeat itself. Zeroing out viewport_motion_handler before returning FALSE will
+ * relay the fact that this specific occurrence of timeout has been cancelled.
+ * A new one may be scheduled if the mouse pointer moves to the edge again.
+ */
+static gboolean remmina_scrolled_viewport_motion_timeout(gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaScrolledViewport *gsv;
+	GtkWidget *child;
+	GdkDisplay *display;
+#if GTK_CHECK_VERSION(3, 20, 0)
+	GdkSeat *seat;
+#else
+	GdkDeviceManager *device_manager;
+#endif
+	GdkDevice *pointer;
+	GdkScreen *screen;
+	GdkWindow *gsvwin;
+	gint x, y, mx, my, w, h, rootx, rooty;
+	GtkAdjustment *adj;
+	gdouble value;
+
+	gsv = REMMINA_SCROLLED_VIEWPORT(data);
+	if (!gsv || !gsv->viewport_motion_handler)
+		// Either the pointer is nullptr or the source id is already 0
+		return FALSE;
+	if (!REMMINA_IS_SCROLLED_VIEWPORT(data)) {
+		gsv->viewport_motion_handler = 0;
+		return FALSE;
+	}
+	if (!GTK_IS_BIN(data)) {
+		gsv->viewport_motion_handler = 0;
+		return FALSE;
+	}
+
+	child = gtk_bin_get_child(GTK_BIN(gsv));
+	if (!GTK_IS_VIEWPORT(child)) {
+		gsv->viewport_motion_handler = 0;
+		return FALSE;
+	}
+
+	gsvwin = gtk_widget_get_window(GTK_WIDGET(gsv));
+	display = gdk_display_get_default();
+	if (!display) {
+		gsv->viewport_motion_handler = 0;
+		return FALSE;
+	}
+
+#if GTK_CHECK_VERSION(3, 20, 0)
+	seat = gdk_display_get_default_seat(display);
+	pointer = gdk_seat_get_pointer(seat);
+#else
+	device_manager = gdk_display_get_device_manager(display);
+	pointer = gdk_device_manager_get_client_pointer(device_manager);
+#endif
+	gdk_device_get_position(pointer, &screen, &x, &y);
+
+	w = gdk_window_get_width(gsvwin) + SCROLL_BORDER_SIZE;   // Add 2px of black scroll border
+	h = gdk_window_get_height(gsvwin) + SCROLL_BORDER_SIZE;  // Add 2px of black scroll border
+
+	gdk_window_get_root_origin(gsvwin, &rootx, &rooty );
+
+	x -= rootx;
+	y -= rooty;
+
+	mx = (x <= 0 ? -1 : (x >= w - 1 ? 1 : 0));
+	my = (y <= 0 ? -1 : (y >= h - 1 ? 1 : 0));
+	if (mx != 0) {
+		gint step = MAX(10, MIN(remmina_pref.auto_scroll_step, w / 5));
+		adj = gtk_scrollable_get_hadjustment(GTK_SCROLLABLE(child));
+		value = gtk_adjustment_get_value(GTK_ADJUSTMENT(adj)) + (gdouble)(mx * step);
+		value = MAX(0, MIN(value, gtk_adjustment_get_upper(GTK_ADJUSTMENT(adj)) - (gdouble)w + 2.0));
+		gtk_adjustment_set_value(GTK_ADJUSTMENT(adj), value);
+	}
+	if (my != 0) {
+		gint step = MAX(10, MIN(remmina_pref.auto_scroll_step, h / 5));
+		adj = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(child));
+		value = gtk_adjustment_get_value(GTK_ADJUSTMENT(adj)) + (gdouble)(my * step);
+		value = MAX(0, MIN(value, gtk_adjustment_get_upper(GTK_ADJUSTMENT(adj)) - (gdouble)h + 2.0));
+		gtk_adjustment_set_value(GTK_ADJUSTMENT(adj), value);
+	}
+	return TRUE;
+}
+
+static gboolean remmina_scrolled_viewport_enter(GtkWidget *widget, GdkEventCrossing *event, gpointer data)
+{
+	TRACE_CALL(__func__);
+	remmina_scrolled_viewport_remove_motion(REMMINA_SCROLLED_VIEWPORT(widget));
+	return FALSE;
+}
+
+static gboolean remmina_scrolled_viewport_leave(GtkWidget *widget, GdkEventCrossing *event, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaScrolledViewport *gsv = REMMINA_SCROLLED_VIEWPORT(widget);
+        if (gsv->viewport_motion_handler) {
+           REMMINA_DEBUG("cleaning motion ...");
+           remmina_scrolled_viewport_remove_motion(gsv);
+        }
+	gsv->viewport_motion_handler = g_timeout_add(20, remmina_scrolled_viewport_motion_timeout, gsv);
+	return FALSE;
+}
+
+static void remmina_scrolled_viewport_destroy(GtkWidget *widget, gpointer data)
+{
+	TRACE_CALL(__func__);
+	remmina_scrolled_viewport_remove_motion(REMMINA_SCROLLED_VIEWPORT(widget));
+}
+
+static void remmina_scrolled_viewport_class_init(RemminaScrolledViewportClass *klass)
+{
+	TRACE_CALL(__func__);
+	GtkWidgetClass *widget_class;
+	widget_class = (GtkWidgetClass*)klass;
+
+	widget_class->get_preferred_width = remmina_scrolled_viewport_get_preferred_width;
+	widget_class->get_preferred_height = remmina_scrolled_viewport_get_preferred_height;
+
+}
+
+static void remmina_scrolled_viewport_init(RemminaScrolledViewport *gsv)
+{
+	TRACE_CALL(__func__);
+}
+
+void remmina_scrolled_viewport_remove_motion(RemminaScrolledViewport *gsv)
+{
+	TRACE_CALL(__func__);
+	guint handler = gsv->viewport_motion_handler;
+	if (handler) {
+		gsv->viewport_motion_handler = 0;
+		g_source_remove(handler);
+	}
+}
+
+GtkWidget*
+remmina_scrolled_viewport_new(void)
+{
+	TRACE_CALL(__func__);
+	RemminaScrolledViewport *gsv;
+
+	gsv = REMMINA_SCROLLED_VIEWPORT(g_object_new(REMMINA_TYPE_SCROLLED_VIEWPORT, NULL));
+
+	gsv->viewport_motion_handler = 0;
+
+	gtk_widget_set_size_request(GTK_WIDGET(gsv), 1, 1);
+	gtk_widget_add_events(GTK_WIDGET(gsv), GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
+	g_signal_connect(G_OBJECT(gsv), "destroy", G_CALLBACK(remmina_scrolled_viewport_destroy), NULL);
+	g_signal_connect(G_OBJECT(gsv), "enter-notify-event", G_CALLBACK(remmina_scrolled_viewport_enter), NULL);
+	g_signal_connect(G_OBJECT(gsv), "leave-notify-event", G_CALLBACK(remmina_scrolled_viewport_leave), NULL);
+
+	return GTK_WIDGET(gsv);
+}
+
diff --git a/src/remmina_scrolled_viewport.h b/src/remmina_scrolled_viewport.h
new file mode 100644
index 0000000..39088d4
--- /dev/null
+++ b/src/remmina_scrolled_viewport.h
@@ -0,0 +1,74 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009 - Vic Lee
+ * Copyright (C) 2017-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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define REMMINA_TYPE_SCROLLED_VIEWPORT \
+	(remmina_scrolled_viewport_get_type())
+#define REMMINA_SCROLLED_VIEWPORT(obj) \
+	(G_TYPE_CHECK_INSTANCE_CAST((obj), REMMINA_TYPE_SCROLLED_VIEWPORT, RemminaScrolledViewport))
+#define REMMINA_SCROLLED_VIEWPORT_CLASS(klass) \
+	(G_TYPE_CHECK_CLASS_CAST((klass), REMMINA_TYPE_SCROLLED_VIEWPORT, RemminaScrolledViewportClass))
+#define REMMINA_IS_SCROLLED_VIEWPORT(obj) \
+	(G_TYPE_CHECK_INSTANCE_TYPE((obj), REMMINA_TYPE_SCROLLED_VIEWPORT))
+#define REMMINA_IS_SCROLLED_VIEWPORT_CLASS(klass) \
+	(G_TYPE_CHECK_CLASS_TYPE((klass), REMMINA_TYPE_SCROLLED_VIEWPORT))
+#define REMMINA_SCROLLED_VIEWPORT_GET_CLASS(obj) \
+	(G_TYPE_INSTANCE_GET_CLASS((obj), REMMINA_TYPE_SCROLLED_VIEWPORT, RemminaScrolledViewportClass))
+
+typedef struct _RemminaScrolledViewport {
+	GtkEventBox	event_box;
+
+	/* Motion activates in Viewport Fullscreen mode */
+	guint		viewport_motion_handler;
+} RemminaScrolledViewport;
+
+typedef struct _RemminaScrolledViewportClass {
+	GtkEventBoxClass parent_class;
+} RemminaScrolledViewportClass;
+
+GType remmina_scrolled_viewport_get_type(void)
+G_GNUC_CONST;
+
+GtkWidget *remmina_scrolled_viewport_new(void);
+void remmina_scrolled_viewport_remove_motion(RemminaScrolledViewport *gsv);
+
+#define SCROLL_BORDER_SIZE 1
+
+G_END_DECLS
diff --git a/src/remmina_sftp_client.c b/src/remmina_sftp_client.c
new file mode 100644
index 0000000..1f1e0b9
--- /dev/null
+++ b/src/remmina_sftp_client.c
@@ -0,0 +1,1057 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009-2010 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.
+ *
+ */
+
+#define _FILE_OFFSET_BITS 64
+#include "config.h"
+
+#ifdef HAVE_LIBSSH
+
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+#include <gmodule.h>
+#include <pthread.h>
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#include "remmina_public.h"
+#include "remmina_log.h"
+#include "remmina_pref.h"
+#include "remmina_ssh.h"
+#include "remmina_sftp_client.h"
+#include "remmina_sftp_plugin.h"
+#include "remmina_masterthread_exec.h"
+#include "remmina/remmina_trace_calls.h"
+
+G_DEFINE_TYPE(RemminaSFTPClient, remmina_sftp_client, REMMINA_TYPE_FTP_CLIENT)
+
+#define SET_CURSOR(cur) \
+	if (GDK_IS_WINDOW(gtk_widget_get_window(GTK_WIDGET(client)))) \
+	{ \
+		gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(client)), cur); \
+	}
+
+static void
+remmina_sftp_client_class_init(RemminaSFTPClientClass *klass)
+{
+	TRACE_CALL(__func__);
+}
+
+#define GET_SFTPATTR_TYPE(a, type) \
+	if (a->type == 0) \
+	{ \
+		type = ((a->permissions & 040000) ? REMMINA_FTP_FILE_TYPE_DIR : REMMINA_FTP_FILE_TYPE_FILE); \
+		type = ((a->permissions & 0120000) ? REMMINA_FTP_FILE_TYPE_LINK : REMMINA_FTP_FILE_TYPE_FILE); \
+	} \
+	else \
+	{ \
+		type = (a->type == SSH_FILEXFER_TYPE_DIRECTORY ? REMMINA_FTP_FILE_TYPE_DIR : REMMINA_FTP_FILE_TYPE_FILE); \
+		if (a->type == SSH_FILEXFER_TYPE_SYMLINK ) type = REMMINA_FTP_FILE_TYPE_LINK; \
+	}
+
+/* ------------------------ The Task Thread routines ----------------------------- */
+
+static gboolean remmina_sftp_client_refresh(RemminaSFTPClient *client);
+
+#define THREAD_CHECK_EXIT \
+	(!client->taskid || client->thread_abort)
+
+
+
+static gboolean
+remmina_sftp_client_thread_update_task(RemminaSFTPClient *client, RemminaFTPTask *task)
+{
+	TRACE_CALL(__func__);
+	if (THREAD_CHECK_EXIT) return FALSE;
+
+	remmina_ftp_client_update_task(REMMINA_FTP_CLIENT(client), task);
+
+	return TRUE;
+}
+
+static void
+remmina_sftp_client_thread_set_error(RemminaSFTPClient *client, RemminaFTPTask *task, const gchar *error_format, ...)
+{
+	TRACE_CALL(__func__);
+	va_list args;
+
+	task->status = REMMINA_FTP_TASK_STATUS_ERROR;
+	g_free(task->tooltip);
+	if (error_format) {
+		va_start(args, error_format);
+		task->tooltip = g_strdup_vprintf(error_format, args);
+		va_end(args);
+	} else {
+		task->tooltip = NULL;
+	}
+
+	remmina_sftp_client_thread_update_task(client, task);
+}
+
+static void
+remmina_sftp_client_thread_set_finish(RemminaSFTPClient *client, RemminaFTPTask *task)
+{
+	TRACE_CALL(__func__);
+	task->status = REMMINA_FTP_TASK_STATUS_FINISH;
+	g_free(task->tooltip);
+	task->tooltip = NULL;
+
+	remmina_sftp_client_thread_update_task(client, task);
+}
+
+static RemminaFTPTask *
+remmina_sftp_client_thread_get_task(RemminaSFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	RemminaFTPTask *task;
+
+	if (client->thread_abort) return NULL;
+
+	task = remmina_ftp_client_get_waiting_task(REMMINA_FTP_CLIENT(client));
+	if (task) {
+		client->taskid = task->taskid;
+
+		task->status = REMMINA_FTP_TASK_STATUS_RUN;
+		remmina_ftp_client_update_task(REMMINA_FTP_CLIENT(client), task);
+	}
+
+	return task;
+}
+
+static gboolean
+remmina_sftp_client_thread_download_file(RemminaSFTPClient *client, RemminaSFTP *sftp, RemminaFTPTask *task,
+					 const gchar *remote_path, const gchar *local_path, guint64 *donesize)
+{
+	TRACE_CALL(__func__);
+	sftp_file remote_file;
+	FILE *local_file;
+	gchar *tmp;
+	gchar buf[20480];
+	gint len;
+	gint response;
+	uint64_t size;
+
+	if (THREAD_CHECK_EXIT) return FALSE;
+
+	/* Ensure local dir exists */
+	g_strlcpy(buf, local_path, sizeof(buf));
+	tmp = g_strrstr(buf, "/");
+	if (tmp && tmp != buf) {
+		*tmp = '\0';
+		if (g_mkdir_with_parents(buf, 0755) < 0) {
+			// TRANSLATORS: The placeholder %s is a directory path
+			remmina_sftp_client_thread_set_error(client, task, _("Could not create the folder “%s”."), buf);
+			return FALSE;
+		}
+	}
+
+	local_file = g_fopen(local_path, "ab");
+	if (!local_file) {
+		// TRANSLATORS: The placeholder %s is a file path
+		remmina_sftp_client_thread_set_error(client, task, _("Could not create the file “%s”."), local_path);
+		return FALSE;
+	}
+
+	fseeko(local_file, 0, SEEK_END);
+	size = ftello(local_file);
+	if (size > 0) {
+		response = remmina_sftp_client_confirm_resume(client, local_path);
+
+		switch (response) {
+		case GTK_RESPONSE_CANCEL:
+		case GTK_RESPONSE_DELETE_EVENT:
+			fclose(local_file);
+			remmina_sftp_client_thread_set_error(client, task, NULL);
+			return FALSE;
+
+		case GTK_RESPONSE_ACCEPT:
+			fclose(local_file);
+			local_file = g_fopen(local_path, "wb");
+			if (!local_file) {
+				// TRANSLATORS: The placeholder %s is a file path
+				remmina_sftp_client_thread_set_error(client, task, _("Could not create the file “%s”."), local_path);
+				return FALSE;
+			}
+			size = 0;
+			break;
+
+		case GTK_RESPONSE_APPLY:
+			break;
+		}
+	}
+
+	tmp = remmina_ssh_unconvert(REMMINA_SSH(sftp), remote_path);
+	remote_file = sftp_open(sftp->sftp_sess, tmp, O_RDONLY, 0);
+	g_free(tmp);
+
+	if (!remote_file) {
+		fclose(local_file);
+		// TRANSLATORS: The placeholders %s are a file path, and an error message.
+		remmina_sftp_client_thread_set_error(client, task, _("Could not open the file “%s” on the server. %s"),
+						     remote_path, ssh_get_error(REMMINA_SSH(client->sftp)->session));
+		return FALSE;
+	}
+
+	if (size > 0) {
+		if (sftp_seek64(remote_file, size) < 0) {
+			sftp_close(remote_file);
+			fclose(local_file);
+			remmina_sftp_client_thread_set_error(client, task, "Could not download the file “%s”. %s",
+							     remote_path, ssh_get_error(REMMINA_SSH(client->sftp)->session));
+			return FALSE;
+		}
+		*donesize = size;
+	}
+
+	while (!THREAD_CHECK_EXIT && (len = sftp_read(remote_file, buf, sizeof(buf))) > 0) {
+		if (THREAD_CHECK_EXIT) break;
+
+		if (fwrite(buf, 1, len, local_file) < len) {
+			sftp_close(remote_file);
+			fclose(local_file);
+			remmina_sftp_client_thread_set_error(client, task, _("Could not save the file “%s”."), local_path);
+			return FALSE;
+		}
+
+		*donesize += (guint64)len;
+		task->donesize = (gfloat)(*donesize);
+
+		if (!remmina_sftp_client_thread_update_task(client, task)) break;
+	}
+
+	sftp_close(remote_file);
+	fclose(local_file);
+	return TRUE;
+}
+
+static gboolean
+remmina_sftp_client_thread_recursive_dir(RemminaSFTPClient *client, RemminaSFTP *sftp, RemminaFTPTask *task,
+					 const gchar *rootdir_path, const gchar *subdir_path, GPtrArray *array)
+{
+	TRACE_CALL(__func__);
+	sftp_dir sftpdir;
+	sftp_attributes sftpattr;
+	gchar *tmp;
+	gchar *dir_path;
+	gchar *file_path;
+	gint type;
+	gboolean ret = TRUE;
+
+	if (THREAD_CHECK_EXIT) return FALSE;
+
+	if (subdir_path)
+		dir_path = remmina_public_combine_path(rootdir_path, subdir_path);
+	else
+		dir_path = g_strdup(rootdir_path);
+	tmp = remmina_ssh_unconvert(REMMINA_SSH(sftp), dir_path);
+
+	REMMINA_DEBUG ("%s HELLO", __func__);
+#if 0
+	gchar *tlink = sftp_readlink (sftp->sftp_sess, tmp);
+	if (tlink) {
+		REMMINA_DEBUG ("%s is a link to %s", tmp, tlink);
+		tmp = g_strdup (tlink);
+	}
+	g_free(tlink);
+#endif
+	sftpdir = sftp_opendir(sftp->sftp_sess, tmp);
+	g_free(tmp);
+
+	if (!sftpdir) {
+		remmina_sftp_client_thread_set_error(client, task, _("Could not open the folder “%s”. %s"),
+						     dir_path, ssh_get_error(REMMINA_SSH(client->sftp)->session));
+		g_free(dir_path);
+		return FALSE;
+	}
+
+	g_free(dir_path);
+
+	while ((sftpattr = sftp_readdir(sftp->sftp_sess, sftpdir))) {
+		if (g_strcmp0(sftpattr->name, ".") != 0 &&
+		    g_strcmp0(sftpattr->name, "..") != 0) {
+			GET_SFTPATTR_TYPE(sftpattr, type);
+
+			tmp = remmina_ssh_convert(REMMINA_SSH(sftp), sftpattr->name);
+			if (subdir_path) {
+				file_path = remmina_public_combine_path(subdir_path, tmp);
+				g_free(tmp);
+			} else {
+				file_path = tmp;
+			}
+
+			if (type == REMMINA_FTP_FILE_TYPE_DIR) {
+				ret = remmina_sftp_client_thread_recursive_dir(client, sftp, task, rootdir_path, file_path, array);
+				g_free(file_path);
+				if (!ret) {
+					sftp_attributes_free(sftpattr);
+					break;
+				}
+			} else {
+				task->size += (gfloat)sftpattr->size;
+				g_ptr_array_add(array, file_path);
+
+				if (!remmina_sftp_client_thread_update_task(client, task)) {
+					sftp_attributes_free(sftpattr);
+					break;
+				}
+			}
+		}
+		sftp_attributes_free(sftpattr);
+
+		if (THREAD_CHECK_EXIT) break;
+	}
+
+	sftp_closedir(sftpdir);
+	return ret;
+}
+
+static gboolean
+remmina_sftp_client_thread_recursive_localdir(RemminaSFTPClient *client, RemminaFTPTask *task,
+					      const gchar *rootdir_path, const gchar *subdir_path, GPtrArray *array)
+{
+	TRACE_CALL(__func__);
+	GDir *dir;
+	gchar *path;
+	const gchar *name;
+	gchar *relpath;
+	gchar *abspath;
+	struct stat st;
+	gboolean ret = TRUE;
+
+	path = g_build_filename(rootdir_path, subdir_path, NULL);
+	dir = g_dir_open(path, 0, NULL);
+	if (dir == NULL) {
+		g_free(path);
+		return FALSE;
+	}
+	while ((name = g_dir_read_name(dir)) != NULL) {
+		if (THREAD_CHECK_EXIT) {
+			ret = FALSE;
+			break;
+		}
+		if (g_strcmp0(name, ".") == 0 || g_strcmp0(name, "..") == 0) continue;
+		abspath = g_build_filename(path, name, NULL);
+		if (g_stat(abspath, &st) < 0) {
+			g_free(abspath);
+			continue;
+		}
+		relpath = g_build_filename(subdir_path ? subdir_path : "", name, NULL);
+		g_ptr_array_add(array, relpath);
+		if (g_file_test(abspath, G_FILE_TEST_IS_DIR)) {
+			ret = remmina_sftp_client_thread_recursive_localdir(client, task, rootdir_path, relpath, array);
+			if (!ret) break;
+		} else {
+			task->size += (gfloat)st.st_size;
+		}
+		g_free(abspath);
+	}
+	g_free(path);
+	g_dir_close(dir);
+	return ret;
+}
+
+static gboolean
+remmina_sftp_client_thread_mkdir(RemminaSFTPClient *client, RemminaSFTP *sftp, RemminaFTPTask *task, const gchar *path)
+{
+	TRACE_CALL(__func__);
+	sftp_attributes sftpattr;
+
+	sftpattr = sftp_stat(sftp->sftp_sess, path);
+	if (sftpattr != NULL) {
+		sftp_attributes_free(sftpattr);
+		return TRUE;
+	}
+	if (sftp_mkdir(sftp->sftp_sess, path, 0755) < 0) {
+		remmina_sftp_client_thread_set_error(client, task, _("Could not create the folder “%s” on the server. %s"),
+						     path, ssh_get_error(REMMINA_SSH(client->sftp)->session));
+		return FALSE;
+	}
+	return TRUE;
+}
+
+static gboolean
+remmina_sftp_client_thread_upload_file(RemminaSFTPClient *client, RemminaSFTP *sftp, RemminaFTPTask *task,
+				       const gchar *remote_path, const gchar *local_path, guint64 *donesize)
+{
+	TRACE_CALL(__func__);
+	sftp_file remote_file;
+	FILE *local_file;
+	gchar *tmp;
+	gchar buf[20480];
+	gint len;
+	sftp_attributes attr;
+	gint response;
+	uint64_t size;
+
+	if (THREAD_CHECK_EXIT) return FALSE;
+
+	tmp = remmina_ssh_unconvert(REMMINA_SSH(sftp), remote_path);
+	remote_file = sftp_open(sftp->sftp_sess, tmp, O_WRONLY | O_CREAT, 0644);
+	g_free(tmp);
+
+	if (!remote_file) {
+		remmina_sftp_client_thread_set_error(client, task, _("Could not create the file “%s” on the server. %s"),
+						     remote_path, ssh_get_error(REMMINA_SSH(client->sftp)->session));
+		return FALSE;
+	}
+	attr = sftp_fstat(remote_file);
+	size = attr->size;
+	sftp_attributes_free(attr);
+	if (size > 0) {
+		response = remmina_sftp_client_confirm_resume(client, remote_path);
+		switch (response) {
+		case GTK_RESPONSE_CANCEL:
+		case GTK_RESPONSE_DELETE_EVENT:
+			sftp_close(remote_file);
+			remmina_sftp_client_thread_set_error(client, task, NULL);
+			return FALSE;
+
+		case GTK_RESPONSE_ACCEPT:
+			sftp_close(remote_file);
+			tmp = remmina_ssh_unconvert(REMMINA_SSH(sftp), remote_path);
+			remote_file = sftp_open(sftp->sftp_sess, tmp, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+			g_free(tmp);
+			if (!remote_file) {
+				remmina_sftp_client_thread_set_error(client, task, _("Could not create the file “%s” on the server. %s"),
+								     remote_path, ssh_get_error(REMMINA_SSH(client->sftp)->session));
+				return FALSE;
+			}
+			size = 0;
+			break;
+
+		case GTK_RESPONSE_APPLY:
+			if (sftp_seek64(remote_file, size) < 0) {
+				sftp_close(remote_file);
+				remmina_sftp_client_thread_set_error(client, task, "Could not download the file “%s”. %s",
+								     remote_path, ssh_get_error(REMMINA_SSH(client->sftp)->session));
+				return FALSE;
+			}
+			break;
+		}
+	}
+
+	local_file = g_fopen(local_path, "rb");
+	if (!local_file) {
+		sftp_close(remote_file);
+		remmina_sftp_client_thread_set_error(client, task, _("Could not open the file “%s”."), local_path);
+		return FALSE;
+	}
+
+	if (size > 0) {
+		if (fseeko(local_file, size, SEEK_SET) < 0) {
+			sftp_close(remote_file);
+			fclose(local_file);
+			remmina_sftp_client_thread_set_error(client, task, "Could not find the local file “%s”.", local_path);
+			return FALSE;
+		}
+		*donesize = size;
+	}
+
+	while (!THREAD_CHECK_EXIT && (len = fread(buf, 1, sizeof(buf), local_file)) > 0) {
+		if (THREAD_CHECK_EXIT) break;
+
+		if (sftp_write(remote_file, buf, len) < len) {
+			sftp_close(remote_file);
+			fclose(local_file);
+			remmina_sftp_client_thread_set_error(client, task, _("Could not write to the file “%s” on the server. %s"),
+							     remote_path, ssh_get_error(REMMINA_SSH(client->sftp)->session));
+			return FALSE;
+		}
+
+		*donesize += (guint64)len;
+		task->donesize = (gfloat)(*donesize);
+
+		if (!remmina_sftp_client_thread_update_task(client, task)) break;
+	}
+
+	sftp_close(remote_file);
+	fclose(local_file);
+	return TRUE;
+}
+
+static gpointer
+remmina_sftp_client_thread_main(gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaSFTPClient *client = REMMINA_SFTP_CLIENT(data);
+	RemminaSFTP *sftp = NULL;
+	RemminaFTPTask *task;
+	gchar *remote, *local;
+	guint64 size;
+	GPtrArray *array;
+	gint i;
+	gchar *remote_file, *local_file;
+	gboolean ret;
+	gchar *refreshdir = NULL;
+	gchar *tmp;
+	gboolean refresh = FALSE;
+	gchar *host;
+	int port;
+
+	task = remmina_sftp_client_thread_get_task(client);
+	while (task) {
+		size = 0;
+		if (!sftp) {
+			sftp = remmina_sftp_new_from_ssh(REMMINA_SSH(client->sftp));
+
+			/* we may need to open a new tunnel too */
+			host = NULL;
+			port = 0;
+			if (!remmina_plugin_sftp_start_direct_tunnel(client->gp, &host, &port))
+				return NULL;
+			(REMMINA_SSH(sftp))->tunnel_entrance_host = host;
+			(REMMINA_SSH(sftp))->tunnel_entrance_port = port;
+
+			/* Open a new connection for this subcommand */
+			g_debug("[SFTPCLI] %s opening ssh session to %s:%d", __func__, host, port);
+			if (!remmina_ssh_init_session(REMMINA_SSH(sftp))) {
+				g_debug("[SFTPCLI] remmina_ssh_init_session returned error %s\n", (REMMINA_SSH(sftp))->error);
+				remmina_sftp_client_thread_set_error(client, task, (REMMINA_SSH(sftp))->error);
+				remmina_ftp_task_free(task);
+				break;
+			}
+
+			if (remmina_ssh_auth(REMMINA_SSH(sftp), REMMINA_SSH(sftp)->password, client->gp, NULL) != REMMINA_SSH_AUTH_SUCCESS) {
+				g_debug("[SFTPCLI] remmina_ssh_auth returned error %s\n", (REMMINA_SSH(sftp))->error);
+				remmina_sftp_client_thread_set_error(client, task, (REMMINA_SSH(sftp))->error);
+				remmina_ftp_task_free(task);
+				break;
+			}
+
+			if (!remmina_sftp_open(sftp)) {
+				g_debug("[SFTPCLI] remmina_sftp_open returned error %s\n", (REMMINA_SSH(sftp))->error);
+				remmina_sftp_client_thread_set_error(client, task, (REMMINA_SSH(sftp))->error);
+				remmina_ftp_task_free(task);
+				break;
+			}
+		}
+
+		remote = remmina_public_combine_path(task->remotedir, task->name);
+		local = remmina_public_combine_path(task->localdir, task->name);
+
+		switch (task->tasktype) {
+		case REMMINA_FTP_TASK_TYPE_DOWNLOAD:
+			switch (task->type) {
+			case REMMINA_FTP_FILE_TYPE_FILE:
+				ret = remmina_sftp_client_thread_download_file(client, sftp, task,
+									       remote, local, &size);
+				break;
+
+			case REMMINA_FTP_FILE_TYPE_DIR:
+				array = g_ptr_array_new();
+				ret = remmina_sftp_client_thread_recursive_dir(client, sftp, task, remote, NULL, array);
+				if (ret) {
+					for (i = 0; i < array->len; i++) {
+						if (THREAD_CHECK_EXIT) {
+							ret = FALSE;
+							break;
+						}
+						remote_file = remmina_public_combine_path(remote, (gchar *)g_ptr_array_index(array, i));
+						local_file = remmina_public_combine_path(local, (gchar *)g_ptr_array_index(array, i));
+						ret = remmina_sftp_client_thread_download_file(client, sftp, task,
+											       remote_file, local_file, &size);
+						g_free(remote_file);
+						g_free(local_file);
+						if (!ret) break;
+					}
+				}
+				g_ptr_array_foreach(array, (GFunc)g_free, NULL);
+				g_ptr_array_free(array, TRUE);
+				break;
+
+			default:
+				ret = 0;
+				break;
+			}
+			if (ret)
+				remmina_sftp_client_thread_set_finish(client, task);
+			break;
+
+		case REMMINA_FTP_TASK_TYPE_UPLOAD:
+			switch (task->type) {
+			case REMMINA_FTP_FILE_TYPE_FILE:
+				ret = remmina_sftp_client_thread_upload_file(client, sftp, task,
+									     remote, local, &size);
+				break;
+
+			case REMMINA_FTP_FILE_TYPE_DIR:
+				ret = remmina_sftp_client_thread_mkdir(client, sftp, task, remote);
+				if (!ret) break;
+				array = g_ptr_array_new();
+				ret = remmina_sftp_client_thread_recursive_localdir(client, task, local, NULL, array);
+				if (ret) {
+					for (i = 0; i < array->len; i++) {
+						if (THREAD_CHECK_EXIT) {
+							ret = FALSE;
+							break;
+						}
+						remote_file = remmina_public_combine_path(remote, (gchar *)g_ptr_array_index(array, i));
+						local_file = g_build_filename(local, (gchar *)g_ptr_array_index(array, i), NULL);
+						if (g_file_test(local_file, G_FILE_TEST_IS_DIR))
+							ret = remmina_sftp_client_thread_mkdir(client, sftp, task, remote_file);
+						else
+							ret = remmina_sftp_client_thread_upload_file(client, sftp, task,
+												     remote_file, local_file, &size);
+						g_free(remote_file);
+						g_free(local_file);
+						if (!ret) break;
+					}
+				}
+				g_ptr_array_foreach(array, (GFunc)g_free, NULL);
+				g_ptr_array_free(array, TRUE);
+				break;
+
+			default:
+				ret = 0;
+				break;
+			}
+			if (ret) {
+				remmina_sftp_client_thread_set_finish(client, task);
+				tmp = remmina_ftp_client_get_dir(REMMINA_FTP_CLIENT(client));
+				if (g_strcmp0(tmp, task->remotedir) == 0) {
+					refresh = TRUE;
+					g_free(refreshdir);
+					refreshdir = tmp;
+				} else {
+					g_free(tmp);
+				}
+			}
+			break;
+		}
+
+		g_free(remote);
+		g_free(local);
+
+		remmina_ftp_task_free(task);
+		client->taskid = 0;
+
+		if (client->thread_abort) break;
+
+		task = remmina_sftp_client_thread_get_task(client);
+	}
+
+	if (sftp)
+		remmina_sftp_free(sftp);
+
+	if (!client->thread_abort && refresh) {
+		tmp = remmina_ftp_client_get_dir(REMMINA_FTP_CLIENT(client));
+		if (g_strcmp0(tmp, refreshdir) == 0)
+			IDLE_ADD((GSourceFunc)remmina_sftp_client_refresh, client);
+		g_free(tmp);
+	}
+	g_free(refreshdir);
+	client->thread = 0;
+
+	return NULL;
+}
+
+/* ------------------------ The SFTP Client routines ----------------------------- */
+
+static void
+remmina_sftp_client_destroy(RemminaSFTPClient *client, gpointer data)
+{
+	TRACE_CALL(__func__);
+	if (client->sftp) {
+		remmina_sftp_free(client->sftp);
+		client->sftp = NULL;
+	}
+	client->thread_abort = TRUE;
+	/* We will wait for the thread to quit itself, and hopefully the thread is handling things correctly */
+	while (client->thread) {
+		/* gdk_threads_leave (); */
+		sleep(1);
+		/* gdk_threads_enter (); */
+	}
+}
+
+static sftp_dir
+remmina_sftp_client_sftp_session_opendir(RemminaSFTPClient *client, const gchar *dir)
+{
+	TRACE_CALL(__func__);
+	sftp_dir sftpdir;
+
+	sftpdir = sftp_opendir(client->sftp->sftp_sess, (gchar *)dir);
+	if (!sftpdir) {
+		GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(client))),
+						GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
+						_("Could not open the folder “%s”. %s"), dir,
+						ssh_get_error(REMMINA_SSH(client->sftp)->session));
+		gtk_dialog_run(GTK_DIALOG(dialog));
+		gtk_widget_destroy(dialog);
+		return NULL;
+	}
+	return sftpdir;
+}
+
+static gboolean
+remmina_sftp_client_sftp_session_closedir(RemminaSFTPClient *client, sftp_dir sftpdir)
+{
+	TRACE_CALL(__func__);
+
+	if (!sftp_dir_eof(sftpdir)) {
+		GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(client))),
+						GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
+						_("Could not read from the folder. %s"), ssh_get_error(REMMINA_SSH(client->sftp)->session));
+		gtk_dialog_run(GTK_DIALOG(dialog));
+		gtk_widget_destroy(dialog);
+		return FALSE;
+	}
+	sftp_closedir(sftpdir);
+	return TRUE;
+}
+
+static void
+remmina_sftp_client_on_opendir(RemminaSFTPClient *client, gchar *dir, gpointer data)
+{
+	TRACE_CALL(__func__);
+	sftp_dir sftpdir;
+	sftp_attributes sftpattr;
+	GtkWidget *dialog;
+	gchar *newdir;
+	gchar *newdir_conv;
+	gchar *tmp;
+	gint type;
+
+	if (client->sftp == NULL) return;
+
+	if (!dir || dir[0] == '\0') {
+		newdir = g_strdup(".");
+	} else if (dir[0] == '/') {
+		newdir = g_strdup(dir);
+	} else {
+		tmp = remmina_ftp_client_get_dir(REMMINA_FTP_CLIENT(client));
+		if (tmp) {
+			newdir = remmina_public_combine_path(tmp, dir);
+			g_free(tmp);
+		} else {
+			newdir = g_strdup_printf("./%s", dir);
+		}
+	}
+
+	gchar *tlink = sftp_readlink (client->sftp->sftp_sess, newdir);
+	if (tlink) {
+		REMMINA_DEBUG ("%s is a link to %s", newdir, tlink);
+		newdir = g_strdup (tlink);
+		if (sftp_opendir (client->sftp->sftp_sess, newdir)) {
+			REMMINA_DEBUG ("%s is a link to a folder", tlink);
+		} else {
+			REMMINA_DEBUG ("%s is a link to a file", tlink);
+			return;
+		}
+	}
+	g_free(tlink);
+
+	tmp = remmina_ssh_unconvert(REMMINA_SSH(client->sftp), newdir);
+	newdir_conv = sftp_canonicalize_path(client->sftp->sftp_sess, tmp);
+	g_free(tmp);
+	g_free(newdir);
+	newdir = remmina_ssh_convert(REMMINA_SSH(client->sftp), newdir_conv);
+	if (!newdir) {
+		dialog = gtk_message_dialog_new(NULL,
+						GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
+						_("Could not open the folder “%s”. %s"), dir,
+						ssh_get_error(REMMINA_SSH(client->sftp)->session));
+		gtk_widget_show(dialog);
+		g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(gtk_widget_destroy), NULL);
+		g_free(newdir_conv);
+		return;
+	}
+
+	sftpdir = remmina_sftp_client_sftp_session_opendir(client, newdir_conv);
+	g_free(newdir_conv);
+	if (!sftpdir) {
+		g_free(newdir);
+		return;
+	}
+
+	remmina_ftp_client_clear_file_list(REMMINA_FTP_CLIENT(client));
+
+	while ((sftpattr = sftp_readdir(client->sftp->sftp_sess, sftpdir))) {
+		if (g_strcmp0(sftpattr->name, ".") != 0 &&
+		    g_strcmp0(sftpattr->name, "..") != 0) {
+			GET_SFTPATTR_TYPE(sftpattr, type);
+
+			tmp = remmina_ssh_convert(REMMINA_SSH(client->sftp), sftpattr->name);
+			remmina_ftp_client_add_file(REMMINA_FTP_CLIENT(client),
+						    REMMINA_FTP_FILE_COLUMN_TYPE, type,
+						    REMMINA_FTP_FILE_COLUMN_NAME, tmp,
+						    REMMINA_FTP_FILE_COLUMN_SIZE, (gfloat)sftpattr->size,
+						    REMMINA_FTP_FILE_COLUMN_USER, sftpattr->owner,
+						    REMMINA_FTP_FILE_COLUMN_GROUP, sftpattr->group,
+						    REMMINA_FTP_FILE_COLUMN_PERMISSION, sftpattr->permissions,
+						    REMMINA_FTP_FILE_COLUMN_MODIFIED, sftpattr->mtime,
+						    -1);
+			g_free(tmp);
+		}
+		sftp_attributes_free(sftpattr);
+	}
+	remmina_sftp_client_sftp_session_closedir(client, sftpdir);
+
+	remmina_ftp_client_set_dir(REMMINA_FTP_CLIENT(client), newdir);
+	g_free(newdir);
+}
+
+static void
+remmina_sftp_client_on_newtask(RemminaSFTPClient *client, gpointer data)
+{
+	TRACE_CALL(__func__);
+	if (client->thread) return;
+
+	if (pthread_create(&client->thread, NULL, remmina_sftp_client_thread_main, client))
+		client->thread = 0;
+}
+
+static gboolean
+remmina_sftp_client_on_canceltask(RemminaSFTPClient *client, gint taskid, gpointer data)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *dialog;
+	gint ret;
+
+	if (client->taskid != taskid) return TRUE;
+
+	dialog = gtk_message_dialog_new(GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(client))),
+					GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
+					_("Are you sure you want to cancel the file transfer in progress?"));
+	ret = gtk_dialog_run(GTK_DIALOG(dialog));
+	gtk_widget_destroy(dialog);
+	if (ret == GTK_RESPONSE_YES) {
+		/* Make sure we are still handling the same task before we clear the flag */
+		if (client->taskid == taskid) client->taskid = 0;
+		return TRUE;
+	}
+	return FALSE;
+}
+
+static gboolean
+remmina_sftp_client_on_deletefile(RemminaSFTPClient *client, gint type, gchar *name, gpointer data)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *dialog;
+	gint ret = 0;
+	gchar *tmp;
+
+	tmp = remmina_ssh_unconvert(REMMINA_SSH(client->sftp), name);
+	switch (type) {
+	case REMMINA_FTP_FILE_TYPE_DIR:
+		ret = sftp_rmdir(client->sftp->sftp_sess, tmp);
+		break;
+
+	case REMMINA_FTP_FILE_TYPE_FILE:
+		ret = sftp_unlink(client->sftp->sftp_sess, tmp);
+		break;
+	}
+	g_free(tmp);
+
+	if (ret != 0) {
+		dialog = gtk_message_dialog_new(GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(client))),
+						GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
+						_("Could not delete “%s”. %s"),
+						name, ssh_get_error(REMMINA_SSH(client->sftp)->session));
+		gtk_dialog_run(GTK_DIALOG(dialog));
+		gtk_widget_destroy(dialog);
+		return FALSE;
+	}
+	return TRUE;
+}
+
+static void
+remmina_sftp_client_init(RemminaSFTPClient *client)
+{
+	TRACE_CALL(__func__);
+	client->sftp = NULL;
+	client->thread = 0;
+	client->taskid = 0;
+	client->thread_abort = FALSE;
+
+	/* Setup the internal signals */
+	g_signal_connect(G_OBJECT(client), "destroy",
+			 G_CALLBACK(remmina_sftp_client_destroy), NULL);
+	g_signal_connect(G_OBJECT(client), "open-dir",
+			 G_CALLBACK(remmina_sftp_client_on_opendir), NULL);
+	g_signal_connect(G_OBJECT(client), "new-task",
+			 G_CALLBACK(remmina_sftp_client_on_newtask), NULL);
+	g_signal_connect(G_OBJECT(client), "cancel-task",
+			 G_CALLBACK(remmina_sftp_client_on_canceltask), NULL);
+	g_signal_connect(G_OBJECT(client), "delete-file",
+			 G_CALLBACK(remmina_sftp_client_on_deletefile), NULL);
+}
+
+static gboolean
+remmina_sftp_client_refresh(RemminaSFTPClient *client)
+{
+	TRACE_CALL(__func__);
+
+	GdkDisplay *display = gdk_display_get_default();
+
+	SET_CURSOR(gdk_cursor_new_for_display(display, GDK_WATCH));
+	gdk_display_flush(display);
+
+	remmina_sftp_client_on_opendir(client, ".", NULL);
+
+	SET_CURSOR(NULL);
+
+	return FALSE;
+}
+
+gint
+remmina_sftp_client_confirm_resume(RemminaSFTPClient *client, const gchar *path)
+{
+	TRACE_CALL(__func__);
+
+	GtkWidget *dialog;
+	gint response;
+	GtkWidget *hbox;
+	GtkWidget *vbox;
+	GtkWidget *widget;
+	const gchar *filename;
+
+	/* Always reply ACCEPT if overwrite_all was already set */
+	if (remmina_ftp_client_get_overwrite_status(REMMINA_FTP_CLIENT(client)))
+		return GTK_RESPONSE_ACCEPT;
+
+	/* Always reply APPLY if resume was already set */
+	if (remmina_ftp_client_get_resume_status(REMMINA_FTP_CLIENT(client)))
+		return GTK_RESPONSE_APPLY;
+
+	if (!remmina_masterthread_exec_is_main_thread()) {
+		/* Allow the execution of this function from a non main thread */
+		RemminaMTExecData *d;
+		gint retval;
+		d = (RemminaMTExecData *)g_malloc(sizeof(RemminaMTExecData));
+		d->func = FUNC_SFTP_CLIENT_CONFIRM_RESUME;
+		d->p.sftp_client_confirm_resume.client = client;
+		d->p.sftp_client_confirm_resume.path = path;
+		remmina_masterthread_exec_and_wait(d);
+		retval = d->p.sftp_client_confirm_resume.retval;
+		g_free(d);
+		return retval;
+	}
+
+	filename = strrchr(path, '/');
+	filename = filename ? filename + 1 : path;
+
+	dialog = gtk_dialog_new_with_buttons(_("The file exists already"),
+					     GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(client))),
+					     GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+					     _("Resume"), GTK_RESPONSE_APPLY,
+					     _("Overwrite"), GTK_RESPONSE_ACCEPT,
+					     _("_Cancel"), GTK_RESPONSE_CANCEL,
+					     NULL);
+	gtk_container_set_border_width(GTK_CONTAINER(dialog), 4);
+
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
+	gtk_widget_show(hbox);
+	gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
+			   hbox, TRUE, TRUE, 4);
+
+	widget = gtk_image_new_from_icon_name("dialog-question", GTK_ICON_SIZE_DIALOG);
+	gtk_widget_show(widget);
+	gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 4);
+
+	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
+	gtk_widget_show(vbox);
+	gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 4);
+
+	widget = gtk_label_new(_("The following file already exists in the target folder:"));
+	gtk_widget_show(widget);
+	gtk_widget_set_halign(GTK_WIDGET(widget), GTK_ALIGN_START);
+	gtk_widget_set_valign(GTK_WIDGET(widget), GTK_ALIGN_CENTER);
+	gtk_box_pack_start(GTK_BOX(vbox), widget, TRUE, TRUE, 4);
+
+	widget = gtk_label_new(filename);
+	gtk_widget_show(widget);
+	gtk_widget_set_halign(GTK_WIDGET(widget), GTK_ALIGN_START);
+	gtk_widget_set_valign(GTK_WIDGET(widget), GTK_ALIGN_CENTER);
+	gtk_box_pack_start(GTK_BOX(vbox), widget, TRUE, TRUE, 4);
+
+	response = gtk_dialog_run(GTK_DIALOG(dialog));
+	gtk_widget_destroy(dialog);
+	return response;
+}
+
+RemminaSFTPClient *
+remmina_sftp_client_new(void)
+{
+	TRACE_CALL(__func__);
+	return REMMINA_SFTP_CLIENT(g_object_new(REMMINA_TYPE_SFTP_CLIENT, NULL));
+}
+
+void
+remmina_sftp_client_open(RemminaSFTPClient *client, RemminaSFTP *sftp)
+{
+	TRACE_CALL(__func__);
+	client->sftp = sftp;
+
+	g_idle_add((GSourceFunc)remmina_sftp_client_refresh, client);
+}
+
+/*
+ * GtkWidget *
+ * remmina_sftp_client_new_init(RemminaSFTP *sftp)
+ * {
+ *      TRACE_CALL(__func__);
+ *      GdkDisplay *display;
+ *      GtkWidget *client;
+ *      GtkWidget *dialog;
+ *
+ *      display = gdk_display_get_default();
+ *      client = remmina_sftp_client_new();
+ *
+ *
+ *      SET_CURSOR(gdk_cursor_new_for_display(display, GDK_WATCH));
+ *      gdk_display_flush(display);
+ *
+ *      if (!remmina_ssh_init_session(REMMINA_SSH(sftp)) ||
+ *          remmina_ssh_auth(REMMINA_SSH(sftp), NULL, NULL, NULL) != REMMINA_SSH_AUTH_SUCCESS ||
+ *          !remmina_sftp_open(sftp)) {
+ *              dialog = gtk_message_dialog_new(GTK_WINDOW(gtk_widget_get_toplevel(client)),
+ *                                              GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
+ *                                              (REMMINA_SSH(sftp))->error, NULL);
+ *              gtk_dialog_run(GTK_DIALOG(dialog));
+ *              gtk_widget_destroy(dialog);
+ *              gtk_widget_destroy(client);
+ *              return NULL;
+ *      }
+ *
+ *      SET_CURSOR(NULL);
+ *
+ *      g_idle_add((GSourceFunc)remmina_sftp_client_refresh, client);
+ *      return client;
+ * }
+ */
+
+#endif
diff --git a/src/remmina_sftp_client.h b/src/remmina_sftp_client.h
new file mode 100644
index 0000000..13da079
--- /dev/null
+++ b/src/remmina_sftp_client.h
@@ -0,0 +1,80 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009-2010 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.
+ *
+ */
+
+#pragma once
+
+#include "config.h"
+
+#ifdef HAVE_LIBSSH
+
+#include "remmina_file.h"
+#include "remmina_ftp_client.h"
+#include "remmina_ssh.h"
+
+G_BEGIN_DECLS
+
+#define REMMINA_TYPE_SFTP_CLIENT               (remmina_sftp_client_get_type())
+#define REMMINA_SFTP_CLIENT(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), REMMINA_TYPE_SFTP_CLIENT, RemminaSFTPClient))
+#define REMMINA_SFTP_CLIENT_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), REMMINA_TYPE_SFTP_CLIENT, RemminaSFTPClientClass))
+#define REMMINA_IS_SFTP_CLIENT(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), REMMINA_TYPE_SFTP_CLIENT))
+#define REMMINA_IS_SFTP_CLIENT_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), REMMINA_TYPE_SFTP_CLIENT))
+#define REMMINA_SFTP_CLIENT_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), REMMINA_TYPE_SFTP_CLIENT, RemminaSFTPClientClass))
+
+typedef struct _RemminaSFTPClient {
+	RemminaFTPClient	client;
+
+	RemminaSFTP *		sftp;
+
+	pthread_t		thread;
+	gint			taskid;
+	gboolean		thread_abort;
+	RemminaProtocolWidget * gp;
+} RemminaSFTPClient;
+
+typedef struct _RemminaSFTPClientClass {
+	RemminaFTPClientClass parent_class;
+} RemminaSFTPClientClass;
+
+GType remmina_sftp_client_get_type(void) G_GNUC_CONST;
+
+RemminaSFTPClient *remmina_sftp_client_new();
+
+void remmina_sftp_client_open(RemminaSFTPClient *client, RemminaSFTP *sftp);
+gint remmina_sftp_client_confirm_resume(RemminaSFTPClient *client, const gchar *path);
+
+G_END_DECLS
+
+#endif  /* HAVE_LIBSSH */
diff --git a/src/remmina_sftp_plugin.c b/src/remmina_sftp_plugin.c
new file mode 100644
index 0000000..8132649
--- /dev/null
+++ b/src/remmina_sftp_plugin.c
@@ -0,0 +1,401 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010 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 "remmina/remmina_trace_calls.h"
+
+#ifdef HAVE_LIBSSH
+
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
+#include "remmina_public.h"
+#include "remmina_sftp_client.h"
+#include "remmina_plugin_manager.h"
+#include "remmina_ssh.h"
+#include "remmina_sftp_plugin.h"
+
+#define   REMMINA_PLUGIN_SFTP_FEATURE_PREF_SHOW_HIDDEN     1
+#define   REMMINA_PLUGIN_SFTP_FEATURE_PREF_OVERWRITE_ALL   2
+#define   REMMINA_PLUGIN_SFTP_FEATURE_PREF_RESUME_ALL      3
+
+#define REMMINA_PLUGIN_SFTP_FEATURE_PREF_OVERWRITE_ALL_KEY "overwrite_all"
+#define REMMINA_PLUGIN_SFTP_FEATURE_PREF_RESUME_ALL_KEY    "resume_all"
+
+#define GET_PLUGIN_DATA(gp) (RemminaPluginSftpData *)g_object_get_data(G_OBJECT(gp), "plugin-data");
+
+typedef struct _RemminaPluginSftpData {
+	RemminaSFTPClient *	client;
+	pthread_t		thread;
+	RemminaSFTP *		sftp;
+} RemminaPluginSftpData;
+
+static RemminaPluginService *remmina_plugin_service = NULL;
+
+gboolean remmina_plugin_sftp_start_direct_tunnel(RemminaProtocolWidget *gp, char **phost, int *pport)
+{
+	gchar *hostport;
+
+	hostport = remmina_plugin_service->protocol_plugin_start_direct_tunnel(gp, 22, FALSE);
+	if (hostport == NULL) {
+		remmina_plugin_service->protocol_plugin_signal_connection_closed(gp);
+		return FALSE;
+	}
+
+	remmina_plugin_service->get_server_port(hostport, 22, phost, pport);
+
+	return TRUE;
+}
+
+static gpointer
+remmina_plugin_sftp_main_thread(gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)data;
+	RemminaPluginSftpData *gpdata;
+	RemminaFile *remminafile;
+	RemminaSSH *ssh;
+	RemminaSFTP *sftp = NULL;
+	gboolean cont = FALSE;
+	gint ret;
+	const gchar *cs;
+	gchar *host;
+	int port;
+
+	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+	CANCEL_ASYNC
+
+		gpdata = GET_PLUGIN_DATA(gp);
+
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+
+	/* we may need to open a new tunnel too */
+	host = NULL;
+	port = 0;
+	if (!remmina_plugin_sftp_start_direct_tunnel(gp, &host, &port))
+		return NULL;
+
+	ssh = g_object_get_data(G_OBJECT(gp), "user-data");
+	if (ssh) {
+		/* Create SFTP connection based on existing SSH session */
+		sftp = remmina_sftp_new_from_ssh(ssh);
+		ssh->tunnel_entrance_host = host;
+		ssh->tunnel_entrance_port = port;
+		if (remmina_ssh_init_session(REMMINA_SSH(sftp)) &&
+		    remmina_ssh_auth(REMMINA_SSH(sftp), NULL, gp, remminafile) == REMMINA_SSH_AUTH_SUCCESS &&
+		    remmina_sftp_open(sftp))
+			cont = TRUE;
+	} else {
+		/* New SFTP connection */
+		sftp = remmina_sftp_new_from_file(remminafile);
+		ssh = REMMINA_SSH(sftp);
+		ssh->tunnel_entrance_host = host;
+		ssh->tunnel_entrance_port = port;
+		while (1) {
+			if (!remmina_ssh_init_session(ssh)) {
+				remmina_plugin_service->protocol_plugin_set_error(gp, "%s", ssh->error);
+				break;
+			}
+
+			ret = remmina_ssh_auth_gui(ssh, gp, remminafile);
+			if (ret != REMMINA_SSH_AUTH_SUCCESS) {
+				if (ret == REMMINA_SSH_AUTH_RECONNECT) {
+					if (ssh->session) {
+						ssh_disconnect(ssh->session);
+						ssh_free(ssh->session);
+						ssh->session = NULL;
+					}
+					g_free(ssh->callback);
+					continue;
+				}
+				if (ret != REMMINA_SSH_AUTH_USERCANCEL)
+					remmina_plugin_service->protocol_plugin_set_error(gp, "%s", ssh->error);
+				break;
+			}
+
+			if (!remmina_sftp_open(sftp)) {
+				remmina_plugin_service->protocol_plugin_set_error(gp, "%s", ssh->error);
+				break;
+			}
+
+			cs = remmina_plugin_service->file_get_string(remminafile, "execpath");
+			if (cs && cs[0])
+				remmina_ftp_client_set_dir(REMMINA_FTP_CLIENT(gpdata->client), cs);
+
+			cont = TRUE;
+			break;
+		}
+	}
+
+	if (!cont) {
+		if (sftp) remmina_sftp_free(sftp);
+		remmina_plugin_service->protocol_plugin_signal_connection_closed(gp);
+		return NULL;
+	}
+
+	remmina_sftp_client_open(REMMINA_SFTP_CLIENT(gpdata->client), sftp);
+	/* RemminaSFTPClient owns the object, we just take the reference */
+	gpdata->sftp = sftp;
+
+	remmina_plugin_service->protocol_plugin_signal_connection_opened(gp);
+
+	gpdata->thread = 0;
+	return NULL;
+}
+
+static void
+remmina_plugin_sftp_client_on_realize(GtkWidget *widget, RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaFile *remminafile;
+
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+	remmina_ftp_client_load_state(REMMINA_FTP_CLIENT(widget), remminafile);
+}
+
+static void
+remmina_plugin_sftp_init(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginSftpData *gpdata;
+	RemminaFile *remminafile;
+
+	gpdata = g_new0(RemminaPluginSftpData, 1);
+	g_object_set_data_full(G_OBJECT(gp), "plugin-data", gpdata, g_free);
+
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+
+	gpdata->client = remmina_sftp_client_new();
+	gpdata->client->gp = gp;
+	gtk_widget_show(GTK_WIDGET(gpdata->client));
+	gtk_container_add(GTK_CONTAINER(gp), GTK_WIDGET(gpdata->client));
+
+	remmina_ftp_client_set_show_hidden(REMMINA_FTP_CLIENT(gpdata->client),
+					   remmina_plugin_service->file_get_int(remminafile, "showhidden", FALSE));
+
+	remmina_ftp_client_set_overwrite_status(REMMINA_FTP_CLIENT(gpdata->client),
+						remmina_plugin_service->file_get_int(remminafile,
+										     REMMINA_PLUGIN_SFTP_FEATURE_PREF_OVERWRITE_ALL_KEY, FALSE));
+	remmina_ftp_client_set_resume_status(REMMINA_FTP_CLIENT(gpdata->client),
+					     remmina_plugin_service->file_get_int(remminafile,
+										  REMMINA_PLUGIN_SFTP_FEATURE_PREF_RESUME_ALL_KEY, FALSE));
+
+	remmina_plugin_service->protocol_plugin_register_hostkey(gp, GTK_WIDGET(gpdata->client));
+
+	g_signal_connect(G_OBJECT(gpdata->client),
+			 "realize", G_CALLBACK(remmina_plugin_sftp_client_on_realize), gp);
+}
+
+static gboolean
+remmina_plugin_sftp_open_connection(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginSftpData *gpdata = GET_PLUGIN_DATA(gp);
+
+	remmina_plugin_service->protocol_plugin_set_expand(gp, TRUE);
+	remmina_plugin_service->protocol_plugin_set_width(gp, 640);
+	remmina_plugin_service->protocol_plugin_set_height(gp, 480);
+
+	if (pthread_create(&gpdata->thread, NULL, remmina_plugin_sftp_main_thread, gp)) {
+		remmina_plugin_service->protocol_plugin_set_error(gp,
+								  "Could not initialize pthread. Falling back to non-thread mode…");
+		gpdata->thread = 0;
+		return FALSE;
+	} else {
+		return TRUE;
+	}
+	return TRUE;
+}
+
+static gboolean
+remmina_plugin_sftp_close_connection(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginSftpData *gpdata = GET_PLUGIN_DATA(gp);
+	RemminaFile *remminafile;
+
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+	if (gpdata->thread) {
+		pthread_cancel(gpdata->thread);
+		if (gpdata->thread) pthread_join(gpdata->thread, NULL);
+	}
+
+	remmina_ftp_client_save_state(REMMINA_FTP_CLIENT(gpdata->client), remminafile);
+	remmina_plugin_service->protocol_plugin_signal_connection_closed(gp);
+	/* The session preference overwrite_all is always saved to FALSE in order
+	 * to avoid unwanted overwriting.
+	 * If we'd change idea just remove the next line to save the preference. */
+	remmina_file_set_int(remminafile,
+			     REMMINA_PLUGIN_SFTP_FEATURE_PREF_OVERWRITE_ALL_KEY, FALSE);
+	return FALSE;
+}
+
+static gboolean
+remmina_plugin_sftp_query_feature(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature)
+{
+	TRACE_CALL(__func__);
+	return TRUE;
+}
+
+static void
+remmina_plugin_sftp_call_feature(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginSftpData *gpdata = GET_PLUGIN_DATA(gp);
+	RemminaFile *remminafile;
+
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+	switch (feature->id) {
+	case REMMINA_PROTOCOL_FEATURE_TOOL_SSH:
+		remmina_plugin_service->open_connection(
+			remmina_file_dup_temp_protocol(remmina_plugin_service->protocol_plugin_get_file(gp), "SSH"),
+			NULL, gpdata->sftp, NULL);
+		return;
+	case REMMINA_PROTOCOL_FEATURE_TOOL_SFTP:
+		remmina_plugin_service->open_connection(
+			remmina_file_dup_temp_protocol(remmina_plugin_service->protocol_plugin_get_file(gp), "SFTP"),
+			NULL, gpdata->sftp, NULL);
+		return;
+	case REMMINA_PLUGIN_SFTP_FEATURE_PREF_SHOW_HIDDEN:
+		remmina_ftp_client_set_show_hidden(REMMINA_FTP_CLIENT(gpdata->client),
+						   remmina_plugin_service->file_get_int(remminafile, "showhidden", FALSE));
+		return;
+	case REMMINA_PLUGIN_SFTP_FEATURE_PREF_OVERWRITE_ALL:
+		remmina_ftp_client_set_overwrite_status(REMMINA_FTP_CLIENT(gpdata->client),
+							remmina_plugin_service->file_get_int(remminafile,
+											     REMMINA_PLUGIN_SFTP_FEATURE_PREF_OVERWRITE_ALL_KEY, FALSE));
+	case REMMINA_PLUGIN_SFTP_FEATURE_PREF_RESUME_ALL:
+		remmina_ftp_client_set_resume_status(REMMINA_FTP_CLIENT(gpdata->client),
+						     remmina_plugin_service->file_get_int(remminafile,
+											  REMMINA_PLUGIN_SFTP_FEATURE_PREF_RESUME_ALL_KEY, FALSE));
+		return;
+	}
+}
+
+static gpointer ssh_auth[] =
+{
+	"0", N_("Password"),
+	"1", N_("SSH identity file"),
+	"2", N_("SSH agent"),
+	"3", N_("Public key (automatic)"),
+	"4", N_("Kerberos (GSSAPI)"),
+	NULL
+};
+
+/* Array for available features.
+ * The last element of the array must be REMMINA_PROTOCOL_FEATURE_TYPE_END. */
+static const RemminaProtocolFeature remmina_plugin_sftp_features[] =
+{
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_PREF, REMMINA_PLUGIN_SFTP_FEATURE_PREF_SHOW_HIDDEN,   GINT_TO_POINTER(REMMINA_PROTOCOL_FEATURE_PREF_CHECK), "showhidden",
+	  N_("Show Hidden Files") },
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_PREF, REMMINA_PLUGIN_SFTP_FEATURE_PREF_OVERWRITE_ALL, GINT_TO_POINTER(REMMINA_PROTOCOL_FEATURE_PREF_CHECK),
+	  REMMINA_PLUGIN_SFTP_FEATURE_PREF_OVERWRITE_ALL_KEY, N_("Overwrite all files") },
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_PREF, REMMINA_PLUGIN_SFTP_FEATURE_PREF_RESUME_ALL,    GINT_TO_POINTER(REMMINA_PROTOCOL_FEATURE_PREF_CHECK),
+	  REMMINA_PLUGIN_SFTP_FEATURE_PREF_RESUME_ALL_KEY, N_("Resume all file transfers") },
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_TOOL, REMMINA_PROTOCOL_FEATURE_TOOL_SSH,	      N_("Connect via SSH from a new terminal"),	    "utilities-terminal",NULL},
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_END,  0,					      NULL,						    NULL,
+	  NULL }
+};
+
+/* Array of RemminaProtocolSetting for basic settings.
+ * Each item is composed by:
+ * a) RemminaProtocolSettingType for setting type
+ * b) Setting name
+ * c) Setting description
+ * d) Compact disposition
+ * e) Values for REMMINA_PROTOCOL_SETTING_TYPE_SELECT or REMMINA_PROTOCOL_SETTING_TYPE_COMBO
+ * f) Setting tooltip
+ * g) Validation data pointer, will be passed to the validation callback method.
+ * h) Validation callback method (Can be NULL. Every entry will be valid then.)
+ *		use following prototype:
+ *		gboolean mysetting_validator_method(gpointer key, gpointer value,
+ *						    gpointer validator_data);
+ *		gpointer key is a gchar* containing the setting's name,
+ *		gpointer value contains the value which should be validated,
+ *		gpointer validator_data contains your passed data.
+ */
+static const RemminaProtocolSetting remmina_sftp_basic_settings[] =
+{
+	{ REMMINA_PROTOCOL_SETTING_TYPE_SERVER,	  "server",	      NULL,				    FALSE, "_sftp-ssh._tcp", NULL, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_TEXT,	  "username",	      N_("Username"),			    FALSE, NULL,	     NULL, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_PASSWORD, "password",	      N_("Password"),			    FALSE, NULL,	     NULL, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_SELECT,	  "ssh_auth",	      N_("Authentication type"),	    FALSE, ssh_auth,	     NULL, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_FILE,	  "ssh_privatekey",   N_("SSH identity file"),		    FALSE, NULL,	     NULL, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_PASSWORD, "ssh_passphrase",   N_("Password to unlock private key"), FALSE, NULL,	     NULL, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_TEXT,	  "ssh_proxycommand", N_("SSH Proxy Command"),		    FALSE, NULL,	     NULL, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_END,	  NULL,		      NULL,				    FALSE, NULL,	     NULL, NULL, NULL }
+};
+
+/* Protocol plugin definition and features */
+static RemminaProtocolPlugin remmina_plugin_sftp =
+{
+	REMMINA_PLUGIN_TYPE_PROTOCOL,                   // Type
+	"SFTP",                                         // Name
+	N_("SFTP - Secure File Transfer"),              // Description
+	GETTEXT_PACKAGE,                                // Translation domain
+	VERSION,                                        // Version number
+	"org.remmina.Remmina-sftp-symbolic",                        // Icon for normal connection
+	"org.remmina.Remmina-sftp-symbolic",                        // Icon for SSH connection
+	remmina_sftp_basic_settings,                    // Array for basic settings
+	NULL,                                           // Array for advanced settings
+	REMMINA_PROTOCOL_SSH_SETTING_TUNNEL,            // SSH settings type
+	remmina_plugin_sftp_features,                   // Array for available features
+	remmina_plugin_sftp_init,                       // Plugin initialization
+	remmina_plugin_sftp_open_connection,            // Plugin open connection
+	remmina_plugin_sftp_close_connection,           // Plugin close connection
+	remmina_plugin_sftp_query_feature,              // Query for available features
+	remmina_plugin_sftp_call_feature,               // Call a feature
+	NULL,                                           // Send a keystroke
+	NULL,                                           // Screenshot support unavailable
+	NULL,                                           // RCW map event
+	NULL                                            // RCW unmap event
+};
+
+void
+remmina_sftp_plugin_register(void)
+{
+	TRACE_CALL(__func__);
+	remmina_plugin_service = &remmina_plugin_manager_service;
+	remmina_plugin_service->register_plugin((RemminaPlugin *)&remmina_plugin_sftp);
+}
+
+#else
+
+void remmina_sftp_plugin_register(void)
+{
+	TRACE_CALL(__func__);
+}
+
+#endif
diff --git a/src/remmina_sftp_plugin.h b/src/remmina_sftp_plugin.h
new file mode 100644
index 0000000..06d95c3
--- /dev/null
+++ b/src/remmina_sftp_plugin.h
@@ -0,0 +1,47 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010 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.
+ *
+ */
+
+#pragma once
+
+#include <glib.h>
+#include "remmina_protocol_widget.h"
+
+G_BEGIN_DECLS
+
+void remmina_sftp_plugin_register(void);
+gboolean remmina_plugin_sftp_start_direct_tunnel(RemminaProtocolWidget *gp, char **phost, int *pport);
+
+G_END_DECLS
diff --git a/src/remmina_sodium.c b/src/remmina_sodium.c
new file mode 100644
index 0000000..fabc050
--- /dev/null
+++ b/src/remmina_sodium.c
@@ -0,0 +1,192 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * 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.
+ *
+ */
+
+/**
+ * @file remmina_sodium.c
+ * @brief Remmina encryption functions,
+ * @author Antenore Gatta
+ * @date 31 Mar 2019
+ *
+ * These functions are used to:
+ *  - hash password using the Argon2 hashing algorithm.
+ *  - Encrypt and decrypt data streams (files for examples).
+ *
+ * @code
+ *
+ *  gchar *test = remmina_sodium_pwhash("Password test");
+ *  g_free(test);
+ *  test = remmina_sodium_pwhash_str("Password Test");
+ *  g_free(test);
+ *  gint rc = remmina_sodium_pwhash_str_verify("$argon2id$v=19$m=65536,t=2,p=1$6o+kpazlHSaevezH2J9qUA$4pN75oHgyh1BLc/b+ybLYHjZbatG4ZSCSlxLI32YPY4", "Password Test");
+ *
+ * @endcode
+ *
+ */
+
+#include <string.h>
+
+#if defined(__linux__)
+# include <fcntl.h>
+# include <unistd.h>
+# include <sys/ioctl.h>
+# include <linux/random.h>
+#endif
+
+#include "config.h"
+#include <glib.h>
+#include "remmina_pref.h"
+#include "remmina/remmina_trace_calls.h"
+
+#include "remmina_sodium.h"
+#if SODIUM_VERSION_INT >= 90200
+
+gchar *remmina_sodium_pwhash(const gchar *pass)
+{
+	TRACE_CALL(__func__);
+	g_info("Generating passphrase (may take a while)...");
+	/* Create a random salt for the key derivation function */
+	unsigned char salt[crypto_pwhash_SALTBYTES] = { 0 };
+	randombytes_buf(salt, sizeof salt);
+
+	unsigned long long opslimit;
+	size_t memlimit;
+
+	switch (remmina_pref.enc_mode) {
+		case RM_ENC_MODE_SODIUM_MODERATE:
+			opslimit = crypto_pwhash_OPSLIMIT_MODERATE;
+			memlimit = crypto_pwhash_MEMLIMIT_MODERATE;
+			break;
+		case RM_ENC_MODE_SODIUM_SENSITIVE:
+			opslimit = crypto_pwhash_OPSLIMIT_SENSITIVE;
+			memlimit = crypto_pwhash_MEMLIMIT_SENSITIVE;
+			break;
+		case RM_ENC_MODE_GCRYPT:
+		case RM_ENC_MODE_SECRET:
+		case RM_ENC_MODE_SODIUM_INTERACTIVE:
+		default:
+			opslimit = crypto_pwhash_OPSLIMIT_INTERACTIVE;
+			memlimit = crypto_pwhash_MEMLIMIT_INTERACTIVE;
+			break;
+	}
+
+	/* Use argon2 to convert password to a full size key */
+	unsigned char key[crypto_secretbox_KEYBYTES];
+	if (crypto_pwhash(key, sizeof key, pass, strlen(pass), salt,
+			  opslimit,
+			  memlimit,
+			  crypto_pwhash_ALG_DEFAULT) != 0) {
+		g_error("%s - Out of memory!", __func__);
+		exit(1);
+	}
+
+	g_info("%s - Password hashed", __func__);
+	return g_strdup((const char *)key);
+}
+
+gchar *remmina_sodium_pwhash_str(const gchar *pass)
+{
+	TRACE_CALL(__func__);
+	g_info("Generating passphrase (may take a while)...");
+	/* Create a random salt for the key derivation function */
+	unsigned char salt[crypto_pwhash_SALTBYTES] = { 0 };
+	randombytes_buf(salt, sizeof salt);
+
+	unsigned long long opslimit;
+	size_t memlimit;
+
+	switch (remmina_pref.enc_mode) {
+		case RM_ENC_MODE_SODIUM_MODERATE:
+			opslimit = crypto_pwhash_OPSLIMIT_MODERATE;
+			memlimit = crypto_pwhash_MEMLIMIT_MODERATE;
+			break;
+		case RM_ENC_MODE_SODIUM_SENSITIVE:
+			opslimit = crypto_pwhash_OPSLIMIT_SENSITIVE;
+			memlimit = crypto_pwhash_MEMLIMIT_SENSITIVE;
+			break;
+		case RM_ENC_MODE_GCRYPT:
+		case RM_ENC_MODE_SECRET:
+		case RM_ENC_MODE_SODIUM_INTERACTIVE:
+		default:
+			opslimit = crypto_pwhash_OPSLIMIT_INTERACTIVE;
+			memlimit = crypto_pwhash_MEMLIMIT_INTERACTIVE;
+			break;
+	}
+
+	/* Use argon2 to convert password to a full size key */
+	char key[crypto_pwhash_STRBYTES];
+	if (crypto_pwhash_str(key, pass, strlen(pass),
+			      opslimit,
+			      memlimit) != 0) {
+		g_error("%s - Out of memory!", __func__);
+		exit(1);
+	}
+
+	g_info("%s - Password hashed", __func__);
+	return g_strdup((const char *)key);
+}
+
+gint remmina_sodium_pwhash_str_verify(const char *key, const char *pass)
+{
+	TRACE_CALL(__func__);
+
+	gint rc;
+
+	rc = crypto_pwhash_str_verify(key, pass, strlen(pass));
+
+	return rc;
+}
+
+void remmina_sodium_init(void)
+{
+	TRACE_CALL(__func__);
+#if defined(__linux__) && defined(RNDGETENTCNT)
+	int fd;
+	int c;
+
+	if ((fd = open("/dev/random", O_RDONLY)) != -1) {
+		if (ioctl(fd, RNDGETENTCNT, &c) == 0 && c < 160) {
+			g_printerr("This system doesn't provide enough entropy to quickly generate high-quality random numbers.\n"
+				   "Installing the rng-utils/rng-tools, jitterentropy or haveged packages may help.\n"
+				   "On virtualized Linux environments, also consider using virtio-rng.\n"
+				   "The service will not start until enough entropy has been collected.\n");
+		}
+		(void)close(fd);
+	}
+#endif
+
+	if (sodium_init() < 0)
+		g_critical("%s - Failed to initialize sodium, it is not safe to use", __func__);
+}
+
+#endif
diff --git a/src/remmina_sodium.h b/src/remmina_sodium.h
new file mode 100644
index 0000000..cd151e5
--- /dev/null
+++ b/src/remmina_sodium.h
@@ -0,0 +1,52 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2017-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.
+ *
+ */
+
+#pragma once
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+#include <sodium.h>
+#include <glib.h>
+
+#define SODIUM_VERSION_INT (SODIUM_LIBRARY_VERSION_MAJOR * 10000 + SODIUM_LIBRARY_VERSION_MINOR * 100)
+#if SODIUM_VERSION_INT >= 90200
+void remmina_sodium_init(void);
+gchar *remmina_sodium_pwhash(const gchar *pass);
+gchar *remmina_sodium_pwhash_str(const gchar *pass);
+gint remmina_sodium_pwhash_str_verify(const char *key, const char *pass);
+#endif
+
+G_END_DECLS
diff --git a/src/remmina_ssh.c b/src/remmina_ssh.c
new file mode 100644
index 0000000..890046a
--- /dev/null
+++ b/src/remmina_ssh.c
@@ -0,0 +1,3238 @@
+/*
+ * 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-2022 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2022-2023 Antenore Gatta, Giovanni Panozzo, Hiroyuki Tanaka
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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"
+
+#ifdef HAVE_LIBSSH
+
+/* To get definitions of NI_MAXHOST and NI_MAXSERV from <netdb.h> */
+#define _DEFAULT_SOURCE
+#define _DARWIN_C_SOURCE
+
+/* Define this before stdlib.h to have posix_openpt */
+#define _XOPEN_SOURCE 600
+
+#include <errno.h>
+#define LIBSSH_STATIC 1
+#include <libssh/libssh.h>
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
+#include <poll.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <time.h>
+#include <sys/types.h>
+#include <pthread.h>
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#ifdef HAVE_TERMIOS_H
+#include <termios.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_PTY_H
+#include <pty.h>
+#endif
+#ifdef HAVE_SYS_UN_H
+#include <sys/un.h>
+#endif
+#include "remmina_public.h"
+#include "remmina/types.h"
+#include "remmina_file.h"
+#include "remmina_log.h"
+#include "remmina_pref.h"
+#include "remmina_ssh.h"
+#include "remmina_masterthread_exec.h"
+#include "remmina/remmina_trace_calls.h"
+
+
+#ifdef HAVE_NETINET_TCP_H
+#include <netinet/tcp.h>
+
+#if defined(__FreeBSD__) || defined(__OpenBSD__)
+#ifndef SOL_TCP
+#define SOL_TCP IPPROTO_TCP
+#endif
+#endif
+
+#endif
+
+/*-----------------------------------------------------------------------------*
+*                           SSH Base                                          *
+*-----------------------------------------------------------------------------*/
+
+#define LOCK_SSH(ssh) pthread_mutex_lock(&REMMINA_SSH(ssh)->ssh_mutex);
+#define UNLOCK_SSH(ssh) pthread_mutex_unlock(&REMMINA_SSH(ssh)->ssh_mutex);
+
+static const gchar *common_identities[] =
+{
+	".ssh/id_ed25519",
+	".ssh/id_rsa",
+	".ssh/id_dsa",
+	".ssh/identity",
+	NULL
+};
+
+/*-----------------------------------------------------------------------------*
+*                           X11 Channels                                      *
+*-----------------------------------------------------------------------------*/
+#define _PATH_UNIX_X    "/tmp/.X11-unix/X%d"
+#define _XAUTH_CMD      "/usr/bin/xauth list %s 2>/dev/null"
+
+typedef struct item {
+	ssh_channel channel;
+	gint fd_in;
+	gint fd_out;
+	gboolean protected;
+	pthread_t thread;
+	struct item *next;
+} node_t;
+
+node_t *node = NULL;
+
+// Mutex
+pthread_mutex_t mutex;
+
+// Linked nodes to manage channel/fd tuples
+static void remmina_ssh_insert_item(ssh_channel channel, gint fd_in, gint fd_out, gboolean protected, pthread_t thread);
+static void remmina_ssh_delete_item(ssh_channel channel);
+static node_t * remmina_ssh_search_item(ssh_channel channel);
+
+// X11 Display
+const char * remmina_ssh_ssh_gai_strerror(int gaierr);
+static int remmina_ssh_x11_get_proto(const char *display, char **_proto, char **_data);
+static void remmina_ssh_set_nodelay(int fd);
+static int remmina_ssh_connect_local_xsocket_path(const char *pathname);
+static int remmina_ssh_connect_local_xsocket(int display_number);
+static int remmina_ssh_x11_connect_display();
+
+// Send data to channel
+static int remmina_ssh_cp_to_ch_cb(int fd, int revents, void *userdata);
+
+// Read data from channel
+static int remmina_ssh_cp_to_fd_cb(ssh_session session, ssh_channel channel, void *data, uint32_t len, int is_stderr, void *userdata);
+
+// EOF&Close channel
+static void remmina_ssh_ch_close_cb(ssh_session session, ssh_channel channel, void *userdata);
+
+// Close all X11 channel
+static void remmina_ssh_close_all_x11_ch(pthread_t thread);
+
+// X11 Request
+static ssh_channel remmina_ssh_x11_open_request_cb(ssh_session session, const char *shost, int sport, void *userdata);
+
+// SSH Channel Callbacks
+struct ssh_channel_callbacks_struct channel_cb =
+{
+	.channel_data_function = remmina_ssh_cp_to_fd_cb,
+	.channel_eof_function = remmina_ssh_ch_close_cb,
+	.channel_close_function = remmina_ssh_ch_close_cb,
+	.userdata = NULL
+};
+
+// SSH Event Context
+short events = POLLIN | POLLPRI | POLLERR | POLLHUP | POLLNVAL;
+
+// Functions
+static void
+remmina_ssh_insert_item(ssh_channel channel, gint fd_in, gint fd_out, gboolean protected, pthread_t thread)
+{
+	TRACE_CALL(__func__);
+
+	pthread_mutex_lock(&mutex);
+
+	REMMINA_DEBUG("insert node - fd_in: %d - fd_out: %d - protected %d", fd_in, fd_out, protected);
+
+	node_t *node_iterator, *new;
+	if (node == NULL) {
+		/* Calloc ensure that node is full of 0 */
+		node = (node_t *) calloc(1, sizeof(node_t));
+		node->channel = channel;
+		node->fd_in = fd_in;
+		node->fd_out = fd_out;
+		node->protected = protected;
+		node->thread = thread;
+		node->next = NULL;
+	} else {
+		node_iterator = node;
+		while (node_iterator->next != NULL)
+			node_iterator = node_iterator->next;
+		/* Create the new node */
+		new = (node_t *) malloc(sizeof(node_t));
+		new->channel = channel;
+		new->fd_in = fd_in;
+		new->fd_out = fd_out;
+		new->protected = protected;
+		new->thread = thread;
+		new->next = NULL;
+		node_iterator->next = new;
+	}
+
+	pthread_mutex_unlock(&mutex);
+}
+
+static void
+remmina_ssh_delete_item(ssh_channel channel)
+{
+	TRACE_CALL(__func__);
+
+	REMMINA_DEBUG("delete node");
+
+	pthread_mutex_lock(&mutex);
+
+	node_t *current, *previous = NULL;
+	for (current = node; current; previous = current, current = current->next) {
+		if (current->channel != channel)
+			continue;
+
+		if (previous == NULL)
+			node = current->next;
+		else
+			previous->next = current->next;
+
+		free(current);
+		pthread_mutex_unlock(&mutex);
+		return;
+	}
+
+	pthread_mutex_unlock(&mutex);
+}
+
+static node_t *
+remmina_ssh_search_item(ssh_channel channel)
+{
+	TRACE_CALL(__func__);
+
+	// TODO: too verbose REMMINA_DEBUG("search node");
+
+	pthread_mutex_lock(&mutex);
+
+	node_t *current = node;
+	while (current != NULL) {
+		if (current->channel == channel) {
+			pthread_mutex_unlock(&mutex);
+			// TODO: too verbose REMMINA_DEBUG("found node - fd_in: %d - fd_out: %d - protected: %d", current->fd_in, current->fd_out, current->protected);
+			return current;
+		} else {
+			current = current->next;
+		}
+	}
+
+	pthread_mutex_unlock(&mutex);
+
+	return NULL;
+}
+
+static void
+remmina_ssh_set_nodelay(int fd)
+{
+	TRACE_CALL(__func__);
+	int opt;
+	socklen_t optlen;
+
+	optlen = sizeof(opt);
+	if (getsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &opt, &optlen) == -1) {
+		REMMINA_WARNING("getsockopt TCP_NODELAY: %.100s", strerror(errno));
+		return;
+	}
+	if (opt == 1) {
+		REMMINA_DEBUG("fd %d is TCP_NODELAY", fd);
+		return;
+	}
+	opt = 1;
+	REMMINA_DEBUG("fd %d setting TCP_NODELAY", fd);
+	if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt)) == -1)
+		REMMINA_WARNING("setsockopt TCP_NODELAY: %.100s", strerror(errno));
+}
+
+const char *
+remmina_ssh_ssh_gai_strerror(int gaierr)
+{
+	TRACE_CALL(__func__);
+
+	if (gaierr == EAI_SYSTEM && errno != 0)
+		return strerror(errno);
+	return gai_strerror(gaierr);
+}
+
+static int
+remmina_ssh_x11_get_proto(const char *display, char **_proto, char **_cookie)
+{
+	TRACE_CALL(__func__);
+
+	char cmd[1024], line[512], xdisplay[512];
+	static char proto[512], cookie[512];
+	FILE *f;
+	int ret = 0, r;
+
+	*_proto = proto;
+	*_cookie = cookie;
+
+	proto[0] = cookie[0] = '\0';
+
+	if (strncmp(display, "localhost:", 10) == 0) {
+		if ((r = snprintf(xdisplay, sizeof(xdisplay), "unix:%s", display + 10)) < 0 || (size_t)r >= sizeof(xdisplay)) {
+			REMMINA_WARNING("display name too long. display: %s", display);
+			return -1;
+		}
+		display = xdisplay;
+	}
+
+	snprintf(cmd, sizeof(cmd), _XAUTH_CMD, display);
+	REMMINA_DEBUG("xauth cmd: %s", cmd);
+
+	f = popen(cmd, "r");
+	if (f && fgets(line, sizeof(line), f) && sscanf(line, "%*s %511s %511s", proto, cookie) == 2) {
+		ret = 0;
+	} else {
+		ret = 1;
+	}
+
+	if (f) pclose(f);
+
+	REMMINA_DEBUG("proto: %s - cookie: %s - ret: %d", proto, cookie, ret);
+
+	return ret;
+}
+
+static int
+remmina_ssh_connect_local_xsocket_path(const char *pathname)
+{
+	TRACE_CALL(__func__);
+
+	int sock;
+	struct sockaddr_un addr;
+
+	sock = socket(AF_UNIX, SOCK_STREAM, 0);
+	if (sock == -1)
+		REMMINA_WARNING("socket: %.100s", strerror(errno));
+
+	memset(&addr, 0, sizeof(addr));
+	addr.sun_family = AF_UNIX;
+	addr.sun_path[0] = '\0';
+	memcpy(addr.sun_path + 1, pathname, strlen(pathname));
+	if (connect(sock, (struct sockaddr *)&addr, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(pathname)) == 0) {
+		REMMINA_DEBUG("sock: %d", sock);
+		return sock;
+	}
+
+	REMMINA_WARNING("connect %.100s: %.100s", addr.sun_path, strerror(errno));
+	close(sock);
+
+	return -1;
+}
+
+static int
+remmina_ssh_connect_local_xsocket(int display_number)
+{
+	TRACE_CALL(__func__);
+
+	char buf[1024];
+	snprintf(buf, sizeof(buf), _PATH_UNIX_X, display_number);
+	return remmina_ssh_connect_local_xsocket_path(buf);
+}
+
+static int
+remmina_ssh_x11_connect_display()
+{
+	TRACE_CALL(__func__);
+
+	unsigned int display_number;
+	const char *display;
+	char buf[1024], *cp;
+	struct addrinfo hints, *ai, *aitop;
+	char strport[NI_MAXSERV];
+	int gaierr, sock = 0;
+
+	/* Try to open a socket for the local X server. */
+	display = getenv("DISPLAY");
+	if (!display) {
+		return -1;
+	}
+
+	REMMINA_DEBUG("display: %s", display);
+
+	/* Check if it is a unix domain socket. */
+	if (strncmp(display, "unix:", 5) == 0 || display[0] == ':') {
+		/* Connect to the unix domain socket. */
+		if (sscanf(strrchr(display, ':') + 1, "%u", &display_number) != 1) {
+			REMMINA_WARNING("Could not parse display number from DISPLAY: %.100s", display);
+			return -1;
+		}
+
+		REMMINA_DEBUG("display_number: %d", display_number);
+
+		/* Create a socket. */
+		sock = remmina_ssh_connect_local_xsocket(display_number);
+
+		REMMINA_DEBUG("socket: %d", sock);
+
+		if (sock < 0)
+			return -1;
+
+		/* OK, we now have a connection to the display. */
+		return sock;
+	}
+
+	/* Connect to an inet socket. */
+	strncpy(buf, display, sizeof(buf) - 1);
+	cp = strchr(buf, ':');
+	if (!cp) {
+		REMMINA_WARNING("Could not find ':' in DISPLAY: %.100s", display);
+		return -1;
+	}
+	*cp = 0;
+	if (sscanf(cp + 1, "%u", &display_number) != 1) {
+		REMMINA_WARNING("Could not parse display number from DISPLAY: %.100s", display);
+		return -1;
+	}
+
+	/* Look up the host address */
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = AF_INET;
+	hints.ai_socktype = SOCK_STREAM;
+	snprintf(strport, sizeof(strport), "%u", 6000 + display_number);
+	if ((gaierr = getaddrinfo(buf, strport, &hints, &aitop)) != 0) {
+		REMMINA_WARNING("%.100s: unknown host. (%s)", buf, remmina_ssh_ssh_gai_strerror(gaierr));
+		return -1;
+	}
+	for (ai = aitop; ai; ai = ai->ai_next) {
+		/* Create a socket. */
+		sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
+		if (sock == -1) {
+			REMMINA_WARNING("socket: %.100s", strerror(errno));
+			continue;
+		}
+		/* Connect it to the display. */
+		if (connect(sock, ai->ai_addr, ai->ai_addrlen) == -1) {
+			REMMINA_WARNING("connect %.100s port %u: %.100s", buf, 6000 + display_number, strerror(errno));
+			close(sock);
+			continue;
+		}
+		/* Success */
+		break;
+	}
+	freeaddrinfo(aitop);
+	if (!ai) {
+		REMMINA_WARNING("connect %.100s port %u: %.100s", buf, 6000 + display_number, strerror(errno));
+		return -1;
+	}
+	remmina_ssh_set_nodelay(sock);
+
+	REMMINA_DEBUG("sock: %d", sock);
+
+	return sock;
+}
+
+static int
+remmina_ssh_cp_to_ch_cb(int fd, int revents, void *userdata)
+{
+	TRACE_CALL(__func__);
+	ssh_channel channel = (ssh_channel)userdata;
+	gchar *buf = (gchar *) g_malloc ( sizeof(gchar) * 0x200000 );
+	if (buf ==NULL){
+		return -1;
+	}
+	gint sz = 0, ret = 0;
+
+	node_t *temp_node = remmina_ssh_search_item(channel);
+
+	if (!channel) {
+		if (!temp_node->protected) {
+			shutdown(fd, SHUT_RDWR);
+			close(fd);
+			REMMINA_DEBUG("fd %d closed.", fd);
+		}
+		REMMINA_WARNING("channel does not exist.");
+		return -1;
+	}
+
+	if ((revents & POLLIN) || (revents & POLLPRI)) {
+		sz = read(fd, buf, sizeof(buf));
+		if (sz > 0) {
+			ret = ssh_channel_write(channel, buf, sz);
+			if (ret != sz){
+				g_free(buf);
+				return -1;
+			}
+				
+			//TODO: too verbose REMMINA_DEBUG("ssh_channel_write ret: %d sz: %d", ret, sz);
+		} else if (sz < 0) {
+			// TODO: too verbose REMMINA_WARNING("fd bytes read: %d", sz);
+			g_free(buf);
+			return -1;
+		} else {
+			REMMINA_WARNING("Why the hell am I here?");
+			if (!temp_node->protected) {
+				shutdown(fd, SHUT_RDWR);
+				close(fd);
+				REMMINA_DEBUG("fd %d closed.", fd);
+			}
+			g_free(buf);
+			return -1;
+		}
+	}
+
+	if ((revents & POLLHUP) || (revents & POLLNVAL) || (revents & POLLERR)) {
+		REMMINA_DEBUG("Closing channel.");
+		ssh_channel_close(channel);
+		ret = -1;
+	}
+	g_free(buf);
+	return ret;
+}
+
+static int
+remmina_ssh_cp_to_fd_cb(ssh_session session, ssh_channel channel, void *data, uint32_t len, int is_stderr, void *userdata)
+{
+	TRACE_CALL(__func__);
+	(void)session;
+	(void)is_stderr;
+	// Expecting userdata to be type RemminaSSHShell *, but it is unused
+	// in this function.
+	(void)userdata;
+
+	node_t *temp_node = remmina_ssh_search_item(channel);
+	gint fd = temp_node->fd_out;
+	gint sz = 0;
+
+	sz = write(fd, data, len);
+	// TODO: too verbose REMMINA_DEBUG("fd bytes written: %d", sz);
+
+	return sz;
+}
+
+static void
+remmina_ssh_ch_close_cb(ssh_session session, ssh_channel channel, void *userdata)
+{
+	TRACE_CALL(__func__);
+	(void)session;
+
+	RemminaSSHShell *shell = (RemminaSSHShell *)userdata;
+
+	node_t *temp_node = remmina_ssh_search_item(channel);
+
+	if (temp_node != NULL) {
+		int fd = temp_node->fd_in;
+
+		if (!temp_node->protected) {
+			remmina_ssh_delete_item(channel);
+			ssh_event_remove_fd(shell->event, fd);
+			shutdown(fd, SHUT_RDWR);
+			close(fd);
+			REMMINA_DEBUG("fd %d closed.", fd);
+		}
+	}
+	REMMINA_DEBUG("Channel closed.");
+}
+
+static void
+remmina_ssh_close_all_x11_ch(pthread_t thread)
+{
+	TRACE_CALL(__func__);
+
+	REMMINA_DEBUG("Close all X11 channels");
+
+	node_t *current = node;
+	while (current != NULL) {
+		if (current->thread == thread && !current->protected) {
+			shutdown(current->fd_in, SHUT_RDWR);
+			close(current->fd_in);
+			REMMINA_DEBUG("thread: %d - fd %d closed.", thread, current->fd_in);
+			if (current->fd_in != current->fd_out) {
+				shutdown(current->fd_out, SHUT_RDWR);
+				close(current->fd_out);
+				REMMINA_DEBUG("thread: %d - fd %d closed.", thread, current->fd_out);
+			}
+		}
+		current = current->next;
+	}
+}
+
+static ssh_channel
+remmina_ssh_x11_open_request_cb(ssh_session session, const char *shost, int sport, void *userdata)
+{
+	TRACE_CALL(__func__);
+
+	(void)shost;
+	(void)sport;
+
+	RemminaSSHShell *shell = (RemminaSSHShell *)userdata;
+
+	ssh_channel channel = ssh_channel_new(session);
+
+	int sock = remmina_ssh_x11_connect_display();
+
+	remmina_ssh_insert_item(channel, sock, sock, FALSE, shell->thread);
+
+	ssh_event_add_fd(shell->event, sock, events, remmina_ssh_cp_to_ch_cb, channel);
+	ssh_event_add_session(shell->event, session);
+
+	ssh_add_channel_callbacks(channel, &channel_cb);
+
+	return channel;
+}
+
+gchar *
+remmina_ssh_identity_path(const gchar *id)
+{
+	TRACE_CALL(__func__);
+	if (id == NULL) return NULL;
+	if (id[0] == '/') return g_strdup(id);
+	return g_strdup_printf("%s/%s", g_get_home_dir(), id);
+}
+
+gchar *
+remmina_ssh_find_identity(void)
+{
+	TRACE_CALL(__func__);
+	gchar *path;
+	gint i;
+
+	for (i = 0; common_identities[i]; i++) {
+		path = remmina_ssh_identity_path(common_identities[i]);
+		if (g_file_test(path, G_FILE_TEST_IS_REGULAR | G_FILE_TEST_EXISTS))
+			return path;
+		g_free(path);
+	}
+	return NULL;
+}
+
+void
+remmina_ssh_set_error(RemminaSSH *ssh, const gchar *fmt)
+{
+	TRACE_CALL(__func__);
+	const gchar *err;
+
+	err = ssh_get_error(ssh->session);
+	ssh->error = g_strdup_printf(fmt, err);
+}
+
+void
+remmina_ssh_set_application_error(RemminaSSH *ssh, const gchar *fmt, ...)
+{
+	TRACE_CALL(__func__);
+	va_list args;
+
+	va_start(args, fmt);
+	ssh->error = g_strdup_vprintf(fmt, args);
+	va_end(args);
+}
+
+static enum remmina_ssh_auth_result
+remmina_ssh_auth_interactive(RemminaSSH *ssh)
+{
+	TRACE_CALL(__func__);
+	gint ret;
+	gint n;
+	gint i;
+	const gchar *name, *instruction = NULL;
+	//gchar *prompt,*ptr;
+
+	ret = SSH_AUTH_ERROR;
+	if (ssh->authenticated) return REMMINA_SSH_AUTH_SUCCESS;
+	/* TODO: What if I have an empty password? */
+	if (ssh->password == NULL) {
+		remmina_ssh_set_error(ssh, "OTP code is empty");
+		REMMINA_DEBUG("OTP code is empty, returning");
+		return REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT;
+	}
+	REMMINA_DEBUG("OTP code has been set to: %s", ssh->password);
+
+	ret = ssh_userauth_kbdint(ssh->session, NULL, NULL);
+	while (ret == SSH_AUTH_INFO) {
+		name = ssh_userauth_kbdint_getname(ssh->session);
+		if (strlen(name) > 0)
+			REMMINA_DEBUG("SSH kbd-interactive name: %s", name);
+		else
+			REMMINA_DEBUG("SSH kbd-interactive name is empty");
+		instruction = ssh_userauth_kbdint_getinstruction(ssh->session);
+		if (strlen(instruction) > 0)
+			REMMINA_DEBUG("SSH kbd-interactive instruction: %s", instruction);
+		else
+			REMMINA_DEBUG("SSH kbd-interactive instruction is empty");
+		n = ssh_userauth_kbdint_getnprompts(ssh->session);
+		for (i = 0; i < n; i++)
+			ssh_userauth_kbdint_setanswer(ssh->session, i, ssh->password);
+		ret = ssh_userauth_kbdint(ssh->session, NULL, NULL);
+	}
+
+
+	REMMINA_DEBUG("ssh_userauth_kbdint returned %d", ret);
+	switch (ret) {
+	case SSH_AUTH_PARTIAL:
+		if (ssh->password) {
+			g_free(ssh->password);
+			ssh->password = NULL;
+		}
+		//You've been partially authenticated, you still have to use another method
+		REMMINA_DEBUG("Authenticated with SSH keyboard interactive. Another method is required. %d", ret);
+		ssh->is_multiauth = TRUE;
+		return REMMINA_SSH_AUTH_PARTIAL;
+		break;
+	case SSH_AUTH_SUCCESS:
+		//Authentication success
+		ssh->authenticated = TRUE;
+		REMMINA_DEBUG("Authenticated with SSH keyboard interactive. %s", ssh->error);
+		return REMMINA_SSH_AUTH_SUCCESS;
+		break;
+	case SSH_AUTH_INFO:
+		//The server asked some questions. Use ssh_userauth_kbdint_getnprompts() and such.
+		REMMINA_DEBUG("Authenticating aagin with SSH keyboard interactive??? %s", ssh->error);
+		break;
+	case SSH_AUTH_AGAIN:
+		//In nonblocking mode, you've got to call this again later.
+		REMMINA_DEBUG("Authenticated with keyboard interactive, Requested to authenticate again. %s", ssh->error);
+		return REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT;
+		break;
+	case SSH_AUTH_DENIED:
+	case SSH_AUTH_ERROR:
+	default:
+		//A serious error happened
+		ssh->authenticated = FALSE;
+		remmina_ssh_set_error(ssh, _("Could not authenticate with TOTP/OTP/2FA. %s"));
+		REMMINA_DEBUG("Cannot authenticate with TOTP/OTP/2FA. Error is %s", ssh->error);
+		return REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT;
+	}
+	ssh->authenticated = FALSE;
+	return REMMINA_SSH_AUTH_FATAL_ERROR;
+}
+
+static enum remmina_ssh_auth_result
+remmina_ssh_auth_password(RemminaSSH *ssh)
+{
+	TRACE_CALL(__func__);
+	gint ret;
+
+	REMMINA_DEBUG("Password authentication");
+
+	ret = SSH_AUTH_ERROR;
+	if (ssh->authenticated) {
+		REMMINA_DEBUG("Already authenticated");
+		return REMMINA_SSH_AUTH_SUCCESS;
+	}
+	if (ssh->password == NULL) {
+		remmina_ssh_set_error(ssh, "Password is null");
+		REMMINA_DEBUG("Password is null, returning");
+		return REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT;
+	}
+
+	ret = ssh_userauth_password(ssh->session, NULL, ssh->password);
+	REMMINA_DEBUG("Authentication with SSH password returned: %d", ret);
+
+	switch (ret) {
+	case SSH_AUTH_PARTIAL:
+		if (ssh->password) {
+			g_free(ssh->password);
+			ssh->password = NULL;
+		}
+		//You've been partially authenticated, you still have to use another method.
+		REMMINA_DEBUG("Authenticated with SSH password, Another method is required. %d", ret);
+		ssh->is_multiauth = TRUE;
+		return REMMINA_SSH_AUTH_PARTIAL;
+		break;
+	case SSH_AUTH_SUCCESS:
+		//The public key is accepted.
+		ssh->authenticated = TRUE;
+		REMMINA_DEBUG("Authenticated with SSH password. %s", ssh->error);
+		return REMMINA_SSH_AUTH_SUCCESS;
+		break;
+	case SSH_AUTH_AGAIN:
+		//In nonblocking mode, you've got to call this again later.
+		REMMINA_DEBUG("Authenticated with SSH password, Requested to authenticate again. %s", ssh->error);
+		ssh->authenticated = FALSE;
+		return REMMINA_SSH_AUTH_AGAIN;
+		break;
+	case SSH_AUTH_DENIED:
+	case SSH_AUTH_ERROR:
+	default:
+		//A serious error happened.
+		ssh->authenticated = FALSE;
+		REMMINA_DEBUG("Cannot authenticate with password. Error is %s", ssh->error);
+		remmina_ssh_set_error(ssh, _("Could not authenticate with SSH password. %s"));
+		return REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT;
+	}
+	ssh->authenticated = FALSE;
+	return REMMINA_SSH_AUTH_FATAL_ERROR;
+}
+
+static enum remmina_ssh_auth_result
+remmina_ssh_auth_pubkey(RemminaSSH *ssh, RemminaProtocolWidget *gp, RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+
+	ssh_key key = NULL;
+	ssh_key cert = NULL;
+	gchar pubkey[132] = { 0 }; // +".pub"
+	gint ret;
+
+	if (ssh->authenticated) return REMMINA_SSH_AUTH_SUCCESS;
+
+	REMMINA_DEBUG("SSH certificate file: %s", ssh->certfile);
+	REMMINA_DEBUG("File for private SSH key: %s", ssh->privkeyfile);
+	if (ssh->certfile != NULL) {
+#if LIBSSH_VERSION_INT >= SSH_VERSION_INT(0, 9, 0)
+		/* First we import the private key */
+		if (ssh_pki_import_privkey_file(ssh->privkeyfile, (ssh->passphrase ? ssh->passphrase : ""),
+						NULL, NULL, &key) != SSH_OK) {
+			if (ssh->passphrase == NULL || ssh->passphrase[0] == '\0') {
+				remmina_ssh_set_error(ssh, _("No saved SSH password supplied. Asking user to enter it."));
+				return REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT;
+			}
+
+			// TRANSLATORS: The placeholder %s is an error message
+			remmina_ssh_set_error(ssh, _("Could not authenticate with public SSH key. %s"));
+			return REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT;
+		}
+		REMMINA_DEBUG ("Imported private SSH key file");
+		/* First we import the certificate */
+		ret = ssh_pki_import_cert_file(ssh->certfile, &cert );
+		if (ret != SSH_OK) {
+			REMMINA_DEBUG ("Certificate import returned: %d", ret);
+			// TRANSLATORS: The placeholder %s is an error message
+			remmina_ssh_set_error(ssh, _("SSH certificate cannot be imported. %s"));
+			return REMMINA_SSH_AUTH_FATAL_ERROR;
+		}
+		REMMINA_DEBUG ("certificate imported correctly");
+		/* We copy th certificate in the private key */
+		ret = ssh_pki_copy_cert_to_privkey(cert, key);
+		if (ret != SSH_OK) {
+			REMMINA_DEBUG ("Copying the certificate into a key returned: %d", ret);
+			// TRANSLATORS: The placeholder %s is an error message
+			remmina_ssh_set_error(ssh, _("SSH certificate cannot be copied into the private SSH key. %s"));
+			ssh_key_free(cert);
+			return REMMINA_SSH_AUTH_FATAL_ERROR;
+		}
+		REMMINA_DEBUG ("%s certificate copied into the private SSH key", ssh->certfile);
+		/* We try to authenticate */
+		ret = ssh_userauth_try_publickey(ssh->session, NULL, cert);
+		if (ret != SSH_AUTH_SUCCESS && ret != SSH_AUTH_AGAIN ) {
+			REMMINA_DEBUG ("Trying to authenticate with the new key returned: %d", ret);
+			// TRANSLATORS: The placeholder %s is an error message
+			remmina_ssh_set_error(ssh, _("Could not authenticate using SSH certificate. %s"));
+			ssh_key_free(key);
+			ssh_key_free(cert);
+			return REMMINA_SSH_AUTH_FATAL_ERROR;
+		}
+		REMMINA_DEBUG ("Authentication with a certificate file works, we can authenticate");
+#else
+		REMMINA_DEBUG ("lbssh >= 0.9.0 is required to authenticate with certificate file");
+#endif
+		/* if it goes well we authenticate (later on) with the key, not the cert*/
+	} else {
+		if (ssh->privkeyfile == NULL) {
+			// TRANSLATORS: The placeholder %s is an error message
+			ssh->error = g_strdup_printf(_("Could not authenticate with public SSH key. %s"),
+						     _("SSH identity file not selected."));
+			return REMMINA_SSH_AUTH_FATAL_ERROR;
+		}
+
+		// Check for empty username
+		if (ssh->user == NULL) {
+			remmina_ssh_set_error(ssh, _("No username found. Asking user to enter it."));
+			return REMMINA_SSH_AUTH_AUTHFAILED_EMPTY_USERNAME;
+		}
+
+		g_snprintf(pubkey, sizeof(pubkey), "%s.pub", ssh->privkeyfile);
+
+		/*G_FILE_TEST_EXISTS*/
+		if (g_file_test(pubkey, G_FILE_TEST_EXISTS)) {
+			ret = ssh_pki_import_pubkey_file(pubkey, &key);
+			if (ret != SSH_OK) {
+				// TRANSLATORS: The placeholder %s is an error message
+				remmina_ssh_set_error(ssh, _("Public SSH key cannot be imported. %s"));
+				ssh_key_free(key);
+				return REMMINA_SSH_AUTH_FATAL_ERROR;
+			}
+		}
+
+		if (ssh_pki_import_privkey_file(ssh->privkeyfile, (ssh->passphrase ? ssh->passphrase : ""),
+						NULL, NULL, &key) != SSH_OK) {
+			if (ssh->passphrase == NULL || ssh->passphrase[0] == '\0') {
+				remmina_ssh_set_error(ssh, _("No saved SSH password supplied. Asking user to enter it."));
+				return REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT;
+			}
+
+			// TRANSLATORS: The placeholder %s is an error message
+			remmina_ssh_set_error(ssh, _("Could not authenticate with public SSH key. %s"));
+			return REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT;
+		}
+	}
+
+	ret = ssh_userauth_publickey(ssh->session, NULL, key);
+	ssh_key_free(key);
+	ssh_key_free(cert);
+	REMMINA_DEBUG("Authentication with public SSH key returned: %d", ret);
+
+	switch (ret) {
+	case SSH_AUTH_PARTIAL:
+		if (ssh->password) {
+			g_free(ssh->password);
+			ssh->password = NULL;
+		}
+		//You've been partially authenticated, you still have to use another method.
+		REMMINA_DEBUG("Authenticated with public SSH key, Another method is required. %d", ret);
+		ssh->is_multiauth = TRUE;
+		return REMMINA_SSH_AUTH_PARTIAL;
+		break;
+	case SSH_AUTH_SUCCESS:
+		//The public key is accepted.
+		ssh->authenticated = TRUE;
+		REMMINA_DEBUG("Authenticated with public SSH key. %s", ssh->error);
+		return REMMINA_SSH_AUTH_SUCCESS;
+		break;
+	case SSH_AUTH_AGAIN:
+		//In nonblocking mode, you've got to call this again later.
+		REMMINA_DEBUG("Authenticated with public SSH key, Requested to authenticate again. %s", ssh->error);
+		ssh->authenticated = FALSE;
+		return REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT;
+		break;
+	case SSH_AUTH_DENIED:
+	case SSH_AUTH_ERROR:
+	default:
+		//A serious error happened.
+		ssh->authenticated = FALSE;
+		REMMINA_DEBUG("Could not authenticate with public SSH key. %s", ssh->error);
+		remmina_ssh_set_error(ssh, _("Could not authenticate with public SSH key. %s"));
+		return REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT;
+	}
+	return REMMINA_SSH_AUTH_FATAL_ERROR;
+}
+
+static enum remmina_ssh_auth_result
+remmina_ssh_auth_auto_pubkey(RemminaSSH *ssh, RemminaProtocolWidget *gp, RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+
+	gint ret;
+	ret = ssh_userauth_publickey_auto(ssh->session, NULL, (ssh->passphrase ? ssh->passphrase : NULL));
+
+	REMMINA_DEBUG("Authentication with public SSH key returned: %d", ret);
+
+	switch (ret) {
+	case SSH_AUTH_PARTIAL:
+		if (ssh->password) {
+			g_free(ssh->password);
+			ssh->password = NULL;
+		}
+		//You've been partially authenticated, you still have to use another method.
+		REMMINA_DEBUG("Authenticated with public SSH key, Another method is required. %d", ret);
+		ssh->is_multiauth = TRUE;
+		return REMMINA_SSH_AUTH_PARTIAL;
+		break;
+	case SSH_AUTH_SUCCESS:
+		//The public key is accepted.
+		ssh->authenticated = TRUE;
+		REMMINA_DEBUG("Authenticated with public SSH key. %s", ssh->error);
+		return REMMINA_SSH_AUTH_SUCCESS;
+		break;
+	case SSH_AUTH_AGAIN:
+		//In nonblocking mode, you've got to call this again later.
+		REMMINA_DEBUG("Authenticated with public SSH key, Requested to authenticate again. %s", ssh->error);
+		ssh->authenticated = FALSE;
+		return REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT;
+		break;
+	case SSH_AUTH_DENIED:
+	case SSH_AUTH_ERROR:
+	default:
+		//A serious error happened.
+		ssh->authenticated = FALSE;
+		REMMINA_DEBUG("Cannot authenticate automatically with public SSH key. %s", ssh->error);
+		remmina_ssh_set_error(ssh, _("Could not authenticate automatically with public SSH key. %s"));
+		return REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT;
+	}
+	ssh->authenticated = FALSE;
+	return REMMINA_SSH_AUTH_FATAL_ERROR;
+}
+
+static enum remmina_ssh_auth_result
+remmina_ssh_auth_agent(RemminaSSH *ssh)
+{
+	TRACE_CALL(__func__);
+	gint ret;
+	ret = ssh_userauth_agent(ssh->session, NULL);
+
+	REMMINA_DEBUG("Authentication with SSH agent returned: %d", ret);
+
+	switch (ret) {
+	case SSH_AUTH_PARTIAL:
+		if (ssh->password) {
+			g_free(ssh->password);
+			ssh->password = NULL;
+		}
+		//You've been partially authenticated, you still have to use another method.
+		REMMINA_DEBUG("Authenticated with public SSH key, Another method is required. %d", ret);
+		ssh->is_multiauth = TRUE;
+		return REMMINA_SSH_AUTH_PARTIAL;
+		break;
+	case SSH_AUTH_SUCCESS:
+		//The public key is accepted.
+		ssh->authenticated = TRUE;
+		REMMINA_DEBUG("Authenticated with public SSH key. %s", ssh->error);
+		return REMMINA_SSH_AUTH_SUCCESS;
+		break;
+	case SSH_AUTH_AGAIN:
+		//In nonblocking mode, you've got to call this again later.
+		REMMINA_DEBUG("Authenticated with public SSH key, Requested to authenticate again. %s", ssh->error);
+		ssh->authenticated = FALSE;
+		return REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT;
+		break;
+	case SSH_AUTH_DENIED:
+	case SSH_AUTH_ERROR:
+	default:
+		//A serious error happened.
+		ssh->authenticated = FALSE;
+		REMMINA_DEBUG("Cannot authenticate automatically with SSH agent. %s", ssh->error);
+		remmina_ssh_set_error(ssh, _("Could not authenticate automatically with SSH agent. %s"));
+		return REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT;
+	}
+	ssh->authenticated = FALSE;
+	return REMMINA_SSH_AUTH_FATAL_ERROR;
+
+}
+
+static enum remmina_ssh_auth_result
+remmina_ssh_auth_gssapi(RemminaSSH *ssh)
+{
+	TRACE_CALL(__func__);
+	gint ret;
+
+	ret = ssh_userauth_gssapi(ssh->session);
+	REMMINA_DEBUG("Authentication with SSH GSSAPI/Kerberos: %d", ret);
+
+	switch (ret) {
+	case SSH_AUTH_PARTIAL:
+		if (ssh->password) {
+			g_free(ssh->password);
+			ssh->password = NULL;
+		}
+		//You've been partially authenticated, you still have to use another method.
+		REMMINA_DEBUG("Authenticated with public SSH key, Another method is required. %d", ret);
+		ssh->is_multiauth = TRUE;
+		return REMMINA_SSH_AUTH_PARTIAL;
+		break;
+	case SSH_AUTH_SUCCESS:
+		//The public key is accepted.
+		ssh->authenticated = TRUE;
+		REMMINA_DEBUG("Authenticated with public SSH key. %s", ssh->error);
+		return REMMINA_SSH_AUTH_SUCCESS;
+		break;
+	case SSH_AUTH_AGAIN:
+		//In nonblocking mode, you've got to call this again later.
+		REMMINA_DEBUG("Authenticated with public SSH key, Requested to authenticate again. %s", ssh->error);
+		ssh->authenticated = FALSE;
+		return REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT;
+		break;
+	case SSH_AUTH_DENIED:
+	case SSH_AUTH_ERROR:
+	default:
+		//A serious error happened.
+		ssh->authenticated = FALSE;
+		REMMINA_DEBUG("Cannot authenticate with SSH GSSAPI/Kerberos. %s", ssh->error);
+		remmina_ssh_set_error(ssh, _("Could not authenticate with SSH GSSAPI/Kerberos. %s"));
+		return REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT;
+	}
+	ssh->authenticated = FALSE;
+	return REMMINA_SSH_AUTH_FATAL_ERROR;
+}
+
+enum remmina_ssh_auth_result
+remmina_ssh_auth(RemminaSSH *ssh, const gchar *password, RemminaProtocolWidget *gp, RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	gint method;
+	enum remmina_ssh_auth_result rv = REMMINA_SSH_AUTH_NULL;
+
+	/* Check known host again to ensure it’s still the original server when user forks
+	 * a new session from existing one */
+#if LIBSSH_VERSION_INT >= SSH_VERSION_INT(0, 9, 0)
+	/* TODO: Add error checking
+	 * SSH_KNOWN_HOSTS_OK: The server is known and has not changed.
+	 * SSH_KNOWN_HOSTS_CHANGED: The server key has changed. Either you are under attack or the administrator changed the key. You HAVE to warn the user about a possible attack.
+	 * SSH_KNOWN_HOSTS_OTHER: The server gave use a key of a type while we had an other type recorded. It is a possible attack.
+	 * SSH_KNOWN_HOSTS_UNKNOWN: The server is unknown. User should confirm the public key hash is correct.
+	 * SSH_KNOWN_HOSTS_NOT_FOUND: The known host file does not exist. The host is thus unknown. File will be created if host key is accepted.
+	 * SSH_KNOWN_HOSTS_ERROR: There had been an error checking the host.
+	 */
+	if (ssh_session_is_known_server(ssh->session) != SSH_KNOWN_HOSTS_OK) {
+#else
+	if (ssh_is_server_known(ssh->session) != SSH_SERVER_KNOWN_OK) {
+#endif
+		remmina_ssh_set_application_error(ssh, _("The public SSH key changed!"));
+		return REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT;
+	}
+
+	if (password) {
+		if (password != ssh->password) {
+			g_free(ssh->password);
+			ssh->password = NULL;
+		}
+		if (password != ssh->passphrase) g_free(ssh->passphrase);
+		ssh->password = g_strdup(password);
+		ssh->passphrase = g_strdup(password);
+	}
+
+	/** @todo Here we should call
+	 * gint method;
+	 * method = ssh_userauth_list(ssh->session, NULL);
+	 *
+	 * #define SSH_AUTH_METHOD_UNKNOWN     0x0000u
+	 * #define SSH_AUTH_METHOD_NONE        0x0001u
+	 * #define SSH_AUTH_METHOD_PASSWORD    0x0002u
+	 * #define SSH_AUTH_METHOD_PUBLICKEY   0x0004u
+	 * #define SSH_AUTH_METHOD_HOSTBASED   0x0008u
+	 * #define SSH_AUTH_METHOD_INTERACTIVE 0x0010u
+	 * #define SSH_AUTH_METHOD_GSSAPI_MIC  0x0020u
+	 *
+	 * And than test both the method and the option selected by the user
+	 */
+	method = ssh_userauth_list(ssh->session, NULL);
+	REMMINA_DEBUG("Methods supported by server: %s%s%s%s%s%s%s",
+		      (method & SSH_AUTH_METHOD_NONE) ? "SSH_AUTH_METHOD_NONE " : "",
+		      (method & SSH_AUTH_METHOD_UNKNOWN) ? "SSH_AUTH_METHOD_UNKNOWN " : "",
+		      (method & SSH_AUTH_METHOD_PASSWORD) ? "SSH_AUTH_METHOD_PASSWORD " : "",
+		      (method & SSH_AUTH_METHOD_PUBLICKEY) ? "SSH_AUTH_METHOD_PUBLICKEY " : "",
+		      (method & SSH_AUTH_METHOD_HOSTBASED) ? "SSH_AUTH_METHOD_HOSTBASED " : "",
+		      (method & SSH_AUTH_METHOD_INTERACTIVE) ? "SSH_AUTH_METHOD_INTERACTIVE " : "",
+		      (method & SSH_AUTH_METHOD_GSSAPI_MIC) ? "SSH_AUTH_METHOD_GSSAPI_MIC " : ""
+		      );
+	switch (ssh->auth) {
+	case SSH_AUTH_PASSWORD:
+		/* This authentication method is normally disabled on SSHv2 server. You should use keyboard-interactive mode. */
+		REMMINA_DEBUG("SSH_AUTH_PASSWORD (%d)", ssh->auth);
+		if (ssh->authenticated)
+			return REMMINA_SSH_AUTH_SUCCESS;
+		if (method & SSH_AUTH_METHOD_PASSWORD) {
+			REMMINA_DEBUG("SSH using remmina_ssh_auth_password");
+			rv = remmina_ssh_auth_password(ssh);
+		}
+		if (!ssh->authenticated && (method & SSH_AUTH_METHOD_INTERACTIVE)) {
+			/* SSH server is requesting us to do interactive auth. */
+			REMMINA_DEBUG("SSH using remmina_ssh_auth_interactive after password has failed");
+			rv = remmina_ssh_auth_interactive(ssh);
+		}
+		if (rv == REMMINA_SSH_AUTH_PARTIAL) {
+			if (ssh->password) {
+				g_free(ssh->password);
+				ssh->password = NULL;
+			}
+			switch (ssh_userauth_list(ssh->session, NULL)) {
+				case SSH_AUTH_METHOD_PASSWORD:
+					ssh->auth = SSH_AUTH_PASSWORD;
+					break;
+				case SSH_AUTH_METHOD_PUBLICKEY:
+					ssh->auth = SSH_AUTH_PUBLICKEY;
+					break;
+				case SSH_AUTH_METHOD_HOSTBASED:
+					REMMINA_DEBUG("Host-based authentication method not implemented: %d", ssh->auth);
+					break;
+				case SSH_AUTH_METHOD_INTERACTIVE:
+					ssh->auth = SSH_AUTH_KBDINTERACTIVE;
+					//REMMINA_DEBUG("Interactive auth method not implemented: %d", ssh->auth);
+					break;
+				case SSH_AUTH_METHOD_UNKNOWN:
+				default:
+					REMMINA_DEBUG("User-based authentication method not supported: %d", ssh->auth);
+					return REMMINA_SSH_AUTH_FATAL_ERROR;
+			}
+		}
+		ssh->error = g_strdup_printf(_("Could not authenticate with SSH password. %s"), "");
+		return rv;
+		break;
+
+	case SSH_AUTH_KBDINTERACTIVE:
+		REMMINA_DEBUG("SSH using remmina_ssh_auth_interactive");
+		if (method & SSH_AUTH_METHOD_INTERACTIVE) {
+			rv = remmina_ssh_auth_interactive(ssh);
+			if (rv == REMMINA_SSH_AUTH_PARTIAL) {
+				if (ssh->password) {
+					g_free(ssh->password);
+					ssh->password = NULL;
+				}
+				switch (ssh_userauth_list(ssh->session, NULL)) {
+				case SSH_AUTH_METHOD_PASSWORD:
+					ssh->auth = SSH_AUTH_PASSWORD;
+					break;
+				case SSH_AUTH_METHOD_PUBLICKEY:
+					ssh->auth = SSH_AUTH_PUBLICKEY;
+					break;
+				case SSH_AUTH_METHOD_HOSTBASED:
+					REMMINA_DEBUG("Host-based authentication method not implemented: %d", ssh->auth);
+					break;
+				case SSH_AUTH_METHOD_INTERACTIVE:
+					ssh->auth = SSH_AUTH_KBDINTERACTIVE;
+					//REMMINA_DEBUG("Interactive auth method not implemented: %d", ssh->auth);
+					break;
+				case SSH_AUTH_METHOD_UNKNOWN:
+				default:
+					REMMINA_DEBUG("User-based authentication method not supported: %d", ssh->auth);
+					return REMMINA_SSH_AUTH_FATAL_ERROR;
+				}
+			}
+			return rv;
+		}
+		ssh->error = g_strdup_printf(_("Could not authenticate with keyboard-interactive. %s"), "");
+		break;
+
+	case SSH_AUTH_PUBLICKEY:
+		REMMINA_DEBUG("SSH_AUTH_PUBLICKEY (%d)", ssh->auth);
+		if (method & SSH_AUTH_METHOD_PUBLICKEY) {
+			rv = remmina_ssh_auth_pubkey(ssh, gp, remminafile);
+			if (rv == REMMINA_SSH_AUTH_PARTIAL) {
+				if (ssh->password) {
+					g_free(ssh->password);
+					ssh->password = NULL;
+				}
+				switch (ssh_userauth_list(ssh->session, NULL)) {
+				case SSH_AUTH_METHOD_PASSWORD:
+					ssh->auth = SSH_AUTH_PASSWORD;
+					break;
+				case SSH_AUTH_METHOD_PUBLICKEY:
+					ssh->auth = SSH_AUTH_PUBLICKEY;
+					break;
+				case SSH_AUTH_METHOD_HOSTBASED:
+					REMMINA_DEBUG("Host based auth method not implemented: %d", ssh->auth);
+					break;
+				case SSH_AUTH_METHOD_INTERACTIVE:
+					ssh->auth = SSH_AUTH_KBDINTERACTIVE;
+					//REMMINA_DEBUG("Interactive auth method not implemented: %d", ssh->auth);
+					break;
+				case SSH_AUTH_METHOD_UNKNOWN:
+				default:
+					REMMINA_DEBUG("User auth method not supported: %d", ssh->auth);
+					return REMMINA_SSH_AUTH_FATAL_ERROR;
+				}
+			}
+			return rv;
+		}
+		// The real error here should be: "The SSH server %s:%d does not support public key authentication"
+		ssh->error = g_strdup_printf(_("Could not authenticate with public SSH key. %s"), "");
+		break;
+
+	case SSH_AUTH_AGENT:
+		REMMINA_DEBUG("SSH_AUTH_AGENT (%d)", ssh->auth);
+		rv = remmina_ssh_auth_agent(ssh);
+		if (rv == REMMINA_SSH_AUTH_PARTIAL) {
+			if (ssh->password) {
+				g_free(ssh->password);
+				ssh->password = NULL;
+			}
+			switch (ssh_userauth_list(ssh->session, NULL)) {
+				case SSH_AUTH_METHOD_PASSWORD:
+					ssh->auth = SSH_AUTH_PASSWORD;
+					break;
+				case SSH_AUTH_METHOD_PUBLICKEY:
+					ssh->auth = SSH_AUTH_PUBLICKEY;
+					break;
+				case SSH_AUTH_METHOD_HOSTBASED:
+					REMMINA_DEBUG("Host based auth method not implemented: %d", ssh->auth);
+					break;
+				case SSH_AUTH_METHOD_INTERACTIVE:
+					ssh->auth = SSH_AUTH_KBDINTERACTIVE;
+					//REMMINA_DEBUG("Interactive auth method not implemented: %d", ssh->auth);
+					break;
+				case SSH_AUTH_METHOD_UNKNOWN:
+				default:
+					REMMINA_DEBUG("User auth method not supported: %d", ssh->auth);
+					return REMMINA_SSH_AUTH_FATAL_ERROR;
+			}
+		}
+		return rv;
+		break;
+
+	case SSH_AUTH_AUTO_PUBLICKEY:
+		REMMINA_DEBUG("SSH_AUTH_AUTO_PUBLICKEY (%d)", ssh->auth);
+		rv = remmina_ssh_auth_auto_pubkey(ssh, gp, remminafile);
+		/* ssh_agent or none */
+		if (method & SSH_AUTH_METHOD_PUBLICKEY) {
+			if (rv == REMMINA_SSH_AUTH_PARTIAL) {
+				if (ssh->password) {
+					g_free(ssh->password);
+					ssh->password = NULL;
+				}
+				switch (ssh_userauth_list(ssh->session, NULL)) {
+					case SSH_AUTH_METHOD_PASSWORD:
+						ssh->auth = SSH_AUTH_PASSWORD;
+						break;
+					case SSH_AUTH_METHOD_PUBLICKEY:
+						ssh->auth = SSH_AUTH_PUBLICKEY;
+						break;
+					case SSH_AUTH_METHOD_HOSTBASED:
+						REMMINA_DEBUG("Host based auth method not implemented: %d", ssh->auth);
+						break;
+					case SSH_AUTH_METHOD_INTERACTIVE:
+						ssh->auth = SSH_AUTH_KBDINTERACTIVE;
+						//REMMINA_DEBUG("Interactive auth method not implemented: %d", ssh->auth);
+						break;
+					case SSH_AUTH_METHOD_UNKNOWN:
+					default:
+						REMMINA_DEBUG("User auth method not supported: %d", ssh->auth);
+						return REMMINA_SSH_AUTH_FATAL_ERROR;
+				}
+			}
+			return rv;
+		}
+		// The real error here should be: "The SSH server %s:%d does not support public key authentication"
+		ssh->error = g_strdup_printf(_("Could not authenticate with automatic public SSH key. %s"), "");
+		break;
+
+#if 0
+	/* Not yet supported by libssh */
+	case SSH_AUTH_HOSTBASED:
+		if (method & SSH_AUTH_METHOD_HOSTBASED)
+			//return remmina_ssh_auth_hostbased;
+			return 0;
+#endif
+
+	case SSH_AUTH_GSSAPI:
+		REMMINA_DEBUG("SSH_AUTH_GSSAPI (%d)", ssh->auth);
+		if (method & SSH_AUTH_METHOD_GSSAPI_MIC) {
+			rv = remmina_ssh_auth_gssapi(ssh);
+			if (rv == REMMINA_SSH_AUTH_PARTIAL) {
+				if (ssh->password) {
+					g_free(ssh->password);
+					ssh->password = NULL;
+				}
+				switch (ssh_userauth_list(ssh->session, NULL)) {
+				case SSH_AUTH_METHOD_PASSWORD:
+					ssh->auth = SSH_AUTH_PASSWORD;
+					break;
+				case SSH_AUTH_METHOD_PUBLICKEY:
+					ssh->auth = SSH_AUTH_PUBLICKEY;
+					break;
+				case SSH_AUTH_METHOD_HOSTBASED:
+					REMMINA_DEBUG("Host based auth method not implemented: %d", ssh->auth);
+					break;
+				case SSH_AUTH_METHOD_INTERACTIVE:
+					ssh->auth = SSH_AUTH_KBDINTERACTIVE;
+					//REMMINA_DEBUG("Interactive auth method not implemented: %d", ssh->auth);
+					break;
+				case SSH_AUTH_METHOD_UNKNOWN:
+				default:
+					REMMINA_DEBUG("User auth method not supported: %d", ssh->auth);
+					return REMMINA_SSH_AUTH_FATAL_ERROR;
+				}
+			}
+			return rv;
+		}
+		// The real error here should be: "The SSH server %s:%d does not support SSH GSSAPI/Kerberos authentication"
+		ssh->error = g_strdup_printf(_("Could not authenticate with SSH GSSAPI/Kerberos. %s"), "");
+		break;
+
+	default:
+		REMMINA_DEBUG("User auth method not supported: %d", ssh->auth);
+		return REMMINA_SSH_AUTH_FATAL_ERROR;
+	}
+
+	// We come here after a "break". ssh->error should be already set
+	return REMMINA_SSH_AUTH_FATAL_ERROR;
+}
+
+enum remmina_ssh_auth_result
+remmina_ssh_auth_gui(RemminaSSH *ssh, RemminaProtocolWidget *gp, RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	gchar *keyname;
+	gchar *pwdfkey = NULL;
+	gchar *message;
+	gchar *current_pwd;
+	gchar *current_user;
+	const gchar *instruction = NULL;
+	gint ret;
+	size_t len;
+	guchar *pubkey;
+	ssh_key server_pubkey;
+	gboolean disablepasswordstoring;
+	gboolean save_password;
+	gint attempt;
+
+	/* Check if the server’s public key is known */
+#if LIBSSH_VERSION_INT >= SSH_VERSION_INT(0, 9, 0)
+	/* TODO: Add error checking
+	 * SSH_KNOWN_HOSTS_OK: The server is known and has not changed.
+	 * SSH_KNOWN_HOSTS_CHANGED: The server key has changed. Either you are under attack or the administrator changed the key. You HAVE to warn the user about a possible attack.
+	 * SSH_KNOWN_HOSTS_OTHER: The server gave use a key of a type while we had an other type recorded. It is a possible attack.
+	 * SSH_KNOWN_HOSTS_UNKNOWN: The server is unknown. User should confirm the public key hash is correct.
+	 * SSH_KNOWN_HOSTS_NOT_FOUND: The known host file does not exist. The host is thus unknown. File will be created if host key is accepted.
+	 * SSH_KNOWN_HOSTS_ERROR: There had been an error checking the host.
+	 */
+	ret = ssh_session_is_known_server(ssh->session);
+	switch (ret) {
+	case SSH_KNOWN_HOSTS_OK:
+		break;                                                  /* ok */
+
+	/*  TODO: These are all wrong, we should deal with each of them */
+	case SSH_KNOWN_HOSTS_CHANGED:
+	case SSH_KNOWN_HOSTS_OTHER:
+	case SSH_KNOWN_HOSTS_UNKNOWN:
+	case SSH_KNOWN_HOSTS_NOT_FOUND:
+#else
+	ret = ssh_is_server_known(ssh->session);
+	switch (ret) {
+	case SSH_SERVER_KNOWN_OK:
+		break;                                                                  /* ok */
+
+	/*  fallback to SSH_SERVER_NOT_KNOWN behavior */
+	case SSH_SERVER_KNOWN_CHANGED:
+	case SSH_SERVER_FOUND_OTHER:
+	case SSH_SERVER_NOT_KNOWN:
+	case SSH_SERVER_FILE_NOT_FOUND:
+#endif
+#if LIBSSH_VERSION_INT >= SSH_VERSION_INT(0, 8, 6)
+		if (ssh_get_server_publickey(ssh->session, &server_pubkey) != SSH_OK) {
+			// TRANSLATORS: The placeholder %s is an error message
+			remmina_ssh_set_error(ssh, _("Could not fetch the server\'s public SSH key. %s"));
+			REMMINA_DEBUG("ssh_get_server_publickey() has failed");
+			return REMMINA_SSH_AUTH_FATAL_ERROR;
+		}
+#else
+		if (ssh_get_publickey(ssh->session, &server_pubkey) != SSH_OK) {
+			// TRANSLATORS: The placeholder %s is an error message
+			remmina_ssh_set_error(ssh, _("Could not fetch public SSH key. %s"));
+			REMMINA_DEBUG("ssh_get_publickey() has failed");
+			return REMMINA_SSH_AUTH_FATAL_ERROR;
+		}
+#endif
+		if (ssh_get_publickey_hash(server_pubkey, SSH_PUBLICKEY_HASH_MD5, &pubkey, &len) != 0) {
+			ssh_key_free(server_pubkey);
+			// TRANSLATORS: The placeholder %s is an error message
+			remmina_ssh_set_error(ssh, _("Could not fetch checksum of the public SSH key. %s"));
+			REMMINA_DEBUG("ssh_get_publickey_hash() has failed");
+			return REMMINA_SSH_AUTH_FATAL_ERROR;
+		}
+		ssh_key_free(server_pubkey);
+		keyname = ssh_get_hexa(pubkey, len);
+
+#if LIBSSH_VERSION_INT >= SSH_VERSION_INT(0, 9, 0)
+		if (ret == SSH_KNOWN_HOSTS_UNKNOWN || ret == SSH_KNOWN_HOSTS_NOT_FOUND) {
+#else
+		if (ret == SSH_SERVER_NOT_KNOWN || ret == SSH_SERVER_FILE_NOT_FOUND) {
+#endif
+			message = g_strdup_printf("%s\n%s\n\n%s",
+						  _("The server is unknown. The public key fingerprint is:"),
+						  keyname,
+						  _("Do you trust the new public key?"));
+		} else {
+			message = g_strdup_printf("%s\n%s\n\n%s",
+						  _("Warning: The server has changed its public key. This means you are either under attack,\n"
+						    "or the administrator has changed the key. The new public key fingerprint is:"),
+						  keyname,
+						  _("Do you trust the new public key?"));
+		}
+
+		ret = remmina_protocol_widget_panel_question_yesno(gp, message);
+		g_free(message);
+
+		ssh_string_free_char(keyname);
+		ssh_clean_pubkey_hash(&pubkey);
+		if (ret != GTK_RESPONSE_YES) return REMMINA_SSH_AUTH_USERCANCEL;
+#if LIBSSH_VERSION_INT >= SSH_VERSION_INT(0, 9, 0)
+		ssh_session_update_known_hosts(ssh->session);
+#else
+		ssh_write_knownhost(ssh->session);
+#endif
+		break;
+#if LIBSSH_VERSION_INT >= SSH_VERSION_INT(0, 9, 0)
+	case SSH_KNOWN_HOSTS_ERROR:
+#else
+	case SSH_SERVER_ERROR:
+#endif
+	default:
+		// TRANSLATORS: The placeholder %s is an error message
+		remmina_ssh_set_error(ssh, _("Could not check list of known SSH hosts. %s"));
+		REMMINA_DEBUG("Could not check list of known SSH hosts");
+		return REMMINA_SSH_AUTH_FATAL_ERROR;
+	}
+
+	enum { REMMINA_SSH_AUTH_PASSWORD, REMMINA_SSH_AUTH_PKPASSPHRASE, REMMINA_SSH_AUTH_KRBTOKEN, REMMINA_SSH_AUTH_KBDINTERACTIVE } remmina_ssh_auth_type;
+
+	switch (ssh->auth) {
+	case SSH_AUTH_PASSWORD:
+		keyname = _("SSH password");
+		pwdfkey = ssh->is_tunnel ? "ssh_tunnel_password" : "password";
+		remmina_ssh_auth_type = REMMINA_SSH_AUTH_PASSWORD;
+		break;
+	case SSH_AUTH_PUBLICKEY:
+	case SSH_AUTH_AGENT:
+	case SSH_AUTH_AUTO_PUBLICKEY:
+		keyname = _("Password for private SSH key");
+		pwdfkey = ssh->is_tunnel ? "ssh_tunnel_passphrase" : "ssh_passphrase";
+		remmina_ssh_auth_type = REMMINA_SSH_AUTH_PKPASSPHRASE;
+		break;
+	case SSH_AUTH_GSSAPI:
+		keyname = _("SSH Kerberos/GSSAPI");
+		pwdfkey = ssh->is_tunnel ? "ssh_tunnel_kerberos_token" : "ssh_kerberos_token";
+		remmina_ssh_auth_type = REMMINA_SSH_AUTH_KRBTOKEN;
+		break;
+	case SSH_AUTH_KBDINTERACTIVE:
+		instruction = _("Enter TOTP/OTP/2FA code");
+		remmina_ssh_auth_type = REMMINA_SSH_AUTH_KBDINTERACTIVE;
+		break;
+	default:
+		return REMMINA_SSH_AUTH_FATAL_ERROR;
+	}
+
+	disablepasswordstoring = remmina_file_get_int(remminafile, "disablepasswordstoring", FALSE);
+
+
+	current_pwd = g_strdup(remmina_file_get_string(remminafile, pwdfkey));
+
+	/* Try existing password/passphrase first */
+	ret = remmina_ssh_auth(ssh, current_pwd, gp, remminafile);
+	REMMINA_DEBUG("Returned %d at 1st attempt with the following message:", ret);
+	REMMINA_DEBUG("%s", ssh->error);
+
+	/* It seems that functions like ssh_userauth_password() can only be called 3 times
+	 * on a ssh connection. And the 3rd failed attempt will block the calling thread forever.
+	 * So we retry only 2 extra time authentication. */
+	for (attempt = 0;
+	     attempt < 2 && (ret == REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT || ret == REMMINA_SSH_AUTH_AUTHFAILED_EMPTY_USERNAME);
+	     attempt++) {
+		if (ssh->error)
+			REMMINA_DEBUG("Retrying auth because %s", ssh->error);
+
+		if (remmina_ssh_auth_type == REMMINA_SSH_AUTH_PKPASSPHRASE) {
+			// If username is empty, prompt user to enter it and attempt reconnect
+			if ( ret == REMMINA_SSH_AUTH_AUTHFAILED_EMPTY_USERNAME ) {
+				current_user = g_strdup(remmina_file_get_string(remminafile, ssh->is_tunnel ? "ssh_tunnel_username" : "username"));
+				ret = remmina_protocol_widget_panel_auth(gp,
+										(REMMINA_MESSAGE_PANEL_FLAG_USERNAME | REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD),
+										(ssh->is_tunnel ? _("SSH tunnel private key credentials") : _("SSH private key credentials")),
+										current_user,
+										remmina_file_get_string(remminafile, pwdfkey),
+										NULL,
+										_("Password for private SSH key"));
+
+				if (ret == GTK_RESPONSE_OK) {
+					// Save username to remmina file and reset ssh error for reconnect attempt
+					// If password is empty or changed, save the new password
+					remmina_file_set_string(remminafile, ssh->is_tunnel ? "ssh_tunnel_username" : "username", remmina_protocol_widget_get_username(gp));
+					ssh->user = remmina_protocol_widget_get_username(gp);
+					
+					g_free(current_pwd);
+					current_pwd = remmina_protocol_widget_get_password(gp);
+					save_password = remmina_protocol_widget_get_savepassword(gp);
+					if (save_password) {
+						remmina_file_set_string(remminafile, pwdfkey, current_pwd);
+					}
+					else {
+						remmina_file_set_string(remminafile, pwdfkey, NULL);
+					}
+
+					ssh->passphrase = remmina_protocol_widget_get_password(gp);
+					ssh->error = NULL;
+					return REMMINA_SSH_AUTH_RECONNECT;
+				}
+				else {
+					return REMMINA_SSH_AUTH_USERCANCEL;
+				}
+			}
+
+			ret = remmina_protocol_widget_panel_auth(gp,
+								 (disablepasswordstoring ? 0 :
+								  REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD),
+								 ssh->is_tunnel ? _("SSH tunnel credentials") : _("SSH credentials"),
+								 NULL,
+								 remmina_file_get_string(remminafile, pwdfkey),
+								 NULL,
+								 _("Password for private SSH key"));
+			if (ret == GTK_RESPONSE_OK) {
+				g_free(current_pwd);
+				current_pwd = remmina_protocol_widget_get_password(gp);
+				save_password = remmina_protocol_widget_get_savepassword(gp);
+				if (save_password)
+					remmina_file_set_string(remminafile, pwdfkey, current_pwd);
+				else
+					remmina_file_set_string(remminafile, pwdfkey, NULL);
+			} else {
+				g_free(current_pwd);
+				return REMMINA_SSH_AUTH_USERCANCEL;
+			}
+		} else if (remmina_ssh_auth_type == REMMINA_SSH_AUTH_PASSWORD) {
+			/* Ask for user credentials. Username cannot be changed here,
+			 * because we already sent it when opening the connection */
+			REMMINA_DEBUG("Showing panel for password\n");
+			current_user = g_strdup(remmina_file_get_string(remminafile, ssh->is_tunnel ? "ssh_tunnel_username" : "username"));
+			ret = remmina_protocol_widget_panel_auth(gp,
+								 (disablepasswordstoring ? 0 : REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD)
+								 | REMMINA_MESSAGE_PANEL_FLAG_USERNAME
+								 | (!ssh->is_tunnel ? 0 : REMMINA_MESSAGE_PANEL_FLAG_USERNAME_READONLY),
+								 ssh->is_tunnel ? _("SSH tunnel credentials") : _("SSH credentials"),
+								 current_user,
+								 current_pwd,
+								 NULL,
+								 NULL);
+			if (ret == GTK_RESPONSE_OK) {
+				g_free(current_pwd);
+				current_pwd = remmina_protocol_widget_get_password(gp);
+				save_password = remmina_protocol_widget_get_savepassword(gp);
+				if (save_password)
+					remmina_file_set_string(remminafile, pwdfkey, current_pwd);
+				else
+					remmina_file_set_string(remminafile, pwdfkey, NULL);
+
+				if (!ssh->is_tunnel && !ssh->is_multiauth) {
+					g_free(current_user);
+					current_user = remmina_protocol_widget_get_username(gp);
+					remmina_file_set_string(remminafile, "username", current_user);
+					if (ssh->user != NULL) {
+						g_free(ssh->user);
+						ssh->user = NULL;
+					}
+					ssh->user = g_strdup(current_user);
+					if (ssh->password != NULL) {
+						g_free(ssh->password);
+						ssh->password = NULL;
+					}
+					ssh->password = g_strdup(current_pwd);
+					g_free(current_user);
+					return REMMINA_SSH_AUTH_RECONNECT;
+				}
+				g_free(current_user);
+			} else {
+				g_free(current_pwd);
+				g_free(current_user);
+				return REMMINA_SSH_AUTH_USERCANCEL;
+			}
+		} else if (remmina_ssh_auth_type == REMMINA_SSH_AUTH_KBDINTERACTIVE) {
+			REMMINA_DEBUG("Showing panel for keyboard interactive login\n");
+			/**
+			 * gp
+			 * flags
+			 * title
+			 * default_username
+			 * default_password
+			 * default_domain
+			 * password_prompt
+			 */
+			ret = remmina_protocol_widget_panel_auth(
+				gp,
+				0,
+				_("Keyboard interactive login, TOTP/OTP/2FA"),
+				NULL,
+				NULL,
+				NULL,
+				instruction);
+			if (ret == GTK_RESPONSE_OK) {
+				g_free(current_pwd);
+				current_pwd = remmina_protocol_widget_get_password(gp);
+				REMMINA_DEBUG("OTP code is: %s", current_pwd);
+				ssh->password = g_strdup(current_pwd);
+			} else {
+				g_free(current_pwd);
+				return REMMINA_SSH_AUTH_USERCANCEL;
+			}
+		} else {
+			g_print("Unimplemented.");
+			g_free(current_pwd);
+			return REMMINA_SSH_AUTH_FATAL_ERROR;
+		}
+		REMMINA_DEBUG("Retrying authentication");
+		ret = remmina_ssh_auth(ssh, current_pwd, gp, remminafile);
+		REMMINA_DEBUG("Authentication attempt n° %d returned %d with the following message:", attempt + 2, ret);
+		REMMINA_DEBUG("%s", ssh->error);
+	}
+
+	g_free(current_pwd); current_pwd = NULL;
+
+	/* After attempting the max number of times, REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT
+	 * becomes REMMINA_SSH_AUTH_FATAL_ERROR */
+	if (ret == REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT || ret == REMMINA_SSH_AUTH_AGAIN) {
+		REMMINA_DEBUG("SSH Authentication failed");
+		ret = REMMINA_SSH_AUTH_FATAL_ERROR;
+	}
+
+	return ret;
+}
+
+void
+remmina_ssh_log_callback(ssh_session session, int priority, const char *message, void *userdata)
+{
+	TRACE_CALL(__func__);
+	REMMINA_DEBUG(message);
+}
+
+gboolean
+remmina_ssh_init_session(RemminaSSH *ssh)
+{
+	TRACE_CALL(__func__);
+	gint verbosity;
+	gint rc;
+	gchar *parsed_config;
+#ifdef HAVE_NETINET_TCP_H
+	socket_t sshsock;
+	gint optval;
+#endif
+	// Handle IPv4 / IPv6 dual stack
+	char *hostname;
+	struct addrinfo hints,*aitop,*ai;
+	char ipstr[INET6_ADDRSTRLEN];
+	void *addr4=NULL;
+	void *addr6=NULL;
+
+	ssh->callback = g_new0(struct ssh_callbacks_struct, 1);
+
+	/* Init & startup the SSH session */
+	REMMINA_DEBUG("server=%s port=%d is_tunnel=%s tunnel_entrance_host=%s tunnel_entrance_port=%d",
+		      ssh->server,
+		      ssh->port,
+		      ssh->is_tunnel ? "Yes" : "No",
+		      ssh->tunnel_entrance_host, ssh->tunnel_entrance_port);
+
+	ssh->session = ssh_new();
+
+	/* Tunnel sanity checks */
+	if (ssh->is_tunnel && ssh->tunnel_entrance_host != NULL) {
+		ssh->error = g_strdup_printf("Internal error in %s: is_tunnel and tunnel_entrance != NULL", __func__);
+		REMMINA_DEBUG(ssh->error);
+		return FALSE;
+	}
+	if (!ssh->is_tunnel && ssh->tunnel_entrance_host == NULL) {
+		ssh->error = g_strdup_printf("Internal error in %s: is_tunnel == false and tunnel_entrance == NULL", __func__);
+		REMMINA_DEBUG(ssh->error);
+		return FALSE;
+	}
+
+	/* Set connection host/port */
+	if (ssh->is_tunnel) {
+		ssh_options_set(ssh->session, SSH_OPTIONS_HOST, ssh->server);
+		ssh_options_set(ssh->session, SSH_OPTIONS_PORT, &ssh->port);
+		REMMINA_DEBUG("Setting SSH_OPTIONS_HOST to %s and SSH_OPTIONS_PORT to %d", ssh->server, ssh->port);
+	} else {
+		ssh_options_set(ssh->session, SSH_OPTIONS_HOST, ssh->tunnel_entrance_host);
+		ssh_options_set(ssh->session, SSH_OPTIONS_PORT, &ssh->tunnel_entrance_port);
+		REMMINA_DEBUG("Setting SSH_OPTIONS_HOST to %s and SSH_OPTIONS_PORT to %d", ssh->tunnel_entrance_host, ssh->tunnel_entrance_port);
+	}
+
+	if (ssh->privkeyfile && *ssh->privkeyfile != 0) {
+		rc = ssh_options_set(ssh->session, SSH_OPTIONS_IDENTITY, ssh->privkeyfile);
+		if (rc == 0)
+			REMMINA_DEBUG("SSH_OPTIONS_IDENTITY is now %s", ssh->privkeyfile);
+		else
+			REMMINA_DEBUG("SSH_OPTIONS_IDENTITY is not set, by default the files “identity”, “id_dsa” and “id_rsa” are used.");
+	}
+
+#ifdef SNAP_BUILD
+	ssh_options_set(ssh->session, SSH_OPTIONS_SSH_DIR, g_strdup_printf("%s/.ssh", g_getenv("SNAP_USER_COMMON")));
+#endif
+	ssh_callbacks_init(ssh->callback);
+	if (remmina_log_running()) {
+		verbosity = remmina_pref.ssh_loglevel;
+		ssh_options_set(ssh->session, SSH_OPTIONS_LOG_VERBOSITY, &verbosity);
+		ssh->callback->log_function = remmina_ssh_log_callback;
+		/* Reset libssh legacy userdata. This is a workaround for a libssh bug */
+		ssh_set_log_userdata(ssh->session);
+	}
+	ssh->callback->userdata = ssh;
+	ssh_set_callbacks(ssh->session, ssh->callback);
+
+	/* As the latest parse the ~/.ssh/config file */
+	if (g_strcmp0(ssh->tunnel_entrance_host, "127.0.0.1") == 0) {
+		REMMINA_DEBUG("SSH_OPTIONS_HOST temporary set to the destination host as ssh->tunnel_entrance_host is 127.0.0.1,");
+		ssh_options_set(ssh->session, SSH_OPTIONS_HOST, ssh->server);
+	}
+	if (remmina_pref.ssh_parseconfig) {
+		if (ssh_options_parse_config(ssh->session, NULL) == 0)
+			REMMINA_DEBUG("ssh_config have been correctly parsed");
+		else
+			REMMINA_DEBUG("Cannot parse ssh_config: %s", ssh_get_error(ssh->session));
+	}
+	if (g_strcmp0(ssh->tunnel_entrance_host, "127.0.0.1") == 0) {
+		REMMINA_DEBUG("Setting SSH_OPTIONS_HOST to ssh->tunnel_entrance_host is 127.0.0.1,");
+		ssh_options_set(ssh->session, SSH_OPTIONS_HOST, ssh->tunnel_entrance_host);
+	}
+	if (!ssh->user || *ssh->user == 0) {
+    rc = ssh_options_get(ssh->session, SSH_OPTIONS_USER, &parsed_config);
+    if (rc == SSH_OK) {
+      if (ssh->user)
+        g_free(ssh->user);
+      ssh->user = g_strdup(parsed_config);
+      ssh_string_free_char(parsed_config);
+    } else {
+      REMMINA_DEBUG("Parsing ssh_config for SSH_OPTIONS_USER returned an error: %s", ssh_get_error(ssh->session));
+    }
+  }
+  ssh_options_set(ssh->session, SSH_OPTIONS_USER, ssh->user);
+	REMMINA_DEBUG("SSH_OPTIONS_USER is now %s", ssh->user);
+
+	/* SSH_OPTIONS_PROXYCOMMAND */
+	rc = ssh_options_get(ssh->session, SSH_OPTIONS_PROXYCOMMAND, &parsed_config);
+	if (rc == SSH_OK) {
+		ssh->proxycommand = g_strdup(parsed_config);
+		ssh_string_free_char(parsed_config);
+	} else {
+		REMMINA_DEBUG("Parsing ssh_config for SSH_OPTIONS_PROXYCOMMAND returned an error: %s", ssh_get_error(ssh->session));
+	}
+	rc = ssh_options_set(ssh->session, SSH_OPTIONS_PROXYCOMMAND, ssh->proxycommand);
+	if (rc == 0)
+		REMMINA_DEBUG("SSH_OPTIONS_PROXYCOMMAND is now %s", ssh->proxycommand);
+	else
+		REMMINA_DEBUG("SSH_OPTIONS_PROXYCOMMAND does not have a valid value. %s", ssh->proxycommand);
+
+	/* SSH_OPTIONS_HOSTKEYS */
+	rc = ssh_options_get(ssh->session, SSH_OPTIONS_HOSTKEYS, &parsed_config);
+	if (rc == SSH_OK) {
+		ssh->hostkeytypes = g_strdup(parsed_config);
+		ssh_string_free_char(parsed_config);
+	} else {
+		REMMINA_DEBUG("Parsing ssh_config for SSH_OPTIONS_HOSTKEYS returned an error: %s", ssh_get_error(ssh->session));
+	}
+	rc = ssh_options_set(ssh->session, SSH_OPTIONS_HOSTKEYS, ssh->hostkeytypes);
+	if (rc == 0)
+		REMMINA_DEBUG("SSH_OPTIONS_HOSTKEYS is now %s", ssh->hostkeytypes);
+	else
+		REMMINA_DEBUG("SSH_OPTIONS_HOSTKEYS does not have a valid value. %s", ssh->hostkeytypes);
+
+	/* SSH_OPTIONS_KEY_EXCHANGE */
+	rc = ssh_options_get(ssh->session, SSH_OPTIONS_KEY_EXCHANGE, &parsed_config);
+	if (rc == SSH_OK) {
+		ssh->kex_algorithms = g_strdup(parsed_config);
+		ssh_string_free_char(parsed_config);
+	} else {
+		REMMINA_DEBUG("Parsing ssh_config for SSH_OPTIONS_KEY_EXCHANGE returned an error: %s", ssh_get_error(ssh->session));
+	}
+	rc = ssh_options_set(ssh->session, SSH_OPTIONS_KEY_EXCHANGE, ssh->kex_algorithms);
+	if (rc == 0)
+		REMMINA_DEBUG("SSH_OPTIONS_KEY_EXCHANGE is now %s", ssh->kex_algorithms);
+	else
+		REMMINA_DEBUG("SSH_OPTIONS_KEY_EXCHANGE does not have a valid value. %s", ssh->kex_algorithms);
+
+	/* SSH_OPTIONS_CIPHERS_C_S */
+	rc = ssh_options_get(ssh->session, SSH_OPTIONS_CIPHERS_C_S, &parsed_config);
+	if (rc == SSH_OK) {
+		ssh->ciphers = g_strdup(parsed_config);
+		ssh_string_free_char(parsed_config);
+	} else {
+		REMMINA_DEBUG("Parsing ssh_config for SSH_OPTIONS_CIPHERS_C_S returned an error: %s", ssh_get_error(ssh->session));
+	}
+	rc = ssh_options_set(ssh->session, SSH_OPTIONS_CIPHERS_C_S, ssh->ciphers);
+	if (rc == 0)
+		REMMINA_DEBUG("SSH_OPTIONS_CIPHERS_C_S has been set to %s", ssh->ciphers);
+	else
+		REMMINA_DEBUG("SSH_OPTIONS_CIPHERS_C_S does not have a valid value. %s", ssh->ciphers);
+	/* SSH_OPTIONS_STRICTHOSTKEYCHECK */
+	rc = ssh_options_get(ssh->session, SSH_OPTIONS_STRICTHOSTKEYCHECK, &parsed_config);
+	if (rc == SSH_OK) {
+		ssh->stricthostkeycheck = atoi(parsed_config);
+		ssh_string_free_char(parsed_config);
+	} else {
+		REMMINA_DEBUG("Parsing ssh_config for SSH_OPTIONS_STRICTHOSTKEYCHECK returned an error: %s", ssh_get_error(ssh->session));
+	}
+	rc = ssh_options_set(ssh->session, SSH_OPTIONS_STRICTHOSTKEYCHECK, &ssh->stricthostkeycheck);
+	if (rc == 0)
+		REMMINA_DEBUG("SSH_OPTIONS_STRICTHOSTKEYCHECK is now %d", ssh->stricthostkeycheck);
+	else
+		REMMINA_DEBUG("SSH_OPTIONS_STRICTHOSTKEYCHECK does not have a valid value. %d", ssh->stricthostkeycheck);
+	/* SSH_OPTIONS_COMPRESSION */
+	rc = ssh_options_get(ssh->session, SSH_OPTIONS_COMPRESSION, &parsed_config);
+	if (rc == SSH_OK) {
+		ssh->compression = g_strdup(parsed_config);
+		ssh_string_free_char(parsed_config);
+	} else {
+		REMMINA_DEBUG("Parsing ssh_config for SSH_OPTIONS_COMPRESSION returned an error: %s", ssh_get_error(ssh->session));
+	}
+	rc = ssh_options_set(ssh->session, SSH_OPTIONS_COMPRESSION, ssh->compression);
+	if (rc == 0)
+		REMMINA_DEBUG("SSH_OPTIONS_COMPRESSION is now %s", ssh->compression);
+	else
+		REMMINA_DEBUG("SSH_OPTIONS_COMPRESSION does not have a valid value. %s", ssh->compression);
+
+	// Handle the dual IPv4 / IPv6 stack
+	// Prioritize IPv6 and fallback to IPv4
+	if (ssh_connect(ssh->session)) {
+		unsigned short int success = 0;
+
+		// Run the DNS resolution 
+		// First retrieve host from the ssh->session structure
+		ssh_options_get(ssh->session, SSH_OPTIONS_HOST, &hostname);
+		// Call getaddrinfo
+		memset(&hints, 0, sizeof(hints));
+		hints.ai_family = AF_INET6;
+		hints.ai_socktype = SOCK_STREAM;
+		if ((getaddrinfo(hostname, NULL, &hints, &aitop)) != 0) {
+			ssh->error = g_strdup_printf("Could not resolve hostname %s to IPv6", hostname);
+			REMMINA_DEBUG(ssh->error);
+		}
+		else {
+			// We have one or more IPV6 addesses now, extract them
+			ai = aitop;
+			while (ai != NULL) {
+				struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)ai->ai_addr;
+				addr6 = &(ipv6->sin6_addr);
+				inet_ntop(AF_INET6, addr6, ipstr, sizeof ipstr);
+				ssh_options_set(ssh->session, SSH_OPTIONS_HOST, ipstr);
+				REMMINA_DEBUG("Setting SSH_OPTIONS_HOST to IPv6 %s", ipstr);
+				if (ssh_connect(ssh->session)) {
+					ssh_disconnect(ssh->session);
+					REMMINA_DEBUG("IPv6 session failed");
+				} else {
+					success = 1;
+					REMMINA_DEBUG("IPv6 session success !");
+					break;
+				}
+				ai = ai->ai_next;
+			}
+			freeaddrinfo(aitop);
+		}
+		if (success == 0) {
+			// Fallback to IPv4
+			// Call getaddrinfo
+			memset(&hints, 0, sizeof(hints));
+			hints.ai_family = AF_INET;
+			hints.ai_socktype = SOCK_STREAM;
+			if ((getaddrinfo(hostname, NULL, &hints, &aitop)) != 0) {
+				ssh->error = g_strdup_printf("Could not resolve hostname %s to IPv4", hostname);
+				REMMINA_DEBUG(ssh->error);
+				return FALSE;
+			}
+			else {
+				// We have one or more IPV4 addesses now, extract them
+				ai = aitop;
+				while (ai != NULL) {
+					struct sockaddr_in *ipv4 = (struct sockaddr_in *)ai->ai_addr;
+					addr4 = &(ipv4->sin_addr);
+					inet_ntop(AF_INET, addr4, ipstr, sizeof ipstr);
+					ssh_options_set(ssh->session, SSH_OPTIONS_HOST, ipstr);
+					REMMINA_DEBUG("Setting SSH_OPTIONS_HOST to IPv4 %s", ipstr);
+					if (ssh_connect(ssh->session)) {
+						ssh_disconnect(ssh->session);
+						REMMINA_DEBUG("IPv4 session failed");
+					} else {
+						success = 1;
+						REMMINA_DEBUG("IPv4 session success !");
+						break;
+					}
+					ai = ai->ai_next;
+				}
+				freeaddrinfo(aitop);
+			}
+		}
+		if (success == 0){
+			return FALSE;
+		}
+	}
+ 
+ #ifdef HAVE_NETINET_TCP_H
+
+	/* Set keepalive on SSH socket, so we can keep firewalls awaken and detect
+	 * when we loss the tunnel */
+	sshsock = ssh_get_fd(ssh->session);
+	if (sshsock >= 0) {
+		optval = 1;
+		if (setsockopt(sshsock, SOL_SOCKET, SO_KEEPALIVE, &optval, sizeof(optval)) < 0)
+			REMMINA_DEBUG("TCP KeepAlive not set");
+		else
+			REMMINA_DEBUG("TCP KeepAlive enabled");
+
+#ifdef TCP_KEEPIDLE
+		optval = remmina_pref.ssh_tcp_keepidle;
+		if (setsockopt(sshsock, IPPROTO_TCP, TCP_KEEPIDLE, &optval, sizeof(optval)) < 0)
+			REMMINA_DEBUG("TCP_KEEPIDLE not set");
+		else
+			REMMINA_DEBUG("TCP_KEEPIDLE set to %i", optval);
+
+#endif
+#ifdef TCP_KEEPCNT
+		optval = remmina_pref.ssh_tcp_keepcnt;
+		if (setsockopt(sshsock, IPPROTO_TCP, TCP_KEEPCNT, &optval, sizeof(optval)) < 0)
+			REMMINA_DEBUG("TCP_KEEPCNT not set");
+		else
+			REMMINA_DEBUG("TCP_KEEPCNT set to %i", optval);
+
+#endif
+#ifdef TCP_KEEPINTVL
+		optval = remmina_pref.ssh_tcp_keepintvl;
+		if (setsockopt(sshsock, IPPROTO_TCP, TCP_KEEPINTVL, &optval, sizeof(optval)) < 0)
+			REMMINA_DEBUG("TCP_KEEPINTVL not set");
+		else
+			REMMINA_DEBUG("TCP_KEEPINTVL set to %i", optval);
+
+#endif
+#ifdef TCP_USER_TIMEOUT
+		optval = remmina_pref.ssh_tcp_usrtimeout;
+		if (setsockopt(sshsock, IPPROTO_TCP, TCP_USER_TIMEOUT, &optval, sizeof(optval)) < 0)
+			REMMINA_DEBUG("TCP_USER_TIMEOUT not set");
+		else
+			REMMINA_DEBUG("TCP_USER_TIMEOUT set to %i", optval);
+
+#endif
+	}
+#endif
+
+	/* Try the "none" authentication */
+	if (ssh_userauth_none(ssh->session, NULL) == SSH_AUTH_SUCCESS)
+		ssh->authenticated = TRUE;
+	return TRUE;
+}
+
+gboolean
+remmina_ssh_init_from_file(RemminaSSH *ssh, RemminaFile *remminafile, gboolean is_tunnel)
+{
+	TRACE_CALL(__func__);
+	const gchar *username;
+	const gchar *privatekey;
+	const gchar *server;
+	gchar *s;
+
+	ssh->session = NULL;
+	ssh->callback = NULL;
+	ssh->authenticated = FALSE;
+	ssh->error = NULL;
+	ssh->passphrase = NULL;
+	ssh->is_tunnel = is_tunnel;
+	pthread_mutex_init(&ssh->ssh_mutex, NULL);
+
+	ssh->tunnel_entrance_host = NULL;
+	ssh->tunnel_entrance_port = 0;
+
+	username = remmina_file_get_string(remminafile, is_tunnel ? "ssh_tunnel_username" : "username");
+	privatekey = remmina_file_get_string(remminafile, is_tunnel ? "ssh_tunnel_privatekey" : "ssh_privatekey");
+	ssh->certfile = g_strdup(remmina_file_get_string(remminafile, is_tunnel ? "ssh_tunnel_certfile" : "ssh_certfile"));
+
+	/* The ssh->server and ssh->port values */
+	if (is_tunnel) {
+		REMMINA_DEBUG("We are initializing an SSH tunnel session");
+		server = remmina_file_get_string(remminafile, "ssh_tunnel_server");
+		if (server == NULL || server[0] == 0) {
+			// ssh_tunnel_server empty or invalid, we are opening a tunnel, it means that "Same server at port 22" has been selected
+			server = remmina_file_get_string(remminafile, "server");
+			if (server == NULL || server[0] == 0)
+				server = "localhost";
+			REMMINA_DEBUG("Calling remmina_public_get_server_port");
+			remmina_public_get_server_port(server, 22, &ssh->server, &ssh->port);
+			ssh->port = 22;
+		} else {
+			REMMINA_DEBUG("Calling remmina_public_get_server_port");
+			remmina_public_get_server_port(server, 22, &ssh->server, &ssh->port);
+		}
+		REMMINA_DEBUG("server:port = %s, server = %s, port = %d", server, ssh->server, ssh->port);
+	} else {
+		REMMINA_DEBUG("We are initializing an SSH session");
+		server = remmina_file_get_string(remminafile, "server");
+		if (server == NULL || server[0] == 0)
+			server = "localhost";
+		REMMINA_DEBUG("Calling remmina_public_get_server_port");
+		remmina_public_get_server_port(server, 22, &ssh->server, &ssh->port);
+		REMMINA_DEBUG("server:port = %s, server = %s, port = %d", server, ssh->server, ssh->port);
+	}
+
+	if (ssh->server[0] == '\0') {
+		g_free(ssh->server);
+		// ???
+		REMMINA_DEBUG("Calling remmina_public_get_server_port");
+		remmina_public_get_server_port(server, 0, &ssh->server, NULL);
+	}
+
+	REMMINA_DEBUG("Initialized SSH struct from file with ssh->server = %s and SSH->port = %d", ssh->server, ssh->port);
+
+	ssh->user = g_strdup(username ? username : NULL);
+	ssh->password = NULL;
+	ssh->auth = remmina_file_get_int(remminafile, is_tunnel ? "ssh_tunnel_auth" : "ssh_auth", 0);
+	ssh->charset = g_strdup(remmina_file_get_string(remminafile, "ssh_charset"));
+	ssh->kex_algorithms = g_strdup(remmina_file_get_string(remminafile, is_tunnel ? "ssh_tunnel_kex_algorithms" : "ssh_kex_algorithms"));
+	ssh->ciphers = g_strdup(remmina_file_get_string(remminafile, is_tunnel ? "ssh_tunnel_ciphers" : "ssh_ciphers"));
+	ssh->hostkeytypes = g_strdup(remmina_file_get_string(remminafile, is_tunnel ? "ssh_tunnel_hostkeytypes" : "ssh_hostkeytypes"));
+	ssh->proxycommand = g_strdup(remmina_file_get_string(remminafile, is_tunnel ? "ssh_tunnel_proxycommand" : "ssh_proxycommand"));
+	ssh->stricthostkeycheck = remmina_file_get_int(remminafile, is_tunnel ? "ssh_tunnel_stricthostkeycheck" : "ssh_stricthostkeycheck", 0);
+	gint c = remmina_file_get_int(remminafile, is_tunnel ? "ssh_tunnel_compression" : "ssh_compression", 0);
+	ssh->compression = (c == 1) ? "yes" : "no";
+
+	REMMINA_DEBUG("ssh->user: %s", ssh->user);
+	REMMINA_DEBUG("ssh->password: %s", ssh->password);
+	REMMINA_DEBUG("ssh->auth: %d", ssh->auth);
+	REMMINA_DEBUG("ssh->charset: %s", ssh->charset);
+	REMMINA_DEBUG("ssh->kex_algorithms: %s", ssh->kex_algorithms);
+	REMMINA_DEBUG("ssh->ciphers: %s", ssh->ciphers);
+	REMMINA_DEBUG("ssh->hostkeytypes: %s", ssh->hostkeytypes);
+	REMMINA_DEBUG("ssh->proxycommand: %s", ssh->proxycommand);
+	REMMINA_DEBUG("ssh->stricthostkeycheck: %d", ssh->stricthostkeycheck);
+	REMMINA_DEBUG("ssh->compression: %s", ssh->compression);
+
+	/* Public/Private keys */
+	s = (privatekey ? g_strdup(privatekey) : remmina_ssh_find_identity());
+	if (s) {
+		ssh->privkeyfile = remmina_ssh_identity_path(s);
+		REMMINA_DEBUG("ssh->privkeyfile: %s", ssh->privkeyfile);
+		g_free(s);
+	} else {
+		ssh->privkeyfile = NULL;
+	}
+
+	return TRUE;
+}
+
+static gboolean
+remmina_ssh_init_from_ssh(RemminaSSH *ssh, const RemminaSSH *ssh_src)
+{
+	TRACE_CALL(__func__);
+	ssh->session = NULL;
+	ssh->authenticated = FALSE;
+	ssh->error = NULL;
+	pthread_mutex_init(&ssh->ssh_mutex, NULL);
+
+	ssh->is_tunnel = ssh_src->is_tunnel;
+	ssh->server = g_strdup(ssh_src->server);
+	ssh->port = ssh_src->port;
+	ssh->user = g_strdup(ssh_src->user ? ssh_src->user : NULL);
+	ssh->auth = ssh_src->auth;
+	ssh->password = g_strdup(ssh_src->password);
+	ssh->passphrase = g_strdup(ssh_src->passphrase);
+	ssh->privkeyfile = g_strdup(ssh_src->privkeyfile);
+	ssh->certfile = g_strdup(ssh_src->certfile);
+	ssh->charset = g_strdup(ssh_src->charset);
+	ssh->proxycommand = g_strdup(ssh_src->proxycommand);
+	ssh->kex_algorithms = g_strdup(ssh_src->kex_algorithms);
+	ssh->ciphers = g_strdup(ssh_src->ciphers);
+	ssh->hostkeytypes = g_strdup(ssh_src->hostkeytypes);
+	ssh->stricthostkeycheck = ssh_src->stricthostkeycheck;
+	ssh->compression = ssh_src->compression;
+	ssh->tunnel_entrance_host = g_strdup(ssh_src->tunnel_entrance_host);
+	ssh->tunnel_entrance_port = ssh_src->tunnel_entrance_port;
+
+	return TRUE;
+}
+
+gchar *
+remmina_ssh_convert(RemminaSSH *ssh, const gchar *from)
+{
+	TRACE_CALL(__func__);
+	gchar *to = NULL;
+
+	if (ssh->charset && from)
+		to = g_convert(from, -1, "UTF-8", ssh->charset, NULL, NULL, NULL);
+	if (!to) to = g_strdup(from);
+	return to;
+}
+
+gchar *
+remmina_ssh_unconvert(RemminaSSH *ssh, const gchar *from)
+{
+	TRACE_CALL(__func__);
+	gchar *to = NULL;
+
+	if (ssh->charset && from)
+		to = g_convert(from, -1, ssh->charset, "UTF-8", NULL, NULL, NULL);
+	if (!to) to = g_strdup(from);
+	return to;
+}
+
+void
+remmina_ssh_free(RemminaSSH *ssh)
+{
+	TRACE_CALL(__func__);
+	if (ssh->session) {
+		REMMINA_DEBUG("Disconnecting SSH session");
+		ssh_disconnect(ssh->session);
+		ssh_free(ssh->session);
+		ssh->session = NULL;
+	}
+	g_free(ssh->callback);
+	g_free(ssh->server);
+	g_free(ssh->user);
+	g_free(ssh->password);
+	g_free(ssh->privkeyfile);
+	g_free(ssh->certfile);
+	g_free(ssh->charset);
+	g_free(ssh->error);
+	pthread_mutex_destroy(&ssh->ssh_mutex);
+	g_free(ssh);
+}
+
+/*-----------------------------------------------------------------------------*
+*                           SSH Tunnel                                        *
+*-----------------------------------------------------------------------------*/
+struct _RemminaSSHTunnelBuffer {
+	gchar * data;
+	gchar * ptr;
+	ssize_t len;
+};
+
+static RemminaSSHTunnelBuffer *
+remmina_ssh_tunnel_buffer_new(ssize_t len)
+{
+	TRACE_CALL(__func__);
+	RemminaSSHTunnelBuffer *buffer;
+
+	buffer = g_new(RemminaSSHTunnelBuffer, 1);
+	buffer->data = (gchar *)g_malloc(len);
+	buffer->ptr = buffer->data;
+	buffer->len = len;
+	return buffer;
+}
+
+static void
+remmina_ssh_tunnel_buffer_free(RemminaSSHTunnelBuffer *buffer)
+{
+	TRACE_CALL(__func__);
+	if (buffer) {
+		g_free(buffer->data);
+		g_free(buffer);
+	}
+}
+
+RemminaSSHTunnel *
+remmina_ssh_tunnel_new_from_file(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	RemminaSSHTunnel *tunnel;
+
+	tunnel = g_new(RemminaSSHTunnel, 1);
+
+	remmina_ssh_init_from_file(REMMINA_SSH(tunnel), remminafile, TRUE);
+
+	tunnel->tunnel_type = -1;
+	tunnel->channels = NULL;
+	tunnel->sockets = NULL;
+	tunnel->socketbuffers = NULL;
+	tunnel->num_channels = 0;
+	tunnel->max_channels = 0;
+	tunnel->thread = 0;
+	tunnel->running = FALSE;
+	tunnel->server_sock = -1;
+	tunnel->dest = NULL;
+	tunnel->port = 0;
+	tunnel->buffer = NULL;
+	tunnel->buffer_len = 0;
+	tunnel->channels_out = NULL;
+	tunnel->remotedisplay = 0;
+	tunnel->localdisplay = NULL;
+	tunnel->init_func = NULL;
+	tunnel->connect_func = NULL;
+	tunnel->disconnect_func = NULL;
+	tunnel->callback_data = NULL;
+
+	return tunnel;
+}
+
+static void
+remmina_ssh_tunnel_close_all_channels(RemminaSSHTunnel *tunnel)
+{
+	TRACE_CALL(__func__);
+	int i;
+
+	for (i = 0; i < tunnel->num_channels; i++) {
+		close(tunnel->sockets[i]);
+		remmina_ssh_tunnel_buffer_free(tunnel->socketbuffers[i]);
+		ssh_channel_close(tunnel->channels[i]);
+		ssh_channel_send_eof(tunnel->channels[i]);
+		ssh_channel_free(tunnel->channels[i]);
+	}
+
+	g_free(tunnel->channels);
+	tunnel->channels = NULL;
+	g_free(tunnel->sockets);
+	tunnel->sockets = NULL;
+	g_free(tunnel->socketbuffers);
+	tunnel->socketbuffers = NULL;
+
+	tunnel->num_channels = 0;
+	tunnel->max_channels = 0;
+}
+
+static void
+remmina_ssh_tunnel_remove_channel(RemminaSSHTunnel *tunnel, gint n)
+{
+	TRACE_CALL(__func__);
+	ssh_channel_close(tunnel->channels[n]);
+	ssh_channel_send_eof(tunnel->channels[n]);
+	ssh_channel_free(tunnel->channels[n]);
+	close(tunnel->sockets[n]);
+	remmina_ssh_tunnel_buffer_free(tunnel->socketbuffers[n]);
+	tunnel->num_channels--;
+	tunnel->channels[n] = tunnel->channels[tunnel->num_channels];
+	tunnel->channels[tunnel->num_channels] = NULL;
+	tunnel->sockets[n] = tunnel->sockets[tunnel->num_channels];
+	tunnel->socketbuffers[n] = tunnel->socketbuffers[tunnel->num_channels];
+}
+
+/* Register the new channel/socket pair */
+static void
+remmina_ssh_tunnel_add_channel(RemminaSSHTunnel *tunnel, ssh_channel channel, gint sock)
+{
+	TRACE_CALL(__func__);
+	gint flags;
+	gint i;
+
+	i = tunnel->num_channels++;
+	if (tunnel->num_channels > tunnel->max_channels) {
+		/* Allocate an extra NULL pointer in channels for ssh_select */
+		tunnel->channels = (ssh_channel *)g_realloc(tunnel->channels,
+							    sizeof(ssh_channel) * (tunnel->num_channels + 1));
+		tunnel->sockets = (gint *)g_realloc(tunnel->sockets,
+						    sizeof(gint) * tunnel->num_channels);
+		tunnel->socketbuffers = (RemminaSSHTunnelBuffer **)g_realloc(tunnel->socketbuffers,
+									     sizeof(RemminaSSHTunnelBuffer *) * tunnel->num_channels);
+		tunnel->max_channels = tunnel->num_channels;
+
+		tunnel->channels_out = (ssh_channel *)g_realloc(tunnel->channels_out,
+								sizeof(ssh_channel) * (tunnel->num_channels + 1));
+	}
+	tunnel->channels[i] = channel;
+	tunnel->channels[i + 1] = NULL;
+	tunnel->sockets[i] = sock;
+	tunnel->socketbuffers[i] = NULL;
+
+	flags = fcntl(sock, F_GETFL, 0);
+	fcntl(sock, F_SETFL, flags | O_NONBLOCK);
+}
+
+static int
+remmina_ssh_tunnel_accept_local_connection(RemminaSSHTunnel *tunnel, gboolean blocking)
+{
+	gint sock, sock_flags;
+
+	sock_flags = fcntl(tunnel->server_sock, F_GETFL, 0);
+	if (blocking)
+		sock_flags &= ~O_NONBLOCK;
+	else
+		sock_flags |= O_NONBLOCK;
+	fcntl(tunnel->server_sock, F_SETFL, sock_flags);
+
+	/* Accept a local connection */
+	sock = accept(tunnel->server_sock, NULL, NULL);
+	if (sock < 0) {
+		if (blocking) {
+			g_free(REMMINA_SSH(tunnel)->error);
+			REMMINA_SSH(tunnel)->error = g_strdup("Local socket not accepted");
+		}
+	}
+
+	return sock;
+}
+
+static ssh_channel
+remmina_ssh_tunnel_create_forward_channel(RemminaSSHTunnel *tunnel)
+{
+	ssh_channel channel = NULL;
+
+	channel = ssh_channel_new(tunnel->ssh.session);
+	if (!channel) {
+		// TRANSLATORS: The placeholder %s is an error message
+		remmina_ssh_set_error(REMMINA_SSH(tunnel), _("Could not create channel. %s"));
+		return NULL;
+	}
+
+	/* Request the SSH server to connect to the destination */
+	REMMINA_DEBUG("SSH tunnel destination is %s", tunnel->dest);
+	if (ssh_channel_open_forward(channel, tunnel->dest, tunnel->port, "127.0.0.1", 0) != SSH_OK) {
+		ssh_channel_close(channel);
+		ssh_channel_send_eof(channel);
+		ssh_channel_free(channel);
+		// TRANSLATORS: The placeholder %s is an error message
+		remmina_ssh_set_error(REMMINA_SSH(tunnel), _("Could not connect to SSH tunnel. %s"));
+		return NULL;
+	}
+
+	return channel;
+}
+
+static gpointer
+remmina_ssh_tunnel_main_thread_proc(gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaSSHTunnel *tunnel = (RemminaSSHTunnel *)data;
+	gchar *ptr;
+	ssize_t len = 0, lenw = 0;
+	fd_set set;
+	struct timeval timeout;
+	g_autoptr(GDateTime) t1 = NULL;
+	g_autoptr(GDateTime) t2 = NULL;
+	GTimeSpan diff;                                                 // microseconds
+	ssh_channel channel = NULL;
+	gboolean first = TRUE;
+	gboolean disconnected;
+	gint sock;
+	gint maxfd;
+	gint i;
+	gint ret;
+	struct sockaddr_in sin;
+
+	t1 = g_date_time_new_now_local();
+	t2 = g_date_time_new_now_local();
+
+	switch (tunnel->tunnel_type) {
+	case REMMINA_SSH_TUNNEL_OPEN:
+		sock = remmina_ssh_tunnel_accept_local_connection(tunnel, TRUE);
+		if (sock < 0) {
+			if (tunnel)
+				tunnel->thread = 0;
+			return NULL;
+		}
+
+		channel = remmina_ssh_tunnel_create_forward_channel(tunnel);
+		if (!tunnel) {
+			close(sock);
+			tunnel->thread = 0;
+			return NULL;
+		}
+
+		remmina_ssh_tunnel_add_channel(tunnel, channel, sock);
+		break;
+
+	case REMMINA_SSH_TUNNEL_XPORT:
+		/* Detect the next available port starting from 6010 on the server */
+		for (i = 10; i <= MAX_X_DISPLAY_NUMBER; i++) {
+#if LIBSSH_VERSION_INT >= SSH_VERSION_INT(0, 7, 0)
+			if (ssh_channel_listen_forward(REMMINA_SSH(tunnel)->session, (tunnel->bindlocalhost ? "localhost" : NULL), 6000 + i, NULL)) {
+				continue;
+			} else {
+				tunnel->remotedisplay = i;
+				break;
+			}
+#else
+			if (ssh_forward_listen(REMMINA_SSH(tunnel)->session, (tunnel->bindlocalhost ? "localhost" : NULL), 6000 + i, NULL)) {
+				continue;
+			} else {
+				tunnel->remotedisplay = i;
+				break;
+			}
+#endif
+		}
+		if (tunnel->remotedisplay < 1) {
+			// TRANSLATORS: The placeholder %s is an error message
+			remmina_ssh_set_error(REMMINA_SSH(tunnel), _("Could not request port forwarding. %s"));
+			if (tunnel->disconnect_func)
+				(*tunnel->disconnect_func)(tunnel, tunnel->callback_data);
+			tunnel->thread = 0;
+			return NULL;
+		}
+
+		if (tunnel->init_func &&
+		    !(*tunnel->init_func)(tunnel, tunnel->callback_data)) {
+			if (tunnel->disconnect_func)
+				(*tunnel->disconnect_func)(tunnel, tunnel->callback_data);
+			tunnel->thread = 0;
+			return NULL;
+		}
+
+		break;
+
+	case REMMINA_SSH_TUNNEL_REVERSE:
+#if LIBSSH_VERSION_INT >= SSH_VERSION_INT(0, 7, 0)
+		if (ssh_channel_listen_forward(REMMINA_SSH(tunnel)->session, NULL, tunnel->port, NULL)) {
+			// TRANSLATORS: The placeholder %s is an error message
+			remmina_ssh_set_error(REMMINA_SSH(tunnel), _("Could not request port forwarding. %s"));
+			if (tunnel->disconnect_func)
+				(*tunnel->disconnect_func)(tunnel, tunnel->callback_data);
+			tunnel->thread = 0;
+			return NULL;
+		}
+#else
+		if (ssh_forward_listen(REMMINA_SSH(tunnel)->session, NULL, tunnel->port, NULL)) {
+			// TRANSLATORS: The placeholder %s is an error message
+			remmina_ssh_set_error(REMMINA_SSH(tunnel), _("Could not request port forwarding. %s"));
+			if (tunnel->disconnect_func)
+				(*tunnel->disconnect_func)(tunnel, tunnel->callback_data);
+			tunnel->thread = 0;
+			return NULL;
+		}
+#endif
+
+		if (tunnel->init_func &&
+		    !(*tunnel->init_func)(tunnel, tunnel->callback_data)) {
+			if (tunnel->disconnect_func)
+				(*tunnel->disconnect_func)(tunnel, tunnel->callback_data);
+			tunnel->thread = 0;
+			return NULL;
+		}
+
+		break;
+	}
+
+	tunnel->buffer_len = 10240;
+	tunnel->buffer = g_malloc(tunnel->buffer_len);
+
+	/* Start the tunnel data transmission */
+	while (tunnel->running) {
+		if (tunnel->tunnel_type == REMMINA_SSH_TUNNEL_XPORT ||
+		    tunnel->tunnel_type == REMMINA_SSH_TUNNEL_REVERSE) {
+			if (first) {
+				first = FALSE;
+				channel = ssh_channel_accept_forward(REMMINA_SSH(tunnel)->session, 15000, &tunnel->port);
+				if (!channel) {
+					remmina_ssh_set_application_error(REMMINA_SSH(tunnel), _("The server did not respond."));
+					if (tunnel->disconnect_func)
+						(*tunnel->disconnect_func)(tunnel, tunnel->callback_data);
+					tunnel->thread = 0;
+					return NULL;
+				}
+				if (tunnel->connect_func)
+					(*tunnel->connect_func)(tunnel, tunnel->callback_data);
+				if (tunnel->tunnel_type == REMMINA_SSH_TUNNEL_REVERSE) {
+					/* For reverse tunnel, we only need one connection. */
+#if LIBSSH_VERSION_INT >= SSH_VERSION_INT(0, 7, 0)
+					ssh_channel_cancel_forward(REMMINA_SSH(tunnel)->session, NULL, tunnel->port);
+#else
+					ssh_forward_cancel(REMMINA_SSH(tunnel)->session, NULL, tunnel->port);
+#endif
+				}
+			} else if (tunnel->tunnel_type != REMMINA_SSH_TUNNEL_REVERSE) {
+				/* Poll once per some period of time if no incoming connections.
+				 * Don’t try to poll continuously as it will significantly slow down the loop */
+				t1 = g_date_time_new_now_local();
+				diff = g_date_time_difference(t1, t2) * 10000000
+				       + g_date_time_difference(t1, t2) / 100000;
+				if (diff > 1) {
+					REMMINA_DEBUG("Polling tunnel channels");
+						channel = ssh_channel_accept_forward(REMMINA_SSH(tunnel)->session, 0, &tunnel->port);
+					if (channel == NULL)
+						t2 = g_date_time_new_now_local();
+				}
+			}
+
+			if (channel) {
+				if (tunnel->tunnel_type == REMMINA_SSH_TUNNEL_REVERSE) {
+					sin.sin_family = AF_INET;
+					sin.sin_port = htons(tunnel->localport);
+					sin.sin_addr.s_addr = inet_addr("127.0.0.1");
+					sock = socket(AF_INET, SOCK_STREAM, 0);
+					if (connect(sock, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
+						remmina_ssh_set_application_error(REMMINA_SSH(tunnel),
+										  _("Cannot connect to local port %i."), tunnel->localport);
+						close(sock);
+						sock = -1;
+					}
+				} else
+					sock = remmina_public_open_xdisplay(tunnel->localdisplay);
+				if (sock >= 0)
+					remmina_ssh_tunnel_add_channel(tunnel, channel, sock);
+				else {
+					/* Failed to create unix socket. Will this happen? */
+					ssh_channel_close(channel);
+					ssh_channel_send_eof(channel);
+					ssh_channel_free(channel);
+				}
+				channel = NULL;
+			}
+		}
+
+		if (tunnel->num_channels <= 0)
+			/* No more connections. We should quit */
+			break;
+
+		timeout.tv_sec = 0;
+		timeout.tv_usec = 200000;
+
+		FD_ZERO(&set);
+		maxfd = 0;
+		for (i = 0; i < tunnel->num_channels; i++) {
+			if (tunnel->sockets[i] > maxfd)
+				maxfd = tunnel->sockets[i];
+			FD_SET(tunnel->sockets[i], &set);
+		}
+
+		ret = ssh_select(tunnel->channels, tunnel->channels_out, maxfd + 1, &set, &timeout);
+		if (!tunnel->running) break;
+		if (ret == SSH_EINTR) continue;
+		if (ret == -1) break;
+
+		i = 0;
+		while (tunnel->running && i < tunnel->num_channels) {
+			disconnected = FALSE;
+			if (FD_ISSET(tunnel->sockets[i], &set)) {
+				while (!disconnected &&
+				       (len = read(tunnel->sockets[i], tunnel->buffer, tunnel->buffer_len)) > 0) {
+					for (ptr = tunnel->buffer, lenw = 0; len > 0; len -= lenw, ptr += lenw) {
+						lenw = ssh_channel_write(tunnel->channels[i], (char *)ptr, len);
+						if (lenw <= 0) {
+							disconnected = TRUE;
+							// TRANSLATORS: The placeholder %s is an error message
+							remmina_ssh_set_error(REMMINA_SSH(tunnel), _("Could not write to SSH channel. %s"));
+							break;
+						}
+					}
+				}
+				if (len == 0) {
+					// TRANSLATORS: The placeholder %s is an error message
+					remmina_ssh_set_error(REMMINA_SSH(tunnel), _("Could not read from tunnel listening socket. %s"));
+					disconnected = TRUE;
+				}
+			}
+			if (disconnected) {
+				REMMINA_DEBUG("tunnel disconnected because %s", REMMINA_SSH(tunnel)->error);
+				remmina_ssh_tunnel_remove_channel(tunnel, i);
+				continue;
+			}
+			i++;
+		}
+		if (!tunnel->running) break;
+
+		i = 0;
+		while (tunnel->running && i < tunnel->num_channels) {
+			disconnected = FALSE;
+			if (!tunnel->socketbuffers[i]) {
+				len = ssh_channel_poll(tunnel->channels[i], 0);
+				if (len == SSH_ERROR || len == SSH_EOF) {
+					// TRANSLATORS: The placeholder %s is an error message
+					remmina_ssh_set_error(REMMINA_SSH(tunnel), _("Could not poll SSH channel. %s"));
+					disconnected = TRUE;
+				} else if (len > 0) {
+					tunnel->socketbuffers[i] = remmina_ssh_tunnel_buffer_new(len);
+					len = ssh_channel_read_nonblocking(tunnel->channels[i], tunnel->socketbuffers[i]->data, len, 0);
+					if (len <= 0) {
+						// TRANSLATORS: The placeholder %s is an error message
+						remmina_ssh_set_error(REMMINA_SSH(tunnel), _("Could not read SSH channel in a non-blocking way. %s"));
+						disconnected = TRUE;
+					} else {
+						tunnel->socketbuffers[i]->len = len;
+					}
+				}
+			}
+
+			if (!disconnected && tunnel->socketbuffers[i]) {
+				for (lenw = 0; tunnel->socketbuffers[i]->len > 0;
+				     tunnel->socketbuffers[i]->len -= lenw, tunnel->socketbuffers[i]->ptr += lenw) {
+					lenw = write(tunnel->sockets[i], tunnel->socketbuffers[i]->ptr, tunnel->socketbuffers[i]->len);
+					if (lenw == -1 && errno == EAGAIN && tunnel->running)
+						/* Sometimes we cannot write to a socket (always EAGAIN), probably because it’s internal
+						 * buffer is full. We need read the pending bytes from the socket first. so here we simply
+						 * break, leave the buffer there, and continue with other data */
+						break;
+					if (lenw <= 0) {
+						// TRANSLATORS: The placeholder %s is an error message
+						remmina_ssh_set_error(REMMINA_SSH(tunnel), _("Could not send data to tunnel listening socket. %s"));
+						disconnected = TRUE;
+						break;
+					}
+				}
+				if (tunnel->socketbuffers[i]->len <= 0) {
+					remmina_ssh_tunnel_buffer_free(tunnel->socketbuffers[i]);
+					tunnel->socketbuffers[i] = NULL;
+				}
+			}
+
+			if (disconnected) {
+				REMMINA_DEBUG("Connection to SSH tunnel dropped. %s", REMMINA_SSH(tunnel)->error);
+				remmina_ssh_tunnel_remove_channel(tunnel, i);
+				continue;
+			}
+			i++;
+		}
+		/**
+		 * Some protocols may open new connections during the session.
+		 * e.g: SPICE opens a new connection for some channels.
+		 */
+		sock = remmina_ssh_tunnel_accept_local_connection(tunnel, FALSE);
+		if (sock > 0) {
+			channel = remmina_ssh_tunnel_create_forward_channel(tunnel);
+			if (!channel) {
+				REMMINA_DEBUG("Could not open new SSH connection. %s", REMMINA_SSH(tunnel)->error);
+				close(sock);
+				/* Leave thread loop */
+				tunnel->running = FALSE;
+			} else {
+				remmina_ssh_tunnel_add_channel(tunnel, channel, sock);
+			}
+		}
+	}
+
+	remmina_ssh_tunnel_close_all_channels(tunnel);
+
+	tunnel->running = FALSE;
+
+	/* Notify tunnel owner of disconnection */
+	if (tunnel->disconnect_func)
+		(*tunnel->disconnect_func)(tunnel, tunnel->callback_data);
+
+	return NULL;
+}
+
+static gboolean remmina_ssh_notify_tunnel_main_thread_end(gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaSSHTunnel *tunnel = (RemminaSSHTunnel *)data;
+
+	/* Ask tunnel owner to destroy tunnel object */
+	if (tunnel->destroy_func)
+		(*tunnel->destroy_func)(tunnel, tunnel->destroy_func_callback_data);
+
+	return FALSE;
+}
+
+static gpointer
+remmina_ssh_tunnel_main_thread(gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaSSHTunnel *tunnel = (RemminaSSHTunnel *)data;
+
+	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+
+	while (TRUE) {
+		remmina_ssh_tunnel_main_thread_proc(data);
+		if (tunnel->server_sock < 0 || tunnel->thread == 0 || !tunnel->running) break;
+	}
+	tunnel->thread = 0;
+
+	/* Do after tunnel thread cleanup */
+	IDLE_ADD((GSourceFunc)remmina_ssh_notify_tunnel_main_thread_end, (gpointer)tunnel);
+
+	return NULL;
+}
+
+
+void
+remmina_ssh_tunnel_cancel_accept(RemminaSSHTunnel *tunnel)
+{
+	TRACE_CALL(__func__);
+	if (tunnel->server_sock >= 0) {
+		close(tunnel->server_sock);
+		tunnel->server_sock = -1;
+	}
+}
+
+gboolean
+remmina_ssh_tunnel_open(RemminaSSHTunnel *tunnel, const gchar *host, gint port, gint local_port)
+{
+	TRACE_CALL(__func__);
+	gint sock;
+	gint sockopt = 1;
+	struct sockaddr_in sin;
+
+	tunnel->tunnel_type = REMMINA_SSH_TUNNEL_OPEN;
+	tunnel->dest = g_strdup(host);
+	tunnel->port = port;
+	if (tunnel->port == 0) {
+		REMMINA_SSH(tunnel)->error = g_strdup(_("Assign a destination port."));
+		return FALSE;
+	}
+
+	/* Create the server socket that listens on the local port */
+	sock = socket(AF_INET, SOCK_STREAM, 0);
+	if (sock < 0) {
+		REMMINA_SSH(tunnel)->error = g_strdup(_("Could not create socket."));
+		return FALSE;
+	}
+	setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &sockopt, sizeof(sockopt));
+
+	sin.sin_family = AF_INET;
+	sin.sin_port = htons(local_port);
+	sin.sin_addr.s_addr = inet_addr("127.0.0.1");
+
+	if (bind(sock, (struct sockaddr *)&sin, sizeof(sin))) {
+		REMMINA_SSH(tunnel)->error = g_strdup(_("Could not bind server socket to local port."));
+		close(sock);
+		return FALSE;
+	}
+
+	if (listen(sock, 1)) {
+		REMMINA_SSH(tunnel)->error = g_strdup(_("Could not listen to local port."));
+		close(sock);
+		return FALSE;
+	}
+
+	tunnel->server_sock = sock;
+	tunnel->running = TRUE;
+
+	if (pthread_create(&tunnel->thread, NULL, remmina_ssh_tunnel_main_thread, tunnel)) {
+		// TRANSLATORS: Do not translate pthread
+		remmina_ssh_set_application_error(REMMINA_SSH(tunnel), _("Could not start pthread."));
+		tunnel->thread = 0;
+		return FALSE;
+	}
+	return TRUE;
+}
+
+gboolean
+remmina_ssh_tunnel_xport(RemminaSSHTunnel *tunnel, gboolean bindlocalhost)
+{
+	TRACE_CALL(__func__);
+	tunnel->tunnel_type = REMMINA_SSH_TUNNEL_XPORT;
+	tunnel->bindlocalhost = bindlocalhost;
+	tunnel->running = TRUE;
+
+	if (pthread_create(&tunnel->thread, NULL, remmina_ssh_tunnel_main_thread, tunnel)) {
+		// TRANSLATORS: Do not translate pthread
+		remmina_ssh_set_application_error(REMMINA_SSH(tunnel), _("Could not start pthread."));
+		tunnel->thread = 0;
+		return FALSE;
+	}
+	return TRUE;
+}
+
+gboolean
+remmina_ssh_tunnel_reverse(RemminaSSHTunnel *tunnel, gint port, gint local_port)
+{
+	TRACE_CALL(__func__);
+	tunnel->tunnel_type = REMMINA_SSH_TUNNEL_REVERSE;
+	tunnel->port = port;
+	tunnel->localport = local_port;
+	tunnel->running = TRUE;
+
+	if (pthread_create(&tunnel->thread, NULL, remmina_ssh_tunnel_main_thread, tunnel)) {
+		// TRANSLATORS: Do not translate pthread
+		remmina_ssh_set_application_error(REMMINA_SSH(tunnel), _("Could not start pthread."));
+		tunnel->thread = 0;
+		return FALSE;
+	}
+	return TRUE;
+}
+
+gboolean
+remmina_ssh_tunnel_terminated(RemminaSSHTunnel *tunnel)
+{
+	TRACE_CALL(__func__);
+	return tunnel->thread == 0;
+}
+
+void
+remmina_ssh_tunnel_free(RemminaSSHTunnel *tunnel)
+{
+	TRACE_CALL(__func__);
+	pthread_t thread;
+
+	REMMINA_DEBUG("tunnel->thread = %lX\n", tunnel->thread);
+
+	thread = tunnel->thread;
+	if (thread != 0) {
+		tunnel->running = FALSE;
+		pthread_cancel(thread);
+		pthread_join(thread, NULL);
+		tunnel->thread = 0;
+	}
+
+	if (tunnel->tunnel_type == REMMINA_SSH_TUNNEL_XPORT && tunnel->remotedisplay > 0) {
+#if LIBSSH_VERSION_INT >= SSH_VERSION_INT(0, 7, 0)
+		ssh_channel_cancel_forward(REMMINA_SSH(tunnel)->session, NULL, 6000 + tunnel->remotedisplay);
+#else
+		ssh_forward_cancel(REMMINA_SSH(tunnel)->session, NULL, 6000 + tunnel->remotedisplay);
+#endif
+	}
+	if (tunnel->server_sock >= 0) {
+		close(tunnel->server_sock);
+		tunnel->server_sock = -1;
+	}
+
+	remmina_ssh_tunnel_close_all_channels(tunnel);
+
+	g_free(tunnel->buffer);
+	g_free(tunnel->channels_out);
+	g_free(tunnel->dest);
+	g_free(tunnel->localdisplay);
+
+	remmina_ssh_free((RemminaSSH *)tunnel);
+}
+
+/*-----------------------------------------------------------------------------*
+*                           SSH SFTP                                          *
+*-----------------------------------------------------------------------------*/
+RemminaSFTP *
+remmina_sftp_new_from_file(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	RemminaSFTP *sftp;
+
+	sftp = g_new(RemminaSFTP, 1);
+
+	remmina_ssh_init_from_file(REMMINA_SSH(sftp), remminafile, FALSE);
+
+	sftp->sftp_sess = NULL;
+
+	return sftp;
+}
+
+RemminaSFTP *
+remmina_sftp_new_from_ssh(RemminaSSH *ssh)
+{
+	TRACE_CALL(__func__);
+	RemminaSFTP *sftp;
+
+	sftp = g_new(RemminaSFTP, 1);
+
+	remmina_ssh_init_from_ssh(REMMINA_SSH(sftp), ssh);
+
+	sftp->sftp_sess = NULL;
+
+	return sftp;
+}
+
+gboolean
+remmina_sftp_open(RemminaSFTP *sftp)
+{
+	TRACE_CALL(__func__);
+	sftp->sftp_sess = sftp_new(sftp->ssh.session);
+	if (!sftp->sftp_sess) {
+		// TRANSLATORS: The placeholder %s is an error message
+		remmina_ssh_set_error(REMMINA_SSH(sftp), _("Could not create SFTP session. %s"));
+		return FALSE;
+	}
+	if (sftp_init(sftp->sftp_sess)) {
+		// TRANSLATORS: The placeholder %s is an error message
+		remmina_ssh_set_error(REMMINA_SSH(sftp), _("Could not start SFTP session. %s"));
+		return FALSE;
+	}
+	return TRUE;
+}
+
+void
+remmina_sftp_free(RemminaSFTP *sftp)
+{
+	TRACE_CALL(__func__);
+	if (sftp->sftp_sess) {
+		sftp_free(sftp->sftp_sess);
+		sftp->sftp_sess = NULL;
+	}
+	remmina_ssh_free(REMMINA_SSH(sftp));
+}
+
+/*-----------------------------------------------------------------------------*
+*                           SSH Shell                                         *
+*-----------------------------------------------------------------------------*/
+RemminaSSHShell *
+remmina_ssh_shell_new_from_file(RemminaFile *remminafile)
+{
+	TRACE_CALL(__func__);
+	RemminaSSHShell *shell;
+
+	shell = g_new0(RemminaSSHShell, 1);
+
+	remmina_ssh_init_from_file(REMMINA_SSH(shell), remminafile, FALSE);
+
+	shell->master = -1;
+	shell->slave = -1;
+	shell->exec = g_strdup(remmina_file_get_string(remminafile, "exec"));
+	shell->run_line = g_strdup(remmina_file_get_string(remminafile, "run_line"));
+
+	return shell;
+}
+
+RemminaSSHShell *
+remmina_ssh_shell_new_from_ssh(RemminaSSH *ssh)
+{
+	TRACE_CALL(__func__);
+	RemminaSSHShell *shell;
+
+	shell = g_new0(RemminaSSHShell, 1);
+
+	remmina_ssh_init_from_ssh(REMMINA_SSH(shell), ssh);
+
+	shell->master = -1;
+	shell->slave = -1;
+
+	return shell;
+}
+
+static gboolean
+remmina_ssh_call_exit_callback_on_main_thread(gpointer data)
+{
+	TRACE_CALL(__func__);
+
+	RemminaSSHShell *shell = (RemminaSSHShell *)data;
+	if (shell->exit_callback)
+		shell->exit_callback(shell->user_data);
+	if (shell) {
+		remmina_ssh_shell_free(shell);
+		shell = NULL;
+	}
+	return FALSE;
+}
+
+static gpointer
+remmina_ssh_shell_thread(gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaSSHShell *shell = (RemminaSSHShell *)data;
+	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)shell->user_data;
+	RemminaFile *remminafile;
+	remminafile = remmina_protocol_widget_get_file(gp);
+	ssh_channel channel = NULL;
+	gint ret;
+	gchar *filename;
+	const gchar *dir;
+	const gchar *sshlogname;
+	FILE *fp = NULL;
+
+	//gint screen;
+
+	LOCK_SSH(shell)
+
+	if ((channel = ssh_channel_new(REMMINA_SSH(shell)->session)) == NULL ||
+	    ssh_channel_open_session(channel)) {
+		UNLOCK_SSH(shell)
+		// TRANSLATORS: The placeholder %s is an error message
+		remmina_ssh_set_error(REMMINA_SSH(shell), _("Could not open channel. %s"));
+		if (channel) ssh_channel_free(channel);
+		shell->thread = 0;
+		return NULL;
+	}
+
+	ssh_channel_request_pty(channel);
+
+	// SSH Callbacks
+	struct ssh_callbacks_struct cb =
+	{
+		.channel_open_request_x11_function = remmina_ssh_x11_open_request_cb,
+		.userdata = shell,
+	};
+
+	if (remmina_file_get_int(remminafile, "ssh_forward_x11", FALSE)) {
+		ssh_callbacks_init(&cb);
+		ssh_set_callbacks(REMMINA_SSH(shell)->session, &cb);
+
+		const char *display = getenv("DISPLAY");
+		char *proto = NULL, *cookie = NULL;
+		if (remmina_ssh_x11_get_proto(display, &proto, &cookie) != 0) {
+			REMMINA_DEBUG("Using fake authentication data for X11 forwarding");
+			proto = NULL;
+			cookie = NULL;
+		}
+
+		REMMINA_DEBUG("proto: %s - cookie: %s", proto, cookie);
+		ret = ssh_channel_request_x11(channel, 0, proto, cookie, 0);
+		if (ret != SSH_OK) return NULL;
+	}
+
+	if (shell->exec && shell->exec[0]) {
+		REMMINA_DEBUG ("Requesting an SSH exec channel");
+		ret = ssh_channel_request_exec(channel, shell->exec);
+	} else {
+		REMMINA_DEBUG ("Requesting an SSH shell channel");
+		ret = ssh_channel_request_shell(channel);
+	}
+	if (ret != SSH_OK) {
+		UNLOCK_SSH(shell)
+		REMMINA_WARNING ("Could not request shell");
+		// TRANSLATORS: The placeholder %s is an error message
+		remmina_ssh_set_error(REMMINA_SSH(shell), _("Could not request shell. %s"));
+		ssh_channel_close(channel);
+		ssh_channel_send_eof(channel);
+		ssh_channel_free(channel);
+		shell->thread = 0;
+		return NULL;
+	}
+
+	shell->channel = channel;
+
+	UNLOCK_SSH(shell)
+
+	GFile *rf = g_file_new_for_path(remminafile->filename);
+
+	if (remmina_file_get_string(remminafile, "sshlogfolder") == NULL)
+		dir = g_build_path("/", g_get_user_cache_dir(), "remmina", NULL);
+	else
+		dir = remmina_file_get_string(remminafile, "sshlogfolder");
+
+	if (remmina_file_get_string(remminafile, "sshlogname") == NULL)
+		sshlogname = g_strconcat(g_file_get_basename(rf), ".", "log", NULL);
+	else
+		sshlogname = remmina_file_get_string(remminafile, "sshlogname");
+	sshlogname = remmina_file_format_properties(remminafile, sshlogname);
+	filename = g_strconcat(dir, "/", sshlogname, NULL);
+
+	if (remmina_file_get_int (remminafile, "sshsavesession", FALSE)) {
+		REMMINA_DEBUG("Saving session log to %s", filename);
+		fp = fopen(filename, "w");
+	}
+
+	g_free(filename);
+
+	REMMINA_DEBUG("Run_line: %s", shell->run_line);
+	if (!shell->closed && shell->run_line && shell->run_line[0]) {
+		LOCK_SSH(shell)
+		//TODO: Confirm assumption - assuming null terminated gchar string
+		ssh_channel_write(channel, shell->run_line, (gint)strlen(shell->run_line));
+		ssh_channel_write(channel, "\n", (gint)1); //TODO: Test this
+		UNLOCK_SSH(shell)
+		REMMINA_DEBUG("Run_line written to channel");
+	}
+
+	LOCK_SSH(shell)
+
+	// Create new event context.
+	shell->event = ssh_event_new();
+	if (shell->event == NULL) {
+		REMMINA_WARNING("Internal error in %s: Couldn't get a event.", __func__);
+		return NULL;
+	}
+
+	REMMINA_DEBUG("shell->slave: %d", shell->slave);
+
+	// Add the fd to the event and assign it the callback.
+	if (ssh_event_add_fd(shell->event, shell->slave, events, remmina_ssh_cp_to_ch_cb, channel) != SSH_OK) {
+		REMMINA_WARNING("Internal error in %s: Couldn't add an fd to the event.", __func__);
+		return NULL;
+	}
+
+	// Remove the poll handle from session and assign them to the event.
+	if (ssh_event_add_session(shell->event, REMMINA_SSH(shell)->session) != SSH_OK) {
+		REMMINA_WARNING("Internal error in %s: Couldn't add the session to the event.", __func__);
+		return NULL;
+	}
+
+	remmina_ssh_insert_item(shell->channel, shell->slave, shell->slave, TRUE, shell->thread);
+
+	// Initializes the ssh_callbacks_struct.
+	channel_cb.userdata = &shell;
+	ssh_callbacks_init(&channel_cb);
+	// Set the channel callback functions.
+	ssh_set_channel_callbacks(shell->channel, &channel_cb);
+	UNLOCK_SSH(shell)
+
+	do {
+		ssh_event_dopoll(shell->event, 1000);
+	} while(!ssh_channel_is_closed(shell->channel));
+
+	// Close all OPENED X11 channel
+	remmina_ssh_close_all_x11_ch(shell->thread);
+
+	shell->closed = TRUE;
+
+	LOCK_SSH(shell)
+
+	// Remove socket fd from event context.
+	ret = ssh_event_remove_fd(shell->event, shell->slave);
+	REMMINA_DEBUG("Remove socket fd from event context: %d", ret);
+
+	// Remove session object from event context.
+	ret = ssh_event_remove_session(shell->event, REMMINA_SSH(shell)->session);
+	REMMINA_DEBUG("Remove session object from event context: %d", ret);
+
+	// Free event context.
+	ssh_event_free(shell->event);
+	REMMINA_DEBUG("Free event context");
+
+	// Remove channel callback.
+	ret = ssh_remove_channel_callbacks(shell->channel, &channel_cb);
+	REMMINA_DEBUG("Remove channel callback: %d", ret);
+
+	if (remmina_file_get_int (remminafile, "sshsavesession", FALSE))
+		fclose(fp);
+	shell->channel = NULL;
+	ssh_channel_close(channel);
+	ssh_channel_send_eof(channel);
+	ssh_channel_free(channel);
+	UNLOCK_SSH(shell)
+
+	shell->thread = 0;
+
+	if (shell->exit_callback)
+		IDLE_ADD((GSourceFunc)remmina_ssh_call_exit_callback_on_main_thread, (gpointer)shell);
+	return NULL;
+}
+
+gboolean
+remmina_ssh_shell_open(RemminaSSHShell *shell, RemminaSSHExitFunc exit_callback, gpointer data)
+{
+	TRACE_CALL(__func__);
+	gchar *slavedevice;
+	struct termios stermios;
+
+	shell->master = posix_openpt(O_RDWR | O_NOCTTY);
+	if (shell->master == -1 ||
+	    grantpt(shell->master) == -1 ||
+	    unlockpt(shell->master) == -1 ||
+	    (slavedevice = ptsname(shell->master)) == NULL ||
+	    (shell->slave = open(slavedevice, O_RDWR | O_NOCTTY)) < 0) {
+		REMMINA_SSH(shell)->error = g_strdup(_("Could not create PTY device."));
+		return FALSE;
+	}
+
+	/* As per libssh documentation */
+	tcgetattr(shell->slave, &stermios);
+	stermios.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
+	stermios.c_oflag &= ~OPOST;
+	stermios.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
+	stermios.c_cflag &= ~(CSIZE | PARENB);
+	stermios.c_cflag |= CS8;
+	tcsetattr(shell->slave, TCSANOW, &stermios);
+
+	shell->exit_callback = exit_callback;
+	shell->user_data = data;
+
+	/* Once the process started, we should always TRUE and assume the pthread will be created always */
+	pthread_create(&shell->thread, NULL, remmina_ssh_shell_thread, shell);
+
+	return TRUE;
+}
+
+void
+remmina_ssh_shell_set_size(RemminaSSHShell *shell, gint columns, gint rows)
+{
+	TRACE_CALL(__func__);
+	LOCK_SSH(shell)
+	if (shell->channel)
+		ssh_channel_change_pty_size(shell->channel, columns, rows);
+	UNLOCK_SSH(shell)
+}
+
+void
+remmina_ssh_shell_free(RemminaSSHShell *shell)
+{
+	TRACE_CALL(__func__);
+	//pthread_t thread = shell->thread;
+
+	// Close all OPENED X11 channel
+	remmina_ssh_close_all_x11_ch(shell->thread);
+
+	shell->exit_callback = NULL;
+	shell->closed = TRUE;
+	REMMINA_DEBUG("Cancelling the shell thread if needed");
+	if (shell->thread) {
+		pthread_cancel(shell->thread);
+		if (shell->thread) pthread_join(shell->thread, NULL);
+	}
+	close(shell->slave);
+	if (shell->exec) {
+		g_free(shell->exec);
+		shell->exec = NULL;
+	}
+	if (shell->run_line) {
+		g_free(shell->run_line);
+		shell->run_line = NULL;
+	}
+	/* It’s not necessary to close shell->slave since the other end (vte) will close it */;
+	remmina_ssh_free(REMMINA_SSH(shell));
+}
+
+#endif /* HAVE_LIBSSH */
diff --git a/src/remmina_ssh.h b/src/remmina_ssh.h
new file mode 100644
index 0000000..baad192
--- /dev/null
+++ b/src/remmina_ssh.h
@@ -0,0 +1,284 @@
+/*
+ * 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.
+ *
+ */
+
+#pragma once
+
+#include "config.h"
+
+#ifdef HAVE_LIBSSH
+
+#define LIBSSH_STATIC 1
+#include <libssh/libssh.h>
+#include <libssh/callbacks.h>
+#include <libssh/sftp.h>
+#include <pthread.h>
+#include "remmina_file.h"
+#include "rcw.h"
+
+G_BEGIN_DECLS
+
+/*-----------------------------------------------------------------------------*
+*                           SSH Base                                          *
+*-----------------------------------------------------------------------------*/
+
+#define REMMINA_SSH(a) ((RemminaSSH *)a)
+
+typedef struct _RemminaSSH {
+	ssh_session	session;
+	ssh_callbacks	callback;
+	gboolean	authenticated;
+
+	gchar *		server;
+	gint		port;
+	gchar *		user;
+	gint		auth;
+	gchar *		password;
+	gchar *		privkeyfile;
+	gchar *		certfile;
+
+	gchar *		charset;
+	const gchar *	kex_algorithms;
+	gchar *		ciphers;
+	gchar *		hostkeytypes;
+	gchar *		proxycommand;
+	gint		stricthostkeycheck;
+	const gchar *	compression;
+
+	gchar *		error;
+
+	pthread_mutex_t ssh_mutex;
+
+	gchar *		passphrase;
+
+	gboolean	is_tunnel;
+	gboolean	is_multiauth;
+	gchar *		tunnel_entrance_host;
+	gint		tunnel_entrance_port;
+
+} RemminaSSH;
+
+gchar *remmina_ssh_identity_path(const gchar *id);
+
+/* Auto-detect commonly used private key identities */
+gchar *remmina_ssh_find_identity(void);
+
+/* Initialize the ssh object */
+gboolean remmina_ssh_init_from_file(RemminaSSH *ssh, RemminaFile *remminafile, gboolean is_tunnel);
+
+/* Initialize the SSH session */
+gboolean remmina_ssh_init_session(RemminaSSH *ssh);
+
+/* Authenticate SSH session */
+
+
+enum remmina_ssh_auth_result {
+	REMMINA_SSH_AUTH_NULL,
+	REMMINA_SSH_AUTH_SUCCESS,
+	REMMINA_SSH_AUTH_PARTIAL,
+	REMMINA_SSH_AUTH_AGAIN,
+	REMMINA_SSH_AUTH_AUTHFAILED_RETRY_AFTER_PROMPT,
+	REMMINA_SSH_AUTH_USERCANCEL,
+	REMMINA_SSH_AUTH_FATAL_ERROR,
+	REMMINA_SSH_AUTH_RECONNECT,
+	REMMINA_SSH_AUTH_AUTHFAILED_EMPTY_USERNAME
+};
+
+enum remmina_ssh_auth_result remmina_ssh_auth(RemminaSSH *ssh, const gchar *password, RemminaProtocolWidget *gp, RemminaFile *remminafile);
+
+enum remmina_ssh_auth_result remmina_ssh_auth_gui(RemminaSSH *ssh, RemminaProtocolWidget *gp, RemminaFile *remminafile);
+
+/* Error handling */
+#define remmina_ssh_has_error(ssh) (((RemminaSSH *)ssh)->error != NULL)
+void remmina_ssh_set_error(RemminaSSH *ssh, const gchar *fmt);
+void remmina_ssh_set_application_error(RemminaSSH *ssh, const gchar *fmt, ...);
+
+/* Converts a string to/from UTF-8, or simply duplicate it if no conversion */
+gchar *remmina_ssh_convert(RemminaSSH *ssh, const gchar *from);
+gchar *remmina_ssh_unconvert(RemminaSSH *ssh, const gchar *from);
+
+void remmina_ssh_free(RemminaSSH *ssh);
+
+/*-----------------------------------------------------------------------------*
+*                           SSH Tunnel                                        *
+*-----------------------------------------------------------------------------*/
+typedef struct _RemminaSSHTunnel RemminaSSHTunnel;
+typedef struct _RemminaSSHTunnelBuffer RemminaSSHTunnelBuffer;
+
+typedef gboolean (*RemminaSSHTunnelCallback) (RemminaSSHTunnel *, gpointer);
+
+enum {
+	REMMINA_SSH_TUNNEL_OPEN,
+	REMMINA_SSH_TUNNEL_XPORT,
+	REMMINA_SSH_TUNNEL_REVERSE
+};
+
+
+struct _RemminaSSHTunnel {
+	RemminaSSH			ssh;
+
+	gint				tunnel_type;
+
+	ssh_channel *			channels;
+	gint *				sockets;
+	RemminaSSHTunnelBuffer **	socketbuffers;
+	gint				num_channels;
+	gint				max_channels;
+
+	pthread_t			thread;
+	gboolean			running;
+
+	gchar *				buffer;
+	gint				buffer_len;
+	ssh_channel *			channels_out;
+
+	gint				server_sock;
+	gchar *				dest;
+	gint				port;
+	gint				localport;
+
+	gint				remotedisplay;
+	gboolean			bindlocalhost;
+	gchar *				localdisplay;
+
+	RemminaSSHTunnelCallback	init_func;
+	RemminaSSHTunnelCallback	connect_func;
+	RemminaSSHTunnelCallback	disconnect_func;
+	gpointer			callback_data;
+
+	RemminaSSHTunnelCallback	destroy_func;
+	gpointer	destroy_func_callback_data;
+
+};
+
+/* Create a new SSH Tunnel session and connects to the SSH server */
+RemminaSSHTunnel *remmina_ssh_tunnel_new_from_file(RemminaFile *remminafile);
+
+/* Open the tunnel. A new thread will be started and listen on a local port.
+ * dest: The host:port of the remote destination
+ * local_port: The listening local port for the tunnel
+ */
+gboolean remmina_ssh_tunnel_open(RemminaSSHTunnel *tunnel, const gchar *host, gint port, gint local_port);
+
+/* Cancel accepting any incoming tunnel request.
+ * Typically called after the connection has already been establish.
+ */
+void remmina_ssh_tunnel_cancel_accept(RemminaSSHTunnel *tunnel);
+
+/* start X Port Forwarding */
+gboolean remmina_ssh_tunnel_xport(RemminaSSHTunnel *tunnel, gboolean bindlocalhost);
+
+/* start reverse tunnel. A new thread will be started and waiting for incoming connection.
+ * port: the port listening on the remote server side.
+ * local_port: the port listening on the local side. When connection on the server side comes
+ *             in, it will connect to the local port and create the tunnel. The caller should
+ *             start listening on the local port before calling it or in connect_func callback.
+ */
+gboolean remmina_ssh_tunnel_reverse(RemminaSSHTunnel *tunnel, gint port, gint local_port);
+
+/* Tells if the tunnel is terminated after start */
+gboolean remmina_ssh_tunnel_terminated(RemminaSSHTunnel *tunnel);
+
+/* Free the tunnel */
+void remmina_ssh_tunnel_free(RemminaSSHTunnel *tunnel);
+
+/*-----------------------------------------------------------------------------*
+*                           SSH sFTP                                          *
+*-----------------------------------------------------------------------------*/
+
+typedef struct _RemminaSFTP {
+	RemminaSSH	ssh;
+
+	sftp_session	sftp_sess;
+} RemminaSFTP;
+
+/* Create a new SFTP session object from RemminaFile */
+RemminaSFTP *remmina_sftp_new_from_file(RemminaFile *remminafile);
+
+/* Create a new SFTP session object from existing SSH session */
+RemminaSFTP *remmina_sftp_new_from_ssh(RemminaSSH *ssh);
+
+/* open the SFTP session, assuming the session already authenticated */
+gboolean remmina_sftp_open(RemminaSFTP *sftp);
+
+/* Free the SFTP session */
+void remmina_sftp_free(RemminaSFTP *sftp);
+
+/*-----------------------------------------------------------------------------*
+*                           SSH Shell                                         *
+*-----------------------------------------------------------------------------*/
+typedef void (*RemminaSSHExitFunc) (gpointer data);
+
+typedef struct _RemminaSSHShell {
+	RemminaSSH		ssh;
+
+	gint			master;
+	gint			slave;
+	gchar *			exec;
+	gchar *			run_line;
+	pthread_t		thread;
+	ssh_channel		channel;
+	gboolean		closed;
+	RemminaSSHExitFunc	exit_callback;
+	gpointer		user_data;
+	ssh_event		event;
+} RemminaSSHShell;
+
+/* Create a new SSH Shell session object from RemminaFile */
+RemminaSSHShell *remmina_ssh_shell_new_from_file(RemminaFile *remminafile);
+
+/* Create a new SSH Shell session object from existing SSH session */
+RemminaSSHShell *remmina_ssh_shell_new_from_ssh(RemminaSSH *ssh);
+
+/* open the SSH Shell, assuming the session already authenticated */
+gboolean remmina_ssh_shell_open(RemminaSSHShell *shell, RemminaSSHExitFunc exit_callback, gpointer data);
+
+/* Change the SSH Shell terminal size */
+void remmina_ssh_shell_set_size(RemminaSSHShell *shell, gint columns, gint rows);
+
+/* Free the SFTP session */
+void remmina_ssh_shell_free(RemminaSSHShell *shell);
+
+G_END_DECLS
+
+#else
+
+#define RemminaSSH void
+#define RemminaSSHTunnel void
+#define RemminaSFTP void
+#define RemminaSSHShell void
+typedef void (*RemminaSSHTunnelCallback)(void);
+
+#endif /* HAVE_LIBSSH */
diff --git a/src/remmina_ssh_plugin.c b/src/remmina_ssh_plugin.c
new file mode 100644
index 0000000..93f692f
--- /dev/null
+++ b/src/remmina_ssh_plugin.c
@@ -0,0 +1,1738 @@
+/**
+ * Remmina - The GTK+ Remote Desktop Client - SSH plugin.
+ *
+ * @copyright Copyright (C) 2010-2011 Vic Lee.
+ * @copyright Copyright (C) 2014-2015 Antenore Gatta, Fabio Castelli, Giovanni Panozzo.
+ * @copyright Copyright (C) 2016-2022 Antenore Gatta, Giovanni Panozzo.
+ * @copyright Copyright (C) 2022-2023 Antenore Gatta, Giovanni Panozzo, Hiroyuki Tanaka
+ *
+ * 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 "remmina/remmina_trace_calls.h"
+
+#if defined (HAVE_LIBSSH) && defined (HAVE_LIBVTE)
+
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
+#include <gio/gio.h>
+#include <glib-object.h>
+#include <gobject/gvaluecollector.h>
+#include <vte/vte.h>
+#include <locale.h>
+#include <langinfo.h>
+#include "remmina_log.h"
+#include "remmina_public.h"
+#include "remmina_plugin_manager.h"
+#include "remmina_ssh.h"
+#include "remmina_protocol_widget.h"
+#include "remmina_pref.h"
+#include "remmina_ssh_plugin.h"
+#include "remmina_masterthread_exec.h"
+
+#define PCRE2_CODE_UNIT_WIDTH 8
+#include <pcre2.h>
+
+
+#define REMMINA_PLUGIN_SSH_FEATURE_TOOL_COPY  1
+#define REMMINA_PLUGIN_SSH_FEATURE_TOOL_PASTE 2
+#define REMMINA_PLUGIN_SSH_FEATURE_TOOL_SELECT_ALL 3
+#define REMMINA_PLUGIN_SSH_FEATURE_TOOL_INCREASE_FONT 4
+#define REMMINA_PLUGIN_SSH_FEATURE_TOOL_DECREASE_FONT 5
+#define REMMINA_PLUGIN_SSH_FEATURE_TOOL_SEARCH 6
+
+#define GET_PLUGIN_DATA(gp) (RemminaPluginSshData *)g_object_get_data(G_OBJECT(gp), "plugin-data");
+
+/** Palette colors taken from sakura */
+#define PALETTE_SIZE 16
+/* Min fontsize and increase */
+#define FONT_SCALE    0.75
+#define SCALE_FACTOR  0.1
+#define FONT_MINIMAL_SIZE (PANGO_SCALE * 6)
+
+enum color_schemes { LINUX, TANGO, GRUVBOX, SOLARIZED_DARK, SOLARIZED_LIGHT, XTERM, CUSTOM };
+
+/** 16 colour palettes in GdkRGBA format (red, green, blue, alpha).
+ * Text displayed in the first 8 colours (0-7) is meek (uses thin strokes).
+ * Text displayed in the second 8 colours (8-15) is bold (uses thick strokes).
+ **/
+const GdkRGBA linux_palette[PALETTE_SIZE] = {
+	{ 0,	    0,	      0,	1 },
+	{ 0.666667, 0,	      0,	1 },
+	{ 0,	    0.666667, 0,	1 },
+	{ 0.666667, 0.333333, 0,	1 },
+	{ 0,	    0,	      0.666667, 1 },
+	{ 0.666667, 0,	      0.666667, 1 },
+	{ 0,	    0.666667, 0.666667, 1 },
+	{ 0.666667, 0.666667, 0.666667, 1 },
+	{ 0.333333, 0.333333, 0.333333, 1 },
+	{ 1,	    0.333333, 0.333333, 1 },
+	{ 0.333333, 1,	      0.333333, 1 },
+	{ 1,	    1,	      0.333333, 1 },
+	{ 0.333333, 0.333333, 1,	1 },
+	{ 1,	    0.333333, 1,	1 },
+	{ 0.333333, 1,	      1,	1 },
+	{ 1,	    1,	      1,	1 }
+};
+
+const GdkRGBA tango_palette[PALETTE_SIZE] = {
+	{ 0,	     0,	       0,	 1 },
+	{ 0.8,	     0,	       0,	 1 },
+	{ 0.305882,  0.603922, 0.023529, 1 },
+	{ 0.768627,  0.627451, 0,	 1 },
+	{ 0.203922,  0.396078, 0.643137, 1 },
+	{ 0.458824,  0.313725, 0.482353, 1 },
+	{ 0.0235294, 0.596078, 0.603922, 1 },
+	{ 0.827451,  0.843137, 0.811765, 1 },
+	{ 0.333333,  0.341176, 0.32549,	 1 },
+	{ 0.937255,  0.160784, 0.160784, 1 },
+	{ 0.541176,  0.886275, 0.203922, 1 },
+	{ 0.988235,  0.913725, 0.309804, 1 },
+	{ 0.447059,  0.623529, 0.811765, 1 },
+	{ 0.678431,  0.498039, 0.658824, 1 },
+	{ 0.203922,  0.886275, 0.886275, 1 },
+	{ 0.933333,  0.933333, 0.92549,	 1 }
+};
+
+const GdkRGBA gruvbox_palette[PALETTE_SIZE] = {
+	{ 0.156863, 0.156863, 0.156863, 1.000000 },
+	{ 0.800000, 0.141176, 0.113725, 1.000000 },
+	{ 0.596078, 0.592157, 0.101961, 1.000000 },
+	{ 0.843137, 0.600000, 0.129412, 1.000000 },
+	{ 0.270588, 0.521569, 0.533333, 1.000000 },
+	{ 0.694118, 0.384314, 0.525490, 1.000000 },
+	{ 0.407843, 0.615686, 0.415686, 1.000000 },
+	{ 0.658824, 0.600000, 0.517647, 1.000000 },
+	{ 0.572549, 0.513725, 0.454902, 1.000000 },
+	{ 0.984314, 0.286275, 0.203922, 1.000000 },
+	{ 0.721569, 0.733333, 0.149020, 1.000000 },
+	{ 0.980392, 0.741176, 0.184314, 1.000000 },
+	{ 0.513725, 0.647059, 0.596078, 1.000000 },
+	{ 0.827451, 0.525490, 0.607843, 1.000000 },
+	{ 0.556863, 0.752941, 0.486275, 1.000000 },
+	{ 0.921569, 0.858824, 0.698039, 1.000000 },
+};
+
+const GdkRGBA solarized_dark_palette[PALETTE_SIZE] = {
+	{ 0.027451, 0.211765, 0.258824, 1 },
+	{ 0.862745, 0.196078, 0.184314, 1 },
+	{ 0.521569, 0.600000, 0.000000, 1 },
+	{ 0.709804, 0.537255, 0.000000, 1 },
+	{ 0.149020, 0.545098, 0.823529, 1 },
+	{ 0.827451, 0.211765, 0.509804, 1 },
+	{ 0.164706, 0.631373, 0.596078, 1 },
+	{ 0.933333, 0.909804, 0.835294, 1 },
+	{ 0.000000, 0.168627, 0.211765, 1 },
+	{ 0.796078, 0.294118, 0.086275, 1 },
+	{ 0.345098, 0.431373, 0.458824, 1 },
+	{ 0.396078, 0.482353, 0.513725, 1 },
+	{ 0.513725, 0.580392, 0.588235, 1 },
+	{ 0.423529, 0.443137, 0.768627, 1 },
+	{ 0.576471, 0.631373, 0.631373, 1 },
+	{ 0.992157, 0.964706, 0.890196, 1 }
+};
+
+const GdkRGBA solarized_light_palette[PALETTE_SIZE] = {
+	{ 0.933333, 0.909804, 0.835294, 1 },
+	{ 0.862745, 0.196078, 0.184314, 1 },
+	{ 0.521569, 0.600000, 0.000000, 1 },
+	{ 0.709804, 0.537255, 0.000000, 1 },
+	{ 0.149020, 0.545098, 0.823529, 1 },
+	{ 0.827451, 0.211765, 0.509804, 1 },
+	{ 0.164706, 0.631373, 0.596078, 1 },
+	{ 0.027451, 0.211765, 0.258824, 1 },
+	{ 0.992157, 0.964706, 0.890196, 1 },
+	{ 0.796078, 0.294118, 0.086275, 1 },
+	{ 0.576471, 0.631373, 0.631373, 1 },
+	{ 0.513725, 0.580392, 0.588235, 1 },
+	{ 0.396078, 0.482353, 0.513725, 1 },
+	{ 0.423529, 0.443137, 0.768627, 1 },
+	{ 0.345098, 0.431373, 0.458824, 1 },
+	{ 0.000000, 0.168627, 0.211765, 1 }
+};
+
+const GdkRGBA xterm_palette[PALETTE_SIZE] = {
+	{ 0,	    0,	      0,	1 },
+	{ 0.803922, 0,	      0,	1 },
+	{ 0,	    0.803922, 0,	1 },
+	{ 0.803922, 0.803922, 0,	1 },
+	{ 0.117647, 0.564706, 1,	1 },
+	{ 0.803922, 0,	      0.803922, 1 },
+	{ 0,	    0.803922, 0.803922, 1 },
+	{ 0.898039, 0.898039, 0.898039, 1 },
+	{ 0.298039, 0.298039, 0.298039, 1 },
+	{ 1,	    0,	      0,	1 },
+	{ 0,	    1,	      0,	1 },
+	{ 1,	    1,	      0,	1 },
+	{ 0.27451,  0.509804, 0.705882, 1 },
+	{ 1,	    0,	      1,	1 },
+	{ 0,	    1,	      1,	1 },
+	{ 1,	    1,	      1,	1 }
+};
+
+#define DEFAULT_PALETTE "linux_palette"
+
+
+/** The SSH plugin implementation */
+typedef struct _RemminaSshSearch {
+	GtkWidget *		parent;
+
+	GtkBuilder *		builder;
+	GtkWidget *		window;
+	GtkWidget *		search_entry;
+	GtkWidget *		search_prev_button;
+	GtkWidget *		search_next_button;
+	GtkWidget *		close_button;
+	GtkToggleButton *	match_case_checkbutton;
+	GtkToggleButton *	entire_word_checkbutton;
+	GtkToggleButton *	regex_checkbutton;
+	GtkToggleButton *	wrap_around_checkbutton;
+	GtkWidget *		reveal_button;
+	GtkWidget *		revealer;
+
+	//VteTerminal *terminal;
+	gboolean		regex_caseless;
+	gboolean		has_regex;
+	gchar *			regex_pattern;
+} RemminaSshSearch;
+
+typedef struct _RemminaPluginSshData {
+	RemminaSSHShell *	shell;
+	GFile *			vte_session_file;
+	GtkWidget *		vte;
+
+	const GdkRGBA *		palette;
+
+	pthread_t		thread;
+
+	gboolean		closed;
+
+	RemminaSshSearch *	search_widget;
+} RemminaPluginSshData;
+
+
+#define GET_OBJECT(object_name) gtk_builder_get_object(search_widget->builder, object_name)
+
+static RemminaPluginService *remmina_plugin_service = NULL;
+
+static gboolean
+remmina_plugin_ssh_on_size_allocate(GtkWidget *widget, GtkAllocation *alloc, RemminaProtocolWidget *gp);
+
+static gboolean
+valid_color(GdkRGBA const *color)
+{
+	return color->red >= 0. && color->red <= 1. &&
+	       color->green >= 0. && color->green <= 1. &&
+	       color->blue >= 0. && color->blue <= 1. &&
+	       color->alpha >= 0. && color->alpha <= 1.;
+}
+
+
+/**
+ * Remmina protocol plugin main function.
+ *
+ * First it starts the SSH tunnel if needed and then the SSH connection.
+ *
+ */
+static gpointer
+remmina_plugin_ssh_main_thread(gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)data;
+	RemminaPluginSshData *gpdata;
+	RemminaFile *remminafile;
+	RemminaSSH *ssh;
+	RemminaSSHShell *shell = NULL;
+	gboolean cont = FALSE;
+	gboolean partial = FALSE;
+	gchar *hostport;
+	gint ret = REMMINA_SSH_AUTH_NULL;
+
+	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+	CANCEL_ASYNC
+
+		gpdata = GET_PLUGIN_DATA(gp);
+
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+
+	/* we may need to open a new tunnel */
+	REMMINA_DEBUG("Tentatively create an SSH tunnel");
+	hostport = remmina_plugin_service->protocol_plugin_start_direct_tunnel(gp, 22, FALSE);
+	if (hostport == NULL) {
+		remmina_plugin_service->protocol_plugin_signal_connection_closed(gp);
+		return NULL;
+	}
+	REMMINA_DEBUG("protocol_plugin_start_direct_tunnel returned hostport: %s", hostport);
+
+	ssh = g_object_get_data(G_OBJECT(gp), "user-data");
+	if (ssh) {
+		REMMINA_DEBUG("Creating SSH shell based on existing SSH session");
+		shell = remmina_ssh_shell_new_from_ssh(ssh);
+		REMMINA_DEBUG("Calling remmina_public_get_server_port");
+		remmina_plugin_service->get_server_port(hostport, 22, &ssh->tunnel_entrance_host, &ssh->tunnel_entrance_port);
+		REMMINA_DEBUG("tunnel_entrance_host: %s, tunnel_entrance_port: %d", ssh->tunnel_entrance_host, ssh->tunnel_entrance_port);
+
+		if (remmina_ssh_init_session(REMMINA_SSH(shell)) &&
+		    remmina_ssh_auth(REMMINA_SSH(shell), NULL, gp, remminafile) == REMMINA_SSH_AUTH_SUCCESS &&
+		    remmina_ssh_shell_open(shell, (RemminaSSHExitFunc)
+					   remmina_plugin_service->protocol_plugin_signal_connection_closed, gp))
+			cont = TRUE;
+	} else {
+		/* New SSH Shell connection */
+		REMMINA_DEBUG("Creating SSH shell based on a new SSH session");
+		shell = remmina_ssh_shell_new_from_file(remminafile);
+		ssh = REMMINA_SSH(shell);
+		REMMINA_DEBUG("Calling remmina_public_get_server_port");
+		remmina_plugin_service->get_server_port(hostport, 22, &ssh->tunnel_entrance_host, &ssh->tunnel_entrance_port);
+		REMMINA_DEBUG("tunnel_entrance_host: %s, tunnel_entrance_port: %d", ssh->tunnel_entrance_host, ssh->tunnel_entrance_port);
+
+		while (1) {
+			if (!partial) {
+				if (!remmina_ssh_init_session(ssh)) {
+					REMMINA_DEBUG("init session error: %s", ssh->error);
+					remmina_plugin_service->protocol_plugin_set_error(gp, "%s", ssh->error);
+					// exit the loop here: OK
+					break;
+				}
+			}
+
+			ret = remmina_ssh_auth_gui(ssh, gp, remminafile);
+			switch (ret) {
+			case REMMINA_SSH_AUTH_SUCCESS:
+				REMMINA_DEBUG("Authentication success");
+				if (!remmina_ssh_shell_open(shell, (RemminaSSHExitFunc)
+							    remmina_plugin_service->protocol_plugin_signal_connection_closed, gp)) {
+					remmina_plugin_service->protocol_plugin_set_error(gp, "%s", ssh->error);
+					break;
+				}
+				gchar *server;
+				gint port;
+				remmina_plugin_service->get_server_port(remmina_plugin_service->file_get_string(remminafile, "server"),
+						22,
+						&server,
+						&port);
+
+				REMMINA_AUDIT(_("Connected to %s:%d via SSH"), server, port);
+				g_free(server), server = NULL;
+				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 (ssh->session) {
+					ssh_disconnect(ssh->session);
+					ssh_free(ssh->session);
+					ssh->session = NULL;
+				}
+				g_free(ssh->callback);
+				// Continue the loop: OK
+				continue;
+				break;
+			case REMMINA_SSH_AUTH_USERCANCEL:
+				REMMINA_DEBUG("Interrupted by the user");
+				// TODO: exit the loop here: OK
+				goto BREAK;
+				break;
+			default:
+				REMMINA_DEBUG("Error during the authentication: %s", ssh->error);
+				remmina_plugin_service->protocol_plugin_set_error(gp, "%s", ssh->error);
+				// TODO: exit the loop here: OK
+				goto BREAK;
+			}
+
+
+			cont = TRUE;
+			break;
+		}
+	}
+
+BREAK:
+	REMMINA_DEBUG("Authentication terminated with exit status %d", ret);
+
+	g_free(hostport);
+
+	if (!cont) {
+		if (shell) remmina_ssh_shell_free(shell);
+		remmina_plugin_service->protocol_plugin_signal_connection_closed(gp);
+		return NULL;
+	}
+
+	gpdata->shell = shell;
+
+	gchar *charset = REMMINA_SSH(shell)->charset;
+
+	remmina_plugin_ssh_vte_terminal_set_encoding_and_pty(VTE_TERMINAL(gpdata->vte), charset, shell->master, shell->slave);
+
+	/* TODO: The following call should be moved on the main thread, or something weird could happen */
+	//remmina_plugin_ssh_on_size_allocate(GTK_WIDGET(gpdata->vte), NULL, gp);
+
+	remmina_plugin_service->protocol_plugin_signal_connection_opened(gp);
+
+	gpdata->thread = 0;
+	return NULL;
+}
+
+void remmina_plugin_ssh_vte_terminal_set_encoding_and_pty(VteTerminal *terminal, const char *codeset, int master, int slave)
+{
+	TRACE_CALL(__func__);
+	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_VTE_TERMINAL_SET_ENCODING_AND_PTY;
+		d->p.vte_terminal_set_encoding_and_pty.terminal = terminal;
+		d->p.vte_terminal_set_encoding_and_pty.codeset = codeset;
+		d->p.vte_terminal_set_encoding_and_pty.master = master;
+		remmina_masterthread_exec_and_wait(d);
+		g_free(d);
+		return;
+	}
+
+	setlocale(LC_ALL, "");
+	if (codeset && codeset[0] != '\0') {
+	}
+
+	vte_terminal_set_backspace_binding(terminal, VTE_ERASE_ASCII_DELETE);
+	vte_terminal_set_delete_binding(terminal, VTE_ERASE_DELETE_SEQUENCE);
+
+#if VTE_CHECK_VERSION(0, 38, 0)
+	/* vte_pty_new_foreign expect master FD, see https://bugzilla.gnome.org/show_bug.cgi?id=765382 */
+	vte_terminal_set_pty(terminal, vte_pty_new_foreign_sync(master, NULL, NULL));
+#else
+	vte_terminal_set_pty(terminal, master);
+#endif
+}
+
+static gboolean
+remmina_plugin_ssh_on_focus_in(GtkWidget *widget, GdkEventFocus *event, RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginSshData *gpdata = GET_PLUGIN_DATA(gp);
+
+	gtk_widget_grab_focus(gpdata->vte);
+	return TRUE;
+}
+
+static gboolean
+remmina_plugin_ssh_on_size_allocate(GtkWidget *widget, GtkAllocation *alloc, RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginSshData *gpdata = GET_PLUGIN_DATA(gp);
+	gint cols, rows;
+
+	if (!gtk_widget_get_mapped(widget)) return FALSE;
+
+	cols = vte_terminal_get_column_count(VTE_TERMINAL(widget));
+	rows = vte_terminal_get_row_count(VTE_TERMINAL(widget));
+
+	if (gpdata->shell)
+		remmina_ssh_shell_set_size(gpdata->shell, cols, rows);
+
+	return FALSE;
+}
+
+static void
+remmina_plugin_ssh_set_vte_pref(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginSshData *gpdata = GET_PLUGIN_DATA(gp);
+	RemminaFile *remminafile;
+
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+
+	if (remmina_plugin_service->file_get_int(remminafile, "audiblebell", FALSE)) {
+		vte_terminal_set_audible_bell(VTE_TERMINAL(gpdata->vte), TRUE);
+		g_info("audible_bell set to %i", vte_terminal_get_audible_bell(VTE_TERMINAL(gpdata->vte)));
+	}
+	if (remmina_pref.vte_font && remmina_pref.vte_font[0]) {
+#if !VTE_CHECK_VERSION(0, 38, 0)
+		vte_terminal_set_font_from_string(VTE_TERMINAL(gpdata->vte), remmina_pref.vte_font);
+#else
+		vte_terminal_set_font(VTE_TERMINAL(gpdata->vte),
+				      pango_font_description_from_string(remmina_pref.vte_font));
+#endif
+	}
+
+#if VTE_CHECK_VERSION(0, 51, 3)
+	REMMINA_DEBUG("Using vte_terminal_set_bold_is_bright instead of vte_terminal_set_allow_bold as deprecated");
+	vte_terminal_set_bold_is_bright(VTE_TERMINAL(gpdata->vte), remmina_pref.vte_allow_bold_text);
+#else
+	vte_terminal_set_allow_bold(VTE_TERMINAL(gpdata->vte), remmina_pref.vte_allow_bold_text);
+#endif
+	if (remmina_pref.vte_lines > 0)
+		vte_terminal_set_scrollback_lines(VTE_TERMINAL(gpdata->vte), remmina_pref.vte_lines);
+}
+
+void
+remmina_plugin_ssh_vte_select_all(GtkMenuItem *menuitem, gpointer vte)
+{
+	TRACE_CALL(__func__);
+	vte_terminal_select_all(VTE_TERMINAL(vte));
+	/** @todo we should add the vte_terminal_unselect_all as well */
+}
+
+void
+remmina_plugin_ssh_vte_decrease_font(GtkMenuItem *menuitem, gpointer vte)
+{
+	TRACE_CALL(__func__);
+	vte_terminal_set_font_scale(VTE_TERMINAL(vte), vte_terminal_get_font_scale(VTE_TERMINAL(vte)) - SCALE_FACTOR);
+}
+
+void
+remmina_plugin_ssh_vte_increase_font(GtkMenuItem *menuitem, gpointer vte)
+{
+	TRACE_CALL(__func__);
+	vte_terminal_set_font_scale(VTE_TERMINAL(vte), vte_terminal_get_font_scale(VTE_TERMINAL(vte)) + SCALE_FACTOR);
+}
+
+void
+remmina_plugin_ssh_vte_copy_clipboard(GtkMenuItem *menuitem, gpointer vte)
+{
+	TRACE_CALL(__func__);
+#if VTE_CHECK_VERSION(0, 50, 0)
+	vte_terminal_copy_clipboard_format(VTE_TERMINAL(vte), VTE_FORMAT_TEXT);
+#else
+	vte_terminal_copy_clipboard(VTE_TERMINAL(vte));
+#endif
+}
+
+void
+remmina_plugin_ssh_vte_paste_clipboard(GtkMenuItem *menuitem, gpointer vte)
+{
+	TRACE_CALL(__func__);
+	vte_terminal_paste_clipboard(VTE_TERMINAL(vte));
+}
+
+void
+remmina_plugin_ssh_vte_save_session(GtkMenuItem *menuitem, RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginSshData *gpdata = GET_PLUGIN_DATA(gp);
+
+	GtkWidget *widget;
+	GError *err = NULL;
+
+	GFileOutputStream *stream = g_file_replace(gpdata->vte_session_file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &err);
+
+	if (err != NULL) {
+		// TRANSLATORS: %s is a placeholder for an error message
+		widget = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error: %s"), err->message);
+		g_signal_connect(G_OBJECT(widget), "response", G_CALLBACK(gtk_widget_destroy), NULL);
+		gtk_widget_show(widget);
+		return;
+	}
+
+	if (stream != NULL)
+#if VTE_CHECK_VERSION(0, 38, 0)
+		vte_terminal_write_contents_sync(VTE_TERMINAL(gpdata->vte), G_OUTPUT_STREAM(stream),
+						 VTE_WRITE_DEFAULT, NULL, &err);
+#else
+		vte_terminal_write_contents(VTE_TERMINAL(gpdata->vte), G_OUTPUT_STREAM(stream),
+					    VTE_TERMINAL_WRITE_DEFAULT, NULL, &err);
+#endif
+
+	if (err == NULL) {
+		remmina_public_send_notification("remmina-terminal-saved",
+						 _("Terminal content saved in"),
+						 g_file_get_path(gpdata->vte_session_file));
+	}
+
+	g_object_unref(stream);
+	g_free(err);
+}
+
+/** Send a keystroke to the plugin window */
+static void remmina_ssh_keystroke(RemminaProtocolWidget *gp, const guint keystrokes[], const gint keylen)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginSshData *gpdata = GET_PLUGIN_DATA(gp);
+
+	remmina_plugin_service->protocol_plugin_send_keys_signals(gpdata->vte,
+								  keystrokes, keylen, GDK_KEY_PRESS | GDK_KEY_RELEASE);
+	return;
+}
+
+
+/* regex */
+
+static void jit_regex(VteRegex *regex, char const *pattern)
+{
+	TRACE_CALL(__func__);
+	GError *error;
+
+	if (!vte_regex_jit(regex, PCRE2_JIT_COMPLETE, &error) ||
+	    !vte_regex_jit(regex, PCRE2_JIT_PARTIAL_SOFT, &error))
+		if (!g_error_matches(error, VTE_REGEX_ERROR, -45 /* PCRE2_ERROR_JIT_BADOPTION: JIT not supported */))
+			REMMINA_DEBUG("JITing regex “%s” failed: %s\n", pattern, error->message);
+}
+
+static VteRegex *compile_regex_for_search(char const *pattern, gboolean caseless, GError **error)
+{
+	TRACE_CALL(__func__);
+	uint32_t flags = PCRE2_UTF | PCRE2_NO_UTF_CHECK | PCRE2_MULTILINE;
+
+	if (caseless)
+		flags |= PCRE2_CASELESS;
+
+	VteRegex *regex = vte_regex_new_for_search(pattern, strlen(pattern), flags, error);
+
+	if (regex != NULL)
+		jit_regex(regex, pattern);
+
+	return regex;
+}
+
+static void
+remmina_search_widget_update_sensitivity(RemminaSshSearch *search_widget)
+{
+	TRACE_CALL(__func__);
+	gboolean can_search = search_widget->has_regex;
+
+	gtk_widget_set_sensitive(search_widget->search_next_button, can_search);
+	gtk_widget_set_sensitive(search_widget->search_prev_button, can_search);
+}
+
+static void
+remmina_search_widget_update_regex(RemminaPluginSshData *gpdata)
+{
+	TRACE_CALL(__func__);
+	GError *error = NULL;
+
+	RemminaSshSearch *search_widget = gpdata->search_widget;
+	char const *search_text = gtk_entry_get_text(GTK_ENTRY(search_widget->search_entry));
+	gboolean caseless = gtk_toggle_button_get_active(search_widget->match_case_checkbutton) == FALSE;
+
+	char *pattern;
+
+	if (gtk_toggle_button_get_active(search_widget->regex_checkbutton))
+		pattern = g_strdup(search_text);
+	else
+		pattern = g_regex_escape_string(search_text, -1);
+
+	if (gtk_toggle_button_get_active(search_widget->regex_checkbutton)) {
+		char *tmp = g_strdup_printf("\\b%s\\b", pattern);
+		g_free(pattern);
+		pattern = tmp;
+	}
+
+	if (caseless == search_widget->regex_caseless &&
+	    g_strcmp0(pattern, search_widget->regex_pattern) == 0)
+		return;
+
+	search_widget->regex_caseless = caseless;
+	g_free(search_widget->regex_pattern);
+	search_widget->regex_pattern = NULL;
+
+	if (search_text[0] != '\0') {
+		REMMINA_DEBUG("Search text is: %s", search_text);
+		VteRegex *regex = compile_regex_for_search(pattern, caseless, &error);
+		vte_terminal_search_set_regex(VTE_TERMINAL(gpdata->vte), regex, 0);
+		if (regex != NULL)
+			vte_regex_unref(regex);
+
+		if (!error) {
+			search_widget->has_regex = TRUE;
+			search_widget->regex_pattern = pattern; /* adopt */
+			pattern = NULL;                         /* adopted */
+			gtk_widget_set_tooltip_text(search_widget->search_entry, NULL);
+		} else {
+			search_widget->has_regex = FALSE;
+			REMMINA_DEBUG("Regex not set, cannot search");
+			gtk_widget_set_tooltip_text(search_widget->search_entry, error->message);
+		}
+	}
+
+	g_free(pattern);
+	g_free(error);
+
+	remmina_search_widget_update_sensitivity(search_widget);
+}
+
+static void
+remmina_search_widget_wrap_around_toggled(GtkToggleButton *button, RemminaPluginSshData *gpdata)
+{
+	TRACE_CALL(__func__);
+
+	vte_terminal_search_set_wrap_around(VTE_TERMINAL(gpdata->vte), gtk_toggle_button_get_active(button));
+}
+
+static void
+remmina_search_widget_search_forward(RemminaPluginSshData *gpdata)
+{
+	TRACE_CALL(__func__);
+
+	RemminaSshSearch *search_sidget = gpdata->search_widget;
+
+	if (!search_sidget->has_regex)
+		return;
+	vte_terminal_search_find_next(VTE_TERMINAL(gpdata->vte));
+}
+
+static void
+remmina_search_widget_search_backward(RemminaPluginSshData *gpdata)
+{
+	TRACE_CALL(__func__);
+
+	RemminaSshSearch *search_sidget = gpdata->search_widget;
+
+	if (!search_sidget->has_regex)
+		return;
+	vte_terminal_search_find_previous(VTE_TERMINAL(gpdata->vte));
+}
+
+GtkWidget *remmina_plugin_pop_search_new(GtkWidget *relative_to, RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginSshData *gpdata = GET_PLUGIN_DATA(gp);
+
+	gpdata->search_widget = g_new0(RemminaSshSearch, 1);
+	RemminaSshSearch *search_widget = gpdata->search_widget;
+
+	search_widget->regex_caseless = FALSE;
+	search_widget->has_regex = FALSE;
+	search_widget->regex_pattern = NULL;
+
+	search_widget->builder = remmina_public_gtk_builder_new_from_resource("/org/remmina/Remmina/src/../data/ui/remmina_search.glade");
+	search_widget->window = GTK_WIDGET(GET_OBJECT("RemminaSearchWidget"));
+	search_widget->search_entry = GTK_WIDGET(GET_OBJECT("search_entry"));
+	search_widget->search_prev_button = GTK_WIDGET(GET_OBJECT("search_prev_button"));
+	search_widget->search_next_button = GTK_WIDGET(GET_OBJECT("search_next_button"));
+	search_widget->close_button = GTK_WIDGET(GET_OBJECT("close_button"));
+	search_widget->match_case_checkbutton = GTK_TOGGLE_BUTTON(GET_OBJECT("match_case_checkbutton"));
+	search_widget->entire_word_checkbutton = GTK_TOGGLE_BUTTON(GET_OBJECT("entire_word_checkbutton"));
+	search_widget->regex_checkbutton = GTK_TOGGLE_BUTTON(GET_OBJECT("regex_checkbutton"));
+	search_widget->wrap_around_checkbutton = GTK_TOGGLE_BUTTON(GET_OBJECT("wrap_around_checkbutton"));
+	search_widget->reveal_button = GTK_WIDGET(GET_OBJECT("reveal_button"));
+	search_widget->revealer = GTK_WIDGET(GET_OBJECT("revealer"));
+
+	gtk_widget_set_can_default(search_widget->search_next_button, TRUE);
+	gtk_widget_grab_default(search_widget->search_next_button);
+
+	gtk_entry_set_activates_default(GTK_ENTRY(search_widget->search_entry), TRUE);
+
+	/* Connect signals */
+	gtk_builder_connect_signals(search_widget->builder, NULL);
+
+	g_signal_connect_swapped(search_widget->close_button, "clicked", G_CALLBACK(gtk_widget_destroy), GTK_WIDGET(search_widget->window));
+
+	g_object_bind_property(search_widget->reveal_button, "active",
+			       search_widget->revealer, "reveal-child",
+			       G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
+
+	g_signal_connect_swapped(search_widget->search_entry, "next-match", G_CALLBACK(remmina_search_widget_search_forward), gpdata);
+	g_signal_connect_swapped(search_widget->search_entry, "previous-match", G_CALLBACK(remmina_search_widget_search_backward), gpdata);
+	g_signal_connect_swapped(search_widget->search_entry, "search-changed", G_CALLBACK(remmina_search_widget_update_regex), gpdata);
+
+	g_signal_connect_swapped(search_widget->search_next_button, "clicked", G_CALLBACK(remmina_search_widget_search_forward), gpdata);
+	g_signal_connect_swapped(search_widget->search_prev_button, "clicked", G_CALLBACK(remmina_search_widget_search_backward), gpdata);
+
+	g_signal_connect_swapped(search_widget->match_case_checkbutton, "toggled", G_CALLBACK(remmina_search_widget_update_regex), gpdata);
+	g_signal_connect_swapped(search_widget->entire_word_checkbutton, "toggled", G_CALLBACK(remmina_search_widget_update_regex), gpdata);
+	g_signal_connect_swapped(search_widget->regex_checkbutton, "toggled", G_CALLBACK(remmina_search_widget_update_regex), gpdata);
+	g_signal_connect_swapped(search_widget->match_case_checkbutton, "toggled", G_CALLBACK(remmina_search_widget_update_regex), gpdata);
+
+	g_signal_connect(search_widget->wrap_around_checkbutton, "toggled", G_CALLBACK(remmina_search_widget_wrap_around_toggled), gpdata);
+
+	remmina_search_widget_update_sensitivity(search_widget);
+	return search_widget->window;
+}
+
+void remmina_plugin_pop_search(GtkMenuItem *menuitem, RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginSshData *gpdata = GET_PLUGIN_DATA(gp);
+
+	GtkWindow *parent = NULL;
+
+	REMMINA_DEBUG("Before popover");
+	GtkWidget *window = remmina_plugin_pop_search_new(gpdata->vte, gp);
+	GtkWidget *toplevel = gtk_widget_get_toplevel(gpdata->vte);
+
+	if (GTK_IS_WINDOW(toplevel)) {
+		parent = GTK_WINDOW(toplevel);
+		gtk_window_set_transient_for(GTK_WINDOW(window), parent);
+		gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ON_PARENT);
+	}
+	gtk_widget_show(window);
+	REMMINA_DEBUG("After popover");
+}
+
+void remmina_plugin_ssh_call_sftp(GtkMenuItem *menuitem, RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	remmina_protocol_widget_call_feature_by_type(gp, REMMINA_PROTOCOL_FEATURE_TYPE_TOOL, REMMINA_PROTOCOL_FEATURE_TOOL_SFTP);
+}
+
+gboolean
+remmina_ssh_plugin_popup_menu(GtkWidget *widget, GdkEvent *event, GtkWidget *menu)
+{
+	if ((event->type == GDK_BUTTON_PRESS) && (((GdkEventButton *)event)->button == 3)) {
+#if GTK_CHECK_VERSION(3, 22, 0)
+		gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+#else
+		gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
+			       ((GdkEventButton *)event)->button, gtk_get_current_event_time());
+#endif
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+/**
+ * Remmina SSH plugin terminal popup menu.
+ *
+ * This is the context menu that popup when you right click in a terminal window.
+ * You can than select, copy, paste text and save the whole buffer to a file.
+ * Each menu entry call back the following functions:
+ * - remmina_plugin_ssh_vte_select_all()
+ * - remmina_plugin_ssh_vte_copy_clipboard()
+ * - remmina_plugin_ssh_vte_paste_clipboard()
+ * - remmina_plugin_ssh_vte_save_session()
+ * .
+ *
+ */
+void remmina_plugin_ssh_popup_ui(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginSshData *gpdata = GET_PLUGIN_DATA(gp);
+	/* Context menu for slection and clipboard */
+	GtkWidget *menu = gtk_menu_new();
+
+	GtkWidget *select_all = gtk_menu_item_new_with_label(_("Select All (host+A)"));
+	GtkWidget *copy = gtk_menu_item_new_with_label(_("Copy (host+C)"));
+	GtkWidget *paste = gtk_menu_item_new_with_label(_("Paste (host+V)"));
+	GtkWidget *save = gtk_menu_item_new_with_label(_("Save session to file"));
+	GtkWidget *font_incr = gtk_menu_item_new_with_label(_("Increase font size (host+Page Up)"));
+	GtkWidget *font_decr = gtk_menu_item_new_with_label(_("Decrease font size (host+Page Down)"));
+	GtkWidget *find_text = gtk_menu_item_new_with_label(_("Find text (host+G)"));
+	GtkWidget *sftp = gtk_menu_item_new_with_label(_("Open SFTP transfer…"));
+
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), select_all);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), copy);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), paste);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), save);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), font_incr);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), font_decr);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), find_text);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu), sftp);
+
+	g_signal_connect(G_OBJECT(gpdata->vte), "button_press_event",
+			 G_CALLBACK(remmina_ssh_plugin_popup_menu), menu);
+
+	g_signal_connect(G_OBJECT(select_all), "activate",
+			 G_CALLBACK(remmina_plugin_ssh_vte_select_all), gpdata->vte);
+	g_signal_connect(G_OBJECT(copy), "activate",
+			 G_CALLBACK(remmina_plugin_ssh_vte_copy_clipboard), gpdata->vte);
+	g_signal_connect(G_OBJECT(paste), "activate",
+			 G_CALLBACK(remmina_plugin_ssh_vte_paste_clipboard), gpdata->vte);
+	g_signal_connect(G_OBJECT(save), "activate",
+			 G_CALLBACK(remmina_plugin_ssh_vte_save_session), gp);
+	g_signal_connect(G_OBJECT(font_incr), "activate",
+			 G_CALLBACK(remmina_plugin_ssh_vte_increase_font), gpdata->vte);
+	g_signal_connect(G_OBJECT(font_decr), "activate",
+			 G_CALLBACK(remmina_plugin_ssh_vte_decrease_font), gpdata->vte);
+	g_signal_connect(G_OBJECT(find_text), "activate",
+			 G_CALLBACK(remmina_plugin_pop_search), gp);
+	g_signal_connect(G_OBJECT(sftp), "activate",
+			 G_CALLBACK(remmina_plugin_ssh_call_sftp), gp);
+
+	gtk_widget_show_all(menu);
+}
+
+static void
+remmina_plugin_ssh_eof(VteTerminal *vteterminal, RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+
+	RemminaFile *remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+	RemminaPluginSshData *gpdata = GET_PLUGIN_DATA(gp);
+
+	if (gpdata->closed)
+		return;
+
+	if (remmina_file_get_int(remminafile, "sshlogenabled", FALSE))
+		remmina_plugin_ssh_vte_save_session(NULL, gp);
+
+	gchar *server;
+	gint port;
+	remmina_plugin_service->get_server_port(remmina_plugin_service->file_get_string(remminafile, "server"),
+			22,
+			&server,
+			&port);
+
+	REMMINA_AUDIT(_("Disconnected from %s:%d via SSH"), server, port);
+	g_free(server), server = NULL;
+	gpdata->closed = TRUE;
+}
+
+static gboolean
+remmina_plugin_ssh_close_connection(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginSshData *gpdata = GET_PLUGIN_DATA(gp);
+
+	RemminaFile *remminafile;
+
+	REMMINA_DEBUG("Requesting to close the connection");
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+
+	if (remmina_file_get_int(remminafile, "sshlogenabled", FALSE))
+		remmina_plugin_ssh_vte_save_session(NULL, gp);
+	remmina_plugin_ssh_eof(VTE_TERMINAL(gpdata->vte), gp);
+
+	if (gpdata->thread) {
+		pthread_cancel(gpdata->thread);
+		if (gpdata->thread) pthread_join(gpdata->thread, NULL);
+	}
+	if (gpdata->shell) {
+		remmina_ssh_shell_free(gpdata->shell);
+		gpdata->shell = NULL;
+	}
+
+	remmina_plugin_service->protocol_plugin_signal_connection_closed(gp);
+	return FALSE;
+}
+
+/**
+ * Remmina SSH plugin initialization.
+ *
+ * This is the main function used to create the widget that will be embedded in the
+ * Remmina Connection Window.
+ * Initialize the terminal colours based on the user, everything is needed for the
+ * terminal window, the terminal session logging and the terminal popup menu.
+ *
+ * @see remmina_plugin_ssh_popup_ui
+ * @see RemminaProtocolWidget
+ * @see https://gitlab.com/Remmina/Remmina/wikis/Remmina-SSH-Terminal-colour-schemes
+ */
+static void
+remmina_plugin_ssh_init(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginSshData *gpdata;
+	RemminaFile *remminafile;
+	GtkWidget *hbox;
+	GtkAdjustment *vadjustment;
+	GtkWidget *vscrollbar;
+	GtkWidget *vte;
+	GdkRGBA foreground_color;
+	GdkRGBA background_color;
+	GdkRGBA palette[PALETTE_SIZE];
+
+
+#if !VTE_CHECK_VERSION(0, 38, 0)
+	GdkColor foreground_gdkcolor;
+	GdkColor background_gdkcolor;
+#endif  /* VTE_CHECK_VERSION(0,38,0) */
+
+	gpdata = g_new0(RemminaPluginSshData, 1);
+	g_object_set_data_full(G_OBJECT(gp), "plugin-data", gpdata, g_free);
+
+	gpdata->closed = FALSE;
+
+	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+	gtk_widget_show(hbox);
+	gtk_container_add(GTK_CONTAINER(gp), hbox);
+	g_signal_connect(G_OBJECT(hbox), "focus-in-event", G_CALLBACK(remmina_plugin_ssh_on_focus_in), gp);
+
+	vte = vte_terminal_new();
+	//gtk_widget_show(vte);
+	vte_terminal_set_size(VTE_TERMINAL(vte), 80, 25);
+	vte_terminal_set_scroll_on_keystroke(VTE_TERMINAL(vte), TRUE);
+#if !VTE_CHECK_VERSION(0, 38, 0)
+	gdk_rgba_parse(&foreground_color, remmina_pref.color_pref.foreground);
+	gdk_rgba_parse(&background_color, remmina_pref.color_pref.background);
+#endif
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+
+
+#if VTE_CHECK_VERSION(0, 38, 0)
+	GdkRGBA cp[PALETTE_SIZE];
+	GdkRGBA cursor_color;
+	GdkRGBA cursor_foreground;
+	GdkRGBA highlight;
+	GdkRGBA highlight_foreground;
+	GdkRGBA colorBD;
+	unsigned int i = 0;
+
+	/*
+	 * custom colors reside inside of the 'theme' subdir of the remmina config folder (.config/remmina/theme)
+	 * with the file extension '.colors'. The name of the colorfile came from the menu (see below)
+	 * sideeffect: It is possible to overwrite the standard colours with a dedicated colourfile like
+	 * '0.colors' for GRUVBOX, '1.colors' for TANGO and so on
+	 */
+	const gchar *color_name = remmina_plugin_service->file_get_string(remminafile, "ssh_color_scheme");
+
+	gchar *remmina_dir = g_build_path("/", g_get_user_config_dir(), "remmina", "theme", NULL);
+	gchar *remmina_colors_file = g_strdup_printf("%s/%s.colors", remmina_dir, color_name);
+	g_free(remmina_dir);
+
+	/*
+	 * try to load theme from one of the system data dirs (based on XDG_DATA_DIRS environment var)
+	 */
+	if (!g_file_test(remmina_colors_file, G_FILE_TEST_IS_REGULAR)) {
+		GError *error = NULL;
+		const gchar *const *dirs = g_get_system_data_dirs();
+
+		for (i = 0; dirs[i] != NULL; ++i) {
+			remmina_dir = g_build_path("/", dirs[i], "remmina", "theme", NULL);
+			GDir *system_data_dir = g_dir_open(remmina_dir, 0, &error);
+			// ignoring this error is OK, because the folder may not exist
+			if (error) {
+				g_error_free(error);
+				error = NULL;
+			} else {
+				if (system_data_dir) {
+					g_dir_close(system_data_dir);
+					g_free(remmina_colors_file);
+					remmina_colors_file = g_strdup_printf("%s/%s.colors", remmina_dir, color_name);
+					if (g_file_test(remmina_colors_file, G_FILE_TEST_IS_REGULAR))
+						break;
+				}
+			}
+			g_free(remmina_dir);
+		}
+	}
+
+	if (g_file_test(remmina_colors_file, G_FILE_TEST_IS_REGULAR)) {
+		GKeyFile *gkeyfile;
+		RemminaColorPref color_pref;
+
+		gkeyfile = g_key_file_new();
+		g_key_file_load_from_file(gkeyfile, remmina_colors_file, G_KEY_FILE_NONE, NULL);
+		remmina_pref_file_load_colors(gkeyfile, &color_pref);
+
+		REMMINA_DEBUG("Load custom theme for SSH teminal");
+		g_warn_if_fail(gdk_rgba_parse(&foreground_color, color_pref.foreground));
+		g_warn_if_fail(gdk_rgba_parse(&background_color, color_pref.background));
+		g_warn_if_fail(gdk_rgba_parse(&cursor_color, color_pref.cursor));
+		g_warn_if_fail(gdk_rgba_parse(&cursor_foreground, color_pref.cursor_foreground));
+		g_warn_if_fail(gdk_rgba_parse(&highlight, color_pref.highlight));
+		g_warn_if_fail(gdk_rgba_parse(&highlight_foreground, color_pref.highlight_foreground));
+		g_warn_if_fail(gdk_rgba_parse(&colorBD, color_pref.colorBD));
+
+		g_warn_if_fail(gdk_rgba_parse(&cp[0], color_pref.color0));
+		g_warn_if_fail(gdk_rgba_parse(&cp[1], color_pref.color1));
+		g_warn_if_fail(gdk_rgba_parse(&cp[2], color_pref.color2));
+		g_warn_if_fail(gdk_rgba_parse(&cp[3], color_pref.color3));
+		g_warn_if_fail(gdk_rgba_parse(&cp[4], color_pref.color4));
+		g_warn_if_fail(gdk_rgba_parse(&cp[5], color_pref.color5));
+		g_warn_if_fail(gdk_rgba_parse(&cp[6], color_pref.color6));
+		g_warn_if_fail(gdk_rgba_parse(&cp[7], color_pref.color7));
+		g_warn_if_fail(gdk_rgba_parse(&cp[8], color_pref.color8));
+		g_warn_if_fail(gdk_rgba_parse(&cp[9], color_pref.color9));
+		g_warn_if_fail(gdk_rgba_parse(&cp[10], color_pref.color10));
+		g_warn_if_fail(gdk_rgba_parse(&cp[11], color_pref.color11));
+		g_warn_if_fail(gdk_rgba_parse(&cp[12], color_pref.color12));
+		g_warn_if_fail(gdk_rgba_parse(&cp[13], color_pref.color13));
+		g_warn_if_fail(gdk_rgba_parse(&cp[14], color_pref.color14));
+		g_warn_if_fail(gdk_rgba_parse(&cp[15], color_pref.color15));
+
+		const GdkRGBA custom_palette[PALETTE_SIZE] = {
+			cp[0],	cp[1],	cp[2],	cp[3],
+			cp[4],	cp[5],	cp[6],	cp[7],
+			cp[8],	cp[9],	cp[10], cp[11],
+			cp[12], cp[13], cp[14], cp[15]
+		};
+
+		for (i = 0; i < PALETTE_SIZE; i++)
+			palette[i] = custom_palette[i];
+	} else {
+		/* Set colors to GdkRGBA */
+		switch (remmina_plugin_service->file_get_int(remminafile, "ssh_color_scheme", FALSE)) {
+		case LINUX:
+			gdk_rgba_parse(&foreground_color, "#ffffff");
+			gdk_rgba_parse(&background_color, "#000000");
+			gdk_rgba_parse(&cursor_color, "#ffffff");
+			gdk_rgba_parse(&cursor_foreground, "#00000");
+			gdk_rgba_parse(&highlight, "#ffffff");
+			gdk_rgba_parse(&highlight_foreground, "#00000");
+			gdk_rgba_parse(&colorBD, "#ffffff");
+			for (i = 0; i < PALETTE_SIZE; i++)
+				palette[i] = linux_palette[i];
+			break;
+		case TANGO:
+			gdk_rgba_parse(&foreground_color, "#ffffff");
+			gdk_rgba_parse(&background_color, "#000000");
+			gdk_rgba_parse(&cursor_color, "#000000");
+			gdk_rgba_parse(&cursor_foreground, "#ffffff");
+			gdk_rgba_parse(&highlight, "#ffffff");
+			gdk_rgba_parse(&highlight_foreground, "#00000");
+			gdk_rgba_parse(&colorBD, "#000000");
+			for (i = 0; i < PALETTE_SIZE; i++)
+				palette[i] = tango_palette[i];
+			break;
+		case GRUVBOX:
+			gdk_rgba_parse(&foreground_color, "#e6d4a3");
+			gdk_rgba_parse(&background_color, "#1e1e1e");
+			gdk_rgba_parse(&cursor_color, "#e6d4a3");
+			gdk_rgba_parse(&cursor_foreground, "#e6d4a3");
+			gdk_rgba_parse(&highlight, "#e6d4a3");
+			gdk_rgba_parse(&highlight_foreground, "#1e1e1e");
+			gdk_rgba_parse(&colorBD, "#ffffff");
+			for (i = 0; i < PALETTE_SIZE; i++)
+				palette[i] = gruvbox_palette[i];
+			break;
+		case SOLARIZED_DARK:
+			gdk_rgba_parse(&foreground_color, "#839496");
+			gdk_rgba_parse(&background_color, "#002b36");
+			gdk_rgba_parse(&cursor_color, "#93a1a1");
+			gdk_rgba_parse(&cursor_foreground, "#839496");
+			gdk_rgba_parse(&highlight, "#839496");
+			gdk_rgba_parse(&highlight_foreground, "#002b36");
+			gdk_rgba_parse(&colorBD, "#819090");
+			for (i = 0; i < PALETTE_SIZE; i++)
+				palette[i] = solarized_dark_palette[i];
+			break;
+		case SOLARIZED_LIGHT:
+			gdk_rgba_parse(&foreground_color, "#657b83");
+			gdk_rgba_parse(&background_color, "#fdf6e3");
+			gdk_rgba_parse(&cursor_color, "#586e75");
+			gdk_rgba_parse(&cursor_foreground, "#657b83");
+			gdk_rgba_parse(&highlight, "#657b83");
+			gdk_rgba_parse(&highlight_foreground, "#fdf6e3");
+			gdk_rgba_parse(&colorBD, "#475b62");
+			for (i = 0; i < PALETTE_SIZE; i++)
+				palette[i] = solarized_light_palette[i];
+			break;
+		case XTERM:
+			gdk_rgba_parse(&foreground_color, "#000000");
+			gdk_rgba_parse(&background_color, "#ffffff");
+			gdk_rgba_parse(&cursor_color, "#000000");
+			gdk_rgba_parse(&cursor_foreground, "#ffffff");
+			gdk_rgba_parse(&highlight, "#000000");
+			gdk_rgba_parse(&highlight_foreground, "#ffffff");
+			gdk_rgba_parse(&colorBD, "#000000");
+			for (i = 0; i < PALETTE_SIZE; i++)
+				palette[i] = xterm_palette[i];
+			break;
+		case CUSTOM:
+			REMMINA_DEBUG("Custom colors");
+			g_warn_if_fail(gdk_rgba_parse(&foreground_color, remmina_pref.color_pref.foreground));
+			g_warn_if_fail(gdk_rgba_parse(&background_color, remmina_pref.color_pref.background));
+			g_warn_if_fail(gdk_rgba_parse(&cursor_color, remmina_pref.color_pref.cursor));
+			g_warn_if_fail(gdk_rgba_parse(&cursor_foreground, remmina_pref.color_pref.cursor_foreground));
+			g_warn_if_fail(gdk_rgba_parse(&highlight, remmina_pref.color_pref.highlight));
+			g_warn_if_fail(gdk_rgba_parse(&highlight_foreground, remmina_pref.color_pref.highlight_foreground));
+			g_warn_if_fail(gdk_rgba_parse(&colorBD, remmina_pref.color_pref.colorBD));
+
+			g_warn_if_fail(gdk_rgba_parse(&cp[0], remmina_pref.color_pref.color0));
+			g_warn_if_fail(gdk_rgba_parse(&cp[1], remmina_pref.color_pref.color1));
+			g_warn_if_fail(gdk_rgba_parse(&cp[2], remmina_pref.color_pref.color2));
+			g_warn_if_fail(gdk_rgba_parse(&cp[3], remmina_pref.color_pref.color3));
+			g_warn_if_fail(gdk_rgba_parse(&cp[4], remmina_pref.color_pref.color4));
+			g_warn_if_fail(gdk_rgba_parse(&cp[5], remmina_pref.color_pref.color5));
+			g_warn_if_fail(gdk_rgba_parse(&cp[6], remmina_pref.color_pref.color6));
+			g_warn_if_fail(gdk_rgba_parse(&cp[7], remmina_pref.color_pref.color7));
+			g_warn_if_fail(gdk_rgba_parse(&cp[8], remmina_pref.color_pref.color8));
+			g_warn_if_fail(gdk_rgba_parse(&cp[9], remmina_pref.color_pref.color9));
+			g_warn_if_fail(gdk_rgba_parse(&cp[10], remmina_pref.color_pref.color10));
+			g_warn_if_fail(gdk_rgba_parse(&cp[11], remmina_pref.color_pref.color11));
+			g_warn_if_fail(gdk_rgba_parse(&cp[12], remmina_pref.color_pref.color12));
+			g_warn_if_fail(gdk_rgba_parse(&cp[13], remmina_pref.color_pref.color13));
+			g_warn_if_fail(gdk_rgba_parse(&cp[14], remmina_pref.color_pref.color14));
+			g_warn_if_fail(gdk_rgba_parse(&cp[15], remmina_pref.color_pref.color15));
+
+			const GdkRGBA custom_palette[PALETTE_SIZE] = {
+				cp[0],          //  remmina_pref.color_pref.color0
+				cp[1],          //  remmina_pref.color_pref.color1
+				cp[2],          //  remmina_pref.color_pref.color2
+				cp[3],          //  remmina_pref.color_pref.color3
+				cp[4],          //  remmina_pref.color_pref.color4
+				cp[5],          //  remmina_pref.color_pref.color5
+				cp[6],          //  remmina_pref.color_pref.color6
+				cp[7],          //  remmina_pref.color_pref.color7
+				cp[8],          //  remmina_pref.color_pref.color8
+				cp[9],          //  remmina_pref.color_pref.color9
+				cp[10],         //  remmina_pref.color_pref.color10
+				cp[11],         //  remmina_pref.color_pref.color11
+				cp[12],         //  remmina_pref.color_pref.color12
+				cp[13],         //  remmina_pref.color_pref.color13
+				cp[14],         //  remmina_pref.color_pref.color14
+				cp[15]          //  remmina_pref.color_pref.color15
+			};
+
+			for (i = 0; i < PALETTE_SIZE; i++)
+				palette[i] = custom_palette[i];
+			break;
+		default:
+			REMMINA_DEBUG("Linux paelette colors");
+			for (i = 0; i < PALETTE_SIZE; i++)
+				palette[i] = linux_palette[i];
+			break;
+		}
+	}
+	g_free(remmina_colors_file);
+	REMMINA_DEBUG("foreground_color.red %f, background_color.red %f", foreground_color.red, background_color.red);
+	REMMINA_DEBUG("foreground_color.blue %f, background_color.blue %f", foreground_color.blue, background_color.blue);
+	REMMINA_DEBUG("foreground_color.green %f, background_color.green %f", foreground_color.green, background_color.green);
+	REMMINA_DEBUG("foreground_color.alpha %f, background_color.alpha %f", foreground_color.alpha, background_color.alpha);
+	for (i = 0; i < PALETTE_SIZE; i++) {
+		REMMINA_DEBUG("index: %d, palette validation for red: %f", i, palette[i].red);
+		REMMINA_DEBUG("index: %d, palette validation for green: %f", i, palette[i].green);
+		REMMINA_DEBUG("index: %d, palette validation for blue: %f", i, palette[i].blue);
+		REMMINA_DEBUG("index: %d, palette validation for alpha: %f", i, palette[i].alpha);
+		g_warn_if_fail(valid_color(&palette[i]));
+	}
+	vte_terminal_set_colors(VTE_TERMINAL(vte), &foreground_color, &background_color, palette, PALETTE_SIZE);
+	vte_terminal_set_color_foreground(VTE_TERMINAL(vte), &foreground_color);
+	vte_terminal_set_color_background(VTE_TERMINAL(vte), &background_color);
+	vte_terminal_set_color_cursor(VTE_TERMINAL(vte), &cursor_color);
+	vte_terminal_set_color_cursor_foreground(VTE_TERMINAL(vte), &cursor_foreground);
+	vte_terminal_set_color_highlight(VTE_TERMINAL(vte), &highlight);
+	vte_terminal_set_color_highlight_foreground(VTE_TERMINAL(vte), &highlight_foreground);
+	vte_terminal_set_color_bold(VTE_TERMINAL(vte), &colorBD);
+
+#else
+	/* VTE <= 2.90 doesn’t support GdkRGBA so we must convert GdkRGBA to GdkColor */
+	foreground_gdkcolor.red = (guint16)(foreground_color.red * 0xFFFF);
+	foreground_gdkcolor.green = (guint16)(foreground_color.green * 0xFFFF);
+	foreground_gdkcolor.blue = (guint16)(foreground_color.blue * 0xFFFF);
+	background_gdkcolor.red = (guint16)(background_color.red * 0xFFFF);
+	background_gdkcolor.green = (guint16)(background_color.green * 0xFFFF);
+	background_gdkcolor.blue = (guint16)(background_color.blue * 0xFFFF);
+	/* Set colors to GdkColor */
+	vte_terminal_set_colors(VTE_TERMINAL(vte), &foreground_gdkcolor, &background_gdkcolor, NULL, 0);
+#endif
+
+	gtk_box_pack_start(GTK_BOX(hbox), vte, TRUE, TRUE, 0);
+	gpdata->vte = vte;
+	remmina_plugin_ssh_set_vte_pref(gp);
+
+	remmina_plugin_service->protocol_plugin_register_hostkey(gp, vte);
+
+#if VTE_CHECK_VERSION(0, 28, 0)
+	vadjustment = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(vte));
+#else
+	vadjustment = vte_terminal_get_adjustment(VTE_TERMINAL(vc->vte.terminal));
+#endif
+
+	vscrollbar = gtk_scrollbar_new(GTK_ORIENTATION_VERTICAL, vadjustment);
+
+	gtk_widget_show(vscrollbar);
+	gtk_box_pack_start(GTK_BOX(hbox), vscrollbar, FALSE, TRUE, 0);
+
+	const gchar *dir;
+	const gchar *sshlogname;
+	gchar *fp;
+
+	GFile *rf = g_file_new_for_path(remminafile->filename);
+
+	if (remmina_plugin_service->file_get_string(remminafile, "sshlogfolder") == NULL)
+		dir = g_build_path("/", g_get_user_cache_dir(), "remmina", NULL);
+	else
+		dir = remmina_plugin_service->file_get_string(remminafile, "sshlogfolder");
+
+	if (remmina_plugin_service->file_get_string(remminafile, "sshlogname") == NULL)
+		sshlogname = g_strconcat(g_file_get_basename(rf), ".", "log", NULL);
+	else
+		sshlogname = remmina_plugin_service->file_get_string(remminafile, "sshlogname");
+
+	sshlogname = remmina_file_format_properties(remminafile, sshlogname);
+
+	fp = g_strconcat(dir, "/", sshlogname, NULL);
+	g_free((gpointer) sshlogname);
+
+	gpdata->vte_session_file = g_file_new_for_path(fp);
+	g_free(fp);
+
+	g_signal_connect(G_OBJECT(vte), "size-allocate", G_CALLBACK(remmina_plugin_ssh_on_size_allocate), gp);
+	g_signal_connect(G_OBJECT(vte), "unrealize", G_CALLBACK(remmina_plugin_ssh_eof), gp);
+	g_signal_connect(G_OBJECT(vte), "eof", G_CALLBACK(remmina_plugin_ssh_eof), gp);
+	g_signal_connect(G_OBJECT(vte), "child-exited", G_CALLBACK(remmina_plugin_ssh_eof), gp);
+	remmina_plugin_ssh_popup_ui(gp);
+	gtk_widget_show_all(hbox);
+}
+
+/**
+ * Initialize the main window properties and the pthread.
+ *
+ * The call of this function is a requirement of remmina_protocol_widget_open_connection_real().
+ * @return TRUE
+ * @return FALSE and remmina_protocol_widget_open_connection_real() will fails.
+ */
+static gboolean
+remmina_plugin_ssh_open_connection(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginSshData *gpdata = GET_PLUGIN_DATA(gp);
+
+	remmina_plugin_service->protocol_plugin_set_expand(gp, TRUE);
+	remmina_plugin_service->protocol_plugin_set_width(gp, 640);
+	remmina_plugin_service->protocol_plugin_set_height(gp, 480);
+
+	if (pthread_create(&gpdata->thread, NULL, remmina_plugin_ssh_main_thread, gp)) {
+		remmina_plugin_service->protocol_plugin_set_error(gp,
+								  "Failed to initialize pthread. Falling back to non-thread mode…");
+		gpdata->thread = 0;
+		return FALSE;
+	} else {
+		return TRUE;
+	}
+	return TRUE;
+}
+
+/**
+ * Not used by the plugin.
+ *
+ * @return Always TRUE
+ */
+static gboolean
+remmina_plugin_ssh_query_feature(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature)
+{
+	TRACE_CALL(__func__);
+	return TRUE;
+}
+
+/**
+ * Functions to call when an entry in the Tool menu in the Remmina Connection Window is clicked.
+ *
+ * In the Remmina Connection Window toolbar, there is a tool menu, this function is used to
+ * call the right function for each entry with its parameters.
+ *
+ * At the moment it’s possible to:
+ * - Open a new SSH session.
+ * - Open an SFTP session.
+ * - Select, copy and paste text.
+ * - Send recorded Key Strokes.
+ * .
+ *
+ * @return the return value of the calling function.
+ *
+ */
+static void
+remmina_plugin_ssh_call_feature(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginSshData *gpdata = GET_PLUGIN_DATA(gp);
+
+	switch (feature->id) {
+	case REMMINA_PROTOCOL_FEATURE_TOOL_SSH:
+		remmina_plugin_service->open_connection(
+			remmina_file_dup_temp_protocol(remmina_plugin_service->protocol_plugin_get_file(gp), "SSH"),
+			NULL, gpdata->shell, NULL);
+		return;
+	case REMMINA_PROTOCOL_FEATURE_TOOL_SFTP:
+		remmina_plugin_service->open_connection(
+			/** @todo start the direct tunnel here */
+			remmina_file_dup_temp_protocol(remmina_plugin_service->protocol_plugin_get_file(gp), "SFTP"),
+			NULL, gpdata->shell, NULL);
+		return;
+	case REMMINA_PLUGIN_SSH_FEATURE_TOOL_COPY:
+#if VTE_CHECK_VERSION(0, 50, 0)
+		vte_terminal_copy_clipboard_format(VTE_TERMINAL(gpdata->vte), VTE_FORMAT_TEXT);
+#else
+		vte_terminal_copy_clipboard(VTE_TERMINAL(gpdata->vte));
+#endif
+		return;
+	case REMMINA_PLUGIN_SSH_FEATURE_TOOL_PASTE:
+		vte_terminal_paste_clipboard(VTE_TERMINAL(gpdata->vte));
+		return;
+	case REMMINA_PLUGIN_SSH_FEATURE_TOOL_SELECT_ALL:
+		vte_terminal_select_all(VTE_TERMINAL(gpdata->vte));
+		return;
+	case REMMINA_PLUGIN_SSH_FEATURE_TOOL_INCREASE_FONT:
+		vte_terminal_set_font_scale(VTE_TERMINAL(gpdata->vte),
+					    vte_terminal_get_font_scale(VTE_TERMINAL(gpdata->vte)) + SCALE_FACTOR);
+		return;
+	case REMMINA_PLUGIN_SSH_FEATURE_TOOL_DECREASE_FONT:
+		vte_terminal_set_font_scale(VTE_TERMINAL(gpdata->vte),
+					    vte_terminal_get_font_scale(VTE_TERMINAL(gpdata->vte)) - SCALE_FACTOR);
+		return;
+	case REMMINA_PLUGIN_SSH_FEATURE_TOOL_SEARCH:
+		remmina_plugin_pop_search(NULL, gp);
+		return;
+	}
+}
+
+/** Array of key/value pairs for SSH auth type
+ * libssh methods:
+ *
+ * #define SSH_AUTH_METHOD_UNKNOWN     0x0000u
+ * #define SSH_AUTH_METHOD_NONE        0x0001u
+ * #define SSH_AUTH_METHOD_PASSWORD    0x0002u
+ * #define SSH_AUTH_METHOD_PUBLICKEY   0x0004u
+ * #define SSH_AUTH_METHOD_HOSTBASED   0x0008u
+ * #define SSH_AUTH_METHOD_INTERACTIVE 0x0010u
+ * #define SSH_AUTH_METHOD_GSSAPI_MIC  0x0020u
+ */
+static gpointer ssh_auth[] =
+{
+	"0", N_("Password"),
+	"1", N_("SSH identity file"),
+	"2", N_("SSH agent"),
+	"3", N_("Public key (automatic)"),
+	"4", N_("Kerberos (GSSAPI)"),
+	NULL
+};
+
+/** Charset list */
+static gpointer ssh_charset_list[] =
+{
+	"", "",
+	"", "ASCII",
+	"", "BIG5",
+	"", "CP437",
+	"", "CP720",
+	"", "CP737",
+	"", "CP775",
+	"", "CP850",
+	"", "CP852",
+	"", "CP855",
+	"", "CP857",
+	"", "CP858",
+	"", "CP862",
+	"", "CP866",
+	"", "CP874",
+	"", "CP1125",
+	"", "CP1250",
+	"", "CP1251",
+	"", "CP1252",
+	"", "CP1253",
+	"", "CP1254",
+	"", "CP1255",
+	"", "CP1256",
+	"", "CP1257",
+	"", "CP1258",
+	"", "EUC-JP",
+	"", "EUC-KR",
+	"", "GBK",
+	"", "ISO 8859-1",
+	"", "ISO 8859-2",
+	"", "ISO 8859-3",
+	"", "ISO 8859-4",
+	"", "ISO 8859-5",
+	"", "ISO 8859-6",
+	"", "ISO 8859-7",
+	"", "ISO 8859-8",
+	"", "ISO 8859-9",
+	"", "ISO 8859-10",
+	"", "ISO 8859-11",
+	"", "ISO 8859-12",
+	"", "ISO 8859-13",
+	"", "ISO 8859-14",
+	"", "ISO 8859-15",
+	"", "ISO 8859-16",
+	"", "KOI8-R",
+	"", "SJIS",
+	"", "UTF-8",
+	NULL
+};
+
+static gpointer ssh_terminal_palette[] =
+{
+	"0",  "Linux",
+	"1",  "Tango",
+	"2",  "Gruvbox",
+	"3",  "Solarized Dark",
+	"4",  "Solarized Light",
+	"5",  "XTerm",
+	"6",  "Custom (Configured in Remmina preferences)",
+	NULL, NULL
+};
+
+/**
+ * Array for available features.
+ * The last element of the array must be REMMINA_PROTOCOL_FEATURE_TYPE_END.
+ */
+static RemminaProtocolFeature remmina_plugin_ssh_features[] =
+{
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_TOOL, REMMINA_PLUGIN_SSH_FEATURE_TOOL_COPY,	     N_("Copy"),		N_("_Copy"),		   NULL },
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_TOOL, REMMINA_PLUGIN_SSH_FEATURE_TOOL_PASTE,	     N_("Paste"),		N_("_Paste"),		   NULL },
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_TOOL, REMMINA_PLUGIN_SSH_FEATURE_TOOL_SELECT_ALL,    N_("Select all"),		N_("_Select all"),	   NULL },
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_TOOL, REMMINA_PLUGIN_SSH_FEATURE_TOOL_INCREASE_FONT, N_("Increase font size"),	N_("_Increase font size"), NULL },
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_TOOL, REMMINA_PLUGIN_SSH_FEATURE_TOOL_DECREASE_FONT, N_("Decrease font size"),	N_("_Decrease font size"), NULL },
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_TOOL, REMMINA_PLUGIN_SSH_FEATURE_TOOL_SEARCH,	     N_("Find text"),		N_("_Find text"),	   NULL },
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_TOOL, REMMINA_PROTOCOL_FEATURE_TOOL_SFTP,	     N_("Open SFTP transfer…"), "folder-remote",	   NULL },
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_END,  0,					     NULL,			NULL,			   NULL }
+};
+
+/* Array of RemminaProtocolSetting for basic settings.
+ * Each item is composed by:
+ * a) RemminaProtocolSettingType for setting type
+ * b) Setting name
+ * c) Setting description
+ * d) Compact disposition
+ * e) Values for REMMINA_PROTOCOL_SETTING_TYPE_SELECT or REMMINA_PROTOCOL_SETTING_TYPE_COMBO
+ * f) Setting tooltip
+ * g) Validation data pointer, will be passed to the validation callback method.
+ * h) Validation callback method (Can be NULL. Every entry will be valid then.)
+ *		use following prototype:
+ *		gboolean mysetting_validator_method(gpointer key, gpointer value,
+ *						    gpointer validator_data);
+ *		gpointer key is a gchar* containing the setting's name,
+ *		gpointer value contains the value which should be validated,
+ *		gpointer validator_data contains your passed data.
+ */
+static const RemminaProtocolSetting remmina_ssh_basic_settings[] =
+{
+	{ REMMINA_PROTOCOL_SETTING_TYPE_SERVER,	  "server",	    NULL,				  FALSE, "_ssh._tcp", NULL, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_SELECT,	  "ssh_auth",	    N_("Authentication type"),		  FALSE, ssh_auth,    NULL, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_TEXT,	  "username",	    N_("Username"),			  FALSE, NULL,	      NULL, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_PASSWORD, "password",	    N_("User password"),		  FALSE, NULL,	      NULL, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_FILE,	  "ssh_privatekey", N_("SSH identity file"),		  FALSE, NULL,	      NULL, NULL, NULL },
+#if LIBSSH_VERSION_INT >= SSH_VERSION_INT(0, 9, 0)
+	{ REMMINA_PROTOCOL_SETTING_TYPE_FILE,	  "ssh_certfile",   N_("SSH certificate file"),		  FALSE, NULL,	      NULL, NULL, NULL },
+#endif
+	{ REMMINA_PROTOCOL_SETTING_TYPE_PASSWORD, "ssh_passphrase", N_("Password to unlock private key"), FALSE, NULL,	      NULL, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_TEXT,	  "run_line",	    N_("Opening command"),		  FALSE, NULL,	      NULL, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_TEXT,	  "exec",	    N_("Start-up background program"),		  FALSE, NULL,	      NULL, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_END,	  NULL,		    NULL,				  FALSE, NULL,	      NULL, NULL, NULL }
+};
+
+static gchar log_tips[] =
+	N_("The filename can use the following placeholders:\n\n"
+	   "  • %h is substituted with the server name\n"
+	   "  • %t is substituted with the SSH server name\n"
+	   "  • %u is substituted with the username\n"
+	   "  • %U is substituted with the SSH username\n"
+	   "  • %p is substituted with Remmina profile name\n"
+	   "  • %g is substituted with Remmina profile group name\n"
+	   "  • %d is substituted with local date and time in ISO 8601 format\n");
+
+/**
+ * Array of RemminaProtocolSetting for advanced settings.
+ * - Each item is composed by:
+ *  1. RemminaProtocolSettingType for setting type.
+ *  2. Setting name.
+ *  3. Setting description.
+ *  4. Compact disposition.
+ *  5. Values for REMMINA_PROTOCOL_SETTING_TYPE_SELECT or REMMINA_PROTOCOL_SETTING_TYPE_COMBO.
+ *  6. Setting Tooltip.
+ *
+ */
+static const RemminaProtocolSetting remmina_ssh_advanced_settings[] =
+{
+	{ REMMINA_PROTOCOL_SETTING_TYPE_SELECT, "ssh_color_scheme",	  N_("Terminal colour scheme"),		      FALSE, ssh_terminal_palette, NULL										 },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_SELECT, "ssh_charset",		  N_("Character set"),			      FALSE, ssh_charset_list,	   NULL										 },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_TEXT,	"ssh_proxycommand",	  N_("SSH Proxy Command"),		      FALSE, NULL,		   NULL										 },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_TEXT,	"ssh_kex_algorithms",	  N_("KEX (Key Exchange) algorithms"),	      FALSE, NULL,		   NULL										 },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_TEXT,	"ssh_ciphers",		  N_("Symmetric cipher client to server"),    FALSE, NULL,		   NULL										 },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_TEXT,	"ssh_hostkeytypes",	  N_("Preferred server host key types"),      FALSE, NULL,		   NULL										 },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_TEXT,   "sshlogfolder",		  N_("Folder for SSH session log"),	      FALSE, NULL,		   N_("Full path of an existing folder")					 },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_TEXT,	"sshlogname",		  N_("Filename for SSH session log"),	      FALSE, NULL,		   log_tips									 },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_CHECK,	"sshlogenabled",	  N_("Log SSH session when exiting Remmina"), FALSE, NULL,		   NULL										 },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_CHECK,	"sshsavesession",	  N_("Log SSH session asynchronously"),	      TRUE,  NULL,		   N_("Saving the session asynchronously may have a notable performance impact") },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_CHECK,	"audiblebell",		  N_("Audible terminal bell"),		      FALSE, NULL,		   NULL										 },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_CHECK,	"ssh_forward_x11",	  N_("SSH X11 Forwarding"),			      TRUE,  NULL,		   NULL										 },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_CHECK,	"ssh_compression",	  N_("SSH compression"),		      FALSE, NULL,		   NULL										 },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_CHECK,	"disablepasswordstoring", N_("Don't remember passwords"),	      TRUE,  NULL,		   NULL										 },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_CHECK,	"ssh_stricthostkeycheck", N_("Strict host key checking"),	      FALSE, NULL,		   NULL										 },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_END,	NULL,			  NULL,					      FALSE, NULL,		   NULL										 }
+};
+
+/**
+ * SSH Protocol plugin definition and features.
+ *
+ * Array used to define the SSH Protocol plugin Type, name, description, version
+ * Plugin icon, features, initialization and closing functions.
+ */
+static RemminaProtocolPlugin remmina_plugin_ssh =
+{
+	REMMINA_PLUGIN_TYPE_PROTOCOL,                   /**< Type */
+	"SSH",                                          /**< Name */
+	N_("SSH - Secure Shell"),                       /**< Description */
+	GETTEXT_PACKAGE,                                /**< Translation domain */
+	VERSION,                                        /**< Version number */
+	"org.remmina.Remmina-ssh-symbolic",             /**< Icon for normal connection */
+	"org.remmina.Remmina-ssh-symbolic",             /**< Icon for SSH connection */
+	remmina_ssh_basic_settings,                     /**< Array for basic settings */
+	remmina_ssh_advanced_settings,                  /**< Array for advanced settings */
+	REMMINA_PROTOCOL_SSH_SETTING_TUNNEL,            /**< SSH settings type */
+	remmina_plugin_ssh_features,                    /**< Array for available features */
+	remmina_plugin_ssh_init,                        /**< Plugin initialization */
+	remmina_plugin_ssh_open_connection,             /**< Plugin open connection */
+	remmina_plugin_ssh_close_connection,            /**< Plugin close connection */
+	remmina_plugin_ssh_query_feature,               /**< Query for available features */
+	remmina_plugin_ssh_call_feature,                /**< Call a feature */
+	remmina_ssh_keystroke,                          /**< Send a keystroke */
+	NULL,                                           /**< No screenshot support available */
+	NULL,                                           /**< RCW map event */
+	NULL                                            /**< RCW unmap event */
+};
+
+
+/*
+ * this function is used for
+ * - inserting into the list to became a sorted list [g_list_insert_sorted()]
+ * - checking the list to avoid duplicate entries [g_list_find_custom()]
+ */
+static gint
+compare(gconstpointer a, gconstpointer b)
+{
+	return strcmp((gchar *)a, (gchar *)b);
+}
+
+void
+remmina_ssh_plugin_load_terminal_palettes(gpointer *ssh_terminal_palette_new)
+{
+	unsigned int preset_rec_size = sizeof(ssh_terminal_palette) / sizeof(gpointer);
+
+	GError *error = NULL;
+	GList *files = NULL;
+	unsigned int rec_size = 0;
+	/*
+	 * count number of (all) files to reserve enough memory
+	 */
+	/* /usr/local/share/remmina */
+	const gchar *const *dirs = g_get_system_data_dirs();
+
+	unsigned int i = 0;
+
+	for (i = 0; dirs[i] != NULL; ++i) {
+		GDir *system_data_dir = NULL;
+		gchar *remmina_dir = g_build_path("/", dirs[i], "remmina", "theme", NULL);
+		system_data_dir = g_dir_open(remmina_dir, 0, &error);
+		g_free(remmina_dir);
+		// ignoring this error is OK, because the folder may not exist
+		if (error) {
+			g_error_free(error);
+			error = NULL;
+		} else {
+			if (system_data_dir) {
+				const gchar *filename;
+				while ((filename = g_dir_read_name(system_data_dir))) {
+					if (!g_file_test(filename, G_FILE_TEST_IS_DIR)) {
+						if (g_str_has_suffix(filename, ".colors")) {
+							gsize len = strrchr(filename, '.') - filename;
+							gchar *menu_str = g_strndup(filename, len);
+							if (g_list_find_custom(files, menu_str, compare) == NULL)
+								files = g_list_insert_sorted(files, menu_str, compare);
+						}
+					}
+				}
+			}
+		}
+	}
+
+	/* ~/.config/remmina/colors */
+	gchar *remmina_dir = g_build_path("/", g_get_user_config_dir(), "remmina", "theme", NULL);
+	GDir *user_data_dir;
+
+	user_data_dir = g_dir_open(remmina_dir, 0, &error);
+	g_free(remmina_dir);
+	if (error) {
+		g_error_free(error);
+		error = NULL;
+	} else {
+		if (user_data_dir) {
+			const gchar *filename;
+			while ((filename = g_dir_read_name(user_data_dir))) {
+				if (!g_file_test(filename, G_FILE_TEST_IS_DIR)) {
+					if (g_str_has_suffix(filename, ".colors")) {
+						char *menu_str = g_malloc(strlen(filename) + 1);
+						strcpy(menu_str, filename);
+						char *t2 = strrchr(menu_str, '.');
+						t2[0] = 0;
+						if (g_list_find_custom(files, menu_str, compare) == NULL)
+							files = g_list_insert_sorted(files, menu_str, compare);
+					}
+				}
+			}
+		}
+	}
+
+	rec_size = g_list_length(files) * 2;
+
+	gpointer *color_palette = g_malloc((preset_rec_size + rec_size) * sizeof(gpointer));
+
+	unsigned int field_idx = 0;
+
+	*ssh_terminal_palette_new = color_palette;
+	// preset with (old) static ssh_terminal_palette data
+	for (; field_idx < preset_rec_size; field_idx++) {
+		color_palette[field_idx] = ssh_terminal_palette[field_idx];
+		if (!color_palette[field_idx])
+			break;
+	}
+
+	GList *l_files = NULL;
+
+	for (l_files = g_list_first(files); l_files != NULL; l_files = l_files->next) {
+		gchar *menu_str = (gchar *)l_files->data;
+
+		color_palette[field_idx++] = menu_str;
+		color_palette[field_idx++] = menu_str;
+	}
+	g_list_free(files);
+
+	color_palette[field_idx] = NULL;
+}
+
+void
+remmina_ssh_plugin_register(void)
+{
+	TRACE_CALL(__func__);
+	remmina_plugin_ssh_features[0].opt3 = GUINT_TO_POINTER(remmina_pref.vte_shortcutkey_copy);
+	remmina_plugin_ssh_features[1].opt3 = GUINT_TO_POINTER(remmina_pref.vte_shortcutkey_paste);
+	remmina_plugin_ssh_features[2].opt3 = GUINT_TO_POINTER(remmina_pref.vte_shortcutkey_select_all);
+	remmina_plugin_ssh_features[3].opt3 = GUINT_TO_POINTER(remmina_pref.vte_shortcutkey_increase_font);
+	remmina_plugin_ssh_features[4].opt3 = GUINT_TO_POINTER(remmina_pref.vte_shortcutkey_decrease_font);
+	remmina_plugin_ssh_features[5].opt3 = GUINT_TO_POINTER(remmina_pref.vte_shortcutkey_search_text);
+
+	remmina_plugin_service = &remmina_plugin_manager_service;
+
+	RemminaProtocolSettingOpt *settings;
+
+	// preset new settings with (old) static remmina_ssh_advanced_settings data
+#if GLIB_CHECK_VERSION(2,68,0)
+	settings = g_memdup2(remmina_ssh_advanced_settings, sizeof(remmina_ssh_advanced_settings));
+#else
+	settings = g_memdup(remmina_ssh_advanced_settings, sizeof(remmina_ssh_advanced_settings));
+#endif
+
+	// create dynamic advanced settings to made replacing of ssh_terminal_palette possible
+	gpointer ssh_terminal_palette_new = NULL;
+
+	remmina_ssh_plugin_load_terminal_palettes(&ssh_terminal_palette_new);
+
+	settings[0].opt1 = ssh_terminal_palette_new;
+	remmina_plugin_ssh.advanced_settings = (RemminaProtocolSetting *)settings;
+
+	remmina_plugin_service->register_plugin((RemminaPlugin *)&remmina_plugin_ssh);
+
+	ssh_threads_set_callbacks(ssh_threads_get_pthread());
+	ssh_init();
+}
+
+#else
+
+void remmina_ssh_plugin_register(void)
+{
+	TRACE_CALL(__func__);
+}
+
+#endif
diff --git a/src/remmina_ssh_plugin.h b/src/remmina_ssh_plugin.h
new file mode 100644
index 0000000..b02a982
--- /dev/null
+++ b/src/remmina_ssh_plugin.h
@@ -0,0 +1,67 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010-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.
+ *
+ */
+
+#pragma once
+
+#ifdef HAVE_LIBVTE
+#include <vte/vte.h>
+#endif
+
+G_BEGIN_DECLS
+
+void remmina_ssh_plugin_register(void);
+
+typedef struct _RemminaProtocolSettingOpt {
+	RemminaProtocolSettingType	type;
+	const gchar *			name;
+	const gchar *			label;
+	gboolean			compact;
+	gpointer			opt1;
+	gpointer			opt2;
+} RemminaProtocolSettingOpt;
+
+/* For callback in main thread */
+#if defined (HAVE_LIBSSH) && defined (HAVE_LIBVTE)
+void remmina_plugin_ssh_vte_terminal_set_encoding_and_pty(VteTerminal *terminal, const char *codeset, int master, int slave);
+void remmina_plugin_ssh_vte_select_all(GtkMenuItem *menuitem, gpointer vte);
+void remmina_plugin_ssh_vte_copy_clipboard(GtkMenuItem *menuitem, gpointer vte);
+void remmina_plugin_ssh_vte_paste_clipboard(GtkMenuItem *menuitem, gpointer vte);
+void remmina_plugin_ssh_vte_decrease_font(GtkMenuItem *menuitem, gpointer vte);
+void remmina_plugin_ssh_vte_increase_font(GtkMenuItem *menuitem, gpointer vte);
+gboolean remmina_ssh_plugin_popup_menu(GtkWidget *widget, GdkEvent *event, GtkWidget *menu);
+#endif
+
+G_END_DECLS
diff --git a/src/remmina_string_array.c b/src/remmina_string_array.c
new file mode 100644
index 0000000..e4c41e6
--- /dev/null
+++ b/src/remmina_string_array.c
@@ -0,0 +1,176 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009 - 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 <glib.h>
+#include <gmodule.h>
+#include <string.h>
+#include "remmina_string_array.h"
+#include "remmina/remmina_trace_calls.h"
+
+RemminaStringArray*
+remmina_string_array_new(void)
+{
+	TRACE_CALL(__func__);
+	return g_ptr_array_new();
+}
+
+RemminaStringArray*
+remmina_string_array_new_from_string(const gchar *strs)
+{
+	TRACE_CALL(__func__);
+	RemminaStringArray *array;
+	gchar *buf, *ptr1, *ptr2;
+
+	array = remmina_string_array_new();
+	if (!strs || strs[0] == '\0')
+		return array;
+
+	buf = g_strdup(strs);
+	ptr1 = buf;
+	while (ptr1) {
+		ptr2 = strchr(ptr1, ',');
+		if (ptr2)
+			*ptr2++ = '\0';
+		remmina_string_array_add(array, ptr1);
+		ptr1 = ptr2;
+	}
+
+	g_free(buf);
+
+	return array;
+}
+
+RemminaStringArray*
+remmina_string_array_new_from_allocated_string(gchar *strs)
+{
+	TRACE_CALL(__func__);
+	RemminaStringArray *array;
+	array = remmina_string_array_new_from_string(strs);
+	g_free(strs);
+	return array;
+}
+
+void remmina_string_array_add(RemminaStringArray* array, const gchar *str)
+{
+	TRACE_CALL(__func__);
+	g_ptr_array_add(array, g_strdup(str));
+}
+
+gint remmina_string_array_find(RemminaStringArray* array, const gchar *str)
+{
+	TRACE_CALL(__func__);
+	gint i;
+
+	for (i = 0; i < array->len; i++) {
+		if (g_strcmp0(remmina_string_array_index(array, i), str) == 0)
+			return i;
+	}
+	return -1;
+}
+
+void remmina_string_array_remove_index(RemminaStringArray* array, gint i)
+{
+	TRACE_CALL(__func__);
+	g_ptr_array_remove_index(array, i);
+}
+
+void remmina_string_array_remove(RemminaStringArray* array, const gchar *str)
+{
+	TRACE_CALL(__func__);
+	gint i;
+
+	i = remmina_string_array_find(array, str);
+	if (i >= 0) {
+		remmina_string_array_remove_index(array, i);
+	}
+}
+
+void remmina_string_array_intersect(RemminaStringArray* array, const gchar *dest_strs)
+{
+	TRACE_CALL(__func__);
+	RemminaStringArray *dest_array;
+	gint i, j;
+
+	dest_array = remmina_string_array_new_from_string(dest_strs);
+
+	i = 0;
+	while (i < array->len) {
+		j = remmina_string_array_find(dest_array, remmina_string_array_index(array, i));
+		if (j < 0) {
+			remmina_string_array_remove_index(array, i);
+			continue;
+		}
+		i++;
+	}
+
+	remmina_string_array_free(dest_array);
+}
+
+static gint remmina_string_array_compare_func(const gchar **a, const gchar **b)
+{
+	TRACE_CALL(__func__);
+	return g_strcmp0(*a, *b);
+}
+
+void remmina_string_array_sort(RemminaStringArray *array)
+{
+	TRACE_CALL(__func__);
+	g_ptr_array_sort(array, (GCompareFunc)remmina_string_array_compare_func);
+}
+
+gchar*
+remmina_string_array_to_string(RemminaStringArray* array)
+{
+	TRACE_CALL(__func__);
+	GString *gstr;
+	gint i;
+
+	gstr = g_string_new("");
+	for (i = 0; i < array->len; i++) {
+		if (i > 0)
+			g_string_append_c(gstr, ',');
+		g_string_append(gstr, remmina_string_array_index(array, i));
+	}
+	return g_string_free(gstr, FALSE);
+}
+
+void remmina_string_array_free(RemminaStringArray *array)
+{
+	TRACE_CALL(__func__);
+	g_ptr_array_foreach(array, (GFunc)g_free, NULL);
+	g_ptr_array_free(array, TRUE);
+}
+
diff --git a/src/remmina_string_array.h b/src/remmina_string_array.h
new file mode 100644
index 0000000..5b93e03
--- /dev/null
+++ b/src/remmina_string_array.h
@@ -0,0 +1,56 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009 - Vic Lee
+ * Copyright (C) 2017-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.
+ *
+ */
+
+#pragma once
+#include <gmodule.h>
+
+G_BEGIN_DECLS
+
+typedef GPtrArray RemminaStringArray;
+
+RemminaStringArray *remmina_string_array_new(void);
+#define remmina_string_array_index(array, i) (gchar *)g_ptr_array_index(array, i)
+RemminaStringArray *remmina_string_array_new_from_string(const gchar *strs);
+RemminaStringArray *remmina_string_array_new_from_allocated_string(gchar *strs);
+void remmina_string_array_add(RemminaStringArray *array, const gchar *str);
+gint remmina_string_array_find(RemminaStringArray *array, const gchar *str);
+void remmina_string_array_remove_index(RemminaStringArray *array, gint i);
+void remmina_string_array_remove(RemminaStringArray *array, const gchar *str);
+void remmina_string_array_intersect(RemminaStringArray *array, const gchar *dest_strs);
+void remmina_string_array_sort(RemminaStringArray *array);
+gchar *remmina_string_array_to_string(RemminaStringArray *array);
+void remmina_string_array_free(RemminaStringArray *array);
+
+G_END_DECLS
diff --git a/src/remmina_string_list.c b/src/remmina_string_list.c
new file mode 100644
index 0000000..0fafacb
--- /dev/null
+++ b/src/remmina_string_list.c
@@ -0,0 +1,312 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009 - 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 <string.h>
+#include "config.h"
+#include "remmina_public.h"
+#include "remmina_string_list.h"
+#include "remmina/remmina_trace_calls.h"
+
+static RemminaStringList *string_list;
+
+#define COLUMN_DESCRIPTION 0
+#define COLUMN_VALUE 1
+#define GET_OBJECT(object_name) gtk_builder_get_object(string_list->builder, object_name)
+
+/* Update the buttons state on the items in the TreeModel */
+void remmina_string_list_update_buttons_state(void)
+{
+	gint items_count = gtk_tree_model_iter_n_children(
+		GTK_TREE_MODEL(string_list->liststore_items), NULL);
+
+	gtk_widget_set_sensitive(GTK_WIDGET(string_list->button_remove), items_count > 0);
+	gtk_widget_set_sensitive(GTK_WIDGET(string_list->button_up), items_count > 1);
+	gtk_widget_set_sensitive(GTK_WIDGET(string_list->button_down), items_count > 1);
+}
+
+/* Check the text inserted in the list */
+void remmina_string_list_on_cell_edited(GtkCellRendererText *cell, const gchar *path_string, const gchar *new_text)
+{
+	TRACE_CALL(__func__);
+	gchar *text;
+	gchar *error;
+	GtkTreePath *path = gtk_tree_path_new_from_string(path_string);
+	GtkTreeIter iter;
+
+	gtk_tree_model_get_iter(GTK_TREE_MODEL(string_list->liststore_items), &iter, path);
+	/* Remove delimitors from the string */
+	text = remmina_public_str_replace(new_text, STRING_DELIMITOR, " ");
+	if (cell == string_list->cellrenderertext_item1) {
+		gtk_list_store_set(string_list->liststore_items, &iter, COLUMN_DESCRIPTION, text, -1);
+	}else  {
+		/* Check for validation only in second field */
+		if (string_list->priv->validation_func) {
+			if (!((*string_list->priv->validation_func)(text, &error))) {
+				gtk_label_set_text(string_list->label_status, error);
+				gtk_widget_show(GTK_WIDGET(string_list->label_status));
+				g_free(error);
+			}else  {
+				gtk_widget_hide(GTK_WIDGET(string_list->label_status));
+			}
+		}
+		gtk_list_store_set(string_list->liststore_items, &iter, COLUMN_VALUE, text, -1);
+	}
+	gtk_tree_path_free(path);
+	g_free(text);
+}
+
+/* Move a TreeIter position */
+static void remmina_string_list_move_iter(GtkTreeIter *from, GtkTreeIter *to)
+{
+	TRACE_CALL(__func__);
+	GtkTreePath *path;
+
+	gtk_list_store_swap(string_list->liststore_items, from, to);
+	path = gtk_tree_model_get_path(GTK_TREE_MODEL(string_list->liststore_items), from);
+	gtk_tree_view_scroll_to_cell(string_list->treeview_items, path, NULL, 0, 0, 0);
+	gtk_tree_path_free(path);
+}
+
+/* Move down the selected TreeRow */
+void remmina_string_list_on_action_down(GtkWidget *widget, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	GtkTreeIter iter;
+	GtkTreeIter target_iter;
+
+	if (gtk_tree_selection_get_selected(string_list->treeview_selection, NULL, &iter)) {
+		gtk_tree_selection_get_selected(string_list->treeview_selection, NULL, &target_iter);
+		if (gtk_tree_model_iter_next(GTK_TREE_MODEL(string_list->liststore_items), &target_iter)) {
+			remmina_string_list_move_iter(&iter, &target_iter);
+		}
+	}
+}
+
+/* Move up the selected TreeRow */
+void remmina_string_list_on_action_up(GtkWidget *widget, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	GtkTreeIter iter;
+	GtkTreeIter target_iter;
+	GtkTreePath *path;
+
+	if (gtk_tree_selection_get_selected(string_list->treeview_selection, NULL, &iter)) {
+		gtk_tree_selection_get_selected(string_list->treeview_selection, NULL, &target_iter);
+		path = gtk_tree_model_get_path(GTK_TREE_MODEL(string_list->liststore_items), &target_iter);
+		/* Before moving the TreeRow check if there’s a previous item */
+		if (gtk_tree_path_prev(path)) {
+			gtk_tree_model_get_iter(GTK_TREE_MODEL(string_list->liststore_items), &target_iter, path);
+			gtk_tree_path_free(path);
+			remmina_string_list_move_iter(&iter, &target_iter);
+		}
+	}
+}
+
+/* Add a new TreeRow to the list */
+void remmina_string_list_on_action_add(GtkWidget *widget, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	GtkTreeIter iter;
+	GtkTreePath *path;
+
+	gtk_list_store_append(string_list->liststore_items, &iter);
+	gtk_tree_selection_select_iter(string_list->treeview_selection, &iter);
+
+	path = gtk_tree_model_get_path(GTK_TREE_MODEL(string_list->liststore_items), &iter);
+	gtk_tree_view_set_cursor_on_cell(string_list->treeview_items, path,
+		string_list->treeviewcolumn_item,
+		GTK_CELL_RENDERER(string_list->priv->two_columns ? string_list->cellrenderertext_item1 : string_list->cellrenderertext_item2),
+		TRUE);
+	gtk_tree_path_free(path);
+	remmina_string_list_update_buttons_state();
+}
+
+/* Remove the selected TreeRow from the list */
+void remmina_string_list_on_action_remove(GtkWidget *widget, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	GtkTreeIter iter;
+
+	if (gtk_tree_selection_get_selected(string_list->treeview_selection, NULL, &iter)) {
+		gtk_list_store_remove(string_list->liststore_items, &iter);
+	}
+	gtk_widget_hide(GTK_WIDGET(string_list->label_status));
+	remmina_string_list_update_buttons_state();
+}
+
+/* Load a string list by splitting a string value */
+void remmina_string_list_set_text(const gchar *text, const gboolean clear_data)
+{
+	TRACE_CALL(__func__);
+	GtkTreeIter iter;
+	gchar **items;
+	gchar **values;
+	gint i;
+	/* Clear the data before to load new items */
+	if (clear_data)
+		gtk_list_store_clear(string_list->liststore_items);
+	/* Split the string and insert each snippet in the string list */
+	items = g_strsplit(text, STRING_DELIMITOR, -1);
+	for (i = 0; i < g_strv_length(items); i++) {
+		values = g_strsplit(items[i], string_list->priv->fields_separator, -1);
+		gtk_list_store_append(string_list->liststore_items, &iter);
+		if (g_strv_length(values) > 1) {
+			/* Two columns data */
+			gtk_list_store_set(string_list->liststore_items, &iter,
+				COLUMN_DESCRIPTION, values[0],
+				COLUMN_VALUE, values[1],
+				-1);
+		}else  {
+			/* Single column data */
+			gtk_list_store_set(string_list->liststore_items, &iter,
+				COLUMN_VALUE, values[0],
+				-1);
+		}
+		g_strfreev(values);
+	}
+	g_strfreev(items);
+	remmina_string_list_update_buttons_state();
+}
+
+/* Get a string value representing the string list */
+gchar* remmina_string_list_get_text(void)
+{
+	TRACE_CALL(__func__);
+	GString *str;
+	GtkTreeIter iter;
+	gboolean first;
+	gboolean ret;
+	const gchar *item_description;
+	const gchar *item_value;
+
+	str = g_string_new(NULL);
+	first = TRUE;
+	/* Cycle each GtkTreeIter in the ListStore */
+	ret = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(string_list->liststore_items), &iter);
+	while (ret) {
+		gtk_tree_model_get(GTK_TREE_MODEL(string_list->liststore_items), &iter,
+			COLUMN_DESCRIPTION, &item_description,
+			COLUMN_VALUE, &item_value,
+			-1);
+		if (!item_description)
+			item_description = "";
+		if (item_value && strlen(item_value) > 0) {
+			/* Add a delimitor after the first element */
+			if (!first) {
+				g_string_append(str, STRING_DELIMITOR);
+			}else  {
+				first = FALSE;
+			}
+			/* Add the description for two columns list */
+			if (string_list->priv->two_columns) {
+				g_string_append(str, item_description);
+				g_string_append(str, string_list->priv->fields_separator);
+			}
+			/* Add the element to the string */
+			g_string_append(str, item_value);
+		}
+		ret = gtk_tree_model_iter_next(GTK_TREE_MODEL(string_list->liststore_items), &iter);
+	}
+	return g_string_free(str, FALSE);
+}
+
+/* Set a function that will be used to validate the new rows */
+void remmina_string_list_set_validation_func(RemminaStringListValidationFunc func)
+{
+	TRACE_CALL(__func__);
+	string_list->priv->validation_func = func;
+}
+
+/* Set the dialog titles */
+void remmina_string_list_set_titles(gchar *title1, gchar *title2)
+{
+	/* Set dialog titlebar */
+	gtk_window_set_title(GTK_WINDOW(string_list->dialog),
+		(title1 && strlen(title1) > 0) ? title1 : "");
+	/* Set title label */
+	if (title2 && strlen(title2) > 0) {
+		gtk_label_set_text(string_list->label_title, title2);
+		gtk_widget_show(GTK_WIDGET(string_list->label_title));
+	}else  {
+		gtk_widget_hide(GTK_WIDGET(string_list->label_title));
+	}
+}
+
+/* RemminaStringList initialization */
+static void remmina_string_list_init(void)
+{
+	TRACE_CALL(__func__);
+	string_list->priv->validation_func = NULL;
+	/* When two columns are requested, show also the first column */
+	if (string_list->priv->two_columns)
+		gtk_cell_renderer_set_visible(GTK_CELL_RENDERER(string_list->cellrenderertext_item1), TRUE);
+	remmina_string_list_update_buttons_state();
+}
+
+/* RemminaStringList instance */
+GtkDialog* remmina_string_list_new(gboolean two_columns, const gchar *fields_separator)
+{
+	TRACE_CALL(__func__);
+	string_list = g_new0(RemminaStringList, 1);
+	string_list->priv = g_new0(RemminaStringListPriv, 1);
+
+	string_list->builder = remmina_public_gtk_builder_new_from_resource("/org/remmina/Remmina/src/../data/ui/remmina_string_list.glade");
+	string_list->dialog = GTK_DIALOG(gtk_builder_get_object(string_list->builder, "DialogStringList"));
+
+	string_list->liststore_items = GTK_LIST_STORE(GET_OBJECT("liststore_items"));
+	string_list->treeview_items = GTK_TREE_VIEW(GET_OBJECT("treeview_items"));
+	string_list->treeviewcolumn_item = GTK_TREE_VIEW_COLUMN(GET_OBJECT("treeviewcolumn_item"));
+	string_list->treeview_selection = GTK_TREE_SELECTION(GET_OBJECT("treeview_selection"));
+	string_list->cellrenderertext_item1 = GTK_CELL_RENDERER_TEXT(GET_OBJECT("cellrenderertext_item1"));
+	string_list->cellrenderertext_item2 = GTK_CELL_RENDERER_TEXT(GET_OBJECT("cellrenderertext_item2"));
+	string_list->button_add = GTK_BUTTON(GET_OBJECT("button_add"));
+	string_list->button_remove = GTK_BUTTON(GET_OBJECT("button_remove"));
+	string_list->button_up = GTK_BUTTON(GET_OBJECT("button_up"));
+	string_list->button_down = GTK_BUTTON(GET_OBJECT("button_down"));
+	string_list->label_title = GTK_LABEL(GET_OBJECT("label_title"));
+	string_list->label_status = GTK_LABEL(GET_OBJECT("label_status"));
+
+	/* Connect signals */
+	gtk_builder_connect_signals(string_list->builder, NULL);
+	/* Initialize the window and load the values */
+	if (!fields_separator)
+		fields_separator = STRING_DELIMITOR2;
+	string_list->priv->fields_separator = fields_separator;
+	string_list->priv->two_columns = two_columns;
+	remmina_string_list_init();
+
+	return string_list->dialog;
+}
diff --git a/src/remmina_string_list.h b/src/remmina_string_list.h
new file mode 100644
index 0000000..5d33c52
--- /dev/null
+++ b/src/remmina_string_list.h
@@ -0,0 +1,84 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009 - 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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+typedef gboolean (*RemminaStringListValidationFunc)(const gchar *new_str, gchar **error);
+
+typedef struct _RemminaStringListPriv {
+	RemminaStringListValidationFunc validation_func;
+	const gchar *			fields_separator;
+	gboolean			two_columns;
+} RemminaStringListPriv;
+
+typedef struct _RemminaStringList {
+	GtkBuilder *		builder;
+	GtkDialog *		dialog;
+
+	GtkListStore *		liststore_items;
+	GtkTreeView *		treeview_items;
+	GtkTreeViewColumn *	treeviewcolumn_item;
+	GtkTreeSelection *	treeview_selection;
+	GtkCellRendererText *	cellrenderertext_item1;
+	GtkCellRendererText *	cellrenderertext_item2;
+
+	GtkButton *		button_add;
+	GtkButton *		button_remove;
+	GtkButton *		button_up;
+	GtkButton *		button_down;
+
+	GtkLabel *		label_title;
+	GtkLabel *		label_status;
+
+	RemminaStringListPriv * priv;
+} RemminaStringList;
+
+G_BEGIN_DECLS
+
+/* RemminaStringList instance */
+GtkDialog *remmina_string_list_new(gboolean two_columns, const gchar *fields_separator);
+/* Load a string list by splitting a string value */
+void remmina_string_list_set_text(const gchar *text, const gboolean clear_data);
+/* Get a string value representing the string list */
+gchar *remmina_string_list_get_text(void);
+/* Set the dialog titles */
+void remmina_string_list_set_titles(gchar *title1, gchar *title2);
+/* Set a function that will be used to validate the new rows */
+void remmina_string_list_set_validation_func(RemminaStringListValidationFunc func);
+
+G_END_DECLS
diff --git a/src/remmina_sysinfo.c b/src/remmina_sysinfo.c
new file mode 100644
index 0000000..cfbe1c3
--- /dev/null
+++ b/src/remmina_sysinfo.c
@@ -0,0 +1,155 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010 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 <glib/gi18n.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include "remmina/remmina_trace_calls.h"
+#include "remmina_sysinfo.h"
+
+gboolean remmina_sysinfo_is_appindicator_available()
+{
+	/* Check if we have an appindicator available (which uses
+	 * DBUS KDE StatusNotifier)
+	 */
+
+	TRACE_CALL(__func__);
+	GDBusConnection *con;
+	GVariant *v;
+	GError *error;
+	gboolean available;
+
+	available = FALSE;
+	con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	if (con) {
+		error = NULL;
+		v = g_dbus_connection_call_sync(con,
+			"org.kde.StatusNotifierWatcher",
+			"/StatusNotifierWatcher",
+			"org.freedesktop.DBus.Introspectable",
+			"Introspect",
+			NULL,
+			NULL,
+			G_DBUS_CALL_FLAGS_NONE,
+			-1,
+			NULL,
+			&error);
+		if (v) {
+			available = TRUE;
+			g_variant_unref(v);
+		}
+		g_object_unref(con);
+	}
+	return available;
+}
+
+/**
+ * Query DBUS to get GNOME Shell version.
+ * @return the GNOME Shell version as a string or NULL if error or no GNOME Shell found.
+ * @warning The returned string must be freed with g_free.
+ */
+gchar *remmina_sysinfo_get_gnome_shell_version()
+{
+	TRACE_CALL(__func__);
+	GDBusConnection *con;
+	GDBusProxy *p;
+	GVariant *v;
+	GError *error;
+	gsize sz;
+	gchar *ret;
+
+	ret = NULL;
+
+	con = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	if (con) {
+		error = NULL;
+		p = g_dbus_proxy_new_sync(con,
+			G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+			NULL,
+			"org.gnome.Shell",
+			"/org/gnome/Shell",
+			"org.gnome.Shell",
+			NULL,
+			&error);
+		if (p) {
+			v = g_dbus_proxy_get_cached_property(p, "ShellVersion");
+			if (v) {
+				if (g_variant_is_of_type(v, G_VARIANT_TYPE_STRING)) {
+					ret = g_strdup(g_variant_get_string(v, &sz));
+				}
+				g_variant_unref(v);
+			}
+			g_object_unref(p);
+		}
+		g_object_unref(con);
+	}
+	return ret;
+}
+
+/**
+ * Query environment variables to get the Window manager name.
+ * @return a string composed by XDG_CURRENT_DESKTOP and GDMSESSION as a string
+ * or \0 if nothing has been found.
+ * @warning The returned string must be freed with g_free.
+ */
+gchar *remmina_sysinfo_get_wm_name()
+{
+	TRACE_CALL(__func__);
+	const gchar *xdg_current_desktop;
+	const gchar *gdmsession;
+	gchar *ret;
+
+	xdg_current_desktop = g_environ_getenv(g_get_environ(), "XDG_CURRENT_DESKTOP");
+	gdmsession = g_environ_getenv(g_get_environ(), "GDMSESSION");
+
+	if (!xdg_current_desktop || xdg_current_desktop[0] == '\0') {
+		if (!gdmsession || gdmsession[0] == '\0') {
+			ret = NULL;
+		}else {
+			ret = g_strdup_printf("%s", gdmsession);
+		}
+	}else if (!gdmsession || gdmsession[0] == '\0') {
+		ret = g_strdup_printf("%s", xdg_current_desktop);
+		return ret;
+	}else if (g_strcmp0(xdg_current_desktop,gdmsession) == 0) {
+		ret = g_strdup_printf("%s", xdg_current_desktop);
+	}else {
+		ret = g_strdup_printf("%s %s", xdg_current_desktop, gdmsession);
+	}
+	return ret;
+}
diff --git a/src/remmina_sysinfo.h b/src/remmina_sysinfo.h
new file mode 100644
index 0000000..7aa51fe
--- /dev/null
+++ b/src/remmina_sysinfo.h
@@ -0,0 +1,45 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * 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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+gboolean remmina_sysinfo_is_appindicator_available(void);
+gchar *remmina_sysinfo_get_gnome_shell_version(void);
+gchar *remmina_sysinfo_get_wm_name(void);
+
+G_END_DECLS
diff --git a/src/remmina_unlock.c b/src/remmina_unlock.c
new file mode 100644
index 0000000..d05000f
--- /dev/null
+++ b/src/remmina_unlock.c
@@ -0,0 +1,238 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * 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 <stdlib.h>
+
+#include <glib/gi18n.h>
+#include <glib.h>
+#include <glib/gprintf.h>
+
+#include "config.h"
+#include "remmina_sodium.h"
+#include "remmina_pref.h"
+#include "remmina_log.h"
+#include "remmina_unlock.h"
+#include "remmina_passwd.h"
+#include "remmina_public.h"
+#include "remmina/remmina_trace_calls.h"
+
+#if SODIUM_VERSION_INT >= 90200
+static RemminaUnlockDialog *remmina_unlock_dialog;
+#define GET_OBJ(object_name) gtk_builder_get_object(remmina_unlock_dialog->builder, object_name)
+
+GTimer *timer;
+gboolean unlocked;
+
+static void remmina_unlock_timer_init()
+{
+	TRACE_CALL(__func__);
+
+	timer = g_timer_new();
+	REMMINA_DEBUG("Validity timer for Remmina password started");
+}
+
+static void remmina_unlock_timer_reset(gpointer user_data)
+{
+	TRACE_CALL(__func__);
+
+	g_timer_reset(timer);
+	REMMINA_DEBUG("Validity timer for Remmina password reset");
+}
+
+void remmina_unlock_timer_destroy()
+{
+	TRACE_CALL(__func__);
+
+	g_timer_destroy(timer);
+	timer = NULL;
+}
+
+static void remmina_unlock_unlock_clicked(GtkButton *btn, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	//g_timer_reset(NULL);
+
+	gchar *unlock_password;
+	const gchar *entry_passwd;
+	gint rc;
+
+	unlock_password = remmina_pref_get_value("unlock_password");
+	entry_passwd = gtk_entry_get_text(remmina_unlock_dialog->entry_unlock);
+	rc = remmina_sodium_pwhash_str_verify(unlock_password, entry_passwd);
+	//REMMINA_DEBUG("remmina_sodium_pwhash_str_verify returned %i", rc);
+
+	if (rc == 0) {
+		REMMINA_DEBUG("Password verified");
+		//unlocked = FALSE;
+		remmina_unlock_dialog->retval = TRUE;
+	} else {
+		REMMINA_WARNING ("The password is wrong. Reset it by editing the remmina.pref file by hand");
+		remmina_unlock_timer_reset(NULL);
+		remmina_unlock_dialog->retval = FALSE;
+	}
+	gtk_dialog_response(remmina_unlock_dialog->dialog, GTK_RESPONSE_ACCEPT);
+}
+
+static void remmina_unlock_cancel_clicked(GtkButton *btn, gpointer user_data)
+{
+	TRACE_CALL(__func__);
+	gtk_dialog_response(remmina_unlock_dialog->dialog, GTK_RESPONSE_CANCEL);
+}
+
+gint remmina_unlock_new(GtkWindow *parent)
+{
+	TRACE_CALL(__func__);
+
+	gdouble unlock_timeout;
+	gdouble elapsed = 0.0;
+	gboolean lock = FALSE;
+	gboolean rc;
+
+	/* We don't have a timer, so this is the first time
+	 * or the timer has been destroyed
+	 */
+	if (timer == NULL) {
+		remmina_unlock_timer_init();
+		unlocked = FALSE;
+	}
+
+	/* We have a timer, we get the elapsed time since its start */
+	if (timer != NULL)
+		elapsed = g_timer_elapsed(timer, NULL);
+
+	/* We stop the timer while we enter the password) */
+	if (timer) g_timer_stop(timer);
+
+	unlock_timeout = remmina_pref.unlock_timeout;
+	REMMINA_DEBUG ("unlock_timeout = %f", unlock_timeout);
+	REMMINA_DEBUG ("elapsed = %f", elapsed);
+	REMMINA_DEBUG ("INT unlock_timeout = %d", (int)unlock_timeout);
+	REMMINA_DEBUG ("INT elapsed = %d", (int)elapsed);
+	/* always LOCK and ask password */
+	if ((elapsed) && ((int)unlock_timeout - elapsed) <= 0) {
+		unlocked = FALSE;
+		remmina_unlock_timer_reset(NULL);
+	}
+	/* We don't lock as it has been already requested */
+	//if (!unlocked && ((int)unlock_timeout - elapsed) > 0) unlocked = TRUE;
+
+	REMMINA_DEBUG("Based on settings and current status, the unlocking dialog is set to %d", unlocked);
+
+	if (unlocked) {
+		REMMINA_DEBUG ("No need to request a password");
+		rc = TRUE;
+		return rc;
+	} else {
+
+		remmina_unlock_dialog = g_new0(RemminaUnlockDialog, 1);
+		remmina_unlock_dialog->retval = FALSE;
+
+		remmina_unlock_dialog->builder = remmina_public_gtk_builder_new_from_resource("/org/remmina/Remmina/src/../data/ui/remmina_unlock.glade");
+		remmina_unlock_dialog->dialog = GTK_DIALOG(gtk_builder_get_object(remmina_unlock_dialog->builder, "RemminaUnlockDialog"));
+		if (parent)
+			gtk_window_set_transient_for(GTK_WINDOW(remmina_unlock_dialog->dialog), parent);
+
+		remmina_unlock_dialog->entry_unlock = GTK_ENTRY(GET_OBJ("entry_unlock"));
+		gtk_entry_set_activates_default(GTK_ENTRY(remmina_unlock_dialog->entry_unlock), TRUE);
+		remmina_unlock_dialog->button_unlock = GTK_BUTTON(GET_OBJ("button_unlock"));
+		gtk_widget_set_can_default(GTK_WIDGET(remmina_unlock_dialog->button_unlock), TRUE);
+		gtk_widget_grab_default(GTK_WIDGET(remmina_unlock_dialog->button_unlock));
+		remmina_unlock_dialog->button_unlock_cancel = GTK_BUTTON(GET_OBJ("button_unlock_cancel"));
+
+		g_signal_connect(remmina_unlock_dialog->button_unlock, "clicked",
+				 G_CALLBACK(remmina_unlock_unlock_clicked), (gpointer)remmina_unlock_dialog);
+		g_signal_connect(remmina_unlock_dialog->button_unlock_cancel, "clicked",
+				 G_CALLBACK(remmina_unlock_cancel_clicked), (gpointer)remmina_unlock_dialog);
+		g_signal_connect (remmina_unlock_dialog->dialog, "close",
+			  G_CALLBACK (remmina_unlock_cancel_clicked), (gpointer)remmina_unlock_dialog);
+
+		/* Connect signals */
+		gtk_builder_connect_signals(remmina_unlock_dialog->builder, NULL);
+
+		 g_object_set_data_full (G_OBJECT(remmina_unlock_dialog->dialog), "builder", remmina_unlock_dialog->builder, g_object_unref);
+
+		gchar *unlock_password = NULL;
+		unlock_password = g_strdup(remmina_pref_get_value("unlock_password"));
+		//REMMINA_DEBUG ("Password from preferences is: %s", unlock_password);
+		if ((unlock_password == NULL) || (g_strcmp0(unlock_password, "") == 0)) {
+			if (remmina_passwd (GTK_WINDOW(remmina_unlock_dialog->dialog), &unlock_password)) {
+				//REMMINA_DEBUG ("Password is: %s", unlock_password);
+				remmina_pref_set_value("unlock_password", g_strdup(unlock_password));
+				remmina_unlock_dialog->retval = TRUE;
+			} else {
+				remmina_unlock_dialog->retval = FALSE;
+			}
+		}
+
+		int result = GTK_RESPONSE_NONE;
+		if (g_strcmp0(unlock_password, "") != 0) {
+			result = gtk_dialog_run (GTK_DIALOG (remmina_unlock_dialog->dialog));
+		} else
+			remmina_unlock_dialog->retval = lock;
+
+		switch (result)
+		{
+			case GTK_RESPONSE_ACCEPT:
+				if (!remmina_unlock_dialog->retval)
+					REMMINA_DEBUG ("Wrong password");
+				else {
+					REMMINA_DEBUG ("Correct password. Unlocking…");
+					unlocked = TRUE;
+				}
+				REMMINA_DEBUG ("retval: %d", remmina_unlock_dialog->retval);
+				break;
+			default:
+				//unlocked = FALSE;
+				remmina_unlock_dialog->retval = FALSE;
+				remmina_unlock_timer_destroy ();
+				REMMINA_DEBUG ("Password not requested. Return value: %d", remmina_unlock_dialog->retval);
+				break;
+		}
+
+		rc = remmina_unlock_dialog->retval;
+
+		g_free(unlock_password), unlock_password = NULL;
+		gtk_widget_destroy(GTK_WIDGET(remmina_unlock_dialog->dialog));
+		remmina_unlock_dialog->dialog = NULL;
+	}
+	if (timer) g_timer_start(timer);
+	return(rc);
+}
+
+#else
+gint remmina_unlock_new(GtkWindow *parent)
+{
+	return 1;
+}
+#endif
diff --git a/src/remmina_unlock.h b/src/remmina_unlock.h
new file mode 100644
index 0000000..f0c4a1d
--- /dev/null
+++ b/src/remmina_unlock.h
@@ -0,0 +1,63 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2017-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.
+ *
+ */
+
+#pragma once
+
+#include <sodium.h>
+#include <gtk/gtk.h>
+
+#if SODIUM_VERSION_INT >= 90200
+typedef struct _RemminaUnlockDialog {
+	GtkBuilder *	builder;
+	GtkDialog *	dialog;
+
+	GtkEntry *	entry_unlock;
+	GtkButton *	button_unlock;
+	GtkButton *	button_unlock_cancel;
+
+	gboolean	unlock_init;
+
+	gint		retval;
+} RemminaUnlockDialog;
+
+extern GTimer *timer;
+extern gboolean unlocked;
+
+#endif
+
+G_BEGIN_DECLS
+
+gint remmina_unlock_new(GtkWindow *parent);
+
+G_END_DECLS
diff --git a/src/remmina_utils.c b/src/remmina_utils.c
new file mode 100644
index 0000000..14c0283
--- /dev/null
+++ b/src/remmina_utils.c
@@ -0,0 +1,1121 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2016-2023 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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.
+ *
+ */
+
+/**
+ * General utility functions, non-GTK related.
+ */
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/utsname.h>
+#include <locale.h>
+
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+#include <gio/gio.h>
+#include <openssl/evp.h>
+#include <openssl/decoder.h>
+#include <openssl/core_names.h>
+#include <openssl/rsa.h>
+#include <openssl/err.h>
+#include "remmina_sodium.h"
+#include "remmina/remmina_trace_calls.h"
+#include "remmina_utils.h"
+#include "remmina_log.h"
+#include "remmina_plugin_manager.h"
+
+/** Returns @c TRUE if @a ptr is @c NULL or @c *ptr is @c FALSE. */
+#define EMPTY(ptr) \
+	(!(ptr) || !*(ptr))
+
+/* Copyright (C) 1998 VMware, Inc. All rights reserved.
+ * Some of the code in this file is taken from the VMware open client.
+ */
+typedef struct lsb_distro_info {
+	gchar * name;
+	gchar * scanstring;
+} LSBDistroInfo;
+
+/*
+ * static LSBDistroInfo lsbFields[] = {
+ *      { "DISTRIB_ID=",	  "DISTRIB_ID=%s"		},
+ *      { "DISTRIB_RELEASE=",	  "DISTRIB_RELEASE=%s"		},
+ *      { "DISTRIB_CODENAME=",	  "DISTRIB_CODENAME=%s"		},
+ *      { "DISTRIB_DESCRIPTION=", "DISTRIB_DESCRIPTION=%s"	},
+ *      { NULL,			  NULL				},
+ * };
+ */
+
+typedef struct distro_info {
+	gchar * name;
+	gchar * filename;
+} DistroInfo;
+
+static DistroInfo distroArray[] = {
+	{ "RedHat",		"/etc/redhat-release"	     },
+	{ "RedHat",		"/etc/redhat_version"	     },
+	{ "Sun",		"/etc/sun-release"	     },
+	{ "SuSE",		"/etc/SuSE-release"	     },
+	{ "SuSE",		"/etc/novell-release"	     },
+	{ "SuSE",		"/etc/sles-release"	     },
+	{ "SuSE",		"/etc/os-release"	     },
+	{ "Debian",		"/etc/debian_version"	     },
+	{ "Debian",		"/etc/debian_release"	     },
+	{ "Ubuntu",		"/etc/lsb-release"	     },
+	{ "Mandrake",		"/etc/mandrake-release"	     },
+	{ "Mandriva",		"/etc/mandriva-release"	     },
+	{ "Mandrake",		"/etc/mandrakelinux-release" },
+	{ "TurboLinux",		"/etc/turbolinux-release"    },
+	{ "Fedora Core",	"/etc/fedora-release"	     },
+	{ "Gentoo",		"/etc/gentoo-release"	     },
+	{ "Novell",		"/etc/nld-release"	     },
+	{ "Annvix",		"/etc/annvix-release"	     },
+	{ "Arch",		"/etc/arch-release"	     },
+	{ "Arklinux",		"/etc/arklinux-release"	     },
+	{ "Aurox",		"/etc/aurox-release"	     },
+	{ "BlackCat",		"/etc/blackcat-release"	     },
+	{ "Cobalt",		"/etc/cobalt-release"	     },
+	{ "Conectiva",		"/etc/conectiva-release"     },
+	{ "Immunix",		"/etc/immunix-release"	     },
+	{ "Knoppix",		"/etc/knoppix_version"	     },
+	{ "Linux-From-Scratch", "/etc/lfs-release"	     },
+	{ "Linux-PPC",		"/etc/linuxppc-release"	     },
+	{ "MkLinux",		"/etc/mklinux-release"	     },
+	{ "PLD",		"/etc/pld-release"	     },
+	{ "Slackware",		"/etc/slackware-version"     },
+	{ "Slackware",		"/etc/slackware-release"     },
+	{ "SMEServer",		"/etc/e-smith-release"	     },
+	{ "Solaris",		"/etc/release"		     },
+	{ "Solus",		"/etc/solus-release"	     },
+	{ "Tiny Sofa",		"/etc/tinysofa-release"	     },
+	{ "UltraPenguin",	"/etc/ultrapenguin-release"  },
+	{ "UnitedLinux",	"/etc/UnitedLinux-release"   },
+	{ "VALinux",		"/etc/va-release"	     },
+	{ "Yellow Dog",		"/etc/yellowdog-release"     },
+	{ NULL,			NULL			     },
+};
+
+const char *remmina_RSA_PubKey_v1 =
+		"-----BEGIN PUBLIC KEY-----\n"
+		"MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAyTig5CnpPOIZQn5yVfsg\n"
+		"Y+fNzVS3u0zgyZ7QPstVMgCR234KobRDy/6NOa6tHAzohn166dYZOrkOqFtAUUzQ\n"
+		"wVT0P9KkA0RTIChNBCA7G+LE3BYgomoSm2ofBRsfax8RdwYzsqArBHwluv3F6zOT\n"
+		"aLwUbtUbDYRwzeIOlfcBLxNlPxHKR8Jq9zREVaEHm8Vj8/e6vNZ66v5I8tg+NaUV\n"
+		"omR1h0SPfU0R77x1q/LX41jHISq/cCRLoi4ft+zEJ03HhtmPeV84DfWwtQtpv9P4\n"
+		"q2bC5pEH73VHs/igVC44JA9eNcJ/qGxd1uI7K3DGrqtVfa+csEzGtWD3THEo/ZXW\n"
+		"bBlGIbOvh58DxKpheR4C3xzWJfeHRUPueGaanwpALydaV5uE4yFwPmQ9KvBhEQAg\n"
+		"ck9d10FPKQfHXOAfXkTWToeVLoIk/oDIo9XUbEnFHELtw3gIGNHpMUmUOEk7th80\n"
+		"Cldf86fyEw0SPnP+y+SR6gw1zOvs1gbBfMxHsNKIfmpps162JV0bpP0vz7eZMyme\n"
+		"EuEEJ6TiyPHLaHaAluljc4UlpA+Huh/S8pZeObUhFpk3bvKVol/BHp3p388PRzZ1\n"
+		"eYLNXO8muQqL2SX4k9ndFggsDnr2QYp/dkLaoclNJUiBWPDSHDCuRMX1rCm+wv1p\n"
+		"wGWm2KJS9Iz7J5Bc19pcm90CAwEAAQ==\n"
+		"-----END PUBLIC KEY-----\n";
+
+
+const char *remmina_RSA_PubKey_v2 =
+		"-----BEGIN PUBLIC KEY-----\n"
+		"MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxn7UtcGVxDbTvbprKNnw\n"
+		"CQws91Gg7as+A6PcqJ1GkRP46OKEiwJcVigbKZH53LQXLZUY+kOTYtD21+IicrAP\n"
+		"QL1er52oQf47ECEsNQ94kNirs/iqoGo+igNd+4scpFhm8WnrPgVvjbulqwGFY40d\n"
+		"/zqHaKgYhLvt8OUXF+YSIAC8cQ5qkXy8ncnrpBi22Slly5MyPfXciZj4oKvtXA54\n"
+		"8+TP9E+hwagH6xF7aH6fyEgTmzuI2y4hXzkWRXNg5umifpkdHfppWETA+FHIZ7Dh\n"
+		"/jy2NnR3wvoDMSqxNaea/LrGJS2cCQpO5d0EzAT+umA4ou2iDi6DfUgkAU/Vh7Jt\n"
+		"fedB6x2iewsMU12ef6UkRFrcf7v1tgfAjbWDUXCZTR5zNBm+nrWI6J8jsQ2h6ykP\n"
+		"qFdcUjMilLisDB8XPccUoEa0xCAMS2CgPiaC/CPeZoxpBXXxUlcwHUKLpl7wKxn7\n"
+		"/MxAu+ynbfL44xEJ74ka1z06Zi7pa4v16Pv0CAgoIRWI0mvZV7iANiBIvNQ5jE8I\n"
+		"k273owYRDfnZEHbFMF3TBzFdG6dALpJYqPA649p6VKNwoEksubf9ygWHWmaheUA1\n"
+		"Vq3SYIEx+Kymr650VdWLVXrLF+Gl+QXcGtfd5rTnVwW+erKWJU8bFDkmKLw8xADC\n"
+		"LlH/YYsHZOx0hXoxQJf+VHcCAwEAAQ==\n"
+		"-----END PUBLIC KEY-----\n";
+
+
+gint remmina_utils_strpos(const gchar *haystack, const gchar *needle)
+{
+	TRACE_CALL(__func__);
+	const gchar *sub;
+
+	if (!*needle)
+		return -1;
+
+	sub = strstr(haystack, needle);
+	if (!sub)
+		return -1;
+
+	return sub - haystack;
+}
+
+/* end can be -1 for haystack->len.
+ * returns: position of found text or -1.
+ * (C) Taken from geany */
+gint remmina_utils_string_find(GString *haystack, gint start, gint end, const gchar *needle)
+{
+	TRACE_CALL(__func__);
+	gint pos;
+
+	g_return_val_if_fail(haystack != NULL, -1);
+	if (haystack->len == 0)
+		return -1;
+
+	g_return_val_if_fail(start >= 0, -1);
+	if (start >= (gint)haystack->len)
+		return -1;
+
+	g_return_val_if_fail(!EMPTY(needle), -1);
+
+	if (end < 0)
+		end = haystack->len;
+
+	pos = remmina_utils_strpos(haystack->str + start, needle);
+	if (pos == -1)
+		return -1;
+
+	pos += start;
+	if (pos >= end)
+		return -1;
+	return pos;
+}
+
+/* Replaces @len characters from offset @a pos.
+ * len can be -1 to replace the remainder of @a str.
+ * returns: pos + strlen(replace).
+ * (C) Taken from geany */
+gint remmina_utils_string_replace(GString *str, gint pos, gint len, const gchar *replace)
+{
+	TRACE_CALL(__func__);
+	g_string_erase(str, pos, len);
+	if (replace) {
+		g_string_insert(str, pos, replace);
+		pos += strlen(replace);
+	}
+	return pos;
+}
+
+/**
+ * Replaces all occurrences of @a needle in @a haystack with @a replace.
+ *
+ * @param haystack The input string to operate on. This string is modified in place.
+ * @param needle The string which should be replaced.
+ * @param replace The replacement for @a needle.
+ *
+ * @return Number of replacements made.
+ **/
+guint remmina_utils_string_replace_all(GString *haystack, const gchar *needle, const gchar *replace)
+{
+	TRACE_CALL(__func__);
+	guint count = 0;
+	gint pos = 0;
+	gsize needle_length = strlen(needle);
+
+	while (1) {
+		pos = remmina_utils_string_find(haystack, pos, -1, needle);
+
+		if (pos == -1)
+			break;
+
+		pos = remmina_utils_string_replace(haystack, pos, needle_length, replace);
+		count++;
+	}
+	return count;
+}
+
+/**
+ * Strip \n, \t and \" from a given string.
+ * This function is particularly useful with g_spawn_command_line_sync that does
+ * not strip control characters from the output.
+ * @warning the result should be freed.
+ * @param a string.
+ * @return a newly allocated copy of string cleaned by \t, \n and \"
+ */
+gchar *remmina_utils_string_strip(const gchar *s)
+{
+	gchar *p = g_malloc(strlen(s) + 1);
+	if (p == NULL) {
+		return NULL;
+	}
+
+	if (p) {
+		gchar *p2 = p;
+		while (*s != '\0') {
+			if (*s != '\t' && *s != '\n' && *s != '\"')
+				*p2++ = *s++;
+			else
+				++s;
+		}
+		*p2 = '\0';
+	}
+	return p;
+}
+
+/** OS related functions */
+
+/**
+ * remmina_utils_read_distrofile.
+ *
+ * Look for a distro version file /etc/xxx-release.
+ * Once found, read the file in and figure out which distribution.
+ *
+ * @param filename The file path of a Linux distribution release file.
+ * @param distroSize The size of the distribution name.
+ * @param distro The full distro name.
+ * @return Returns a string containing distro information verbatim from /etc/xxx-release (distro). Use g_free to free the string.
+ *
+ */
+static gchar *remmina_utils_read_distrofile(gchar *filename)
+{
+	TRACE_CALL(__func__);
+	gsize file_sz;
+	struct stat st;
+	gchar *distro_desc = NULL;
+	GError *err = NULL;
+
+	if (g_stat(filename, &st) == -1) {
+		return NULL;
+	}
+
+	if (st.st_size > 131072)
+		return NULL;
+
+	if (!g_file_get_contents(filename, &distro_desc, &file_sz, &err)) {
+		g_error_free(err);
+		return NULL;
+	}
+
+	if (file_sz == 0) {
+		return NULL;
+	}
+
+	return distro_desc;
+}
+
+/**
+ * Return the current language defined in the LC_ALL.
+ * @return a language string or en_US.
+ */
+gchar *remmina_utils_get_lang()
+{
+	TRACE_CALL(__func__);
+	gchar *lang = setlocale(LC_ALL, NULL);
+	gchar *ptr;
+
+	if (!lang || lang[0] == '\0') {
+		lang = "en_US\0";
+	} else {
+		ptr = strchr(lang, '.');
+		if (ptr != NULL)
+			*ptr = '\0';
+	}
+
+	return lang;
+}
+
+/**
+ * Return the OS name as in "uname -s".
+ * @return The OS name or NULL.
+ */
+gchar *remmina_utils_get_kernel_name()
+{
+	TRACE_CALL(__func__);
+	struct utsname u;
+
+	if (uname(&u) == -1) {
+		return NULL;
+	}
+	return g_strdup(u.sysname);
+}
+
+/**
+ * Return the OS version as in "uname -r".
+ * @return The OS release or NULL.
+ */
+gchar *remmina_utils_get_kernel_release()
+{
+	TRACE_CALL(__func__);
+	struct utsname u;
+
+	if (uname(&u) == -1) {
+		return NULL;
+	}
+	return g_strdup(u.release);
+}
+
+/**
+ * Return the machine hardware name as in "uname -m".
+ * @return The machine hardware name or NULL.
+ */
+gchar *remmina_utils_get_kernel_arch()
+{
+	TRACE_CALL(__func__);
+	struct utsname u;
+
+	if (uname(&u) == -1) {
+		return NULL;
+	}
+	return g_strdup(u.machine);
+}
+
+/**
+ * Print the Distributor as specified by the lsb_release command.
+ * @return the distributor ID string or NULL. Caller must free it with g_free().
+ */
+gchar *remmina_utils_get_lsb_id()
+{
+	TRACE_CALL(__func__);
+	gchar *lsb_id = NULL;
+	if (g_spawn_command_line_sync("/usr/bin/lsb_release -si", &lsb_id, NULL, NULL, NULL))
+		return lsb_id;
+	return NULL;
+}
+
+/**
+ * Print the Distribution description as specified by the lsb_release command.
+ * @return the Distribution description string or NULL. Caller must free it with g_free().
+ */
+gchar *remmina_utils_get_lsb_description()
+{
+	TRACE_CALL(__func__);
+	gchar *lsb_description = NULL;
+	if (g_spawn_command_line_sync("/usr/bin/lsb_release -sd", &lsb_description, NULL, NULL, NULL))
+		return lsb_description;
+	return NULL;
+}
+
+/**
+ * Print the Distribution release name as specified by the lsb_release command.
+ * @return the Distribution release name string or NULL. Caller must free it with g_free().
+ */
+gchar *remmina_utils_get_lsb_release()
+{
+	TRACE_CALL(__func__);
+	gchar *lsb_release = NULL;
+	if (g_spawn_command_line_sync("/usr/bin/lsb_release -sr", &lsb_release, NULL, NULL, NULL))
+		return lsb_release;
+	return NULL;
+}
+
+/**
+ * Print the Distribution codename as specified by the lsb_release command.
+ * @return the codename string or NULL. Caller must free it with g_free().
+ */
+gchar *remmina_utils_get_lsb_codename()
+{
+	TRACE_CALL(__func__);
+	gchar *lsb_codename = NULL;
+	if (g_spawn_command_line_sync("/usr/bin/lsb_release -sc", &lsb_codename, NULL, NULL, NULL))
+		return lsb_codename;
+	return NULL;
+}
+
+/**
+ * Print the distribution description if found.
+ * Test each known distribution specific information file and print it’s content.
+ * @return a string or NULL. Caller must free it with g_free().
+ */
+GHashTable *remmina_utils_get_etc_release()
+{
+	TRACE_CALL(__func__);
+	gchar *etc_release = NULL;
+	gint i;
+	GHashTable *r;
+
+	r = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, g_free);
+
+	for (i = 0; distroArray[i].filename != NULL; i++) {
+		etc_release = remmina_utils_read_distrofile(distroArray[i].filename);
+		if (etc_release) {
+			if (etc_release[0] != '\0') {
+				g_hash_table_insert(r, distroArray[i].filename, etc_release);
+			} else {
+				g_free(etc_release);
+			}
+		}
+	}
+	return r;
+}
+
+/**
+ * Print device associated with default route.
+ * @return a string or NULL. Caller must free it with g_free().
+ */
+gchar *remmina_utils_get_dev()
+{
+	TRACE_CALL(__func__);
+	gchar *dif;
+	gint pos = 0;
+	GString *dev;
+
+	if (g_spawn_command_line_sync("ip route show default", &dif, NULL, NULL, NULL)) {
+		dev = g_string_new(dif);
+		g_free(dif);
+		pos = remmina_utils_string_find(dev, pos, -1, "dev ");
+		dev = g_string_erase(dev, 0, pos + 4);
+		pos = remmina_utils_string_find(dev, 0, -1, " ");
+		dev = g_string_truncate(dev, pos);
+		return g_string_free(dev, FALSE);
+	}
+	return NULL;
+}
+
+/**
+ * Print address associated with default route.
+ * @return a string or NULL. Caller must free it with g_free().
+ */
+gchar *remmina_utils_get_logical()
+{
+	TRACE_CALL(__func__);
+	gchar *dev = NULL;
+	gchar *dlog;
+	gint pos = 0;
+
+	dev = remmina_utils_get_dev();
+	GString *lbuf = g_string_new("ip -4 -o addr show ");
+	if ( dev != NULL ) {
+		lbuf = g_string_append(lbuf, dev);
+		g_free(dev);
+	}
+
+	if (g_spawn_command_line_sync(lbuf->str, &dlog, NULL, NULL, NULL)) {
+		g_string_free(lbuf, TRUE);
+		GString *log = g_string_new(dlog);
+		g_free(dlog);
+		pos = remmina_utils_string_find(log, pos, -1, "inet ");
+		log = g_string_erase(log, 0, pos + 5);
+		pos = remmina_utils_string_find(log, 0, -1, " ");
+		log = g_string_truncate(log, pos);
+		return g_string_free(log, FALSE);
+	}
+	g_string_free(lbuf, TRUE);
+	return NULL;
+}
+
+/**
+ * Print link associated with default route.
+ * @return a string or NULL. Caller must free it with g_free().
+ */
+gchar *remmina_utils_get_link()
+{
+	TRACE_CALL(__func__);
+	gchar *dev = NULL;
+	gchar *plink;
+	gint pos = 0;
+
+	dev = remmina_utils_get_dev();
+	GString *pbuf = g_string_new("ip -4 -o link show ");
+	if ( dev != NULL ) {
+		pbuf = g_string_append(pbuf, dev);
+		g_free(dev);
+	}
+
+	if (g_spawn_command_line_sync(pbuf->str, &plink, NULL, NULL, NULL))
+	{
+		g_string_free(pbuf, TRUE);
+		GString *link = g_string_new(plink);
+		g_free(plink);
+		pos = remmina_utils_string_find(link, pos, -1, "link/ether ");
+		link = g_string_erase(link, 0, pos + 11);
+		pos = remmina_utils_string_find(link, 0, -1, " ");
+		link = g_string_truncate(link, pos);
+		return g_string_free(link, FALSE);
+	}
+	g_string_free(pbuf, TRUE);
+	return NULL;
+}
+
+/**
+ * Print python version.
+ * @return a string or NULL. Caller must free it with g_free().
+ */
+gchar *remmina_utils_get_python()
+{
+	TRACE_CALL(__func__);
+	gchar *version;
+
+	version = (g_spawn_command_line_sync("python -V", &version, NULL, NULL, NULL)) ||
+		(g_spawn_command_line_sync("python3 -V", &version, NULL, NULL, NULL)) ? version : NULL;
+	if (version != NULL)
+		version = remmina_utils_string_strip(version);
+
+	return version;
+}
+
+
+/**
+ * Print machine age.
+ * @return a string or NULL. Caller must free it with g_free().
+ */
+gchar *remmina_utils_get_mage()
+{
+	TRACE_CALL(__func__);
+	gchar *mage = malloc(21);
+	if (mage == NULL) {
+		return "";
+	}
+	struct stat sb;
+
+	if (stat("/etc/machine-id", &sb) == 0) {
+		sprintf(mage, "%ld", (long)(time(NULL) - sb.st_mtim.tv_sec));
+	}
+	else {
+		strcpy(mage, "0");
+	}
+	
+	return mage;
+}
+
+/**
+ * Create a hexadecimal string version of the SHA-256 digest of the
+ * buffer.
+ *
+ * @return a newly allocated string which the caller should free() when
+ * finished.
+ *
+ * If any error occurs, this function returns NULL.
+ */
+gchar *remmina_sha256_buffer(const guchar *buffer, gssize length)
+{
+	GChecksum *sha256 = NULL;
+	gchar *digest_string = NULL;
+
+	sha256 = g_checksum_new(G_CHECKSUM_SHA256);
+	if (sha256 == NULL) {
+		goto DONE;
+	}
+
+	g_checksum_update(sha256, buffer, length);
+
+	digest_string = g_strdup(g_checksum_get_string(sha256));
+
+DONE:
+	if (sha256) {
+		g_checksum_free(sha256);
+	}
+
+	return digest_string;
+}
+
+/**
+ * Create a hexadecimal string version of the SHA-1 digest of the
+ * contents of the named file.
+ *
+ * @return a newly allocated string which the caller
+ * should free() when finished.
+ *
+ * If any error occurs while reading the file, (permission denied,
+ * file not found, etc.), this function returns NULL.
+ *
+ * Taken from https://github.com/ttuegel/notmuch do PR in case of substantial modifications.
+ *
+ */
+gchar *remmina_sha1_file(const gchar *filename)
+{
+	FILE *file;
+
+#define BLOCK_SIZE 4096
+	unsigned char block[BLOCK_SIZE];
+	size_t bytes_read;
+	GChecksum *sha1;
+	char *digest = NULL;
+
+	file = fopen(filename, "r");
+	if (file == NULL)
+		return NULL;
+
+	sha1 = g_checksum_new(G_CHECKSUM_SHA1);
+	if (sha1 == NULL)
+		goto DONE;
+
+	while (1) {
+		bytes_read = fread(block, 1, 4096, file);
+		if (bytes_read == 0) {
+			if (feof(file))
+				break;
+			else if (ferror(file))
+				goto DONE;
+		} else {
+			g_checksum_update(sha1, block, bytes_read);
+		}
+	}
+
+	digest = g_strdup(g_checksum_get_string(sha1));
+
+DONE:
+	if (sha1)
+		g_checksum_free(sha1);
+	if (file)
+		fclose(file);
+
+	return digest;
+}
+
+/**
+ * Generate a random sting of chars to be used as part of UID for news or stats
+ * @return a string or NULL. Caller must free it with g_free().
+ */
+gchar *remmina_gen_random_uuid()
+{
+	TRACE_CALL(__func__);
+	gchar *result;
+	int i;
+	static char alpha[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+
+	result = g_malloc0(15);
+	if (result == NULL) {
+		return "";
+	}
+
+	for (i = 0; i < 7; i++)
+		result[i] = alpha[randombytes_uniform(sizeof(alpha) - 1)];
+
+	for (i = 0; i < 7; i++)
+		result[i + 7] = alpha[randombytes_uniform(sizeof(alpha) - 1)];
+
+	return result;
+}
+
+/**
+ * Uses OSSL_DECODER_CTX to convert public key string to usable OpenSSL structs
+ * @return an EVP_PKEY that can be used for public encryption
+ */
+EVP_PKEY *remmina_get_pubkey(const char *keytype, const char *public_key_selection) {
+	BIO *pkbio;
+	OSSL_DECODER_CTX *dctx;
+
+	EVP_PKEY *pubkey = NULL;
+	const char *format = "PEM";
+	const char *structure = NULL;
+	dctx = OSSL_DECODER_CTX_new_for_pkey(&pubkey, format, structure,
+										keytype,
+										EVP_PKEY_PUBLIC_KEY,
+										NULL, NULL);
+
+	if (dctx == NULL) {
+		return NULL;
+	}
+	pkbio = BIO_new_mem_buf(public_key_selection, -1);
+
+	if (OSSL_DECODER_from_bio(dctx, pkbio) == 0) {
+		BIO_free(pkbio);
+		OSSL_DECODER_CTX_free(dctx);
+		return NULL;
+	}
+	BIO_free(pkbio);
+	OSSL_DECODER_CTX_free(dctx);
+	return pubkey;
+}
+
+/**
+ * Calls EVP_PKEY_encrypt multiple times to encrypt instr. At the end, base64
+ * encode the resulting buffer.
+ *
+ * @param pubkey an RSA public key
+ * @param instr input string to be encrypted
+ *
+ * @return a buffer ptr. Use g_free() to deallocate it 
+ */
+gchar *remmina_rsa_encrypt_string(EVP_PKEY *pubkey, const char *instr)
+{
+#define RSA_OAEP_PAD_SIZE 42
+	gchar *enc;
+	int remaining;
+	size_t blksz, maxblksz;
+	unsigned char *outptr;
+
+	unsigned char *ebuf = NULL;
+	gsize ebufLen;
+	EVP_PKEY_CTX *ctx = NULL;
+	int pkeyLen = EVP_PKEY_size(pubkey);
+	int inLen = strlen(instr);
+	remaining = inLen;
+
+	maxblksz = pkeyLen - RSA_OAEP_PAD_SIZE;
+	ebufLen = (((inLen - 1) / maxblksz) + 1) * pkeyLen;
+	ebuf = g_malloc(ebufLen);
+	if (ebuf == NULL) {
+		return NULL;
+	}
+	outptr = ebuf;
+
+	ctx = EVP_PKEY_CTX_new_from_pkey(NULL, pubkey, NULL);
+	if (ctx == NULL) {
+		g_free(ebuf);
+		return NULL;
+	}
+
+	if (EVP_PKEY_encrypt_init_ex(ctx, NULL) <= 0) {;
+		EVP_PKEY_CTX_free(ctx);
+		g_free(ebuf);
+		return NULL;
+	}
+
+	if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_OAEP_PADDING) <= 0) {
+		EVP_PKEY_CTX_free(ctx);
+		g_free(ebuf);
+		return NULL;
+	}
+
+	/* encrypt input string block by block */
+	while (remaining > 0) {
+		blksz = remaining > maxblksz ? maxblksz : remaining;
+		size_t out_blksz;
+
+		int calc_size_return_val = EVP_PKEY_encrypt(ctx, NULL, &out_blksz, (const unsigned char *)instr, blksz);
+		if (calc_size_return_val == -2) {
+			EVP_PKEY_CTX_free(ctx);
+			g_free(ebuf);
+			return NULL;
+		}
+		else if (calc_size_return_val <= 0) {
+			EVP_PKEY_CTX_free(ctx);
+			g_free(ebuf);
+			return NULL;
+		}
+
+		if (EVP_PKEY_encrypt(ctx, outptr, &out_blksz, (const unsigned char *)instr, blksz) <= 0) {;
+			EVP_PKEY_CTX_free(ctx);
+			g_free(ebuf);
+			return NULL;
+		}
+
+		instr += blksz;
+		remaining -= blksz;
+		outptr += out_blksz;
+	}
+
+	enc = g_base64_encode(ebuf, ebufLen);
+	g_free(ebuf);
+	EVP_PKEY_CTX_free(ctx);
+	return enc;
+}
+
+/**
+ * Attempts to verify the contents of @a plugin_file with base64 encoded @a signature. This function uses the OpenSSL EVP API
+ * and expects a well-formed EC signature in DER format. The digest function used is SHA256.
+ *
+ * @param signature A base64 encoded signature.
+ * @param plugin_file The file containing the message you wish to verify.
+ * @param message_length The length of the message.
+ * @param signature_length The length of the signature.
+ *
+ * @return TRUE if the signature can be verified or FALSE if it cannot or there is an error.
+ */
+gboolean remmina_verify_plugin_signature(const guchar *signature, GFile* plugin_file, size_t message_length,
+										 size_t signature_length) {
+	EVP_PKEY *public_key = NULL;
+
+	/* Get public key */
+	public_key = remmina_get_pubkey(RSA_KEYTYPE, remmina_RSA_PubKey_v2);
+	if (public_key == NULL) {
+		return FALSE;
+	}
+
+	gboolean verified = remmina_execute_plugin_signature_verification(plugin_file, message_length, signature,
+																	  signature_length, public_key);
+
+	EVP_PKEY_free(public_key);
+	if (verified) {
+		return TRUE;
+	} else {
+		return FALSE;
+	}
+}
+
+/**
+ * A helper function that performs the actual signature verification (that is, this function makes direct calls to the
+ * OPENSSL EVP API) of @a plugin_file using signature @a sig with @a public_key.
+ *
+ * @param plugin_file The file containing the message you wish to verify.
+ * @param msg_len The length of the message.
+ * @param sig The signature to verify the message with.
+ * @param sig_len The length of the signature.
+ * @param public_key The public key to use in the signature verification.
+ *
+ * @return TRUE if the signature can be verified or FALSE if there is an error or the signature cannot be verified.
+ */
+gboolean remmina_execute_plugin_signature_verification(GFile* plugin_file, size_t msg_len, const guchar *sig, size_t sig_len, EVP_PKEY* public_key)
+{
+	/* Returned to caller */
+	if(!plugin_file || !msg_len || !sig || !sig_len || !public_key) {
+		return FALSE;
+	}
+
+	EVP_MD_CTX* ctx = NULL;
+	gssize read = 0;
+	gssize total_read = 0;
+	unsigned char buffer[1025];
+
+
+	/* Create context for verification */
+	ctx = EVP_MD_CTX_create();
+	if(ctx == NULL) {
+		return FALSE;
+	}
+
+	/* Returns the message digest (hash function) specified*/
+	const EVP_MD* message_digest = EVP_get_digestbyname(NAME_OF_DIGEST);
+	if(message_digest == NULL) {
+		EVP_MD_CTX_free(ctx);
+		return FALSE;
+	}
+
+	/* Set up context with the corresponding message digest. 1 is the only code for success */
+	int return_val = EVP_DigestInit_ex(ctx, message_digest, NULL);
+
+	if(return_val != 1) {
+		EVP_MD_CTX_free(ctx);
+		return FALSE;
+	}
+
+	/* Add the public key and initialize the context for verification*/
+
+	return_val = EVP_DigestVerifyInit(ctx, NULL, message_digest, NULL, public_key);
+
+	if(return_val != 1) {
+		EVP_MD_CTX_free(ctx);
+		return FALSE;
+	}
+
+	GFileInputStream *in_stream = g_file_read(plugin_file, NULL, NULL);
+
+	/* Add the msg to the context. The next step will be to actually verify the added message */
+	read = g_input_stream_read(G_INPUT_STREAM(in_stream), buffer, 1024, NULL, NULL);
+	while (read > 0){
+		total_read += read;
+		return_val = EVP_DigestVerifyUpdate(ctx, buffer, read);
+
+		if(return_val != 1) {
+			EVP_MD_CTX_free(ctx);
+			return FALSE;
+		}
+		read = g_input_stream_read(G_INPUT_STREAM(in_stream), buffer, 1024, NULL, NULL);
+	}
+	msg_len = total_read;
+
+	/* Clear any errors for the call below */
+	ERR_clear_error();
+
+	/* Execute the signature verification. */
+	return_val = EVP_DigestVerifyFinal(ctx, sig, sig_len);
+
+	if(return_val != 1) {
+		EVP_MD_CTX_free(ctx);
+		return FALSE;
+	}
+
+	if(ctx != NULL) {
+		EVP_MD_CTX_destroy(ctx);
+		ctx = NULL;
+	}
+
+	return TRUE;
+}
+
+/**
+ *
+ * Decompresses pointer @source with length @len to file pointed to by @plugin_file. It is the caller's responsibility
+ * to free @source and @plugin_file when no longer in use.
+ *
+ * @return The total number of compressed bytes read or -1 on error.
+ */
+int remmina_decompress_from_memory_to_file(guchar *source, int len, GFile* plugin_file) {
+	GError *error = NULL;
+	//Compress with gzip. The level is -1 for default
+	GZlibDecompressor* gzlib_decompressor = g_zlib_decompressor_new(G_ZLIB_COMPRESSOR_FORMAT_GZIP);
+	if (gzlib_decompressor == NULL) {
+		return -1;
+	}
+
+	GInputStream *base_stream = g_memory_input_stream_new_from_data(source, len, NULL);
+
+	if (base_stream == NULL) {
+		g_object_unref(gzlib_decompressor);
+		return -1;
+	}
+	GInputStream *converted_input_stream = g_converter_input_stream_new(base_stream, G_CONVERTER(gzlib_decompressor));
+
+	if (converted_input_stream == NULL) {
+		g_object_unref(base_stream);
+		g_object_unref(gzlib_decompressor);
+		return -1;
+	}
+
+	int total_read = 0;
+
+	GFileOutputStream *f_out_stream = g_file_replace(plugin_file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &error);
+	if (f_out_stream == NULL){
+		g_object_unref(base_stream);
+		g_object_unref(gzlib_decompressor);
+		return -1;
+	}
+
+	g_output_stream_splice(G_OUTPUT_STREAM(f_out_stream), converted_input_stream, G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, NULL, NULL);
+	GFileInfo* info = g_file_query_info(plugin_file, G_FILE_ATTRIBUTE_STANDARD_SIZE, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, NULL);
+	total_read = g_file_info_get_size(info);
+
+
+	//Freeing stuff
+	g_object_unref(converted_input_stream);
+	g_object_unref(f_out_stream);
+	g_object_unref(gzlib_decompressor);
+	g_object_unref(base_stream);
+	g_object_unref(info);
+
+
+	return total_read;
+
+}
+
+/**
+ * Compresses file @source to file @dest. Creates enough space to compress MAX_COMPRESSED_FILE_SIZE. It is the caller's
+ * responsibility to close @source and @dest.
+ *
+ * @return Total number of bytes read from source or -1 on error.
+ */
+int remmina_compress_from_file_to_file(GFile *source, GFile *dest)
+{
+	TRACE_CALL(__func__);
+	GError *error = NULL;
+
+	// Compress with gzip. The level is -1 for default
+	GZlibCompressor *gzlib_compressor = g_zlib_compressor_new(G_ZLIB_COMPRESSOR_FORMAT_GZIP, -1);
+
+	if (gzlib_compressor == NULL) {
+		REMMINA_DEBUG("Compressor instantiation failed");
+		return -1;
+	}
+
+	GFileInputStream *base_stream = g_file_read(source, NULL, &error);
+
+	if (base_stream == NULL) {
+		REMMINA_DEBUG("Base stream is null, error: %s", error->message);
+		g_free(error);
+		g_object_unref(gzlib_compressor);
+		return -1;
+	}
+
+	GInputStream *converted_input_stream = g_converter_input_stream_new((GInputStream *) base_stream, G_CONVERTER(gzlib_compressor));
+
+	if (converted_input_stream == NULL) {
+		REMMINA_DEBUG("Failed to allocate converted input stream");
+		g_object_unref(base_stream);
+		g_object_unref(gzlib_compressor);
+		return -1;
+	}
+
+	int total_read = 0;
+
+	guint8 *converted, *current_position;
+	converted = g_malloc(sizeof(guint8) * MAX_COMPRESSED_FILE_SIZE); // 100kb file max
+	if (converted == NULL) {
+		REMMINA_DEBUG("Failed to allocate compressed file memory");
+		g_object_unref(base_stream);
+		g_object_unref(gzlib_compressor);
+		g_object_unref(converted_input_stream);
+		return -1;
+	}
+
+	current_position = converted; // Set traveling pointer
+
+	gsize bytes_read = 0;
+	while (total_read < MAX_COMPRESSED_FILE_SIZE) {
+		bytes_read = g_input_stream_read(G_INPUT_STREAM(converted_input_stream), current_position, 1, NULL, &error);
+		if (error != NULL) {
+			REMMINA_DEBUG("Error reading input stream: %s", error->message);
+			g_free(error);
+			g_object_unref(base_stream);
+			g_object_unref(gzlib_compressor);
+			g_object_unref(converted_input_stream);
+			g_free(converted);
+			return -1;
+		}
+
+		if (bytes_read == 0) {
+			break; // Reached EOF, break read
+		}
+		current_position += bytes_read;
+
+		total_read += bytes_read;
+	}
+
+	if (total_read >= MAX_COMPRESSED_FILE_SIZE) {
+		REMMINA_DEBUG("Detected heap overflow in allocating compressed file");
+		g_object_unref(base_stream);
+		g_object_unref(gzlib_compressor);
+		g_object_unref(converted_input_stream);
+		g_free(converted);
+		return -1;
+	}
+
+	gsize *bytes_written = g_malloc(sizeof(gsize) * total_read);
+	if (bytes_written == NULL) {
+		REMMINA_DEBUG("Failed to allocate bytes written");
+		g_object_unref(base_stream);
+		g_object_unref(gzlib_compressor);
+		g_object_unref(converted_input_stream);
+		g_free(converted);
+		return -1;
+	}
+
+	GFileOutputStream *g_output_stream = g_file_append_to(dest, G_FILE_CREATE_NONE, NULL, &error);
+
+	if (g_output_stream == NULL) {
+		REMMINA_DEBUG("Error appending to file: %s", error->message);
+		g_error_free(error);
+		g_object_unref(base_stream);
+		g_object_unref(gzlib_compressor);
+		g_object_unref(converted_input_stream);
+		g_free(bytes_written);
+		g_free(converted);
+		return -1;
+	}
+	g_output_stream_write_all(G_OUTPUT_STREAM(g_output_stream), converted, total_read, bytes_written, NULL, &error);
+	if (error != NULL) {
+		REMMINA_DEBUG("Error writing all bytes to file: %s", error->message);
+		g_error_free(error);
+		g_object_unref(base_stream);
+		g_object_unref(gzlib_compressor);
+		g_object_unref(converted_input_stream);
+		g_object_unref(g_output_stream);
+		g_free(bytes_written);
+		g_free(converted);
+		return -1;
+	}
+
+	g_object_unref(base_stream);
+	g_object_unref(gzlib_compressor);
+	g_object_unref(converted_input_stream);
+	g_object_unref(g_output_stream);
+	g_free(bytes_written);
+	g_free(converted);
+	return total_read;
+}
diff --git a/src/remmina_utils.h b/src/remmina_utils.h
new file mode 100644
index 0000000..8c3af3f
--- /dev/null
+++ b/src/remmina_utils.h
@@ -0,0 +1,86 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2016-2023 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2023-2024 Hiroyuki Tanaka, Sunil Bhat
+ *
+ * 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.
+ *
+ */
+
+/**
+ *  @file: remmina_utils.h
+ *  General utility functions, non-GTK related.
+ */
+
+#pragma once
+
+#include <glib.h>
+#include <gio/gio.h>
+#include <openssl/rsa.h>
+#include <openssl/evp.h>
+#include <openssl/decoder.h>
+
+#define MAX_COMPRESSED_FILE_SIZE 100000 //100kb file size max
+#define NAME_OF_DIGEST "SHA256"
+#define RSA_KEYTYPE "RSA"
+
+extern const char *remmina_RSA_PubKey_v1;
+extern const char *remmina_RSA_PubKey_v2;
+extern const char *remmina_EC_PubKey;
+G_BEGIN_DECLS
+gint remmina_utils_string_find(GString *haystack, gint start, gint end, const gchar *needle);
+gint remmina_utils_string_replace(GString *str, gint pos, gint len, const gchar *replace);
+
+guint remmina_utils_string_replace_all(GString *haystack, const gchar *needle, const gchar *replace);
+gchar *remmina_utils_string_strip(const gchar *s);
+
+gchar *remmina_utils_get_lang();
+gchar *remmina_utils_get_kernel_name();
+gchar *remmina_utils_get_kernel_release();
+gchar *remmina_utils_get_kernel_arch();
+gchar *remmina_utils_get_lsb_id();
+gchar *remmina_utils_get_lsb_description();
+gchar *remmina_utils_get_lsb_release();
+gchar *remmina_utils_get_lsb_codename();
+GHashTable *remmina_utils_get_etc_release();
+gchar *remmina_utils_get_dev();
+gchar *remmina_utils_get_logical();
+gchar *remmina_utils_get_link();
+gchar *remmina_utils_get_python();
+gchar *remmina_utils_get_mage();
+gchar *remmina_sha256_buffer(const guchar *buffer, gssize length);
+gchar *remmina_sha1_file(const gchar *filename);
+gchar *remmina_gen_random_uuid();
+EVP_PKEY *remmina_get_pubkey(const char *keytype, const char *public_key_selection);
+gchar *remmina_rsa_encrypt_string(EVP_PKEY *pubkey, const char *instr);
+int remmina_decompress_from_memory_to_file(guchar *source, int len, GFile* plugin_file);
+int remmina_compress_from_file_to_file(GFile *source, GFile *dest);
+gboolean remmina_verify_plugin_signature(const guchar *signature, GFile* plugin_file, size_t message_length, size_t signature_length);
+gboolean remmina_execute_plugin_signature_verification(GFile* plugin_file, size_t msg_len, const guchar *sig, size_t sig_len, EVP_PKEY* public_key);
+G_END_DECLS
diff --git a/src/remmina_widget_pool.c b/src/remmina_widget_pool.c
new file mode 100644
index 0000000..53c32a0
--- /dev/null
+++ b/src/remmina_widget_pool.c
@@ -0,0 +1,144 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009 - 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 <gmodule.h>
+#include "remmina_public.h"
+#include "remmina_widget_pool.h"
+#include "remmina/remmina_trace_calls.h"
+
+static GPtrArray *remmina_widget_pool = NULL;
+
+void remmina_widget_pool_init(void)
+{
+	TRACE_CALL(__func__);
+	remmina_widget_pool = g_ptr_array_new();
+}
+
+static void remmina_widget_pool_on_widget_destroy(GtkWidget *widget, gpointer data)
+{
+	TRACE_CALL(__func__);
+	g_ptr_array_remove(remmina_widget_pool, widget);
+}
+
+void remmina_widget_pool_register(GtkWidget *widget)
+{
+	TRACE_CALL(__func__);
+	g_ptr_array_add(remmina_widget_pool, widget);
+	g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(remmina_widget_pool_on_widget_destroy), NULL);
+}
+
+GtkWidget*
+remmina_widget_pool_find(GType type, const gchar *tag)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget;
+	gint i;
+
+	if (remmina_widget_pool == NULL)
+		return NULL;
+
+	for (i = 0; i < remmina_widget_pool->len; i++) {
+		widget = GTK_WIDGET(g_ptr_array_index(remmina_widget_pool, i));
+		if (!G_TYPE_CHECK_INSTANCE_TYPE(widget, type))
+			continue;
+		if (tag && g_strcmp0((const gchar*)g_object_get_data(G_OBJECT(widget), "tag"), tag) != 0)
+			continue;
+		return widget;
+	}
+	return NULL;
+}
+
+GtkWidget*
+remmina_widget_pool_find_by_window(GType type, GdkWindow *window)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget;
+	gint i;
+	GdkWindow *parent;
+
+	if (window == NULL || remmina_widget_pool == NULL)
+		return NULL;
+
+	for (i = 0; i < remmina_widget_pool->len; i++) {
+		widget = GTK_WIDGET(g_ptr_array_index(remmina_widget_pool, i));
+		if (!G_TYPE_CHECK_INSTANCE_TYPE(widget, type))
+			continue;
+		/* gdk_window_get_toplevel won’t work here, if the window is an embedded client. So we iterate the window tree */
+		for (parent = window; parent && parent != GDK_WINDOW_ROOT; parent = gdk_window_get_parent(parent)) {
+			if (gtk_widget_get_window(widget) == parent)
+				return widget;
+		}
+	}
+	return NULL;
+}
+
+gint remmina_widget_pool_foreach(RemminaWidgetPoolForEachFunc callback, gpointer data)
+{
+	TRACE_CALL(__func__);
+	GtkWidget *widget;
+	gint i;
+	gint n = 0;
+	GPtrArray *wpcpy = NULL;
+
+	if (remmina_widget_pool == NULL)
+		return 0;
+
+	/* Make a copy of remmina_widget_pool, so we can survive when callback()
+	 * remove an element from remmina_widget_pool */
+
+	wpcpy = g_ptr_array_sized_new(remmina_widget_pool->len);
+
+	for (i = 0; i < remmina_widget_pool->len; i++)
+		g_ptr_array_add(wpcpy, g_ptr_array_index(remmina_widget_pool, i));
+
+	/* Scan the remmina_widget_pool and call callbac() on every element */
+	for (i = 0; i < wpcpy->len; i++) {
+		widget = GTK_WIDGET(g_ptr_array_index(wpcpy, i));
+		if (callback(widget, data))
+			n++;
+	}
+
+	/* Free the copy */
+	g_ptr_array_unref(wpcpy);
+	return n;
+}
+
+gint remmina_widget_pool_count()
+{
+	TRACE_CALL(__func__);
+	return remmina_widget_pool->len;
+}
+
diff --git a/src/remmina_widget_pool.h b/src/remmina_widget_pool.h
new file mode 100644
index 0000000..81fd130
--- /dev/null
+++ b/src/remmina_widget_pool.h
@@ -0,0 +1,51 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2009 - Vic Lee
+ * Copyright (C) 2017-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.
+ *
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+typedef gboolean (*RemminaWidgetPoolForEachFunc)(GtkWidget *widget, gpointer data);
+
+void remmina_widget_pool_init(void);
+void remmina_widget_pool_register(GtkWidget *widget);
+GtkWidget *remmina_widget_pool_find(GType type, const gchar *tag);
+GtkWidget *remmina_widget_pool_find_by_window(GType type, GdkWindow *window);
+gint remmina_widget_pool_foreach(RemminaWidgetPoolForEachFunc callback, gpointer data);
+gint remmina_widget_pool_count(void);
+
+G_END_DECLS