static gboolean
open_idle_cb (gpointer data)
{
GVfsJobOpenForRead *job = data;
int fd;
if (g_vfs_job_is_cancelled (G_VFS_JOB (job)))
{
g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR,
G_IO_ERROR_CANCELLED,
_("Operation was cancelled"));
return FALSE;
}
fd = g_open (job->filename, O_RDONLY);
if (fd == -1)
{
int errsv = errno;
g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR,
g_io_error_from_errno (errsv),
"Error opening file %s: %s",
job->filename, g_strerror (errsv));
}
else
{
g_vfs_job_open_for_read_set_can_seek (job, TRUE);
g_vfs_job_open_for_read_set_handle (job, GINT_TO_POINTER (fd));
g_vfs_job_succeeded (G_VFS_JOB (job));
}
return FALSE;
}
static gboolean
try_mount (GVfsBackend *backend,
GVfsJobMount *job,
GMountSpec *mount_spec,
GMountSource *mount_source,
gboolean is_automount)
{
GVfsBackendAfpBrowse *afp_backend = G_VFS_BACKEND_AFP_BROWSE (backend);
const char *host, *portstr, *user;
guint16 port = 548;
host = g_mount_spec_get (mount_spec, "host");
if (host == NULL)
{
g_vfs_job_failed (G_VFS_JOB (job),
G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("No hostname specified"));
return TRUE;
}
portstr = g_mount_spec_get (mount_spec, "port");
if (portstr != NULL)
{
port = atoi (portstr);
}
afp_backend->addr = G_NETWORK_ADDRESS (g_network_address_new (host, port));
user = g_mount_spec_get (mount_spec, "user");
afp_backend->user = g_strdup (user);
return FALSE;
}
static void
do_query_info_on_read (GVfsBackend *backend,
GVfsJobQueryInfoRead *job,
GVfsBackendHandle handle,
GFileInfo *info,
GFileAttributeMatcher *attribute_matcher)
{
int fd, res;
struct stat statbuf;
fd = GPOINTER_TO_INT (handle);
res = fstat (fd, &statbuf);
if (res == -1)
{
int errsv = errno;
g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR,
g_io_error_from_errno (errsv),
"Error querying info in file: %s",
g_strerror (errsv));
}
else
{
g_file_info_set_size (info, statbuf.st_size);
g_file_info_set_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_DEVICE,
statbuf.st_dev);
g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED, statbuf.st_mtime);
g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_ACCESS, statbuf.st_atime);
g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_CHANGED, statbuf.st_ctime);
g_vfs_job_succeeded (G_VFS_JOB (job));
}
}
static void
do_seek_on_read (GVfsBackend *backend,
GVfsJobSeekRead *job,
GVfsBackendHandle handle,
goffset offset,
GSeekType type)
{
int whence;
int fd;
off_t final_offset;
g_print ("seek_on_read (%d, %u)\n", (int)offset, type);
if ((whence = gvfs_seek_type_to_lseek (type)) == -1)
whence = SEEK_SET;
fd = GPOINTER_TO_INT (handle);
final_offset = lseek (fd, offset, whence);
if (final_offset == (off_t)-1)
{
int errsv = errno;
g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR,
g_io_error_from_errno (errsv),
"Error seeking in file: %s",
g_strerror (errsv));
}
else
{
g_vfs_job_seek_read_set_offset (job, offset);
g_vfs_job_succeeded (G_VFS_JOB (job));
}
}
static gboolean
read_idle_cb (gpointer data)
{
GVfsJobRead *job = data;
int fd;
ssize_t res;
fd = GPOINTER_TO_INT (job->handle);
res = read (fd, job->buffer, job->bytes_requested);
if (res == -1)
{
int errsv = errno;
g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR,
g_io_error_from_errno (errsv),
"Error reading from file: %s",
g_strerror (errsv));
}
else
{
g_vfs_job_read_set_size (job, res);
g_vfs_job_succeeded (G_VFS_JOB (job));
}
return FALSE;
}
static void
read_cancelled_cb (GVfsJob *job, gpointer data)
{
guint tag = GPOINTER_TO_INT (job->backend_data);
g_source_remove (tag);
g_vfs_job_failed (job, G_IO_ERROR,
G_IO_ERROR_CANCELLED,
_("Operation was cancelled"));
}
void
http_job_failed (GVfsJob *job, SoupMessage *msg)
{
switch (msg->status_code) {
case SOUP_STATUS_NOT_FOUND:
g_vfs_job_failed_literal (job, G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
msg->reason_phrase);
break;
case SOUP_STATUS_UNAUTHORIZED:
case SOUP_STATUS_PAYMENT_REQUIRED:
case SOUP_STATUS_FORBIDDEN:
g_vfs_job_failed (job, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,
_("HTTP Client Error: %s"), msg->reason_phrase);
break;
default:
g_vfs_job_failed (job, G_IO_ERROR, G_IO_ERROR_FAILED,
_("HTTP Error: %s"), msg->reason_phrase);
}
}
static void
open_read_cancelled_cb (GVfsJob *job, gpointer data)
{
guint tag = GPOINTER_TO_INT (data);
g_print ("open_read_cancelled_cb\n");
if (g_source_remove (tag))
g_vfs_job_failed (job, G_IO_ERROR,
G_IO_ERROR_CANCELLED,
_("Operation was cancelled"));
}
static gboolean
try_mount (GVfsBackend *backend,
GVfsJobMount *job,
GMountSpec *mount_spec,
GMountSource *mount_source,
gboolean is_automount)
{
GVfsBackendHttp *op_backend;
const char *uri_str;
char *path;
SoupURI *uri;
GMountSpec *real_mount_spec;
op_backend = G_VFS_BACKEND_HTTP (backend);
uri = NULL;
uri_str = g_mount_spec_get (mount_spec, "uri");
if (uri_str)
uri = soup_uri_new (uri_str);
g_debug ("+ try_mount: %s\n", uri_str ? uri_str : "(null)");
if (uri == NULL)
{
g_vfs_job_failed (G_VFS_JOB (job),
G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("Invalid mount spec"));
return TRUE;
}
real_mount_spec = g_mount_spec_new ("http");
g_mount_spec_set (real_mount_spec, "uri", uri_str);
if (uri->path != NULL)
{
path = g_uri_unescape_string (uri->path, "/");
g_free (real_mount_spec->mount_prefix);
real_mount_spec->mount_prefix = g_mount_spec_canonicalize_path (path);
g_free (path);
}
g_vfs_backend_set_mount_spec (backend, real_mount_spec);
op_backend->mount_base = uri;
g_vfs_job_succeeded (G_VFS_JOB (job));
return TRUE;
}
static gboolean
try_mount_mountable (GVfsBackend *backend,
GVfsJobMountMountable *job,
const char *filename,
GMountSource *mount_source)
{
GVfsBackendAfpBrowse *afp_backend = G_VFS_BACKEND_AFP_BROWSE (backend);
if (is_root (filename))
{
g_vfs_job_failed (G_VFS_JOB (job),
G_IO_ERROR, G_IO_ERROR_NOT_MOUNTABLE_FILE,
_("The file is not a mountable"));
return TRUE;
}
update_cache (afp_backend, G_VFS_JOB (job)->cancellable, mount_mountable_cb, job);
return TRUE;
}
static gboolean
try_enumerate (GVfsBackend *backend,
GVfsJobEnumerate *job,
const char *filename,
GFileAttributeMatcher *attribute_matcher,
GFileQueryInfoFlags flags)
{
GVfsBackendAfpBrowse *afp_backend = G_VFS_BACKEND_AFP_BROWSE (backend);
if (!is_root(filename))
{
g_vfs_job_failed (G_VFS_JOB (job),
G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
_("File doesn't exist"));
return TRUE;
}
update_cache (afp_backend, G_VFS_JOB (job)->cancellable,
enumerate_cache_updated_cb, job);
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));
}
