/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* * Copyright © 2002 Jorn Baayen * Copyright © 2003, 2004 Marco Pesenti Gritti * Copyright © 2004, 2005, 2006 Christian Persch * Copyright © 2012 Igalia S.L. * * This file is part of Epiphany. * * Epiphany 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 3 of the License, or * (at your option) any later version. * * Epiphany 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 Epiphany. If not, see . */ #include "config.h" #include "ephy-file-helpers.h" #include "ephy-debug.h" #include "ephy-flatpak-utils.h" #include "ephy-prefs.h" #include "ephy-profile-utils.h" #include "ephy-settings.h" #include "ephy-string.h" #include "ephy-web-app-utils.h" #include #include #include #include #include #include #include #include #include #include #include #include #include /** * SECTION:ephy-file-helpers * @short_description: miscellaneous file related utility functions * * File related functions, including functions to launch, browse or move files * atomically. */ #define DELAY_MAX_TICKS 64 #define INITIAL_TICKS 2 typedef enum { EPHY_PROFILE_DIR_UNKNOWN, EPHY_PROFILE_DIR_DEFAULT, EPHY_PROFILE_DIR_WEB_APP, EPHY_PROFILE_DIR_TEST } EphyProfileDirType; static GHashTable *files; static GHashTable *mime_table; static gboolean keep_directory; static char *profile_dir_global; static char *cache_dir; static char *config_dir; static char *tmp_dir; static EphyProfileDirType profile_dir_type; GQuark ephy_file_helpers_error_quark; /** * ephy_file_tmp_dir: * * Returns the name of the temp dir for the running Epiphany instance. * * Returns: the name of the temp dir, this string belongs to Epiphany. **/ const char * ephy_file_tmp_dir (void) { if (tmp_dir == NULL) { char *partial_name; char *full_name; partial_name = g_strconcat ("epiphany-", g_get_user_name (), "-XXXXXX", NULL); full_name = g_build_filename (g_get_tmp_dir (), partial_name, NULL); tmp_dir = mkdtemp (full_name); g_free (partial_name); if (tmp_dir == NULL) { g_free (full_name); } } return tmp_dir; } static char * ephy_file_download_dir (void) { const char *xdg_download_dir; xdg_download_dir = g_get_user_special_dir (G_USER_DIRECTORY_DOWNLOAD); if (xdg_download_dir != NULL) return g_strdup (xdg_download_dir); /* If we don't have XDG user dirs info, return an educated guess. */ return g_build_filename (g_get_home_dir (), _("Downloads"), NULL); } /** * ephy_file_get_downloads_dir: * * Returns a proper downloads destination by checking the * EPHY_PREFS_STATE_DOWNLOAD_DIR GSettings key and following this logic: * * - Under flatpak, always use the XDG downloads directory * * - An absolute path: considered user-set, use this value directly. * * - "Desktop" keyword in GSettings: the directory returned by * ephy_file_desktop_dir(). * * - "Downloads" keyword in GSettings, or any other value: the XDG * downloads directory, or ~/Downloads. * * Returns: a newly-allocated string containing the path to the downloads dir. **/ char * ephy_file_get_downloads_dir (void) { g_autofree char *download_dir = g_settings_get_string (EPHY_SETTINGS_STATE, EPHY_PREFS_STATE_DOWNLOAD_DIR); if (ephy_is_running_inside_flatpak ()) return ephy_file_download_dir (); if (g_strcmp0 (download_dir, "Desktop") == 0) return ephy_file_desktop_dir (); if (g_strcmp0 (download_dir, "Downloads") == 0 || !g_path_is_absolute (download_dir)) return ephy_file_download_dir (); return g_steal_pointer (&download_dir); } /** * ephy_file_desktop_dir: * * Gets the XDG desktop dir path or a default homedir/Desktop alternative. * * Returns: a newly-allocated string containing the desktop dir path. **/ char * ephy_file_desktop_dir (void) { const char *xdg_desktop_dir; xdg_desktop_dir = g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP); if (xdg_desktop_dir != NULL) return g_strdup (xdg_desktop_dir); /* If we don't have XDG user dirs info, return an educated guess. */ return g_build_filename (g_get_home_dir (), _("Desktop"), NULL); } /** * ephy_file_tmp_filename: * @base: the base name of the temp file to create, containing "XXXXXX" * @extension: an optional extension for @base or %NULL * * Gets a usable temp filename with g_mkstemp() using @base as the name * with an optional @extension. @base should contain "XXXXXX" in it. * * Notice that this does not create the file. It only gets a valid * filename. * * Returns: a newly-allocated string containing the name of the temp * file name or %NULL. **/ char * ephy_file_tmp_filename (const char *base, const char *extension) { int fd; char *name = g_strdup (base); fd = g_mkstemp (name); if (fd != -1) { unlink (name); close (fd); } else { g_free (name); return NULL; } if (extension) { char *tmp; tmp = g_strconcat (name, ".", extension, NULL); g_free (name); name = tmp; } return name; } /** * ephy_profile_dir: * * Gets Epiphany's configuration directory, usually .local/share/epiphany * under user's homedir. * * Returns: the full path to Epiphany's configuration directory **/ const char * ephy_profile_dir (void) { return profile_dir_global; } /** * ephy_config_dir: * * Gets Epiphany's configuration directory, usually .config/epiphany * under user's homedir. * * Returns: the full path to Epiphany's configuration directory **/ const char * ephy_config_dir (void) { return config_dir; } /** * ephy_cache_dir: * * Gets Epiphany's cache directory, usually .cache/epiphany * under user's homedir. * * Returns: the full path to Epiphany's cache directory **/ const char * ephy_cache_dir (void) { return cache_dir; } /** * ephy_profile_dir_is_default: * * Returns whether the profile directory in use is the default one, found in * ~/.local/share * * Returns: %TRUE if it is the default profile dir, %FALSE for others **/ gboolean ephy_profile_dir_is_default (void) { return profile_dir_type == EPHY_PROFILE_DIR_DEFAULT || profile_dir_type == EPHY_PROFILE_DIR_TEST; } /** * ephy_profile_dir_is_web_application: * * Returns whether the profile directory in use is a web appplication one. * * Returns: %TRUE if it is a web application profile dir, %FALSE for others */ gboolean ephy_profile_dir_is_web_application (void) { return profile_dir_type == EPHY_PROFILE_DIR_WEB_APP; } /** * ephy_default_profile_dir: * * Get the path to the default profile directory found in ~/.local/share * * Returns: a new allocated string, free with g_free() when done. */ char * ephy_default_profile_dir (void) { return profile_dir_type == EPHY_PROFILE_DIR_TEST ? g_strdup (ephy_profile_dir ()) : g_build_filename (g_get_user_data_dir (), "epiphany", NULL); } /** * ephy_default_cache_dir: * * Get the path to the default cache directory found in ~/.cache * * Returns: a new allocated string, free with g_free() when done. */ char * ephy_default_cache_dir (void) { return profile_dir_type == EPHY_PROFILE_DIR_TEST ? g_build_filename (ephy_profile_dir (), "cache", NULL) : g_build_filename (g_get_user_cache_dir (), "epiphany", NULL); } /** * ephy_default_config_dir: * * Get the path to the default config directory found in ~/.config * * Returns: a new allocated string, free with g_free() when done. */ char * ephy_default_config_dir (void) { return profile_dir_type == EPHY_PROFILE_DIR_TEST ? g_build_filename (ephy_profile_dir (), "config", NULL) : g_build_filename (g_get_user_config_dir (), "epiphany", NULL); } /** * ephy_file_helpers_init: * @profile_dir: directory to use as Epiphany's profile * @flags: the %EphyFileHelpersFlags for this session * @error: an optional #GError * * Initializes Epiphany file helper functions, sets @profile_dir as Epiphany's * profile dir and whether the running session will be private. * * Returns: %FALSE if the profile dir couldn't be created or accessed **/ gboolean ephy_file_helpers_init (const char *profile_dir, EphyFileHelpersFlags flags, GError **error) { gboolean ret = TRUE; gboolean private_profile; gboolean steal_data_from_profile; g_autofree char *app_file = NULL; ephy_file_helpers_error_quark = g_quark_from_static_string ("ephy-file-helpers-error"); files = g_hash_table_new_full (g_str_hash, g_str_equal, (GDestroyNotify)g_free, (GDestroyNotify)g_free); keep_directory = flags & EPHY_FILE_HELPERS_KEEP_DIR; private_profile = (flags & EPHY_FILE_HELPERS_PRIVATE_PROFILE || flags & EPHY_FILE_HELPERS_TESTING_MODE); steal_data_from_profile = flags & EPHY_FILE_HELPERS_STEAL_DATA; if (profile_dir != NULL && !steal_data_from_profile) { if (g_path_is_absolute (profile_dir)) { profile_dir_global = g_strdup (profile_dir); } else { GFile *file = g_file_new_for_path (profile_dir); profile_dir_global = g_file_get_path (file); g_object_unref (file); } app_file = g_build_filename (profile_dir, ".app", NULL); if (g_file_test (app_file, G_FILE_TEST_EXISTS)) { const char *app_name = ephy_web_application_get_program_name_from_profile_directory (profile_dir_global); cache_dir = g_build_filename (g_get_user_cache_dir (), app_name, NULL); config_dir = g_build_filename (g_get_user_config_dir (), app_name, NULL); profile_dir_type = EPHY_PROFILE_DIR_WEB_APP; } else { cache_dir = g_build_filename (profile_dir_global, "cache", NULL); config_dir = g_build_filename (profile_dir_global, "config", NULL); } } else if (private_profile) { if (ephy_file_tmp_dir () == NULL) { g_set_error (error, EPHY_FILE_HELPERS_ERROR_QUARK, 0, _("Could not create a temporary directory in “%s”."), g_get_tmp_dir ()); return FALSE; } profile_dir_global = g_build_filename (ephy_file_tmp_dir (), "epiphany", NULL); cache_dir = g_build_filename (profile_dir_global, "cache", NULL); config_dir = g_build_filename (profile_dir_global, "config", NULL); if (flags & EPHY_FILE_HELPERS_TESTING_MODE) profile_dir_type = EPHY_PROFILE_DIR_TEST; } if (profile_dir_global == NULL) { profile_dir_type = EPHY_PROFILE_DIR_DEFAULT; profile_dir_global = ephy_default_profile_dir (); } if (cache_dir == NULL) cache_dir = ephy_default_cache_dir (); if (config_dir == NULL) config_dir = ephy_default_config_dir (); if (flags & EPHY_FILE_HELPERS_ENSURE_EXISTS) { ret = ephy_ensure_dir_exists (ephy_profile_dir (), error); ephy_ensure_dir_exists (ephy_cache_dir (), NULL); ephy_ensure_dir_exists (ephy_config_dir (), NULL); ephy_ensure_dir_exists (ephy_file_tmp_dir (), NULL); } if (steal_data_from_profile && profile_dir) { guint i; const char *files_to_copy[] = { EPHY_HISTORY_FILE, EPHY_BOOKMARKS_FILE }; for (i = 0; i < G_N_ELEMENTS (files_to_copy); i++) { char *filename; GError *err = NULL; GFile *source, *destination; filename = g_build_filename (profile_dir, files_to_copy[i], NULL); source = g_file_new_for_path (filename); g_free (filename); filename = g_build_filename (profile_dir_global, files_to_copy[i], NULL); destination = g_file_new_for_path (filename); g_free (filename); g_file_copy (source, destination, G_FILE_COPY_OVERWRITE, NULL, NULL, NULL, &err); if (err) { printf ("Error stealing file %s from profile: %s\n", files_to_copy[i], err->message); g_error_free (err); } g_object_unref (source); g_object_unref (destination); } } return ret; } /** * ephy_file_helpers_shutdown: * * Cleans file helpers information, corresponds to ephy_file_helpers_init(). **/ void ephy_file_helpers_shutdown (void) { g_hash_table_destroy (files); if (mime_table != NULL) { LOG ("Destroying mime type hashtable"); g_hash_table_destroy (mime_table); mime_table = NULL; } g_clear_pointer (&profile_dir_global, g_free); g_clear_pointer (&cache_dir, g_free); g_clear_pointer (&config_dir, g_free); if (tmp_dir != NULL) { if (!keep_directory) { /* recursively delete the contents and the * directory */ LOG ("shutdown: delete tmp_dir %s", tmp_dir); ephy_file_delete_dir_recursively (tmp_dir, NULL); } g_free (tmp_dir); tmp_dir = NULL; } } /** * ephy_ensure_dir_exists: * @dir: path to a directory * @error: an optional GError to fill or %NULL * * Checks if @dir exists and is a directory, if it it exists and it's not a * directory %FALSE is returned. If @dir doesn't exist and can't be created * then %FALSE is returned. * * Returns: %TRUE if @dir exists and is a directory **/ gboolean ephy_ensure_dir_exists (const char *dir, GError **error) { if (g_file_test (dir, G_FILE_TEST_EXISTS) && !g_file_test (dir, G_FILE_TEST_IS_DIR)) { g_set_error (error, EPHY_FILE_HELPERS_ERROR_QUARK, 0, _("The file “%s” exists. Please move it out of the way."), dir); return FALSE; } if (!g_file_test (dir, G_FILE_TEST_EXISTS)) { if (g_mkdir_with_parents (dir, 488) == 0) { if (dir == ephy_profile_dir ()) { /* We need to set the .migrated file to the * current profile migration version, * otherwise the next time the browser runs * things might go awry. */ ephy_profile_utils_set_migration_version (EPHY_PROFILE_MIGRATION_VERSION); } } else { g_set_error (error, EPHY_FILE_HELPERS_ERROR_QUARK, 0, _("Failed to create directory “%s”."), dir); return FALSE; } } return TRUE; } static gboolean launch_application (GAppInfo *app, GList *files, guint32 user_time) { g_autoptr (GdkAppLaunchContext) context = NULL; g_autoptr (GError) error = NULL; GdkDisplay *display; GdkScreen *screen; gboolean res; /* This is impossible to implement inside flatpak. Higher layers must * ensure we don't get here. */ g_assert (!ephy_is_running_inside_flatpak ()); display = gdk_display_get_default (); screen = gdk_screen_get_default (); context = gdk_display_get_app_launch_context (display); gdk_app_launch_context_set_screen (context, screen); gdk_app_launch_context_set_timestamp (context, user_time); res = g_app_info_launch (app, files, G_APP_LAUNCH_CONTEXT (context), &error); if (!res) g_warning ("Failed to launch %s: %s", g_app_info_get_display_name (app), error->message); return res; } /** * ephy_file_launch_desktop_file: * @filename: the path to the .desktop file * @tag: used to guard against improper usage * * Launches the application described by the desktop file @filename. * * Returns: %TRUE if the application launch was successful **/ gboolean ephy_file_launch_desktop_file (const char *filename, guint32 user_time, EphyFileHelpersNotFlatpakTag tag) { g_autoptr (GDesktopAppInfo) app = NULL; /* This is impossible to implement inside flatpak. Higher layers must * ensure we don't get here. */ g_assert (tag == EPHY_FILE_HELPERS_I_UNDERSTAND_I_MUST_NOT_USE_THIS_FUNCTION_UNDER_FLATPAK); g_assert (!ephy_is_running_inside_flatpak ()); app = g_desktop_app_info_new (filename); return launch_application (G_APP_INFO (app), NULL, user_time); } static gboolean launch_via_uri_handler (GFile *file) { const char *uri; GdkDisplay *display; GdkAppLaunchContext *context; g_autoptr (GError) error = NULL; display = gdk_display_get_default (); context = gdk_display_get_app_launch_context (display); uri = g_file_get_uri (file); g_app_info_launch_default_for_uri (uri, G_APP_LAUNCH_CONTEXT (context), &error); if (error) { g_warning ("Failed to launch handler for URI %s: %s", uri, error->message); return FALSE; } return TRUE; } /** * ephy_file_launch_handler: * @file: a #GFile to pass as argument * @user_time: user time to prevent focus stealing * * Launches @file with its default handler application, if @mime_type is %NULL * then @file will be queried for its type. * * Returns: %TRUE on success **/ gboolean ephy_file_launch_handler (GFile *file, guint32 user_time) { GAppInfo *app = NULL; gboolean ret = FALSE; g_autoptr (GList) list = NULL; g_autoptr (GError) error = NULL; g_assert (file != NULL); /* Launch via URI handler only under flatpak, because this way loses * focus stealing prevention. There's no other way to open a file * under flatpak, and focus stealing prevention becomes the * responsibility of the portal in this case anyway. */ if (ephy_is_running_inside_flatpak ()) return launch_via_uri_handler (file); app = g_file_query_default_handler (file, NULL, &error); if (!app) { g_autofree char *path = g_file_get_path (file); g_warning ("No available application to open %s: %s", path, error->message); return FALSE; } list = g_list_append (list, file); ret = launch_application (app, list, user_time); return ret; } static gboolean open_in_default_handler (const char *uri, const char *mime_type, guint32 timestamp, GdkScreen *screen, EphyFileHelpersNotFlatpakTag tag) { g_autoptr (GdkAppLaunchContext) context = NULL; g_autoptr (GAppInfo) appinfo = NULL; g_autoptr (GError) error = NULL; GList uris; /* This is impossible to implement inside flatpak. Higher layers must * ensure we don't get here. */ g_assert (tag == EPHY_FILE_HELPERS_I_UNDERSTAND_I_MUST_NOT_USE_THIS_FUNCTION_UNDER_FLATPAK); g_assert (!ephy_is_running_inside_flatpak ()); context = gdk_display_get_app_launch_context (screen ? gdk_screen_get_display (screen) : gdk_display_get_default ()); gdk_app_launch_context_set_screen (context, screen); gdk_app_launch_context_set_timestamp (context, timestamp); appinfo = g_app_info_get_default_for_type (mime_type, TRUE); if (!appinfo) { g_warning ("Failed to get default app for MIME type: %s", mime_type); return FALSE; } uris.data = (gpointer)uri; uris.next = uris.prev = NULL; if (!g_app_info_launch_uris (appinfo, &uris, G_APP_LAUNCH_CONTEXT (context), &error)) { g_warning ("Failed to launch %s: %s", uri, error->message); return FALSE; } return TRUE; } gboolean ephy_file_open_uri_in_default_browser (const char *uri, guint32 user_time, GdkScreen *screen, EphyFileHelpersNotFlatpakTag tag) { return open_in_default_handler (uri, "x-scheme-handler/http", user_time, screen, tag); } /** * ephy_file_browse_to: * @file: a #GFile * @user_time: user_time to prevent focus stealing * @tag: used to guard against improper usage * * Launches the default application for browsing directories to point to * @file. E.g. nautilus will jump to @file within its directory and * select it. * * Returns: %TRUE if the launch succeeded **/ gboolean ephy_file_browse_to (GFile *file, guint32 user_time, EphyFileHelpersNotFlatpakTag tag) { g_autofree char *uri = g_file_get_uri (file); return open_in_default_handler (uri, "inode/directory", user_time, NULL, tag); } /** * ephy_file_delete_dir_recursively: * @directory: directory to remove * @error: location to set any #GError * * Remove @path and its contents. Like calling rm -rf @path. * * Returns: %TRUE if delete succeeded **/ gboolean ephy_file_delete_dir_recursively (const char *directory, GError **error) { GDir *dir; const char *file_name; gboolean failed = FALSE; dir = g_dir_open (directory, 0, error); if (!dir) return FALSE; file_name = g_dir_read_name (dir); while (file_name && !failed) { char *file_path; file_path = g_build_filename (directory, file_name, NULL); if (g_file_test (file_path, G_FILE_TEST_IS_DIR)) { failed = !ephy_file_delete_dir_recursively (file_path, error); } else { int result = g_unlink (file_path); if (result == -1) { int errsv = errno; g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv), "Error removing file %s: %s", file_path, g_strerror (errsv)); failed = TRUE; } } g_free (file_path); file_name = g_dir_read_name (dir); } g_dir_close (dir); if (!failed) { int result = g_rmdir (directory); if (result == -1) { int errsv = errno; g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv), "Error removing directory %s: %s", directory, g_strerror (errsv)); failed = TRUE; } } return !failed; } /** * ephy_sanitize_filename: * @filename: a filename * * Sanitize @filename to make sure it's a valid filename. If the * filename contains directory separators, they will be converted to * underscores, so that they are not interpreted as a path by the * filesystem. * * Note that it modifies string in place. The return value is to allow nesting. * * Returns: the sanitized filename */ char * ephy_sanitize_filename (char *filename) { g_assert (filename != NULL); return g_strdelimit (filename, G_DIR_SEPARATOR_S, '_'); } void ephy_open_default_instance_window (void) { GError *error = NULL; g_spawn_command_line_async ("epiphany --new-window", &error); if (error) { g_warning ("Couldn't open default instance: %s", error->message); g_error_free (error); } } void ephy_open_incognito_window (const char *uri) { char *command; GError *error = NULL; command = g_strdup_printf ("epiphany --incognito-mode --profile %s ", ephy_profile_dir ()); if (uri) { char *str = g_strconcat (command, uri, NULL); g_free (command); command = str; } g_spawn_command_line_async (command, &error); if (error) { g_warning ("Couldn't open link in incognito window: %s", error->message); g_error_free (error); } g_free (command); }