GMountSpec *
g_mount_spec_from_dbus (GVariant *value)
{
GMountSpec *spec;
const gchar *key;
const gchar *mount_prefix;
GVariantIter *iter_mount_spec_items;
GVariant *v;
mount_prefix = NULL;
g_variant_get (value, "(^&aya{sv})",
&mount_prefix,
&iter_mount_spec_items);
spec = g_mount_spec_new (NULL);
g_free (spec->mount_prefix);
spec->mount_prefix = NULL;
if (mount_prefix && mount_prefix[0])
spec->mount_prefix = g_strdup (mount_prefix);
while (g_variant_iter_loop (iter_mount_spec_items, "{&sv}", &key, &v))
{
add_item (spec, key, g_variant_dup_bytestring (v, NULL));
}
g_variant_iter_free (iter_mount_spec_items);
/* Sort on key */
g_array_sort (spec->items, item_compare);
return spec;
}
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
g_vfs_backend_test_init (GVfsBackendTest *test_backend)
{
GVfsBackend *backend = G_VFS_BACKEND (test_backend);
GMountSpec *mount_spec;
g_vfs_backend_set_display_name (backend, "test");
mount_spec = g_mount_spec_new ("test");
g_vfs_backend_set_mount_spec (backend, mount_spec);
g_mount_spec_unref (mount_spec);
}
GMountSpec *
g_mount_spec_from_dbus (DBusMessageIter *iter)
{
GMountSpec *spec;
DBusMessageIter array_iter, struct_iter, spec_iter;
const char *key;
char *value;
char *mount_prefix;
if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_STRUCT)
return NULL;
dbus_message_iter_recurse (iter, &spec_iter);
mount_prefix = NULL;
if (!_g_dbus_message_iter_get_args (&spec_iter, NULL,
G_DBUS_TYPE_CSTRING, &mount_prefix,
0))
return NULL;
spec = g_mount_spec_new (NULL);
g_free (spec->mount_prefix);
spec->mount_prefix = mount_prefix;
if (dbus_message_iter_get_arg_type (&spec_iter) != DBUS_TYPE_ARRAY ||
dbus_message_iter_get_element_type (&spec_iter) != DBUS_TYPE_STRUCT)
{
g_mount_spec_unref (spec);
return NULL;
}
dbus_message_iter_recurse (&spec_iter, &array_iter);
while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_STRUCT)
{
dbus_message_iter_recurse (&array_iter, &struct_iter);
if (_g_dbus_message_iter_get_args (&struct_iter, NULL,
DBUS_TYPE_STRING, &key,
G_DBUS_TYPE_CSTRING, &value,
0))
add_item (spec, key, value);
dbus_message_iter_next (&array_iter);
}
dbus_message_iter_next (iter);
/* Sort on key */
g_array_sort (spec->items, item_compare);
return spec;
}
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 void
fill_info (GFileInfo *info, GVfsAfpVolumeData *vol_data, GVfsBackendAfpBrowse *afp_backend)
{
GIcon *icon;
GMountSpec *mount_spec;
char *uri;
g_file_info_set_name (info, vol_data->name);
g_file_info_set_display_name (info, vol_data->name);
g_file_info_set_edit_name (info, vol_data->name);
g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL, TRUE);
g_file_info_set_content_type (info, "inode/directory");
g_file_info_set_file_type (info, G_FILE_TYPE_MOUNTABLE);
g_file_info_set_attribute_boolean (info, "afp::volume-password-protected", (vol_data->flags & 0x01));
icon = g_themed_icon_new_with_default_fallbacks ("folder-remote-afp");
g_file_info_set_icon (info, icon);
g_object_unref (icon);
icon = g_themed_icon_new_with_default_fallbacks ("folder-remote-symbolic");
g_file_info_set_symbolic_icon (info, icon);
g_object_unref (icon);
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);
if (g_mount_tracker_has_mount_spec (afp_backend->mount_tracker, mount_spec))
{
g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT, FALSE);
g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT, TRUE);
}
else
{
g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT, TRUE);
g_file_info_set_attribute_boolean(info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT, FALSE);
}
g_mount_spec_unref (mount_spec);
uri = g_strdup_printf ("afp://%s/%s",
g_network_address_get_hostname (G_NETWORK_ADDRESS (afp_backend->addr)),
vol_data->name);
g_file_info_set_attribute_string (info, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI,
uri);
g_free (uri);
}
static void
g_vfs_backend_trash_init (GVfsBackendTrash *backend)
{
GVfsBackend *vfs_backend = G_VFS_BACKEND (backend);
GMountSpec *mount_spec;
/* translators: This is the name of the backend */
g_vfs_backend_set_display_name (vfs_backend, _("Trash"));
g_vfs_backend_set_icon_name (vfs_backend, "user-trash");
g_vfs_backend_set_symbolic_icon_name (vfs_backend, "user-trash-symbolic");
g_vfs_backend_set_user_visible (vfs_backend, FALSE);
mount_spec = g_mount_spec_new ("trash");
g_vfs_backend_set_mount_spec (vfs_backend, mount_spec);
g_mount_spec_unref (mount_spec);
}
GMountSpec *
g_mount_spec_copy (GMountSpec *spec)
{
GMountSpec *copy;
int i;
copy = g_mount_spec_new (NULL);
g_mount_spec_set_mount_prefix (copy, spec->mount_prefix);
for (i = 0; i < spec->items->len; i++)
{
GMountSpecItem *item = &g_array_index (spec->items, GMountSpecItem, i);
g_mount_spec_set (copy, item->key, item->value);
}
return copy;
}
static void
g_vfs_backend_recent_init (GVfsBackendRecent *backend)
{
GVfsBackend *vfs_backend = G_VFS_BACKEND (backend);
GMountSpec *mount_spec;
backend->items = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, (GDestroyNotify)recent_item_free);
backend->uri_map = g_hash_table_new (g_str_hash, g_str_equal);
gtk_init (NULL, NULL);
/* translators: This is the name of the backend */
g_vfs_backend_set_display_name (vfs_backend, _("Recent"));
g_vfs_backend_set_icon_name (vfs_backend, "document-open-recent");
g_vfs_backend_set_symbolic_icon_name (vfs_backend, "document-open-recent-symbolic");
g_vfs_backend_set_user_visible (vfs_backend, FALSE);
mount_spec = g_mount_spec_new ("recent");
g_vfs_backend_set_mount_spec (vfs_backend, mount_spec);
g_mount_spec_unref (mount_spec);
}
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));
}
GMountSpec *
daemon_parse_args (int argc, char *argv[], const char *default_type)
{
GMountSpec *mount_spec;
if (argc > 1 && strcmp (argv[1], "--debug") == 0)
{
gvfs_set_debug (TRUE);
argc--;
argv++;
}
else if (g_getenv ("GVFS_DEBUG"))
{
gvfs_set_debug (TRUE);
}
mount_spec = NULL;
if (argc > 1 && strcmp (argv[1], "--spawner") == 0)
{
if (argc < 4)
{
g_printerr (_("Usage: %s --spawner dbus-id object_path"), argv[0]);
g_printerr ("\n");
exit (1);
}
spawner_id = argv[2];
spawner_path = argv[3];
}
else if (argc > 1 || default_type != NULL)
{
gboolean found_type;
int i;
mount_spec = g_mount_spec_new (default_type);
found_type = default_type != NULL;
for (i = 1; i < argc; i++)
{
char *p;
char *key;
p = strchr (argv[i], '=');
if (p == NULL || p[1] == 0 || p == argv[i])
{
g_printerr (_("Usage: %s key=value key=value …"), argv[0]);
g_printerr ("\n");
exit (1);
}
key = g_strndup (argv[i], p - argv[i]);
if (strcmp (key, "type") == 0)
found_type = TRUE;
g_mount_spec_set (mount_spec, key, p+1);
g_debug ("setting '%s' to '%s'\n", key, p+1);
g_free (key);
}
if (!found_type)
{
g_printerr (_("No mount type specified"));
g_printerr ("\n");
g_printerr (_("Usage: %s key=value key=value …"), argv[0]);
g_printerr ("\n");
exit (1);
}
}
return mount_spec;
}
