Allow multiple backend in one daemon

Original git commit by Alexander Larsson <alex@greebo.(none)> at 1164972080 +0100

svn path=/trunk/; revision=207

21 files changed, 311 insertions, 177 deletions

diff --git a/daemon/gvfsbackend.c b/daemon/gvfsbackend.c
index 573d13c6..ddf8bce4 100644
--- a/daemon/gvfsbackend.c
+++ b/daemon/gvfsbackend.c
@@ -36,6 +36,20 @@ g_vfs_backend_init (GVfsBackend *backend)
 {
 }
 
+void
+g_vfs_backend_set_mountpoint (GVfsBackend *backend,
+			      const char  *mountpoint)
+{
+  g_free (backend->mountpoint);
+  backend->mountpoint = g_strdup (mountpoint);
+}
+
+const char *
+g_vfs_backend_get_mountpoint (GVfsBackend *backend)
+{
+  return backend->mountpoint;
+}
+
 gboolean
 g_vfs_backend_open_for_read (GVfsBackend *backend,
 			     GVfsJobOpenForRead *job,
@@ -51,7 +65,7 @@ g_vfs_backend_open_for_read (GVfsBackend *backend,
 gboolean
 g_vfs_backend_close_read (GVfsBackend        *backend,
 			  GVfsJobCloseRead   *job,
-			  GVfsHandle         *handle)
+			  GVfsBackendHandle   handle)
 {
   GVfsBackendClass *class;
 
@@ -63,7 +77,7 @@ g_vfs_backend_close_read (GVfsBackend        *backend,
 gboolean
 g_vfs_backend_read (GVfsBackend *backend,
 		    GVfsJobRead *job,
-		    GVfsHandle *handle,
+		    GVfsBackendHandle handle,
 		    char *buffer,
 		    gsize bytes_requested)
 {
@@ -78,7 +92,7 @@ g_vfs_backend_read (GVfsBackend *backend,
 gboolean
 g_vfs_backend_seek_on_read  (GVfsBackend        *backend,
 			     GVfsJobSeekRead    *job,
-			     GVfsHandle         *handle,
+			     GVfsBackendHandle   handle,
 			     goffset             offset,
 			     GSeekType           type)
 {
diff --git a/daemon/gvfsbackend.h b/daemon/gvfsbackend.h
index 0f7e385c..a0cfc590 100644
--- a/daemon/gvfsbackend.h
+++ b/daemon/gvfsbackend.h
@@ -17,11 +17,12 @@ G_BEGIN_DECLS
 /* GVfsBackend defined in gvfsdaemon.h to fix circular defines */
 typedef struct _GVfsBackendClass   GVfsBackendClass;
 
-typedef gpointer GVfsHandle;
+typedef gpointer GVfsBackendHandle;
 
 struct _GVfsBackend
 {
   GObject parent_instance;
+  char *mountpoint;
 };
 
 struct _GVfsBackendClass
@@ -43,35 +44,39 @@ struct _GVfsBackendClass
 			     char *filename);
   gboolean (*close_read)    (GVfsBackend *backend,
 			     GVfsJobCloseRead *job,
-			     GVfsHandle *handle);
+			     GVfsBackendHandle handle);
   gboolean (*read)          (GVfsBackend *backend,
 			     GVfsJobRead *job,
-			     GVfsHandle *handle,
+			     GVfsBackendHandle handle,
 			     char *buffer,
 			     gsize bytes_requested);
   gboolean (*seek_on_read)  (GVfsBackend *backend,
 			     GVfsJobSeekRead *job,
-			     GVfsHandle *handle,
+			     GVfsBackendHandle handle,
 			     goffset    offset,
 			     GSeekType  type);
 };
 
 GType g_vfs_backend_get_type (void) G_GNUC_CONST;
 
+void        g_vfs_backend_set_mountpoint (GVfsBackend *backend,
+					  const char  *mountpoint);
+const char *g_vfs_backend_get_mountpoint (GVfsBackend *backend);
+
 gboolean g_vfs_backend_open_for_read (GVfsBackend        *backend,
 				      GVfsJobOpenForRead *job,
 				      char               *filename);
 gboolean g_vfs_backend_close_read    (GVfsBackend        *backend,
 				      GVfsJobCloseRead   *job,
-				      GVfsHandle         *handle);
+				      GVfsBackendHandle   handle);
 gboolean g_vfs_backend_read          (GVfsBackend        *backend,
 				      GVfsJobRead        *job,
-				      GVfsHandle         *handle,
+				      GVfsBackendHandle   handle,
 				      char               *buffer,
 				      gsize               bytes_requested);
 gboolean g_vfs_backend_seek_on_read  (GVfsBackend        *backend,
 				      GVfsJobSeekRead    *job,
-				      GVfsHandle         *handle,
+				      GVfsBackendHandle   handle,
 				      goffset             offset,
 				      GSeekType           type);
 
diff --git a/daemon/gvfsbackendtest.c b/daemon/gvfsbackendtest.c
index 1ae93d81..92b6ffc6 100644
--- a/daemon/gvfsbackendtest.c
+++ b/daemon/gvfsbackendtest.c
@@ -32,6 +32,7 @@ g_vfs_backend_test_finalize (GObject *object)
 static void
 g_vfs_backend_test_init (GVfsBackendTest *backend)
 {
+  g_vfs_backend_set_mountpoint (G_VFS_BACKEND (backend), "foo://");
 }
 
 GVfsBackendTest *
@@ -129,7 +130,7 @@ read_cancelled_cb (GVfsJob *job, gpointer data)
 static gboolean
 do_read (GVfsBackend *backend,
 	 GVfsJobRead *job,
-	 GVfsHandle *handle,
+	 GVfsBackendHandle handle,
 	 char *buffer,
 	 gsize bytes_requested)
 {
@@ -147,7 +148,7 @@ do_read (GVfsBackend *backend,
 static gboolean
 do_seek_on_read (GVfsBackend *backend,
 		 GVfsJobSeekRead *job,
-		 GVfsHandle *handle,
+		 GVfsBackendHandle handle,
 		 goffset    offset,
 		 GSeekType  type)
 {
@@ -195,7 +196,7 @@ do_seek_on_read (GVfsBackend *backend,
 static gboolean
 do_close_read (GVfsBackend *backend,
 	       GVfsJobCloseRead *job,
-	       GVfsHandle *handle)
+	       GVfsBackendHandle handle)
 {
   int fd;
 
diff --git a/daemon/gvfsdaemon.c b/daemon/gvfsdaemon.c
index e85b6736..9aa76dc2 100644
--- a/daemon/gvfsdaemon.c
+++ b/daemon/gvfsdaemon.c
@@ -18,14 +18,13 @@ G_DEFINE_TYPE (GVfsDaemon, g_vfs_daemon, G_TYPE_OBJECT);
 
 enum {
   PROP_0,
-  PROP_MOUNTPOINT
 };
 
 struct _GVfsDaemonPrivate
 {
+  GHashTable *backends; /* bus_name -> backend */
+
   GMutex *lock; /* protects the parts that are accessed by multiple threads */
-  char *mountpoint;
-  gboolean active;
 
   GQueue *pending_jobs; 
   GQueue *jobs; /* protected by lock */
@@ -53,9 +52,6 @@ static void g_vfs_daemon_set_property (GObject         *object,
 				       guint            prop_id,
 				       const GValue    *value,
 				       GParamSpec      *pspec);
-static GObject*g_vfs_daemon_constructor (GType                  type,
-					 guint                  n_construct_properties,
-					 GObjectConstructParam *construct_params);
 static void              daemon_unregistered_func (DBusConnection *conn,
 						   gpointer        data);
 static DBusHandlerResult daemon_message_func      (DBusConnection *conn,
@@ -85,11 +81,9 @@ g_vfs_daemon_finalize (GObject *object)
   g_queue_free (daemon->priv->jobs);
   g_queue_free (daemon->priv->pending_jobs);
 
-  g_object_unref (daemon->backend);
+  g_hash_table_destroy (daemon->priv->backends);
   g_mutex_free (daemon->priv->lock);
 
-  g_free (daemon->priv->mountpoint);
-
   if (G_OBJECT_CLASS (g_vfs_daemon_parent_class)->finalize)
     (*G_OBJECT_CLASS (g_vfs_daemon_parent_class)->finalize) (object);
 }
@@ -104,16 +98,6 @@ g_vfs_daemon_class_init (GVfsDaemonClass *klass)
   gobject_class->finalize = g_vfs_daemon_finalize;
   gobject_class->set_property = g_vfs_daemon_set_property;
   gobject_class->get_property = g_vfs_daemon_get_property;
-  gobject_class->constructor = g_vfs_daemon_constructor;
-
-  g_object_class_install_property (gobject_class,
-				   PROP_MOUNTPOINT,
-				   g_param_spec_string ("mountpoint",
-							"Mountpoint",
-							"Mountpoint of the daemon.",
-							NULL,
-							G_PARAM_READWRITE | 
-							G_PARAM_CONSTRUCT_ONLY));
 }
 
 static void
@@ -125,51 +109,12 @@ g_vfs_daemon_init (GVfsDaemon *daemon)
   daemon->priv->lock = g_mutex_new ();
   daemon->priv->jobs = g_queue_new ();
   daemon->priv->pending_jobs = g_queue_new ();
+  daemon->priv->backends = g_hash_table_new_full (g_str_hash,
+						  g_str_equal,
+						  g_free,
+						  g_object_unref);
 }
 
-static GObject*
-g_vfs_daemon_constructor (GType                  type,
-			  guint                  n_construct_properties,
-			  GObjectConstructParam *construct_params)
-{
-  DBusConnection *conn;
-  DBusError error;
-  GObject *object;
-  GVfsDaemon *daemon;
-  int ret;
-
-  object =
-    G_OBJECT_CLASS (g_vfs_daemon_parent_class)->constructor (type,
-							     n_construct_properties,
-							     construct_params);
-
-  daemon = G_VFS_DAEMON (object);
-
-  conn = dbus_bus_get (DBUS_BUS_SESSION, NULL);
-  
-  dbus_error_init (&error);
-
-  ret = dbus_bus_request_name (conn, daemon->priv->mountpoint, 0, &error);
-  if (ret != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
-    {
-      g_printerr ("Failed to acquire vfs-daemon service: %s", error.message);
-      dbus_error_free (&error);
-    }
-  else
-    {
-      if (!dbus_connection_register_object_path (conn,
-						 G_VFS_DBUS_DAEMON_PATH,
-						 &daemon_vtable,
-						 daemon))
-	g_printerr ("Failed to register object with D-BUS.\n");
-      else
-	daemon->priv->active = TRUE;
-    }
-  
-  return object;
-}
-
-
 static void
 g_vfs_daemon_set_property (GObject         *object,
 			   guint            prop_id,
@@ -177,17 +122,11 @@ g_vfs_daemon_set_property (GObject         *object,
 			   GParamSpec      *pspec)
 {
   GVfsDaemon *daemon;
-  gchar *tmp;
   
   daemon = G_VFS_DAEMON (object);
   
   switch (prop_id)
     {
-    case PROP_MOUNTPOINT:
-      tmp = daemon->priv->mountpoint;
-      daemon->priv->mountpoint = g_value_dup_string (value);
-      g_free (tmp);
-      break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
@@ -206,9 +145,6 @@ g_vfs_daemon_get_property (GObject    *object,
 
   switch (prop_id)
     {
-    case PROP_MOUNTPOINT:
-      g_value_set_string (value, daemon->priv->mountpoint);
-      break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
@@ -216,19 +152,55 @@ g_vfs_daemon_get_property (GObject    *object,
 }
 
 GVfsDaemon *
-g_vfs_daemon_new (const char *mountpoint,
-		  GVfsBackend *backend)
+g_vfs_daemon_new (void)
 {
   GVfsDaemon *daemon;
 
-  daemon = g_object_new (G_TYPE_VFS_DAEMON,
-			 "mountpoint", mountpoint,
-			 NULL);
-  daemon->backend = g_object_ref (backend);
-
+  daemon = g_object_new (G_TYPE_VFS_DAEMON, NULL);
   return daemon;
 }
 
+gboolean
+g_vfs_daemon_add_backend (GVfsDaemon  *daemon,
+			  GVfsBackend *backend)
+{
+  DBusConnection *conn;
+  const char *mountpoint;
+  char *bus_name;
+  int ret;
+  DBusError error;
+
+  mountpoint = g_vfs_backend_get_mountpoint (backend);
+  
+  g_assert (g_hash_table_lookup (daemon->priv->backends, mountpoint) == NULL);
+
+  conn = dbus_bus_get (DBUS_BUS_SESSION, NULL);
+  if (conn == NULL)
+    return FALSE;
+
+  bus_name = _g_dbus_bus_name_from_mountpoint (mountpoint);
+  g_print ("bus_name: %s, mountpoint: %s\n", bus_name, mountpoint);
+  dbus_error_init (&error);
+  ret = dbus_bus_request_name (conn, bus_name, 0, &error);
+  if (ret != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
+    {
+      g_printerr ("Failed to acquire vfs-daemon service: %s", error.message);
+      dbus_error_free (&error);
+      return FALSE;
+    }
+
+  if (!dbus_connection_register_object_path (conn,
+					     G_VFS_DBUS_DAEMON_PATH,
+					     &daemon_vtable,
+					     daemon))
+    g_error ("Failed to register object with D-BUS (oom).\n");
+  
+  g_hash_table_insert (daemon->priv->backends,
+		       bus_name,
+		       g_object_ref (backend));
+  return TRUE;
+}
+
 static gboolean
 start_jobs_at_idle (gpointer data)
 {
@@ -323,7 +295,8 @@ static void
 start_or_queue_job (GVfsDaemon *daemon,
 		    GVfsJob *job)
 {
-  g_vfs_job_set_backend (job, daemon->backend);
+  g_assert (job->backend != NULL);
+  
   g_mutex_lock (daemon->priv->lock);
   g_queue_push_tail (daemon->priv->jobs, job);
   g_mutex_unlock (daemon->priv->lock);
@@ -625,6 +598,19 @@ accept_new_fd_client (GIOChannel  *channel,
 }
 
 static void
+append_mountpoint_cb (gpointer       key,
+		      gpointer       value,
+		      gpointer       user_data)
+{
+  DBusMessageIter *array_iter = user_data;
+  char *mountpoint = key;
+
+  if (!dbus_message_iter_append_basic (array_iter,
+				       DBUS_TYPE_STRING, &mountpoint))
+    g_error ("Can't allocate dbus message");
+}
+
+static void
 daemon_handle_get_connection (DBusConnection *conn,
 			      DBusMessage *message,
 			      GVfsDaemon *daemon)
@@ -638,6 +624,7 @@ daemon_handle_get_connection (DBusConnection *conn,
   GIOChannel *channel;
   char *socket_dir;
   int fd;
+  DBusMessageIter iter, array_iter;
   
   generate_addresses (&address1, &address2, &socket_dir);
 
@@ -683,12 +670,31 @@ daemon_handle_get_connection (DBusConnection *conn,
   g_io_channel_unref (channel);
     
   reply = dbus_message_new_method_return (message);
-  if (reply && 
-      dbus_message_append_args (reply,
-				DBUS_TYPE_STRING, &address1,
-				DBUS_TYPE_STRING, &address2,
-				DBUS_TYPE_INVALID))
-    dbus_connection_send (conn, reply, NULL);
+  if (reply == NULL)
+    g_error ("Can't allocate dbus message\n");
+
+  if (!dbus_message_append_args (reply,
+				 DBUS_TYPE_STRING, &address1,
+				 DBUS_TYPE_STRING, &address2,
+				 DBUS_TYPE_INVALID))
+    g_error ("Can't allocate dbus message\n");
+
+  dbus_message_iter_init_append (reply, &iter);
+  
+  if (!dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
+					 DBUS_TYPE_STRING_AS_STRING,
+					 &array_iter))
+    g_error ("Can't allocate dbus message\n");
+
+  
+  g_hash_table_foreach (daemon->priv->backends,
+			append_mountpoint_cb,
+			&array_iter);
+  
+  if (!dbus_message_iter_close_container (&iter, &array_iter))
+    g_error ("Can't allocate dbus message\n");
+  
+  dbus_connection_send (conn, reply, NULL);
   
   dbus_message_unref (reply);
 
@@ -721,17 +727,31 @@ daemon_message_func (DBusConnection *conn,
 		     gpointer        data)
 {
   GVfsDaemon *daemon = data;
+  GVfsBackend *backend;
+  const char *dest;
   GVfsJob *job;
   
   job = NULL;
   if (dbus_message_is_method_call (message,
 				   G_VFS_DBUS_DAEMON_INTERFACE,
 				   G_VFS_DBUS_OP_GET_CONNECTION))
-    daemon_handle_get_connection (conn, message, daemon);
-  else if (dbus_message_is_method_call (message,
-					G_VFS_DBUS_DAEMON_INTERFACE,
-					G_VFS_DBUS_OP_OPEN_FOR_READ))
-    job = g_vfs_job_open_for_read_new (conn, message);
+    {
+      daemon_handle_get_connection (conn, message, daemon);
+      return DBUS_HANDLER_RESULT_HANDLED;
+    }
+
+  backend = NULL;
+  dest = dbus_message_get_destination (message);
+  if (dest != NULL)
+    backend = g_hash_table_lookup (daemon->priv->backends,
+				   dest);
+  if (backend == NULL)
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+  if (dbus_message_is_method_call (message,
+				   G_VFS_DBUS_DAEMON_INTERFACE,
+				   G_VFS_DBUS_OP_OPEN_FOR_READ))
+    job = g_vfs_job_open_for_read_new (conn, message, backend);
   else
     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
   
@@ -757,11 +777,3 @@ daemon_filter_func (DBusConnection *conn,
   
   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
-
-
-gboolean
- g_vfs_daemon_is_active (GVfsDaemon *daemon)
-{
-  return daemon->priv->active;
-}
-
diff --git a/daemon/gvfsdaemon.h b/daemon/gvfsdaemon.h
index 0e0e5167..7440d381 100644
--- a/daemon/gvfsdaemon.h
+++ b/daemon/gvfsdaemon.h
@@ -23,7 +23,6 @@ struct _GVfsDaemon
 {
   GObject parent_instance;
 
-  GVfsBackend *backend;
   GVfsDaemonPrivate *priv;
 };
 
@@ -37,9 +36,9 @@ struct _GVfsDaemonClass
 
 GType g_vfs_daemon_get_type (void) G_GNUC_CONST;
 
-GVfsDaemon *g_vfs_daemon_new (const char *mountpoint,
-			      GVfsBackend *backend);
-gboolean g_vfs_daemon_is_active (GVfsDaemon *daemon);
+GVfsDaemon *g_vfs_daemon_new         (void);
+gboolean    g_vfs_daemon_add_backend (GVfsDaemon  *daemon,
+				      GVfsBackend *backend);
 
 G_END_DECLS
 
diff --git a/daemon/gvfsdaemonutils.c b/daemon/gvfsdaemonutils.c
index 97e998e1..68dd5825 100644
--- a/daemon/gvfsdaemonutils.c
+++ b/daemon/gvfsdaemonutils.c
@@ -78,6 +78,63 @@ dbus_message_new_error_from_gerror (DBusMessage *message,
   return reply;
 }
 
+/* We use _ for escaping */
+#define VALID_INITIAL_BUS_NAME_CHARACTER(c)         \
+  ( ((c) >= 'A' && (c) <= 'Z') ||               \
+    ((c) >= 'a' && (c) <= 'z') ||               \
+   /*((c) == '_') || */((c) == '-'))
+#define VALID_BUS_NAME_CHARACTER(c)                 \
+  ( ((c) >= '0' && (c) <= '9') ||               \
+    ((c) >= 'A' && (c) <= 'Z') ||               \
+    ((c) >= 'a' && (c) <= 'z') ||               \
+   /*((c) == '_')||*/  ((c) == '-'))
+
+
+static void
+append_escaped_bus_name (GString *s,
+			 const char *unescaped)
+{
+  char c;
+  gboolean first;
+  static const gchar hex[16] = "0123456789ABCDEF";
+
+  while ((c = *unescaped++) != 0)
+    {
+      if (first)
+	{
+	  if (VALID_INITIAL_BUS_NAME_CHARACTER (c))
+	    {
+	      g_string_append_c (s, c);
+	      continue;
+	    }
+	}
+      else
+	{
+	  if (VALID_BUS_NAME_CHARACTER (c))
+	    {
+	      g_string_append_c (s, c);
+	      continue;
+	    }
+	}
+
+      first = FALSE;
+      g_string_append_c (s, '_');
+      g_string_append_c (s, hex[((guchar)c) >> 4]);
+      g_string_append_c (s, hex[((guchar)c) & 0xf]);
+    }
+}
+
+char *
+_g_dbus_bus_name_from_mountpoint (const char *mountpoint)
+{
+  GString *bus_name;
+  
+  bus_name = g_string_new (G_VFS_DBUS_MOUNTPOINT_NAME);
+  append_escaped_bus_name (bus_name, mountpoint);
+  return g_string_free (bus_name, FALSE);
+}
+
+
 static void
 free_extra (gpointer p)
 {
diff --git a/daemon/gvfsdaemonutils.h b/daemon/gvfsdaemonutils.h
index fcac685b..16b27bd9 100644
--- a/daemon/gvfsdaemonutils.h
+++ b/daemon/gvfsdaemonutils.h
@@ -17,6 +17,7 @@ gboolean     dbus_connection_send_fd            (DBusConnection  *connection,
 char *       g_error_to_daemon_reply            (GError          *error,
 						 guint32          seq_nr,
 						 gsize           *len_out);
+char *       _g_dbus_bus_name_from_mountpoint   (const char      *mountpoint);
 
 G_END_DECLS
 
diff --git a/daemon/gvfsjobcloseread.c b/daemon/gvfsjobcloseread.c
index b47217d3..19f600ef 100644
--- a/daemon/gvfsjobcloseread.c
+++ b/daemon/gvfsjobcloseread.c
@@ -47,15 +47,18 @@ g_vfs_job_close_read_init (GVfsJobCloseRead *job)
 
 GVfsJob *
 g_vfs_job_close_read_new (GVfsReadStream *stream,
-			  gpointer        handle)
+			  GVfsBackendHandle handle,
+			  GVfsBackend *backend)
 {
   GVfsJobCloseRead *job;
   
   job = g_object_new (G_TYPE_VFS_JOB_CLOSE_READ, NULL);
 
+  g_vfs_job_set_backend (G_VFS_JOB (job), backend);
+  
   job->stream = g_object_ref (stream);
   job->handle = handle;
- 
+  
   return G_VFS_JOB (job);
 }
 
diff --git a/daemon/gvfsjobcloseread.h b/daemon/gvfsjobcloseread.h
index 2d914863..c64be03b 100644
--- a/daemon/gvfsjobcloseread.h
+++ b/daemon/gvfsjobcloseread.h
@@ -22,7 +22,7 @@ struct _GVfsJobCloseRead
   GVfsJob parent_instance;
 
   GVfsReadStream *stream;
-  gpointer handle;
+  GVfsBackendHandle handle;
 };
 
 struct _GVfsJobCloseReadClass
@@ -33,7 +33,8 @@ struct _GVfsJobCloseReadClass
 GType g_vfs_job_close_read_get_type (void) G_GNUC_CONST;
 
 GVfsJob *g_vfs_job_close_read_new (GVfsReadStream    *stream,
-				   gpointer           handle);
+				   GVfsBackendHandle  handle,
+				   GVfsBackend       *backend);
 
 G_END_DECLS
 
diff --git a/daemon/gvfsjobopenforread.c b/daemon/gvfsjobopenforread.c
index a7cdea7b..9a9c16ca 100644
--- a/daemon/gvfsjobopenforread.c
+++ b/daemon/gvfsjobopenforread.c
@@ -60,7 +60,8 @@ g_vfs_job_open_for_read_init (GVfsJobOpenForRead *job)
 
 GVfsJob *
 g_vfs_job_open_for_read_new (DBusConnection *connection,
-			     DBusMessage *message)
+			     DBusMessage *message,
+			     GVfsBackend *backend)
 {
   GVfsJobOpenForRead *job;
   DBusMessage *reply;
@@ -85,6 +86,8 @@ g_vfs_job_open_for_read_new (DBusConnection *connection,
 
   job = g_object_new (G_TYPE_VFS_JOB_OPEN_FOR_READ, NULL);
 
+  g_vfs_job_set_backend (G_VFS_JOB (job), backend);
+  
   job->connection = dbus_connection_ref (connection);
   job->message = dbus_message_ref (message);
   job->filename = g_strndup (path_data, path_len);
@@ -104,7 +107,7 @@ start (GVfsJob *job)
 
 void
 g_vfs_job_open_for_read_set_handle (GVfsJobOpenForRead *job,
-				    GVfsHandle *handle)
+				    GVfsBackendHandle handle)
 {
   job->backend_handle = handle;
 }
@@ -134,7 +137,7 @@ create_reply (GVfsJob *job,
   g_assert (open_job->backend_handle != NULL);
 
   error = NULL;
-  stream = g_vfs_read_stream_new (&error);
+  stream = g_vfs_read_stream_new (job->backend, &error);
   if (stream == NULL)
     {
       reply = dbus_message_new_error_from_gerror (message, error);
@@ -162,7 +165,7 @@ create_reply (GVfsJob *job,
 				  DBUS_TYPE_BOOLEAN, &can_seek,
 				  DBUS_TYPE_INVALID);
 
-  g_vfs_read_stream_set_user_data (stream, open_job->backend_handle);
+  g_vfs_read_stream_set_backend_handle (stream, open_job->backend_handle);
   open_job->backend_handle = NULL;
   open_job->read_stream = stream;
   
diff --git a/daemon/gvfsjobopenforread.h b/daemon/gvfsjobopenforread.h
index 2b26a33b..c000446e 100644
--- a/daemon/gvfsjobopenforread.h
+++ b/daemon/gvfsjobopenforread.h
@@ -26,7 +26,7 @@ struct _GVfsJobOpenForRead
   DBusConnection *connection;
   DBusMessage *message;
   char *filename;
-  GVfsHandle *backend_handle;
+  GVfsBackendHandle backend_handle;
   gboolean can_seek;
   GVfsReadStream *read_stream;
 };
@@ -39,9 +39,10 @@ struct _GVfsJobOpenForReadClass
 GType g_vfs_job_open_for_read_get_type (void) G_GNUC_CONST;
 
 GVfsJob *       g_vfs_job_open_for_read_new          (DBusConnection     *connection,
-						      DBusMessage        *message);
+						      DBusMessage        *message,
+						      GVfsBackend        *backend);
 void            g_vfs_job_open_for_read_set_handle   (GVfsJobOpenForRead *job,
-						      GVfsHandle         *handle);
+						      GVfsBackendHandle   handle);
 void            g_vfs_job_open_for_read_set_can_seek (GVfsJobOpenForRead *job,
 						      gboolean            can_seek);
 GVfsReadStream *g_vfs_job_open_for_read_steal_stream (GVfsJobOpenForRead *job);
diff --git a/daemon/gvfsjobread.c b/daemon/gvfsjobread.c
index ac26969e..6b5fdcce 100644
--- a/daemon/gvfsjobread.c
+++ b/daemon/gvfsjobread.c
@@ -49,13 +49,16 @@ g_vfs_job_read_init (GVfsJobRead *job)
 
 GVfsJob *
 g_vfs_job_read_new (GVfsReadStream *stream,
-		    gpointer handle,
-		    gsize bytes_requested)
+		    GVfsBackendHandle handle,
+		    gsize bytes_requested,
+		    GVfsBackend *backend)
 {
   GVfsJobRead *job;
   
   job = g_object_new (G_TYPE_VFS_JOB_READ, NULL);
 
+  g_vfs_job_set_backend (G_VFS_JOB (job), backend);
+  
   job->stream = g_object_ref (stream);
   job->handle = handle;
   job->buffer = g_malloc (bytes_requested);
diff --git a/daemon/gvfsjobread.h b/daemon/gvfsjobread.h
index 8c414bca..9e40b6b9 100644
--- a/daemon/gvfsjobread.h
+++ b/daemon/gvfsjobread.h
@@ -22,7 +22,7 @@ struct _GVfsJobRead
   GVfsJob parent_instance;
 
   GVfsReadStream *stream;
-  gpointer handle;
+  GVfsBackendHandle handle;
   gsize bytes_requested;
   char *buffer;
   gsize data_count;
@@ -36,8 +36,9 @@ struct _GVfsJobReadClass
 GType g_vfs_job_read_get_type (void) G_GNUC_CONST;
 
 GVfsJob *g_vfs_job_read_new        (GVfsReadStream    *stream,
-				    gpointer           handle,
-				    gsize              bytes_requested);
+				    GVfsBackendHandle  handle,
+				    gsize              bytes_requested,
+				    GVfsBackend       *backend);
 void     g_vfs_job_read_set_size   (GVfsJobRead       *job,
 				    gsize              data_size);
 
diff --git a/daemon/gvfsjobseekread.c b/daemon/gvfsjobseekread.c
index 9b1ed3ff..c0ee0876 100644
--- a/daemon/gvfsjobseekread.c
+++ b/daemon/gvfsjobseekread.c
@@ -47,14 +47,17 @@ g_vfs_job_seek_read_init (GVfsJobSeekRead *job)
 
 GVfsJob *
 g_vfs_job_seek_read_new (GVfsReadStream *stream,
-			 gpointer           handle,
-			 GSeekType          seek_type,
-			 goffset            offset)
+			 GVfsBackendHandle handle,
+			 GSeekType seek_type,
+			 goffset offset,
+			 GVfsBackend *backend)
 {
   GVfsJobSeekRead *job;
   
   job = g_object_new (G_TYPE_VFS_JOB_SEEK_READ, NULL);
 
+  g_vfs_job_set_backend (G_VFS_JOB (job), backend);
+  
   job->stream = g_object_ref (stream);
   job->handle = handle;
   job->requested_offset = offset;
diff --git a/daemon/gvfsjobseekread.h b/daemon/gvfsjobseekread.h
index a18ef494..177c8769 100644
--- a/daemon/gvfsjobseekread.h
+++ b/daemon/gvfsjobseekread.h
@@ -22,7 +22,7 @@ struct _GVfsJobSeekRead
   GVfsJob parent_instance;
 
   GVfsReadStream *stream;
-  gpointer handle;
+  GVfsBackendHandle handle;
   GSeekType seek_type;
   goffset requested_offset;
   goffset final_offset;
@@ -36,9 +36,10 @@ struct _GVfsJobSeekReadClass
 GType g_vfs_job_seek_read_get_type (void) G_GNUC_CONST;
 
 GVfsJob *g_vfs_job_seek_read_new (GVfsReadStream    *stream,
-				  gpointer           handle,
+				  GVfsBackendHandle  handle,
 				  GSeekType          seek_type,
-				  goffset            offset);
+				  goffset            offset,
+				  GVfsBackend       *backend);
 
 void g_vfs_job_seek_read_set_offset (GVfsJobSeekRead *job,
 				     goffset offset);
diff --git a/daemon/gvfsreadstream.c b/daemon/gvfsreadstream.c
index 625ed8fb..41e9b3ea 100644
--- a/daemon/gvfsreadstream.c
+++ b/daemon/gvfsreadstream.c
@@ -45,13 +45,14 @@ typedef struct
 
 struct _GVfsReadStreamPrivate
 {
+  GVfsBackend *backend;
   gboolean connection_closed;
   GInputStream *command_stream;
   GOutputStream *reply_stream;
   int remote_fd;
   int seek_generation;
   
-  gpointer data; /* user data, i.e. GVfsHandle */
+  GVfsBackendHandle backend_handle;
   GVfsJob *current_job;
   guint32 current_job_seq_nr;
 
@@ -93,7 +94,7 @@ g_vfs_read_stream_finalize (GObject *object)
   if (read_stream->priv->remote_fd != -1)
     close (read_stream->priv->remote_fd);
 
-  g_assert (read_stream->priv->data == NULL);
+  g_assert (read_stream->priv->backend_handle == NULL);
   
   if (G_OBJECT_CLASS (g_vfs_read_stream_parent_class)->finalize)
     (*G_OBJECT_CLASS (g_vfs_read_stream_parent_class)->finalize) (object);
@@ -145,9 +146,9 @@ g_vfs_read_stream_connection_closed (GVfsReadStream *stream)
   stream->priv->connection_closed = TRUE;
   
   if (stream->priv->current_job == NULL &&
-      stream->priv->data != NULL)
+      stream->priv->backend_handle != NULL)
     {
-      stream->priv->current_job = g_vfs_job_close_read_new (stream, stream->priv->data);
+      stream->priv->current_job = g_vfs_job_close_read_new (stream, stream->priv->backend_handle, stream->priv->backend);
       stream->priv->current_job_seq_nr = 0;
       g_signal_emit (stream, signals[NEW_JOB], 0, stream->priv->current_job);
     }
@@ -185,12 +186,14 @@ got_command (GVfsReadStream *stream,
     {
     case G_VFS_DAEMON_SOCKET_PROTOCOL_REQUEST_READ:
       job = g_vfs_job_read_new (stream,
-				stream->priv->data,
-				arg1);
+				stream->priv->backend_handle,
+				arg1,
+				stream->priv->backend);
       break;
     case G_VFS_DAEMON_SOCKET_PROTOCOL_REQUEST_CLOSE:
       job = g_vfs_job_close_read_new (stream,
-				      stream->priv->data);
+				      stream->priv->backend_handle,
+				      stream->priv->backend);
       break;
     case G_VFS_DAEMON_SOCKET_PROTOCOL_REQUEST_SEEK_CUR:
     case G_VFS_DAEMON_SOCKET_PROTOCOL_REQUEST_SEEK_END:
@@ -203,9 +206,10 @@ got_command (GVfsReadStream *stream,
       
       stream->priv->seek_generation++;
       job = g_vfs_job_seek_read_new (stream,
-				     stream->priv->data,
+				     stream->priv->backend_handle,
 				     seek_type,
-				     ((goffset)arg1) | (((goffset)arg2) << 32));
+				     ((goffset)arg1) | (((goffset)arg2) << 32),
+				     stream->priv->backend);
       break;
       
     case G_VFS_DAEMON_SOCKET_PROTOCOL_REQUEST_CANCEL:
@@ -382,11 +386,12 @@ send_reply_cb (GOutputStream *output_stream,
   if (G_IS_VFS_JOB_CLOSE_READ (job))
     {
       g_signal_emit (stream, signals[CLOSED], 0);
-      stream->priv->data = NULL;
+      stream->priv->backend_handle = NULL;
     }
   else if (stream->priv->connection_closed)
     {
-      stream->priv->current_job = g_vfs_job_close_read_new (stream, stream->priv->data);
+      stream->priv->current_job = g_vfs_job_close_read_new (stream, stream->priv->backend_handle,
+							    stream->priv->backend);
       stream->priv->current_job_seq_nr = 0;
       g_signal_emit (stream, signals[NEW_JOB], 0, stream->priv->current_job);
     }
@@ -497,7 +502,8 @@ g_vfs_read_stream_send_data (GVfsReadStream  *read_stream,
 }
 
 GVfsReadStream *
-g_vfs_read_stream_new (GError **error)
+g_vfs_read_stream_new (GVfsBackend *backend,
+		       GError **error)
 {
   GVfsReadStream *stream;
   int socket_fds[2];
@@ -513,6 +519,7 @@ g_vfs_read_stream_new (GError **error)
     }
 
   stream = g_object_new (G_TYPE_VFS_READ_STREAM, NULL);
+  stream->priv->backend = backend;
   stream->priv->command_stream = g_input_stream_socket_new (socket_fds[0], TRUE);
   stream->priv->reply_stream = g_output_stream_socket_new (socket_fds[0], FALSE);
   stream->priv->remote_fd = socket_fds[1];
@@ -531,9 +538,15 @@ g_vfs_read_stream_steal_remote_fd (GVfsReadStream *stream)
   return fd;
 }
 
+GVfsBackend *
+g_vfs_read_stream_get_backend (GVfsReadStream  *read_stream)
+{
+  return read_stream->priv->backend;
+}
+
 void
-g_vfs_read_stream_set_user_data (GVfsReadStream *read_stream,
-				 gpointer data)
+g_vfs_read_stream_set_backend_handle (GVfsReadStream *read_stream,
+				      GVfsBackendHandle backend_handle)
 {
-  read_stream->priv->data = data;
+  read_stream->priv->backend_handle = backend_handle;
 }
diff --git a/daemon/gvfsreadstream.h b/daemon/gvfsreadstream.h
index 4fe947d6..1a571093 100644
--- a/daemon/gvfsreadstream.h
+++ b/daemon/gvfsreadstream.h
@@ -3,6 +3,7 @@
 
 #include <glib-object.h>
 #include <gvfsjob.h>
+#include <gvfsbackend.h>
 #include <gvfs/gvfstypes.h>
 
 G_BEGIN_DECLS
@@ -38,20 +39,22 @@ struct _GVfsReadStreamClass
 
 GType g_vfs_read_stream_get_type (void) G_GNUC_CONST;
 
-GVfsReadStream *g_vfs_read_stream_new              (GError         **error);
-int             g_vfs_read_stream_steal_remote_fd  (GVfsReadStream  *read_stream);
-void            g_vfs_read_stream_set_user_data    (GVfsReadStream  *read_stream,
-						    gpointer         data);
-gboolean        g_vfs_read_stream_has_job          (GVfsReadStream  *read_stream);
-GVfsJob *       g_vfs_read_stream_get_job          (GVfsReadStream  *read_stream);
-void            g_vfs_read_stream_send_data        (GVfsReadStream  *read_stream,
-						    char            *buffer,
-						    gsize            count);
-void            g_vfs_read_stream_send_error       (GVfsReadStream  *read_stream,
-						    GError          *error);
-void            g_vfs_read_stream_send_closed      (GVfsReadStream  *read_stream);
-void            g_vfs_read_stream_send_seek_offset (GVfsReadStream  *read_stream,
-						    goffset          offset);
+GVfsReadStream *g_vfs_read_stream_new                (GVfsBackend        *backend,
+						      GError            **error);
+int             g_vfs_read_stream_steal_remote_fd    (GVfsReadStream     *read_stream);
+GVfsBackend    *g_vfs_read_stream_get_backend        (GVfsReadStream     *read_stream);
+void            g_vfs_read_stream_set_backend_handle (GVfsReadStream     *read_stream,
+						      GVfsBackendHandle   backend_handle);
+gboolean        g_vfs_read_stream_has_job            (GVfsReadStream     *read_stream);
+GVfsJob *       g_vfs_read_stream_get_job            (GVfsReadStream     *read_stream);
+void            g_vfs_read_stream_send_data          (GVfsReadStream     *read_stream,
+						      char               *buffer,
+						      gsize               count);
+void            g_vfs_read_stream_send_error         (GVfsReadStream     *read_stream,
+						      GError             *error);
+void            g_vfs_read_stream_send_closed        (GVfsReadStream     *read_stream);
+void            g_vfs_read_stream_send_seek_offset   (GVfsReadStream     *read_stream,
+						      goffset             offset);
 
 /* TODO: i/o priority? */
 
diff --git a/daemon/main.c b/daemon/main.c
index 14a02b33..696d54c1 100644
--- a/daemon/main.c
+++ b/daemon/main.c
@@ -45,13 +45,13 @@ main (int argc, char *argv[])
   if (!init_dbus ())
     return 1;
 
+  daemon = g_vfs_daemon_new ();
+  
   backend = g_vfs_backend_test_new ();
-  daemon = g_vfs_daemon_new (G_VFS_DBUS_MOUNTPOINT_NAME "foo_3A_2F_2F",
-			     G_VFS_BACKEND (backend));
+  if (!g_vfs_daemon_add_backend (daemon, G_VFS_BACKEND (backend)))
+      return 1;
   g_object_unref (backend);
 
-  if (!g_vfs_daemon_is_active (daemon))
-    return 1;
 
   loop = g_main_loop_new (NULL, FALSE);
 
diff --git a/gvfs/gfiledaemon.c b/gvfs/gfiledaemon.c
index aec11d24..0fe399ed 100644
--- a/gvfs/gfiledaemon.c
+++ b/gvfs/gfiledaemon.c
@@ -20,6 +20,7 @@ struct _GFileDaemon
 
   char *filename;
   char *mountpoint;
+  char *bus_name;
 };
 
 G_DEFINE_TYPE_WITH_CODE (GFileDaemon, g_file_daemon, G_TYPE_OBJECT,
@@ -61,8 +62,10 @@ g_file_daemon_new (const char *filename,
   int len;
 
   daemon_file = g_object_new (G_TYPE_FILE_DAEMON, NULL);
+  /* TODO: These should be construct only properties */
   daemon_file->filename = g_strdup (filename);
   daemon_file->mountpoint = g_strdup (mountpoint);
+  daemon_file->bus_name = _g_dbus_bus_name_from_mountpoint (mountpoint);
 
   /* Remove any trailing slashes */
   len = strlen (daemon_file->filename);
@@ -247,7 +250,7 @@ g_file_daemon_read_async (GFile *file,
   DBusMessage *message;
   DBusMessageIter iter;
   
-  message = dbus_message_new_method_call ("org.gtk.vfs.Daemon",
+  message = dbus_message_new_method_call (daemon_file->bus_name,
 					  G_VFS_DBUS_DAEMON_PATH,
 					  G_VFS_DBUS_DAEMON_INTERFACE,
 					  G_VFS_DBUS_OP_OPEN_FOR_READ);
@@ -287,7 +290,7 @@ g_file_daemon_read (GFile *file,
       return NULL;
     }
 
-  message = dbus_message_new_method_call ("org.gtk.vfs.Daemon",
+  message = dbus_message_new_method_call (daemon_file->bus_name,
 					  G_VFS_DBUS_DAEMON_PATH,
 					  G_VFS_DBUS_DAEMON_INTERFACE,
 					  G_VFS_DBUS_OP_OPEN_FOR_READ);
diff --git a/gvfs/gvfsdaemondbus.c b/gvfs/gvfsdaemondbus.c
index cf3c4b3c..b66e55db 100644
--- a/gvfs/gvfsdaemondbus.c
+++ b/gvfs/gvfsdaemondbus.c
@@ -143,6 +143,16 @@ append_escaped_bus_name (GString *s,
     }
 }
 
+char *
+_g_dbus_bus_name_from_mountpoint (const char *mountpoint)
+{
+  GString *bus_name;
+  
+  bus_name = g_string_new (G_VFS_DBUS_MOUNTPOINT_NAME);
+  append_escaped_bus_name (bus_name, mountpoint);
+  return g_string_free (bus_name, FALSE);
+}
+
 
 static int
 daemon_socket_connect (const char *address, GError **error)
@@ -504,7 +514,7 @@ static void
 open_connection_async (AsyncDBusCall *async_call)
 {
   DBusError derror;
-  GString *bus_name;
+  char *bus_name;
   DBusMessage *get_connection_message;
   DBusPendingCall *pending;
   DBusConnection *bus;
@@ -527,13 +537,12 @@ open_connection_async (AsyncDBusCall *async_call)
   async_call->get_connection_source =
     set_connection_for_main_context (async_call->context, NULL, bus);
   
-  bus_name = g_string_new (G_VFS_DBUS_MOUNTPOINT_NAME);
-  append_escaped_bus_name (bus_name, async_call->mountpoint);
-  get_connection_message = dbus_message_new_method_call (bus_name->str,
+  bus_name = _g_dbus_bus_name_from_mountpoint (async_call->mountpoint);
+  get_connection_message = dbus_message_new_method_call (bus_name,
 							 G_VFS_DBUS_DAEMON_PATH,
 							 G_VFS_DBUS_DAEMON_INTERFACE,
 							 G_VFS_DBUS_OP_GET_CONNECTION);
-  g_string_free (bus_name, TRUE);
+  g_free (bus_name);
   
   if (get_connection_message == NULL)
     g_error ("Failed to allocate message");
diff --git a/gvfs/gvfsdaemondbus.h b/gvfs/gvfsdaemondbus.h
index baa3dc65..e2f9f2b4 100644
--- a/gvfs/gvfsdaemondbus.h
+++ b/gvfs/gvfsdaemondbus.h
@@ -13,6 +13,7 @@ gboolean        _g_dbus_message_iter_append_filename (DBusMessageIter  *iter,
 						      const char       *filename);
 void            _g_error_from_dbus                   (DBusError        *derror,
 						      GError          **error);
+char *          _g_dbus_bus_name_from_mountpoint     (const char       *mountpoint);
 
 
 typedef void (*GVfsAsyncDBusCallback) (DBusMessage *reply,