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