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

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

1 files changed, 1057 insertions, 0 deletions

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