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);
}
static void
g_vfs_icon_finalize (GObject *object)
{
GVfsIcon *vfs_icon;
vfs_icon = G_VFS_ICON (object);
if (vfs_icon->mount_spec != NULL)
g_mount_spec_unref (vfs_icon->mount_spec);
g_free (vfs_icon->icon_id);
G_OBJECT_CLASS (g_vfs_icon_parent_class)->finalize (object);
}
static void
spawned_succeeded_cb (gpointer user_data)
{
DaemonData *data = user_data;
GMountSource *mount_source;
if (data->mount_spec)
{
mount_source = g_mount_source_new_dummy ();
g_vfs_daemon_initiate_mount (data->daemon, data->mount_spec, mount_source, FALSE, NULL, NULL);
g_mount_spec_unref (data->mount_spec);
g_object_unref (mount_source);
}
}
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 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);
}
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 GIcon *
g_vfs_icon_from_tokens (gchar **tokens,
gint num_tokens,
gint version,
GError **error)
{
GMountSpec *mount_spec;
GIcon *icon;
icon = NULL;
if (version != 0)
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Can't handle version %d of GVfsIcon encoding"),
version);
goto out;
}
if (num_tokens != 2)
{
g_set_error_literal (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Malformed input data for GVfsIcon"));
goto out;
}
mount_spec = g_mount_spec_new_from_string (tokens[0], error);
if (mount_spec == NULL)
goto out;
icon = g_vfs_icon_new (mount_spec, tokens[1]);
g_mount_spec_unref (mount_spec);
out:
return icon;
}
GIcon *
g_vfs_icon_deserialize (GVariant *value)
{
const gchar *mount_spec_str;
const gchar *id_str;
GMountSpec *mount_spec;
GIcon *icon;
if (!g_variant_is_of_type (value, G_VARIANT_TYPE ("(ss)")))
return NULL;
g_variant_get (value, "(&s&s)", &mount_spec_str, &id_str);
mount_spec = g_mount_spec_new_from_string (mount_spec_str, NULL);
if (mount_spec == NULL)
return NULL;
icon = g_vfs_icon_new (mount_spec, id_str);
g_mount_spec_unref (mount_spec);
return icon;
}
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));
}
void
daemon_main (int argc,
char *argv[],
int max_job_threads,
const char *default_type,
const char *mountable_name,
const char *first_type_name,
...)
{
va_list var_args;
DBusConnection *connection;
GMainLoop *loop;
GVfsDaemon *daemon;
DBusError derror;
GMountSpec *mount_spec;
GMountSource *mount_source;
GError *error;
int res;
const char *type;
dbus_error_init (&derror);
connection = dbus_bus_get (DBUS_BUS_SESSION, &derror);
if (connection == NULL)
{
g_printerr (_("Error connecting to D-Bus: %s"), derror.message);
g_printerr ("\n");
dbus_error_free (&derror);
exit (1);
}
mount_spec = daemon_parse_args (argc, argv, default_type);
va_start (var_args, first_type_name);
type = first_type_name;
while (type != NULL)
{
GType backend_type = va_arg (var_args, GType);
g_vfs_register_backend (backend_type, type);
type = va_arg (var_args, char *);
}
error = NULL;
if (mountable_name)
{
res = dbus_bus_request_name (connection,
mountable_name,
0, &derror);
if (res != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
{
if (res == -1)
_g_error_from_dbus (&derror, &error);
else
g_set_error (&error, G_IO_ERROR, G_IO_ERROR_FAILED,
_("mountpoint for %s already running"), mountable_name);
send_spawned (connection, FALSE, error->message);
g_error_free (error);
exit (1);
}
}
daemon = g_vfs_daemon_new (FALSE, FALSE);
if (daemon == NULL)
{
send_spawned (connection, FALSE, _("error starting mount daemon"));
exit (1);
}
g_vfs_daemon_set_max_threads (daemon, max_job_threads);
send_spawned (connection, TRUE, NULL);
if (mount_spec)
{
mount_source = g_mount_source_new_dummy ();
g_vfs_daemon_initiate_mount (daemon, mount_spec, mount_source, FALSE, NULL);
g_mount_spec_unref (mount_spec);
g_object_unref (mount_source);
}
loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (loop);
}
