gvfs/gvfs-dice-backend.patch

Index: gvfs-1.5.5/configure.ac
===================================================================
--- gvfs-1.5.5.orig/configure.ac
+++ gvfs-1.5.5/configure.ac
@@ -47,6 +47,10 @@ PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.23
 
 PKG_CHECK_MODULES(DBUS, dbus-1)
 
+PKG_CHECK_MODULES(DBUS_GLIB, dbus-glib-1)
+AC_SUBST(DBUS_GLIB_CFLAGS)
+AC_SUBST(DBUS_GLIB_LIBS)
+
 AC_ARG_WITH(dbus_service_dir,
 		AS_HELP_STRING([--with-dbus-service-dir=PATH],[choose directory for dbus service files, [default=PREFIX/share/dbus-1/services]]),
             with_dbus_service_dir="$withval", with_dbus_service_dir=$datadir/dbus-1/services)
Index: gvfs-1.5.5/daemon/dice.mount.in
===================================================================
--- /dev/null
+++ gvfs-1.5.5/daemon/dice.mount.in
@@ -0,0 +1,6 @@
+[Mount]
+Type=dice
+Exec=@libexecdir@/gvfsd-dice
+AutoMount=true
+DBusName=org.gtk.vfs.mountpoint.dice
+
Index: gvfs-1.5.5/daemon/gvfsbackenddice.c
===================================================================
--- /dev/null
+++ gvfs-1.5.5/daemon/gvfsbackenddice.c
@@ -0,0 +1,1989 @@
+/* Novell DICE Backend for GVfs
+ * 
+ * Copyright (C) 2008 Novell, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author:	Boyd Timothy <btimothy@novell.com>
+ *			Brady Anderson <banderso@novell.com>
+ */
+
+
+#include <config.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <glib/gstdio.h>
+#include <glib/gi18n.h>
+#include <glib/gprintf.h>
+#include <gio/gio.h>
+#include <gio/gunixmounts.h>
+#include <glib/gurifuncs.h>
+
+#include <dbus/dbus-glib.h>
+
+#include <time.h>
+
+#include "gvfsbackenddice.h"
+#include "gvfsmonitor.h"
+#include "gvfsjobopenforread.h"
+#include "gvfsjobread.h"
+#include "gvfsjobseekread.h"
+#include "gvfsjobopenforwrite.h"
+#include "gvfsjobwrite.h"
+#include "gvfsjobclosewrite.h"
+#include "gvfsjobseekwrite.h"
+#include "gvfsjobsetdisplayname.h"
+#include "gvfsjobqueryinfo.h"
+#include "gvfsjobdelete.h"
+#include "gvfsjobqueryfsinfo.h"
+#include "gvfsjobqueryattributes.h"
+#include "gvfsjobenumerate.h"
+#include "gvfsjobcreatemonitor.h"
+#include "gvfsdaemonprotocol.h"
+#include "gvfsdaemonutils.h"
+
+#define G_FILE_ATTRIBUTE_DICE_LOCAL_PATH "dice::local-path"
+#define G_FILE_ATTRIBUTE_DICE_ID "dice::id"
+
+static void lose (const char *fmt, ...) G_GNUC_NORETURN G_GNUC_PRINTF (1, 2);
+static void lose_gerror (const char *prefix, GError *error) G_GNUC_NORETURN;
+static GFileInfo *create_file_info_from_dbus_array(GValueArray *array_obj);
+
+struct _GVfsBackendDice
+{
+	GVfsBackend parent_instance;
+	DBusGConnection *dbus_connection;
+	DBusGProxy *dice_proxy;
+
+	GMountSpec *mount_spec;
+	GList *top_files; /* Files in toplevel dir */
+	guint num_top_files;
+};
+
+struct DiceHandle
+{
+	char *file_path;
+	GFileInputStream *input_stream;
+	GFileOutputStream *output_stream;
+} *PDiceHandle;
+
+G_DEFINE_TYPE (GVfsBackendDice, g_vfs_backend_dice, G_VFS_TYPE_BACKEND)
+
+#define DBUS_STRUCT_STRING_STRING_STRING (dbus_g_type_get_struct ("GValueArray", G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID))
+
+static void
+g_vfs_backend_dice_init (GVfsBackendDice *ice_backend)
+{
+	g_print ("(dice) g_vfs_backend_dice_init \n");
+	GVfsBackendDice *backend = G_VFS_BACKEND_DICE (ice_backend);
+	backend->dbus_connection = NULL;
+	
+	DBusGConnection *connection;
+	GError *error;
+	DBusGProxy *dice_proxy;
+	
+	g_printf(" (dice) connecting to the ICE Daemon via DBus...\n");
+	
+	error = NULL;
+	connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
+	if (connection == NULL)
+	{
+		g_printerr (
+			"Failed to open connection to bus: %s\n",
+			error->message);
+		g_error_free (error);
+		exit (1);
+	}
+	
+	g_printf("  (dice) got a connection to the session bus\n");
+	backend->dbus_connection = connection;
+	
+	dice_proxy = 
+		dbus_g_proxy_new_for_name (
+			backend->dbus_connection,
+			"Novell.ICEDesktop.Daemon",
+			"/Novell/ICEDesktop/Daemon",
+			"Novell.ICEDesktop.Daemon");
+			
+	gboolean ping_successful;
+	error = NULL;
+	if (!dbus_g_proxy_call (
+			dice_proxy, 
+			"Ping", 
+			&error,
+			G_TYPE_INVALID, // Input params
+			G_TYPE_BOOLEAN, 
+			&ping_successful, // Output params
+			G_TYPE_INVALID))
+	{
+		lose_gerror ("Could not ping the DICE Daemon", error);
+		exit (-1);
+	}
+	
+	g_printf ("  (dice) connected to the DICE Daemon.\n");
+	backend->dice_proxy = dice_proxy;
+}
+
+static void
+g_vfs_backend_dice_finalize (GObject *object)
+{
+	GVfsBackendDice *dice;
+
+	dice = G_VFS_BACKEND_DICE (object);
+	g_mount_spec_unref (dice->mount_spec);
+	
+	if (G_OBJECT_CLASS (g_vfs_backend_dice_parent_class)->finalize)
+		(*G_OBJECT_CLASS (g_vfs_backend_dice_parent_class)->finalize) (object);
+}
+
+/*********************
+ * Utility Functions *
+ *********************/
+
+
+static void
+lose (const char *str, ...)
+{
+	va_list args;
+	va_start (args, str);
+
+	vfprintf (stderr, str, args);
+	fputc ('\n', stderr);
+
+	va_end (args);
+	exit (1);
+}
+
+
+static void
+lose_gerror (const char *prefix, GError *error)
+{
+	lose ("%s: %s", prefix, error->message);
+}
+
+
+/**
+ * Caller must free using g_free () if not NULL return.
+ */
+/*
+static char *
+get_last_path_component (const char *path)
+{
+	if (path == NULL)
+		return NULL;
+	
+	g_printf ("  (ice) get_last_path_component (%s)\n", path);
+	char *parsable_path = g_strdup (path);
+	char *path_component = NULL;
+	char *last_component = strtok (parsable_path, "/");
+	if (last_component != NULL)
+	{
+		while ((path_component = strtok (NULL, "/")) != NULL)
+		{
+			// Intentionally blank.  Tokenize until we've reached
+			// the last token.
+			last_component = path_component;
+		}
+		
+		// Make a copy of the last component
+		last_component = g_strdup (last_component);
+	}
+	
+	g_free (parsable_path);
+	
+	g_printf("    (ice) get_last_path_component () returning -> '%s'\n", last_component == NULL ? "(null)" : last_component);
+	
+	return last_component;
+}
+*/
+
+
+/*
+G_IO_ERROR_FAILED,             EIO          },
+      { G_IO_ERROR_NOT_FOUND,          ENOENT       },
+      { G_IO_ERROR_EXISTS,             EEXIST       },
+      { G_IO_ERROR_IS_DIRECTORY,       EISDIR       },
+      { G_IO_ERROR_NOT_DIRECTORY,      ENOTDIR      },
+      { G_IO_ERROR_NOT_EMPTY,          ENOTEMPTY    },
+      { G_IO_ERROR_NOT_REGULAR_FILE,   EIO          },
+      { G_IO_ERROR_NOT_SYMBOLIC_LINK,  EIO          },
+      { G_IO_ERROR_NOT_MOUNTABLE_FILE, EIO          },
+      { G_IO_ERROR_FILENAME_TOO_LONG,  ENAMETOOLONG },
+      { G_IO_ERROR_INVALID_FILENAME,   EIO          },
+      { G_IO_ERROR_TOO_MANY_LINKS,     ELOOP        },
+      { G_IO_ERROR_NO_SPACE,           ENOSPC       },
+      { G_IO_ERROR_INVALID_ARGUMENT,   EINVAL       },
+      { G_IO_ERROR_PERMISSION_DENIED,  EACCES       },
+      { G_IO_ERROR_NOT_SUPPORTED,      ENOTSUP      },
+      { G_IO_ERROR_NOT_MOUNTED,        EIO          },
+      { G_IO_ERROR_ALREADY_MOUNTED,    EIO          },
+      { G_IO_ERROR_CLOSED,             EIO          },
+      { G_IO_ERROR_CANCELLED,          EIO          },
+      { G_IO_ERROR_PENDING,            EIO          },
+      { G_IO_ERROR_READ_ONLY,          EACCES       },
+      { G_IO_ERROR_CANT_CREATE_BACKUP, EIO          },
+      { G_IO_ERROR_WRONG_ETAG,         EIO          },
+      { G_IO_ERROR_TIMED_OUT,          EIO          },
+      { G_IO_ERROR_BUSY,               EBUSY        },
+      { -1,                            -1           }
+*/
+
+// Method to convert all DICE Exceptions to an
+// equivalent GIO_ERROR.
+// The Exception class is returned and contained
+// in the error->message field.
+GError * convert_dice_error_to_gio_status (GError *dice_error)
+{
+	GError *error;
+	
+	if (strstr (dice_error->message, "PathNotFoundException") != NULL)
+	{
+		error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_NOT_FOUND, 
+				_("No such file or directory"));
+	}
+	else if (strstr (dice_error->message, "NoEntriesException") != NULL)
+	{
+		error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_NOT_FOUND, 
+				_("No such file or directory"));
+	}
+	else if (strstr (dice_error->message, "NoWorkspacesException") != NULL)
+	{
+		error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_NOT_FOUND, 
+				_("No such file or directory"));
+	}
+	else if (strstr (dice_error->message, "NoFoldersException") != NULL)
+	{
+		error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_NOT_FOUND, 
+				_("No such file or directory"));
+	}
+	else if (strstr (dice_error->message, "NoFolderEntriesException") != NULL)
+	{
+		error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_NOT_FOUND, 
+				_("No such file or directory"));
+	}
+	else if (strstr (dice_error->message, "NoFileEntriesException") != NULL)
+	{
+		error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_NOT_FOUND, 
+				_("No such file or directory"));
+	}
+	else if (strstr (dice_error->message, "FolderNotFoundException") != NULL)
+	{
+		error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_NOT_FOUND, 
+				_("No such file or directory"));
+	}
+	else if (strstr (dice_error->message, "FileNotFoundException") != NULL)
+	{
+		error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_NOT_FOUND, 
+				_("No such file or directory"));
+	}
+	else if (strstr (dice_error->message, "NotAFolderException") != NULL)
+	{
+		error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_NOT_DIRECTORY, 
+				_("is not a directory"));
+		error->code = G_IO_ERROR_NOT_DIRECTORY;
+	}
+	else if (strstr (dice_error->message, "NotAFileException") != NULL)
+	{
+		error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_NOT_REGULAR_FILE, 
+				_("is not a file"));
+	}
+	else if (strstr (error->message, "NotAuthenticatedException") != NULL)
+	{
+		error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_PERMISSION_DENIED, 
+				_("Access denied"));
+	}
+	else if (strstr (dice_error->message, "FailedAuthenticationException") != NULL)
+	{
+		error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_PERMISSION_DENIED, 
+				_("Access denied"));
+	}
+	else if (strstr (dice_error->message, "DiskFullException") != NULL)
+	{
+		error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_NO_SPACE, 
+				_("No available space"));
+	}
+	else
+	{
+		error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_FAILED, 
+				_("General failure"));
+	}
+
+	return error;
+}
+
+static GFileInfo *
+create_file_info_from_dbus_array (GValueArray *array_obj)
+{
+	g_printf ("  ***   create_file_info_from_dbus_array ()  ***\n");
+	
+	if (array_obj == NULL) return NULL;
+	
+	GFileInfo *info = g_file_info_new ();
+	
+	GValue *file_id				= g_value_array_get_nth (array_obj, 0);
+	GValue *file_display_name	= g_value_array_get_nth (array_obj, 1);
+	GValue *file_path			= g_value_array_get_nth (array_obj, 2);
+	GValue *file_local_path		= g_value_array_get_nth (array_obj, 3);
+	GValue *file_type			= g_value_array_get_nth (array_obj, 4);
+	GValue *mime_type			= g_value_array_get_nth (array_obj, 5);
+	GValue *file_access_mask	= g_value_array_get_nth (array_obj, 6);
+	GValue *creation_time		= g_value_array_get_nth (array_obj, 7);
+	GValue *last_access_time	= g_value_array_get_nth (array_obj, 8);
+	GValue *last_modified_time	= g_value_array_get_nth (array_obj, 9);
+	GValue *size				= g_value_array_get_nth (array_obj, 10);
+	GValue *hidden				= g_value_array_get_nth (array_obj, 11);
+	
+	g_printf (" *** read a file info ***\n");
+	g_printf ("\t           ID: %s\n", g_value_get_string (file_id));
+	g_printf ("\t Display Name: %s\n", g_value_get_string (file_display_name));
+	g_printf ("\t         Path: %s\n", g_value_get_string (file_path));
+	g_printf ("\t   Local Path: %s\n", g_value_get_string (file_local_path));
+	
+	struct tm *tmp_time;
+	char timestr[200];
+	gint64 creationDateInSecondsFromEpoch = g_value_get_int64 (creation_time);
+	g_printf("timestamp: %lld\n", creationDateInSecondsFromEpoch); 
+	tmp_time = localtime ((time_t *)&creationDateInSecondsFromEpoch);
+	if (strftime(timestr, sizeof (timestr), "%F %T", tmp_time) != 0)
+	{
+		g_printf ("\t\tCreation Time: %s\n", timestr);
+	}
+
+	gint64 modifiedDateInSecondsFromEpoch = g_value_get_int64 (last_modified_time);
+	g_printf("timestamp: %lld\n", modifiedDateInSecondsFromEpoch); 
+	tmp_time = localtime ((time_t *)&modifiedDateInSecondsFromEpoch);
+	if (strftime(timestr, sizeof (timestr), "%F %T", tmp_time) != 0)
+	{
+		g_printf ("\t\tModifed Time: %s\n", timestr);
+	}
+	
+	// Set the name, display name and the unique id
+	g_file_info_set_name (info, g_value_get_string (file_display_name));
+	g_file_info_set_display_name (info, g_value_get_string (file_display_name));
+	g_file_info_set_attribute_string (info, G_FILE_ATTRIBUTE_ID_FILE, g_value_get_string (file_id));
+	
+	switch (g_value_get_int (file_type))
+	{
+		case 2:
+		case 3:
+			g_printf ("\t\tType: Directory\n");
+			gvfs_file_info_populate_content_types (info, g_value_get_string (file_path), G_FILE_TYPE_DIRECTORY);
+			g_file_info_set_content_type (info, "inode/directory");
+			g_file_info_set_size (info, 4096);
+			break;
+			
+		case 4:
+			g_printf ("\t\tType: Regular\n");
+			gvfs_file_info_populate_content_types (info, g_value_get_string (file_path), G_FILE_TYPE_REGULAR);
+			
+			// Store the local path in the file info
+			g_printf ("\t\tLocal Path: %s\n", g_value_get_string (file_local_path));
+			g_file_info_set_attribute_string (info, G_FILE_ATTRIBUTE_DICE_LOCAL_PATH, g_value_get_string (file_local_path));
+			
+			// File size
+			g_printf ("\t\tFile Size: %lu\n", g_value_get_uint64 (size));
+			g_file_info_set_size (info, g_value_get_uint64 (size));
+			
+			// Mime type
+			g_printf ("\t\tMime Type: %s\n", g_value_get_string (mime_type));
+			g_file_info_set_content_type (info, g_value_get_string (mime_type));
+
+			g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_READ, TRUE);
+			g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE, TRUE);
+			//g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE, TRUE);
+			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, TRUE);
+			g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME, TRUE);
+
+			break;
+			
+		default:
+			g_printf ("\t\tType: Unknown\n");
+			gvfs_file_info_populate_content_types (info, g_value_get_string (file_path), G_FILE_TYPE_UNKNOWN);
+			break;
+	}
+	
+	// File Access
+
+/*
+	uint access_mask = g_value_get_uint (file_access_mask);
+	g_printf ("\t		Access: %X\n", access_mask);
+	if (access_mask & 1) // Read
+		g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_READ, TRUE);
+	else
+		g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_READ, FALSE);
+		
+	if (access_mask & 2) // Write
+		g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE, TRUE);
+	else
+		g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE, FALSE);
+	
+	if (access_mask & 4) // Execute
+		g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE, TRUE);
+	else
+		g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE, FALSE);
+	
+	if (access_mask & 8) // CanDelete
+		g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE, TRUE);
+	else
+		g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE, FALSE);
+	
+	if (access_mask & 16) // CanTrash
+		g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH, TRUE);
+	else
+		g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH, FALSE);
+	
+	if (access_mask && 32) // CanRename
+		g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME, TRUE);
+	else
+		g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME, FALSE);
+		*/
+	
+	// Set the creation and modified times
+	g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_CREATED, creationDateInSecondsFromEpoch);
+	g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED, modifiedDateInSecondsFromEpoch);
+
+	GTimeVal t;
+  	t.tv_sec = modifiedDateInSecondsFromEpoch;
+ 	g_file_info_set_modification_time (info, &t);
+
+	g_file_info_set_is_hidden (info, FALSE);
+	return info;
+}
+
+
+static void enumerate_workspaces (
+	GVfsBackendDice *dice_backend,
+	GVfsJob *job)
+{
+  	GPtrArray *files = NULL;
+	GFileInfo *info;
+	GError *dbus_error = NULL;
+	int dbus_status;
+	
+	g_print ("(dice) enumerate_workspaces - called");
+		
+	// Read in all the workspaces
+	dbus_status =
+		dbus_g_proxy_call (
+			dice_backend->dice_proxy, 
+			"EnumerateWorkspaces", 
+			&dbus_error,
+			// Input params (none)
+			G_TYPE_INVALID,
+			// Output params
+			dbus_g_type_get_collection	 (
+				"GPtrArray", 
+				dbus_g_type_get_struct (
+					"GValueArray",
+					G_TYPE_STRING,		// Id
+					G_TYPE_STRING,		// Display Name
+					G_TYPE_STRING,		// Path
+					G_TYPE_STRING,		// Local Path
+					G_TYPE_INT,			// File Type
+					G_TYPE_STRING,		// Mime Type
+					G_TYPE_UINT,		// Access Mask
+					G_TYPE_INT64,		// Creation Time
+					G_TYPE_INT64,		// Last Access Time
+					G_TYPE_INT64,		// Last Modified Time
+					G_TYPE_UINT64,		// Size
+					G_TYPE_BOOLEAN,		// Hidden
+					G_TYPE_INVALID)),
+			&files,
+			G_TYPE_INVALID);
+	
+	g_print ("dbus_status: %d\n", dbus_status);
+	g_print ("dbus_error: 0x%X\n", dbus_error);
+	
+	if (dbus_status > 0 && dbus_error == NULL)
+	{
+		// You have to say succeeded before you add the infos
+		g_vfs_job_succeeded (G_VFS_JOB (job));
+
+		if (files != NULL)
+		{
+			int i;
+			for (i = 0; i < files->len; i++)
+			{
+				GValueArray *dbus_array_obj = g_ptr_array_index (files, i);
+				if (dbus_array_obj != NULL)
+				{
+					info = create_file_info_from_dbus_array (dbus_array_obj);
+					g_vfs_job_enumerate_add_info (job, info);
+					g_object_unref (info);
+				}
+			}
+			
+			g_ptr_array_free (files, TRUE);
+		}
+		
+		g_vfs_job_enumerate_done (job);
+	}
+	else
+	{
+		if (dbus_error != NULL)
+		{
+			if (strstr(dbus_error->message, "NoEntries") != NULL ||
+				strstr (dbus_error->message, "NoWorkspaces") != NULL ||
+				strstr (dbus_error->message, "NoFolders") != NULL ||
+				strstr (dbus_error->message, "NoFiles") != NULL)
+			{
+				g_printf ("Hit the no more entries case");
+				g_vfs_job_succeeded (G_VFS_JOB (job));
+				g_vfs_job_enumerate_done (job);
+			}
+			else
+			{
+				g_vfs_job_failed (
+					G_VFS_JOB (job),
+					G_IO_ERROR,
+					dbus_error->code,
+					dbus_error->message);
+			}
+		}
+		else
+		{
+			g_vfs_job_failed (
+				G_VFS_JOB (job),
+				G_IO_ERROR,
+				G_IO_ERROR_FAILED,
+				_("Error enumerating a directory"));
+				
+		}
+				
+		g_error_free (dbus_error);
+	}
+		
+	g_print ("(dice) enumerate_workspaces. \n");
+}
+
+
+/**
+ * ???
+ *
+ * Note: The returned object should be freed by the caller.
+ */
+static GFileInfo*
+get_g_file_info_from_dice (
+	GVfsBackendDice *dice_backend,
+	const char *filename,// GFile *file, 
+	const char *attributes, 
+	GFileQueryInfoFlags flags,
+	GVfsJob *job,
+	GError **error)
+{
+	g_printf("*** get_g_file_info_from_dice ()\n");
+	g_printf("\tfilename: %s\n", filename);
+	GError *dbus_error = NULL;
+	GFileInfo *info = NULL;
+	GValueArray *dbus_file_info = NULL;
+		
+	if (strlen (filename) == 1 && filename [0] == '/')
+	{
+		// This is the top-level item that will appear in
+		// Nautilus' sidebar as one of the "Places".
+		info = g_file_info_new ();
+		g_file_info_set_name (info, "/");
+		g_file_info_set_display_name (info, _("DICE"));
+		g_file_info_set_file_type (info, G_FILE_TYPE_DIRECTORY);
+		return info;
+	}
+	
+	// If we make it this far, we're dealing with either a
+	// workspace, a directory, or a file.  Communicate via DBus
+	// to the DICE Daemon to determine the information for the
+	// given path.
+	if (dice_backend->dice_proxy == NULL)
+	{
+		*error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_FAILED, 
+				_("No connection to the DICE daemon"));
+		
+		return NULL;
+	}
+	
+	if (!dbus_g_proxy_call (
+		dice_backend->dice_proxy,
+		"GetFileByPath",
+		&dbus_error,
+		// Input Params
+		G_TYPE_STRING,
+		filename,
+		G_TYPE_INVALID,
+		// Output Params (struct of items)
+		dbus_g_type_get_struct (
+			"GValueArray",
+			G_TYPE_STRING,		// Id
+			G_TYPE_STRING,		// Display Name
+			G_TYPE_STRING,		// Path
+			G_TYPE_STRING,		// Local Path
+			G_TYPE_INT,			// File Type
+			G_TYPE_STRING,		// Mime Type
+			G_TYPE_UINT,		// Access Mask
+			G_TYPE_INT64,		// Creation Time
+			G_TYPE_INT64,		// Last Access Time
+			G_TYPE_INT64,		// Last Modified Time
+			G_TYPE_UINT64,		// Size
+			G_TYPE_BOOLEAN,		// Hidden
+			G_TYPE_INVALID),
+		&dbus_file_info,
+		G_TYPE_INVALID))
+	{
+		*error = convert_dice_error_to_gio_status (dbus_error);
+		g_error_free (dbus_error);
+	}
+	else
+	if (dbus_file_info != NULL)
+	{
+		info = create_file_info_from_dbus_array (dbus_file_info);
+		g_value_array_free (dbus_file_info);
+	}
+	
+	g_printf("     success - returning from get_g_file_info_from_dice\n");
+	return info;
+}
+
+// Caller must free the returned GFileInfo on success
+static GFileInfo*
+create_g_file_info_in_dice (
+	GVfsBackendDice *ice_backend,
+	const char *filename,
+	GError **error)
+{
+	g_printf("*** create_g_file_info_in_dice ()\n");
+	g_printf("\tfilename: %s\n", filename);
+	GFileInfo *info = NULL;
+		
+	GError *dbus_error = NULL;
+	if (ice_backend->dice_proxy == NULL)
+	{
+		if (*error != NULL)
+			*error = 
+				g_error_new (
+					G_IO_ERROR, 
+					G_IO_ERROR_FAILED, 
+					_("No connection to the DICE daemon"));
+				
+		return NULL;
+	}
+	
+	GValueArray *dbus_file_info = NULL;
+	
+	if (!dbus_g_proxy_call (
+			ice_backend->dice_proxy,
+			"CreateLocalFile",
+			&dbus_error,
+			// Input Params
+			G_TYPE_STRING, filename, G_TYPE_INVALID,
+			// Output Params (struct of items)
+			dbus_g_type_get_struct (
+				"GValueArray",
+				G_TYPE_STRING,		// Id
+				G_TYPE_STRING,		// Display Name
+				G_TYPE_STRING,		// Path
+				G_TYPE_STRING,		// Local Path
+				G_TYPE_INT,			// File Type
+				G_TYPE_STRING,		// Mime Type
+				G_TYPE_UINT,		// Access Mask
+				G_TYPE_INT64,		// Creation Time
+				G_TYPE_INT64,		// Last Access Time
+				G_TYPE_INT64,		// Last Modified Time
+				G_TYPE_UINT64,		// Size
+				G_TYPE_BOOLEAN,		// Hidden
+				G_TYPE_INVALID),
+			&dbus_file_info,
+			G_TYPE_INVALID))
+	{
+		if (strstr (dbus_error->message, "Exception:") != NULL)
+		{
+			g_printf ("Could not create file '%s': %s\n", filename, dbus_error->message);
+			dbus_file_info = NULL;
+		}
+
+		// Convert the returned dice error to an equivalent GIO_ERROR
+		*error = convert_dice_error_to_gio_status (dbus_error);		
+		g_error_free (dbus_error);
+	}
+	else
+	if (dbus_file_info != NULL)
+	{
+		info = create_file_info_from_dbus_array (dbus_file_info);
+		g_value_array_free (dbus_file_info);
+	}
+	
+	g_printf("     returning from create_g_file_info_in_dice ()\n");
+	return info;
+}
+
+
+// Returns TRUE if the file was successfully deleted.
+// If FALSE, the caller must free the GError that may be set.
+static gboolean
+delete_local_file_from_dice (
+	GVfsBackendDice *dice_backend,
+	const char *filename,
+	GError **error)
+{
+	GError *dbus_error;
+	g_printf ("*** delete_local_file_from_dice ()\n");
+	g_printf ("\tfilename: %s\n", filename);
+		
+	if (dice_backend->dice_proxy == NULL)
+	{
+		*error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_FAILED, 
+				_("No connection to the DICE daemon"));
+		
+		return FALSE;
+	}
+	
+	if (error != NULL) *error = NULL;
+	
+	dbus_error = NULL;
+	if (!dbus_g_proxy_call (
+			dice_backend->dice_proxy,
+			"DeleteLocalFile",
+			&dbus_error,
+			// Input Params
+			G_TYPE_STRING,
+			filename,
+			G_TYPE_INVALID,
+			G_TYPE_INVALID)) // Output Params (none)
+	{
+		if (strstr(dbus_error->message, "Exception:") != NULL)
+		{
+			g_printf ("Could not delete file '%s': %s\n", filename, dbus_error->message);
+		}
+		else
+		{
+			g_printf ("Could not delete the file '%s'\n", filename);
+			g_printf ("Received an unexpected dbus error: %s\n", dbus_error->message);
+		}
+		
+		*error = convert_dice_error_to_gio_status (dbus_error);
+		g_error_free (dbus_error);
+		return FALSE;
+	}
+	
+	g_printf("     success - returning from delete_local_file_from_dice ()\n");
+	return TRUE;
+}
+
+
+// This should be called any time our provider modifies a
+// file.  Basically any time we close a file handle.  Returns
+// TRUE if the file was updated successfully.  If FALSE, the
+// caller must free the GError that may be set.
+static gboolean
+update_local_file_in_dice (
+	GVfsBackendDice *dice_backend,
+	const char *filename,
+	GError **error)
+{
+	GError *dbus_error;
+	g_printf ("*** update_local_file_in_dice ()\n");
+	g_printf ("\tfilename: %s\n", filename);
+		
+	if (dice_backend->dice_proxy == NULL)
+	{
+		*error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_FAILED, 
+				_("No connection to the DICE daemon"));
+				
+		return FALSE;
+	}
+	
+	if (error != NULL) *error = NULL;
+	
+	dbus_error = NULL;
+	if (!dbus_g_proxy_call (
+			dice_backend->dice_proxy,
+			"UpdateLocalFile",
+			&dbus_error,
+			// Input Params
+			G_TYPE_STRING,
+			filename,
+			G_TYPE_INVALID,
+			G_TYPE_INVALID)) // Output Params (none)
+	{
+		if (strstr(dbus_error->message, "Exception:") != NULL)
+		{
+			g_printf ("Could not update file '%s': %s\n", filename, dbus_error->message);
+		}
+		
+		*error = convert_dice_error_to_gio_status (dbus_error);
+		g_error_free (dbus_error);
+		return FALSE;
+	}
+	
+	g_printf("     success - returning from update_local_file_in_dice ()\n");
+	return TRUE;
+}
+
+//
+// Procedure for calling DICE to retrieve
+// file system information, creating a
+// GFileInfo structure and populating it
+// with the correct information.
+//
+// NOTE! The caller must free the returned
+// GFileInfo data structure
+// 
+static GFileInfo *
+get_g_filesystem_info_from_dice (
+	GVfsBackendDice *dice_backend,
+	GFile *file,
+	const char *attributes,
+	GCancellable *cancellable,
+	GError **error)
+{
+	GError *dbus_error;
+	GValueArray *dbus_filesystem_info = NULL;
+	
+	g_printf ("*** get_g_filesystem_info_from_dice ()\n");
+	//g_printf ("\tfilename: %s\n", filename);
+		
+	if (dice_backend->dice_proxy == NULL)
+	{
+		*error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_FAILED, 
+				_("No connection to the DICE daemon"));
+				
+		return NULL;
+	}
+	
+	if (error != NULL) *error = NULL;
+	
+	dbus_error = NULL;
+	
+	if (!dbus_g_proxy_call (
+		dice_backend->dice_proxy,
+		"GetFileSystemInformation",
+		&dbus_error,
+		// Input Params
+		G_TYPE_STRING,
+		"/",
+		G_TYPE_INVALID,
+		// Output Params (struct of items)
+		dbus_g_type_get_struct (
+			"GValueArray",
+			G_TYPE_STRING,		// Label
+			G_TYPE_INT,			// Attributes (RO,RW)
+			G_TYPE_INT64,		// Total Size (in bytes)
+			G_TYPE_INT64,		// Available Size (in bytes)
+			G_TYPE_INVALID),
+		&dbus_filesystem_info,
+		G_TYPE_INVALID))
+	{
+		if (strstr(dbus_error->message, "Exception:") != NULL)
+		{
+			g_printf ("Could not get file system information '%s'\n", dbus_error->message);
+		}
+		else
+		{
+			g_printf ("Could not call DICE daemon's GetFileSystemInformation ()");
+			g_printf ("Received an unexpected dbus error: %s\n", dbus_error->message);
+		}
+		
+		*error = convert_dice_error_to_gio_status (dbus_error);
+		g_error_free (dbus_error);
+		return NULL;
+	}
+	
+	GValue *label				= g_value_array_get_nth (dbus_filesystem_info, 0);
+	GValue *fsattributes		= g_value_array_get_nth (dbus_filesystem_info, 1);
+	GValue *total_space			= g_value_array_get_nth (dbus_filesystem_info, 2);
+	GValue *available_space		= g_value_array_get_nth (dbus_filesystem_info, 3);
+	
+	GFileInfo *info = g_file_info_new ();
+	if (g_value_get_int (fsattributes) == 1)
+		g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY, TRUE);
+	else
+		g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY, FALSE);
+
+	gint64 total = 4000000000;
+	gint64 available = 3000000000;
+	
+	g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_SIZE,  total);
+	g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE, available);
+//	g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_SIZE,  g_value_get_int64 (total_space));
+//	g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE, g_value_get_int64 (available_space));
+	
+	g_value_array_free (dbus_filesystem_info);
+	return info;
+}
+
+
+/*  returned object should be freed in user's function  */
+static GFile*
+get_g_file_from_local (const char *filename, GVfsJob *job)
+{
+	GVfs *local_vfs;
+	GFile *file = NULL;
+	  
+	local_vfs = g_vfs_get_local ();
+	if (! local_vfs)
+	{
+		g_vfs_job_failed (job,	G_IO_ERROR, G_IO_ERROR_FAILED,
+				"Cannot get local vfs"); 
+	    g_print (" (EE) get_g_file_from_local (filename = '%s'): local_vfs == NULL \n", filename);
+	    return NULL;
+	}
+
+	file = g_vfs_get_file_for_path (local_vfs, filename);
+	if (! file)
+	{
+		g_vfs_job_failed (job,	G_IO_ERROR, G_IO_ERROR_FAILED,
+				"Cannot get file from local vfs"); 
+	    g_print (" (EE) get_g_file_from_local (filename = '%s'): file == NULL \n", filename);
+		return NULL;
+	}
+	return file;
+}
+
+
+/************
+ * Mounting *
+ ************/
+
+static void
+do_mount (
+	GVfsBackend *backend,
+	GVfsJobMount *job,
+	GMountSpec *mount_spec,
+	GMountSource *mount_source,
+	gboolean is_automount)
+{
+	GVfsBackendDice *dice_backend = G_VFS_BACKEND_DICE (backend);
+
+	g_print ("(dice) do_mount \n");
+
+	g_vfs_backend_set_display_name (backend, _("My Spaces"));
+
+	dice_backend->mount_spec = g_mount_spec_new ("dice");
+	g_vfs_backend_set_mount_spec (backend, dice_backend->mount_spec);
+
+	g_vfs_backend_set_icon_name (backend, "network-server");
+
+	g_vfs_job_succeeded (G_VFS_JOB (job));
+}
+
+static void
+do_unmount (GVfsBackend *backend, GVfsJobUnmount *job)
+{
+  GVfsBackendDice *dice_backend;
+
+  g_print ("(dice) do_umount \n");
+
+  dice_backend = G_VFS_BACKEND_DICE (backend);
+  g_mount_spec_unref (dice_backend->mount_spec);
+  g_vfs_job_succeeded (G_VFS_JOB (job));
+}
+
+
+/*******************
+ * Query Functions *
+ *******************/
+
+static void
+do_query_info (
+	GVfsBackend *backend,
+	GVfsJobQueryInfo *job,
+	const char *filename,
+	GFileQueryInfoFlags flags,
+	GFileInfo *info,
+	GFileAttributeMatcher *matcher)
+{
+	GVfsBackendDice *dice_backend = G_VFS_BACKEND_DICE (backend);
+	GFileInfo *info2;
+	GError *error = NULL;
+
+	g_print ("(dice) (filename = %s)\n", filename);
+  
+  	// NOTE! get_g_file_info_from_dice is completing the job on failure
+  	// this needs to change
+	info2 = 
+		get_g_file_info_from_dice (
+			dice_backend, 
+			filename, 
+			/*file,*/ "*", 
+			flags, G_VFS_JOB (job),
+			&error);
+ 	if (info2 != NULL && error == NULL)
+	{
+		g_file_info_copy_into (info2, info);
+		g_object_unref (info2);
+		g_vfs_job_succeeded (G_VFS_JOB (job));
+		g_print ("(dice) do_query_info success. \n");
+	}
+	else
+	{
+		g_printf ("Error code: %d\n", error->code);
+		g_printf ("Error message: %s\n", error->message);
+		g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
+		g_error_free (error);
+		g_print ("(dice) do_query_info failed. \n");
+	}
+}
+
+
+static void
+do_query_fs_info (
+	GVfsBackend *backend,
+	GVfsJobQueryFsInfo *job,
+	const char *filename,
+	GFileInfo *info,
+	GFileAttributeMatcher *attribute_matcher)
+{
+	GFile *file;
+	GFileInfo *info2;
+	GError *error = NULL;
+	
+	g_print ("(dice) do_query_fs_info (filename = %s) \n", filename);
+	file = g_file_new_for_path (filename);
+	if (file != NULL)
+	{
+		info2 = get_g_filesystem_info_from_dice (backend, file, "fs:*", G_VFS_JOB (job)->cancellable, &error);
+		if ((error) || (!info2))
+		{
+			g_print ("  (dice) do_query_fs_info (filename = '%s'): g_file_query_filesystem_info failed: %s \n", filename, error->message);
+			g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
+		}
+		else
+		{
+			g_file_info_copy_into (info2, info);
+			g_object_unref (info2);
+			g_file_info_set_attribute_string (info, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE, "dice");
+			g_vfs_job_succeeded (G_VFS_JOB (job));
+			g_print ("(dice) do_query_fs_info success. \n");
+		}
+		
+		g_object_unref (file);
+	}
+	else
+	{
+		error = g_error_new (G_IO_ERROR, G_IO_ERROR_FAILED, _("Error creating a file info from a path"));
+		g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
+		g_print ("(dice) do_query_fs_info failed - creating a new path. \n");
+	}
+	
+	if (error != NULL) g_error_free (error);
+}
+
+
+static void
+do_enumerate (
+	GVfsBackend *backend,
+	GVfsJobEnumerate *job,
+	const char *filename,
+	GFileAttributeMatcher *attribute_matcher,
+	GFileQueryInfoFlags flags)
+{
+	GVfsBackendDice *dice_backend = G_VFS_BACKEND_DICE (backend);
+  	GPtrArray *files = NULL;
+	GFileInfo *info;
+	GError *dbus_error = NULL;
+	int dbus_status;
+	
+	g_print ("(dice) do_enumerate (filename = %s) \n", filename);
+	
+	if (strlen (filename) == 1 && filename [0] == '/')
+	{
+		g_print("  ---> calling EnumerateWorkspaces ()\n");
+		
+		// Read in all the workspaces
+		dbus_status =
+			dbus_g_proxy_call (
+				dice_backend->dice_proxy, 
+				"EnumerateWorkspaces", 
+				&dbus_error,
+				// Input params (none)
+				G_TYPE_INVALID,
+				// Output params
+				dbus_g_type_get_collection	 (
+					"GPtrArray", 
+					dbus_g_type_get_struct (
+						"GValueArray",
+						G_TYPE_STRING,		// Id
+						G_TYPE_STRING,		// Display Name
+						G_TYPE_STRING,		// Path
+						G_TYPE_STRING,		// Local Path
+						G_TYPE_INT,			// File Type
+						G_TYPE_STRING,		// Mime Type
+						G_TYPE_UINT,		// Access Mask
+						G_TYPE_INT64,		// Creation Time
+						G_TYPE_INT64,		// Last Access Time
+						G_TYPE_INT64,		// Last Modified Time
+						G_TYPE_UINT64,		// Size
+						G_TYPE_BOOLEAN,		// Hidden
+						G_TYPE_INVALID)),
+				&files,
+				G_TYPE_INVALID);
+	}
+	else
+	{
+		g_print("  ---> calling EnumerateFiles ()\n");
+		
+		// Read in the files contained in a specific directory
+		int dbus_status =
+			dbus_g_proxy_call (
+				dice_backend->dice_proxy, 
+				"EnumerateFiles", 
+				&dbus_error,
+				// Input params
+				G_TYPE_STRING, filename,
+				G_TYPE_INVALID,
+				// Output params
+				dbus_g_type_get_collection (
+					"GPtrArray", 
+					dbus_g_type_get_struct (
+						"GValueArray",
+						G_TYPE_STRING,		// Id
+						G_TYPE_STRING,		// Display Name
+						G_TYPE_STRING,		// Path
+						G_TYPE_STRING,		// Local Path
+						G_TYPE_INT,			// File Type
+						G_TYPE_STRING,		// Mime Type
+						G_TYPE_UINT,		// Access Mask
+						G_TYPE_INT64,		// Creation Time
+						G_TYPE_INT64,		// Last Access Time
+						G_TYPE_INT64,		// Last Modified Time
+						G_TYPE_UINT64,		// Size
+						G_TYPE_BOOLEAN,		// Hidden
+						G_TYPE_INVALID)),
+				&files,
+				G_TYPE_INVALID);
+				
+	}
+	
+	g_print ("  ---- EnumerateFiles () out of dbus call\n");
+	g_print ("dbus_status: %d\n", dbus_status);
+	g_print ("dbus_error: 0x%X\n", dbus_error);
+	
+	if (dbus_status > 0 && dbus_error == NULL)
+	{
+		// You have to say succeeded before you add the infos
+		g_vfs_job_succeeded (G_VFS_JOB (job));
+
+		if (files != NULL)
+		{
+			int i;
+			for (i = 0; i < files->len; i++)
+			{
+				GValueArray *dbus_array_obj = g_ptr_array_index (files, i);
+				if (dbus_array_obj != NULL)
+				{
+					info = create_file_info_from_dbus_array (dbus_array_obj);
+					g_vfs_job_enumerate_add_info (job, info);
+					g_object_unref (info);
+				}
+			}
+			
+			g_ptr_array_free (files, TRUE);
+		}
+		
+		g_vfs_job_enumerate_done (job);
+	}
+	else
+	{
+		if (dbus_error != NULL)
+		{
+			if (strstr (dbus_error->message, "NoEntries") != NULL ||
+				strstr (dbus_error->message, "NoWorkspaces") != NULL ||
+				strstr (dbus_error->message, "NoFolders") != NULL ||
+				strstr (dbus_error->message, "NoFiles") != NULL)
+			{
+				g_printf ("Hit the no more entries case");
+				g_vfs_job_succeeded (G_VFS_JOB (job));
+				g_vfs_job_enumerate_done (job);
+			}
+			else
+			{
+				GError *error = convert_dice_error_to_gio_status (dbus_error);		
+				g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
+				g_error_free (error);
+			}
+		}
+		else
+		{
+			g_vfs_job_failed (
+				G_VFS_JOB (job),
+				G_IO_ERROR,
+				G_IO_ERROR_FAILED,
+				_("Error enumerating a directory"));
+				
+		}
+				
+		g_error_free (dbus_error);
+	}
+		
+	g_print ("(dice) do_enumerate done. \n");
+}
+
+
+/******************
+ * Read Functions *
+ ******************/
+
+static void
+do_open_for_read (
+	GVfsBackend *backend,
+	GVfsJobOpenForRead *job,
+	const char *filename)
+{
+	GVfsBackendDice *dice_backend = G_VFS_BACKEND_DICE (backend);
+	struct DiceHandle *dice_handle;
+	GFileInputStream *stream;
+	GError *error = NULL;
+	GFile *file = NULL;
+	GFileInfo *info = NULL;
+
+	g_print ("(II) do_open_for_read (filename = '%s') \n", filename);
+	
+	if (strcmp (filename, "/") == 0)
+	{
+		g_print ("caught the read on / case");
+
+		error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_NOT_REGULAR_FILE, 
+				_("Failed to read the root directory"));
+		goto do_open_for_read_error;		
+	}
+	
+	info = 
+		get_g_file_info_from_dice (
+			dice_backend,
+			filename,
+			"*",
+			G_FILE_QUERY_INFO_NONE,
+			G_VFS_JOB (job),
+			&error);
+	if (error != NULL)
+	{
+		goto do_open_for_read_error;
+	}
+	
+	g_assert (info != NULL);
+
+	// Build a GFile object from the local path
+	file = 
+		get_g_file_from_local (
+			g_file_info_get_attribute_string (
+				info, 
+				G_FILE_ATTRIBUTE_DICE_LOCAL_PATH),
+			G_VFS_JOB (job));
+	if (file == NULL)
+	{
+		error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_FAILED, 
+				_("Unable to create a GFile object"));
+		goto do_open_for_read_error;
+	}
+	
+	stream = g_file_read (file, G_VFS_JOB (job)->cancellable, &error);
+	if (stream == NULL)
+	{
+		g_print ("  (EE) do_open_for_read: stream == NULL, error: %s \n", error->message);
+		goto do_open_for_read_error;
+	}
+	
+	dice_handle = g_malloc (sizeof (struct DiceHandle));
+	dice_handle->input_stream = stream;
+	dice_handle->file_path = g_strdup (filename);
+    g_vfs_job_open_for_read_set_can_seek (job, TRUE);
+    g_vfs_job_open_for_read_set_handle (job, dice_handle);
+	g_vfs_job_succeeded (G_VFS_JOB (job));
+	g_print ("(II) do_open_for_read success. \n");
+	g_object_unref (file);
+	g_object_unref (info);
+	return;
+
+do_open_for_read_error:
+	g_vfs_job_failed_from_error (G_VFS_JOB (job), error); 
+	if (error != NULL) g_error_free (error);
+	if (info != NULL) g_object_unref (info);
+	if (file != NULL) g_object_unref (file);
+	
+	return;
+}
+
+
+static void
+do_read (
+	GVfsBackend *backend,
+	GVfsJobRead *job,
+	GVfsBackendHandle handle,
+	char *buffer,
+	gsize bytes_requested)
+{
+	GError *error;
+	struct DiceHandle *dice_handle = (struct DiceHandle *)handle;
+	gssize s;
+
+	g_assert (dice_handle != NULL);
+	g_assert (dice_handle->input_stream);
+	
+	g_print ("(II) do_read (handle = '%lx', buffer = '%lx', bytes_requested = %ld) \n", 
+			 (long int)dice_handle->input_stream, (long int)buffer, (long int)bytes_requested);
+
+	error = NULL;
+	s = g_input_stream_read (G_INPUT_STREAM (dice_handle->input_stream), buffer, bytes_requested, 
+	G_VFS_JOB (job)->cancellable, &error); 
+	if (s >= 0)
+	{
+		g_vfs_job_read_set_size (job, s);
+		g_vfs_job_succeeded (G_VFS_JOB (job));
+		g_print ("(II) do_read success. \n");
+	}
+	else
+	{
+		g_vfs_job_failed_from_error (G_VFS_JOB (job), error); 
+		g_print ("  (EE) do_read: g_input_stream_read() failed, error: %s \n", error->message);
+		g_error_free (error);
+	}
+}
+
+
+static void
+do_seek_on_read (
+	GVfsBackend *backend,
+	GVfsJobSeekRead *job,
+	GVfsBackendHandle handle,
+	goffset    offset,
+	GSeekType  type)
+{
+	GError *error;
+	struct DiceHandle *dice_handle = (struct DiceHandle *)handle;
+
+	g_assert (dice_handle != NULL);
+	g_assert (dice_handle->input_stream != NULL);
+	
+	g_print (
+		"(II) do_seek_on_read (handle = '%lx', offset = %ld) \n", 
+		(long int)dice_handle->input_stream, 
+		(long int)offset);
+	  
+	error = NULL;
+	if (g_seekable_seek (
+			G_SEEKABLE (dice_handle->input_stream), 
+			offset, 
+			type, 
+			G_VFS_JOB (job)->cancellable, &error))
+	{
+		g_vfs_job_seek_read_set_offset (job, g_seekable_tell (G_SEEKABLE (dice_handle->input_stream)));
+		g_vfs_job_succeeded (G_VFS_JOB (job));
+		g_print ("(II) do_seek_on_read success. \n");
+	}
+	else
+	{
+		g_vfs_job_failed_from_error (G_VFS_JOB (job), error); 
+		g_print ("  (EE) do_seek_on_read: g_file_input_stream_seek() failed, error: %s \n", error->message);
+		g_error_free (error);
+	}
+}
+
+
+static void
+do_close_read (
+	GVfsBackend *backend,
+	GVfsJobCloseRead *job,
+	GVfsBackendHandle handle)
+{
+	GError *error;
+	struct DiceHandle *dice_handle = (struct DiceHandle *)handle;
+
+	g_assert (dice_handle != NULL);
+	g_assert (dice_handle->input_stream != NULL);
+	
+	g_print ("(II) do_close_read (handle = '%lx') \n", (long int)dice_handle->input_stream);
+	  
+	error = NULL;
+	if (g_input_stream_close (
+			G_INPUT_STREAM (dice_handle->input_stream), 
+			G_VFS_JOB (job)->cancellable, &error))
+	{
+		g_object_unref (dice_handle->input_stream);
+		if (dice_handle->file_path != NULL)
+			g_free (dice_handle->file_path);
+		g_free (dice_handle);
+		g_vfs_job_succeeded (G_VFS_JOB (job));
+		g_print ("(II) try_close_read success. \n");
+	}
+	else
+	{
+		g_vfs_job_failed_from_error (G_VFS_JOB (job), error); 
+		g_print ("  (EE) try_close_read: g_input_stream_close() failed, error: %s \n", error->message);
+		g_error_free (error);
+	}
+}
+
+
+/*******************
+ * Write Functions *
+ *******************/
+
+static void
+do_create (
+	GVfsBackend *backend,
+	GVfsJobOpenForWrite *job,
+	const char *filename,
+	GFileCreateFlags flags)
+{
+	GVfsBackendDice *dice_backend = G_VFS_BACKEND_DICE (backend);
+	GError *error;
+	GFileInfo *info = NULL;
+	GFile *file;
+	struct DiceHandle *dice_handle;
+	
+	info = 
+		get_g_file_info_from_dice (
+			dice_backend,
+			filename,
+			"*",
+			G_FILE_QUERY_INFO_NONE,
+			G_VFS_JOB (job),
+			&error);
+	
+//		g_file_new_for_path (filename);
+	if (info != NULL)
+	{
+		if (error != NULL) g_error_free (error);
+		g_object_unref (info);
+		error = g_error_new (G_IO_ERROR, G_IO_ERROR_EXISTS, _("Target file already exists"));
+		g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
+		g_error_free (error);
+		return;
+	}
+	
+	// Create a limbo entry in the dice database
+	info = create_g_file_info_in_dice (dice_backend, filename, &error);
+	if (info == NULL)
+	{
+		// The error returned from the dice create call
+		// will be converted to the correct GIO_ERROR
+		g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
+		g_error_free (error);
+		return;
+	}
+
+	g_printf ("Successfully created the file locally");
+	
+	// Open the real local file file!
+	const char *local_path = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_DICE_LOCAL_PATH);
+	g_assert (local_path != NULL);
+
+	g_printf ("local path: %s\n", local_path);
+	file = get_g_file_from_local (local_path, G_VFS_JOB (job));
+	g_object_unref (info);
+
+	error = NULL;
+	GFileOutputStream *stream = g_file_create (file, flags, G_VFS_JOB (job)->cancellable, &error);
+	if (stream != NULL && !error)
+	{
+		g_printf ("g_file_create was successful\n");
+		dice_handle = g_malloc (sizeof (struct DiceHandle));
+		dice_handle->file_path = g_strdup (filename);
+		dice_handle->output_stream = stream;
+
+		//g_vfs_job_open_for_write_set_can_seek (job, TRUE);
+		g_vfs_job_open_for_write_set_handle (job, dice_handle);
+
+		//g_vfs_job_open_for_write_set_handle (G_VFS_JOB_OPEN_FOR_WRITE (job), dice_stream);
+		//g_vfs_job_open_for_write_set_can_seek (G_VFS_JOB_OPEN_FOR_WRITE (job), g_seekable_can_seek (G_SEEKABLE (stream)));
+		////g_vfs_job_succeeded (G_VFS_JOB (job));
+		g_printf ("g_vfs_job_succeeded\n");
+	}
+	else
+	{
+		g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
+		g_error_free (error);
+	}
+	
+	g_object_unref (file);
+	return;
+}
+
+
+static void
+do_close_write (
+	GVfsBackend *backend,
+	GVfsJobCloseWrite *job,
+	GVfsBackendHandle handle)
+{
+	GVfsBackendDice *dice_backend = G_VFS_BACKEND_DICE (backend);
+	GError *error = NULL;
+	struct DiceHandle *dice_handle = (struct DiceHandle *)handle;
+	
+	g_print ("(II) do_close_write (handle = '%lx') \n", (long int)handle);
+	g_assert (dice_handle != NULL);
+	g_assert (dice_handle->output_stream != NULL);
+	g_assert (dice_handle->file_path != NULL);
+	
+	if (!g_output_stream_close (
+			G_OUTPUT_STREAM(dice_handle->output_stream), 
+			G_VFS_JOB (job)->cancellable, 
+			&error))
+	{
+		g_printf ("Failed closing the output stream\n");
+		goto do_close_write_error;
+	}
+
+	// Notify DICE daemon that the file has been closed/changed
+	error = NULL;
+	if (update_local_file_in_dice (
+			dice_backend,
+			dice_handle->file_path,
+			&error) == FALSE)
+	{
+		g_print ("(II) failed updating dice of changes\n");
+		goto do_close_write_error;
+	}
+		
+	g_object_unref (dice_handle->output_stream);
+	if (dice_handle->file_path != NULL)
+		g_free (dice_handle->file_path);
+	g_free (dice_handle);
+	g_vfs_job_succeeded (G_VFS_JOB (job));
+	g_print ("(II) do_close_write success. \n");
+	return;
+
+do_close_write_error:
+	if (dice_handle != NULL)
+	{
+		if (dice_handle->file_path != NULL)
+			g_free (dice_handle->file_path);
+		g_free (dice_handle);
+	}
+	
+	g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
+	g_print ("  (EE) do_close_write: failed, error: %s \n", error->message);
+	g_error_free (error);
+	return;
+}
+
+
+static void
+do_write (
+	GVfsBackend *backend,
+	GVfsJobWrite *job,
+	GVfsBackendHandle handle,
+	char *buffer,
+	gsize buffer_size)
+{
+	GError *error;
+	struct DiceHandle *dice_handle = (struct DiceHandle *)handle;
+	gssize s;
+
+	g_print (
+		"(II) do_write (handle = '%lx', buffer = '%lx', buffer_size = %ld) \n",
+		(long int)handle, 
+		(long int)buffer, 
+		(long int)buffer_size);
+
+	g_assert (dice_handle != NULL);
+	g_assert (dice_handle->output_stream != NULL);
+	  
+	error = NULL;
+	s = 
+		g_output_stream_write (
+			G_OUTPUT_STREAM (dice_handle->output_stream), 
+			buffer, 
+			buffer_size, 
+			G_VFS_JOB (job)->cancellable, 
+			&error);
+	if (s >= 0)
+	{
+		g_vfs_job_write_set_written_size (job, s);
+		g_vfs_job_succeeded (G_VFS_JOB (job));
+		g_print ("(II) do_write success. \n");
+	}
+	else
+	{
+		g_vfs_job_failed_from_error (G_VFS_JOB (job), error); 
+		g_print (
+			"  (EE) do_write: g_output_stream_write() failed, error: %s \n", 
+			error->message);
+		g_error_free (error);
+	}
+}
+
+
+static void
+do_append (
+	GVfsBackend *backend,
+	GVfsJobOpenForWrite *job,
+	const char *filename,
+	GFileCreateFlags flags)
+{
+	GVfsBackendDice *dice_backend = G_VFS_BACKEND_DICE (backend);
+	GError *error;
+	GFileInfo *info;
+	GFile *file;
+	struct DiceHandle *dice_handle = NULL;
+	
+	g_print ("(II) do_append (filename = %s) \n", filename);
+	
+	info = 
+		get_g_file_info_from_dice (
+			dice_backend,
+			filename,
+			"*",
+			G_FILE_QUERY_INFO_NONE,
+			G_VFS_JOB (job),
+			&error);
+	
+	if (info == NULL)
+	{
+		if (error != NULL) g_error_free (error);
+		// The file must not exist, so just use the create function
+		do_create (backend, job, filename, flags);
+		return;
+	}
+
+	// Get the real local path
+	const char *local_path = 
+		g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_DICE_LOCAL_PATH);
+	g_assert (local_path != NULL);
+
+	file = get_g_file_from_local (local_path, G_VFS_JOB (job));
+	g_object_unref (info);
+
+	g_assert (file != NULL);
+
+	if (file != NULL)
+	{
+		error = NULL;
+		dice_handle = g_malloc (sizeof (struct DiceHandle));
+		dice_handle->output_stream = 
+			g_file_append_to (file, flags, G_VFS_JOB (job)->cancellable, &error);
+		g_object_unref (file);
+		if (dice_handle->output_stream)
+		{
+			/*  Should seek at the end of the file here  */
+			if ((g_seekable_seek (
+					G_SEEKABLE (dice_handle->output_stream), 
+					0, 
+					G_SEEK_END, 
+					G_VFS_JOB (job)->cancellable, &error)) && (! error))
+			{
+				g_vfs_job_open_for_write_set_initial_offset (
+					job, 
+					g_seekable_tell (G_SEEKABLE (dice_handle->output_stream)));
+			}
+			else
+			{
+				g_print ("  (EE) do_append: error during g_file_output_stream_seek(), error: %s \n", error->message);
+			}
+			
+			// Store the filename so we can close properly and notify the DICE Daemon
+			dice_handle->file_path = g_strdup (filename);
+			g_vfs_job_open_for_write_set_can_seek (
+				job,
+				g_seekable_can_seek (G_SEEKABLE (dice_handle->output_stream)));
+			g_vfs_job_open_for_write_set_handle (job, dice_handle);
+			g_vfs_job_succeeded (G_VFS_JOB (job));
+
+			g_print ("(II) do_append success. \n");
+		}
+		else
+		{
+			g_free (dice_handle);
+			g_vfs_job_failed_from_error (G_VFS_JOB (job), error); 
+			g_print ("  (EE) do_append: stream == NULL, error: %s \n", error->message);
+			g_error_free (error);
+		}
+	}
+	else
+	{
+		g_print ("  (EE) do_append: file == NULL \n");
+
+		g_vfs_job_failed (
+			G_VFS_JOB (job),
+			G_IO_ERROR,
+			G_IO_ERROR_NOT_FOUND,
+			_("Unable to get the local path"));
+	}
+}
+
+
+static void
+do_replace (
+	GVfsBackend *backend,
+	GVfsJobOpenForWrite *job,
+	const char *filename,
+	const char *etag,
+	gboolean make_backup,
+	GFileCreateFlags flags)
+{
+	GVfsBackendDice *dice_backend = G_VFS_BACKEND_DICE (backend);
+	struct DiceHandle *dice_handle = NULL;
+	GError *error = NULL;
+	GFile *file = NULL;
+	GFileInfo *info = NULL;
+	
+	g_print ("(II) do_replace (filename = '%s', etag = '%s') \n", filename, etag);
+	g_print ("\t\t make_backup == %s\n", (make_backup == TRUE) ? "TRUE" : "FALSE");
+	g_print ("\t\t create flags == %X\n", flags);
+
+	if (make_backup == TRUE)
+	{
+		g_printf ("\t\tcan't create backups yet - fail");
+		
+		error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_CANT_CREATE_BACKUP, 
+				_("backup creation is not supported"));
+
+		goto do_replace_error;
+	}
+
+
+	// Check if the file already exists in the DICE namespace
+	info = 
+		get_g_file_info_from_dice (
+			dice_backend,
+			filename,
+			"*",
+			G_FILE_QUERY_INFO_NONE,
+			G_VFS_JOB (job),
+			&error);
+	
+	if (info == NULL)
+	{
+		if (error != NULL)
+		{
+			g_error_free (error);
+			error = NULL;
+		}
+		
+		g_printf ("\t\tfailed to find the filename in the dice namespace");
+
+		// Create a limbo entry in the dice database
+		info = create_g_file_info_in_dice (dice_backend, filename, &error);
+		if (info == NULL)
+		{
+			// The error returned from the dice create call
+			// will be converted to the correct GIO_ERROR
+			goto do_replace_error;
+		}
+
+		/*
+		if (etag == NULL)
+			etag = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_ID_FILE);
+		*/
+
+		g_printf ("Successfully created the file locally");
+	}
+
+	// Get the real local path
+	const char *local_path = 
+		g_file_info_get_attribute_string (info,	G_FILE_ATTRIBUTE_DICE_LOCAL_PATH);
+
+	g_assert (local_path != NULL);
+	g_printf ("local path: %s\n", local_path);
+
+	// Create a GFile object from the local path
+	file = get_g_file_from_local (local_path, G_VFS_JOB (job));
+	if (file == NULL)
+	{
+		g_print ("  (EE) do_replace: file == NULL \n");
+		g_assert (file != NULL);
+		error = 
+			g_error_new (
+				G_IO_ERROR, 
+				G_IO_ERROR_NOT_FOUND, 
+				_("Unable to get the local path"));
+
+		goto do_replace_error;
+	}
+
+	dice_handle = g_malloc (sizeof (struct DiceHandle));
+	dice_handle->output_stream = 
+		g_file_replace (
+			file, 
+			NULL,
+			make_backup, 
+			flags, 
+			G_VFS_JOB (job)->cancellable,
+			&error);
+
+	if (dice_handle->output_stream == NULL)
+	{
+		g_print ("  (EE) do_replace: stream == NULL, error: %s \n", error->message);
+		goto do_replace_error;
+	}
+
+
+	// Save off the filename so we can notify DICE Daemon during a close
+	dice_handle->file_path = g_strdup (filename);
+	g_vfs_job_open_for_write_set_handle (job, dice_handle);
+	g_object_unref (file);
+	g_object_unref (info);
+	g_vfs_job_succeeded (G_VFS_JOB (job));
+
+	// Call dice with a local update
+	if (update_local_file_in_dice (
+			dice_backend,
+			filename,
+			&error) == FALSE)
+	{
+		g_error_free (error);
+	}
+
+	g_print ("(II) do_replace success. \n");
+	return;
+
+do_replace_error:
+	g_print ("  do_replace failed - error message: %s\n", error->message);
+	g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
+	if (error != NULL) g_error_free (error);
+	if (info != NULL) g_object_unref (info);
+	if (file != NULL) g_object_unref (file);
+	if (dice_handle != NULL) g_free (dice_handle);
+	return;
+}
+
+
+static void
+do_delete (
+	GVfsBackend *backend,
+	GVfsJobDelete *job,
+	const char *filename)
+{
+	GVfsBackendDice *dice_backend = G_VFS_BACKEND_DICE (backend);
+	GError *error;
+
+	g_print ("(II) do_delete (filename = %s) \n", filename);
+
+	if (filename != NULL)
+	{
+		error = NULL;
+		if (delete_local_file_from_dice (dice_backend, filename, &error))
+		{
+			g_vfs_job_succeeded (G_VFS_JOB (job));
+			g_print ("(II) do_delete success. \n");
+		}
+		else
+		{
+			g_vfs_job_failed_from_error (G_VFS_JOB (job), error); 
+			g_print ("  (EE) do_delete: g_file_delete == FALSE, error: %s \n", error->message);
+			g_error_free (error);
+		}
+	}
+	else
+	{
+		g_print ("  (EE) do_delete: filename == NULL \n");
+	}
+}
+
+
+static void
+g_vfs_backend_dice_class_init (GVfsBackendDiceClass *klass)
+{
+	GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+	GVfsBackendClass *backend_class = G_VFS_BACKEND_CLASS (klass);
+	
+	gobject_class->finalize = g_vfs_backend_dice_finalize;
+
+	backend_class->mount = do_mount;
+	backend_class->unmount = do_unmount;
+	backend_class->query_info = do_query_info;
+	backend_class->query_fs_info = do_query_fs_info;
+	backend_class->enumerate = do_enumerate;
+	
+	backend_class->open_for_read = do_open_for_read;
+	backend_class->read = do_read;
+	backend_class->seek_on_read = do_seek_on_read;
+	backend_class->close_read = do_close_read;
+
+	backend_class->create = do_create;
+	backend_class->close_write = do_close_write;
+	backend_class->write = do_write;
+	backend_class->append_to = do_append;
+	backend_class->replace = do_replace;
+
+	backend_class->delete = do_delete;
+	
+//	backend_class->move = do_move;
+//	backend_class->make_directory = do_make_directory;
+	
+//	backend_class->create_dir_monitor = do_create_dir_monitor;
+//	backend_class->create_file_monitor = do_create_file_monitor;
+}
Index: gvfs-1.5.5/daemon/gvfsbackenddice.h
===================================================================
--- /dev/null
+++ gvfs-1.5.5/daemon/gvfsbackenddice.h
@@ -0,0 +1,50 @@
+/* Novell IceDesktop Backend for GVfs
+ * 
+ * Copyright (C) 2008 Novell, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author: Boyd Timothy <btimothy@novell.com>
+ */
+
+#ifndef __G_VFS_BACKEND_DICE_H__
+#define __G_VFS_BACKEND_DICE_H__
+
+#include <gvfsbackend.h>
+#include <gmountspec.h>
+
+G_BEGIN_DECLS
+
+#define G_VFS_TYPE_BACKEND_DICE         (g_vfs_backend_dice_get_type ())
+#define G_VFS_BACKEND_DICE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_VFS_TYPE_BACKEND_DICE, GVfsBackendDice))
+#define G_VFS_BACKEND_DICE_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), G_VFS_TYPE_BACKEND_DICE, GVfsBackendDiceClass))
+#define G_VFS_IS_BACKEND_DICE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_VFS_TYPE_BACKEND_DICE))
+#define G_VFS_IS_BACKEND_DICE_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), G_VFS_TYPE_BACKEND_DICE))
+#define G_VFS_BACKEND_DICE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), G_VFS_TYPE_BACKEND_DICE, GVfsBackendDiceClass))
+
+typedef struct _GVfsBackendDice        GVfsBackendDice;
+typedef struct _GVfsBackendDiceClass   GVfsBackendDiceClass;
+
+struct _GVfsBackendDiceClass
+{
+  GVfsBackendClass parent_class;
+};
+
+GType g_vfs_backend_dice_get_type (void) G_GNUC_CONST;
+
+G_END_DECLS
+
+#endif /* __G_VFS_BACKEND_DICE_H__ */
Index: gvfs-1.5.5/daemon/Makefile.am
===================================================================
--- gvfs-1.5.5.orig/daemon/Makefile.am
+++ gvfs-1.5.5/daemon/Makefile.am
@@ -10,6 +10,7 @@ INCLUDES =					\
 	-I$(top_srcdir)/common			\
 	-I$(top_builddir)			\
 	$(GLIB_CFLAGS) $(DBUS_CFLAGS) 		\
+	$(DBUS_GLIB_CFLAGS)			\
 	$(OBEXFTP_CFLAGS) $(EXPAT_CFLAGS)	\
 	$(KEYRING_CFLAGS)			\
 	-DDBUS_API_SUBJECT_TO_CHANGE		\
@@ -24,7 +25,7 @@ noinst_LTLIBRARIES=libdaemon.la
 libraries =						\
 	libdaemon.la					\
 	$(top_builddir)/common/libgvfscommon.la		\
-	$(GLIB_LIBS) $(DBUS_LIBS) $(KEYRING_LIBS)
+	$(GLIB_LIBS) $(DBUS_LIBS) $(DBUS_GLIB_LIBS) $(KEYRING_LIBS)
 
 # D-BUS service file
 %.service: %.service.in ../config.log
@@ -37,10 +38,10 @@ service_DATA = gvfs-daemon.service
 %.mount: %.mount.in ../config.log
 	$(AM_V_GEN) $(SED) -e "s|\@libexecdir\@|$(libexecdir)|" $< > $@
 
-libexec_PROGRAMS=gvfsd gvfsd-sftp gvfsd-trash gvfsd-computer gvfsd-burn gvfsd-localtest gvfsd-ftp
+libexec_PROGRAMS=gvfsd gvfsd-sftp gvfsd-trash gvfsd-computer gvfsd-burn gvfsd-localtest gvfsd-ftp gvfsd-dice
 
-mount_in_files = sftp.mount.in trash.mount.in computer.mount.in burn.mount.in localtest.mount.in
-mount_DATA =  sftp.mount trash.mount computer.mount burn.mount localtest.mount
+mount_in_files = sftp.mount.in trash.mount.in computer.mount.in burn.mount.in localtest.mount.in dice.mount.in
+mount_DATA =  sftp.mount trash.mount computer.mount burn.mount localtest.mount dice.mount
 
 mount_in_files += http.mount.in dav.mount.in dav+sd.mount.in ftp.mount.in 
 if HAVE_HTTP
@@ -292,6 +293,19 @@ gvfsd_trash_CPPFLAGS = \
 
 gvfsd_trash_LDADD = trashlib/libtrash.a $(libraries)
 
+gvfsd_dice_SOURCES = \
+	gvfsbackenddice.c gvfsbackenddice.h \
+	daemon-main.c daemon-main.h \
+	daemon-main-generic.c
+
+gvfsd_dice_CPPFLAGS = \
+	-DBACKEND_HEADER=gvfsbackenddice.h \
+	-DDEFAULT_BACKEND_TYPE=dice \
+	-DMAX_JOB_THREADS=10 \
+	-DBACKEND_TYPES='"dice", G_VFS_TYPE_BACKEND_DICE,'
+
+gvfsd_dice_LDADD = $(libraries)
+
 gvfsd_computer_SOURCES = \
 	gvfsbackendcomputer.c gvfsbackendcomputer.h \
 	daemon-main.c daemon-main.h \