Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
openSUSE:11.4
gvfs
gvfs-dice-backend.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File gvfs-dice-backend.patch of Package gvfs
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 \
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
