diff options
Diffstat (limited to 'src/fr-archive.c')
| -rw-r--r-- | src/fr-archive.c | 3354 |
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; +} |