initial

1 files changed, 1395 insertions, 0 deletions

diff --git a/src/file-utils.c b/src/file-utils.c
new file mode 100644
index 0000000..9c3bff5
--- /dev/null
+++ b/src/file-utils.c
@@ -0,0 +1,1395 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  File-Roller
+ *
+ *  Copyright (C) 2001, 2003 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 <pwd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <time.h>
+#include <unistd.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <dirent.h>
+
+#include <glib.h>
+#include <gio/gio.h>
+#include <mateconf/mateconf-client.h>
+#include "file-utils.h"
+#include "glib-utils.h"
+#include "main.h"
+
+
+#ifndef HAVE_MKDTEMP
+#include "mkdtemp.h"
+#endif
+
+#define BUF_SIZE 4096
+#define FILE_PREFIX    "file://"
+#define FILE_PREFIX_L  7
+#define SPECIAL_DIR(x) ((strcmp ((x), "..") == 0) || (strcmp ((x), ".") == 0))
+
+
+gboolean
+uri_exists (const char *uri)
+{
+	GFile     *file;
+	gboolean   exists;
+
+	if (uri == NULL)
+		return FALSE;
+
+	file = g_file_new_for_uri (uri);
+	exists = g_file_query_exists (file, NULL);
+	g_object_unref (file);
+
+	return exists;
+}
+
+
+static gboolean
+uri_is_filetype (const char *uri,
+		 GFileType   file_type)
+{
+	gboolean   result = FALSE;
+	GFile     *file;
+	GFileInfo *info;
+	GError    *error = NULL;
+
+	file = g_file_new_for_uri (uri);
+
+	if (! g_file_query_exists (file, NULL)) {
+		g_object_unref (file);
+		return FALSE;
+	}
+
+	info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_TYPE, 0, NULL, &error);
+	if (error == NULL) {
+		result = (g_file_info_get_file_type (info) == file_type);
+	}
+	else {
+		g_warning ("Failed to get file type for uri %s: %s", uri, error->message);
+		g_error_free (error);
+	}
+
+	g_object_unref (info);
+	g_object_unref (file);
+
+	return result;
+}
+
+
+gboolean
+uri_is_file (const char *uri)
+{
+	return uri_is_filetype (uri, G_FILE_TYPE_REGULAR);
+}
+
+
+gboolean
+uri_is_dir (const char *uri)
+{
+	return uri_is_filetype (uri, G_FILE_TYPE_DIRECTORY);
+}
+
+
+gboolean
+path_is_dir (const char *path)
+{
+	char     *uri;
+	gboolean  result;
+
+	uri = g_filename_to_uri (path, NULL, NULL);
+	result = uri_is_dir (uri);
+	g_free (uri);
+
+	return result;
+}
+
+gboolean
+uri_is_local (const char  *uri)
+{
+	return strncmp (uri, "file://", 7) == 0;
+}
+
+
+gboolean
+dir_is_empty (const char *uri)
+{
+	GFile           *file;
+	GFileEnumerator *file_enum;
+	GFileInfo       *info;
+	GError          *error = NULL;
+	int              n = 0;
+
+	file = g_file_new_for_uri (uri);
+
+	if (! g_file_query_exists (file, NULL)) {
+		g_object_unref (file);
+		return TRUE;
+	}
+
+	file_enum = g_file_enumerate_children (file, G_FILE_ATTRIBUTE_STANDARD_NAME, 0, NULL, &error);
+	if (error != NULL) {
+		g_warning ("Failed to enumerate children of %s: %s", uri, error->message);
+		g_error_free (error);
+		g_object_unref (file_enum);
+		g_object_unref (file);
+		return TRUE;
+	}
+
+	while ((n == 0) && ((info = g_file_enumerator_next_file (file_enum, NULL, &error)) != NULL)) {
+		if (error != NULL) {
+			g_warning ("Encountered error while enumerating children of %s (ignoring): %s", uri, error->message);
+			g_error_free (error);
+		}
+		else if (! SPECIAL_DIR (g_file_info_get_name (info)))
+			n++;
+		g_object_unref (info);
+	}
+
+	g_object_unref (file);
+	g_object_unref (file_enum);
+
+	return (n == 0);
+}
+
+
+gboolean
+dir_contains_one_object (const char *uri)
+{
+	GFile           *file;
+	GFileEnumerator *file_enum;
+	GFileInfo       *info;
+	GError          *err = NULL;
+	int              n = 0;
+
+	file = g_file_new_for_uri (uri);
+
+	if (! g_file_query_exists (file, NULL)) {
+		g_object_unref (file);
+		return FALSE;
+	}
+
+	file_enum = g_file_enumerate_children (file, G_FILE_ATTRIBUTE_STANDARD_NAME, 0, NULL, &err);
+	if (err != NULL) {
+		g_warning ("Failed to enumerate children of %s: %s", uri, err->message);
+		g_error_free (err);
+		g_object_unref (file_enum);
+		g_object_unref (file);
+		return FALSE;
+	}
+
+	while ((info = g_file_enumerator_next_file (file_enum, NULL, &err)) != NULL) {
+		const char *name;
+
+		if (err != NULL) {
+			g_warning ("Encountered error while enumerating children of %s, ignoring: %s", uri, err->message);
+			g_error_free (err);
+			g_object_unref (info);
+			continue;
+		}
+
+		name = g_file_info_get_name (info);
+		if (strcmp (name, ".") == 0 || strcmp (name, "..") == 0) {
+			g_object_unref (info);
+ 			continue;
+		}
+
+		g_object_unref (info);
+
+		if (++n > 1)
+			break;
+	}
+
+	g_object_unref (file);
+	g_object_unref (file_enum);
+
+	return (n == 1);
+}
+
+
+char *
+get_dir_content_if_unique (const char  *uri)
+{
+	GFile           *file;
+	GFileEnumerator *file_enum;
+	GFileInfo       *info;
+	GError          *err = NULL;
+	char            *content_uri = NULL;
+
+	file = g_file_new_for_uri (uri);
+
+	if (! g_file_query_exists (file, NULL)) {
+		g_object_unref (file);
+		return NULL;
+	}
+
+	file_enum = g_file_enumerate_children (file, G_FILE_ATTRIBUTE_STANDARD_NAME, 0, NULL, &err);
+	if (err != NULL) {
+		g_warning ("Failed to enumerate children of %s: %s", uri, err->message);
+		g_error_free (err);
+		return NULL;
+	}
+
+	while ((info = g_file_enumerator_next_file (file_enum, NULL, &err)) != NULL) {
+		const char *name;
+
+		if (err != NULL) {
+			g_warning ("Failed to get info while enumerating children: %s", err->message);
+			g_clear_error (&err);
+			g_object_unref (info);
+			continue;
+		}
+
+		name = g_file_info_get_name (info);
+		if ((strcmp (name, ".") == 0) || (strcmp (name, "..") == 0)) {
+			g_object_unref (info);
+			continue;
+		}
+
+		if (content_uri != NULL) {
+			g_free (content_uri);
+			g_object_unref (info);
+			content_uri = NULL;
+			break;
+		}
+
+		content_uri = build_uri (uri, name, NULL);
+		g_object_unref (info);
+	}
+
+	if (err != NULL) {
+		g_warning ("Failed to get info after enumerating children: %s", err->message);
+		g_clear_error (&err);
+	}
+
+	g_object_unref (file_enum);
+	g_object_unref (file);
+
+	return content_uri;
+}
+
+
+/* Check whether the dirname is contained in filename */
+gboolean
+path_in_path (const char *dirname,
+	      const char *filename)
+{
+	int dirname_l, filename_l, separator_position;
+
+	if ((dirname == NULL) || (filename == NULL))
+		return FALSE;
+
+	dirname_l = strlen (dirname);
+	filename_l = strlen (filename);
+
+	if ((dirname_l == filename_l + 1)
+	     && (dirname[dirname_l - 1] == '/'))
+		return FALSE;
+
+	if ((filename_l == dirname_l + 1)
+	     && (filename[filename_l - 1] == '/'))
+		return FALSE;
+
+	if (dirname[dirname_l - 1] == '/')
+		separator_position = dirname_l - 1;
+	else
+		separator_position = dirname_l;
+
+	return ((filename_l > dirname_l)
+		&& (strncmp (dirname, filename, dirname_l) == 0)
+		&& (filename[separator_position] == '/'));
+}
+
+
+goffset
+get_file_size (const char *uri)
+{
+	goffset    size = 0;
+	GFile     *file;
+	GFileInfo *info;
+	GError    *err = NULL;
+
+	if ((uri == NULL) || (*uri == '\0'))
+		return 0;
+
+	file = g_file_new_for_uri (uri);
+	info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_SIZE, 0, NULL, &err);
+	if (err == NULL) {
+		size = g_file_info_get_size (info);
+	}
+	else {
+		g_warning ("Failed to get file size for %s: %s", uri, err->message);
+		g_error_free (err);
+	}
+
+	g_object_unref (info);
+	g_object_unref (file);
+
+	return size;
+}
+
+
+goffset
+get_file_size_for_path (const char *path)
+{
+	char    *uri;
+	goffset  result;
+
+	uri = g_filename_to_uri (path, NULL, NULL);
+	result = get_file_size (uri);
+	g_free (uri);
+
+	return result;
+}
+
+
+static time_t
+get_file_time_type (const char *uri,
+		    const char *type)
+{
+	time_t     result = 0;
+	GFile     *file;
+	GFileInfo *info;
+	GError    *err = NULL;
+
+	if ((uri == NULL) || (*uri == '\0'))
+ 		return 0;
+
+	file = g_file_new_for_uri (uri);
+	info = g_file_query_info (file, type, 0, NULL, &err);
+	if (err == NULL) {
+		result = (time_t) g_file_info_get_attribute_uint64 (info, type);
+	}
+	else {
+		g_warning ("Failed to get %s: %s", type, err->message);
+		g_error_free (err);
+		result = 0;
+	}
+
+	g_object_unref (info);
+	g_object_unref (file);
+
+	return result;
+}
+
+
+time_t
+get_file_mtime (const char *uri)
+{
+	return get_file_time_type (uri, G_FILE_ATTRIBUTE_TIME_MODIFIED);
+}
+
+
+time_t
+get_file_mtime_for_path (const char *path)
+{
+	char   *uri;
+	time_t  result;
+
+	uri = g_filename_to_uri (path, NULL, NULL);
+	result = get_file_mtime (uri);
+	g_free (uri);
+
+	return result;
+}
+
+
+time_t
+get_file_ctime (const char *uri)
+{
+	return get_file_time_type (uri, G_FILE_ATTRIBUTE_TIME_CREATED);
+}
+
+
+gboolean
+file_is_hidden (const gchar *name)
+{
+	if (name[0] != '.') return FALSE;
+	if (name[1] == '\0') return FALSE;
+	if ((name[1] == '.') && (name[2] == '\0')) return FALSE;
+
+	return TRUE;
+}
+
+
+/* like g_path_get_basename but does not warn about NULL and does not
+ * alloc a new string. */
+const gchar* file_name_from_path(const gchar *file_name)
+{
+	register char   *base;
+	register gssize  last_char;
+
+	if (file_name == NULL)
+		return NULL;
+
+	if (file_name[0] == '\0')
+		return "";
+
+	last_char = strlen (file_name) - 1;
+
+	if (file_name [last_char] == G_DIR_SEPARATOR)
+		return "";
+
+	base = g_utf8_strrchr (file_name, -1, G_DIR_SEPARATOR);
+	if (! base)
+		return file_name;
+
+	return base + 1;
+}
+
+
+char *
+dir_name_from_path (const gchar *path)
+{
+	register gssize base;
+	register gssize last_char;
+
+	if (path == NULL)
+		return NULL;
+
+	if (path[0] == '\0')
+		return g_strdup ("");
+
+	last_char = strlen (path) - 1;
+	if (path[last_char] == G_DIR_SEPARATOR)
+		last_char--;
+
+	base = last_char;
+	while ((base >= 0) && (path[base] != G_DIR_SEPARATOR))
+		base--;
+
+	return g_strndup (path + base + 1, last_char - base);
+}
+
+
+gchar *
+remove_level_from_path (const gchar *path)
+{
+	int         p;
+	const char *ptr = path;
+	char       *new_path;
+
+	if (path == NULL)
+		return NULL;
+
+	p = strlen (path) - 1;
+	if (p < 0)
+		return NULL;
+
+	while ((p > 0) && (ptr[p] != '/'))
+		p--;
+	if ((p == 0) && (ptr[p] == '/'))
+		p++;
+	new_path = g_strndup (path, (guint)p);
+
+	return new_path;
+}
+
+
+char *
+remove_ending_separator (const char *path)
+{
+	gint len, copy_len;
+
+	if (path == NULL)
+		return NULL;
+
+	copy_len = len = strlen (path);
+	if ((len > 1) && (path[len - 1] == '/'))
+		copy_len--;
+
+	return g_strndup (path, copy_len);
+}
+
+
+char *
+build_uri (const char *base, ...)
+{
+	va_list     args;
+	const char *child;
+	GString    *uri;
+
+	uri = g_string_new (base);
+
+	va_start (args, base);
+        while ((child = va_arg (args, const char *)) != NULL) {
+        	if (! g_str_has_suffix (uri->str, "/") && ! g_str_has_prefix (child, "/"))
+        		g_string_append (uri, "/");
+        	g_string_append (uri, child);
+        }
+	va_end (args);
+
+	return g_string_free (uri, FALSE);
+}
+
+
+gchar *
+remove_extension_from_path (const gchar *path)
+{
+	int         len;
+	int         p;
+	const char *ptr = path;
+	char       *new_path;
+
+	if (! path)
+		return NULL;
+
+	len = strlen (path);
+	if (len == 1)
+		return g_strdup (path);
+
+	p = len - 1;
+	while ((p > 0) && (ptr[p] != '.'))
+		p--;
+	if (p == 0)
+		p = len;
+	new_path = g_strndup (path, (guint) p);
+
+	return new_path;
+}
+
+
+gboolean
+make_directory_tree (GFile    *dir,
+		     mode_t    mode,
+		     GError  **error)
+{
+	gboolean  success = TRUE;
+	GFile    *parent;
+
+	if ((dir == NULL) || g_file_query_exists (dir, NULL))
+		return TRUE;
+
+	parent = g_file_get_parent (dir);
+	if (parent != NULL) {
+		success = make_directory_tree (parent, mode, error);
+		g_object_unref (parent);
+		if (! success)
+			return FALSE;
+	}
+
+	success = g_file_make_directory (dir, NULL, error);
+	if ((error != NULL) && (*error != NULL) && g_error_matches (*error, G_IO_ERROR, G_IO_ERROR_EXISTS)) {
+		g_clear_error (error);
+		success = TRUE;
+	}
+
+	if (success)
+		g_file_set_attribute_uint32 (dir,
+					     G_FILE_ATTRIBUTE_UNIX_MODE,
+					     mode,
+					     0,
+					     NULL,
+					     NULL);
+
+	return success;
+}
+
+
+gboolean
+ensure_dir_exists (const char  *uri,
+		   mode_t       mode,
+		   GError     **error)
+{
+	GFile  *dir;
+	GError *priv_error = NULL;
+
+	if (uri == NULL)
+		return FALSE;
+
+	if (error == NULL)
+		error = &priv_error;
+
+	dir = g_file_new_for_uri (uri);
+	if (! make_directory_tree (dir, mode, error)) {
+		g_warning ("could create directory %s: %s", uri, (*error)->message);
+		if (priv_error != NULL)
+			g_clear_error (&priv_error);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+
+gboolean
+make_directory_tree_from_path (const char  *path,
+		   	       mode_t       mode,
+		   	       GError     **error)
+{
+	char     *uri;
+	gboolean  result;
+
+	uri = g_filename_to_uri (path, NULL, NULL);
+	result = ensure_dir_exists (uri, mode, error);
+	g_free (uri);
+
+	return result;
+}
+
+
+const char *
+get_file_extension (const char *filename)
+{
+	const char *ptr = filename;
+	int         len;
+	int         p;
+	const char *ext;
+
+	if (filename == NULL)
+		return NULL;
+
+	len = strlen (filename);
+	if (len <= 1)
+		return NULL;
+
+	p = len - 1;
+	while ((p >= 0) && (ptr[p] != '.'))
+		p--;
+	if (p < 0)
+		return NULL;
+
+	ext = filename + p;
+	if (ext - 4 > filename) {
+		const char *test = ext - 4;
+		if (strncmp (test, ".tar", 4) == 0)
+			ext = ext - 4;
+	}
+	return ext;
+}
+
+
+gboolean
+file_extension_is (const char *filename,
+		   const char *ext)
+{
+	int filename_l, ext_l;
+
+	filename_l = strlen (filename);
+	ext_l = strlen (ext);
+
+	if (filename_l < ext_l)
+		return FALSE;
+	return strcasecmp (filename + filename_l - ext_l, ext) == 0;
+}
+
+
+gboolean
+is_mime_type (const char *mime_type,
+	      const char *pattern)
+{
+	return (strcasecmp (mime_type, pattern) == 0);
+}
+
+
+const char*
+get_file_mime_type (const char *uri,
+                    gboolean    fast_file_type)
+{
+	GFile      *file;
+	GFileInfo  *info;
+	GError     *err = NULL;
+ 	const char *result = NULL;
+
+ 	file = g_file_new_for_uri (uri);
+	info = g_file_query_info (file,
+				  fast_file_type ?
+				  G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE :
+				  G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
+				  0, NULL, &err);
+	if (info == NULL) {
+		g_warning ("could not get content type for %s: %s", uri, err->message);
+		g_clear_error (&err);
+	}
+	else {
+		result = get_static_string (g_file_info_get_content_type (info));
+		g_object_unref (info);
+	}
+
+	g_object_unref (file);
+
+	return result;
+}
+
+
+const char*
+get_file_mime_type_for_path (const char  *filename,
+                    	     gboolean     fast_file_type)
+{
+	char       *uri;
+	const char *mime_type;
+
+	uri = g_filename_to_uri (filename, NULL, NULL);
+	mime_type = get_file_mime_type (uri, fast_file_type);
+	g_free (uri);
+
+	return mime_type;
+}
+
+
+void
+path_list_free (GList *path_list)
+{
+	if (path_list == NULL)
+		return;
+	g_list_foreach (path_list, (GFunc) g_free, NULL);
+	g_list_free (path_list);
+}
+
+
+GList *
+path_list_dup (GList *path_list)
+{
+	GList *new_list = NULL;
+	GList *scan;
+
+	for (scan = path_list; scan; scan = scan->next)
+		new_list = g_list_prepend (new_list, g_strdup (scan->data));
+
+	return g_list_reverse (new_list);
+}
+
+
+guint64
+get_dest_free_space (const char *path)
+{
+	guint64    freespace = 0;
+	GFile     *file;
+	GFileInfo *info;
+	GError    *err = NULL;
+
+	file = g_file_new_for_path (path);
+	info = g_file_query_filesystem_info (file, G_FILE_ATTRIBUTE_FILESYSTEM_FREE, NULL, &err);
+	if (info != NULL) {
+		freespace = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE);
+		g_object_unref (info);
+	}
+	else {
+		g_warning ("Could not get filesystem free space on volume that contains %s: %s", path, err->message);
+		g_error_free (err);
+	}
+	g_object_unref (file);
+
+	return freespace;
+}
+
+
+static gboolean
+delete_directory_recursive (GFile   *dir,
+			    GError **error)
+{
+	char            *uri;
+	GFileEnumerator *file_enum;
+	GFileInfo       *info;
+	gboolean         error_occurred = FALSE;
+
+	if (error != NULL)
+		*error = NULL;
+
+	file_enum = g_file_enumerate_children (dir,
+					       G_FILE_ATTRIBUTE_STANDARD_NAME ","
+					       G_FILE_ATTRIBUTE_STANDARD_TYPE,
+					       0, NULL, error);
+
+	uri = g_file_get_uri (dir);
+	while (! error_occurred && (info = g_file_enumerator_next_file (file_enum, NULL, error)) != NULL) {
+		char  *child_uri;
+		GFile *child;
+
+		child_uri = build_uri (uri, g_file_info_get_name (info), NULL);
+		child = g_file_new_for_uri (child_uri);
+
+		switch (g_file_info_get_file_type (info)) {
+		case G_FILE_TYPE_DIRECTORY:
+			if (! delete_directory_recursive (child, error))
+				error_occurred = TRUE;
+			break;
+		default:
+			if (! g_file_delete (child, NULL, error))
+				error_occurred = TRUE;
+			break;
+		}
+
+		g_object_unref (child);
+		g_free (child_uri);
+		g_object_unref (info);
+	}
+	g_free (uri);
+
+	if (! error_occurred && ! g_file_delete (dir, NULL, error))
+ 		error_occurred = TRUE;
+
+	g_object_unref (file_enum);
+
+	return ! error_occurred;
+}
+
+
+gboolean
+remove_directory (const char *uri)
+{
+	GFile     *dir;
+	gboolean   result;
+	GError    *error = NULL;
+
+	dir = g_file_new_for_uri (uri);
+	result = delete_directory_recursive (dir, &error);
+	if (! result) {
+		g_warning ("Cannot delete %s: %s", uri, error->message);
+		g_clear_error (&error);
+	}
+	g_object_unref (dir);
+
+	return result;
+}
+
+
+gboolean
+remove_local_directory (const char *path)
+{
+	char     *uri;
+	gboolean  result;
+
+	if (path == NULL)
+		return TRUE;
+
+	uri = g_filename_to_uri (path, NULL, NULL);
+	result = remove_directory (uri);
+	g_free (uri);
+
+	return result;
+}
+
+
+static const char *try_folder[] = { "cache", "~", "tmp", NULL };
+
+
+static char *
+ith_temp_folder_to_try (int n)
+{
+	const char *folder;
+
+	folder = try_folder[n];
+	if (strcmp (folder, "cache") == 0)
+		folder = g_get_user_cache_dir ();
+	else if (strcmp (folder, "~") == 0)
+		folder = g_get_home_dir ();
+	else if (strcmp (folder, "tmp") == 0)
+		folder = g_get_tmp_dir ();
+
+	return g_strdup (folder);
+}
+
+
+char *
+get_temp_work_dir (const char *parent_folder)
+{
+	guint64  max_size = 0;
+	char    *best_folder = NULL;
+	int      i;
+	char    *template;
+	char    *result = NULL;
+
+	if (parent_folder == NULL) {
+		/* find the folder with more free space. */
+
+		for (i = 0; try_folder[i] != NULL; i++) {
+			char    *folder;
+			guint64  size;
+
+			folder = ith_temp_folder_to_try (i);
+			size = get_dest_free_space (folder);
+			if (max_size < size) {
+				max_size = size;
+				g_free (best_folder);
+				best_folder = folder;
+			}
+			else
+				g_free (folder);
+		}
+	}
+	else
+		best_folder = g_strdup (parent_folder);
+
+	if (best_folder == NULL)
+		return NULL;
+
+	template = g_strconcat (best_folder, "/.fr-XXXXXX", NULL);
+	result = mkdtemp (template);
+
+	if ((result == NULL) || (*result == '\0')) {
+		g_free (template);
+		result = NULL;
+	}
+
+	return result;
+}
+
+
+gboolean
+is_temp_work_dir (const char *dir)
+{
+	int i;
+	const char *folder;
+
+	if (strncmp (dir, "file://", 7) == 0)
+		dir = dir + 7;
+	else if (dir[0] != '/')
+		return FALSE;
+
+	for (i = 0; try_folder[i] != NULL; i++) {
+
+		folder = ith_temp_folder_to_try (i);
+		if (strncmp (dir, folder, strlen (folder)) == 0)
+			if (strncmp (dir + strlen (folder), "/.fr-", 5) == 0) {
+				g_free (folder);
+				return TRUE;
+			}
+	}
+
+	g_free (folder);
+	return FALSE;
+}
+
+
+gboolean
+is_temp_dir (const char *dir)
+{
+	if (strncmp (dir, "file://", 7) == 0)
+		dir = dir + 7;
+	if (strcmp (g_get_tmp_dir (), dir) == 0)
+		return TRUE;
+	if (path_in_path (g_get_tmp_dir (), dir))
+		return TRUE;
+	else
+		return is_temp_work_dir (dir);
+}
+
+
+/* file list utils */
+
+
+gboolean
+file_list__match_pattern (const char *line,
+			  const char *pattern)
+{
+	const char *l = line, *p = pattern;
+
+	for (; (*p != 0) && (*l != 0); p++, l++) {
+		if (*p != '%') {
+			if (*p != *l)
+				return FALSE;
+		}
+		else {
+			p++;
+			switch (*p) {
+			case 'a':
+				break;
+			case 'n':
+				if (!isdigit (*l))
+					return FALSE;
+				break;
+			case 'c':
+				if (!isalpha (*l))
+					return FALSE;
+				break;
+			default:
+				return FALSE;
+			}
+		}
+	}
+
+	return (*p == 0);
+}
+
+
+int
+file_list__get_index_from_pattern (const char *line,
+				   const char *pattern)
+{
+	int         line_l, pattern_l;
+	const char *l;
+
+	line_l = strlen (line);
+	pattern_l = strlen (pattern);
+
+	if ((pattern_l == 0) || (line_l == 0))
+		return -1;
+
+	for (l = line; *l != 0; l++)
+		if (file_list__match_pattern (l, pattern))
+			return (l - line);
+
+	return -1;
+}
+
+
+char*
+file_list__get_next_field (const char *line,
+			   int         start_from,
+			   int         field_n)
+{
+	const char *f_start, *f_end;
+
+	line = line + start_from;
+
+	f_start = line;
+	while ((*f_start == ' ') && (*f_start != *line))
+		f_start++;
+	f_end = f_start;
+
+	while ((field_n > 0) && (*f_end != 0)) {
+		if (*f_end == ' ') {
+			field_n--;
+			if (field_n != 0) {
+				while ((*f_end == ' ') && (*f_end != *line))
+					f_end++;
+				f_start = f_end;
+			}
+		} else
+			f_end++;
+	}
+
+	return g_strndup (f_start, f_end - f_start);
+}
+
+
+char*
+file_list__get_prev_field (const char *line,
+			   int         start_from,
+			   int         field_n)
+{
+	const char *f_start, *f_end;
+
+	f_start = line + start_from - 1;
+	while ((*f_start == ' ') && (*f_start != *line))
+		f_start--;
+	f_end = f_start;
+
+	while ((field_n > 0) && (*f_start != *line)) {
+		if (*f_start == ' ') {
+			field_n--;
+			if (field_n != 0) {
+				while ((*f_start == ' ') && (*f_start != *line))
+					f_start--;
+				f_end = f_start;
+			}
+		} else
+			f_start--;
+	}
+
+	return g_strndup (f_start + 1, f_end - f_start);
+}
+
+
+gboolean
+check_permissions (const char *uri,
+		   int         mode)
+{
+	GFile    *file;
+	gboolean  result;
+
+	file = g_file_new_for_uri (uri);
+	result = check_file_permissions (file, mode);
+
+	g_object_unref (file);
+
+	return result;
+}
+
+
+gboolean
+check_file_permissions (GFile *file,
+		        int    mode)
+{
+	gboolean   result = TRUE;
+	GFileInfo *info;
+	GError    *err = NULL;
+	gboolean   default_permission_when_unknown = TRUE;
+
+	info = g_file_query_info (file, "access::*", 0, NULL, &err);
+	if (err != NULL) {
+		g_clear_error (&err);
+		result = FALSE;
+	}
+	else {
+		if ((mode & R_OK) == R_OK) {
+			if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_READ))
+				result = (result && g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_READ));
+			else
+				result = (result && default_permission_when_unknown);
+		}
+
+		if ((mode & W_OK) == W_OK) {
+			if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE))
+				result = (result && g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE));
+			else
+				result = (result && default_permission_when_unknown);
+		}
+
+		if ((mode & X_OK) == X_OK) {
+			if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE))
+				result = (result && g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE));
+			else
+				result = (result && default_permission_when_unknown);
+		}
+
+		g_object_unref (info);
+	}
+
+	return result;
+}
+
+
+gboolean
+is_program_in_path (const char *filename)
+{
+	char *str;
+	char *value;
+	int   result = FALSE;
+
+	value = g_hash_table_lookup (ProgramsCache, filename);
+	if (value != NULL) {
+		result = (strcmp (value, "1") == 0);
+		return result;
+	}
+
+	str = g_find_program_in_path (filename);
+	if (str != NULL) {
+		g_free (str);
+		result = TRUE;
+	}
+
+	g_hash_table_insert (ProgramsCache,
+			     g_strdup (filename),
+			     result ? "1" : "0");
+
+	return result;
+}
+
+
+gboolean
+is_program_available (const char *filename,
+		      gboolean    check)
+{
+	return ! check || is_program_in_path (filename);
+}
+
+
+const char *
+get_home_uri (void)
+{
+	static char *home_uri = NULL;
+	if (home_uri == NULL)
+		home_uri = g_filename_to_uri (g_get_home_dir (), NULL, NULL);
+	return home_uri;
+}
+
+
+char *
+get_home_relative_uri (const char *partial_uri)
+{
+	return g_strconcat (get_home_uri (),
+			    "/",
+			    partial_uri,
+			    NULL);
+}
+
+
+GFile *
+get_home_relative_file (const char *partial_uri)
+{
+	GFile *file;
+	char  *uri;
+
+	uri = g_strconcat (get_home_uri (), "/", partial_uri, NULL);
+	file = g_file_new_for_uri (uri);
+	g_free (uri);
+
+	return file;
+}
+
+
+const char *
+remove_host_from_uri (const char *uri)
+{
+        const char *idx, *sep;
+
+        if (uri == NULL)
+                return NULL;
+
+        idx = strstr (uri, "://");
+        if (idx == NULL)
+                return uri;
+        idx += 3;
+        if (*idx == '\0')
+                return "/";
+        sep = strstr (idx, "/");
+        if (sep == NULL)
+                return idx;
+        return sep;
+}
+
+
+char *
+get_uri_host (const char *uri)
+{
+	const char *idx;
+
+	idx = strstr (uri, "://");
+	if (idx == NULL)
+		return NULL;
+	idx = strstr (idx + 3, "/");
+	if (idx == NULL)
+		return NULL;
+	return g_strndup (uri, (idx - uri));
+}
+
+
+char *
+get_uri_root (const char *uri)
+{
+	char *host;
+	char *root;
+
+	host = get_uri_host (uri);
+	if (host == NULL)
+		return NULL;
+	root = g_strconcat (host, "/", NULL);
+	g_free (host);
+
+	return root;
+}
+
+
+int
+uricmp (const char *uri1,
+	const char *uri2)
+{
+	return strcmp_null_tolerant (uri1, uri2);
+}
+
+
+char *
+get_alternative_uri (const char *folder,
+	     const char *name)
+{
+	char *new_uri = NULL;
+	int   n = 1;
+
+	do {
+		g_free (new_uri);
+		if (n == 1)
+			new_uri = g_strconcat (folder, "/", name, NULL);
+		else
+			new_uri = g_strdup_printf ("%s/%s%%20(%d)", folder, name, n);
+		n++;
+	} while (uri_exists (new_uri));
+
+	return new_uri;
+}
+
+
+char *
+get_alternative_uri_for_uri (const char *uri)
+{
+	char *base_uri;
+	char *new_uri;
+
+	base_uri = remove_level_from_path (uri);
+	new_uri = get_alternative_uri (base_uri, file_name_from_path (uri));
+	g_free (base_uri);
+
+	return new_uri;
+}
+
+
+GList *
+gio_file_list_dup (GList *l)
+{
+	GList *r = NULL, *scan;
+	for (scan = l; scan; scan = scan->next)
+		r = g_list_prepend (r, g_file_dup ((GFile*)scan->data));
+	return g_list_reverse (r);
+}
+
+
+void
+gio_file_list_free (GList *l)
+{
+	GList *scan;
+	for (scan = l; scan; scan = scan->next)
+		g_object_unref (scan->data);
+	g_list_free (l);
+}
+
+
+GList *
+gio_file_list_new_from_uri_list (GList *uris)
+{
+	GList *r = NULL, *scan;
+	for (scan = uris; scan; scan = scan->next)
+		r = g_list_prepend (r, g_file_new_for_uri ((char*)scan->data));
+	return g_list_reverse (r);
+}
+
+
+void
+g_key_file_save (GKeyFile *key_file,
+	         GFile    *file)
+{
+	char   *file_data;
+	gsize   size;
+	GError *error = NULL;
+
+	file_data = g_key_file_to_data (key_file, &size, &error);
+	if (error != NULL) {
+		g_warning ("Could not save options: %s\n", error->message);
+		g_clear_error (&error);
+	}
+	else {
+		GFileOutputStream *stream;
+
+		stream = g_file_replace (file, NULL, FALSE, 0, NULL, &error);
+		if (stream == NULL) {
+			g_warning ("Could not save options: %s\n", error->message);
+			g_clear_error (&error);
+		}
+		else if (! g_output_stream_write_all (G_OUTPUT_STREAM (stream), file_data, size, NULL, NULL, &error)) {
+			g_warning ("Could not save options: %s\n", error->message);
+			g_clear_error (&error);
+		}
+		else if (! g_output_stream_close (G_OUTPUT_STREAM (stream), NULL, &error)) {
+			g_warning ("Could not save options: %s\n", error->message);
+			g_clear_error (&error);
+		}
+
+		g_object_unref (stream);
+	}
+
+	g_free (file_data);
+}