Esempio n. 1
0
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;
}
Esempio n. 3
0
/*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);
}
Esempio n. 4
0
/**
 * 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);
}
Esempio n. 6
0
/**
 * 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);
}
Esempio n. 7
0
    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);
        }
    }
Esempio n. 8
0
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;
}
Esempio n. 9
0
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);
}
Esempio n. 10
0
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);
}
Esempio n. 11
0
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);
}
Esempio n. 12
0
File: trans.c Progetto: speidy/xrdp
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);
}
Esempio n. 13
0
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;
}
Esempio n. 14
0
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;
}
Esempio n. 15
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);
}
Esempio n. 16
0
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;
}
Esempio n. 17
0
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);
}
Esempio n. 18
0
/**
 * 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;
}
Esempio n. 19
0
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);
}
Esempio n. 20
0
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);
	}
}
Esempio n. 21
0
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;
    }
}
Esempio n. 23
0
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);
}
Esempio n. 24
0
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;
}
Esempio n. 25
0
/**
 * 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;
}
Esempio n. 27
0
static void
free_tmp_file (GFile *tmp_file)
{

	g_file_delete (tmp_file, NULL, NULL);
	g_object_unref (tmp_file);
}
Esempio n. 28
0
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);
}
Esempio n. 29
0
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;
}
Esempio n. 30
0
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);
}