static void
do_query_info (GVfsBackend *backend,
GVfsJobQueryInfo *job,
const char *filename,
GFileQueryInfoFlags flags,
GFileInfo *info,
GFileAttributeMatcher *matcher)
{
GFile *file;
GFileInfo *info2;
GError *error;
GVfs *local_vfs;
g_print ("do_get_file_info (%s)\n", filename);
local_vfs = g_vfs_get_local ();
file = g_vfs_get_file_for_path (local_vfs, filename);
error = NULL;
info2 = g_file_query_info (file, job->attributes, flags,
NULL, &error);
if (info2)
{
g_file_info_copy_into (info2, info);
g_object_unref (info2);
g_vfs_job_succeeded (G_VFS_JOB (job));
}
else
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
g_object_unref (file);
}
static void
trash_backend_query_info_on_read (GVfsBackend *backend,
GVfsJobQueryInfoRead *job,
GVfsBackendHandle handle,
GFileInfo *info,
GFileAttributeMatcher *matcher)
{
GError *error = NULL;
GFileInfo *real_info;
real_info = g_file_input_stream_query_info (handle,
job->attributes,
G_VFS_JOB (job)->cancellable,
&error);
if (real_info)
{
g_file_info_copy_into (real_info, info);
g_vfs_job_succeeded (G_VFS_JOB (job));
g_object_unref (real_info);
}
else
{
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
g_error_free (error);
}
}
static gboolean
trash_backend_read (GVfsBackend *backend,
GVfsJobRead *job,
GVfsBackendHandle handle,
char *buffer,
gsize bytes_requested)
{
GError *error = NULL;
gssize bytes;
bytes = g_input_stream_read (handle, buffer, bytes_requested,
G_VFS_JOB (job)->cancellable, &error);
if (bytes >= 0)
{
g_vfs_job_read_set_size (job, bytes);
g_vfs_job_succeeded (G_VFS_JOB (job));
return TRUE;
}
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
g_error_free (error);
return TRUE;
}
static void
query_info_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GVfsBackendAfpBrowse *afp_backend = G_VFS_BACKEND_AFP_BROWSE (source_object);
GVfsJobQueryInfo *job = G_VFS_JOB_QUERY_INFO (user_data);
GError *err = NULL;
GVfsAfpVolumeData *vol_data;
if (!update_cache_finish (afp_backend, res, &err))
{
g_vfs_job_failed_from_error (G_VFS_JOB (job), err);
g_error_free (err);
return;
}
vol_data = find_volume (afp_backend, job->filename);
if (!vol_data)
{
g_vfs_job_failed_literal (G_VFS_JOB (job), G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
_("File doesn't exist"));
return;
}
fill_info (job->file_info, vol_data, afp_backend);
g_vfs_job_succeeded (G_VFS_JOB (job));
}
static void
do_mount (GVfsBackend *backend,
GVfsJobMount *job,
GMountSpec *mount_spec,
GMountSource *mount_source,
gboolean is_automount)
{
GVfsBackendAfpBrowse *afp_backend = G_VFS_BACKEND_AFP_BROWSE (backend);
gboolean res;
GError *err = NULL;
GMountSpec *afp_mount_spec;
char *server_name;
char *display_name;
afp_backend->server = g_vfs_afp_server_new (afp_backend->addr);
res = g_vfs_afp_server_login (afp_backend->server, afp_backend->user, mount_source,
&afp_backend->logged_in_user,
G_VFS_JOB (job)->cancellable, &err);
if (!res)
goto error;
/* set mount info */
afp_mount_spec = g_mount_spec_new ("afp-server");
g_mount_spec_set (afp_mount_spec, "host",
g_network_address_get_hostname (G_NETWORK_ADDRESS (afp_backend->addr)));
if (afp_backend->user)
g_mount_spec_set (afp_mount_spec, "user", afp_backend->user);
g_vfs_backend_set_mount_spec (backend, afp_mount_spec);
g_mount_spec_unref (afp_mount_spec);
if (afp_backend->server->utf8_server_name)
server_name = afp_backend->server->utf8_server_name;
else
server_name = afp_backend->server->server_name;
if (afp_backend->user)
/* Translators: first %s is username and second serververname */
display_name = g_strdup_printf (_("AFP volumes for %s on %s"), afp_backend->user,
server_name);
else
/* Translators: %s is the servername */
display_name = g_strdup_printf (_("AFP volumes on %s"),
server_name);
g_vfs_backend_set_display_name (backend, display_name);
g_free (display_name);
g_vfs_backend_set_icon_name (backend, "network-server-afp");
g_vfs_backend_set_user_visible (backend, FALSE);
g_vfs_job_succeeded (G_VFS_JOB (job));
return;
error:
g_vfs_job_failed_from_error (G_VFS_JOB (job), err);
}
static void
do_query_info_on_write (GVfsBackend *backend,
GVfsJobQueryInfoWrite *job,
GVfsBackendHandle handle,
GFileInfo *info,
GFileAttributeMatcher *attribute_matcher)
{
GFileOutputStream *out;
GError *error;
GFileInfo *info2;
g_print ("do_query_info_on_write\n");
out = (GFileOutputStream *)handle;
error = NULL;
info2 = g_file_output_stream_query_info (out, job->attributes,
G_VFS_JOB (job)->cancellable,
&error);
if (info2 == NULL)
{
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
g_error_free (error);
}
else
{
g_file_info_copy_into (info2, info);
g_object_unref (info2);
g_vfs_job_succeeded (G_VFS_JOB (job));
}
}
static void
enumerate_cache_updated_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GVfsBackendAfpBrowse *afp_backend = G_VFS_BACKEND_AFP_BROWSE (source_object);
GVfsJobEnumerate *job = G_VFS_JOB_ENUMERATE (user_data);
GError *err = NULL;
guint i;
if (!update_cache_finish (afp_backend, res, &err))
{
g_vfs_job_failed_from_error (G_VFS_JOB (job), err);
g_error_free (err);
return;
}
g_vfs_job_succeeded (G_VFS_JOB (job));
for (i = 0; i < afp_backend->volumes->len; i++)
{
GVfsAfpVolumeData *vol_data = g_ptr_array_index (afp_backend->volumes, i);
GFileInfo *info;
info = g_file_info_new ();
fill_info (info, vol_data, afp_backend);
g_vfs_job_enumerate_add_info (job, info);
g_object_unref (info);
}
g_vfs_job_enumerate_done (job);
}
static void
do_write (GVfsBackend *backend,
GVfsJobWrite *job,
GVfsBackendHandle handle,
char *buffer,
gsize buffer_size)
{
GFileOutputStream *out;
GError *error;
gssize res;
g_print ("do_write\n");
out = (GFileOutputStream *)handle;
error = NULL;
res = g_output_stream_write (G_OUTPUT_STREAM (out),
buffer, buffer_size,
G_VFS_JOB (job)->cancellable,
&error);
if (res < 0)
{
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
g_error_free (error);
}
else
{
g_vfs_job_write_set_written_size (job, res);
g_vfs_job_succeeded (G_VFS_JOB (job));
}
}
static void
do_close_write (GVfsBackend *backend,
GVfsJobCloseWrite *job,
GVfsBackendHandle handle)
{
GFileOutputStream *out;
GError *error;
char *etag;
out = (GFileOutputStream *)handle;
error = NULL;
if (!g_output_stream_close (G_OUTPUT_STREAM (out),
G_VFS_JOB (job)->cancellable,
&error))
{
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
g_error_free (error);
}
else
{
etag = g_file_output_stream_get_etag (out);
if (etag)
{
g_vfs_job_close_write_set_etag (job, etag);
g_free (etag);
}
g_vfs_job_succeeded (G_VFS_JOB (job));
}
g_object_unref (out);
}
static void
do_replace (GVfsBackend *backend,
GVfsJobOpenForWrite *job,
const char *filename,
const char *etag,
gboolean make_backup,
GFileCreateFlags flags)
{
GFile *file;
GFileOutputStream *out;
GError *error;
file = g_vfs_get_file_for_path (g_vfs_get_local (),
filename);
error = NULL;
out = g_file_replace (file,
etag, make_backup,
flags, G_VFS_JOB (job)->cancellable,
&error);
g_object_unref (file);
if (out)
{
g_vfs_job_open_for_write_set_can_seek (job, FALSE);
g_vfs_job_open_for_write_set_handle (job, out);
g_vfs_job_succeeded (G_VFS_JOB (job));
}
else
{
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
g_error_free (error);
}
}
static gboolean
trash_backend_delete (GVfsBackend *vfs_backend,
GVfsJobDelete *job,
const char *filename)
{
GVfsBackendTrash *backend = G_VFS_BACKEND_TRASH (vfs_backend);
GError *error = NULL;
g_debug ("before job: %d\n", G_OBJECT(job)->ref_count);
if (filename[1] == '\0')
g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,
_("The trash folder may not be deleted"));
else
{
gboolean is_toplevel;
TrashItem *item;
GFile *real;
if (!backend->file_monitor && !backend->dir_monitor)
trash_watcher_rescan (backend->watcher);
real = trash_backend_get_file (backend, filename,
&item, &is_toplevel, &error);
if (real)
{
/* not interested in the 'real', but the item */
g_object_unref (real);
if (!is_toplevel)
g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,
_("Items in the trash may not be modified"));
else
{
if (trash_item_delete (item, &error))
{
trash_backend_schedule_thaw (backend);
g_vfs_job_succeeded (G_VFS_JOB (job));
trash_item_unref (item);
return TRUE;
}
}
trash_item_unref (item);
}
}
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
g_error_free (error);
return TRUE;
}
static void
trash_backend_enumerate_non_root (GVfsBackendTrash *backend,
GVfsJobEnumerate *job,
const gchar *filename,
GFileAttributeMatcher *attribute_matcher,
GFileQueryInfoFlags flags)
{
GError *error = NULL;
GFile *real;
real = trash_backend_get_file (backend, filename, NULL, NULL, &error);
if (real)
{
GFileEnumerator *enumerator;
enumerator = g_file_enumerate_children (real, job->attributes,
job->flags,
G_VFS_JOB (job)->cancellable, &error);
g_object_unref (real);
if (enumerator)
{
GFileInfo *info;
g_vfs_job_succeeded (G_VFS_JOB (job));
while ((info = g_file_enumerator_next_file (enumerator,
G_VFS_JOB (job)->cancellable,
&error)))
{
trash_backend_add_info (NULL, info, FALSE);
g_vfs_job_enumerate_add_info (job, info);
g_object_unref (info);
}
/* error from next_file? ignore. */
if (error)
g_error_free (error);
g_vfs_job_enumerate_done (job);
g_object_unref (enumerator);
return;
}
}
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
g_error_free (error);
}
/**
* g_vfs_ftp_task_done:
* @task: the task to finalize
*
* Finalizes the given task and clears all memory in use. It also marks the
* associated job as success or failure depending on the error state of the
* task.
**/
void
g_vfs_ftp_task_done (GVfsFtpTask *task)
{
g_return_if_fail (task != NULL);
g_vfs_ftp_task_release_connection (task);
if (task->job)
{
if (g_vfs_ftp_task_is_in_error (task))
g_vfs_job_failed_from_error (task->job, task->error);
else
g_vfs_job_succeeded (task->job);
}
g_vfs_ftp_task_clear_error (task);
}
/* ======================= method implementations ======================= */
static gboolean
trash_backend_open_for_read (GVfsBackend *vfs_backend,
GVfsJobOpenForRead *job,
const char *filename)
{
GVfsBackendTrash *backend = G_VFS_BACKEND_TRASH (vfs_backend);
GError *error = NULL;
if (filename[1] == '\0')
g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY,
_("Can't open directory"));
else
{
GFile *real;
if (!backend->file_monitor && !backend->dir_monitor)
trash_watcher_rescan (backend->watcher);
real = trash_backend_get_file (backend, filename, NULL, NULL, &error);
if (real)
{
GFileInputStream *stream;
stream = g_file_read (real, G_VFS_JOB (job)->cancellable, &error);
g_object_unref (real);
if (stream)
{
g_vfs_job_open_for_read_set_handle (job, stream);
g_vfs_job_open_for_read_set_can_seek (job, TRUE);
g_vfs_job_succeeded (G_VFS_JOB (job));
return TRUE;
}
}
}
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
g_error_free (error);
return TRUE;
}
static gboolean
recent_backend_delete (GVfsBackend *vfs_backend,
GVfsJobDelete *job,
const char *filename)
{
GVfsBackendRecent *backend = G_VFS_BACKEND_RECENT (vfs_backend);
GError *error = NULL;
g_debug ("before job: %d\n", G_OBJECT(job)->ref_count);
if (filename[1] == '\0')
{
g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,
_("The recent folder may not be deleted"));
}
else
{
RecentItem *item;
item = g_hash_table_lookup (backend->items, filename + 1);
if (item)
{
gboolean res;
res = gtk_recent_manager_remove_item (backend->recent_manager,
item->uri,
&error);
if (res)
{
g_vfs_job_succeeded (G_VFS_JOB (job));
return TRUE;
}
}
else
g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
_("No such file or directory"));
}
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
g_error_free (error);
return TRUE;
}
static gboolean
try_open_for_read (GVfsBackend *backend,
GVfsJobOpenForRead *job,
const char *filename)
{
GError *error;
g_print ("try_open_for_read (%s)\n", filename);
if (strcmp (filename, "/fail") == 0)
{
error = g_error_new (G_IO_ERROR, G_IO_ERROR_FAILED, "Test error");
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
}
else
{
guint tag = g_timeout_add (0, open_idle_cb, job);
g_signal_connect (job, "cancelled", (GCallback)open_read_cancelled_cb, GINT_TO_POINTER (tag));
}
return TRUE;
}
static gboolean
trash_backend_close_read (GVfsBackend *backend,
GVfsJobCloseRead *job,
GVfsBackendHandle handle)
{
GError *error = NULL;
if (g_input_stream_close (handle, G_VFS_JOB (job)->cancellable, &error))
{
g_vfs_job_succeeded (G_VFS_JOB (job));
g_object_unref (handle);
return TRUE;
}
g_object_unref (handle);
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
g_error_free (error);
return TRUE;
}
static gboolean
trash_backend_seek_on_read (GVfsBackend *backend,
GVfsJobSeekRead *job,
GVfsBackendHandle handle,
goffset offset,
GSeekType type)
{
GError *error = NULL;
if (g_seekable_seek (handle, offset, type, NULL, &error))
{
g_vfs_job_seek_read_set_offset (job, g_seekable_tell (handle));
g_vfs_job_succeeded (G_VFS_JOB (job));
return TRUE;
}
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
g_error_free (error);
return TRUE;
}
static void
mount_mountable_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GVfsBackendAfpBrowse *afp_backend = G_VFS_BACKEND_AFP_BROWSE (source_object);
GVfsJobMountMountable *job = G_VFS_JOB_MOUNT_MOUNTABLE (user_data);
GError *err;
GVfsAfpVolumeData *vol_data;
GMountSpec *mount_spec;
if (!update_cache_finish (afp_backend, res, &err))
{
g_vfs_job_failed_from_error (G_VFS_JOB (job), err);
g_error_free (err);
return;
}
vol_data = find_volume (afp_backend, job->filename);
if (!vol_data)
{
g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
_("File doesn't exist"));
return;
}
mount_spec = g_mount_spec_new ("afp-volume");
g_mount_spec_set (mount_spec, "host",
g_network_address_get_hostname (G_NETWORK_ADDRESS (afp_backend->addr)));
g_mount_spec_set (mount_spec, "volume", vol_data->name);
g_mount_spec_set (mount_spec, "user", afp_backend->logged_in_user);
g_vfs_job_mount_mountable_set_target (job, mount_spec, "/", TRUE);
g_mount_spec_unref (mount_spec);
g_vfs_job_succeeded (G_VFS_JOB (job));
}
static gboolean
trash_backend_query_info (GVfsBackend *vfs_backend,
GVfsJobQueryInfo *job,
const char *filename,
GFileQueryInfoFlags flags,
GFileInfo *info,
GFileAttributeMatcher *matcher)
{
GVfsBackendTrash *backend = G_VFS_BACKEND_TRASH (vfs_backend);
g_assert (filename[0] == '/');
if (filename[1])
{
GError *error = NULL;
gboolean is_toplevel;
TrashItem *item;
GFile *real;
real = trash_backend_get_file (backend, filename,
&item, &is_toplevel, &error);
if (real)
{
GFileInfo *real_info;
real_info = g_file_query_info (real,
job->attributes,
flags,
G_VFS_JOB (job)->cancellable,
&error);
g_object_unref (real);
if (real_info)
{
g_file_info_copy_into (real_info, info);
trash_backend_add_info (item, info, is_toplevel);
g_vfs_job_succeeded (G_VFS_JOB (job));
trash_item_unref (item);
g_object_unref (real_info);
return TRUE;
}
trash_item_unref (item);
}
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
g_error_free (error);
}
else
{
GIcon *icon;
int n_items;
n_items = trash_root_get_n_items (backend->root);
g_file_info_set_file_type (info, G_FILE_TYPE_DIRECTORY);
g_file_info_set_name (info, "/");
/* Translators: this is the display name of the backend */
g_file_info_set_display_name (info, _("Trash"));
g_file_info_set_content_type (info, "inode/directory");
icon = g_themed_icon_new (n_items ? "user-trash-full" : "user-trash");
g_file_info_set_icon (info, icon);
g_object_unref (icon);
icon = g_themed_icon_new (n_items ? "user-trash-full-symbolic" : "user-trash-symbolic");
g_file_info_set_symbolic_icon (info, icon);
g_object_unref (icon);
g_file_info_set_attribute_uint32 (info, G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT, n_items);
g_vfs_job_succeeded (G_VFS_JOB (job));
}
return TRUE;
}
static gboolean
trash_backend_pull (GVfsBackend *vfs_backend,
GVfsJobPull *job,
const gchar *source,
const gchar *local_path,
GFileCopyFlags flags,
gboolean remove_source,
GFileProgressCallback progress_callback,
gpointer progress_callback_data)
{
GVfsBackendTrash *backend = G_VFS_BACKEND_TRASH (vfs_backend);
GError *error = NULL;
if (source[1] == '\0')
g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
_("The trash folder may not be deleted"));
else
{
gboolean is_toplevel;
TrashItem *item;
GFile *real;
real = trash_backend_get_file (backend, source, &item,
&is_toplevel, &error);
if (real)
{
if (remove_source && !is_toplevel)
g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,
_("Items in the trash may not be modified"));
else
{
GFile *destination;
gboolean it_worked;
destination = g_file_new_for_path (local_path);
if (remove_source)
it_worked = trash_item_restore (item, destination, flags, &error);
else
it_worked = g_file_copy (real, destination, flags,
G_VFS_JOB (job)->cancellable,
progress_callback, progress_callback_data, &error);
g_object_unref (destination);
if (it_worked)
{
g_vfs_job_succeeded (G_VFS_JOB (job));
trash_item_unref (item);
g_object_unref (real);
return TRUE;
}
}
trash_item_unref (item);
g_object_unref (real);
}
}
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
g_error_free (error);
return TRUE;
}
static gboolean
recent_backend_query_info (GVfsBackend *vfs_backend,
GVfsJobQueryInfo *job,
const char *filename,
GFileQueryInfoFlags flags,
GFileInfo *info,
GFileAttributeMatcher *matcher)
{
GVfsBackendRecent *backend = G_VFS_BACKEND_RECENT (vfs_backend);
g_assert (filename[0] == '/');
if (filename[1])
{
GError *error = NULL;
RecentItem *item = NULL;
GFile *real;
real = recent_backend_get_file (backend, filename, &item, &error);
if (real)
{
GFileInfo *real_info;
real_info = g_file_query_info (real,
job->attributes,
flags,
G_VFS_JOB (job)->cancellable,
&error);
g_object_unref (real);
if (real_info)
{
g_file_info_copy_into (real_info, info);
recent_backend_add_info (item, info);
g_vfs_job_succeeded (G_VFS_JOB (job));
g_object_unref (real_info);
return TRUE;
}
}
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
g_error_free (error);
}
else
{
GIcon *icon;
g_file_info_set_file_type (info, G_FILE_TYPE_DIRECTORY);
g_file_info_set_name (info, "/");
/* Translators: this is the display name of the backend */
g_file_info_set_display_name (info, _("Recent"));
g_file_info_set_content_type (info, "inode/directory");
g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE, FALSE);
g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE, TRUE);
g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH, FALSE);
icon = g_themed_icon_new ("document-open-recent");
g_file_info_set_icon (info, icon);
g_object_unref (icon);
icon = g_themed_icon_new ("document-open-recent-symbolic");
g_file_info_set_symbolic_icon (info, icon);
g_object_unref (icon);
g_vfs_job_succeeded (G_VFS_JOB (job));
}
return TRUE;
}
