static void
fr_command_cfile_list (FrCommand *comm)
{
FrCommandCFile *comm_cfile = FR_COMMAND_CFILE (comm);
if (is_mime_type (comm->mime_type, "application/x-gzip")) {
/* gzip let us known the uncompressed size */
fr_process_set_out_line_func (FR_COMMAND (comm)->process,
list__process_line,
comm);
fr_process_begin_command (comm->process, "gzip");
fr_process_add_arg (comm->process, "-l");
fr_process_add_arg (comm->process, "-q");
fr_process_add_arg (comm->process, comm->filename);
fr_process_end_command (comm->process);
fr_process_start (comm->process);
}
else {
/* ... other compressors do not support this feature so
* simply use the archive size, suboptimal but there is no
* alternative. */
FileData *fdata;
char *filename;
fdata = file_data_new ();
filename = remove_extension_from_path (comm->filename);
fdata->full_path = g_strconcat ("/",
file_name_from_path (filename),
NULL);
g_free (filename);
fdata->original_path = fdata->full_path + 1;
fdata->link = NULL;
fdata->size = get_file_size_for_path (comm->filename);
fdata->modified = get_file_mtime_for_path (comm->filename);
fdata->name = g_strdup (file_name_from_path (fdata->full_path));
fdata->path = remove_level_from_path (fdata->full_path);
if (*fdata->name == 0)
file_data_free (fdata);
else
fr_command_add_file (comm, fdata);
comm_cfile->error.type = FR_PROC_ERROR_NONE;
comm_cfile->error.status = 0;
g_signal_emit_by_name (G_OBJECT (comm),
"done",
comm->action,
&comm_cfile->error);
}
}
void file_list_add(File_t * list, char *path, ssize_t size, unsigned int mode,
unsigned int mtime)
{
File_t *c = list;
while (c->next)
{
c = c->next;
}
if (c->next == NULL)
{
c->next = calloc(1, sizeof(File_t));
if (c->next == NULL)
{
Error("calloc()");
}
c = c->next;
c->next = NULL;
char *p = file_name_from_path(path);
strlcpy(c->path, p, PATH_MAX);
c->mode = mode;
c->size = size;
c->mtime = mtime;
c->changed = 0x00;
}
}
std::vector<CountH5Record> count(const std::string chr,
const std::string cell_type,
const unsigned int bin_size,
const size_t length,
const unsigned int extension,
const char strand,
const std::string bam_file)
{
const std::string bam_file_name = file_name_from_path(bam_file);
int bins = std::ceil(length / (double) bin_size);
int max_base_pair = bins * bin_size;
const std::vector<double> bin_counts = liquidate(bam_file, chr, 0, max_base_pair, strand, bins, extension);
CountH5Record record;
record.bin_number = 0;
strncpy(record.cell_type, cell_type.c_str(), sizeof(CountH5Record::cell_type));
strncpy(record.chromosome, chr.c_str(), sizeof(CountH5Record::chromosome));
strncpy(record.file_name, bam_file_name.c_str(), sizeof(CountH5Record::file_name));
std::vector<CountH5Record> records(bin_counts.size(), record);
for (size_t bin=0; bin < bin_counts.size(); ++bin)
{
records[bin].bin_number = bin;
records[bin].count = bin_counts[bin];
}
return records;
}
FileData *
file_data_dup (FileData *source)
{
FileData *fd;
if (source == NULL)
return NULL;
fd = g_new0 (FileData, 1);
fd->ref = 1;
fd->path = g_strdup (source->path);
fd->name = file_name_from_path (fd->path);
fd->display_name = g_strdup (source->display_name);
fd->mime_type = get_static_string (source->mime_type);
fd->size = source->size;
fd->ctime = source->ctime;
fd->mtime = source->mtime;
fd->exif_data_loaded = source->exif_data_loaded;
fd->exif_time = source->exif_time;
fd->error = source->error;
fd->thumb_loaded = source->thumb_loaded;
fd->thumb_created = source->thumb_created;
fd->comment = (source->comment != NULL) ? g_strdup (source->comment) : NULL;
fd->comment_data = comment_data_dup (source->comment_data);
return fd;
}
static void
dlg_add_folder_save_last_used_options (DialogData *data,
const char *options_path)
{
g_free (data->last_options);
data->last_options = g_strdup (file_name_from_path (options_path));
}
bool test_file_name_from_path_invalid_operation (Test *test)
{
TITLE ();
CATCH (file_name_from_path (NULL));
CATCH (error_count () == 0);
CATCH (error_at (0).error != ErrorInvalidOperation);
PASS ();
}
static void
list__process_line (char *line,
gpointer data)
{
FileData *fdata;
FrCommand *comm = FR_COMMAND (data);
FrCommandIso *comm_iso = FR_COMMAND_ISO (comm);
char **fields;
const char *name_field;
g_return_if_fail (line != NULL);
if (line[0] == 'd') /* Ignore directories. */
return;
if (line[0] == 'D') {
g_free (comm_iso->cur_path);
comm_iso->cur_path = g_strdup (get_last_field (line, 4));
} else if (line[0] == '-') { /* Is file */
const char *last_field, *first_bracket;
fdata = file_data_new ();
fields = split_line (line, 8);
fdata->size = g_ascii_strtoull (fields[4], NULL, 10);
fdata->modified = mktime_from_string (fields[5], fields[6], fields[7]);
g_strfreev (fields);
/* Full path */
last_field = get_last_field (line, 9);
first_bracket = strchr (last_field, ']');
if (first_bracket == NULL) {
file_data_free (fdata);
return;
}
name_field = eat_spaces (first_bracket + 1);
if ((name_field == NULL)
|| (strcmp (name_field, ".") == 0)
|| (strcmp (name_field, "..") == 0)) {
file_data_free (fdata);
return;
}
if (comm_iso->cur_path[0] != '/')
fdata->full_path = g_strstrip (g_strconcat ("/", comm_iso->cur_path, name_field, NULL));
else
fdata->full_path = g_strstrip (g_strconcat (comm_iso->cur_path, name_field, NULL));
fdata->original_path = fdata->full_path;
fdata->name = g_strdup (file_name_from_path (fdata->full_path));
fdata->path = remove_level_from_path (fdata->full_path);
fr_command_add_file (comm, fdata);
}
}
bool remote_file_del(char *file)
{
char path[PATH_MAX] = { 0 };
snprintf(path, sizeof(path), "%s%c%s", directory, SLASH, file);
if (debugging)
{
printf("the path is %s\n", path);
}
int sock = Connect(hostname, REMOTE_PORT);
if (!sock)
{
fprintf(stderr, "Could not connect()\n");
return false;
}
int content_length = 0;
char *file_from_path = file_name_from_path(path);
char dirname[PATH_MAX] = { 0 };
snprintf(dirname, sizeof(dirname), "%s", directory);
char *dir_from_path = file_name_from_path(dirname);
char post[BUF_MAX] = { 0 };
char *fmt =
"POST %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Content-Length: %d\r\n"
"Username: %s\r\n"
"Password: %s\r\n"
"Directory: %s\r\n"
"Filename: %s\r\n"
"Action: DEL\r\n\r\n";
snprintf(post, sizeof(post), fmt, REMOTE_URI, hostname,
content_length, username, password, dir_from_path, file_from_path);
Write(sock, post, strlen(post));
Close(sock);
return true;
}
static void
list_command_completed (gpointer data)
{
FrCommandUnarchiver *unar_comm = FR_COMMAND_UNARCHIVER (data);
JsonParser *parser;
GError *error = NULL;
parser = json_parser_new ();
if (json_parser_load_from_stream (parser, unar_comm->stream, NULL, &error)) {
JsonObject *root;
root = json_node_get_object (json_parser_get_root (parser));
if (json_object_get_int_member (root, "lsarFormatVersion") == LSAR_SUPPORTED_FORMAT) {
JsonArray *content;
int i;
content = json_object_get_array_member (root, "lsarContents");
for (i = 0; i < json_array_get_length (content); i++) {
JsonObject *entry;
FileData *fdata;
const char *filename;
entry = json_array_get_object_element (content, i);
fdata = file_data_new ();
fdata->size = json_object_get_int_member (entry, "XADFileSize");
fdata->modified = mktime_from_string (json_object_get_string_member (entry, "XADLastModificationDate"));
if (json_object_has_member (entry, "XADIsEncrypted"))
fdata->encrypted = json_object_get_int_member (entry, "XADIsEncrypted") == 1;
filename = json_object_get_string_member (entry, "XADFileName");
if (*filename == '/') {
fdata->full_path = g_strdup (filename);
fdata->original_path = fdata->full_path;
}
else {
fdata->full_path = g_strconcat ("/", filename, NULL);
fdata->original_path = fdata->full_path + 1;
}
fdata->link = NULL;
if (json_object_has_member (entry, "XADIsDirectory"))
fdata->dir = json_object_get_int_member (entry, "XADIsDirectory") == 1;
if (fdata->dir)
fdata->name = dir_name_from_path (fdata->full_path);
else
fdata->name = g_strdup (file_name_from_path (fdata->full_path));
fdata->path = remove_level_from_path (fdata->full_path);
fr_command_add_file (FR_COMMAND (unar_comm), fdata);
}
}
}
g_object_unref (parser);
}
bool test_file_name_from_path (Test *test)
{
char *name;
TITLE ();
CATCH (!(name = file_name_from_path ("/")));
CATCH (!string_equals (name, "/"));
string_destroy (name);
CATCH (!(name = file_name_from_path ("/a")));
CATCH (!string_equals (name, "a"));
string_destroy (name);
CATCH (!(name = file_name_from_path ("/a/bb")));
CATCH (!string_equals (name, "bb"));
string_destroy (name);
CATCH (!(name = file_name_from_path ("/a/bb/ccc.dddd")));
CATCH (!string_equals (name, "ccc.dddd"));
string_destroy (name);
PASS ();
}
static void
list__process_line (char *line,
gpointer data)
{
FrCommand *comm = FR_COMMAND (data);
FileData *fdata;
char **fields;
char *filename;
fdata = file_data_new ();
fields = split_line (line, 2);
if (strcmp (fields[1], "-1") != 0)
fdata->size = g_ascii_strtoull (fields[1], NULL, 10);
g_strfreev (fields);
if (fdata->size == 0)
fdata->size = get_file_size (comm->filename);
filename = get_uncompressed_name_from_archive (comm, comm->filename);
if (filename == NULL)
filename = remove_extension_from_path (comm->filename);
fdata->full_path = g_strconcat ("/",
file_name_from_path (filename),
NULL);
g_free (filename);
fdata->original_path = fdata->full_path + 1;
fdata->link = NULL;
fdata->modified = get_file_mtime_for_path (comm->filename);
fdata->name = g_strdup (file_name_from_path (fdata->full_path));
fdata->path = remove_level_from_path (fdata->full_path);
if (*fdata->name == 0)
file_data_free (fdata);
else
fr_command_add_file (comm, fdata);
}
static char *
get_uncompressed_name_from_archive (FrCommand *comm,
const char *archive)
{
GFile *file;
GInputStream *stream;
char *filename = NULL;
if (! is_mime_type (comm->mime_type, "application/x-gzip"))
return NULL;
file = g_file_new_for_path (archive);
stream = (GInputStream *) g_file_read (file, NULL, NULL);
if (stream != NULL) {
gboolean filename_present = TRUE;
char buffer[10];
if (g_input_stream_read (stream, buffer, 10, NULL, NULL) >= 0) {
/* Check whether the FLG.FNAME is set */
if (((unsigned char)(buffer[3]) & 0x08) != 0x08)
filename_present = FALSE;
/* Check whether the FLG.FEXTRA is set */
if (((unsigned char)(buffer[3]) & 0x04) == 0x04)
filename_present = FALSE;
}
if (filename_present) {
GString *str = NULL;
str = g_string_new ("");
while (g_input_stream_read (stream, buffer, 1, NULL, NULL) > 0) {
if (buffer[0] == '\0') {
filename = g_strdup (file_name_from_path (str->str));
#ifdef DEBUG
g_message ("filename is: %s", filename);
#endif
break;
}
g_string_append_c (str, buffer[0]);
}
g_string_free (str, TRUE);
}
g_object_unref (stream);
}
g_object_unref (file);
return filename;
}
void
rar_check_multi_vomule (FrCommand *comm)
{
GFile *file;
char buffer[11];
file = g_file_new_for_path (comm->filename);
if (! g_load_file_in_buffer (file, buffer, 11, NULL)) {
g_object_unref (file);
return;
}
if (memcmp (buffer, "Rar!", 4) != 0)
return;
if ((buffer[10] & 0x01) == 0x01) {
char *volume_name = NULL;
char *name;
name = g_filename_to_utf8 (file_name_from_path (comm->filename), -1, NULL, NULL, NULL);
volume_name = get_first_volume_name (name, "^(.*\\.part)([0-9]+)(\\.rar)$", FIRST_VOLUME_IS_001);
if (volume_name == NULL)
volume_name = get_first_volume_name (name, "^(.*\\.r)([0-9]+)$", FIRST_VOLUME_IS_RAR);
if (volume_name == NULL)
volume_name = get_first_volume_name (name, "^(.*\\.)([0-9]+)$", FIRST_VOLUME_IS_001);
if (volume_name != NULL) {
GFile *parent;
GFile *child;
char *volume_filename;
parent = g_file_get_parent (file);
child = g_file_get_child (parent, volume_name);
volume_filename = g_file_get_path (child);
fr_command_set_multi_volume (comm, volume_filename);
g_free (volume_filename);
g_object_unref (child);
g_object_unref (parent);
}
g_free (name);
}
g_object_unref (file);
}
static void
process_line (char *line,
gpointer data)
{
FileData *fdata;
FrCommand *comm = FR_COMMAND (data);
char **fields;
const char *name_field;
g_return_if_fail (line != NULL);
fdata = file_data_new ();
fields = split_line_lha (line);
fdata->size = g_ascii_strtoull (fields[2], NULL, 10);
fdata->modified = mktime_from_string (fields[4],
fields[5],
fields[6]);
g_strfreev (fields);
/* Full path */
name_field = get_last_field_lha (line);
if (name_field && *name_field == '/') {
fdata->full_path = g_strdup (name_field);
fdata->original_path = fdata->full_path;
} else {
fdata->full_path = g_strconcat ("/", name_field, NULL);
fdata->original_path = fdata->full_path + 1;
}
fdata->link = NULL;
fdata->dir = line[0] == 'd';
if (fdata->dir)
fdata->name = dir_name_from_path (fdata->full_path);
else
fdata->name = g_strdup (file_name_from_path (fdata->full_path));
fdata->path = remove_level_from_path (fdata->full_path);
if (*fdata->name == 0)
file_data_free (fdata);
else
fr_command_add_file (comm, fdata);
}
static void
fr_command_iso_extract (FrCommand *comm,
const char *from_file,
GList *file_list,
const char *dest_dir,
gboolean overwrite,
gboolean skip_older,
gboolean junk_paths)
{
GList *scan;
for (scan = file_list; scan; scan = scan->next) {
char *path = scan->data;
const char *filename;
char *file_dir;
char *temp_dest_dir = NULL;
filename = file_name_from_path (path);
file_dir = remove_level_from_path (path);
if ((file_dir != NULL) && (strcmp (file_dir, "/") != 0))
temp_dest_dir = g_build_filename (dest_dir, file_dir, NULL);
else
temp_dest_dir = g_strdup (dest_dir);
g_free (file_dir);
if (temp_dest_dir == NULL)
continue;
make_directory_tree_from_path (temp_dest_dir, 0700, NULL);
fr_process_begin_command (comm->process, "sh");
fr_process_set_working_dir (comm->process, temp_dest_dir);
fr_process_add_arg (comm->process, SHDIR "isoinfo.sh");
fr_process_add_arg (comm->process, "-i");
fr_process_add_arg (comm->process, comm->filename);
fr_process_add_arg (comm->process, "-x");
fr_process_add_arg (comm->process, path);
fr_process_add_arg (comm->process, filename);
fr_process_end_command (comm->process);
g_free (temp_dest_dir);
}
}
FileData *
file_data_new (const char *path,
GnomeVFSFileInfo *info)
{
FileData *fd;
fd = g_new0 (FileData, 1);
fd->ref = 1;
fd->path = add_scheme_if_absent (path);
fd->name = file_name_from_path (fd->path);
fd->display_name = gnome_vfs_unescape_string_for_display (fd->name);
if (info != NULL) {
if (info->valid_fields | GNOME_VFS_FILE_INFO_FIELDS_SIZE)
fd->size = info->size;
if (info->valid_fields | GNOME_VFS_FILE_INFO_FIELDS_CTIME)
fd->ctime = info->ctime;
if (info->valid_fields | GNOME_VFS_FILE_INFO_FIELDS_MTIME)
fd->mtime = info->mtime;
if (info->valid_fields | GNOME_VFS_FILE_INFO_FIELDS_MIME_TYPE)
fd->mime_type = get_static_string (info->mime_type);
}
else {
fd->size = (GnomeVFSFileSize) 0;
fd->ctime = (time_t) 0;
fd->mtime = (time_t) 0;
}
/* The Exif DateTime tag is only recorded on an as-needed basis during
DateTime sorts. The tag in memory is refreshed if the file mtime has
changed, so it is recorded as well. */
fd->exif_data_loaded = FALSE;
fd->exif_time = 0;
fd->error = FALSE;
fd->thumb_loaded = FALSE;
fd->thumb_created = FALSE;
fd->comment = g_strdup ("");
return fd;
}
void
file_data_update (FileData *fd)
{
GnomeVFSFileInfo *info;
GnomeVFSResult result;
g_return_if_fail (fd != NULL);
fd->error = FALSE;
fd->thumb_loaded = FALSE;
fd->thumb_created = FALSE;
info = gnome_vfs_file_info_new ();
result = gnome_vfs_get_file_info (fd->path,
info,
(GNOME_VFS_FILE_INFO_FOLLOW_LINKS
| GNOME_VFS_FILE_INFO_GET_MIME_TYPE
| GNOME_VFS_FILE_INFO_FORCE_FAST_MIME_TYPE));
if (result != GNOME_VFS_OK) {
fd->error = TRUE;
fd->size = 0L;
fd->mtime = 0;
fd->ctime = 0;
fd->exif_data_loaded = FALSE;
fd->mime_type = NULL;
return;
}
fd->name = file_name_from_path (fd->path);
g_free (fd->display_name);
fd->display_name = gnome_vfs_unescape_string_for_display (fd->name);
fd->mime_type = get_static_string (info->mime_type);
fd->size = info->size;
fd->mtime = info->mtime;
fd->ctime = info->ctime;
fd->exif_data_loaded = FALSE;
gnome_vfs_file_info_unref (info);
}
char *
cache_get_nautilus_cache_name (const char *path)
{
char *parent;
char *resolved_parent;
char *resolved_path = NULL;
GnomeVFSResult result;
GnomeVFSURI *uri;
char *uri_txt;
char *retval;
parent = remove_level_from_path (path);
result = resolve_all_symlinks (parent, &resolved_parent);
g_free (parent);
if (result == GNOME_VFS_OK)
resolved_path = g_strconcat (resolved_parent,
"/",
file_name_from_path (path),
NULL);
else
resolved_path = g_strdup (path);
uri = new_uri_from_path (resolved_path);
g_free (resolved_path);
g_free (resolved_parent);
uri_txt = gnome_vfs_uri_to_string (uri, GNOME_VFS_URI_HIDE_NONE);
gnome_vfs_uri_unref (uri);
if (uri_txt == NULL)
return NULL;
retval = gnome_thumbnail_path_for_uri (uri_txt, GNOME_THUMBNAIL_SIZE_NORMAL);
g_free (uri_txt);
return retval;
}
static void
process_line__generic (char *line,
gpointer data,
char *action_msg)
{
FrCommand *comm = FR_COMMAND (data);
char *msg;
if (line == NULL)
return;
if (line[strlen (line) - 1] == '/') /* ignore directories */
return;
msg = g_strconcat (action_msg, file_name_from_path (line), NULL);
fr_command_message (comm, msg);
g_free (msg);
if (comm->n_files != 0) {
double fraction = (double) ++comm->n_file / (comm->n_files + 1);
fr_command_progress (comm, fraction);
}
}
std::vector<CountH5Record> count_placeholders(
const std::vector<std::pair<std::string, size_t>>& chromosome_lengths,
const std::string& cell_type,
const std::string& bam_file_path,
const unsigned int bin_size)
{
size_t num_records = 0;
for (auto& chr_length : chromosome_lengths)
{
int bins = std::ceil(chr_length.second / (double) bin_size);
num_records += bins;
}
const std::string bam_file_name = file_name_from_path(bam_file_path);
CountH5Record empty_record;
empty_record.bin_number = 0;
empty_record.count = 0;
strncpy(empty_record.cell_type, cell_type.c_str(), sizeof(CountH5Record::cell_type));
strncpy(empty_record.chromosome, "", sizeof(CountH5Record::chromosome));
strncpy(empty_record.file_name, bam_file_name.c_str(), sizeof(CountH5Record::file_name));
std::vector<CountH5Record> records(num_records, empty_record);
size_t i=0;
for (auto& chr_length : chromosome_lengths)
{
int bins = std::ceil(chr_length.second / (double) bin_size);
for (size_t j=0; j < bins; ++j, ++i)
{
records[i].bin_number = j;
strncpy(records[i].chromosome, chr_length.first.c_str(), sizeof(CountH5Record::chromosome));
}
}
return records;
}
static char *
get_full_uri (DlgNewData *data)
{
char *full_uri = NULL;
char *uri;
const char *filename;
int idx;
uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (data->dialog));
if ((uri == NULL) || (*uri == 0))
return NULL;
filename = file_name_from_path (uri);
if ((filename == NULL) || (*filename == 0)) {
g_free (uri);
return NULL;
}
idx = egg_file_format_chooser_get_format (EGG_FILE_FORMAT_CHOOSER (data->format_chooser), uri);
if (idx > 0) {
const char *uri_ext;
char *default_ext;
uri_ext = get_archive_filename_extension (uri);
default_ext = mime_type_desc[data->supported_types[idx-1]].default_ext;
if (strcmp_null_tolerant (uri_ext, default_ext) != 0) {
full_uri = g_strconcat (uri, default_ext, NULL);
g_free (uri);
}
}
if (full_uri == NULL)
full_uri = uri;
return full_uri;
}
int
gth_sort_by_filename_but_ignore_path (const char *name1,
const char *name2)
{
/* This sorts by the filename. It ignores the path portion, if present. */
/* Based heavily on the Nautilus compare_by_display_name (libnautilus-private/nautilus-file.c)
function, for consistent Nautilus / gthumb behaviour. */
char *key_1, *key_2;
gboolean sort_last_1, sort_last_2;
int compare;
char *unesc_name1, *unesc_name2;
sort_last_1 = file_name_from_path (name1)[0] == SORT_LAST_CHAR1
|| file_name_from_path (name1)[0] == SORT_LAST_CHAR2;
sort_last_2 = file_name_from_path (name2)[0] == SORT_LAST_CHAR1
|| file_name_from_path (name2)[0] == SORT_LAST_CHAR2;
if (sort_last_1 && !sort_last_2) {
compare = +1;
} else if (!sort_last_1 && sort_last_2) {
compare = -1;
} else {
unesc_name1 = gnome_vfs_unescape_string (name1, "");
unesc_name2 = gnome_vfs_unescape_string (name2, "");
key_1 = g_utf8_collate_key_for_filename (file_name_from_path (unesc_name1), -1);
key_2 = g_utf8_collate_key_for_filename (file_name_from_path (unesc_name2), -1);
compare = strcmp (key_1, key_2);
g_free(key_1);
g_free(key_2);
g_free(unesc_name1);
g_free(unesc_name2);
}
return compare;
}
static void
fr_command_cfile_extract (FrCommand *comm,
const char *from_file,
GList *file_list,
const char *dest_dir,
gboolean overwrite,
gboolean skip_older,
gboolean junk_paths)
{
char *temp_dir;
char *dest_file;
char *temp_file;
char *uncompr_file;
char *compr_file;
/* copy file to the temp dir, remove the already existing file first */
temp_dir = get_temp_work_dir (NULL);
temp_file = g_strconcat (temp_dir,
"/",
file_name_from_path (comm->filename),
NULL);
fr_process_begin_command (comm->process, "cp");
fr_process_add_arg (comm->process, "-f");
fr_process_add_arg (comm->process, comm->filename);
fr_process_add_arg (comm->process, temp_file);
fr_process_end_command (comm->process);
/* uncompress the file */
if (is_mime_type (comm->mime_type, "application/x-gzip")) {
fr_process_begin_command (comm->process, "gzip");
fr_process_add_arg (comm->process, "-f");
fr_process_add_arg (comm->process, "-d");
fr_process_add_arg (comm->process, "-n");
fr_process_add_arg (comm->process, temp_file);
fr_process_end_command (comm->process);
}
else if (is_mime_type (comm->mime_type, "application/x-bzip")) {
fr_process_begin_command (comm->process, "bzip2");
fr_process_add_arg (comm->process, "-f");
fr_process_add_arg (comm->process, "-d");
fr_process_add_arg (comm->process, temp_file);
fr_process_end_command (comm->process);
}
else if (is_mime_type (comm->mime_type, "application/x-compress")) {
if (is_program_in_path ("gzip")) {
fr_process_begin_command (comm->process, "gzip");
fr_process_add_arg (comm->process, "-d");
fr_process_add_arg (comm->process, "-n");
}
else
fr_process_begin_command (comm->process, "uncompress");
fr_process_add_arg (comm->process, "-f");
fr_process_add_arg (comm->process, temp_file);
fr_process_end_command (comm->process);
}
else if (is_mime_type (comm->mime_type, "application/x-lzip")) {
fr_process_begin_command (comm->process, "lzip");
fr_process_add_arg (comm->process, "-f");
fr_process_add_arg (comm->process, "-d");
fr_process_add_arg (comm->process, temp_file);
fr_process_end_command (comm->process);
}
else if (is_mime_type (comm->mime_type, "application/x-lzma")) {
fr_process_begin_command (comm->process, "lzma");
fr_process_add_arg (comm->process, "-f");
fr_process_add_arg (comm->process, "-d");
fr_process_add_arg (comm->process, temp_file);
fr_process_end_command (comm->process);
}
else if (is_mime_type (comm->mime_type, "application/x-xz")) {
fr_process_begin_command (comm->process, "xz");
fr_process_add_arg (comm->process, "-f");
fr_process_add_arg (comm->process, "-d");
fr_process_add_arg (comm->process, temp_file);
fr_process_end_command (comm->process);
}
else if (is_mime_type (comm->mime_type, "application/x-lzop")) {
fr_process_begin_command (comm->process, "lzop");
fr_process_set_working_dir (comm->process, temp_dir);
fr_process_add_arg (comm->process, "-d");
fr_process_add_arg (comm->process, "-fU");
fr_process_add_arg (comm->process, "--no-stdin");
fr_process_add_arg (comm->process, temp_file);
fr_process_end_command (comm->process);
}
else if (is_mime_type (comm->mime_type, "application/x-rzip")) {
fr_process_begin_command (comm->process, "rzip");
fr_process_add_arg (comm->process, "-f");
fr_process_add_arg (comm->process, "-d");
fr_process_add_arg (comm->process, temp_file);
fr_process_end_command (comm->process);
}
/* copy uncompress file to the dest dir */
uncompr_file = remove_extension_from_path (temp_file);
compr_file = get_uncompressed_name_from_archive (comm, comm->filename);
if (compr_file == NULL)
compr_file = remove_extension_from_path (file_name_from_path (comm->filename));
dest_file = g_strconcat (dest_dir,
"/",
compr_file,
NULL);
fr_process_begin_command (comm->process, "cp");
fr_process_add_arg (comm->process, "-f");
fr_process_add_arg (comm->process, uncompr_file);
fr_process_add_arg (comm->process, dest_file);
fr_process_end_command (comm->process);
/* remove the temp dir */
fr_process_begin_command (comm->process, "rm");
fr_process_set_sticky (comm->process, TRUE);
fr_process_add_arg (comm->process, "-rf");
fr_process_add_arg (comm->process, temp_dir);
fr_process_end_command (comm->process);
g_free (dest_file);
g_free (compr_file);
g_free (uncompr_file);
g_free (temp_file);
g_free (temp_dir);
}
static void
process_line (char *line,
gpointer data)
{
FrCommand *comm = FR_COMMAND (data);
FrCommandUnstuff *unstuff_comm = FR_COMMAND_UNSTUFF (comm);
const char *str_start;
char *filename, *real_filename;
int i;
FileData *fdata;
g_return_if_fail (line != NULL);
if (strstr (line, "progressEvent - ")) {
const char *ssize;
guint size;
ssize = strstr (line, "progressEvent - ")
+ strlen ("progressEvent - ");
if (ssize[0] == '\0')
size = 0;
else
size = g_ascii_strtoull (ssize, NULL, 10);
if (unstuff_comm->fdata != NULL)
unstuff_comm->fdata->size = size;
return;
}
if (strstr (line, "fileEvent") == NULL)
return;
if (strstr (line, unstuff_comm->target_dir + 1) == NULL)
return;
/* Look for the filename, ends with a comma */
str_start = strstr (line, unstuff_comm->target_dir + 1);
str_start = str_start + strlen (unstuff_comm->target_dir) - 1;
if (str_start[0] != '/')
str_start--;
if (str_start[0] == '.')
str_start--;
i = 0;
while (str_start[i] != '\0' && str_start[i] != ',') {
i++;
}
/* This is not supposed to happen */
g_return_if_fail (str_start[i] != '\0');
filename = g_strndup (str_start, i);
/* Same thing with the real filename */
str_start = strstr (line, unstuff_comm->target_dir);
i = 0;
while (str_start[i] != '\0' && str_start[i] != ',') {
i++;
}
real_filename = g_strndup (str_start, i);
fdata = file_data_new ();
fdata->full_path = filename;
fdata->original_path = filename;
fdata->link = NULL;
fdata->name = g_strdup (file_name_from_path (fdata->full_path));
fdata->path = remove_level_from_path (fdata->full_path);
fdata->size = 0;
fdata->modified = time (NULL);
unstuff_comm->fdata = fdata;
fr_command_add_file (comm, fdata);
unlink (real_filename);
g_free (real_filename);
}
static void
process_line (char *line,
gpointer data)
{
FileData *fdata;
FrCommandAce *ace_comm = FR_COMMAND_ACE (data);
FrCommand *comm = FR_COMMAND (data);
char **fields = NULL;
const char *field_name = NULL;
g_return_if_fail (line != NULL);
if (ace_comm->command_type == FR_ACE_COMMAND_UNKNOWN) {
if (g_str_has_prefix (line, "UNACE")) {
if (strstr (line, "public version") != NULL)
ace_comm->command_type = FR_ACE_COMMAND_PUBLIC;
else
ace_comm->command_type = FR_ACE_COMMAND_NONFREE;
}
return;
}
if (! ace_comm->list_started) {
if (ace_comm->command_type == FR_ACE_COMMAND_PUBLIC) {
if (g_str_has_prefix (line, "Date"))
ace_comm->list_started = TRUE;
}
else if (ace_comm->command_type == FR_ACE_COMMAND_NONFREE) {
if (g_str_has_prefix (line, " Date"))
ace_comm->list_started = TRUE;
}
return;
}
fdata = file_data_new ();
if (ace_comm->command_type == FR_ACE_COMMAND_PUBLIC)
fields = g_strsplit (line, "|", 6);
else if (ace_comm->command_type == FR_ACE_COMMAND_NONFREE)
fields = split_line (line, 5);
if ((fields == NULL) || (fields[0] == NULL) || (n_fields (fields) < 5))
return;
fdata->size = g_ascii_strtoull (fields[3], NULL, 10);
fdata->modified = mktime_from_string (fields[0], fields[1]);
if (ace_comm->command_type == FR_ACE_COMMAND_PUBLIC) {
field_name = fields[5];
field_name = field_name + 1;
}
else if (ace_comm->command_type == FR_ACE_COMMAND_NONFREE)
field_name = get_last_field (line, 6);
g_assert (field_name != NULL);
if (field_name[0] != '/') {
fdata->full_path = g_strconcat ("/", field_name, NULL);
fdata->original_path = fdata->full_path + 1;
}
else {
fdata->full_path = g_strdup (field_name);
fdata->original_path = fdata->full_path;
}
g_strfreev (fields);
fdata->name = g_strdup (file_name_from_path (fdata->full_path));
fdata->path = remove_level_from_path (fdata->full_path);
if (*fdata->name == 0)
file_data_free (fdata);
else
fr_command_add_file (comm, fdata);
}
static void
list__process_line (char *line,
gpointer data)
{
FileData *fdata;
FrCommand *comm = FR_COMMAND (data);
char **fields;
const char *name_field;
char *name;
int ofs = 0;
g_return_if_fail (line != NULL);
fdata = file_data_new ();
#ifdef __sun
fields = split_line (line, 9);
fdata->size = g_ascii_strtoull (fields[4], NULL, 10);
fdata->modified = mktime_from_string (fields[5], fields[6], fields[8]);
g_strfreev (fields);
name_field = get_last_field (line, 10);
#else /* !__sun */
/* Handle char and block device files */
if ((line[0] == 'c') || (line[0] == 'b')) {
fields = split_line (line, 9);
ofs = 1;
fdata->size = 0;
/* FIXME: We should also specify the content type */
}
else {
fields = split_line (line, 8);
fdata->size = g_ascii_strtoull (fields[4], NULL, 10);
}
fdata->modified = mktime_from_string (fields[5+ofs], fields[6+ofs], fields[7+ofs]);
g_strfreev (fields);
name_field = get_last_field (line, 9+ofs);
#endif /* !__sun */
fields = g_strsplit (name_field, " -> ", 2);
if (fields[1] == NULL) {
g_strfreev (fields);
fields = g_strsplit (name_field, " link to ", 2);
}
fdata->dir = line[0] == 'd';
name = g_strcompress (fields[0]);
if (*(fields[0]) == '/') {
fdata->full_path = g_strdup (name);
fdata->original_path = fdata->full_path;
}
else {
fdata->full_path = g_strconcat ("/", name, NULL);
fdata->original_path = fdata->full_path + 1;
}
if (fdata->dir && (name[strlen (name) - 1] != '/')) {
char *old_full_path = fdata->full_path;
fdata->full_path = g_strconcat (old_full_path, "/", NULL);
g_free (old_full_path);
fdata->original_path = g_strdup (name);
fdata->free_original_path = TRUE;
}
g_free (name);
if (fields[1] != NULL)
fdata->link = g_strcompress (fields[1]);
g_strfreev (fields);
if (fdata->dir)
fdata->name = dir_name_from_path (fdata->full_path);
else
fdata->name = g_strdup (file_name_from_path (fdata->full_path));
fdata->path = remove_level_from_path (fdata->full_path);
if (*fdata->name == 0)
file_data_free (fdata);
else
fr_command_add_file (comm, fdata);
}
static void
process_line (char *line,
gpointer data)
{
FileData *fdata;
FrCommand *comm = FR_COMMAND (data);
char **fields;
int date_idx;
char *field_month, *field_day, *field_time, *field_year;
char *field_size, *field_name;
g_return_if_fail (line != NULL);
fdata = file_data_new ();
date_idx = file_list__get_index_from_pattern (line, "%c%c%c %a%n %n%n:%n%n %n%n%n%n");
field_size = file_list__get_prev_field (line, date_idx, 1);
fdata->size = g_ascii_strtoull (field_size, NULL, 10);
g_free (field_size);
field_month = file_list__get_next_field (line, date_idx, 1);
field_day = file_list__get_next_field (line, date_idx, 2);
field_time = file_list__get_next_field (line, date_idx, 3);
field_year = file_list__get_next_field (line, date_idx, 4);
fdata->modified = mktime_from_string (field_time, field_day, field_month, field_year);
g_free (field_day);
g_free (field_month);
g_free (field_year);
g_free (field_time);
/* Full path */
field_name = ar_get_last_field (line, date_idx, 5);
fields = g_strsplit (field_name, " -> ", 2);
if (fields[0] == NULL) {
g_strfreev (fields);
g_free (field_name);
file_data_free (fdata);
return;
}
if (fields[1] == NULL) {
g_strfreev (fields);
fields = g_strsplit (field_name, " link to ", 2);
}
if (*(fields[0]) == '/') {
fdata->full_path = g_strdup (fields[0]);
fdata->original_path = fdata->full_path;
} else {
fdata->full_path = g_strconcat ("/", fields[0], NULL);
fdata->original_path = fdata->full_path + 1;
}
if (fields[1] != NULL)
fdata->link = g_strdup (fields[1]);
g_strfreev (fields);
g_free (field_name);
fdata->name = g_strdup (file_name_from_path (fdata->full_path));
fdata->path = remove_level_from_path (fdata->full_path);
if (*fdata->name == 0)
file_data_free (fdata);
else
fr_command_add_file (comm, fdata);
}
static void
list__process_line (char *line,
gpointer data)
{
FileData *fdata;
FrCommand *comm = FR_COMMAND (data);
char **fields;
const char *name_field;
gint line_l;
g_return_if_fail (line != NULL);
/* check whether unzip gave the empty archive warning. */
if (FR_COMMAND_ZIP (comm)->is_empty)
return;
line_l = strlen (line);
if (line_l == 0)
return;
if (strcmp (line, EMPTY_ARCHIVE_WARNING) == 0) {
FR_COMMAND_ZIP (comm)->is_empty = TRUE;
return;
}
/* ignore lines that do not describe a file or a
* directory. */
if ((line[0] != '?') && (line[0] != 'd') && (line[0] != '-'))
return;
/**/
fdata = file_data_new ();
fields = split_line (line, 7);
fdata->size = g_ascii_strtoull (fields[3], NULL, 10);
fdata->modified = mktime_from_string (fields[6]);
fdata->encrypted = (*fields[4] == 'B') || (*fields[4] == 'T');
g_strfreev (fields);
/* Full path */
name_field = get_last_field (line, 8);
if (*name_field == '/') {
fdata->full_path = g_strdup (name_field);
fdata->original_path = fdata->full_path;
} else {
fdata->full_path = g_strconcat ("/", name_field, NULL);
fdata->original_path = fdata->full_path + 1;
}
fdata->link = NULL;
fdata->dir = line[0] == 'd';
if (fdata->dir)
fdata->name = dir_name_from_path (fdata->full_path);
else
fdata->name = g_strdup (file_name_from_path (fdata->full_path));
fdata->path = remove_level_from_path (fdata->full_path);
if (*fdata->name == 0)
file_data_free (fdata);
else
fr_command_add_file (comm, fdata);
}
static void
process_data_line (char *line,
gpointer data)
{
FileData *fdata;
FrCommand *comm = FR_COMMAND (data);
char **fields;
char **tmfields;
struct tm tm = {0, };
const char *name;
g_return_if_fail (line != NULL);
if (line[0] == ' ') {
/* This is the output of dpkg-deb -I */
process_metadata_line (line, comm);
return;
}
fdata = file_data_new ();
fields = split_line (line, 5);
fdata->size = g_ascii_strtoull (fields[2], NULL, 10);
tmfields = g_strsplit(fields[3], "-", 3);
if (tmfields[2]) {
tm.tm_year = atoi (tmfields[0]) - 1900;
tm.tm_mon = atoi (tmfields[1]);
tm.tm_mday = atoi (tmfields[2]);
}
g_strfreev (tmfields);
tmfields = g_strsplit (fields[4], ":", 2);
if (tmfields[1]) {
tm.tm_hour = atoi (tmfields[0]);
tm.tm_min = atoi (tmfields[1]);
}
g_strfreev (tmfields);
fdata->modified = mktime (&tm);
g_strfreev (fields);
name = get_last_field (line, 6);
fields = g_strsplit (name, " -> ", 2);
fdata->dir = line[0] == 'd';
name = fields[0];
if (g_str_has_prefix (name, "./")) { /* Should generally be the case */
fdata->full_path = g_strdup (name + 1);
fdata->original_path = fdata->full_path + 1;
} else if (name[0] == '/') {
fdata->full_path = g_strdup (name);
fdata->original_path = fdata->full_path;
} else {
fdata->full_path = g_strconcat ("/", name, NULL);
fdata->original_path = fdata->full_path + 1;
}
if (fdata->dir && (name[strlen (name) - 1] != '/')) {
char *old_full_path = fdata->full_path;
fdata->full_path = g_strconcat (old_full_path, "/", NULL);
g_free (old_full_path);
fdata->original_path = g_strdup (name);
fdata->free_original_path = TRUE;
}
if (fields[1] != NULL)
fdata->link = g_strdup (fields[1]);
g_strfreev (fields);
if (fdata->dir)
fdata->name = dir_name_from_path (fdata->full_path);
else
fdata->name = g_strdup (file_name_from_path (fdata->full_path));
fdata->path = remove_level_from_path (fdata->full_path);
if (*fdata->name == 0)
file_data_free (fdata);
else
fr_command_add_file (comm, fdata);
}
static int
file_sel_response_cb (GtkWidget *widget,
int response,
DialogData *data)
{
GtkFileChooser *file_sel = GTK_FILE_CHOOSER (widget);
FrWindow *window = data->window;
char *selected_folder;
gboolean update, UNUSED_VARIABLE recursive, follow_links;
const char *include_files;
const char *exclude_files;
const char *exclude_folders;
char *dest_dir;
char *local_filename;
dlg_add_folder_save_last_options (data);
if ((response == GTK_RESPONSE_CANCEL) || (response == GTK_RESPONSE_DELETE_EVENT)) {
gtk_widget_destroy (data->dialog);
return TRUE;
}
if (response == GTK_RESPONSE_HELP) {
show_help_dialog (GTK_WINDOW (data->dialog), "engrampa-add-options");
return TRUE;
}
selected_folder = gtk_file_chooser_get_uri (file_sel);
/* check folder permissions. */
if (! check_permissions (selected_folder, R_OK)) {
GtkWidget *d;
char *utf8_path;
utf8_path = g_filename_display_name (selected_folder);
d = _gtk_error_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_MODAL,
NULL,
_("Could not add the files to the archive"),
_("You don't have the right permissions to read files from folder \"%s\""),
utf8_path);
gtk_dialog_run (GTK_DIALOG (d));
gtk_widget_destroy (GTK_WIDGET (d));
g_free (utf8_path);
g_free (selected_folder);
return FALSE;
}
update = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->add_if_newer_checkbutton));
recursive = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->include_subfold_checkbutton));
follow_links = ! gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->exclude_symlinks));
include_files = gtk_entry_get_text (GTK_ENTRY (data->include_files_entry));
if (utf8_only_spaces (include_files))
include_files = "*";
exclude_files = gtk_entry_get_text (GTK_ENTRY (data->exclude_files_entry));
if (utf8_only_spaces (exclude_files))
exclude_files = NULL;
exclude_folders = gtk_entry_get_text (GTK_ENTRY (data->exclude_folders_entry));
if (utf8_only_spaces (exclude_folders))
exclude_folders = NULL;
local_filename = g_filename_from_uri (selected_folder, NULL, NULL);
dest_dir = build_uri (fr_window_get_current_location (window),
file_name_from_path (local_filename),
NULL);
fr_window_archive_add_with_wildcard (window,
include_files,
exclude_files,
exclude_folders,
selected_folder,
dest_dir,
update,
follow_links);
g_free (local_filename);
g_free (dest_dir);
g_free (selected_folder);
gtk_widget_destroy (data->dialog);
return TRUE;
}
