summaryrefslogtreecommitdiff
path: root/src/fr-archive.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/fr-archive.c')
-rw-r--r--src/fr-archive.c3354
1 files changed, 3354 insertions, 0 deletions
diff --git a/src/fr-archive.c b/src/fr-archive.c
new file mode 100644
index 0000000..1e79812
--- /dev/null
+++ b/src/fr-archive.c
@@ -0,0 +1,3354 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ * File-Roller
+ *
+ * Copyright (C) 2001, 2003, 2007, 2008 Free Software Foundation, Inc.
+ *
+ * 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., 59 Temple Street #330, Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/param.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <gio/gio.h>
+#include "glib-utils.h"
+#include "file-utils.h"
+#include "gio-utils.h"
+#include "file-data.h"
+#include "fr-archive.h"
+#include "fr-command.h"
+#include "fr-error.h"
+#include "fr-marshal.h"
+#include "fr-process.h"
+#include "main.h"
+
+#ifndef NCARGS
+#define NCARGS _POSIX_ARG_MAX
+#endif
+
+
+/* -- DroppedItemsData -- */
+
+
+typedef struct {
+ FrArchive *archive;
+ GList *item_list;
+ char *base_dir;
+ char *dest_dir;
+ gboolean update;
+ char *password;
+ gboolean encrypt_header;
+ FrCompression compression;
+ guint volume_size;
+} DroppedItemsData;
+
+
+static DroppedItemsData *
+dropped_items_data_new (FrArchive *archive,
+ GList *item_list,
+ const char *base_dir,
+ const char *dest_dir,
+ gboolean update,
+ const char *password,
+ gboolean encrypt_header,
+ FrCompression compression,
+ guint volume_size)
+{
+ DroppedItemsData *data;
+
+ data = g_new0 (DroppedItemsData, 1);
+ data->archive = archive;
+ data->item_list = path_list_dup (item_list);
+ if (base_dir != NULL)
+ data->base_dir = g_strdup (base_dir);
+ if (dest_dir != NULL)
+ data->dest_dir = g_strdup (dest_dir);
+ data->update = update;
+ if (password != NULL)
+ data->password = g_strdup (password);
+ data->encrypt_header = encrypt_header;
+ data->compression = compression;
+ data->volume_size = volume_size;
+
+ return data;
+}
+
+
+static void
+dropped_items_data_free (DroppedItemsData *data)
+{
+ if (data == NULL)
+ return;
+ path_list_free (data->item_list);
+ g_free (data->base_dir);
+ g_free (data->dest_dir);
+ g_free (data->password);
+ g_free (data);
+}
+
+
+struct _FrArchivePrivData {
+ FakeLoadFunc fake_load_func; /* If returns TRUE, archives are not read when
+ * fr_archive_load is invoked, used
+ * in batch mode. */
+ gpointer fake_load_data;
+ FakeLoadFunc add_is_stoppable_func; /* Returns whether the add operation is
+ * stoppable. */
+ gpointer add_is_stoppable_data;
+ GCancellable *cancellable;
+ char *temp_dir;
+ gboolean continue_adding_dropped_items;
+ DroppedItemsData *dropped_items_data;
+
+ char *temp_extraction_dir;
+ char *extraction_destination;
+ gboolean remote_extraction;
+ gboolean extract_here;
+};
+
+
+typedef struct {
+ FrArchive *archive;
+ char *uri;
+ FrAction action;
+ GList *file_list;
+ char *base_uri;
+ char *dest_dir;
+ gboolean update;
+ char *tmp_dir;
+ guint source_id;
+ char *password;
+ gboolean encrypt_header;
+ FrCompression compression;
+ guint volume_size;
+} XferData;
+
+
+static void
+xfer_data_free (XferData *data)
+{
+ if (data == NULL)
+ return;
+
+ g_free (data->uri);
+ g_free (data->password);
+ path_list_free (data->file_list);
+ g_free (data->base_uri);
+ g_free (data->dest_dir);
+ g_free (data->tmp_dir);
+ g_free (data);
+}
+
+
+#define MAX_CHUNK_LEN (NCARGS * 2 / 3) /* Max command line length */
+#define UNKNOWN_TYPE "application/octet-stream"
+#define SAME_FS (FALSE)
+#define NO_BACKUP_FILES (TRUE)
+#define NO_DOT_FILES (FALSE)
+#define IGNORE_CASE (FALSE)
+#define LIST_LENGTH_TO_USE_FILE 10 /* FIXME: find a good value */
+
+
+enum {
+ START,
+ DONE,
+ PROGRESS,
+ MESSAGE,
+ STOPPABLE,
+ WORKING_ARCHIVE,
+ LAST_SIGNAL
+};
+
+static GObjectClass *parent_class;
+static guint fr_archive_signals[LAST_SIGNAL] = { 0 };
+
+static void fr_archive_class_init (FrArchiveClass *class);
+static void fr_archive_init (FrArchive *archive);
+static void fr_archive_finalize (GObject *object);
+
+
+GType
+fr_archive_get_type (void)
+{
+ static GType type = 0;
+
+ if (! type) {
+ static const GTypeInfo type_info = {
+ sizeof (FrArchiveClass),
+ NULL,
+ NULL,
+ (GClassInitFunc) fr_archive_class_init,
+ NULL,
+ NULL,
+ sizeof (FrArchive),
+ 0,
+ (GInstanceInitFunc) fr_archive_init
+ };
+
+ type = g_type_register_static (G_TYPE_OBJECT,
+ "FrArchive",
+ &type_info,
+ 0);
+ }
+
+ return type;
+}
+
+
+static void
+fr_archive_class_init (FrArchiveClass *class)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+
+ parent_class = g_type_class_peek_parent (class);
+
+ gobject_class->finalize = fr_archive_finalize;
+
+ class->start = NULL;
+ class->done = NULL;
+ class->progress = NULL;
+ class->message = NULL;
+ class->working_archive = NULL;
+
+ /* signals */
+
+ fr_archive_signals[START] =
+ g_signal_new ("start",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (FrArchiveClass, start),
+ NULL, NULL,
+ fr_marshal_VOID__INT,
+ G_TYPE_NONE,
+ 1, G_TYPE_INT);
+ fr_archive_signals[DONE] =
+ g_signal_new ("done",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (FrArchiveClass, done),
+ NULL, NULL,
+ fr_marshal_VOID__INT_POINTER,
+ G_TYPE_NONE, 2,
+ G_TYPE_INT,
+ G_TYPE_POINTER);
+ fr_archive_signals[PROGRESS] =
+ g_signal_new ("progress",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (FrArchiveClass, progress),
+ NULL, NULL,
+ fr_marshal_VOID__DOUBLE,
+ G_TYPE_NONE, 1,
+ G_TYPE_DOUBLE);
+ fr_archive_signals[MESSAGE] =
+ g_signal_new ("message",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (FrArchiveClass, message),
+ NULL, NULL,
+ fr_marshal_VOID__STRING,
+ G_TYPE_NONE, 1,
+ G_TYPE_STRING);
+ fr_archive_signals[STOPPABLE] =
+ g_signal_new ("stoppable",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (FrArchiveClass, stoppable),
+ NULL, NULL,
+ fr_marshal_VOID__BOOL,
+ G_TYPE_NONE,
+ 1, G_TYPE_BOOLEAN);
+ fr_archive_signals[WORKING_ARCHIVE] =
+ g_signal_new ("working_archive",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (FrArchiveClass, working_archive),
+ NULL, NULL,
+ fr_marshal_VOID__STRING,
+ G_TYPE_NONE, 1,
+ G_TYPE_STRING);
+}
+
+
+void
+fr_archive_stoppable (FrArchive *archive,
+ gboolean stoppable)
+{
+ g_signal_emit (G_OBJECT (archive),
+ fr_archive_signals[STOPPABLE],
+ 0,
+ stoppable);
+}
+
+
+void
+fr_archive_stop (FrArchive *archive)
+{
+ if (archive->process != NULL) {
+ fr_process_stop (archive->process);
+ return;
+ }
+
+ if (! g_cancellable_is_cancelled (archive->priv->cancellable))
+ g_cancellable_cancel (archive->priv->cancellable);
+}
+
+
+void
+fr_archive_action_completed (FrArchive *archive,
+ FrAction action,
+ FrProcErrorType error_type,
+ const char *error_details)
+{
+ archive->error.type = error_type;
+ archive->error.status = 0;
+ g_clear_error (&archive->error.gerror);
+ if (error_details != NULL)
+ archive->error.gerror = g_error_new_literal (fr_error_quark (),
+ 0,
+ error_details);
+ g_signal_emit (G_OBJECT (archive),
+ fr_archive_signals[DONE],
+ 0,
+ action,
+ &archive->error);
+}
+
+
+static gboolean
+fr_archive_add_is_stoppable (FrArchive *archive)
+{
+ if (archive->priv->add_is_stoppable_func != NULL)
+ return (*archive->priv->add_is_stoppable_func) (archive, archive->priv->add_is_stoppable_data);
+ else
+ return FALSE;
+}
+
+
+static gboolean
+archive_sticky_only_cb (FrProcess *process,
+ FrArchive *archive)
+{
+ fr_archive_stoppable (archive, fr_archive_add_is_stoppable (archive));
+ return TRUE;
+}
+
+
+static void
+fr_archive_init (FrArchive *archive)
+{
+ archive->file = NULL;
+ archive->local_copy = NULL;
+ archive->is_remote = FALSE;
+ archive->command = NULL;
+ archive->is_compressed_file = FALSE;
+ archive->can_create_compressed_file = FALSE;
+
+ archive->priv = g_new0 (FrArchivePrivData, 1);
+ archive->priv->fake_load_func = NULL;
+ archive->priv->fake_load_data = NULL;
+ archive->priv->add_is_stoppable_func = NULL;
+ archive->priv->add_is_stoppable_data = NULL;
+
+ archive->priv->extraction_destination = NULL;
+ archive->priv->temp_extraction_dir = NULL;
+ archive->priv->cancellable = g_cancellable_new ();
+
+ archive->process = fr_process_new ();
+ g_signal_connect (G_OBJECT (archive->process),
+ "sticky_only",
+ G_CALLBACK (archive_sticky_only_cb),
+ archive);
+}
+
+
+FrArchive *
+fr_archive_new (void)
+{
+ return FR_ARCHIVE (g_object_new (FR_TYPE_ARCHIVE, NULL));
+}
+
+
+static GFile *
+get_local_copy_for_file (GFile *remote_file)
+{
+ char *temp_dir;
+ GFile *local_copy = NULL;
+
+ temp_dir = get_temp_work_dir (NULL);
+ if (temp_dir != NULL) {
+ char *archive_name;
+ char *local_path;
+
+ archive_name = g_file_get_basename (remote_file);
+ local_path = g_build_filename (temp_dir, archive_name, NULL);
+ local_copy = g_file_new_for_path (local_path);
+
+ g_free (local_path);
+ g_free (archive_name);
+ }
+ g_free (temp_dir);
+
+ return local_copy;
+}
+
+
+static void
+fr_archive_set_uri (FrArchive *archive,
+ const char *uri)
+{
+ if ((archive->local_copy != NULL) && archive->is_remote) {
+ GFile *temp_folder;
+ GError *err = NULL;
+
+ g_file_delete (archive->local_copy, NULL, &err);
+ if (err != NULL) {
+ g_warning ("Failed to delete the local copy: %s", err->message);
+ g_clear_error (&err);
+ }
+
+ temp_folder = g_file_get_parent (archive->local_copy);
+ g_file_delete (temp_folder, NULL, &err);
+ if (err != NULL) {
+ g_warning ("Failed to delete temp folder: %s", err->message);
+ g_clear_error (&err);
+ }
+
+ g_object_unref (temp_folder);
+ }
+
+ if (archive->file != NULL) {
+ g_object_unref (archive->file);
+ archive->file = NULL;
+ }
+ if (archive->local_copy != NULL) {
+ g_object_unref (archive->local_copy);
+ archive->local_copy = NULL;
+ }
+ archive->content_type = NULL;
+
+ if (uri == NULL)
+ return;
+
+ archive->file = g_file_new_for_uri (uri);
+ archive->is_remote = ! g_file_has_uri_scheme (archive->file, "file");
+ if (archive->is_remote)
+ archive->local_copy = get_local_copy_for_file (archive->file);
+ else
+ archive->local_copy = g_file_dup (archive->file);
+}
+
+
+static void
+fr_archive_remove_temp_work_dir (FrArchive *archive)
+{
+ if (archive->priv->temp_dir == NULL)
+ return;
+ remove_local_directory (archive->priv->temp_dir);
+ g_free (archive->priv->temp_dir);
+ archive->priv->temp_dir = NULL;
+}
+
+
+static void
+fr_archive_finalize (GObject *object)
+{
+ FrArchive *archive;
+
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (FR_IS_ARCHIVE (object));
+
+ archive = FR_ARCHIVE (object);
+
+ fr_archive_set_uri (archive, NULL);
+ fr_archive_remove_temp_work_dir (archive);
+ if (archive->command != NULL)
+ g_object_unref (archive->command);
+ g_object_unref (archive->process);
+ if (archive->priv->dropped_items_data != NULL) {
+ dropped_items_data_free (archive->priv->dropped_items_data);
+ archive->priv->dropped_items_data = NULL;
+ }
+ g_free (archive->priv->temp_extraction_dir);
+ g_free (archive->priv->extraction_destination);
+ g_free (archive->priv);
+
+ /* Chain up */
+
+ if (G_OBJECT_CLASS (parent_class)->finalize)
+ G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+
+static const char *
+get_mime_type_from_content (GFile *file)
+{
+ GFileInfo *info;
+ GError *err = NULL;
+ const char *content_type = NULL;
+
+ info = g_file_query_info (file,
+ G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
+ 0, NULL, &err);
+ if (info == NULL) {
+ g_warning ("could not get content type: %s", err->message);
+ g_clear_error (&err);
+ }
+ else {
+ content_type = get_static_string (g_file_info_get_content_type (info));
+ g_object_unref (info);
+ }
+
+ return content_type;
+}
+
+
+static const char *
+get_mime_type_from_magic_numbers (GFile *file)
+{
+ static struct {
+ const char *mime_type;
+ const char *first_bytes;
+ int offset;
+ int len;
+ } sniffer_data [] = {
+ /* Magic numbers taken from magic/Magdir/archive from the
+ * file-4.21 tarball. */
+ { "application/x-7z-compressed", "7z\274\257\047\034", 0, 5 },
+ { "application/x-ace", "**ACE**", 7, 7 },
+ { "application/x-arj", "\x60\xea", 0, 2 },
+ { "application/x-bzip2", "BZh", 0, 3 },
+ { "application/x-gzip", "\037\213", 0, 2 },
+ { "application/x-lzip", "LZIP", 0, 4 },
+ { "application/x-lzop", "\x89\x4c\x5a\x4f\x00\x0d\x0a\x1a\x0a", 0, 9 },
+ { "application/x-rar", "Rar!", 0, 4 },
+ { "application/x-rzip", "RZIP", 0, 4 },
+ { "application/x-xz", "\3757zXZ\000", 0, 6 },
+ { "application/x-zoo", "\xdc\xa7\xc4\xfd", 20, 4 },
+ { "application/zip", "PK\003\004", 0, 4 },
+ { "application/zip", "PK00PK\003\004", 0, 8 },
+ { "application/x-lrzip", "LRZI", 0, 4 },
+ { NULL, NULL, 0 }
+ };
+ char buffer[32];
+ int i;
+
+ if (! g_load_file_in_buffer (file, buffer, 32, NULL))
+ return NULL;
+
+ for (i = 0; sniffer_data[i].mime_type != NULL; i++)
+ if (memcmp (sniffer_data[i].first_bytes,
+ buffer + sniffer_data[i].offset,
+ sniffer_data[i].len) == 0)
+ {
+ return sniffer_data[i].mime_type;
+ }
+
+ return NULL;
+}
+
+
+static const char *
+get_mime_type_from_filename (GFile *file)
+{
+ const char *mime_type = NULL;
+ char *filename;
+
+ if (file == NULL)
+ return NULL;
+
+ filename = g_file_get_path (file);
+ mime_type = get_mime_type_from_extension (get_file_extension (filename));
+ g_free (filename);
+
+ return mime_type;
+}
+
+
+static gboolean
+create_command_from_type (FrArchive *archive,
+ const char *mime_type,
+ GType command_type,
+ FrCommandCaps requested_capabilities)
+{
+ char *filename;
+
+ if (command_type == 0)
+ return FALSE;
+
+ filename = g_file_get_path (archive->local_copy);
+ archive->command = FR_COMMAND (g_object_new (command_type,
+ "process", archive->process,
+ "filename", filename,
+ "mime-type", mime_type,
+ NULL));
+ g_free (filename);
+
+ if (! fr_command_is_capable_of (archive->command, requested_capabilities)) {
+ g_object_unref (archive->command);
+ archive->command = NULL;
+ archive->is_compressed_file = FALSE;
+ }
+ else
+ archive->is_compressed_file = ! fr_command_is_capable_of (archive->command, FR_COMMAND_CAN_ARCHIVE_MANY_FILES);
+
+ return (archive->command != NULL);
+}
+
+
+static gboolean
+create_command_to_load_archive (FrArchive *archive,
+ const char *mime_type)
+{
+ FrCommandCaps requested_capabilities = FR_COMMAND_CAN_DO_NOTHING;
+ GType command_type;
+
+ if (mime_type == NULL)
+ return FALSE;
+
+ /* try with the WRITE capability even when loading, this way we give
+ * priority to the commands that can read and write over commands
+ * that can only read a specific file format. */
+
+ requested_capabilities |= FR_COMMAND_CAN_READ_WRITE;
+ command_type = get_command_type_from_mime_type (mime_type, requested_capabilities);
+
+ /* if no command was found, remove the write capability and try again */
+
+ if (command_type == 0) {
+ requested_capabilities ^= FR_COMMAND_CAN_WRITE;
+ command_type = get_command_type_from_mime_type (mime_type, requested_capabilities);
+ }
+
+ return create_command_from_type (archive,
+ mime_type,
+ command_type,
+ requested_capabilities);
+}
+
+
+static gboolean
+create_command_to_create_archive (FrArchive *archive,
+ const char *mime_type)
+{
+ FrCommandCaps requested_capabilities = FR_COMMAND_CAN_DO_NOTHING;
+ GType command_type;
+
+ if (mime_type == NULL)
+ return FALSE;
+
+ requested_capabilities |= FR_COMMAND_CAN_WRITE;
+ command_type = get_command_type_from_mime_type (mime_type, requested_capabilities);
+
+ return create_command_from_type (archive,
+ mime_type,
+ command_type,
+ requested_capabilities);
+}
+
+
+static void
+action_started (FrCommand *command,
+ FrAction action,
+ FrArchive *archive)
+{
+#ifdef DEBUG
+ debug (DEBUG_INFO, "%s [START] (FR::Archive)\n", action_names[action]);
+#endif
+
+ g_signal_emit (G_OBJECT (archive),
+ fr_archive_signals[START],
+ 0,
+ action);
+}
+
+
+/* -- copy_to_remote_location -- */
+
+
+static void
+fr_archive_copy_done (FrArchive *archive,
+ FrAction action,
+ GError *error)
+{
+ FrProcErrorType error_type = FR_PROC_ERROR_NONE;
+ const char *error_details = NULL;
+
+ if (error != NULL) {
+ error_type = (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) ? FR_PROC_ERROR_STOPPED : FR_PROC_ERROR_GENERIC);
+ error_details = error->message;
+ }
+ fr_archive_action_completed (archive, action, error_type, error_details);
+}
+
+
+static void
+copy_to_remote_location_done (GError *error,
+ gpointer user_data)
+{
+ XferData *xfer_data = user_data;
+
+ fr_archive_copy_done (xfer_data->archive, xfer_data->action, error);
+ xfer_data_free (xfer_data);
+}
+
+
+static void
+copy_to_remote_location_progress (goffset current_file,
+ goffset total_files,
+ GFile *source,
+ GFile *destination,
+ goffset current_num_bytes,
+ goffset total_num_bytes,
+ gpointer user_data)
+{
+ XferData *xfer_data = user_data;
+
+ g_signal_emit (G_OBJECT (xfer_data->archive),
+ fr_archive_signals[PROGRESS],
+ 0,
+ (double) current_num_bytes / total_num_bytes);
+}
+
+
+static void
+copy_to_remote_location (FrArchive *archive,
+ FrAction action)
+{
+ XferData *xfer_data;
+
+ xfer_data = g_new0 (XferData, 1);
+ xfer_data->archive = archive;
+ xfer_data->action = action;
+
+ g_copy_file_async (archive->local_copy,
+ archive->file,
+ G_FILE_COPY_OVERWRITE,
+ G_PRIORITY_DEFAULT,
+ archive->priv->cancellable,
+ copy_to_remote_location_progress,
+ xfer_data,
+ copy_to_remote_location_done,
+ xfer_data);
+}
+
+
+/* -- copy_extracted_files_to_destination -- */
+
+
+static void
+move_here (FrArchive *archive)
+{
+ char *content_uri;
+ char *parent;
+ char *parent_parent;
+ char *new_content_uri;
+ GFile *source, *destination, *parent_file;
+ GError *error = NULL;
+
+ content_uri = get_dir_content_if_unique (archive->priv->extraction_destination);
+ if (content_uri == NULL)
+ return;
+
+ parent = remove_level_from_path (content_uri);
+
+ if (uricmp (parent, archive->priv->extraction_destination) == 0) {
+ char *new_uri;
+
+ new_uri = get_alternative_uri_for_uri (archive->priv->extraction_destination);
+
+ source = g_file_new_for_uri (archive->priv->extraction_destination);
+ destination = g_file_new_for_uri (new_uri);
+ if (! g_file_move (source, destination, 0, NULL, NULL, NULL, &error)) {
+ g_warning ("could not rename %s to %s: %s", archive->priv->extraction_destination, new_uri, error->message);
+ g_clear_error (&error);
+ }
+ g_object_unref (source);
+ g_object_unref (destination);
+
+ g_free (archive->priv->extraction_destination);
+ archive->priv->extraction_destination = new_uri;
+
+ g_free (parent);
+
+ content_uri = get_dir_content_if_unique (archive->priv->extraction_destination);
+ if (content_uri == NULL)
+ return;
+
+ parent = remove_level_from_path (content_uri);
+ }
+
+ parent_parent = remove_level_from_path (parent);
+ new_content_uri = get_alternative_uri (parent_parent, file_name_from_path (content_uri));
+
+ source = g_file_new_for_uri (content_uri);
+ destination = g_file_new_for_uri (new_content_uri);
+ if (! g_file_move (source, destination, 0, NULL, NULL, NULL, &error)) {
+ g_warning ("could not rename %s to %s: %s", content_uri, new_content_uri, error->message);
+ g_clear_error (&error);
+ }
+
+ parent_file = g_file_new_for_uri (parent);
+ if (! g_file_delete (parent_file, NULL, &error)) {
+ g_warning ("could not remove directory %s: %s", parent, error->message);
+ g_clear_error (&error);
+ }
+ g_object_unref (parent_file);
+
+ g_free (archive->priv->extraction_destination);
+ archive->priv->extraction_destination = new_content_uri;
+
+ g_free (parent_parent);
+ g_free (parent);
+ g_free (content_uri);
+}
+
+
+static void
+copy_extracted_files_done (GError *error,
+ gpointer user_data)
+{
+ FrArchive *archive = user_data;
+
+ remove_local_directory (archive->priv->temp_extraction_dir);
+ g_free (archive->priv->temp_extraction_dir);
+ archive->priv->temp_extraction_dir = NULL;
+
+ fr_archive_action_completed (archive,
+ FR_ACTION_COPYING_FILES_TO_REMOTE,
+ FR_PROC_ERROR_NONE,
+ NULL);
+
+ if ((error == NULL) && (archive->priv->extract_here))
+ move_here (archive);
+
+ fr_archive_copy_done (archive, FR_ACTION_EXTRACTING_FILES, error);
+}
+
+
+static void
+copy_extracted_files_progress (goffset current_file,
+ goffset total_files,
+ GFile *source,
+ GFile *destination,
+ goffset current_num_bytes,
+ goffset total_num_bytes,
+ gpointer user_data)
+{
+ FrArchive *archive = user_data;
+
+ g_signal_emit (G_OBJECT (archive),
+ fr_archive_signals[PROGRESS],
+ 0,
+ (double) current_file / (total_files + 1));
+}
+
+
+static void
+copy_extracted_files_to_destination (FrArchive *archive)
+{
+ g_directory_copy_async (archive->priv->temp_extraction_dir,
+ archive->priv->extraction_destination,
+ G_FILE_COPY_OVERWRITE,
+ G_PRIORITY_DEFAULT,
+ archive->priv->cancellable,
+ copy_extracted_files_progress,
+ archive,
+ copy_extracted_files_done,
+ archive);
+}
+
+
+static void add_dropped_items (DroppedItemsData *data);
+
+
+static void
+fr_archive_change_name (FrArchive *archive,
+ const char *filename)
+{
+ const char *name;
+ GFile *parent;
+
+ name = file_name_from_path (filename);
+
+ parent = g_file_get_parent (archive->file);
+ g_object_unref (archive->file);
+ archive->file = g_file_get_child (parent, name);
+ g_object_unref (parent);
+
+ parent = g_file_get_parent (archive->local_copy);
+ g_object_unref (archive->local_copy);
+ archive->local_copy = g_file_get_child (parent, name);
+ g_object_unref (parent);
+}
+
+
+static void
+action_performed (FrCommand *command,
+ FrAction action,
+ FrProcError *error,
+ FrArchive *archive)
+{
+#ifdef DEBUG
+ debug (DEBUG_INFO, "%s [DONE] (FR::Archive)\n", action_names[action]);
+#endif
+
+ switch (action) {
+ case FR_ACTION_DELETING_FILES:
+ if (error->type == FR_PROC_ERROR_NONE) {
+ if (! g_file_has_uri_scheme (archive->file, "file")) {
+ copy_to_remote_location (archive, action);
+ return;
+ }
+ }
+ break;
+
+ case FR_ACTION_ADDING_FILES:
+ if (error->type == FR_PROC_ERROR_NONE) {
+ fr_archive_remove_temp_work_dir (archive);
+ if (archive->priv->continue_adding_dropped_items) {
+ add_dropped_items (archive->priv->dropped_items_data);
+ return;
+ }
+ if (archive->priv->dropped_items_data != NULL) {
+ dropped_items_data_free (archive->priv->dropped_items_data);
+ archive->priv->dropped_items_data = NULL;
+ }
+ /* the name of the volumes are different from the
+ * original name */
+ if (archive->command->multi_volume)
+ fr_archive_change_name (archive, archive->command->filename);
+ if (! g_file_has_uri_scheme (archive->file, "file")) {
+ copy_to_remote_location (archive, action);
+ return;
+ }
+ }
+ break;
+
+ case FR_ACTION_EXTRACTING_FILES:
+ if (error->type == FR_PROC_ERROR_NONE) {
+ if (archive->priv->remote_extraction) {
+ copy_extracted_files_to_destination (archive);
+ return;
+ }
+ else if (archive->priv->extract_here)
+ move_here (archive);
+ }
+ else {
+ /* if an error occurred during extraction remove the
+ * temp extraction dir, if used. */
+ g_print ("action_performed: ERROR!\n");
+
+ if ((archive->priv->remote_extraction) && (archive->priv->temp_extraction_dir != NULL)) {
+ remove_local_directory (archive->priv->temp_extraction_dir);
+ g_free (archive->priv->temp_extraction_dir);
+ archive->priv->temp_extraction_dir = NULL;
+ }
+
+ if (archive->priv->extract_here)
+ remove_directory (archive->priv->extraction_destination);
+ }
+ break;
+
+ case FR_ACTION_LISTING_CONTENT:
+ /* the name of the volumes are different from the
+ * original name */
+ if (archive->command->multi_volume)
+ fr_archive_change_name (archive, archive->command->filename);
+ fr_command_update_capabilities (archive->command);
+ if (! fr_command_is_capable_of (archive->command, FR_COMMAND_CAN_WRITE))
+ archive->read_only = TRUE;
+ break;
+
+ default:
+ /* nothing */
+ break;
+ }
+
+ g_signal_emit (G_OBJECT (archive),
+ fr_archive_signals[DONE],
+ 0,
+ action,
+ error);
+}
+
+
+static gboolean
+archive_progress_cb (FrCommand *command,
+ double fraction,
+ FrArchive *archive)
+{
+ g_signal_emit (G_OBJECT (archive),
+ fr_archive_signals[PROGRESS],
+ 0,
+ fraction);
+ return TRUE;
+}
+
+
+static gboolean
+archive_message_cb (FrCommand *command,
+ const char *msg,
+ FrArchive *archive)
+{
+ g_signal_emit (G_OBJECT (archive),
+ fr_archive_signals[MESSAGE],
+ 0,
+ msg);
+ return TRUE;
+}
+
+
+static gboolean
+archive_working_archive_cb (FrCommand *command,
+ const char *archive_filename,
+ FrArchive *archive)
+{
+ g_signal_emit (G_OBJECT (archive),
+ fr_archive_signals[WORKING_ARCHIVE],
+ 0,
+ archive_filename);
+ return TRUE;
+}
+
+
+static void
+fr_archive_connect_to_command (FrArchive *archive)
+{
+ g_signal_connect (G_OBJECT (archive->command),
+ "start",
+ G_CALLBACK (action_started),
+ archive);
+ g_signal_connect (G_OBJECT (archive->command),
+ "done",
+ G_CALLBACK (action_performed),
+ archive);
+ g_signal_connect (G_OBJECT (archive->command),
+ "progress",
+ G_CALLBACK (archive_progress_cb),
+ archive);
+ g_signal_connect (G_OBJECT (archive->command),
+ "message",
+ G_CALLBACK (archive_message_cb),
+ archive);
+ g_signal_connect (G_OBJECT (archive->command),
+ "working_archive",
+ G_CALLBACK (archive_working_archive_cb),
+ archive);
+}
+
+
+gboolean
+fr_archive_create (FrArchive *archive,
+ const char *uri)
+{
+ FrCommand *tmp_command;
+ const char *mime_type;
+
+ if (uri == NULL)
+ return FALSE;
+
+ fr_archive_set_uri (archive, uri);
+
+ tmp_command = archive->command;
+
+ mime_type = get_mime_type_from_filename (archive->local_copy);
+ if (! create_command_to_create_archive (archive, mime_type)) {
+ archive->command = tmp_command;
+ return FALSE;
+ }
+
+ if (tmp_command != NULL) {
+ g_signal_handlers_disconnect_by_data (tmp_command, archive);
+ g_object_unref (G_OBJECT (tmp_command));
+ }
+
+ fr_archive_connect_to_command (archive);
+ archive->read_only = FALSE;
+
+ return TRUE;
+}
+
+
+void
+fr_archive_set_fake_load_func (FrArchive *archive,
+ FakeLoadFunc func,
+ gpointer data)
+{
+ archive->priv->fake_load_func = func;
+ archive->priv->fake_load_data = data;
+}
+
+
+gboolean
+fr_archive_fake_load (FrArchive *archive)
+{
+ if (archive->priv->fake_load_func != NULL)
+ return (*archive->priv->fake_load_func) (archive, archive->priv->fake_load_data);
+ else
+ return FALSE;
+}
+
+
+/* -- fr_archive_load -- */
+
+
+static void
+load_local_archive (FrArchive *archive,
+ const char *password)
+{
+ FrCommand *tmp_command;
+ const char *mime_type;
+
+ if (! g_file_query_exists (archive->file, NULL)) {
+ fr_archive_action_completed (archive,
+ FR_ACTION_LOADING_ARCHIVE,
+ FR_PROC_ERROR_GENERIC,
+ _("File not found."));
+ return;
+ }
+
+ archive->have_permissions = check_file_permissions (archive->file, W_OK);
+ archive->read_only = ! archive->have_permissions;
+
+ tmp_command = archive->command;
+
+ mime_type = get_mime_type_from_filename (archive->local_copy);
+ if (! create_command_to_load_archive (archive, mime_type)) {
+ mime_type = get_mime_type_from_content (archive->local_copy);
+ if (! create_command_to_load_archive (archive, mime_type)) {
+ mime_type = get_mime_type_from_magic_numbers (archive->local_copy);
+ if (! create_command_to_load_archive (archive, mime_type)) {
+ archive->command = tmp_command;
+ archive->content_type = mime_type;
+ fr_archive_action_completed (archive,
+ FR_ACTION_LOADING_ARCHIVE,
+ FR_PROC_ERROR_UNSUPPORTED_FORMAT,
+ _("Archive type not supported."));
+ return;
+ }
+ }
+ }
+
+ if (tmp_command != NULL) {
+ g_signal_handlers_disconnect_by_data (tmp_command, archive);
+ g_object_unref (tmp_command);
+ }
+
+ fr_archive_connect_to_command (archive);
+ archive->content_type = mime_type;
+ if (! fr_command_is_capable_of (archive->command, FR_COMMAND_CAN_WRITE))
+ archive->read_only = TRUE;
+ fr_archive_stoppable (archive, TRUE);
+ archive->command->fake_load = fr_archive_fake_load (archive);
+
+ fr_archive_action_completed (archive,
+ FR_ACTION_LOADING_ARCHIVE,
+ FR_PROC_ERROR_NONE,
+ NULL);
+
+ /**/
+
+ fr_process_clear (archive->process);
+ g_object_set (archive->command, "password", password, NULL);
+ fr_command_list (archive->command);
+ fr_process_start (archive->process);
+}
+
+
+static void
+copy_remote_file_done (GError *error,
+ gpointer user_data)
+{
+ XferData *xfer_data = user_data;
+
+ if (error != NULL)
+ fr_archive_copy_done (xfer_data->archive, FR_ACTION_LOADING_ARCHIVE, error);
+ else
+ load_local_archive (xfer_data->archive, xfer_data->password);
+ xfer_data_free (xfer_data);
+}
+
+
+static void
+copy_remote_file_progress (goffset current_file,
+ goffset total_files,
+ GFile *source,
+ GFile *destination,
+ goffset current_num_bytes,
+ goffset total_num_bytes,
+ gpointer user_data)
+{
+ XferData *xfer_data = user_data;
+
+ g_signal_emit (G_OBJECT (xfer_data->archive),
+ fr_archive_signals[PROGRESS],
+ 0,
+ (double) current_num_bytes / total_num_bytes);
+}
+
+
+static gboolean
+copy_remote_file_done_cb (gpointer user_data)
+{
+ XferData *xfer_data = user_data;
+
+ g_source_remove (xfer_data->source_id);
+ copy_remote_file_done (NULL, xfer_data);
+ return FALSE;
+}
+
+
+static void
+copy_remote_file (FrArchive *archive,
+ const char *password)
+{
+ XferData *xfer_data;
+
+ if (! g_file_query_exists (archive->file, NULL)) {
+ GError *error;
+ error = g_error_new (G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("The file doesn't exist"));
+ fr_archive_copy_done (archive, FR_ACTION_LOADING_ARCHIVE, error);
+ g_error_free (error);
+ return;
+ }
+
+ xfer_data = g_new0 (XferData, 1);
+ xfer_data->archive = archive;
+ xfer_data->uri = g_file_get_uri (archive->file);
+ if (password != NULL)
+ xfer_data->password = g_strdup (password);
+
+ if (! archive->is_remote) {
+ xfer_data->source_id = g_idle_add (copy_remote_file_done_cb, xfer_data);
+ return;
+ }
+
+ g_copy_file_async (archive->file,
+ archive->local_copy,
+ G_FILE_COPY_OVERWRITE,
+ G_PRIORITY_DEFAULT,
+ archive->priv->cancellable,
+ copy_remote_file_progress,
+ xfer_data,
+ copy_remote_file_done,
+ xfer_data);
+}
+
+
+gboolean
+fr_archive_load (FrArchive *archive,
+ const char *uri,
+ const char *password)
+{
+ g_return_val_if_fail (archive != NULL, FALSE);
+
+ g_signal_emit (G_OBJECT (archive),
+ fr_archive_signals[START],
+ 0,
+ FR_ACTION_LOADING_ARCHIVE);
+
+ fr_archive_set_uri (archive, uri);
+ copy_remote_file (archive, password);
+
+ return TRUE;
+}
+
+
+gboolean
+fr_archive_load_local (FrArchive *archive,
+ const char *uri,
+ const char *password)
+{
+ g_return_val_if_fail (archive != NULL, FALSE);
+
+ g_signal_emit (G_OBJECT (archive),
+ fr_archive_signals[START],
+ 0,
+ FR_ACTION_LOADING_ARCHIVE);
+
+ fr_archive_set_uri (archive, uri);
+ copy_remote_file (archive, password);
+
+ return TRUE;
+}
+
+
+void
+fr_archive_reload (FrArchive *archive,
+ const char *password)
+{
+ char *uri;
+
+ g_return_if_fail (archive != NULL);
+ g_return_if_fail (archive->file != NULL);
+
+ fr_archive_stoppable (archive, TRUE);
+ archive->command->fake_load = fr_archive_fake_load (archive);
+
+ uri = g_file_get_uri (archive->file);
+ fr_archive_load (archive, uri, password);
+ g_free (uri);
+}
+
+
+void
+fr_archive_rename (FrArchive *archive,
+ const char *filename)
+{
+ g_return_if_fail (archive != NULL);
+
+ if (archive->is_compressed_file) {
+ /* If the archive is a compressed file we have to reload it,
+ * because in this case the 'content' of the archive changes
+ * too. */
+ fr_archive_load (archive, filename, NULL);
+ }
+ else {
+ if (archive->file != NULL)
+ g_object_unref (archive->file);
+ archive->file = g_file_new_for_path (filename);
+ fr_command_set_filename (archive->command, filename);
+ }
+}
+
+
+/* -- add -- */
+
+
+static char *
+create_tmp_base_dir (const char *base_dir,
+ const char *dest_path)
+{
+ char *dest_dir;
+ char *temp_dir;
+ char *tmp;
+ char *parent_dir;
+ char *dir;
+
+ if ((dest_path == NULL)
+ || (*dest_path == '\0')
+ || (strcmp (dest_path, "/") == 0))
+ {
+ return g_strdup (base_dir);
+ }
+
+ dest_dir = g_strdup (dest_path);
+ if (dest_dir[strlen (dest_dir) - 1] == G_DIR_SEPARATOR)
+ dest_dir[strlen (dest_dir) - 1] = 0;
+
+ debug (DEBUG_INFO, "base_dir: %s\n", base_dir);
+ debug (DEBUG_INFO, "dest_dir: %s\n", dest_dir);
+
+ temp_dir = get_temp_work_dir (NULL);
+ tmp = remove_level_from_path (dest_dir);
+ parent_dir = g_build_filename (temp_dir, tmp, NULL);
+ g_free (tmp);
+
+ debug (DEBUG_INFO, "mkdir %s\n", parent_dir);
+ make_directory_tree_from_path (parent_dir, 0700, NULL);
+ g_free (parent_dir);
+
+ dir = g_build_filename (temp_dir, "/", dest_dir, NULL);
+ debug (DEBUG_INFO, "symlink %s --> %s\n", dir, base_dir);
+ symlink (base_dir, dir);
+
+ g_free (dir);
+ g_free (dest_dir);
+
+ return temp_dir;
+}
+
+
+static FileData *
+find_file_in_archive (FrArchive *archive,
+ char *path)
+{
+ int i;
+
+ g_return_val_if_fail (path != NULL, NULL);
+
+ i = find_path_in_file_data_array (archive->command->files, path);
+ if (i >= 0)
+ return (FileData *) g_ptr_array_index (archive->command->files, i);
+ else
+ return NULL;
+}
+
+
+static void delete_from_archive (FrArchive *archive, GList *file_list);
+
+
+static GList *
+newer_files_only (FrArchive *archive,
+ GList *file_list,
+ const char *base_dir)
+{
+ GList *newer_files = NULL;
+ GList *scan;
+
+ for (scan = file_list; scan; scan = scan->next) {
+ char *filename = scan->data;
+ char *fullpath;
+ char *uri;
+ FileData *fdata;
+
+ fdata = find_file_in_archive (archive, filename);
+
+ if (fdata == NULL) {
+ newer_files = g_list_prepend (newer_files, g_strdup (scan->data));
+ continue;
+ }
+
+ fullpath = g_strconcat (base_dir, "/", filename, NULL);
+ uri = g_filename_to_uri (fullpath, NULL, NULL);
+
+ if (fdata->modified >= get_file_mtime (uri)) {
+ g_free (fullpath);
+ g_free (uri);
+ continue;
+ }
+ g_free (fullpath);
+ g_free (uri);
+
+ newer_files = g_list_prepend (newer_files, g_strdup (scan->data));
+ }
+
+ return newer_files;
+}
+
+
+void
+fr_archive_set_add_is_stoppable_func (FrArchive *archive,
+ FakeLoadFunc func,
+ gpointer data)
+{
+ archive->priv->add_is_stoppable_func = func;
+ archive->priv->add_is_stoppable_data = data;
+}
+
+
+static GList *
+convert_to_local_file_list (GList *file_list)
+{
+ GList *local_file_list = NULL;
+ GList *scan;
+
+ for (scan = file_list; scan; scan = scan->next) {
+ char *uri = scan->data;
+ char *local_filename;
+
+ local_filename = g_uri_unescape_string (uri, G_URI_RESERVED_CHARS_ALLOWED_IN_PATH);
+ if (local_filename != NULL)
+ local_file_list = g_list_prepend (local_file_list, local_filename);
+ }
+
+ return local_file_list;
+}
+
+
+static gboolean
+save_list_to_temp_file (GList *file_list,
+ char **list_dir,
+ char **list_filename,
+ GError **error)
+{
+ gboolean error_occurred = FALSE;
+ GFile *list_file;
+ GFileOutputStream *ostream;
+
+ if (error != NULL)
+ *error = NULL;
+ *list_dir = get_temp_work_dir (NULL);
+ *list_filename = g_build_filename (*list_dir, "file-list", NULL);
+ list_file = g_file_new_for_path (*list_filename);
+ ostream = g_file_create (list_file, G_FILE_CREATE_PRIVATE, NULL, error);
+
+ if (ostream != NULL) {
+ GList *scan;
+
+ for (scan = file_list; scan != NULL; scan = scan->next) {
+ char *filename = scan->data;
+
+ filename = str_substitute (filename, "\n", "\\n");
+ if ((g_output_stream_write (G_OUTPUT_STREAM (ostream), filename, strlen (filename), NULL, error) < 0)
+ || (g_output_stream_write (G_OUTPUT_STREAM (ostream), "\n", 1, NULL, error) < 0))
+ {
+ error_occurred = TRUE;
+ }
+
+ g_free (filename);
+
+ if (error_occurred)
+ break;
+ }
+ if (! error_occurred && ! g_output_stream_close (G_OUTPUT_STREAM (ostream), NULL, error))
+ error_occurred = TRUE;
+ g_object_unref (ostream);
+ }
+ else
+ error_occurred = TRUE;
+
+ if (error_occurred) {
+ remove_local_directory (*list_dir);
+ g_free (*list_dir);
+ g_free (*list_filename);
+ *list_dir = NULL;
+ *list_filename = NULL;
+ }
+
+ g_object_unref (list_file);
+
+ return ! error_occurred;
+}
+
+
+static GList *
+split_in_chunks (GList *file_list)
+{
+ GList *chunks = NULL;
+ GList *new_file_list;
+ GList *scan;
+
+ new_file_list = g_list_copy (file_list);
+ for (scan = new_file_list; scan != NULL; /* void */) {
+ GList *prev = scan->prev;
+ GList *chunk;
+ int l;
+
+ chunk = scan;
+ l = 0;
+ while ((scan != NULL) && (l < MAX_CHUNK_LEN)) {
+ if (l == 0)
+ l = strlen (scan->data);
+ prev = scan;
+ scan = scan->next;
+ if (scan != NULL)
+ l += strlen (scan->data);
+ }
+ if (prev != NULL) {
+ if (prev->next != NULL)
+ prev->next->prev = NULL;
+ prev->next = NULL;
+ }
+ chunks = g_list_append (chunks, chunk);
+ }
+
+ return chunks;
+}
+
+
+void
+fr_archive_add (FrArchive *archive,
+ GList *file_list,
+ const char *base_dir,
+ const char *dest_dir,
+ gboolean update,
+ gboolean recursive,
+ const char *password,
+ gboolean encrypt_header,
+ FrCompression compression,
+ guint volume_size)
+{
+ GList *new_file_list = NULL;
+ gboolean base_dir_created = FALSE;
+ GList *scan;
+ char *tmp_base_dir = NULL;
+ gboolean error_occurred = FALSE;
+
+ if (file_list == NULL)
+ return;
+
+ if (archive->read_only)
+ return;
+
+ g_object_set (archive->command,
+ "password", password,
+ "encrypt_header", encrypt_header,
+ "compression", compression,
+ "volume_size", volume_size,
+ NULL);
+
+ fr_archive_stoppable (archive, fr_archive_add_is_stoppable (archive));
+
+ file_list = convert_to_local_file_list (file_list);
+ tmp_base_dir = g_strdup (base_dir);
+
+ if ((dest_dir != NULL) && (*dest_dir != '\0') && (strcmp (dest_dir, "/") != 0)) {
+ const char *rel_dest_dir = dest_dir;
+
+ tmp_base_dir = create_tmp_base_dir (base_dir, dest_dir);
+ base_dir_created = TRUE;
+
+ if (dest_dir[0] == G_DIR_SEPARATOR)
+ rel_dest_dir = dest_dir + 1;
+
+ new_file_list = NULL;
+ for (scan = file_list; scan != NULL; scan = scan->next) {
+ char *filename = scan->data;
+ new_file_list = g_list_prepend (new_file_list, g_build_filename (rel_dest_dir, filename, NULL));
+ }
+ path_list_free (file_list);
+ }
+ else
+ new_file_list = file_list;
+
+ /* if the command cannot update, get the list of files that are
+ * newer than the ones in the archive. */
+
+ if (update && ! archive->command->propAddCanUpdate) {
+ GList *tmp_file_list;
+
+ tmp_file_list = new_file_list;
+ new_file_list = newer_files_only (archive, tmp_file_list, tmp_base_dir);
+ path_list_free (tmp_file_list);
+ }
+
+ if (new_file_list == NULL) {
+ debug (DEBUG_INFO, "nothing to update.\n");
+
+ if (base_dir_created)
+ remove_local_directory (tmp_base_dir);
+ g_free (tmp_base_dir);
+
+ archive->process->error.type = FR_PROC_ERROR_NONE;
+ g_signal_emit_by_name (G_OBJECT (archive->process),
+ "done",
+ FR_ACTION_ADDING_FILES);
+ return;
+ }
+
+ archive->command->creating_archive = ! g_file_test (archive->command->filename, G_FILE_TEST_EXISTS);
+
+ fr_command_uncompress (archive->command);
+
+ /* when files are already present in a tar archive and are added
+ * again, they are not replaced, so we have to delete them first. */
+
+ /* if we are adding (== ! update) and 'add' cannot replace or
+ * if we are updating and 'add' cannot update,
+ * delete the files first. */
+
+ if ((! update && ! archive->command->propAddCanReplace)
+ || (update && ! archive->command->propAddCanUpdate))
+ {
+ GList *del_list = NULL;
+
+ for (scan = new_file_list; scan != NULL; scan = scan->next) {
+ char *filename = scan->data;
+ if (find_file_in_archive (archive, filename))
+ del_list = g_list_prepend (del_list, filename);
+ }
+
+ /* delete */
+
+ if (del_list != NULL) {
+ delete_from_archive (archive, del_list);
+ fr_process_set_ignore_error (archive->process, TRUE);
+ g_list_free (del_list);
+ }
+ }
+
+ /* add now. */
+
+ fr_command_set_n_files (archive->command, g_list_length (new_file_list));
+
+ if (archive->command->propListFromFile
+ && (archive->command->n_files > LIST_LENGTH_TO_USE_FILE))
+ {
+ char *list_dir;
+ char *list_filename;
+ GError *error = NULL;
+
+ if (! save_list_to_temp_file (new_file_list, &list_dir, &list_filename, &error)) {
+ archive->process->error.type = FR_PROC_ERROR_GENERIC;
+ archive->process->error.status = 0;
+ archive->process->error.gerror = g_error_copy (error);
+ g_signal_emit_by_name (G_OBJECT (archive->process),
+ "done",
+ FR_ACTION_ADDING_FILES);
+ g_clear_error (&error);
+ error_occurred = TRUE;
+ }
+ else {
+ fr_command_add (archive->command,
+ list_filename,
+ new_file_list,
+ tmp_base_dir,
+ update,
+ recursive);
+
+ /* remove the temp dir */
+
+ fr_process_begin_command (archive->process, "rm");
+ fr_process_set_working_dir (archive->process, g_get_tmp_dir());
+ fr_process_set_sticky (archive->process, TRUE);
+ fr_process_add_arg (archive->process, "-rf");
+ fr_process_add_arg (archive->process, list_dir);
+ fr_process_end_command (archive->process);
+ }
+
+ g_free (list_filename);
+ g_free (list_dir);
+ }
+ else {
+ GList *chunks = NULL;
+
+ /* specify the file list on the command line, splitting
+ * in more commands to avoid to overflow the command line
+ * length limit. */
+
+ chunks = split_in_chunks (new_file_list);
+ for (scan = chunks; scan != NULL; scan = scan->next) {
+ GList *chunk = scan->data;
+
+ fr_command_add (archive->command,
+ NULL,
+ chunk,
+ tmp_base_dir,
+ update,
+ recursive);
+ g_list_free (chunk);
+ }
+
+ g_list_free (chunks);
+ }
+
+ path_list_free (new_file_list);
+
+ if (! error_occurred) {
+ fr_command_recompress (archive->command);
+
+ if (base_dir_created) { /* remove the temp dir */
+ fr_process_begin_command (archive->process, "rm");
+ fr_process_set_working_dir (archive->process, g_get_tmp_dir());
+ fr_process_set_sticky (archive->process, TRUE);
+ fr_process_add_arg (archive->process, "-rf");
+ fr_process_add_arg (archive->process, tmp_base_dir);
+ fr_process_end_command (archive->process);
+ }
+ }
+
+ g_free (tmp_base_dir);
+}
+
+
+static void
+fr_archive_add_local_files (FrArchive *archive,
+ GList *file_list,
+ const char *base_dir,
+ const char *dest_dir,
+ gboolean update,
+ const char *password,
+ gboolean encrypt_header,
+ FrCompression compression,
+ guint volume_size)
+{
+ fr_archive_stoppable (archive, TRUE);
+ fr_process_clear (archive->process);
+ fr_archive_add (archive,
+ file_list,
+ base_dir,
+ dest_dir,
+ update,
+ FALSE,
+ password,
+ encrypt_header,
+ compression,
+ volume_size);
+ fr_process_start (archive->process);
+}
+
+
+static void
+copy_remote_files_done (GError *error,
+ gpointer user_data)
+{
+ XferData *xfer_data = user_data;
+
+ fr_archive_copy_done (xfer_data->archive, FR_ACTION_COPYING_FILES_FROM_REMOTE, error);
+
+ if (error == NULL)
+ fr_archive_add_local_files (xfer_data->archive,
+ xfer_data->file_list,
+ xfer_data->tmp_dir,
+ xfer_data->dest_dir,
+ FALSE,
+ xfer_data->password,
+ xfer_data->encrypt_header,
+ xfer_data->compression,
+ xfer_data->volume_size);
+ xfer_data_free (xfer_data);
+}
+
+
+static void
+copy_remote_files_progress (goffset current_file,
+ goffset total_files,
+ GFile *source,
+ GFile *destination,
+ goffset current_num_bytes,
+ goffset total_num_bytes,
+ gpointer user_data)
+{
+ XferData *xfer_data = user_data;
+
+ g_signal_emit (G_OBJECT (xfer_data->archive),
+ fr_archive_signals[PROGRESS],
+ 0,
+ (double) current_file / (total_files + 1));
+}
+
+
+static void
+copy_remote_files (FrArchive *archive,
+ GList *file_list,
+ const char *base_uri,
+ const char *dest_dir,
+ gboolean update,
+ const char *password,
+ gboolean encrypt_header,
+ FrCompression compression,
+ guint volume_size,
+ const char *tmp_dir)
+{
+ GList *sources = NULL, *destinations = NULL;
+ GHashTable *created_folders;
+ GList *scan;
+ XferData *xfer_data;
+
+ created_folders = g_hash_table_new_full (g_str_hash, g_str_equal, (GDestroyNotify) g_free, NULL);
+ for (scan = file_list; scan; scan = scan->next) {
+ char *partial_filename = scan->data;
+ char *local_uri;
+ char *local_folder_uri;
+ char *remote_uri;
+
+ local_uri = g_strconcat ("file://", tmp_dir, "/", partial_filename, NULL);
+ local_folder_uri = remove_level_from_path (local_uri);
+ if (g_hash_table_lookup (created_folders, local_folder_uri) == NULL) {
+ GError *error = NULL;
+ if (! ensure_dir_exists (local_folder_uri, 0755, &error)) {
+ g_free (local_folder_uri);
+ g_free (local_uri);
+ gio_file_list_free (sources);
+ gio_file_list_free (destinations);
+ g_hash_table_destroy (created_folders);
+
+ fr_archive_action_completed (archive,
+ FR_ACTION_COPYING_FILES_FROM_REMOTE,
+ FR_PROC_ERROR_GENERIC,
+ error->message);
+ g_clear_error (&error);
+ return;
+ }
+
+ g_hash_table_insert (created_folders, local_folder_uri, GINT_TO_POINTER (1));
+ }
+ else
+ g_free (local_folder_uri);
+
+ remote_uri = g_strconcat (base_uri, "/", partial_filename, NULL);
+ sources = g_list_append (sources, g_file_new_for_uri (remote_uri));
+ g_free (remote_uri);
+
+ destinations = g_list_append (destinations, g_file_new_for_uri (local_uri));
+ g_free (local_uri);
+ }
+ g_hash_table_destroy (created_folders);
+
+ xfer_data = g_new0 (XferData, 1);
+ xfer_data->archive = archive;
+ xfer_data->file_list = path_list_dup (file_list);
+ xfer_data->base_uri = g_strdup (base_uri);
+ xfer_data->dest_dir = g_strdup (dest_dir);
+ xfer_data->update = update;
+ xfer_data->dest_dir = g_strdup (dest_dir);
+ xfer_data->password = g_strdup (password);
+ xfer_data->encrypt_header = encrypt_header;
+ xfer_data->compression = compression;
+ xfer_data->volume_size = volume_size;
+ xfer_data->tmp_dir = g_strdup (tmp_dir);
+
+ g_signal_emit (G_OBJECT (archive),
+ fr_archive_signals[START],
+ 0,
+ FR_ACTION_COPYING_FILES_FROM_REMOTE);
+
+ g_copy_files_async (sources,
+ destinations,
+ G_FILE_COPY_OVERWRITE,
+ G_PRIORITY_DEFAULT,
+ archive->priv->cancellable,
+ copy_remote_files_progress,
+ xfer_data,
+ copy_remote_files_done,
+ xfer_data);
+
+ gio_file_list_free (sources);
+ gio_file_list_free (destinations);
+}
+
+
+static char *
+fr_archive_get_temp_work_dir (FrArchive *archive)
+{
+ fr_archive_remove_temp_work_dir (archive);
+ archive->priv->temp_dir = get_temp_work_dir (NULL);
+ return archive->priv->temp_dir;
+}
+
+
+void
+fr_archive_add_files (FrArchive *archive,
+ GList *file_list,
+ const char *base_dir,
+ const char *dest_dir,
+ gboolean update,
+ const char *password,
+ gboolean encrypt_header,
+ FrCompression compression,
+ guint volume_size)
+{
+ if (uri_is_local (base_dir)) {
+ char *local_dir = g_filename_from_uri (base_dir, NULL, NULL);
+ fr_archive_add_local_files (archive,
+ file_list,
+ local_dir,
+ dest_dir,
+ update,
+ password,
+ encrypt_header,
+ compression,
+ volume_size);
+ g_free (local_dir);
+ }
+ else
+ copy_remote_files (archive,
+ file_list,
+ base_dir,
+ dest_dir,
+ update,
+ password,
+ encrypt_header,
+ compression,
+ volume_size,
+ fr_archive_get_temp_work_dir (archive));
+}
+
+
+/* -- add with wildcard -- */
+
+
+typedef struct {
+ FrArchive *archive;
+ char *source_dir;
+ char *dest_dir;
+ gboolean update;
+ char *password;
+ gboolean encrypt_header;
+ FrCompression compression;
+ guint volume_size;
+} AddWithWildcardData;
+
+
+static void
+add_with_wildcard_data_free (AddWithWildcardData *aww_data)
+{
+ g_free (aww_data->source_dir);
+ g_free (aww_data->dest_dir);
+ g_free (aww_data->password);
+ g_free (aww_data);
+}
+
+
+static void
+add_with_wildcard__step2 (GList *file_list,
+ GList *dirs_list,
+ GError *error,
+ gpointer data)
+{
+ AddWithWildcardData *aww_data = data;
+ FrArchive *archive = aww_data->archive;
+
+ if (error != NULL) {
+ fr_archive_action_completed (archive,
+ FR_ACTION_GETTING_FILE_LIST,
+ (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) ? FR_PROC_ERROR_STOPPED : FR_PROC_ERROR_GENERIC),
+ error->message);
+ return;
+ }
+
+ fr_archive_action_completed (archive,
+ FR_ACTION_GETTING_FILE_LIST,
+ FR_PROC_ERROR_NONE,
+ NULL);
+
+ if (file_list != NULL)
+ fr_archive_add_files (aww_data->archive,
+ file_list,
+ aww_data->source_dir,
+ aww_data->dest_dir,
+ aww_data->update,
+ aww_data->password,
+ aww_data->encrypt_header,
+ aww_data->compression,
+ aww_data->volume_size);
+
+ path_list_free (file_list);
+ path_list_free (dirs_list);
+ add_with_wildcard_data_free (aww_data);
+}
+
+
+void
+fr_archive_add_with_wildcard (FrArchive *archive,
+ const char *include_files,
+ const char *exclude_files,
+ const char *exclude_folders,
+ const char *source_dir,
+ const char *dest_dir,
+ gboolean update,
+ gboolean follow_links,
+ const char *password,
+ gboolean encrypt_header,
+ FrCompression compression,
+ guint volume_size)
+{
+ AddWithWildcardData *aww_data;
+
+ g_return_if_fail (! archive->read_only);
+
+ aww_data = g_new0 (AddWithWildcardData, 1);
+ aww_data->archive = archive;
+ aww_data->source_dir = g_strdup (source_dir);
+ aww_data->dest_dir = g_strdup (dest_dir);
+ aww_data->update = update;
+ aww_data->password = g_strdup (password);
+ aww_data->encrypt_header = encrypt_header;
+ aww_data->compression = compression;
+ aww_data->volume_size = volume_size;
+
+ g_signal_emit (G_OBJECT (archive),
+ fr_archive_signals[START],
+ 0,
+ FR_ACTION_GETTING_FILE_LIST);
+
+ g_directory_list_async (source_dir,
+ source_dir,
+ TRUE,
+ follow_links,
+ NO_BACKUP_FILES,
+ NO_DOT_FILES,
+ include_files,
+ exclude_files,
+ exclude_folders,
+ IGNORE_CASE,
+ archive->priv->cancellable,
+ add_with_wildcard__step2,
+ aww_data);
+}
+
+
+/* -- fr_archive_add_directory -- */
+
+
+typedef struct {
+ FrArchive *archive;
+ char *base_dir;
+ char *dest_dir;
+ gboolean update;
+ char *password;
+ gboolean encrypt_header;
+ FrCompression compression;
+ guint volume_size;
+} AddDirectoryData;
+
+
+static void
+add_directory_data_free (AddDirectoryData *ad_data)
+{
+ g_free (ad_data->base_dir);
+ g_free (ad_data->dest_dir);
+ g_free (ad_data->password);
+ g_free (ad_data);
+}
+
+
+static void
+add_directory__step2 (GList *file_list,
+ GList *dir_list,
+ GError *error,
+ gpointer data)
+{
+ AddDirectoryData *ad_data = data;
+ FrArchive *archive = ad_data->archive;
+
+ if (error != NULL) {
+ fr_archive_action_completed (archive,
+ FR_ACTION_GETTING_FILE_LIST,
+ (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) ? FR_PROC_ERROR_STOPPED : FR_PROC_ERROR_GENERIC),
+ error->message);
+ return;
+ }
+
+ fr_archive_action_completed (archive,
+ FR_ACTION_GETTING_FILE_LIST,
+ FR_PROC_ERROR_NONE,
+ NULL);
+
+ if (archive->command->propAddCanStoreFolders)
+ file_list = g_list_concat (file_list, dir_list);
+ else
+ path_list_free (dir_list);
+
+ if (file_list != NULL) {
+ fr_archive_add_files (ad_data->archive,
+ file_list,
+ ad_data->base_dir,
+ ad_data->dest_dir,
+ ad_data->update,
+ ad_data->password,
+ ad_data->encrypt_header,
+ ad_data->compression,
+ ad_data->volume_size);
+ path_list_free (file_list);
+ }
+
+ add_directory_data_free (ad_data);
+}
+
+
+void
+fr_archive_add_directory (FrArchive *archive,
+ const char *directory,
+ const char *base_dir,
+ const char *dest_dir,
+ gboolean update,
+ const char *password,
+ gboolean encrypt_header,
+ FrCompression compression,
+ guint volume_size)
+
+{
+ AddDirectoryData *ad_data;
+
+ g_return_if_fail (! archive->read_only);
+
+ ad_data = g_new0 (AddDirectoryData, 1);
+ ad_data->archive = archive;
+ ad_data->base_dir = g_strdup (base_dir);
+ ad_data->dest_dir = g_strdup (dest_dir);
+ ad_data->update = update;
+ ad_data->password = g_strdup (password);
+ ad_data->encrypt_header = encrypt_header;
+ ad_data->compression = compression;
+ ad_data->volume_size = volume_size;
+
+ g_signal_emit (G_OBJECT (archive),
+ fr_archive_signals[START],
+ 0,
+ FR_ACTION_GETTING_FILE_LIST);
+
+ g_directory_list_all_async (directory,
+ base_dir,
+ TRUE,
+ archive->priv->cancellable,
+ add_directory__step2,
+ ad_data);
+}
+
+
+void
+fr_archive_add_items (FrArchive *archive,
+ GList *item_list,
+ const char *base_dir,
+ const char *dest_dir,
+ gboolean update,
+ const char *password,
+ gboolean encrypt_header,
+ FrCompression compression,
+ guint volume_size)
+
+{
+ AddDirectoryData *ad_data;
+
+ g_return_if_fail (! archive->read_only);
+
+ ad_data = g_new0 (AddDirectoryData, 1);
+ ad_data->archive = archive;
+ ad_data->base_dir = g_strdup (base_dir);
+ ad_data->dest_dir = g_strdup (dest_dir);
+ ad_data->update = update;
+ ad_data->password = g_strdup (password);
+ ad_data->encrypt_header = encrypt_header;
+ ad_data->compression = compression;
+ ad_data->volume_size = volume_size;
+
+ g_signal_emit (G_OBJECT (archive),
+ fr_archive_signals[START],
+ 0,
+ FR_ACTION_GETTING_FILE_LIST);
+
+ g_list_items_async (item_list,
+ base_dir,
+ archive->priv->cancellable,
+ add_directory__step2,
+ ad_data);
+}
+
+
+/* -- fr_archive_add_dropped_items -- */
+
+
+static gboolean
+all_files_in_same_dir (GList *list)
+{
+ gboolean same_dir = TRUE;
+ char *first_basedir;
+ GList *scan;
+
+ if (list == NULL)
+ return FALSE;
+
+ first_basedir = remove_level_from_path (list->data);
+ if (first_basedir == NULL)
+ return TRUE;
+
+ for (scan = list->next; scan; scan = scan->next) {
+ char *path = scan->data;
+ char *basedir;
+
+ basedir = remove_level_from_path (path);
+ if (basedir == NULL) {
+ same_dir = FALSE;
+ break;
+ }
+
+ if (strcmp (first_basedir, basedir) != 0) {
+ same_dir = FALSE;
+ g_free (basedir);
+ break;
+ }
+ g_free (basedir);
+ }
+ g_free (first_basedir);
+
+ return same_dir;
+}
+
+
+static void
+add_dropped_items (DroppedItemsData *data)
+{
+ FrArchive *archive = data->archive;
+ GList *list = data->item_list;
+ GList *scan;
+
+ if (list == NULL) {
+ dropped_items_data_free (archive->priv->dropped_items_data);
+ archive->priv->dropped_items_data = NULL;
+ fr_archive_action_completed (archive,
+ FR_ACTION_ADDING_FILES,
+ FR_PROC_ERROR_NONE,
+ NULL);
+ return;
+ }
+
+ /* if all files/dirs are in the same directory call fr_archive_add_items... */
+
+ if (all_files_in_same_dir (list)) {
+ char *first_base_dir;
+
+ first_base_dir = remove_level_from_path (list->data);
+ fr_archive_add_items (data->archive,
+ list,
+ first_base_dir,
+ data->dest_dir,
+ data->update,
+ data->password,
+ data->encrypt_header,
+ data->compression,
+ data->volume_size);
+ g_free (first_base_dir);
+
+ dropped_items_data_free (archive->priv->dropped_items_data);
+ archive->priv->dropped_items_data = NULL;
+
+ return;
+ }
+
+ /* ...else add a directory at a time. */
+
+ for (scan = list; scan; scan = scan->next) {
+ char *path = scan->data;
+ char *base_dir;
+
+ if (! uri_is_dir (path))
+ continue;
+
+ data->item_list = g_list_remove_link (list, scan);
+ if (data->item_list != NULL)
+ archive->priv->continue_adding_dropped_items = TRUE;
+ base_dir = remove_level_from_path (path);
+
+ fr_archive_add_directory (archive,
+ file_name_from_path (path),
+ base_dir,
+ data->dest_dir,
+ data->update,
+ data->password,
+ data->encrypt_header,
+ data->compression,
+ data->volume_size);
+
+ g_free (base_dir);
+ g_free (path);
+
+ return;
+ }
+
+ /* if all files are in the same directory call fr_archive_add_files. */
+
+ if (all_files_in_same_dir (list)) {
+ char *first_basedir;
+ GList *only_names_list = NULL;
+
+ first_basedir = remove_level_from_path (list->data);
+
+ for (scan = list; scan; scan = scan->next) {
+ char *name;
+
+ name = g_uri_unescape_string (file_name_from_path (scan->data), NULL);
+ only_names_list = g_list_prepend (only_names_list, name);
+ }
+
+ fr_archive_add_files (archive,
+ only_names_list,
+ first_basedir,
+ data->dest_dir,
+ data->update,
+ data->password,
+ data->encrypt_header,
+ data->compression,
+ data->volume_size);
+
+ path_list_free (only_names_list);
+ g_free (first_basedir);
+
+ return;
+ }
+
+ /* ...else call fr_command_add for each file. This is needed to add
+ * files without path info. FIXME: doesn't work with remote files. */
+
+ fr_archive_stoppable (archive, FALSE);
+ g_object_set (archive->command,
+ "password", data->password,
+ "encrypt_header", data->encrypt_header,
+ "compression", data->compression,
+ "volume_size", data->volume_size,
+ NULL);
+ fr_process_clear (archive->process);
+ fr_command_uncompress (archive->command);
+ for (scan = list; scan; scan = scan->next) {
+ char *fullpath = scan->data;
+ char *basedir;
+ GList *singleton;
+
+ basedir = remove_level_from_path (fullpath);
+ singleton = g_list_prepend (NULL, (char*)file_name_from_path (fullpath));
+ fr_command_add (archive->command,
+ NULL,
+ singleton,
+ basedir,
+ data->update,
+ FALSE);
+ g_list_free (singleton);
+ g_free (basedir);
+ }
+ fr_command_recompress (archive->command);
+ fr_process_start (archive->process);
+
+ path_list_free (data->item_list);
+ data->item_list = NULL;
+}
+
+
+void
+fr_archive_add_dropped_items (FrArchive *archive,
+ GList *item_list,
+ const char *base_dir,
+ const char *dest_dir,
+ gboolean update,
+ const char *password,
+ gboolean encrypt_header,
+ FrCompression compression,
+ guint volume_size)
+{
+ GList *scan;
+ char *archive_uri;
+
+ if (archive->read_only) {
+ fr_archive_action_completed (archive,
+ FR_ACTION_ADDING_FILES,
+ FR_PROC_ERROR_GENERIC,
+ ! archive->have_permissions ? _("You don't have the right permissions.") : _("This archive type cannot be modified"));
+ return;
+ }
+
+ /* FIXME: make this check for all the add actions */
+ archive_uri = g_file_get_uri (archive->file);
+ for (scan = item_list; scan; scan = scan->next) {
+ if (uricmp (scan->data, archive_uri) == 0) {
+ g_free (archive_uri);
+ fr_archive_action_completed (archive,
+ FR_ACTION_ADDING_FILES,
+ FR_PROC_ERROR_GENERIC,
+ _("You can't add an archive to itself."));
+ return;
+ }
+ }
+ g_free (archive_uri);
+
+ if (archive->priv->dropped_items_data != NULL)
+ dropped_items_data_free (archive->priv->dropped_items_data);
+ archive->priv->dropped_items_data = dropped_items_data_new (
+ archive,
+ item_list,
+ base_dir,
+ dest_dir,
+ update,
+ password,
+ encrypt_header,
+ compression,
+ volume_size);
+ add_dropped_items (archive->priv->dropped_items_data);
+}
+
+
+/* -- remove -- */
+
+
+static gboolean
+file_is_in_subfolder_of (const char *filename,
+ GList *folder_list)
+{
+ GList *scan;
+
+ if (filename == NULL)
+ return FALSE;
+
+ for (scan = folder_list; scan; scan = scan->next) {
+ char *folder_in_list = (char*) scan->data;
+
+ if (path_in_path (folder_in_list, filename))
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static gboolean
+archive_type_has_issues_deleting_non_empty_folders (FrArchive *archive)
+{
+ return ! archive->command->propCanDeleteNonEmptyFolders;
+}
+
+
+static void
+delete_from_archive (FrArchive *archive,
+ GList *file_list)
+{
+ gboolean file_list_created = FALSE;
+ GList *tmp_file_list = NULL;
+ gboolean tmp_file_list_created = FALSE;
+ GList *scan;
+
+ /* file_list == NULL means delete all the files in the archive. */
+
+ if (file_list == NULL) {
+ int i;
+
+ for (i = 0; i < archive->command->files->len; i++) {
+ FileData *fdata = g_ptr_array_index (archive->command->files, i);
+ file_list = g_list_prepend (file_list, fdata->original_path);
+ }
+
+ file_list_created = TRUE;
+ }
+
+ if (archive_type_has_issues_deleting_non_empty_folders (archive)) {
+ GList *folders_to_remove;
+
+ /* remove from the list the files contained in folders to be
+ * removed. */
+
+ folders_to_remove = NULL;
+ for (scan = file_list; scan != NULL; scan = scan->next) {
+ char *path = scan->data;
+
+ if (path[strlen (path) - 1] == '/')
+ folders_to_remove = g_list_prepend (folders_to_remove, path);
+ }
+
+ if (folders_to_remove != NULL) {
+ tmp_file_list = NULL;
+ for (scan = file_list; scan != NULL; scan = scan->next) {
+ char *path = scan->data;
+
+ if (! file_is_in_subfolder_of (path, folders_to_remove))
+ tmp_file_list = g_list_prepend (tmp_file_list, path);
+ }
+ tmp_file_list_created = TRUE;
+ g_list_free (folders_to_remove);
+ }
+ }
+
+ if (! tmp_file_list_created)
+ tmp_file_list = g_list_copy (file_list);
+
+ if (file_list_created)
+ g_list_free (file_list);
+
+ fr_command_set_n_files (archive->command, g_list_length (tmp_file_list));
+
+ if (archive->command->propListFromFile
+ && (archive->command->n_files > LIST_LENGTH_TO_USE_FILE))
+ {
+ char *list_dir;
+ char *list_filename;
+
+ if (save_list_to_temp_file (tmp_file_list, &list_dir, &list_filename, NULL)) {
+ fr_command_delete (archive->command,
+ list_filename,
+ tmp_file_list);
+
+ /* remove the temp dir */
+
+ fr_process_begin_command (archive->process, "rm");
+ fr_process_set_working_dir (archive->process, g_get_tmp_dir());
+ fr_process_set_sticky (archive->process, TRUE);
+ fr_process_add_arg (archive->process, "-rf");
+ fr_process_add_arg (archive->process, list_dir);
+ fr_process_end_command (archive->process);
+ }
+
+ g_free (list_filename);
+ g_free (list_dir);
+ }
+ else {
+ for (scan = tmp_file_list; scan != NULL; ) {
+ GList *prev = scan->prev;
+ GList *chunk_list;
+ int l;
+
+ chunk_list = scan;
+ l = 0;
+ while ((scan != NULL) && (l < MAX_CHUNK_LEN)) {
+ if (l == 0)
+ l = strlen (scan->data);
+ prev = scan;
+ scan = scan->next;
+ if (scan != NULL)
+ l += strlen (scan->data);
+ }
+
+ prev->next = NULL;
+ fr_command_delete (archive->command, NULL, chunk_list);
+ prev->next = scan;
+ }
+ }
+
+ g_list_free (tmp_file_list);
+}
+
+
+void
+fr_archive_remove (FrArchive *archive,
+ GList *file_list,
+ FrCompression compression)
+{
+ g_return_if_fail (archive != NULL);
+
+ if (archive->read_only)
+ return;
+
+ fr_archive_stoppable (archive, FALSE);
+ g_object_set (archive->command, "compression", compression, NULL);
+ fr_command_uncompress (archive->command);
+ delete_from_archive (archive, file_list);
+ fr_command_recompress (archive->command);
+}
+
+
+/* -- extract -- */
+
+
+static void
+move_files_to_dir (FrArchive *archive,
+ GList *file_list,
+ const char *source_dir,
+ const char *dest_dir,
+ gboolean overwrite)
+{
+ GList *list;
+ GList *scan;
+
+ /* we prefer mv instead of cp for performance reasons,
+ * but if the destination folder already exists mv
+ * doesn't work correctly. (bug #590027) */
+
+ list = g_list_copy (file_list);
+ for (scan = list; scan; /* void */) {
+ GList *next = scan->next;
+ char *filename = scan->data;
+ char *basename;
+ char *destname;
+
+ basename = g_path_get_basename (filename);
+ destname = g_build_filename (dest_dir, basename, NULL);
+ if (g_file_test (destname, G_FILE_TEST_IS_DIR)) {
+ fr_process_begin_command (archive->process, "cp");
+ fr_process_add_arg (archive->process, "-R");
+ if (overwrite)
+ fr_process_add_arg (archive->process, "-f");
+ else
+ fr_process_add_arg (archive->process, "-n");
+ if (filename[0] == '/')
+ fr_process_add_arg_concat (archive->process, source_dir, filename, NULL);
+ else
+ fr_process_add_arg_concat (archive->process, source_dir, "/", filename, NULL);
+ fr_process_add_arg (archive->process, dest_dir);
+ fr_process_end_command (archive->process);
+
+ list = g_list_remove_link (list, scan);
+ g_list_free (scan);
+ }
+
+ g_free (destname);
+ g_free (basename);
+
+ scan = next;
+ }
+
+ if (list == NULL)
+ return;
+
+ /* 'list' now contains the files that can be moved without problems */
+
+ fr_process_begin_command (archive->process, "mv");
+ if (overwrite)
+ fr_process_add_arg (archive->process, "-f");
+ else
+ fr_process_add_arg (archive->process, "-n");
+ for (scan = list; scan; scan = scan->next) {
+ char *filename = scan->data;
+
+ if (filename[0] == '/')
+ fr_process_add_arg_concat (archive->process, source_dir, filename, NULL);
+ else
+ fr_process_add_arg_concat (archive->process, source_dir, "/", filename, NULL);
+ }
+ fr_process_add_arg (archive->process, dest_dir);
+ fr_process_end_command (archive->process);
+
+ g_list_free (list);
+}
+
+
+static void
+move_files_in_chunks (FrArchive *archive,
+ GList *file_list,
+ const char *temp_dir,
+ const char *dest_dir,
+ gboolean overwrite)
+{
+ GList *scan;
+ int temp_dir_l;
+
+ temp_dir_l = strlen (temp_dir);
+
+ for (scan = file_list; scan != NULL; ) {
+ GList *prev = scan->prev;
+ GList *chunk_list;
+ int l;
+
+ chunk_list = scan;
+ l = 0;
+ while ((scan != NULL) && (l < MAX_CHUNK_LEN)) {
+ if (l == 0)
+ l = temp_dir_l + 1 + strlen (scan->data);
+ prev = scan;
+ scan = scan->next;
+ if (scan != NULL)
+ l += temp_dir_l + 1 + strlen (scan->data);
+ }
+
+ prev->next = NULL;
+ move_files_to_dir (archive, chunk_list, temp_dir, dest_dir, overwrite);
+ prev->next = scan;
+ }
+}
+
+
+static void
+extract_from_archive (FrArchive *archive,
+ GList *file_list,
+ const char *dest_dir,
+ gboolean overwrite,
+ gboolean skip_older,
+ gboolean junk_paths,
+ const char *password)
+{
+ FrCommand *command = archive->command;
+ GList *scan;
+
+ g_object_set (command, "password", password, NULL);
+
+ if (file_list == NULL) {
+ fr_command_extract (command,
+ NULL,
+ file_list,
+ dest_dir,
+ overwrite,
+ skip_older,
+ junk_paths);
+ return;
+ }
+
+ if (command->propListFromFile
+ && (g_list_length (file_list) > LIST_LENGTH_TO_USE_FILE))
+ {
+ char *list_dir;
+ char *list_filename;
+
+ if (save_list_to_temp_file (file_list, &list_dir, &list_filename, NULL)) {
+ fr_command_extract (command,
+ list_filename,
+ file_list,
+ dest_dir,
+ overwrite,
+ skip_older,
+ junk_paths);
+
+ /* remove the temp dir */
+
+ fr_process_begin_command (archive->process, "rm");
+ fr_process_set_working_dir (archive->process, g_get_tmp_dir());
+ fr_process_set_sticky (archive->process, TRUE);
+ fr_process_add_arg (archive->process, "-rf");
+ fr_process_add_arg (archive->process, list_dir);
+ fr_process_end_command (archive->process);
+ }
+
+ g_free (list_filename);
+ g_free (list_dir);
+ }
+ else {
+ for (scan = file_list; scan != NULL; ) {
+ GList *prev = scan->prev;
+ GList *chunk_list;
+ int l;
+
+ chunk_list = scan;
+ l = 0;
+ while ((scan != NULL) && (l < MAX_CHUNK_LEN)) {
+ if (l == 0)
+ l = strlen (scan->data);
+ prev = scan;
+ scan = scan->next;
+ if (scan != NULL)
+ l += strlen (scan->data);
+ }
+
+ prev->next = NULL;
+ fr_command_extract (command,
+ NULL,
+ chunk_list,
+ dest_dir,
+ overwrite,
+ skip_older,
+ junk_paths);
+ prev->next = scan;
+ }
+ }
+}
+
+
+static char*
+compute_base_path (const char *base_dir,
+ const char *path,
+ gboolean junk_paths,
+ gboolean can_junk_paths)
+{
+ int base_dir_len = strlen (base_dir);
+ int path_len = strlen (path);
+ const char *base_path;
+ char *name_end;
+ char *new_path;
+
+ if (junk_paths) {
+ if (can_junk_paths)
+ new_path = g_strdup (file_name_from_path (path));
+ else
+ new_path = g_strdup (path);
+
+ /*debug (DEBUG_INFO, "%s, %s --> %s\n", base_dir, path, new_path);*/
+
+ return new_path;
+ }
+
+ if (path_len <= base_dir_len)
+ return NULL;
+
+ base_path = path + base_dir_len;
+ if (path[0] != '/')
+ base_path -= 1;
+ name_end = strchr (base_path, '/');
+
+ if (name_end == NULL)
+ new_path = g_strdup (path);
+ else {
+ int name_len = name_end - path;
+ new_path = g_strndup (path, name_len);
+ }
+
+ /*debug (DEBUG_INFO, "%s, %s --> %s\n", base_dir, path, new_path);*/
+
+ return new_path;
+}
+
+
+static GList*
+compute_list_base_path (const char *base_dir,
+ GList *filtered,
+ gboolean junk_paths,
+ gboolean can_junk_paths)
+{
+ GList *scan;
+ GList *list = NULL, *list_unique = NULL;
+ GList *last_inserted;
+
+ if (filtered == NULL)
+ return NULL;
+
+ for (scan = filtered; scan; scan = scan->next) {
+ const char *path = scan->data;
+ char *new_path;
+
+ new_path = compute_base_path (base_dir, path, junk_paths, can_junk_paths);
+ if (new_path != NULL)
+ list = g_list_prepend (list, new_path);
+ }
+
+ /* The above operation can create duplicates, we remove them here. */
+ list = g_list_sort (list, (GCompareFunc)strcmp);
+
+ last_inserted = NULL;
+ for (scan = list; scan; scan = scan->next) {
+ const char *path = scan->data;
+
+ if (last_inserted != NULL) {
+ const char *last_path = (const char*)last_inserted->data;
+ if (strcmp (last_path, path) == 0) {
+ g_free (scan->data);
+ continue;
+ }
+ }
+
+ last_inserted = scan;
+ list_unique = g_list_prepend (list_unique, scan->data);
+ }
+
+ g_list_free (list);
+
+ return list_unique;
+}
+
+
+static gboolean
+archive_type_has_issues_extracting_non_empty_folders (FrArchive *archive)
+{
+ /*if ((archive->command->files == NULL) || (archive->command->files->len == 0))
+ return FALSE; FIXME: test with extract_here */
+ return ! archive->command->propCanExtractNonEmptyFolders;
+}
+
+
+static gboolean
+file_list_contains_files_in_this_dir (GList *file_list,
+ const char *dirname)
+{
+ GList *scan;
+
+ for (scan = file_list; scan; scan = scan->next) {
+ char *filename = scan->data;
+
+ if (path_in_path (dirname, filename))
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+static GList*
+remove_files_contained_in_this_dir (GList *file_list,
+ GList *dir_pointer)
+{
+ char *dirname = dir_pointer->data;
+ int dirname_l = strlen (dirname);
+ GList *scan;
+
+ for (scan = dir_pointer->next; scan; /* empty */) {
+ char *filename = scan->data;
+
+ if (strncmp (dirname, filename, dirname_l) != 0)
+ break;
+
+ if (path_in_path (dirname, filename)) {
+ GList *next = scan->next;
+
+ file_list = g_list_remove_link (file_list, scan);
+ g_list_free (scan);
+
+ scan = next;
+ }
+ else
+ scan = scan->next;
+ }
+
+ return file_list;
+}
+
+
+void
+fr_archive_extract_to_local (FrArchive *archive,
+ GList *file_list,
+ const char *destination,
+ const char *base_dir,
+ gboolean skip_older,
+ gboolean overwrite,
+ gboolean junk_paths,
+ const char *password)
+{
+ GList *filtered;
+ GList *scan;
+ gboolean extract_all;
+ gboolean use_base_dir;
+ gboolean all_options_supported;
+ gboolean move_to_dest_dir;
+ gboolean file_list_created = FALSE;
+
+ g_return_if_fail (archive != NULL);
+
+ fr_archive_stoppable (archive, TRUE);
+
+ /* if a command supports all the requested options use
+ * fr_command_extract directly. */
+
+ use_base_dir = ! ((base_dir == NULL)
+ || (strcmp (base_dir, "") == 0)
+ || (strcmp (base_dir, "/") == 0));
+
+ all_options_supported = (! use_base_dir
+ && ! (! overwrite && ! archive->command->propExtractCanAvoidOverwrite)
+ && ! (skip_older && ! archive->command->propExtractCanSkipOlder)
+ && ! (junk_paths && ! archive->command->propExtractCanJunkPaths));
+
+ extract_all = (file_list == NULL);
+ if (extract_all && (! all_options_supported || ! archive->command->propCanExtractAll)) {
+ int i;
+
+ file_list = NULL;
+ for (i = 0; i < archive->command->files->len; i++) {
+ FileData *fdata = g_ptr_array_index (archive->command->files, i);
+ file_list = g_list_prepend (file_list, g_strdup (fdata->original_path));
+ }
+ file_list_created = TRUE;
+ }
+
+ if (extract_all && (file_list == NULL))
+ fr_command_set_n_files (archive->command, archive->command->n_regular_files);
+ else
+ fr_command_set_n_files (archive->command, g_list_length (file_list));
+
+ if (all_options_supported) {
+ gboolean created_filtered_list = FALSE;
+
+ if (! extract_all && archive_type_has_issues_extracting_non_empty_folders (archive)) {
+ created_filtered_list = TRUE;
+ filtered = g_list_copy (file_list);
+ filtered = g_list_sort (filtered, (GCompareFunc) strcmp);
+ for (scan = filtered; scan; scan = scan->next)
+ filtered = remove_files_contained_in_this_dir (filtered, scan);
+ }
+ else
+ filtered = file_list;
+
+ if (! (created_filtered_list && (filtered == NULL)))
+ extract_from_archive (archive,
+ filtered,
+ destination,
+ overwrite,
+ skip_older,
+ junk_paths,
+ password);
+
+ if (created_filtered_list && (filtered != NULL))
+ g_list_free (filtered);
+
+ if (file_list_created)
+ path_list_free (file_list);
+
+ return;
+ }
+
+ /* .. else we have to implement the unsupported options. */
+
+ move_to_dest_dir = (use_base_dir
+ || ((junk_paths
+ && ! archive->command->propExtractCanJunkPaths)));
+
+ if (extract_all && ! file_list_created) {
+ int i;
+
+ file_list = NULL;
+ for (i = 0; i < archive->command->files->len; i++) {
+ FileData *fdata = g_ptr_array_index (archive->command->files, i);
+ file_list = g_list_prepend (file_list, g_strdup (fdata->original_path));
+ }
+
+ file_list_created = TRUE;
+ }
+
+ filtered = NULL;
+ for (scan = file_list; scan; scan = scan->next) {
+ FileData *fdata;
+ char *archive_list_filename = scan->data;
+ char dest_filename[4096];
+ const char *filename;
+
+ fdata = find_file_in_archive (archive, archive_list_filename);
+
+ if (fdata == NULL)
+ continue;
+
+ if (archive_type_has_issues_extracting_non_empty_folders (archive)
+ && fdata->dir
+ && file_list_contains_files_in_this_dir (file_list, archive_list_filename))
+ continue;
+
+ /* get the destination file path. */
+
+ if (! junk_paths)
+ filename = archive_list_filename;
+ else
+ filename = file_name_from_path (archive_list_filename);
+
+ if ((destination[strlen (destination) - 1] == '/')
+ || (filename[0] == '/'))
+ sprintf (dest_filename, "%s%s", destination, filename);
+ else
+ sprintf (dest_filename, "%s/%s", destination, filename);
+
+ /*debug (DEBUG_INFO, "-> %s\n", dest_filename);*/
+
+ /**/
+
+ if (! archive->command->propExtractCanSkipOlder
+ && skip_older
+ && g_file_test (dest_filename, G_FILE_TEST_EXISTS)
+ && (fdata->modified < get_file_mtime_for_path (dest_filename)))
+ continue;
+
+ if (! archive->command->propExtractCanAvoidOverwrite
+ && ! overwrite
+ && g_file_test (dest_filename, G_FILE_TEST_EXISTS))
+ continue;
+
+ filtered = g_list_prepend (filtered, fdata->original_path);
+ }
+
+ if (filtered == NULL) {
+ /* all files got filtered, do nothing. */
+ debug (DEBUG_INFO, "All files got filtered, nothing to do.\n");
+
+ if (extract_all)
+ path_list_free (file_list);
+ return;
+ }
+
+ if (move_to_dest_dir) {
+ char *temp_dir;
+
+ temp_dir = get_temp_work_dir (destination);
+ extract_from_archive (archive,
+ filtered,
+ temp_dir,
+ overwrite,
+ skip_older,
+ junk_paths,
+ password);
+
+ if (use_base_dir) {
+ GList *tmp_list = compute_list_base_path (base_dir, filtered, junk_paths, archive->command->propExtractCanJunkPaths);
+ g_list_free (filtered);
+ filtered = tmp_list;
+ }
+
+ move_files_in_chunks (archive,
+ filtered,
+ temp_dir,
+ destination,
+ overwrite);
+
+ /* remove the temp dir. */
+
+ fr_process_begin_command (archive->process, "rm");
+ fr_process_add_arg (archive->process, "-rf");
+ fr_process_add_arg (archive->process, temp_dir);
+ fr_process_end_command (archive->process);
+
+ g_free (temp_dir);
+ }
+ else
+ extract_from_archive (archive,
+ filtered,
+ destination,
+ overwrite,
+ skip_older,
+ junk_paths,
+ password);
+
+ if (filtered != NULL)
+ g_list_free (filtered);
+ if (file_list_created)
+ path_list_free (file_list);
+}
+
+
+void
+fr_archive_extract (FrArchive *archive,
+ GList *file_list,
+ const char *destination,
+ const char *base_dir,
+ gboolean skip_older,
+ gboolean overwrite,
+ gboolean junk_paths,
+ const char *password)
+{
+ g_free (archive->priv->extraction_destination);
+ archive->priv->extraction_destination = g_strdup (destination);
+
+ g_free (archive->priv->temp_extraction_dir);
+ archive->priv->temp_extraction_dir = NULL;
+
+ archive->priv->remote_extraction = ! uri_is_local (destination);
+ if (archive->priv->remote_extraction) {
+ archive->priv->temp_extraction_dir = get_temp_work_dir (NULL);
+ fr_archive_extract_to_local (archive,
+ file_list,
+ archive->priv->temp_extraction_dir,
+ base_dir,
+ skip_older,
+ overwrite,
+ junk_paths,
+ password);
+ }
+ else {
+ char *local_destination;
+
+ local_destination = g_filename_from_uri (destination, NULL, NULL);
+ fr_archive_extract_to_local (archive,
+ file_list,
+ local_destination,
+ base_dir,
+ skip_older,
+ overwrite,
+ junk_paths,
+ password);
+ g_free (local_destination);
+ }
+}
+
+
+static char *
+get_desired_destination_for_archive (GFile *file)
+{
+ GFile *directory;
+ char *directory_uri;
+ char *name;
+ const char *ext;
+ char *new_name;
+ char *new_name_escaped;
+ char *desired_destination = NULL;
+
+ directory = g_file_get_parent (file);
+ directory_uri = g_file_get_uri (directory);
+
+ name = g_file_get_basename (file);
+ ext = get_archive_filename_extension (name);
+ if (ext == NULL)
+ /* if no extension is present add a suffix to the name... */
+ new_name = g_strconcat (name, "_FILES", NULL);
+ else
+ /* ...else use the name without the extension */
+ new_name = g_strndup (name, strlen (name) - strlen (ext));
+ new_name_escaped = g_uri_escape_string (new_name, "", FALSE);
+
+ desired_destination = g_strconcat (directory_uri, "/", new_name_escaped, NULL);
+
+ g_free (new_name_escaped);
+ g_free (new_name);
+ g_free (name);
+ g_free (directory_uri);
+ g_object_unref (directory);
+
+ return desired_destination;
+}
+
+
+static char *
+get_extract_here_destination (GFile *file,
+ GError **error)
+{
+ char *desired_destination;
+ char *destination = NULL;
+ int n = 1;
+ GFile *directory;
+
+ desired_destination = get_desired_destination_for_archive (file);
+ do {
+ *error = NULL;
+
+ g_free (destination);
+ if (n == 1)
+ destination = g_strdup (desired_destination);
+ else
+ destination = g_strdup_printf ("%s%%20(%d)", desired_destination, n);
+
+ directory = g_file_new_for_uri (destination);
+ g_file_make_directory (directory, NULL, error);
+ g_object_unref (directory);
+
+ n++;
+ } while (g_error_matches (*error, G_IO_ERROR, G_IO_ERROR_EXISTS));
+
+ g_free (desired_destination);
+
+ if (*error != NULL) {
+ g_warning ("could not create destination folder: %s\n", (*error)->message);
+ g_free (destination);
+ destination = NULL;
+ }
+
+ return destination;
+}
+
+
+gboolean
+fr_archive_extract_here (FrArchive *archive,
+ gboolean skip_older,
+ gboolean overwrite,
+ gboolean junk_path,
+ const char *password)
+{
+ char *destination;
+ GError *error = NULL;
+
+ destination = get_extract_here_destination (archive->file, &error);
+ if (error != NULL) {
+ fr_archive_action_completed (archive,
+ FR_ACTION_EXTRACTING_FILES,
+ FR_PROC_ERROR_GENERIC,
+ error->message);
+ g_clear_error (&error);
+ return FALSE;
+ }
+
+ archive->priv->extract_here = TRUE;
+ fr_archive_extract (archive,
+ NULL,
+ destination,
+ NULL,
+ skip_older,
+ overwrite,
+ junk_path,
+ password);
+
+ g_free (destination);
+
+ return TRUE;
+}
+
+
+const char *
+fr_archive_get_last_extraction_destination (FrArchive *archive)
+{
+ return archive->priv->extraction_destination;
+}
+
+
+void
+fr_archive_test (FrArchive *archive,
+ const char *password)
+{
+ fr_archive_stoppable (archive, TRUE);
+
+ g_object_set (archive->command, "password", password, NULL);
+ fr_process_clear (archive->process);
+ fr_command_set_n_files (archive->command, 0);
+ fr_command_test (archive->command);
+ fr_process_start (archive->process);
+}
+
+
+gboolean
+uri_is_archive (const char *uri)
+{
+ GFile *file;
+ const char *mime_type;
+ gboolean is_archive = FALSE;
+
+ file = g_file_new_for_uri (uri);
+ mime_type = get_mime_type_from_magic_numbers (file);
+ if (mime_type == NULL)
+ mime_type = get_mime_type_from_content (file);
+ if (mime_type == NULL)
+ mime_type = get_mime_type_from_filename (file);
+
+ if (mime_type != NULL) {
+ int i;
+
+ for (i = 0; mime_type_desc[i].mime_type != NULL; i++) {
+ if (strcmp (mime_type_desc[i].mime_type, mime_type) == 0) {
+ is_archive = TRUE;
+ break;
+ }
+ }
+ }
+ g_object_unref (file);
+
+ return is_archive;
+}