static void process_state_free (gpointer data) { ProcessState *state = (ProcessState *)data; GtkTextBuffer *buffer; g_assert (state != NULL); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (state->source_view)); gtk_text_buffer_delete_mark (buffer, state->begin_mark); gtk_text_buffer_delete_mark (buffer, state->end_mark); gb_beautifier_helper_remove_tmp_file (state->self, state->src_file); g_clear_object (&state->src_file); g_clear_object (&state->config_file); if (state->tmp_config_file != NULL) g_file_delete (state->tmp_config_file, NULL, NULL); if (state->tmp_src_file != NULL) g_file_delete (state->tmp_src_file, NULL, NULL); if (state->tmp_workdir_file != NULL) g_file_delete (state->tmp_workdir_file, NULL, NULL); g_clear_object (&state->tmp_workdir_file); g_clear_object (&state->tmp_config_file); g_clear_object (&state->tmp_src_file); g_free (state->lang_id); g_free (state->text); if (state->command_args != NULL) g_ptr_array_unref (state->command_args); g_slice_free (ProcessState, state); }
/** * gs_plugin_app_remove: */ gboolean gs_plugin_app_remove (GsPlugin *plugin, GsApp *app, GCancellable *cancellable, GError **error) { const gchar *epi_desktop; g_autofree gchar *basename = NULL; g_autofree gchar *app_desktop = NULL; g_autoptr(GFile) file_epi = NULL; g_autoptr(GFile) file_app = NULL; /* only process this app if was created by this plugin */ if (g_strcmp0 (gs_app_get_management_plugin (app), "Epiphany") != 0) return TRUE; epi_desktop = gs_app_get_source_id_default (app); if (epi_desktop == NULL) return TRUE; /* remove the epi 'config' file */ gs_app_set_state (app, AS_APP_STATE_REMOVING); file_epi = g_file_new_for_path (epi_desktop); if (!g_file_delete (file_epi, NULL, error)) return FALSE; /* remove the shared desktop file */ basename = g_file_get_basename (file_epi); app_desktop = g_build_filename (g_get_user_data_dir (), "applications", gs_app_get_id (app), NULL); file_app = g_file_new_for_path (app_desktop); if (!g_file_delete (file_app, NULL, error)) return FALSE; gs_app_set_state (app, AS_APP_STATE_AVAILABLE); return TRUE; }
/*Recursively delete the file.*/ void codeslayer_utils_file_delete (GFile *file, GError **error) { GFileEnumerator *enumerator; enumerator = g_file_enumerate_children (file, "standard::*", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, NULL); if (enumerator != NULL) { GFileInfo *file_info; while ((file_info = g_file_enumerator_next_file (enumerator, NULL, NULL)) != NULL) { GFile *child; const char *file_name = g_file_info_get_name (file_info); child = g_file_get_child (file, file_name); if (g_file_info_get_file_type (file_info) == G_FILE_TYPE_DIRECTORY) codeslayer_utils_file_delete (child, error); g_file_delete (child, NULL, error); g_object_unref(child); g_object_unref (file_info); } g_object_unref (enumerator); } g_file_delete (file, NULL, error); }
/** * pk_offline_auth_cancel: * @error: A #GError or %NULL * * Cancels the offline operation that has been scheduled. If there is no * scheduled offline operation then this method returns with success. * * Return value: %TRUE for success, else %FALSE and @error set * * Since: 0.9.6 **/ gboolean pk_offline_auth_cancel (GError **error) { g_autoptr(GError) error_local = NULL; g_autoptr(GFile) file1 = NULL; g_autoptr(GFile) file2 = NULL; g_return_val_if_fail (error == NULL || *error == NULL, FALSE); file1 = g_file_new_for_path (PK_OFFLINE_TRIGGER_FILENAME); if (!g_file_query_exists (file1, NULL)) return TRUE; if (!g_file_delete (file1, NULL, &error_local)) { g_set_error (error, PK_OFFLINE_ERROR, PK_OFFLINE_ERROR_FAILED, "Cannot delete %s: %s", PK_OFFLINE_TRIGGER_FILENAME, error_local->message); return FALSE; } file2 = g_file_new_for_path (PK_OFFLINE_ACTION_FILENAME); if (g_file_query_exists (file2, NULL) && !g_file_delete (file2, NULL, &error_local)) { g_set_error (error, PK_OFFLINE_ERROR, PK_OFFLINE_ERROR_FAILED, "Cannot delete %s: %s", PK_OFFLINE_ACTION_FILENAME, error_local->message); return FALSE; } return TRUE; }
void rb_generic_player_source_trash_or_delete_entries (RBGenericPlayerSource *source, GList *entries, gboolean _delete) { RBGenericPlayerSourcePrivate *priv = GENERIC_PLAYER_SOURCE_GET_PRIVATE (source); GList *tem; if (priv->read_only != FALSE) return; for (tem = entries; tem != NULL; tem = tem->next) { RhythmDBEntry *entry; const char *uri; GFile *file; GFile *dir; entry = tem->data; uri = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION); file = g_file_new_for_uri (uri); if (_delete) g_file_delete (file, NULL, NULL); else g_file_trash (file, NULL, NULL); /* now walk up the directory structure and delete empty dirs * until we reach the root or one of the device's audio folders. */ dir = g_file_get_parent (file); while (can_delete_directory (source, dir)) { GFile *parent; char *path; path = g_file_get_path (dir); rb_debug ("trying to delete %s", path); g_free (path); if (g_file_delete (dir, NULL, NULL) == FALSE) { break; } parent = g_file_get_parent (dir); if (parent == NULL) { break; } g_object_unref (dir); dir = parent; } g_object_unref (dir); g_object_unref (file); rhythmdb_entry_delete (priv->db, entry); } rhythmdb_commit (priv->db); }
/** * hif_db_remove_all: * @db: a #HifDb instance. * @package: A package to use as a reference * @error: A #GError, or %NULL * * Removes a all data value from the yumdb 'database' for a given package. * * Returns: %TRUE for success, %FALSE otherwise * * Since: 0.1.0 **/ gboolean hif_db_remove_all(HifDb *db, HifPackage *package, GError **error) { HifDbPrivate *priv = GET_PRIVATE(db); const gchar *filename; g_autoptr(GDir) dir = NULL; g_autofree gchar *index_dir = NULL; g_autoptr(GFile) file_directory = NULL; g_return_val_if_fail(HIF_IS_DB(db), FALSE); g_return_val_if_fail(package != NULL, FALSE); g_return_val_if_fail(error == NULL || *error == NULL, FALSE); if (!priv->enabled) return TRUE; /* get the folder */ index_dir = hif_db_get_dir_for_package(db, package); if (index_dir == NULL) { g_set_error(error, HIF_ERROR, HIF_ERROR_FAILED, "cannot create index for %s", hif_package_get_package_id(package)); return FALSE; } if (!g_file_test(index_dir, G_FILE_TEST_IS_DIR)) { g_debug("Nothing to delete in %s", index_dir); return TRUE; } /* open */ dir = g_dir_open(index_dir, 0, error); if (dir == NULL) return FALSE; /* delete each one */ filename = g_dir_read_name(dir); while (filename != NULL) { g_autofree gchar *index_file = NULL; g_autoptr(GFile) file_tmp = NULL; index_file = g_build_filename(index_dir, filename, NULL); file_tmp = g_file_new_for_path(index_file); /* delete, ignoring error */ g_debug("deleting %s from %s", filename, index_dir); if (!g_file_delete(file_tmp, NULL, NULL)) g_debug("failed to delete %s", filename); filename = g_dir_read_name(dir); } /* now delete the directory */ file_directory = g_file_new_for_path(index_dir); return g_file_delete(file_directory, NULL, error); }
void deleteFilesIfNeeded() { if (m_destinationFile) g_file_delete(m_destinationFile.get(), nullptr, nullptr); if (m_intermediateFile) { ASSERT(m_destinationFile); g_file_delete(m_intermediateFile.get(), nullptr, nullptr); } }
gboolean libre_impuesto_file_delete_dir_recursively (GFile *directory, GError **error) { GFileEnumerator *children = NULL; GFileInfo *info; gboolean ret = TRUE; children = g_file_enumerate_children (directory, "standard::name,standard::type", 0, NULL, error); if (error) goto out; info = g_file_enumerator_next_file (children, NULL, error); while (info || error) { GFile *child; const char *name; GFileType type; if (error) goto out; name = g_file_info_get_name (info); child = g_file_get_child (directory, name); type = g_file_info_get_file_type (info); if (type == G_FILE_TYPE_DIRECTORY) ret = libre_impuesto_file_delete_dir_recursively (child, error); else if (type == G_FILE_TYPE_REGULAR) ret = g_file_delete (child, NULL, error); g_object_unref (info); if (!ret) goto out; info = g_file_enumerator_next_file (children, NULL, error); } ret = TRUE; g_file_delete (directory, NULL, error); out: if (children) g_object_unref (children); return ret; }
static void cache_down (GrlNetWc *self) { GFile *cache_dir_file; GrlNetWcPrivate *priv = self->priv; SoupSessionFeature *cache = soup_session_get_feature (priv->session, SOUP_TYPE_CACHE); gchar *cache_dir; GRL_DEBUG ("cache down"); if (!cache) { return; } soup_cache_clear (SOUP_CACHE (cache)); g_object_get (cache, "cache-dir", &cache_dir, NULL); cache_dir_file = g_file_new_for_path (cache_dir); g_free (cache_dir); g_file_delete (cache_dir_file, NULL, NULL); g_object_unref (G_OBJECT (cache_dir_file)); soup_session_remove_feature (priv->session, cache); }
void on_switch_startup_active_notify(GtkSwitch *widget, gpointer data) { gchar *folder_dir, *startup_dir, *desktop_dir; GFile *folder_file, *startup_file, *desktop_file; folder_dir = g_build_filename(g_get_home_dir(), ".config", "autostart", NULL); startup_dir = g_build_filename(g_get_home_dir(), ".config", "autostart", "acal.desktop", NULL); desktop_dir = g_build_filename(DATADIR, "applications", "acal.desktop", NULL); folder_file = g_file_new_for_path(folder_dir); startup_file = g_file_new_for_path(startup_dir); desktop_file = g_file_new_for_path(desktop_dir); /* create startup folder if not exists */ g_file_make_directory_with_parents(folder_file , NULL, NULL); /* copy acal.desktop to autostart dir on activate autostart */ if(gtk_switch_get_active(widget)) g_file_copy(desktop_file, startup_file, G_FILE_COPY_NONE, NULL, NULL, NULL, NULL); else g_file_delete(startup_file, NULL, NULL); }
static void catalog_saved_cb (void **buffer, gsize count, GError *error, gpointer user_data) { DialogData *data = user_data; if (error == NULL) { if (! g_file_equal (data->original_file, data->file_data->file)) { GFile *gio_file; gio_file = gth_catalog_file_to_gio_file (data->original_file); g_file_delete (gio_file, NULL, NULL); g_object_unref (gio_file); gth_monitor_file_renamed (gth_main_get_default_monitor (), data->original_file, data->file_data->file); } gth_catalog_update_metadata (data->catalog, data->file_data); gth_monitor_metadata_changed (gth_main_get_default_monitor (), data->file_data); gth_hook_invoke ("dlg-catalog-properties-saved", data->browser, data->file_data, data->catalog); } else _gtk_error_dialog_from_gerror_show (GTK_WINDOW (data->browser), _("Could not save the catalog"), error); gtk_widget_destroy (data->dialog); }
void APP_CC trans_delete(struct trans *self) { if (self == 0) { return; } free_stream(self->in_s); free_stream(self->out_s); if (self->sck > 0) { g_tcp_close(self->sck); } self->sck = 0; if (self->listen_filename != 0) { g_file_delete(self->listen_filename); g_free(self->listen_filename); } if (self->tls != 0) { ssl_tls_delete(self->tls); } g_free(self); }
static gboolean _delete_files_async (GFile* file, gpointer data) { gboolean retval = TRUE; TDData* _data = (TDData*) data; GError* error = NULL; GCancellable* _delete_cancellable = NULL; _delete_cancellable = _data->cancellable; g_file_delete (file, _delete_cancellable, &error); if (error != NULL) { //show error dialog g_cancellable_cancel (_delete_cancellable); g_warning ("_delete_files_async: %s", error->message); //fileops_delete_trash_error_show_dialog ("delete", error, file, NULL); g_error_free (error); g_cancellable_reset (_delete_cancellable); } #if 1 char* file_uri = g_file_get_uri (file); g_debug ("_delete_files_async: delete : %s", file_uri); g_free (file_uri); #endif return retval; }
int gtr_file_trash_or_remove (const char * filename) { GFile * file; gboolean trashed = FALSE; g_return_val_if_fail (filename && *filename, 0); file = g_file_new_for_path (filename); if (gtr_pref_flag_get (TR_KEY_trash_can_enabled)) { GError * err = NULL; trashed = g_file_trash (file, NULL, &err); if (err) { g_message ("Unable to trash file \"%s\": %s", filename, err->message); g_clear_error (&err); } } if (!trashed) { GError * err = NULL; g_file_delete (file, NULL, &err); if (err) { g_message ("Unable to delete file \"%s\": %s", filename, err->message); g_clear_error (&err); } } g_object_unref (G_OBJECT (file)); return 0; }
void lllp_connected_cb(GObject *listener, GAsyncResult *res, gpointer pstore_library) { GtkListStore *store_library = GTK_LIST_STORE(pstore_library); GSocketConnection *connection; GSocketAddress *address; gchar *address_char; GInputStream *stream; GFile *output_file; GOutputStream *file_stream; gsize count; gboolean valid = FALSE; connection = g_socket_listener_accept_finish(G_SOCKET_LISTENER(listener), res, NULL, NULL); address = g_socket_connection_get_remote_address(connection, NULL); address_char = g_inet_address_to_string(g_inet_socket_address_get_address(G_INET_SOCKET_ADDRESS(address))); printf("%s\n", address_char); output_file = g_file_new_for_path(address_char); g_file_delete(output_file, NULL, NULL); file_stream = (GOutputStream*)g_file_replace(output_file, NULL, FALSE, G_FILE_CREATE_REPLACE_DESTINATION, NULL, NULL); stream = g_io_stream_get_input_stream(G_IO_STREAM(connection)); g_output_stream_splice(file_stream, stream, G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE & G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, NULL, NULL); g_output_stream_close(file_stream, NULL, NULL); convert_library_to_list_store(store_library, address_char); printf("%s CONNECTED\n", address_char); g_socket_listener_accept_async(G_SOCKET_LISTENER(listener), NULL, lllp_connected_cb, store_library); }
gboolean session_clear (Gimp *gimp, GError **error) { GFile *file; GError *my_error = NULL; gboolean success = TRUE; g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); file = session_file (gimp); if (! g_file_delete (file, NULL, &my_error) && my_error->code != G_IO_ERROR_NOT_FOUND) { success = FALSE; g_set_error (error, GIMP_ERROR, GIMP_FAILED, _("Deleting \"%s\" failed: %s"), gimp_file_get_utf8_name (file), my_error->message); } else { sessionrc_deleted = TRUE; } g_clear_error (&my_error); g_object_unref (file); return success; }
static void remove_catalog (GtkWindow *window, GthFileData *file_data) { GFile *gio_file; GError *error = NULL; gio_file = gth_main_get_gio_file (file_data->file); if (g_file_delete (gio_file, NULL, &error)) { GFile *parent; GList *files; parent = g_file_get_parent (file_data->file); files = g_list_prepend (NULL, g_object_ref (file_data->file)); gth_monitor_folder_changed (gth_main_get_default_monitor (), parent, files, GTH_MONITOR_EVENT_DELETED); _g_object_list_unref (files); _g_object_unref (parent); } else { _gtk_error_dialog_from_gerror_show (window, _("Could not remove the catalog"), error); g_clear_error (&error); } g_object_unref (gio_file); }
/** * pk_offline_auth_invalidate: * @error: A #GError or %NULL * * Invalidates the offline operation. This is normally done when the package * cache has been refreshed, or a package listed in the prepared transaction * is manually installed or removed. * * Return value: %TRUE for success, else %FALSE and @error set * * Since: 0.9.6 **/ gboolean pk_offline_auth_invalidate (GError **error) { _cleanup_error_free_ GError *error_local = NULL; _cleanup_object_unref_ GFile *file = NULL; g_return_val_if_fail (error == NULL || *error == NULL, FALSE); /* cancel the pending update */ if (!pk_offline_auth_cancel (error)) return FALSE; /* delete the prepared file */ file = g_file_new_for_path (PK_OFFLINE_PREPARED_FILENAME); if (g_file_query_exists (file, NULL) && !g_file_delete (file, NULL, &error_local)) { g_set_error (error, PK_OFFLINE_ERROR, PK_OFFLINE_ERROR_FAILED, "Cannot delete %s: %s", PK_OFFLINE_PREPARED_FILENAME, error_local->message); return FALSE; } return TRUE; }
static void aod_remove_cb (GtkWidget *widget, LoadOptionsDialogData *aod_data) { GtkTreeSelection *selection; GtkTreeIter iter; char *filename; GFile *options_dir; GFile *options_file; GError *error = NULL; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (aod_data->aod_treeview)); if (! gtk_tree_selection_get_selected (selection, NULL, &iter)) return; gtk_tree_model_get (aod_data->aod_model, &iter, 1, &filename, -1); gtk_list_store_remove (GTK_LIST_STORE (aod_data->aod_model), &iter); options_dir = get_user_config_subdirectory (ADD_FOLDER_OPTIONS_DIR, TRUE); options_file = g_file_get_child (options_dir, filename); if (! g_file_delete (options_file, NULL, &error)) { g_warning ("could not delete the options: %s", error->message); g_clear_error (&error); } g_object_unref (options_file); g_object_unref (options_dir); g_free (filename); }
void panel_launcher_delete (Launcher *launcher) { if (!launcher->location) return; /* do not remove the file if it's not in the user's launchers path */ if (panel_launcher_is_in_personal_path (launcher->location)) { GError *error; GFile *file; file = panel_launcher_get_gfile (launcher->location); error = NULL; if (!g_file_delete (file, NULL, &error)) { char *path; path = g_file_get_path (file); g_warning ("Error deleting '%s': %s\n", path, error->message); g_free (path); g_error_free (error); } g_object_unref (file); } }
static void _delete_trash_file (GFile *file, gboolean del_file, gboolean del_children) { GFileInfo *info; GFile *child; GFileEnumerator *enumerator; if (del_children) { enumerator = g_file_enumerate_children (file, G_FILE_ATTRIBUTE_STANDARD_NAME "," G_FILE_ATTRIBUTE_STANDARD_TYPE, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, NULL); if (enumerator) { while ((info = g_file_enumerator_next_file (enumerator, NULL, NULL)) != NULL) { child = g_file_get_child (file, g_file_info_get_name (info)); _delete_trash_file (child, TRUE, g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY); g_object_unref (child); g_object_unref (info); } g_file_enumerator_close (enumerator, NULL, NULL); g_object_unref (enumerator); } } if (del_file) { g_file_delete (file, NULL, NULL); } }
IOChannel::IOChannel(const String& filePath, Type type) : m_path(filePath) , m_type(type) { auto path = WebCore::fileSystemRepresentation(filePath); GRefPtr<GFile> file = adoptGRef(g_file_new_for_path(path.data())); switch (m_type) { case Type::Create: { g_file_delete(file.get(), nullptr, nullptr); m_outputStream = adoptGRef(G_OUTPUT_STREAM(g_file_create(file.get(), static_cast<GFileCreateFlags>(G_FILE_CREATE_PRIVATE), nullptr, nullptr))); ASSERT(m_outputStream); GUniquePtr<char> birthtimeString(g_strdup_printf("%" G_GUINT64_FORMAT, std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()))); g_file_set_attribute_string(file.get(), "xattr::birthtime", birthtimeString.get(), G_FILE_QUERY_INFO_NONE, nullptr, nullptr); break; } case Type::Write: { m_ioStream = adoptGRef(g_file_open_readwrite(file.get(), nullptr, nullptr)); ASSERT(m_ioStream); break; } case Type::Read: m_inputStream = adoptGRef(G_INPUT_STREAM(g_file_read(file.get(), nullptr, nullptr))); ASSERT(m_inputStream); break; } }
static void unoconv_child_watch_cb (GPid pid, gint status, gpointer user_data) { PdfLoadJob *job = user_data; if (job->cancellable != NULL) { g_cancellable_disconnect (job->cancellable, job->cancelled_id); job->cancelled_id = 0; } g_spawn_close_pid (pid); job->unoconv_pid = -1; /* We need to clean up the downloaded file (if any) that was * converted. */ if (job->download_file != NULL) { g_file_delete (job->download_file, NULL, NULL); g_clear_object (&job->download_file); } if (g_cancellable_is_cancelled (job->cancellable)) { pdf_load_job_complete_error (job, g_error_new_literal (G_IO_ERROR, G_IO_ERROR_CANCELLED, "Operation cancelled")); return; } pdf_load_job_cache_set_attributes (job); }
int main (int argc, char *argv[]) { GError *error; GOptionContext *context; GFile *file; int retval = 0; gchar *param; gchar *summary; setlocale (LC_ALL, ""); bindtextdomain (GETTEXT_PACKAGE, GVFS_LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); error = NULL; param = g_strdup_printf ("[%s...]", _("FILE")); summary = _("Delete the given files."); context = g_option_context_new (param); g_option_context_set_summary (context, summary); g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE); g_option_context_parse (context, &argc, &argv, &error); g_option_context_free (context); g_free (param); if (error != NULL) { g_printerr (_("Error parsing commandline options: %s\n"), error->message); g_printerr ("\n"); g_printerr (_("Try \"%s --help\" for more information."), g_get_prgname ()); g_printerr ("\n"); g_error_free (error); return 1; } if (argc > 1) { int i; for (i = 1; i < argc; i++) { file = g_file_new_for_commandline_arg (argv[i]); error = NULL; if (!g_file_delete (file, NULL, &error)) { if (!force || !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) { g_printerr ("Error deleting file: %s\n", error->message); retval = 1; } g_error_free (error); } g_object_unref (file); } } return retval; }
/** * i7_app_uninstall_color_scheme: * @self: the app * @id: the id of the color scheme to be uninstalled * * Uninstalls a user color scheme. * * Return value: %TRUE on success, %FALSE otherwise. */ gboolean i7_app_uninstall_color_scheme(I7App *self, const char *id) { I7_APP_USE_PRIVATE(self, priv); GError *error = NULL; g_return_val_if_fail (id != NULL, FALSE); GtkSourceStyleScheme *scheme = gtk_source_style_scheme_manager_get_scheme(priv->color_scheme_manager, id); if(!scheme) return FALSE; const gchar *filename = gtk_source_style_scheme_get_filename(scheme); if(!filename) return FALSE; GFile *file = g_file_new_for_path(filename); if(!g_file_delete(file, NULL, &error)) { WARN(_("Cannot uninstall style scheme"), error); g_error_free(error); g_object_unref(file); return FALSE; } g_object_unref(file); /* Reload the available style schemes */ gtk_source_style_scheme_manager_force_rescan(priv->color_scheme_manager); return TRUE; }
int gtr_file_trash_or_remove( const char * filename ) { gboolean trashed = FALSE; GFile * file = g_file_new_for_path( filename ); if( gtr_pref_flag_get( PREF_KEY_TRASH_CAN_ENABLED ) ) { GError * err = NULL; trashed = g_file_trash( file, NULL, &err ); if( err ) { g_message( "Unable to trash file \"%s\": %s", filename, err->message ); g_clear_error( &err ); } } if( !trashed ) { GError * err = NULL; g_file_delete( file, NULL, &err ); if( err ) { g_message( "Unable to delete file \"%s\": %s", filename, err->message ); g_clear_error( &err ); } } g_object_unref( G_OBJECT( file ) ); return 0; }
static void free_tmp_file (GFile *tmp_file) { g_file_delete (tmp_file, NULL, NULL); g_object_unref (tmp_file); }
static void delete_batch (GObject *source, GAsyncResult *res, gpointer user_data) { GFileEnumerator *enumerator = G_FILE_ENUMERATOR (source); DeleteData *data = user_data; GList *files, *f; GFile *child_file; DeleteData *child; GFileInfo *info; GError *error = NULL; files = g_file_enumerator_next_files_finish (enumerator, res, &error); g_debug ("GsdHousekeeping: purging %d children of %s", g_list_length (files), data->name); if (files) { for (f = files; f; f = f->next) { if (g_cancellable_is_cancelled (data->cancellable)) break; info = f->data; child_file = g_file_get_child (data->file, g_file_info_get_name (info)); child = delete_data_new (child_file, data->cancellable, data->old, data->dry_run, data->trash, data->depth + 1); delete_recursively_by_age (child); delete_data_unref (child); g_object_unref (child_file); } g_list_free_full (files, g_object_unref); if (!g_cancellable_is_cancelled (data->cancellable)) { g_file_enumerator_next_files_async (enumerator, 20, 0, data->cancellable, delete_batch, data); return; } } g_file_enumerator_close (enumerator, data->cancellable, NULL); g_object_unref (enumerator); if (data->depth > 0 && !g_cancellable_is_cancelled (data->cancellable)) { if ((data->trash && data->depth > 1) || should_purge_file (data->file, data->cancellable, data->old)) { g_debug ("GsdHousekeeping: purging %s\n", data->name); if (!data->dry_run) { g_file_delete (data->file, data->cancellable, NULL); } } } delete_data_unref (data); }
bool recursive_delete_path( GFile * file ) { bool result = false; GFileInfo * info = g_file_query_info( file, "standard::*", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, NULL ); if ( info ) { if ( g_file_info_get_file_type( info ) == G_FILE_TYPE_DIRECTORY ) { GFileEnumerator * enumerator = g_file_enumerate_children( file, "standard::*", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, NULL ); if ( enumerator ) { while ( true ) { GError * error = NULL; GFileInfo * child_info = g_file_enumerator_next_file( enumerator, NULL, &error ); if ( ! child_info ) { g_clear_error( &error ); break; } GFile * child = g_file_resolve_relative_path( file, g_file_info_get_name( child_info ) ); bool child_deleted = recursive_delete_path( child ); g_object_unref( G_OBJECT( child_info ) ); g_object_unref( G_OBJECT( child ) ); if ( ! child_deleted ) { break; } } g_object_unref( G_OBJECT( enumerator ) ); } } g_object_unref( G_OBJECT( info ) ); gchar * s = g_file_get_path( file ); g_debug( "DELETING '%s'", s ); g_free( s ); // Will delete the file or directory result = g_file_delete( file, NULL, NULL ); } return result; }
static gboolean gs_plugin_fwupd_install (GsPlugin *plugin, GsApp *app, GCancellable *cancellable, GError **error) { GsPluginData *priv = gs_plugin_get_data (plugin); const gchar *device_id; FwupdInstallFlags install_flags = 0; GFile *local_file; g_autofree gchar *filename = NULL; /* not set */ local_file = gs_app_get_local_file (app); if (local_file == NULL) { g_set_error (error, GS_PLUGIN_ERROR, GS_PLUGIN_ERROR_FAILED, "not enough data for fwupd %s", filename); return FALSE; } /* file does not yet exist */ filename = g_file_get_path (local_file); if (!g_file_query_exists (local_file, cancellable)) { const gchar *uri = gs_fwupd_app_get_update_uri (app); gs_app_set_state (app, AS_APP_STATE_INSTALLING); if (!gs_plugin_download_file (plugin, app, uri, filename, cancellable, error)) return FALSE; } /* limit to single device? */ device_id = gs_fwupd_app_get_device_id (app); if (device_id == NULL) device_id = FWUPD_DEVICE_ID_ANY; /* set the last object */ g_set_object (&priv->app_current, app); /* only offline supported */ if (gs_app_get_metadata_item (app, "fwupd::OnlyOffline") != NULL) install_flags |= FWUPD_INSTALL_FLAG_OFFLINE; gs_app_set_state (app, AS_APP_STATE_INSTALLING); if (!fwupd_client_install (priv->client, device_id, filename, install_flags, cancellable, error)) { gs_plugin_fwupd_error_convert (error); gs_app_set_state_recover (app); return FALSE; } /* delete the file from the cache */ gs_app_set_state (app, AS_APP_STATE_INSTALLED); return g_file_delete (local_file, cancellable, error); }