From 7d1a01028bff13ae621b4874ccdfbfd363ee02a1 Mon Sep 17 00:00:00 2001 From: short <> Date: Tue, 9 Sep 2003 17:27:29 +0000 Subject: [PATCH] Split (vfs|directory|file) to &, &_parent and &_slave by inheritance. --- src/libcaptive/client/Makefile.am | 12 + src/libcaptive/client/directory-parent.c | 167 ++++ src/libcaptive/client/directory-parent.h | 65 ++ src/libcaptive/client/directory-slave.c | 514 ++++++++++++ src/libcaptive/client/directory-slave.h | 83 ++ src/libcaptive/client/directory.c | 412 +--------- src/libcaptive/client/directory.h | 28 +- src/libcaptive/client/file-parent.c | 281 +++++++ src/libcaptive/client/file-parent.h | 63 ++ src/libcaptive/client/file-slave.c | 872 +++++++++++++++++++++ src/libcaptive/client/file-slave.h | 53 ++ src/libcaptive/client/file.c | 719 ++--------------- src/libcaptive/client/file.h | 22 +- src/libcaptive/client/vfs-parent.c | 148 ++++ src/libcaptive/client/vfs-parent.h | 74 ++ src/libcaptive/client/vfs-slave.c | 210 +++++ src/libcaptive/client/vfs-slave.h | 46 ++ src/libcaptive/client/vfs.c | 105 +-- src/libcaptive/client/vfs.h | 36 +- src/libcaptive/include/captive/Makefile.am | 3 - src/libcaptive/sandbox/Makefile.am | 3 + src/libcaptive/sandbox/parent-Directory.c | 155 ++-- .../captive => sandbox}/parent-Directory.h | 18 +- src/libcaptive/sandbox/parent-File.c | 201 +++-- .../{include/captive => sandbox}/parent-File.h | 34 +- src/libcaptive/sandbox/parent-Vfs.c | 136 ++-- .../{include/captive => sandbox}/parent-Vfs.h | 16 +- src/libcaptive/sandbox/server-Directory.c | 5 +- src/libcaptive/sandbox/server-File.c | 5 +- src/libcaptive/sandbox/server-GLogFunc.c | 10 +- src/libcaptive/sandbox/server-GLogFunc.h | 5 +- src/libcaptive/sandbox/server-Vfs.c | 3 +- src/libcaptive/sandbox/split.c | 110 +-- src/libcaptive/sandbox/split.h | 5 +- 34 files changed, 3115 insertions(+), 1504 deletions(-) create mode 100644 src/libcaptive/client/directory-parent.c create mode 100644 src/libcaptive/client/directory-parent.h create mode 100644 src/libcaptive/client/directory-slave.c create mode 100644 src/libcaptive/client/directory-slave.h create mode 100644 src/libcaptive/client/file-parent.c create mode 100644 src/libcaptive/client/file-parent.h create mode 100644 src/libcaptive/client/file-slave.c create mode 100644 src/libcaptive/client/file-slave.h create mode 100644 src/libcaptive/client/vfs-parent.c create mode 100644 src/libcaptive/client/vfs-parent.h create mode 100644 src/libcaptive/client/vfs-slave.c create mode 100644 src/libcaptive/client/vfs-slave.h rename src/libcaptive/{include/captive => sandbox}/parent-Directory.h (71%) rename src/libcaptive/{include/captive => sandbox}/parent-File.h (57%) rename src/libcaptive/{include/captive => sandbox}/parent-Vfs.h (67%) diff --git a/src/libcaptive/client/Makefile.am b/src/libcaptive/client/Makefile.am index f317617..f56cfac 100644 --- a/src/libcaptive/client/Makefile.am +++ b/src/libcaptive/client/Makefile.am @@ -21,8 +21,16 @@ include $(top_srcdir)/src/libcaptive/Makefile-libcaptive.am noinst_LTLIBRARIES=libclient.la libclient_la_SOURCES= \ + directory-slave.c \ + directory-slave.h \ + directory-parent.c \ + directory-parent.h \ directory.c \ directory.h \ + file-parent.c \ + file-parent.h \ + file-slave.c \ + file-slave.h \ file.c \ file.h \ giochannel-blind.c \ @@ -38,6 +46,10 @@ libclient_la_SOURCES= \ result.c \ result.h \ usecount.c \ + vfs-parent.c \ + vfs-parent.h \ + vfs-slave.c \ + vfs-slave.h \ vfs.c \ vfs.h libclient_la_CFLAGS= \ diff --git a/src/libcaptive/client/directory-parent.c b/src/libcaptive/client/directory-parent.c new file mode 100644 index 0000000..6a473cf --- /dev/null +++ b/src/libcaptive/client/directory-parent.c @@ -0,0 +1,167 @@ +/* $Id$ + * captive vfs 'directory' interface to reactos of sandbox parent + * Copyright (C) 2002-2003 Jan Kratochvil + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; exactly version 2 of June 1991 is required + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include "config.h" + +#include "directory-parent.h" /* self */ +#include +#include "../sandbox/parent-Directory.h" +#include "vfs-parent.h" + + +static gpointer captive_directory_parent_object_parent_class=NULL; + + +static GnomeVFSResult captive_directory_parent_close(CaptiveDirectoryObject *captive_directory_object); +static GnomeVFSResult captive_directory_parent_read + (CaptiveDirectoryObject *captive_directory_object,GnomeVFSFileInfo *file_info); +static GnomeVFSResult captive_directory_parent_remove(CaptiveDirectoryObject *captive_directory_object); + + +static void captive_directory_parent_object_finalize(CaptiveDirectoryParentObject *captive_directory_parent_object) +{ + g_return_if_fail(captive_directory_parent_object!=NULL); + + captive_directory_parent_close(CAPTIVE_DIRECTORY_OBJECT(captive_directory_parent_object)); /* errors ignored */ + + G_OBJECT_CLASS(captive_directory_parent_object_parent_class)->finalize((GObject *)captive_directory_parent_object); +} + + +static void captive_directory_parent_object_class_init(CaptiveDirectoryParentObjectClass *class) +{ +GObjectClass *gobject_class=G_OBJECT_CLASS(class); +CaptiveDirectoryObjectClass *captive_directory_object_class=CAPTIVE_DIRECTORY_OBJECT_CLASS(class); + + captive_directory_parent_object_parent_class=g_type_class_ref(g_type_parent(G_TYPE_FROM_CLASS(class))); + gobject_class->finalize=(void (*)(GObject *object))captive_directory_parent_object_finalize; + + captive_directory_object_class->read=captive_directory_parent_read; + captive_directory_object_class->remove=captive_directory_parent_remove; +} + + +static void captive_directory_parent_object_init(CaptiveDirectoryParentObject *captive_directory_parent_object) +{ +} + + +GType captive_directory_parent_object_get_type(void) +{ +static GType captive_directory_parent_object_type=0; + + if (!captive_directory_parent_object_type) { +static const GTypeInfo captive_directory_parent_object_info={ + sizeof(CaptiveDirectoryParentObjectClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc)captive_directory_parent_object_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof(CaptiveDirectoryParentObject), + 5, /* n_preallocs */ + (GInstanceInitFunc)captive_directory_parent_object_init, + }; + + captive_directory_parent_object_type=g_type_register_static(CAPTIVE_DIRECTORY_TYPE_OBJECT, + "CaptiveDirectoryParentObject",&captive_directory_parent_object_info,0); + } + + return captive_directory_parent_object_type; +} + + +GnomeVFSResult captive_directory_parent_new_open(CaptiveDirectoryObject **captive_directory_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname) +{ +CaptiveDirectoryParentObject *captive_directory_parent_object; + + g_return_val_if_fail(captive_directory_object_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_PARENT_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_directory_parent_object=g_object_new( + CAPTIVE_DIRECTORY_PARENT_TYPE_OBJECT, /* object_type */ + NULL); /* first_property_name; FIXME: support properties */ + + captive_directory_init(CAPTIVE_DIRECTORY_OBJECT(captive_directory_parent_object),captive_vfs_object); + + *captive_directory_object_return=CAPTIVE_DIRECTORY_OBJECT(captive_directory_parent_object); + + return captive_sandbox_parent_directory_new_open(captive_directory_parent_object,pathname); +} + + +GnomeVFSResult captive_directory_parent_new_make(CaptiveDirectoryObject **captive_directory_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname,guint perm) +{ +CaptiveDirectoryParentObject *captive_directory_parent_object; + + g_return_val_if_fail(captive_directory_object_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_PARENT_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_directory_parent_object=g_object_new( + CAPTIVE_DIRECTORY_PARENT_TYPE_OBJECT, /* object_type */ + NULL); /* first_property_name; FIXME: support properties */ + + captive_directory_init(CAPTIVE_DIRECTORY_OBJECT(captive_directory_parent_object),captive_vfs_object); + + *captive_directory_object_return=CAPTIVE_DIRECTORY_OBJECT(captive_directory_parent_object); + + return captive_sandbox_parent_directory_new_make(captive_directory_parent_object,pathname,perm); +} + + +static GnomeVFSResult captive_directory_parent_close(CaptiveDirectoryObject *captive_directory_object) +{ +CaptiveDirectoryParentObject *captive_directory_parent_object; + + g_return_val_if_fail(CAPTIVE_DIRECTORY_PARENT_IS_OBJECT(captive_directory_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_directory_parent_object=CAPTIVE_DIRECTORY_PARENT_OBJECT(captive_directory_object); + + return captive_sandbox_parent_directory_close(captive_directory_parent_object); +} + + +static GnomeVFSResult captive_directory_parent_read + (CaptiveDirectoryObject *captive_directory_object,GnomeVFSFileInfo *file_info) +{ +CaptiveDirectoryParentObject *captive_directory_parent_object; + + g_return_val_if_fail(CAPTIVE_DIRECTORY_PARENT_IS_OBJECT(captive_directory_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_directory_parent_object=CAPTIVE_DIRECTORY_PARENT_OBJECT(captive_directory_object); + + return captive_sandbox_parent_directory_read(captive_directory_parent_object,file_info); +} + + +static GnomeVFSResult captive_directory_parent_remove(CaptiveDirectoryObject *captive_directory_object) +{ +CaptiveDirectoryParentObject *captive_directory_parent_object; + + g_return_val_if_fail(CAPTIVE_DIRECTORY_PARENT_IS_OBJECT(captive_directory_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_directory_parent_object=CAPTIVE_DIRECTORY_PARENT_OBJECT(captive_directory_object); + + return captive_sandbox_parent_directory_remove(captive_directory_parent_object); +} diff --git a/src/libcaptive/client/directory-parent.h b/src/libcaptive/client/directory-parent.h new file mode 100644 index 0000000..a2ab98e --- /dev/null +++ b/src/libcaptive/client/directory-parent.h @@ -0,0 +1,65 @@ +/* $Id$ + * Include file for captive vfs 'directory' private interface to reactos of sandbox parent + * Copyright (C) 2003 Jan Kratochvil + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; exactly version 2 of June 1991 is required + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#ifndef _CAPTIVE_CLIENT_PRIV_DIRECTORY_PARENT_H +#define _CAPTIVE_CLIENT_PRIV_DIRECTORY_PARENT_H 1 + + +#include +#include +#include +#include "captive/client-directory.h" /* for CaptiveDirectoryObject */ +#include "directory.h" /* for CaptiveDirectoryObject priv */ +#include "../sandbox/sandbox.h" + + +G_BEGIN_DECLS + +#define CAPTIVE_DIRECTORY_PARENT_TYPE_OBJECT (captive_directory_parent_object_get_type()) +#define CAPTIVE_DIRECTORY_PARENT_OBJECT(object) (G_TYPE_CHECK_INSTANCE_CAST((object),CAPTIVE_DIRECTORY_PARENT_TYPE_OBJECT,CaptiveDirectoryParentObject)) +#define CAPTIVE_DIRECTORY_PARENT_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),CAPTIVE_DIRECTORY_PARENT_TYPE_OBJECT,CaptiveDirectoryParentObjectClass)) +#define CAPTIVE_DIRECTORY_PARENT_IS_OBJECT(object) (G_TYPE_CHECK_INSTANCE_TYPE((object),CAPTIVE_DIRECTORY_PARENT_TYPE_OBJECT)) +#define CAPTIVE_DIRECTORY_PARENT_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),CAPTIVE_DIRECTORY_PARENT_TYPE_OBJECT)) +#define CAPTIVE_DIRECTORY_PARENT_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),CAPTIVE_DIRECTORY_PARENT_TYPE_OBJECT,CaptiveDirectoryParentObjectClass)) +typedef struct _CaptiveDirectoryParentObject CaptiveDirectoryParentObject; +typedef struct _CaptiveDirectoryParentObjectClass CaptiveDirectoryParentObjectClass; + + +GType captive_directory_parent_object_get_type(void); + +struct _CaptiveDirectoryParentObject { + CaptiveDirectoryObject parent_instance; + + /*< private >*/ + Captive_Directory corba_Directory_object; + GList *corba_Directory_file_info_list; /* contents */ + }; +struct _CaptiveDirectoryParentObjectClass { + CaptiveDirectoryObjectClass parent_class; + }; + +GnomeVFSResult captive_directory_parent_new_open(CaptiveDirectoryObject **captive_directory_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname); +GnomeVFSResult captive_directory_parent_new_make(CaptiveDirectoryObject **captive_directory_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname,guint perm); + +G_END_DECLS + + +#endif /* _CAPTIVE_CLIENT_PRIV_DIRECTORY_PARENT_H */ diff --git a/src/libcaptive/client/directory-slave.c b/src/libcaptive/client/directory-slave.c new file mode 100644 index 0000000..e61571e --- /dev/null +++ b/src/libcaptive/client/directory-slave.c @@ -0,0 +1,514 @@ +/* $Id$ + * captive vfs 'directory' interface to reactos of sandbox slave + * Copyright (C) 2002-2003 Jan Kratochvil + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; exactly version 2 of June 1991 is required + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include "config.h" + +#include "directory-slave.h" /* self */ +#include "captive/client-directory.h" /* for CaptiveDirectoryObject */ +#include "directory.h" /* for CaptiveDirectoryObject priv */ +#include "lib.h" +#include +#include "captive/unicode.h" +#include "reactos/ntos/types.h" /* for HANDLE */ +#include "reactos/ddk/iotypes.h" /* for IO_STATUS_BLOCK */ +#include "reactos/ddk/iofuncs.h" /* for IoCreateFile() */ +#include "result.h" +#include "captive/leave.h" +#include "captive/usecount.h" +#include "vfs.h" +#include "vfs-slave.h" + + +static gpointer captive_directory_slave_object_parent_class=NULL; + +static GnomeVFSResult captive_directory_slave_close(CaptiveDirectoryObject *captive_directory_object); +static GnomeVFSResult captive_directory_slave_read + (CaptiveDirectoryObject *captive_directory_object,GnomeVFSFileInfo *file_info); +static GnomeVFSResult captive_directory_slave_remove(CaptiveDirectoryObject *captive_directory_object); + + +static void captive_directory_slave_object_finalize(CaptiveDirectorySlaveObject *captive_directory_slave_object) +{ + g_return_if_fail(captive_directory_slave_object!=NULL); + + captive_directory_slave_close(CAPTIVE_DIRECTORY_OBJECT(captive_directory_slave_object)); /* errors ignored */ + + G_OBJECT_CLASS(captive_directory_slave_object_parent_class)->finalize((GObject *)captive_directory_slave_object); +} + + +static void captive_directory_slave_object_class_init(CaptiveDirectorySlaveObjectClass *class) +{ +GObjectClass *gobject_class=G_OBJECT_CLASS(class); +CaptiveDirectoryObjectClass *captive_directory_object_class=CAPTIVE_DIRECTORY_OBJECT_CLASS(class); + + captive_directory_slave_object_parent_class=g_type_class_ref(g_type_parent(G_TYPE_FROM_CLASS(class))); + gobject_class->finalize=(void (*)(GObject *object))captive_directory_slave_object_finalize; + captive_directory_object_class->read=captive_directory_slave_read; + captive_directory_object_class->remove=captive_directory_slave_remove; +} + + +static void captive_directory_slave_object_init(CaptiveDirectorySlaveObject *captive_directory_slave_object) +{ + captive_directory_slave_object->dir_Handle=NULL; + captive_directory_slave_object->read_first=TRUE; + captive_directory_slave_object->CaptiveDirectorySlaveObject_QueryDirectory_type= + CaptiveDirectorySlaveObject_QueryDirectory_type_FileIdBothDirInformation; +} + + +GType captive_directory_slave_object_get_type(void) +{ +static GType captive_directory_slave_object_type=0; + + if (!captive_directory_slave_object_type) { +static const GTypeInfo captive_directory_slave_object_info={ + sizeof(CaptiveDirectorySlaveObjectClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc)captive_directory_slave_object_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof(CaptiveDirectorySlaveObject), + 5, /* n_preallocs */ + (GInstanceInitFunc)captive_directory_slave_object_init, + }; + + captive_directory_slave_object_type=g_type_register_static(CAPTIVE_DIRECTORY_TYPE_OBJECT, + "CaptiveDirectorySlaveObject",&captive_directory_slave_object_info,0); + } + + return captive_directory_slave_object_type; +} + + +static GnomeVFSResult captive_directory_slave_new_internal + (CaptiveDirectorySlaveObject *captive_directory_slave_object,const gchar *pathname,gboolean create,guint create_perm) +{ +GnomeVFSResult errvfsresult; +OBJECT_ATTRIBUTES dir_ObjectAttributes; +HANDLE dir_Handle; +IO_STATUS_BLOCK dir_IoStatusBlock; +NTSTATUS err; + + g_return_val_if_fail(captive_directory_slave_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + errvfsresult=captive_ObjectAttributes_init(pathname,&dir_ObjectAttributes); + g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult); + + /* wanted: * IoCreateFile()->ObCreateObject(,,,IoFileObjectType)-> + * ->(IoFileObjectType->Create==IopCreateFile)()->IoMountVolume() + */ + err=IoCreateFile( + &dir_Handle, /* FileHandle */ + FILE_LIST_DIRECTORY, /* DesiredAccess */ + &dir_ObjectAttributes, /* ObjectAttributes */ + &dir_IoStatusBlock, /* IoStatusBlock */ + NULL, /* AllocationSize; ignored for open */ + (!create || create_perm&0200 ? FILE_ATTRIBUTE_NORMAL: FILE_ATTRIBUTE_READONLY), /* FileAttributes; ignored for open */ + (FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE), /* ShareAccess; 0 means exclusive */ + (!create ? FILE_OPEN : FILE_CREATE), /* CreateDisposition */ + /* FILE_SYNCHRONOUS_IO_{,NON}ALERT: We need to allow W32 filesystem + * any waits to not to let it return STATUS_CANT_WAIT us. + * Alertability should have only effect on asynchronous events + * from KeWaitForSingleObject() by setting/clearing its parameter 'Alertable'. + */ + FILE_DIRECTORY_FILE|FILE_SYNCHRONOUS_IO_ALERT, /* CreateOptions */ + NULL, /* EaBuffer */ + 0, /* EaLength */ + CreateFileTypeNone, /* CreateFileType */ + NULL, /* ExtraCreateParameters */ + 0); /* Options */ + g_free(dir_ObjectAttributes.ObjectName); /* left from captive_gnomevfs_uri_parent_init() */ + g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(dir_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC); + if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) + return errvfsresult; + g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + g_return_val_if_fail(dir_IoStatusBlock.Information + ==(!create ? FILE_OPENED : FILE_CREATED), + GNOME_VFS_ERROR_GENERIC); + + captive_directory_slave_object->dir_Handle=dir_Handle; + + return GNOME_VFS_OK; +} + + +GnomeVFSResult captive_directory_slave_new_open(CaptiveDirectoryObject **captive_directory_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname) +{ +GnomeVFSResult r; +CaptiveDirectorySlaveObject *captive_directory_slave_object; + + g_return_val_if_fail(captive_directory_object_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_SLAVE_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_directory_slave_object=g_object_new( + CAPTIVE_DIRECTORY_SLAVE_TYPE_OBJECT, /* object_type */ + NULL); /* first_property_name; FIXME: support properties */ + + captive_directory_init(CAPTIVE_DIRECTORY_OBJECT(captive_directory_slave_object),captive_vfs_object); + + *captive_directory_object_return=CAPTIVE_DIRECTORY_OBJECT(captive_directory_slave_object); + + r=captive_directory_slave_new_internal(captive_directory_slave_object,pathname, + FALSE, /* create */ + 0); /* create_perm; ignored */ + + captive_leave(); + if (r==GNOME_VFS_OK) + captive_usecount(+1); + else { + g_object_unref(captive_directory_slave_object); + *captive_directory_object_return=NULL; + } + return r; +} + + +GnomeVFSResult captive_directory_slave_new_make(CaptiveDirectoryObject **captive_directory_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname,guint perm) +{ +GnomeVFSResult r; +CaptiveDirectorySlaveObject *captive_directory_slave_object; + + g_return_val_if_fail(captive_directory_object_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_SLAVE_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_directory_slave_object=g_object_new( + CAPTIVE_DIRECTORY_SLAVE_TYPE_OBJECT, /* object_type */ + NULL); /* first_property_name; FIXME: support properties */ + + captive_directory_init(CAPTIVE_DIRECTORY_OBJECT(captive_directory_slave_object),captive_vfs_object); + + *captive_directory_object_return=CAPTIVE_DIRECTORY_OBJECT(captive_directory_slave_object); + + r=captive_directory_slave_new_internal(captive_directory_slave_object,pathname, + TRUE, /* create */ + perm); /* create_perm; ignored */ + + captive_leave(); + if (r==GNOME_VFS_OK) + captive_usecount(+1); + else { + g_object_unref(captive_directory_slave_object); + *captive_directory_object_return=NULL; + } + return r; +} + + +static GnomeVFSResult FileIdBothDirInformation_to_GnomeVFSFileInfo(GnomeVFSFileInfo *file_info, + FILE_ID_BOTH_DIR_INFORMATION *FileIdBothDirInformation,IO_STATUS_BLOCK *IoStatusBlock) +{ +UNICODE_STRING FileName_UnicodeString; +BOOLEAN errBOOLEAN; +ULONG tmp_ULONG; + + g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_GENERIC); + g_return_val_if_fail(FileIdBothDirInformation!=NULL,GNOME_VFS_ERROR_GENERIC); + g_return_val_if_fail(IoStatusBlock!=NULL,GNOME_VFS_ERROR_GENERIC); + + g_return_val_if_fail(NT_SUCCESS(IoStatusBlock->Status),GNOME_VFS_ERROR_GENERIC); + /* do not exceed the returned buffer by this record; Redundant now, see below. */ + g_assert((gpointer)(((char *)FileIdBothDirInformation)+FileIdBothDirInformation->NextEntryOffset) + <=(gpointer)(((char *)FileIdBothDirInformation)+IoStatusBlock->Information)); + /* '->NextEntryOffset' is ==0 as we used 'ReturnSingleEntry==TRUE' */ + g_assert(FileIdBothDirInformation->NextEntryOffset==0); + + file_info->valid_fields=0; + + FileName_UnicodeString.Length=FileIdBothDirInformation->FileNameLength; + FileName_UnicodeString.MaximumLength=FileIdBothDirInformation->FileNameLength + +sizeof(*FileIdBothDirInformation->FileName); /* 0-terminator */ + g_assert((gpointer)(((char *)FileIdBothDirInformation->FileName)+FileName_UnicodeString.Length) + <=(gpointer)(((char *)FileIdBothDirInformation)+IoStatusBlock->Information)); + /* ensure we fit below '->IoStatusBlock->Information' at least without the 0-terminator */ + FileIdBothDirInformation->FileName[FileIdBothDirInformation->FileNameLength + /sizeof(*FileIdBothDirInformation->FileName)]=0; /* 0-terminate it */ + FileName_UnicodeString.Buffer=FileIdBothDirInformation->FileName; + file_info->name=captive_UnicodeString_to_utf8_malloc(&FileName_UnicodeString); + /* '->name' assumed for 'file_info->valid_fields' */ + + /* FIXME: What is 'FILE_ATTRIBUTE_NORMAL'? */ + switch (FileIdBothDirInformation->FileAttributes & (0 + | FILE_ATTRIBUTE_DIRECTORY + | FILE_ATTRIBUTE_DEVICE)) { + case 0: file_info->type=GNOME_VFS_FILE_TYPE_REGULAR; break; + case FILE_ATTRIBUTE_DIRECTORY: file_info->type=GNOME_VFS_FILE_TYPE_DIRECTORY; break; + case FILE_ATTRIBUTE_DEVICE: file_info->type=GNOME_VFS_FILE_TYPE_SOCKET; + /* or GNOME_VFS_FILE_TYPE_CHARACTER_DEVICE or GNOME_VFS_FILE_TYPE_BLOCK_DEVICE ? */ + break; + default: file_info->type=GNOME_VFS_FILE_TYPE_UNKNOWN; break; + } + file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_TYPE; + + /* we use 0600 for r/w files, 0400 for FILE_ATTRIBUTE_READONLY */ + file_info->permissions=GNOME_VFS_PERM_USER_READ; + if (file_info->type==GNOME_VFS_FILE_TYPE_DIRECTORY) + file_info->permissions|=GNOME_VFS_PERM_USER_EXEC; + if (!(FileIdBothDirInformation->FileAttributes & FILE_ATTRIBUTE_READONLY)) + file_info->permissions|=GNOME_VFS_PERM_USER_WRITE; + file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS; + + file_info->size=FileIdBothDirInformation->EndOfFile.QuadPart; + file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_SIZE; + + file_info->block_count=FileIdBothDirInformation->AllocationSize.QuadPart/512; + file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_BLOCK_COUNT; + + file_info->flags=GNOME_VFS_FILE_FLAGS_LOCAL; + file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_FLAGS; + + if (FileIdBothDirInformation->LastAccessTime.QuadPart) { /* it may be 0 if not set */ + errBOOLEAN=RtlTimeToSecondsSince1970(&FileIdBothDirInformation->LastAccessTime,&tmp_ULONG); + g_assert(errBOOLEAN==TRUE); + file_info->atime=tmp_ULONG; + file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_ATIME; + } + + /* it may be 0 if not set */ + if (FileIdBothDirInformation->LastWriteTime.QuadPart || FileIdBothDirInformation->ChangeTime.QuadPart) { + errBOOLEAN=RtlTimeToSecondsSince1970( + /* take the more recent (==bigger) time: */ + (FileIdBothDirInformation->LastWriteTime.QuadPart > FileIdBothDirInformation->ChangeTime.QuadPart + ? &FileIdBothDirInformation->LastWriteTime : &FileIdBothDirInformation->ChangeTime), + &tmp_ULONG); + g_assert(errBOOLEAN==TRUE); + file_info->mtime=tmp_ULONG; + file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_MTIME; + } + + if (FileIdBothDirInformation->CreationTime.QuadPart) { /* it may be 0 if not set */ + errBOOLEAN=RtlTimeToSecondsSince1970(&FileIdBothDirInformation->CreationTime,&tmp_ULONG); + g_assert(errBOOLEAN==TRUE); + file_info->ctime=tmp_ULONG; + file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_CTIME; + } + + return GNOME_VFS_OK; +} + + +static GnomeVFSResult FileBothDirInformation_to_FileIdBothDirInformation(FILE_ID_BOTH_DIR_INFORMATION *FileIdBothDirInformation, + FILE_BOTH_DIR_INFORMATION *FileBothDirInformation,IO_STATUS_BLOCK *IoStatusBlock) +{ +static LARGE_INTEGER FileId_counter; + + g_return_val_if_fail(FileIdBothDirInformation!=NULL,GNOME_VFS_ERROR_GENERIC); + g_return_val_if_fail(FileBothDirInformation!=NULL,GNOME_VFS_ERROR_GENERIC); + g_return_val_if_fail(IoStatusBlock!=NULL,GNOME_VFS_ERROR_GENERIC); + + g_return_val_if_fail(NT_SUCCESS(IoStatusBlock->Status),GNOME_VFS_ERROR_GENERIC); + /* do not exceed the returned buffer by this record; Redundant now, see below. */ + g_assert((gpointer)(((char *)FileBothDirInformation)+FileBothDirInformation->NextEntryOffset) + <=(gpointer)(((char *)FileBothDirInformation)+IoStatusBlock->Information)); + /* '->NextEntryOffset' is ==0 as we used 'ReturnSingleEntry==TRUE' */ + g_assert(FileBothDirInformation->NextEntryOffset==0); + + g_assert((gpointer)(((char *)FileBothDirInformation->FileName)+FileBothDirInformation->FileNameLength) + <=(gpointer)(((char *)FileBothDirInformation)+IoStatusBlock->Information)); + /* ensure we fit below '->IoStatusBlock->Information' at least without the 0-terminator */ + memcpy(FileIdBothDirInformation->FileName,FileBothDirInformation->FileName, + FileBothDirInformation->FileNameLength); + + /* NextEntryOffset already handled */ + FileIdBothDirInformation->FileIndex =FileBothDirInformation->FileIndex; + FileIdBothDirInformation->CreationTime =FileBothDirInformation->CreationTime; + FileIdBothDirInformation->LastAccessTime =FileBothDirInformation->LastAccessTime; + FileIdBothDirInformation->LastWriteTime =FileBothDirInformation->LastWriteTime; + FileIdBothDirInformation->ChangeTime =FileBothDirInformation->ChangeTime; + FileIdBothDirInformation->EndOfFile =FileBothDirInformation->EndOfFile; + FileIdBothDirInformation->AllocationSize =FileBothDirInformation->AllocationSize; + FileIdBothDirInformation->FileAttributes =FileBothDirInformation->FileAttributes; + FileIdBothDirInformation->FileNameLength =FileBothDirInformation->FileNameLength; + FileIdBothDirInformation->EaSize =FileBothDirInformation->EaSize; + FileIdBothDirInformation->ShortNameLength=FileBothDirInformation->ShortNameLength; + g_assert(sizeof(FileIdBothDirInformation->ShortName)==sizeof(FileBothDirInformation->ShortName)); + memcpy(FileIdBothDirInformation->ShortName,FileBothDirInformation->ShortName, + sizeof(FileBothDirInformation->ShortName)); + /* FIXME: Register filenames for uniqueness; + * Not needed now as 'FileId' field not used by libcaptive anywhere anyway. + */ + FileIdBothDirInformation->FileId.QuadPart=FileId_counter.QuadPart++; + /* FileName already handled */ + + IoStatusBlock->Information=sizeof(*FileIdBothDirInformation)+FileIdBothDirInformation->FileNameLength; + /* '->NextEntryOffset' is ==0 as we used 'ReturnSingleEntry==TRUE' */ + FileIdBothDirInformation->NextEntryOffset=0; + + return GNOME_VFS_OK; +} + + +static GnomeVFSResult captive_directory_slave_close(CaptiveDirectoryObject *captive_directory_object) +{ +CaptiveDirectorySlaveObject *captive_directory_slave_object; +NTSTATUS err; +HANDLE dir_Handle; + + g_return_val_if_fail(CAPTIVE_DIRECTORY_SLAVE_IS_OBJECT(captive_directory_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_directory_slave_object=CAPTIVE_DIRECTORY_SLAVE_OBJECT(captive_directory_object); + + if (captive_directory_slave_object->dir_Handle!=NULL) { /* not yet already closed */ + captive_usecount(-1); /* close() errors notwithstanding */ + + dir_Handle=captive_directory_slave_object->dir_Handle; + captive_directory_slave_object->dir_Handle=NULL; + err=NtClose(dir_Handle); + g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + } + + captive_leave(); + return GNOME_VFS_OK; +} + + +static GnomeVFSResult captive_directory_slave_read + (CaptiveDirectoryObject *captive_directory_object,GnomeVFSFileInfo *file_info) +{ +CaptiveDirectorySlaveObject *captive_directory_slave_object; +NTSTATUS err; +IO_STATUS_BLOCK dir_IoStatusBlock; +FILE_ID_BOTH_DIR_INFORMATION *FileIdBothDirInformation; +FILE_BOTH_DIR_INFORMATION *FileBothDirInformation; +GnomeVFSResult errvfsresult; + + g_return_val_if_fail(CAPTIVE_DIRECTORY_SLAVE_IS_OBJECT(captive_directory_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_directory_slave_object=CAPTIVE_DIRECTORY_SLAVE_OBJECT(captive_directory_object); + + g_return_val_if_fail(captive_directory_slave_object->dir_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + FileIdBothDirInformation=(void *)captive_directory_slave_object->QueryDirectory_buf.FileIdBothDirInformation; +retry: + switch (captive_directory_slave_object->CaptiveDirectorySlaveObject_QueryDirectory_type) { + + case CaptiveDirectorySlaveObject_QueryDirectory_type_FileIdBothDirInformation: + err=NtQueryDirectoryFile( + captive_directory_slave_object->dir_Handle, /* FileHandle */ + NULL, /* PEvent; completion signalling; optional */ + NULL, /* ApcRoutine; optional */ + NULL, /* ApcContext; optional */ + &dir_IoStatusBlock, /* IoStatusBlock */ + (gpointer)captive_directory_slave_object->QueryDirectory_buf.FileIdBothDirInformation, /* FileInformation */ + sizeof(captive_directory_slave_object->QueryDirectory_buf.FileIdBothDirInformation) /* Length */ + -sizeof(*FileIdBothDirInformation->FileName), /* reserve space for 0-terminator */ + FileIdBothDirectoryInformation, /* FileInformationClass; =>FILE_ID_BOTH_DIR_INFORMATION */ + TRUE, /* ReturnSingleEntry */ + NULL, /* FileName; wildcards possible; optional */ + captive_directory_slave_object->read_first); /* RestartScan */ + if (err==STATUS_NO_SUCH_FILE) { + /* 'FileIdBothDirInformation' not supported at least by ext2fsd.sys. + * Emulate it from 'FileBothDirectoryInformation' here. + */ + captive_directory_slave_object->CaptiveDirectorySlaveObject_QueryDirectory_type= + CaptiveDirectorySlaveObject_QueryDirectory_type_FileBothDirInformation; + goto retry; + } + + captive_directory_slave_object->read_first=FALSE; + if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) + return errvfsresult; + g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + break; + + case CaptiveDirectorySlaveObject_QueryDirectory_type_FileBothDirInformation: + FileBothDirInformation=(void *)captive_directory_slave_object->QueryDirectory_buf.FileBothDirInformation; + /* SL_INDEX_SPECIFIED is forbidden for ext2fsd.sys-V0.10A although + * IIRC it was required for the native W32 filesystems. + * Fortunately 'FileBothDirInformation' is just a workaround for ext2fsd.sys-V0.10A + * which is not used for the native W32 filesystems and therefore it should be safe. + * WARNING: Hack with 'FileIndex==0' to prevent SL_INDEX_SPECIFIED is just libcaptive + * specific hack of reactos! See also NtQueryDirectoryFile(). + */ + FileBothDirInformation->FileIndex=0; + err=NtQueryDirectoryFile( + captive_directory_slave_object->dir_Handle, /* FileHandle */ + NULL, /* PEvent; completion signalling; optional */ + NULL, /* ApcRoutine; optional */ + NULL, /* ApcContext; optional */ + &dir_IoStatusBlock, /* IoStatusBlock */ + (gpointer)captive_directory_slave_object->QueryDirectory_buf.FileBothDirInformation, /* FileInformation */ + sizeof(captive_directory_slave_object->QueryDirectory_buf.FileBothDirInformation) /* Length */ + -sizeof(*FileBothDirInformation->FileName), /* reserve space for 0-terminator */ + FileBothDirectoryInformation, /* FileInformationClass; =>FILE_BOTH_DIR_INFORMATION */ + TRUE, /* ReturnSingleEntry */ + NULL, /* FileName; wildcards possible; optional */ + captive_directory_slave_object->read_first); /* RestartScan */ + + captive_directory_slave_object->read_first=FALSE; + if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) { + /* Do not reset 'read_first' on 'STATUS_NO_SUCH_FILE' to leave us stuck at EOF - GnomeVFS behaves that way. */ + return errvfsresult; + } + g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + + errvfsresult=FileBothDirInformation_to_FileIdBothDirInformation(FileIdBothDirInformation,FileBothDirInformation, + &dir_IoStatusBlock); + g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult); + break; + + default: g_assert_not_reached(); + } + + errvfsresult=FileIdBothDirInformation_to_GnomeVFSFileInfo(file_info,FileIdBothDirInformation, + &dir_IoStatusBlock); + g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult); + + captive_leave(); + return GNOME_VFS_OK; +} + + +static GnomeVFSResult captive_directory_slave_remove(CaptiveDirectoryObject *captive_directory_object) +{ +CaptiveDirectorySlaveObject *captive_directory_slave_object; +NTSTATUS err; +FILE_DISPOSITION_INFORMATION FileDispositionInformation_struct; +IO_STATUS_BLOCK dir_IoStatusBlock; +GnomeVFSResult errvfsresult; + + g_return_val_if_fail(CAPTIVE_DIRECTORY_SLAVE_IS_OBJECT(captive_directory_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_directory_slave_object=CAPTIVE_DIRECTORY_SLAVE_OBJECT(captive_directory_object); + + g_return_val_if_fail(captive_directory_slave_object->dir_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + FileDispositionInformation_struct.DoDeleteFile=TRUE; + + err=NtSetInformationFile( + captive_directory_slave_object->dir_Handle, /* FileHandle */ + &dir_IoStatusBlock, /* IoStatusBlock */ + &FileDispositionInformation_struct, /* FileInformation */ + sizeof(FileDispositionInformation_struct), /* Length */ + FileDispositionInformation); /* FileInformationClass */ + if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) + return errvfsresult; + g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + + captive_leave(); + return GNOME_VFS_OK; +} diff --git a/src/libcaptive/client/directory-slave.h b/src/libcaptive/client/directory-slave.h new file mode 100644 index 0000000..12dedc5 --- /dev/null +++ b/src/libcaptive/client/directory-slave.h @@ -0,0 +1,83 @@ +/* $Id$ + * Include file for captive vfs 'directory' private interface to reactos of sandbox slave + * Copyright (C) 2003 Jan Kratochvil + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; exactly version 2 of June 1991 is required + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#ifndef _CAPTIVE_CLIENT_PRIV_DIRECTORY_SLAVE_H +#define _CAPTIVE_CLIENT_PRIV_DIRECTORY_SLAVE_H 1 + + +#include +#include +#include +#include +#include "captive/client-directory.h" /* for CaptiveDirectoryObject */ +#include "directory.h" /* for CaptiveDirectoryObject priv */ +#include "reactos/ntos/types.h" /* for HANDLE */ +#include "reactos/ntos/zwtypes.h" /* for FILE_ID_BOTH_DIR_INFORMATION */ + + +G_BEGIN_DECLS + +#define CAPTIVE_DIRECTORY_SLAVE_TYPE_OBJECT (captive_directory_slave_object_get_type()) +#define CAPTIVE_DIRECTORY_SLAVE_OBJECT(object) (G_TYPE_CHECK_INSTANCE_CAST((object),CAPTIVE_DIRECTORY_SLAVE_TYPE_OBJECT,CaptiveDirectorySlaveObject)) +#define CAPTIVE_DIRECTORY_SLAVE_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),CAPTIVE_DIRECTORY_SLAVE_TYPE_OBJECT,CaptiveDirectorySlaveObjectClass)) +#define CAPTIVE_DIRECTORY_SLAVE_IS_OBJECT(object) (G_TYPE_CHECK_INSTANCE_TYPE((object),CAPTIVE_DIRECTORY_SLAVE_TYPE_OBJECT)) +#define CAPTIVE_DIRECTORY_SLAVE_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),CAPTIVE_DIRECTORY_SLAVE_TYPE_OBJECT)) +#define CAPTIVE_DIRECTORY_SLAVE_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),CAPTIVE_DIRECTORY_SLAVE_TYPE_OBJECT,CaptiveDirectorySlaveObjectClass)) +typedef struct _CaptiveDirectorySlaveObject CaptiveDirectorySlaveObject; +typedef struct _CaptiveDirectorySlaveObjectClass CaptiveDirectorySlaveObjectClass; + + +GType captive_directory_slave_object_get_type(void); + +struct _CaptiveDirectorySlaveObject { + CaptiveDirectoryObject parent_instance; + + /*< private >*/ + HANDLE dir_Handle; + gboolean read_first; + /* 'QueryDirectory_buf' for NtQueryDirectoryFile() must be persistent + * to keep the state if !read_first. + * Both types of 'QueryDirectory_buf' MUST NOT be 'union' as we convert + * them by copying one to other. + */ + struct { + char FileIdBothDirInformation[sizeof(FILE_ID_BOTH_DIR_INFORMATION) + +0x1000 /* max 'FileName' length, 255 should be enough */ * sizeof(WCHAR /* *FILE_ID_BOTH_DIR_INFORMATION.FileName */ )]; + char FileBothDirInformation[sizeof(FILE_BOTH_DIR_INFORMATION) + +0x1000 /* max 'FileName' length, 255 should be enough */ * sizeof(WCHAR /* *FILE_ID_BOTH_DIR_INFORMATION.FileName */ )]; + } QueryDirectory_buf; + enum { + CaptiveDirectorySlaveObject_QueryDirectory_type_FileIdBothDirInformation, + CaptiveDirectorySlaveObject_QueryDirectory_type_FileBothDirInformation, + } CaptiveDirectorySlaveObject_QueryDirectory_type; + }; +struct _CaptiveDirectorySlaveObjectClass { + CaptiveDirectoryObjectClass parent_class; + }; + + +GnomeVFSResult captive_directory_slave_new_open(CaptiveDirectoryObject **captive_directory_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname); +GnomeVFSResult captive_directory_slave_new_make(CaptiveDirectoryObject **captive_directory_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname,guint perm); + +G_END_DECLS + + +#endif /* _CAPTIVE_CLIENT_PRIV_DIRECTORY_SLAVE_H */ diff --git a/src/libcaptive/client/directory.c b/src/libcaptive/client/directory.c index 9950aae..51bbb98 100644 --- a/src/libcaptive/client/directory.c +++ b/src/libcaptive/client/directory.c @@ -21,17 +21,8 @@ #include "captive/client-directory.h" /* self */ #include "directory.h" /* self-priv */ -#include "lib.h" #include -#include "captive/unicode.h" -#include "reactos/ntos/types.h" /* for HANDLE */ -#include "reactos/ddk/iotypes.h" /* for IO_STATUS_BLOCK */ -#include "reactos/ddk/iofuncs.h" /* for IoCreateFile() */ -#include "result.h" -#include "captive/leave.h" -#include "captive/usecount.h" #include "vfs.h" -#include "captive/parent-Directory.h" static gpointer captive_directory_object_parent_class=NULL; @@ -53,17 +44,13 @@ static void captive_directory_object_class_init(CaptiveDirectoryObjectClass *cla { GObjectClass *gobject_class=G_OBJECT_CLASS(class); - captive_directory_object_parent_class=g_type_class_ref(G_TYPE_OBJECT); + captive_directory_object_parent_class=g_type_class_ref(g_type_parent(G_TYPE_FROM_CLASS(class))); gobject_class->finalize=(void (*)(GObject *object))captive_directory_object_finalize; } static void captive_directory_object_init(CaptiveDirectoryObject *captive_directory_object) { - captive_directory_object->dir_Handle=NULL; - captive_directory_object->read_first=TRUE; - captive_directory_object->CaptiveDirectoryObject_QueryDirectory_type= - CaptiveDirectoryObject_QueryDirectory_type_FileIdBothDirInformation; } @@ -85,426 +72,87 @@ static const GTypeInfo captive_directory_object_info={ }; captive_directory_object_type=g_type_register_static(G_TYPE_OBJECT, - "CaptiveDirectoryObject",&captive_directory_object_info,0); + "CaptiveDirectoryObject",&captive_directory_object_info,G_TYPE_FLAG_ABSTRACT); } return captive_directory_object_type; } -static GnomeVFSResult captive_directory_new_internal - (CaptiveDirectoryObject *captive_directory_object,const gchar *pathname,gboolean create,guint create_perm) -{ -GnomeVFSResult errvfsresult; -OBJECT_ATTRIBUTES dir_ObjectAttributes; -HANDLE dir_Handle; -IO_STATUS_BLOCK dir_IoStatusBlock; -NTSTATUS err; - - g_return_val_if_fail(captive_directory_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - - errvfsresult=captive_ObjectAttributes_init(pathname,&dir_ObjectAttributes); - g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult); - - /* wanted: * IoCreateFile()->ObCreateObject(,,,IoFileObjectType)-> - * ->(IoFileObjectType->Create==IopCreateFile)()->IoMountVolume() - */ - err=IoCreateFile( - &dir_Handle, /* FileHandle */ - FILE_LIST_DIRECTORY, /* DesiredAccess */ - &dir_ObjectAttributes, /* ObjectAttributes */ - &dir_IoStatusBlock, /* IoStatusBlock */ - NULL, /* AllocationSize; ignored for open */ - (!create || create_perm&0200 ? FILE_ATTRIBUTE_NORMAL: FILE_ATTRIBUTE_READONLY), /* FileAttributes; ignored for open */ - (FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE), /* ShareAccess; 0 means exclusive */ - (!create ? FILE_OPEN : FILE_CREATE), /* CreateDisposition */ - /* FILE_SYNCHRONOUS_IO_{,NON}ALERT: We need to allow W32 filesystem - * any waits to not to let it return STATUS_CANT_WAIT us. - * Alertability should have only effect on asynchronous events - * from KeWaitForSingleObject() by setting/clearing its parameter 'Alertable'. - */ - FILE_DIRECTORY_FILE|FILE_SYNCHRONOUS_IO_ALERT, /* CreateOptions */ - NULL, /* EaBuffer */ - 0, /* EaLength */ - CreateFileTypeNone, /* CreateFileType */ - NULL, /* ExtraCreateParameters */ - 0); /* Options */ - g_free(dir_ObjectAttributes.ObjectName); /* left from captive_gnomevfs_uri_parent_init() */ - g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(dir_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC); - if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) - return errvfsresult; - g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); - g_return_val_if_fail(dir_IoStatusBlock.Information - ==(!create ? FILE_OPENED : FILE_CREATED), - GNOME_VFS_ERROR_GENERIC); - - captive_directory_object->dir_Handle=dir_Handle; - - return GNOME_VFS_OK; -} - - GnomeVFSResult captive_directory_new_open(CaptiveDirectoryObject **captive_directory_object_return, CaptiveVfsObject *captive_vfs_object,const gchar *pathname) { -GnomeVFSResult r; -CaptiveDirectoryObject *captive_directory_object; - g_return_val_if_fail(captive_directory_object_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_vfs_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - captive_directory_object=g_object_new( - CAPTIVE_DIRECTORY_TYPE_OBJECT, /* object_type */ - NULL); /* first_property_name; FIXME: support properties */ - captive_directory_object->dir_Handle=NULL; - captive_directory_object->vfs=captive_vfs_object; - *captive_directory_object_return=captive_directory_object; - - if (captive_vfs_object->is_sandbox_parent) - return captive_sandbox_parent_directory_new_open(captive_directory_object,pathname); - - r=captive_directory_new_internal(captive_directory_object,pathname, - FALSE, /* create */ - 0); /* create_perm; ignored */ - - captive_leave(); - if (r==GNOME_VFS_OK) - captive_usecount(+1); - else { - g_object_unref(captive_directory_object); - *captive_directory_object_return=NULL; - } - return r; + return (*CAPTIVE_VFS_OBJECT_GET_CLASS(captive_vfs_object)->directory_new_open) + (captive_directory_object_return,captive_vfs_object,pathname); } GnomeVFSResult captive_directory_new_make(CaptiveDirectoryObject **captive_directory_object_return, CaptiveVfsObject *captive_vfs_object,const gchar *pathname,guint perm) { -GnomeVFSResult r; -CaptiveDirectoryObject *captive_directory_object; - g_return_val_if_fail(captive_directory_object_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_vfs_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - captive_directory_object=g_object_new( - CAPTIVE_DIRECTORY_TYPE_OBJECT, /* object_type */ - NULL); /* first_property_name; FIXME: support properties */ - captive_directory_object->dir_Handle=NULL; - captive_directory_object->vfs=captive_vfs_object; - *captive_directory_object_return=captive_directory_object; - - if (captive_vfs_object->is_sandbox_parent) - return captive_sandbox_parent_directory_new_make(captive_directory_object,pathname,perm); - - r=captive_directory_new_internal(captive_directory_object,pathname, - TRUE, /* create */ - perm); /* create_perm; ignored */ - - captive_leave(); - if (r==GNOME_VFS_OK) - captive_usecount(+1); - else { - g_object_unref(captive_directory_object); - *captive_directory_object_return=NULL; - } - return r; + return (*CAPTIVE_VFS_OBJECT_GET_CLASS(captive_vfs_object)->directory_new_make) + (captive_directory_object_return,captive_vfs_object,pathname,perm); } -static GnomeVFSResult FileIdBothDirInformation_to_GnomeVFSFileInfo(GnomeVFSFileInfo *file_info, - FILE_ID_BOTH_DIR_INFORMATION *FileIdBothDirInformation,IO_STATUS_BLOCK *IoStatusBlock) +GnomeVFSResult captive_directory_init(CaptiveDirectoryObject *captive_directory_object,CaptiveVfsObject *captive_vfs_object) { -UNICODE_STRING FileName_UnicodeString; -BOOLEAN errBOOLEAN; -ULONG tmp_ULONG; - - g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_GENERIC); - g_return_val_if_fail(FileIdBothDirInformation!=NULL,GNOME_VFS_ERROR_GENERIC); - g_return_val_if_fail(IoStatusBlock!=NULL,GNOME_VFS_ERROR_GENERIC); - - g_return_val_if_fail(NT_SUCCESS(IoStatusBlock->Status),GNOME_VFS_ERROR_GENERIC); - /* do not exceed the returned buffer by this record; Redundant now, see below. */ - g_assert((gpointer)(((char *)FileIdBothDirInformation)+FileIdBothDirInformation->NextEntryOffset) - <=(gpointer)(((char *)FileIdBothDirInformation)+IoStatusBlock->Information)); - /* '->NextEntryOffset' is ==0 as we used 'ReturnSingleEntry==TRUE' */ - g_assert(FileIdBothDirInformation->NextEntryOffset==0); - - file_info->valid_fields=0; - - FileName_UnicodeString.Length=FileIdBothDirInformation->FileNameLength; - FileName_UnicodeString.MaximumLength=FileIdBothDirInformation->FileNameLength - +sizeof(*FileIdBothDirInformation->FileName); /* 0-terminator */ - g_assert((gpointer)(((char *)FileIdBothDirInformation->FileName)+FileName_UnicodeString.Length) - <=(gpointer)(((char *)FileIdBothDirInformation)+IoStatusBlock->Information)); - /* ensure we fit below '->IoStatusBlock->Information' at least without the 0-terminator */ - FileIdBothDirInformation->FileName[FileIdBothDirInformation->FileNameLength - /sizeof(*FileIdBothDirInformation->FileName)]=0; /* 0-terminate it */ - FileName_UnicodeString.Buffer=FileIdBothDirInformation->FileName; - file_info->name=captive_UnicodeString_to_utf8_malloc(&FileName_UnicodeString); - /* '->name' assumed for 'file_info->valid_fields' */ - - /* FIXME: What is 'FILE_ATTRIBUTE_NORMAL'? */ - switch (FileIdBothDirInformation->FileAttributes & (0 - | FILE_ATTRIBUTE_DIRECTORY - | FILE_ATTRIBUTE_DEVICE)) { - case 0: file_info->type=GNOME_VFS_FILE_TYPE_REGULAR; break; - case FILE_ATTRIBUTE_DIRECTORY: file_info->type=GNOME_VFS_FILE_TYPE_DIRECTORY; break; - case FILE_ATTRIBUTE_DEVICE: file_info->type=GNOME_VFS_FILE_TYPE_SOCKET; - /* or GNOME_VFS_FILE_TYPE_CHARACTER_DEVICE or GNOME_VFS_FILE_TYPE_BLOCK_DEVICE ? */ - break; - default: file_info->type=GNOME_VFS_FILE_TYPE_UNKNOWN; break; - } - file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_TYPE; - - /* we use 0600 for r/w files, 0400 for FILE_ATTRIBUTE_READONLY */ - file_info->permissions=GNOME_VFS_PERM_USER_READ; - if (file_info->type==GNOME_VFS_FILE_TYPE_DIRECTORY) - file_info->permissions|=GNOME_VFS_PERM_USER_EXEC; - if (!(FileIdBothDirInformation->FileAttributes & FILE_ATTRIBUTE_READONLY)) - file_info->permissions|=GNOME_VFS_PERM_USER_WRITE; - file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS; - - file_info->size=FileIdBothDirInformation->EndOfFile.QuadPart; - file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_SIZE; - - file_info->block_count=FileIdBothDirInformation->AllocationSize.QuadPart/512; - file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_BLOCK_COUNT; - - file_info->flags=GNOME_VFS_FILE_FLAGS_LOCAL; - file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_FLAGS; - - if (FileIdBothDirInformation->LastAccessTime.QuadPart) { /* it may be 0 if not set */ - errBOOLEAN=RtlTimeToSecondsSince1970(&FileIdBothDirInformation->LastAccessTime,&tmp_ULONG); - g_assert(errBOOLEAN==TRUE); - file_info->atime=tmp_ULONG; - file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_ATIME; - } + g_return_val_if_fail(CAPTIVE_DIRECTORY_IS_OBJECT(captive_directory_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - /* it may be 0 if not set */ - if (FileIdBothDirInformation->LastWriteTime.QuadPart || FileIdBothDirInformation->ChangeTime.QuadPart) { - errBOOLEAN=RtlTimeToSecondsSince1970( - /* take the more recent (==bigger) time: */ - (FileIdBothDirInformation->LastWriteTime.QuadPart > FileIdBothDirInformation->ChangeTime.QuadPart - ? &FileIdBothDirInformation->LastWriteTime : &FileIdBothDirInformation->ChangeTime), - &tmp_ULONG); - g_assert(errBOOLEAN==TRUE); - file_info->mtime=tmp_ULONG; - file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_MTIME; - } + g_return_val_if_fail(captive_directory_object->vfs==NULL,GNOME_VFS_ERROR_GENERIC); - if (FileIdBothDirInformation->CreationTime.QuadPart) { /* it may be 0 if not set */ - errBOOLEAN=RtlTimeToSecondsSince1970(&FileIdBothDirInformation->CreationTime,&tmp_ULONG); - g_assert(errBOOLEAN==TRUE); - file_info->ctime=tmp_ULONG; - file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_CTIME; - } + captive_directory_object->vfs=g_object_ref(captive_vfs_object); return GNOME_VFS_OK; } -static GnomeVFSResult FileBothDirInformation_to_FileIdBothDirInformation(FILE_ID_BOTH_DIR_INFORMATION *FileIdBothDirInformation, - FILE_BOTH_DIR_INFORMATION *FileBothDirInformation,IO_STATUS_BLOCK *IoStatusBlock) +static GnomeVFSResult captive_directory_close(CaptiveDirectoryObject *captive_directory_object) { -static LARGE_INTEGER FileId_counter; - - g_return_val_if_fail(FileIdBothDirInformation!=NULL,GNOME_VFS_ERROR_GENERIC); - g_return_val_if_fail(FileBothDirInformation!=NULL,GNOME_VFS_ERROR_GENERIC); - g_return_val_if_fail(IoStatusBlock!=NULL,GNOME_VFS_ERROR_GENERIC); - - g_return_val_if_fail(NT_SUCCESS(IoStatusBlock->Status),GNOME_VFS_ERROR_GENERIC); - /* do not exceed the returned buffer by this record; Redundant now, see below. */ - g_assert((gpointer)(((char *)FileBothDirInformation)+FileBothDirInformation->NextEntryOffset) - <=(gpointer)(((char *)FileBothDirInformation)+IoStatusBlock->Information)); - /* '->NextEntryOffset' is ==0 as we used 'ReturnSingleEntry==TRUE' */ - g_assert(FileBothDirInformation->NextEntryOffset==0); - - g_assert((gpointer)(((char *)FileBothDirInformation->FileName)+FileBothDirInformation->FileNameLength) - <=(gpointer)(((char *)FileBothDirInformation)+IoStatusBlock->Information)); - /* ensure we fit below '->IoStatusBlock->Information' at least without the 0-terminator */ - memcpy(FileIdBothDirInformation->FileName,FileBothDirInformation->FileName, - FileBothDirInformation->FileNameLength); - - /* NextEntryOffset already handled */ - FileIdBothDirInformation->FileIndex =FileBothDirInformation->FileIndex; - FileIdBothDirInformation->CreationTime =FileBothDirInformation->CreationTime; - FileIdBothDirInformation->LastAccessTime =FileBothDirInformation->LastAccessTime; - FileIdBothDirInformation->LastWriteTime =FileBothDirInformation->LastWriteTime; - FileIdBothDirInformation->ChangeTime =FileBothDirInformation->ChangeTime; - FileIdBothDirInformation->EndOfFile =FileBothDirInformation->EndOfFile; - FileIdBothDirInformation->AllocationSize =FileBothDirInformation->AllocationSize; - FileIdBothDirInformation->FileAttributes =FileBothDirInformation->FileAttributes; - FileIdBothDirInformation->FileNameLength =FileBothDirInformation->FileNameLength; - FileIdBothDirInformation->EaSize =FileBothDirInformation->EaSize; - FileIdBothDirInformation->ShortNameLength=FileBothDirInformation->ShortNameLength; - g_assert(sizeof(FileIdBothDirInformation->ShortName)==sizeof(FileBothDirInformation->ShortName)); - memcpy(FileIdBothDirInformation->ShortName,FileBothDirInformation->ShortName, - sizeof(FileBothDirInformation->ShortName)); - /* FIXME: Register filenames for uniqueness; - * Not needed now as 'FileId' field not used by libcaptive anywhere anyway. - */ - FileIdBothDirInformation->FileId.QuadPart=FileId_counter.QuadPart++; - /* FileName already handled */ - - IoStatusBlock->Information=sizeof(*FileIdBothDirInformation)+FileIdBothDirInformation->FileNameLength; - /* '->NextEntryOffset' is ==0 as we used 'ReturnSingleEntry==TRUE' */ - FileIdBothDirInformation->NextEntryOffset=0; + g_return_val_if_fail(CAPTIVE_DIRECTORY_IS_OBJECT(captive_directory_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + if (captive_directory_object->vfs!=NULL) { + g_object_unref(captive_directory_object->vfs); + captive_directory_object->vfs=NULL; + } return GNOME_VFS_OK; } -static GnomeVFSResult captive_directory_close(CaptiveDirectoryObject *captive_directory_object) +CaptiveVfsObject *captive_directory_ref_vfs(CaptiveDirectoryObject *captive_directory_object) { -NTSTATUS err; -HANDLE dir_Handle; - - g_return_val_if_fail(captive_directory_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_DIRECTORY_IS_OBJECT(captive_directory_object),NULL); - if (captive_directory_object->vfs->is_sandbox_parent) - return captive_sandbox_parent_directory_close(captive_directory_object); + g_return_val_if_fail(CAPTIVE_VFS_IS_OBJECT(captive_directory_object->vfs),NULL); - if (captive_directory_object->dir_Handle!=NULL) { /* not yet already closed */ - captive_usecount(-1); /* close() errors notwithstanding */ - - dir_Handle=captive_directory_object->dir_Handle; - captive_directory_object->dir_Handle=NULL; - err=NtClose(dir_Handle); - g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); - } - - captive_leave(); - return GNOME_VFS_OK; + return g_object_ref(captive_directory_object->vfs); } GnomeVFSResult captive_directory_read(CaptiveDirectoryObject *captive_directory_object,GnomeVFSFileInfo *file_info) { -NTSTATUS err; -IO_STATUS_BLOCK dir_IoStatusBlock; -FILE_ID_BOTH_DIR_INFORMATION *FileIdBothDirInformation; -FILE_BOTH_DIR_INFORMATION *FileBothDirInformation; -GnomeVFSResult errvfsresult; - - g_return_val_if_fail(captive_directory_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_DIRECTORY_IS_OBJECT(captive_directory_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - if (captive_directory_object->vfs->is_sandbox_parent) - return captive_sandbox_parent_directory_read(captive_directory_object,file_info); - - g_return_val_if_fail(captive_directory_object->dir_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - - FileIdBothDirInformation=(void *)captive_directory_object->QueryDirectory_buf.FileIdBothDirInformation; -retry: - switch (captive_directory_object->CaptiveDirectoryObject_QueryDirectory_type) { - - case CaptiveDirectoryObject_QueryDirectory_type_FileIdBothDirInformation: - err=NtQueryDirectoryFile( - captive_directory_object->dir_Handle, /* FileHandle */ - NULL, /* PEvent; completion signalling; optional */ - NULL, /* ApcRoutine; optional */ - NULL, /* ApcContext; optional */ - &dir_IoStatusBlock, /* IoStatusBlock */ - (gpointer)captive_directory_object->QueryDirectory_buf.FileIdBothDirInformation, /* FileInformation */ - sizeof(captive_directory_object->QueryDirectory_buf.FileIdBothDirInformation) /* Length */ - -sizeof(*FileIdBothDirInformation->FileName), /* reserve space for 0-terminator */ - FileIdBothDirectoryInformation, /* FileInformationClass; =>FILE_ID_BOTH_DIR_INFORMATION */ - TRUE, /* ReturnSingleEntry */ - NULL, /* FileName; wildcards possible; optional */ - captive_directory_object->read_first); /* RestartScan */ - if (err==STATUS_NO_SUCH_FILE) { - /* 'FileIdBothDirInformation' not supported at least by ext2fsd.sys. - * Emulate it from 'FileBothDirectoryInformation' here. - */ - captive_directory_object->CaptiveDirectoryObject_QueryDirectory_type= - CaptiveDirectoryObject_QueryDirectory_type_FileBothDirInformation; - goto retry; - } - - captive_directory_object->read_first=FALSE; - if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) - return errvfsresult; - g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); - break; - - case CaptiveDirectoryObject_QueryDirectory_type_FileBothDirInformation: - FileBothDirInformation=(void *)captive_directory_object->QueryDirectory_buf.FileBothDirInformation; - /* SL_INDEX_SPECIFIED is forbidden for ext2fsd.sys-V0.10A although - * IIRC it was required for the native W32 filesystems. - * Fortunately 'FileBothDirInformation' is just a workaround for ext2fsd.sys-V0.10A - * which is not used for the native W32 filesystems and therefore it should be safe. - * WARNING: Hack with 'FileIndex==0' to prevent SL_INDEX_SPECIFIED is just libcaptive - * specific hack of reactos! See also NtQueryDirectoryFile(). - */ - FileBothDirInformation->FileIndex=0; - err=NtQueryDirectoryFile( - captive_directory_object->dir_Handle, /* FileHandle */ - NULL, /* PEvent; completion signalling; optional */ - NULL, /* ApcRoutine; optional */ - NULL, /* ApcContext; optional */ - &dir_IoStatusBlock, /* IoStatusBlock */ - (gpointer)captive_directory_object->QueryDirectory_buf.FileBothDirInformation, /* FileInformation */ - sizeof(captive_directory_object->QueryDirectory_buf.FileBothDirInformation) /* Length */ - -sizeof(*FileBothDirInformation->FileName), /* reserve space for 0-terminator */ - FileBothDirectoryInformation, /* FileInformationClass; =>FILE_BOTH_DIR_INFORMATION */ - TRUE, /* ReturnSingleEntry */ - NULL, /* FileName; wildcards possible; optional */ - captive_directory_object->read_first); /* RestartScan */ - - captive_directory_object->read_first=FALSE; - if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) { - /* Do not reset 'read_first' on 'STATUS_NO_SUCH_FILE' to leave us stuck at EOF - GnomeVFS behaves that way. */ - return errvfsresult; - } - g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); - - errvfsresult=FileBothDirInformation_to_FileIdBothDirInformation(FileIdBothDirInformation,FileBothDirInformation, - &dir_IoStatusBlock); - g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult); - break; - - default: g_assert_not_reached(); - } - - errvfsresult=FileIdBothDirInformation_to_GnomeVFSFileInfo(file_info,FileIdBothDirInformation, - &dir_IoStatusBlock); - g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult); - - captive_leave(); - return GNOME_VFS_OK; + return (*CAPTIVE_DIRECTORY_OBJECT_GET_CLASS(captive_directory_object)->read) + (captive_directory_object,file_info); } GnomeVFSResult captive_directory_remove(CaptiveDirectoryObject *captive_directory_object) { -NTSTATUS err; -FILE_DISPOSITION_INFORMATION FileDispositionInformation_struct; -IO_STATUS_BLOCK dir_IoStatusBlock; -GnomeVFSResult errvfsresult; - - g_return_val_if_fail(captive_directory_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - - if (captive_directory_object->vfs->is_sandbox_parent) - return captive_sandbox_parent_directory_remove(captive_directory_object); + g_return_val_if_fail(CAPTIVE_DIRECTORY_IS_OBJECT(captive_directory_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_directory_object->dir_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - - FileDispositionInformation_struct.DoDeleteFile=TRUE; - - err=NtSetInformationFile( - captive_directory_object->dir_Handle, /* FileHandle */ - &dir_IoStatusBlock, /* IoStatusBlock */ - &FileDispositionInformation_struct, /* FileInformation */ - sizeof(FileDispositionInformation_struct), /* Length */ - FileDispositionInformation); /* FileInformationClass */ - if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) - return errvfsresult; - g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); - - captive_leave(); - return GNOME_VFS_OK; + return (*CAPTIVE_DIRECTORY_OBJECT_GET_CLASS(captive_directory_object)->remove) + (captive_directory_object); } diff --git a/src/libcaptive/client/directory.h b/src/libcaptive/client/directory.h index 64f0ec0..59da556 100644 --- a/src/libcaptive/client/directory.h +++ b/src/libcaptive/client/directory.h @@ -23,10 +23,8 @@ #include #include -#include "reactos/napi/types.h" /* for NTSTATUS */ -#include "reactos/ntos/zwtypes.h" /* for FILE_ID_BOTH_DIR_INFORMATION */ #include "captive/client-vfs.h" -#include "../sandbox/sandbox.h" +#include "captive/client-directory.h" G_BEGIN_DECLS @@ -36,30 +34,16 @@ struct _CaptiveDirectoryObject { /*< private >*/ CaptiveVfsObject *vfs; - Captive_Directory corba_Directory_object; - GList *corba_Directory_file_info_list; /* contents */ - HANDLE dir_Handle; - gboolean read_first; - /* 'QueryDirectory_buf' for NtQueryDirectoryFile() must be persistent - * to keep the state if !read_first. - * Both types of 'QueryDirectory_buf' MUST NOT be 'union' as we convert - * them by copying one to other. - */ - struct { - char FileIdBothDirInformation[sizeof(FILE_ID_BOTH_DIR_INFORMATION) - +0x1000 /* max 'FileName' length, 255 should be enough */ * sizeof(WCHAR /* *FILE_ID_BOTH_DIR_INFORMATION.FileName */ )]; - char FileBothDirInformation[sizeof(FILE_BOTH_DIR_INFORMATION) - +0x1000 /* max 'FileName' length, 255 should be enough */ * sizeof(WCHAR /* *FILE_ID_BOTH_DIR_INFORMATION.FileName */ )]; - } QueryDirectory_buf; - enum { - CaptiveDirectoryObject_QueryDirectory_type_FileIdBothDirInformation, - CaptiveDirectoryObject_QueryDirectory_type_FileBothDirInformation, - } CaptiveDirectoryObject_QueryDirectory_type; }; struct _CaptiveDirectoryObjectClass { GObjectClass parent_class; + + GnomeVFSResult (*read)(CaptiveDirectoryObject *captive_directory_object,GnomeVFSFileInfo *file_info); + GnomeVFSResult (*remove)(CaptiveDirectoryObject *captive_directory_object); }; +GnomeVFSResult captive_directory_init(CaptiveDirectoryObject *captive_directory_object,CaptiveVfsObject *captive_vfs_object); + G_END_DECLS diff --git a/src/libcaptive/client/file-parent.c b/src/libcaptive/client/file-parent.c new file mode 100644 index 0000000..c1d09b2 --- /dev/null +++ b/src/libcaptive/client/file-parent.c @@ -0,0 +1,281 @@ +/* $Id$ + * captive vfs 'file' interface to reactos of sandbox parent + * Copyright (C) 2002-2003 Jan Kratochvil + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; exactly version 2 of June 1991 is required + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include "config.h" + +#include "file-parent.h" /* self */ +#include +#include "../sandbox/parent-File.h" +#include "vfs-parent.h" +#include "reactos/ntos/types.h" /* for ULONG */ + + +static gpointer captive_file_parent_object_parent_class=NULL; + + +static GnomeVFSResult captive_file_parent_close(CaptiveFileObject *captive_file_object); +static GnomeVFSResult captive_file_parent_read(CaptiveFileObject *captive_file_object, + gpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_read_return); +static GnomeVFSResult captive_file_parent_write(CaptiveFileObject *captive_file_object, + gconstpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_written_return); +static GnomeVFSResult captive_file_parent_seek + (CaptiveFileObject *captive_file_object,GnomeVFSSeekPosition whence,GnomeVFSFileOffset offset); +static GnomeVFSResult captive_file_parent_tell(CaptiveFileObject *captive_file_object,GnomeVFSFileOffset *offset_return); +static GnomeVFSResult captive_file_parent_remove(CaptiveFileObject *captive_file_object); +static GnomeVFSResult captive_file_parent_file_info_get + (CaptiveFileObject *captive_file_object,GnomeVFSFileInfo *file_info); +static GnomeVFSResult captive_file_parent_file_info_set + (CaptiveFileObject *captive_file_object,const GnomeVFSFileInfo *info,GnomeVFSSetFileInfoMask mask); +static GnomeVFSResult captive_file_parent_truncate(CaptiveFileObject *captive_file_object,GnomeVFSFileSize file_size); +static GnomeVFSResult captive_file_parent_move + (CaptiveFileObject *captive_file_object_old,const gchar *pathname_new,gboolean force_replace); + + +static void captive_file_parent_object_finalize(CaptiveFileParentObject *captive_file_parent_object) +{ + g_return_if_fail(captive_file_parent_object!=NULL); + + captive_file_parent_close(CAPTIVE_FILE_OBJECT(captive_file_parent_object)); /* errors ignored */ + + G_OBJECT_CLASS(captive_file_parent_object_parent_class)->finalize((GObject *)captive_file_parent_object); +} + + +static void captive_file_parent_object_class_init(CaptiveFileParentObjectClass *class) +{ +GObjectClass *gobject_class=G_OBJECT_CLASS(class); +CaptiveFileObjectClass *captive_file_object_class=CAPTIVE_FILE_OBJECT_CLASS(class); + + captive_file_parent_object_parent_class=g_type_class_ref(g_type_parent(G_TYPE_FROM_CLASS(class))); + gobject_class->finalize=(void (*)(GObject *object))captive_file_parent_object_finalize; + + captive_file_object_class->read=captive_file_parent_read; + captive_file_object_class->write=captive_file_parent_write; + captive_file_object_class->seek=captive_file_parent_seek; + captive_file_object_class->tell=captive_file_parent_tell; + captive_file_object_class->remove=captive_file_parent_remove; + captive_file_object_class->file_info_get=captive_file_parent_file_info_get; + captive_file_object_class->file_info_set=captive_file_parent_file_info_set; + captive_file_object_class->truncate=captive_file_parent_truncate; + captive_file_object_class->move=captive_file_parent_move; +} + + +static void captive_file_parent_object_init(CaptiveFileParentObject *captive_file_parent_object) +{ +} + + +GType captive_file_parent_object_get_type(void) +{ +static GType captive_file_parent_object_type=0; + + if (!captive_file_parent_object_type) { +static const GTypeInfo captive_file_parent_object_info={ + sizeof(CaptiveFileParentObjectClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc)captive_file_parent_object_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof(CaptiveFileParentObject), + 5, /* n_preallocs */ + (GInstanceInitFunc)captive_file_parent_object_init, + }; + + captive_file_parent_object_type=g_type_register_static(CAPTIVE_FILE_TYPE_OBJECT, + "CaptiveFileParentObject",&captive_file_parent_object_info,0); + } + + return captive_file_parent_object_type; +} + + +GnomeVFSResult captive_file_parent_new_open(CaptiveFileObject **captive_file_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname,GnomeVFSOpenMode mode) +{ +CaptiveFileParentObject *captive_file_parent_object; + + g_return_val_if_fail(captive_file_object_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_PARENT_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_parent_object=g_object_new( + CAPTIVE_FILE_PARENT_TYPE_OBJECT, /* object_type */ + NULL); /* first_property_name; FIXME: support properties */ + + captive_file_init(CAPTIVE_FILE_OBJECT(captive_file_parent_object),captive_vfs_object); + + *captive_file_object_return=CAPTIVE_FILE_OBJECT(captive_file_parent_object); + + return captive_sandbox_parent_file_new_open(captive_file_parent_object,pathname,mode); +} + + +GnomeVFSResult captive_file_parent_new_create(CaptiveFileObject **captive_file_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname,GnomeVFSOpenMode mode,gboolean exclusive,guint perm) +{ +CaptiveFileParentObject *captive_file_parent_object; + + g_return_val_if_fail(captive_file_object_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_PARENT_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_parent_object=g_object_new( + CAPTIVE_FILE_PARENT_TYPE_OBJECT, /* object_type */ + NULL); /* first_property_name; FIXME: support properties */ + + captive_file_init(CAPTIVE_FILE_OBJECT(captive_file_parent_object),captive_vfs_object); + + *captive_file_object_return=CAPTIVE_FILE_OBJECT(captive_file_parent_object); + + return captive_sandbox_parent_file_new_create(captive_file_parent_object,pathname,mode,exclusive,perm); +} + + +static GnomeVFSResult captive_file_parent_close(CaptiveFileObject *captive_file_object) +{ + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + return captive_sandbox_parent_file_close(CAPTIVE_FILE_PARENT_OBJECT(captive_file_object)); +} + + +static GnomeVFSResult captive_file_parent_read(CaptiveFileObject *captive_file_object, + gpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_read_return) +{ +CaptiveFileParentObject *captive_file_parent_object; + + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(buffer!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(bytes_read_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(num_bytes==(ULONG)num_bytes,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_parent_object=CAPTIVE_FILE_PARENT_OBJECT(captive_file_object); + + return captive_sandbox_parent_file_read(captive_file_parent_object,buffer,num_bytes,bytes_read_return); +} + + +static GnomeVFSResult captive_file_parent_write(CaptiveFileObject *captive_file_object, + gconstpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_written_return) +{ +CaptiveFileParentObject *captive_file_parent_object; + + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(buffer!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(bytes_written_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(num_bytes==(ULONG)num_bytes,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_parent_object=CAPTIVE_FILE_PARENT_OBJECT(captive_file_object); + + return captive_sandbox_parent_file_write(captive_file_parent_object,buffer,num_bytes,bytes_written_return); +} + + +static GnomeVFSResult captive_file_parent_seek + (CaptiveFileObject *captive_file_object,GnomeVFSSeekPosition whence,GnomeVFSFileOffset offset) +{ +CaptiveFileParentObject *captive_file_parent_object; + + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_parent_object=CAPTIVE_FILE_PARENT_OBJECT(captive_file_object); + + return captive_sandbox_parent_file_seek(captive_file_parent_object,whence,offset); +} + + +static GnomeVFSResult captive_file_parent_tell(CaptiveFileObject *captive_file_object,GnomeVFSFileOffset *offset_return) +{ +CaptiveFileParentObject *captive_file_parent_object; + + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(offset_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_parent_object=CAPTIVE_FILE_PARENT_OBJECT(captive_file_object); + + return captive_sandbox_parent_file_tell(captive_file_parent_object,offset_return); +} + + +static GnomeVFSResult captive_file_parent_remove(CaptiveFileObject *captive_file_object) +{ +CaptiveFileParentObject *captive_file_parent_object; + + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_parent_object=CAPTIVE_FILE_PARENT_OBJECT(captive_file_object); + + return captive_sandbox_parent_file_remove(captive_file_parent_object); +} + + +static GnomeVFSResult captive_file_parent_file_info_get + (CaptiveFileObject *captive_file_object,GnomeVFSFileInfo *file_info) +{ +CaptiveFileParentObject *captive_file_parent_object; + + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_parent_object=CAPTIVE_FILE_PARENT_OBJECT(captive_file_object); + + return captive_sandbox_parent_file_file_info_get(captive_file_parent_object,file_info); +} + + +static GnomeVFSResult captive_file_parent_file_info_set + (CaptiveFileObject *captive_file_object,const GnomeVFSFileInfo *info,GnomeVFSSetFileInfoMask mask) +{ +CaptiveFileParentObject *captive_file_parent_object; + + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_parent_object=CAPTIVE_FILE_PARENT_OBJECT(captive_file_object); + + return captive_sandbox_parent_file_file_info_set(captive_file_parent_object,info,mask); +} + + +static GnomeVFSResult captive_file_parent_truncate(CaptiveFileObject *captive_file_object,GnomeVFSFileSize file_size) +{ +CaptiveFileParentObject *captive_file_parent_object; + + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_parent_object=CAPTIVE_FILE_PARENT_OBJECT(captive_file_object); + + return captive_sandbox_parent_file_truncate(captive_file_parent_object,file_size); +} + + +static GnomeVFSResult captive_file_parent_move + (CaptiveFileObject *captive_file_object_old,const gchar *pathname_new,gboolean force_replace) +{ +CaptiveFileParentObject *captive_file_parent_object_old; + + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_object_old),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(pathname_new!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_parent_object_old=CAPTIVE_FILE_PARENT_OBJECT(captive_file_object_old); + + return captive_sandbox_parent_file_move(captive_file_parent_object_old,pathname_new,force_replace); +} diff --git a/src/libcaptive/client/file-parent.h b/src/libcaptive/client/file-parent.h new file mode 100644 index 0000000..ed7e6b8 --- /dev/null +++ b/src/libcaptive/client/file-parent.h @@ -0,0 +1,63 @@ +/* $Id$ + * Include file for captive vfs 'file' private interface to reactos of sandbox parent + * Copyright (C) 2003 Jan Kratochvil + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; exactly version 2 of June 1991 is required + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#ifndef _CAPTIVE_CLIENT_PRIV_FILE_PARENT_H +#define _CAPTIVE_CLIENT_PRIV_FILE_PARENT_H 1 + + +#include +#include +#include "captive/client-file.h" /* for CaptiveFileObject */ +#include "file.h" /* for CaptiveFileObject priv */ +#include "../sandbox/sandbox.h" + + +G_BEGIN_DECLS + +#define CAPTIVE_FILE_PARENT_TYPE_OBJECT (captive_file_parent_object_get_type()) +#define CAPTIVE_FILE_PARENT_OBJECT(object) (G_TYPE_CHECK_INSTANCE_CAST((object),CAPTIVE_FILE_PARENT_TYPE_OBJECT,CaptiveFileParentObject)) +#define CAPTIVE_FILE_PARENT_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),CAPTIVE_FILE_PARENT_TYPE_OBJECT,CaptiveFileParentObjectClass)) +#define CAPTIVE_FILE_PARENT_IS_OBJECT(object) (G_TYPE_CHECK_INSTANCE_TYPE((object),CAPTIVE_FILE_PARENT_TYPE_OBJECT)) +#define CAPTIVE_FILE_PARENT_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),CAPTIVE_FILE_PARENT_TYPE_OBJECT)) +#define CAPTIVE_FILE_PARENT_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),CAPTIVE_FILE_PARENT_TYPE_OBJECT,CaptiveFileParentObjectClass)) +typedef struct _CaptiveFileParentObject CaptiveFileParentObject; +typedef struct _CaptiveFileParentObjectClass CaptiveFileParentObjectClass; + + +GType captive_file_parent_object_get_type(void); + +struct _CaptiveFileParentObject { + CaptiveFileObject parent_instance; + + /*< private >*/ + Captive_File corba_File_object; + }; +struct _CaptiveFileParentObjectClass { + CaptiveFileObjectClass parent_class; + }; + +GnomeVFSResult captive_file_parent_new_open(CaptiveFileObject **captive_file_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname,GnomeVFSOpenMode mode); +GnomeVFSResult captive_file_parent_new_create(CaptiveFileObject **captive_file_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname,GnomeVFSOpenMode mode,gboolean exclusive,guint perm); + +G_END_DECLS + + +#endif /* _CAPTIVE_CLIENT_PRIV_FILE_PARENT_H */ diff --git a/src/libcaptive/client/file-slave.c b/src/libcaptive/client/file-slave.c new file mode 100644 index 0000000..a24cfa7 --- /dev/null +++ b/src/libcaptive/client/file-slave.c @@ -0,0 +1,872 @@ +/* $Id$ + * captive vfs 'file' interface to reactos + * Copyright (C) 2002-2003 Jan Kratochvil + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; exactly version 2 of June 1991 is required + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include "config.h" + +#include "file-slave.h" /* self */ +#include "captive/client-file.h" /* for CaptiveFileObject */ +#include "file.h" /* for CaptiveFileObject priv */ +#include "directory.h" +#include "lib.h" +#include +#include "captive/unicode.h" +#include "reactos/ntos/types.h" /* for HANDLE */ +#include "reactos/ddk/iotypes.h" /* for IO_STATUS_BLOCK */ +#include "reactos/ddk/iofuncs.h" /* for IoCreateFile() */ +#include "result.h" +#include "captive/client-directory.h" +#include "reactos/ddk/obfuncs.h" /* for ObReferenceObjectByHandle() */ +#include "captive/macros.h" +#include "captive/leave.h" +#include "captive/usecount.h" +#include "vfs.h" +#include "vfs-slave.h" + + +struct _CaptiveFileSlaveObject { + CaptiveFileObject parent_instance; + + /*< private >*/ + HANDLE file_Handle; + GnomeVFSFileOffset offset; + }; +struct _CaptiveFileSlaveObjectClass { + CaptiveFileObjectClass parent_class; + }; + + +static gpointer captive_file_slave_object_parent_class=NULL; + + +static GnomeVFSResult captive_file_slave_close(CaptiveFileObject *captive_file_object); +static GnomeVFSResult captive_file_slave_read(CaptiveFileObject *captive_file_object, + gpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_read_return); +static GnomeVFSResult captive_file_slave_write(CaptiveFileObject *captive_file_object, + gconstpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_written_return); +static GnomeVFSResult captive_file_slave_seek + (CaptiveFileObject *captive_file_object,GnomeVFSSeekPosition whence,GnomeVFSFileOffset offset); +static GnomeVFSResult captive_file_slave_tell(CaptiveFileObject *captive_file_object,GnomeVFSFileOffset *offset_return); +static GnomeVFSResult captive_file_slave_remove(CaptiveFileObject *captive_file_object); +static GnomeVFSResult captive_file_slave_file_info_get + (CaptiveFileObject *captive_file_object,GnomeVFSFileInfo *file_info); +static GnomeVFSResult captive_file_slave_file_info_set + (CaptiveFileObject *captive_file_object,const GnomeVFSFileInfo *info,GnomeVFSSetFileInfoMask mask); +static GnomeVFSResult captive_file_slave_truncate(CaptiveFileObject *captive_file_object,GnomeVFSFileSize file_size); +static GnomeVFSResult captive_file_slave_move + (CaptiveFileObject *captive_file_object_old,const gchar *pathname_new,gboolean force_replace); + + +static void captive_file_slave_object_finalize(CaptiveFileSlaveObject *captive_file_slave_object) +{ + g_return_if_fail(captive_file_slave_object!=NULL); + + captive_file_slave_close(CAPTIVE_FILE_OBJECT(captive_file_slave_object)); /* errors ignored */ + + G_OBJECT_CLASS(captive_file_slave_object_parent_class)->finalize((GObject *)captive_file_slave_object); +} + + +static void captive_file_slave_object_class_init(CaptiveFileSlaveObjectClass *class) +{ +GObjectClass *gobject_class=G_OBJECT_CLASS(class); +CaptiveFileObjectClass *captive_file_object_class=CAPTIVE_FILE_OBJECT_CLASS(class); + + captive_file_slave_object_parent_class=g_type_class_ref(g_type_parent(G_TYPE_FROM_CLASS(class))); + gobject_class->finalize=(void (*)(GObject *object))captive_file_slave_object_finalize; + + captive_file_object_class->read=captive_file_slave_read; + captive_file_object_class->write=captive_file_slave_write; + captive_file_object_class->seek=captive_file_slave_seek; + captive_file_object_class->tell=captive_file_slave_tell; + captive_file_object_class->remove=captive_file_slave_remove; + captive_file_object_class->file_info_get=captive_file_slave_file_info_get; + captive_file_object_class->file_info_set=captive_file_slave_file_info_set; + captive_file_object_class->truncate=captive_file_slave_truncate; + captive_file_object_class->move=captive_file_slave_move; +} + + +static void captive_file_slave_object_init(CaptiveFileSlaveObject *captive_file_slave_object) +{ + captive_file_slave_object->file_Handle=NULL; +} + + +GType captive_file_slave_object_get_type(void) +{ +static GType captive_file_slave_object_type=0; + + if (!captive_file_slave_object_type) { +static const GTypeInfo captive_file_slave_object_info={ + sizeof(CaptiveFileSlaveObjectClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc)captive_file_slave_object_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof(CaptiveFileSlaveObject), + 5, /* n_preallocs */ + (GInstanceInitFunc)captive_file_slave_object_init, + }; + + captive_file_slave_object_type=g_type_register_static(CAPTIVE_FILE_TYPE_OBJECT, + "CaptiveFileSlaveObject",&captive_file_slave_object_info,0); + } + + return captive_file_slave_object_type; +} + + +static GnomeVFSResult captive_file_slave_new_internal(CaptiveFileSlaveObject *captive_file_slave_object, + const gchar *pathname,GnomeVFSOpenMode mode,gboolean create,gboolean create_exclusive,guint create_perm) +{ +IO_STATUS_BLOCK file_IoStatusBlock; +GnomeVFSResult errvfsresult; +OBJECT_ATTRIBUTES file_ObjectAttributes; +HANDLE file_Handle; +NTSTATUS err; + + g_return_val_if_fail(captive_file_slave_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + errvfsresult=captive_ObjectAttributes_init(pathname,&file_ObjectAttributes); + g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult); + + /* open */ + err=IoCreateFile( + &file_Handle, /* FileHandle */ + 0 + |(!(mode&GNOME_VFS_OPEN_READ ) ? 0 : FILE_READ_DATA) + |(!(mode&GNOME_VFS_OPEN_WRITE) ? 0 : FILE_WRITE_DATA | FILE_APPEND_DATA | FILE_WRITE_ATTRIBUTES) + |( mode!=0 ? 0 : FILE_READ_ATTRIBUTES) + , /* DesiredAccess */ + &file_ObjectAttributes, /* ObjectAttributes */ + &file_IoStatusBlock, /* IoStatusBlock */ + NULL, /* AllocationSize; ignored for open */ + (!create || create_perm&0200 ? FILE_ATTRIBUTE_NORMAL: FILE_ATTRIBUTE_READONLY), /* FileAttributes; ignored for open */ + (!create || !create_exclusive /* ShareAccess; 0 means exclusive */ + ? (FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE) + : 0), + (!create ? FILE_OPEN : FILE_CREATE), /* CreateDisposition */ + /* FILE_SYNCHRONOUS_IO_{,NON}ALERT: We need to allow W32 filesystem + * any waits to not to let it return STATUS_CANT_WAIT us. + * Alertability should have only effect on asynchronous events + * from KeWaitForSingleObject() by setting/clearing its parameter 'Alertable'. + */ + FILE_SYNCHRONOUS_IO_ALERT, /* CreateOptions */ + NULL, /* EaBuffer */ + 0, /* EaLength */ + CreateFileTypeNone, /* CreateFileType */ + NULL, /* ExtraCreateParameters */ + 0); /* Options */ + g_free(file_ObjectAttributes.ObjectName); /* left from captive_file_slave_uri_parent_init() */ + g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC); + if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) + return errvfsresult; + g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + g_return_val_if_fail(file_IoStatusBlock.Information + ==(!create ? FILE_OPENED : FILE_CREATED), + GNOME_VFS_ERROR_GENERIC); + + captive_file_slave_object->file_Handle=file_Handle; + + return GNOME_VFS_OK; +} + + +GnomeVFSResult captive_file_slave_new_open(CaptiveFileObject **captive_file_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname,GnomeVFSOpenMode mode) +{ +GnomeVFSResult r; +CaptiveFileSlaveObject *captive_file_slave_object; + + g_return_val_if_fail(captive_file_object_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_SLAVE_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_slave_object=g_object_new( + CAPTIVE_FILE_SLAVE_TYPE_OBJECT, /* object_type */ + NULL); /* first_property_name; FIXME: support properties */ + + captive_file_init(CAPTIVE_FILE_OBJECT(captive_file_slave_object),captive_vfs_object); + + *captive_file_object_return=CAPTIVE_FILE_OBJECT(captive_file_slave_object); + + r=captive_file_slave_new_internal(captive_file_slave_object,pathname,mode, + FALSE, /* create */ + FALSE, /* create_exclusive; ignored */ + 0); /* create_perm; ignored */ + + captive_leave(); + if (r==GNOME_VFS_OK) + captive_usecount(+1); + else { + g_object_unref(captive_file_slave_object); + *captive_file_object_return=NULL; + } + return r; +} + + +GnomeVFSResult captive_file_slave_new_create(CaptiveFileObject **captive_file_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname,GnomeVFSOpenMode mode,gboolean exclusive,guint perm) +{ +GnomeVFSResult r; +CaptiveFileSlaveObject *captive_file_slave_object; + + g_return_val_if_fail(captive_file_object_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_SLAVE_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_slave_object=g_object_new( + CAPTIVE_FILE_SLAVE_TYPE_OBJECT, /* object_type */ + NULL); /* first_property_name; FIXME: support properties */ + + captive_file_init(CAPTIVE_FILE_OBJECT(captive_file_slave_object),captive_vfs_object); + + *captive_file_object_return=CAPTIVE_FILE_OBJECT(captive_file_slave_object); + + r=captive_file_slave_new_internal(captive_file_slave_object,pathname,mode, + TRUE, /* create */ + exclusive, /* create_exclusive */ + perm); /* create_perm */ + + captive_leave(); + if (r==GNOME_VFS_OK) + captive_usecount(+1); + else { + g_object_unref(captive_file_slave_object); + *captive_file_object_return=NULL; + } + return r; +} + + +static GnomeVFSResult captive_file_slave_close(CaptiveFileObject *captive_file_object) +{ +CaptiveFileSlaveObject *captive_file_slave_object; +NTSTATUS err; +HANDLE file_Handle; + + g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object); + + if (captive_file_slave_object->file_Handle!=NULL) { /* not yet already closed */ + captive_usecount(-1); /* close() errors notwithstanding */ + + file_Handle=captive_file_slave_object->file_Handle; + captive_file_slave_object->file_Handle=NULL; + err=NtClose(file_Handle); + g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + } + + captive_leave(); + return GNOME_VFS_OK; +} + + +GnomeVFSResult captive_file_slave_read(CaptiveFileObject *captive_file_object, + gpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_read_return) +{ +CaptiveFileSlaveObject *captive_file_slave_object; +NTSTATUS err; +IO_STATUS_BLOCK file_IoStatusBlock; +LARGE_INTEGER file_offset; +GnomeVFSResult errvfsresult; + + g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(buffer!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(bytes_read_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(num_bytes==(ULONG)num_bytes,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object); + + g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + file_offset.QuadPart=captive_file_slave_object->offset; + err=NtReadFile( + captive_file_slave_object->file_Handle, /* FileHandle */ + NULL, /* EventHandle; completion signalling; optional */ + NULL, /* ApcRoutine; optional */ + NULL, /* ApcContext; optional */ + &file_IoStatusBlock, /* IoStatusBlock */ + buffer, /* Buffer */ + num_bytes, /* Length */ + &file_offset, /* ByteOffset */ + NULL); /* Key; NULL means no file locking key */ + if (err==STATUS_END_OF_FILE) { + g_return_val_if_fail(file_IoStatusBlock.Status==STATUS_END_OF_FILE,GNOME_VFS_ERROR_GENERIC); + g_return_val_if_fail(file_IoStatusBlock.Information==0,GNOME_VFS_ERROR_GENERIC); + *bytes_read_return=0; + return GNOME_VFS_ERROR_EOF; + } + g_return_val_if_fail(file_IoStatusBlock.Information>0,GNOME_VFS_ERROR_GENERIC); /* if not STATUS_END_OF_FILE... */ + if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) + return errvfsresult; + g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC); + g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + g_return_val_if_fail(file_IoStatusBlock.Information<=num_bytes,GNOME_VFS_ERROR_GENERIC); + + captive_file_slave_object->offset+=file_IoStatusBlock.Information; + *bytes_read_return=file_IoStatusBlock.Information; + captive_leave(); + return GNOME_VFS_OK; +} + + +GnomeVFSResult captive_file_slave_write(CaptiveFileObject *captive_file_object, + gconstpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_written_return) +{ +CaptiveFileSlaveObject *captive_file_slave_object; +NTSTATUS err; +IO_STATUS_BLOCK file_IoStatusBlock; +LARGE_INTEGER file_offset; +GnomeVFSFileInfo file_info; +GnomeVFSFileSize endoffile_wanted; +GnomeVFSResult errvfsresult; + + g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(buffer!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(bytes_written_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(num_bytes==(ULONG)num_bytes,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object); + + g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + if ((GnomeVFSFileOffset)(captive_file_slave_object->offset+num_bytes) < captive_file_slave_object->offset) + return GNOME_VFS_ERROR_TOO_BIG; + endoffile_wanted=captive_file_slave_object->offset+num_bytes; + if (GNOME_VFS_OK!=(errvfsresult=captive_file_slave_file_info_get( + CAPTIVE_FILE_OBJECT(captive_file_slave_object),&file_info))) + return errvfsresult; + if (file_info.sizeoffset; + err=NtWriteFile( + captive_file_slave_object->file_Handle, /* FileHandle */ + NULL, /* Event; completion signalling; optional */ + NULL, /* ApcRoutine; optional */ + NULL, /* ApcContext; optional */ + &file_IoStatusBlock, /* IoStatusBlock */ + (gpointer /* de-const */ )buffer, /* Buffer */ + num_bytes, /* Length */ + &file_offset, /* ByteOffset */ + NULL); /* Key; NULL means no file locking key */ + g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC); + g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + g_return_val_if_fail(file_IoStatusBlock.Information==num_bytes,GNOME_VFS_ERROR_GENERIC); + + captive_file_slave_object->offset+=file_IoStatusBlock.Information; + *bytes_written_return=file_IoStatusBlock.Information; + captive_leave(); + return GNOME_VFS_OK; +} + + +GnomeVFSResult captive_file_slave_seek + (CaptiveFileObject *captive_file_object,GnomeVFSSeekPosition whence,GnomeVFSFileOffset offset) +{ +CaptiveFileSlaveObject *captive_file_slave_object; + + g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object); + + g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + switch (whence) { + case GNOME_VFS_SEEK_START: + captive_file_slave_object->offset=offset; + break; + case GNOME_VFS_SEEK_CURRENT: + if (0 + || (offset>0 && (captive_file_slave_object->offset+offset)offset) + || (offset<0 && (captive_file_slave_object->offset+offset)>captive_file_slave_object->offset)) + return GNOME_VFS_ERROR_BAD_PARAMETERS; + captive_file_slave_object->offset+=offset; + break; + case GNOME_VFS_SEEK_END: + g_assert_not_reached(); /* NOT IMPLEMENTED YET */ + break; + default: + g_return_val_if_reached(GNOME_VFS_ERROR_BAD_PARAMETERS); + } + + captive_leave(); + return GNOME_VFS_OK; +} + + +GnomeVFSResult captive_file_slave_tell(CaptiveFileObject *captive_file_object,GnomeVFSFileOffset *offset_return) +{ +CaptiveFileSlaveObject *captive_file_slave_object; + + g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(offset_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object); + + g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + *offset_return=captive_file_slave_object->offset; + captive_leave(); + return GNOME_VFS_OK; +} + + +GnomeVFSResult captive_file_slave_remove(CaptiveFileObject *captive_file_object) +{ +CaptiveFileSlaveObject *captive_file_slave_object; +NTSTATUS err; +FILE_DISPOSITION_INFORMATION FileDispositionInformation_struct; +IO_STATUS_BLOCK file_IoStatusBlock; +GnomeVFSResult errvfsresult; + + g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object); + + g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + FileDispositionInformation_struct.DoDeleteFile=TRUE; + + err=NtSetInformationFile( + captive_file_slave_object->file_Handle, /* FileHandle */ + &file_IoStatusBlock, /* IoStatusBlock */ + &FileDispositionInformation_struct, /* FileInformation */ + sizeof(FileDispositionInformation_struct), /* Length */ + FileDispositionInformation); /* FileInformationClass */ + if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) + return errvfsresult; + g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + + captive_leave(); + return GNOME_VFS_OK; +} + + +/* Use 'FileNameInformationStruct' identifier instead of the logical 'FileNameInformation' + * to prevent override of enum member 'FileNameInformation' + */ +static GnomeVFSResult FileNameInformationStruct_to_GnomeVFSFileInfo(GnomeVFSFileInfo *file_info, + FILE_NAME_INFORMATION *FileNameInformationStruct) +{ +UNICODE_STRING FileName_UnicodeString; + + g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_GENERIC); + g_return_val_if_fail(FileNameInformationStruct!=NULL,GNOME_VFS_ERROR_GENERIC); + + FileName_UnicodeString.Length=FileNameInformationStruct->FileNameLength; + FileName_UnicodeString.MaximumLength=FileNameInformationStruct->FileNameLength + +sizeof(*FileNameInformationStruct->FileName); /* 0-terminator */ + +#if 0 /* 'IoStatusBlock->Information' is sometimes weird, do not check it */ + g_assert((gpointer)(((char *)FileNameInformationStruct->FileName)+FileName_UnicodeString.Length) + <=(gpointer)(((char *)FileAllInformationStruct)+IoStatusBlock->Information)); + /* ensure we fit below '->IoStatusBlock->Information' at least without the 0-terminator */ +#endif + + FileNameInformationStruct->FileName[FileNameInformationStruct->FileNameLength + /sizeof(*FileNameInformationStruct->FileName)]=0; /* 0-terminate it */ + FileName_UnicodeString.Buffer=FileNameInformationStruct->FileName; + file_info->name=captive_UnicodeString_to_utf8_malloc(&FileName_UnicodeString); + /* '->name' assumed for 'file_info->valid_fields' */ + + return GNOME_VFS_OK; +} + + +/* Use 'FileBasicInformationStruct' identifier instead of the logical 'FileBasicInformation' + * to prevent override of enum member 'FileBasicInformation' + */ +static GnomeVFSResult FileBasicInformationStruct_to_GnomeVFSFileInfo(GnomeVFSFileInfo *file_info, + FILE_BASIC_INFORMATION *FileBasicInformationStruct) +{ +BOOLEAN errBOOLEAN; +ULONG tmp_ULONG; + + /* FIXME: What is 'FILE_ATTRIBUTE_NORMAL'? */ + switch (FileBasicInformationStruct->FileAttributes & (0 + | FILE_ATTRIBUTE_DIRECTORY + | FILE_ATTRIBUTE_DEVICE)) { + case 0: file_info->type=GNOME_VFS_FILE_TYPE_REGULAR; break; + case FILE_ATTRIBUTE_DIRECTORY: file_info->type=GNOME_VFS_FILE_TYPE_DIRECTORY; break; + case FILE_ATTRIBUTE_DEVICE: file_info->type=GNOME_VFS_FILE_TYPE_SOCKET; + /* or GNOME_VFS_FILE_TYPE_CHARACTER_DEVICE or GNOME_VFS_FILE_TYPE_BLOCK_DEVICE ? */ + break; + default: file_info->type=GNOME_VFS_FILE_TYPE_UNKNOWN; break; + } + file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_TYPE; + + /* we use 0600 for r/w files, 0400 for FILE_ATTRIBUTE_READONLY */ + file_info->permissions=GNOME_VFS_PERM_USER_READ; + if (file_info->type==GNOME_VFS_FILE_TYPE_DIRECTORY) + file_info->permissions|=GNOME_VFS_PERM_USER_EXEC; + if (!(FileBasicInformationStruct->FileAttributes & FILE_ATTRIBUTE_READONLY)) + file_info->permissions|=GNOME_VFS_PERM_USER_WRITE; + file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS; + + if (FileBasicInformationStruct->LastAccessTime.QuadPart) { /* it may be 0 if not set */ + errBOOLEAN=RtlTimeToSecondsSince1970(&FileBasicInformationStruct->LastAccessTime,&tmp_ULONG); + g_assert(errBOOLEAN==TRUE); + file_info->atime=tmp_ULONG; + file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_ATIME; + } + + /* it may be 0 if not set */ + if (FileBasicInformationStruct->LastWriteTime.QuadPart || FileBasicInformationStruct->ChangeTime.QuadPart) { + errBOOLEAN=RtlTimeToSecondsSince1970( + /* take the more recent (==bigger) time: */ + (FileBasicInformationStruct->LastWriteTime.QuadPart > FileBasicInformationStruct->ChangeTime.QuadPart + ? &FileBasicInformationStruct->LastWriteTime : &FileBasicInformationStruct->ChangeTime), + &tmp_ULONG); + g_assert(errBOOLEAN==TRUE); + file_info->mtime=tmp_ULONG; + file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_MTIME; + } + + if (FileBasicInformationStruct->CreationTime.QuadPart) { /* it may be 0 if not set */ + errBOOLEAN=RtlTimeToSecondsSince1970(&FileBasicInformationStruct->CreationTime,&tmp_ULONG); + g_assert(errBOOLEAN==TRUE); + file_info->ctime=tmp_ULONG; + file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_CTIME; + } + + return GNOME_VFS_OK; +} + + +/* Use 'FileStandardInformationStruct' identifier instead of the logical 'FileStandardInformation' + * to prevent override of enum member 'FileStandardInformation' + */ +static GnomeVFSResult FileStandardInformationStruct_to_GnomeVFSFileInfo(GnomeVFSFileInfo *file_info, + FILE_STANDARD_INFORMATION *FileStandardInformationStruct) +{ + file_info->size=FileStandardInformationStruct->EndOfFile.QuadPart; + file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_SIZE; + + file_info->block_count=FileStandardInformationStruct->AllocationSize.QuadPart/512; + file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_BLOCK_COUNT; + + return GNOME_VFS_OK; +} + + +GnomeVFSResult captive_file_slave_file_info_get(CaptiveFileObject *captive_file_object, + GnomeVFSFileInfo *file_info) +{ +CaptiveFileSlaveObject *captive_file_slave_object; +NTSTATUS err; +IO_STATUS_BLOCK file_IoStatusBlock; +FILE_NAME_INFORMATION *FileNameInformationStruct; +FILE_BASIC_INFORMATION *FileBasicInformationStruct; +FILE_STANDARD_INFORMATION *FileStandardInformationStruct; +GnomeVFSResult errvfsresult; +char QueryFile_buf[sizeof(FILE_NAME_INFORMATION) + +0x1000 /* max 'FileName' length, 255 should be enough */ * sizeof(WCHAR /* *FILE_ALL_INFORMATION.NameInformation.FileName */ )]; + + g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object); + + g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + /* ntfs.sys of NT-5.1sp1 has *(FILE_BASIC_INFORMATION *)FILE_ALL_INFORMATION.BasicInformation + * size 0x28 although reactos includes and all the information says 0x24. + * fastfat.sys of NT-5.1sp1 also has the 'official' sizeof 0x24. + * It would be a bit of heuristic to correctly detect its expected sizeof. + */ + + file_info->valid_fields=0; + + file_info->flags=GNOME_VFS_FILE_FLAGS_LOCAL; + file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_FLAGS; + + /* query NameInformation */ + FileNameInformationStruct=(void *)QueryFile_buf; + err=NtQueryInformationFile( + captive_file_slave_object->file_Handle, /* FileHandle */ + &file_IoStatusBlock, /* IoStatusBlock */ + (gpointer)QueryFile_buf, /* FileInformation */ + sizeof(QueryFile_buf) /* Length */ + -sizeof(*FileNameInformationStruct->FileName), /* reserve space for a possible 0-terminator */ + FileNameInformation); /* FileInformationClass; =>FILE_NAME_INFORMATION */ + if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) + return errvfsresult; + g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC); + g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + errvfsresult=FileNameInformationStruct_to_GnomeVFSFileInfo(file_info,FileNameInformationStruct); + g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult); + + /* query BasicInformation */ + FileBasicInformationStruct=(void *)QueryFile_buf; + err=NtQueryInformationFile( + captive_file_slave_object->file_Handle, /* FileHandle */ + &file_IoStatusBlock, /* IoStatusBlock */ + (gpointer)QueryFile_buf, /* FileInformation */ + sizeof(QueryFile_buf), /* Length */ + FileBasicInformation); /* FileInformationClass; =>FILE_BASIC_INFORMATION */ + if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) + return errvfsresult; + g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC); + g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + errvfsresult=FileBasicInformationStruct_to_GnomeVFSFileInfo(file_info,FileBasicInformationStruct); + g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult); + + /* query StandardInformation */ + FileStandardInformationStruct=(void *)QueryFile_buf; + err=NtQueryInformationFile( + captive_file_slave_object->file_Handle, /* FileHandle */ + &file_IoStatusBlock, /* IoStatusBlock */ + (gpointer)QueryFile_buf, /* FileInformation */ + sizeof(QueryFile_buf), /* Length */ + FileStandardInformation); /* FileInformationClass; =>FILE_STANDARD_INFORMATION */ + if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) + return errvfsresult; + g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC); + g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + errvfsresult=FileStandardInformationStruct_to_GnomeVFSFileInfo(file_info,FileStandardInformationStruct); + g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult); + + captive_leave(); + return GNOME_VFS_OK; +} + + +GnomeVFSResult captive_file_slave_file_info_set(CaptiveFileObject *captive_file_object, + const GnomeVFSFileInfo *info,GnomeVFSSetFileInfoMask mask) +{ +CaptiveFileSlaveObject *captive_file_slave_object; + + g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object); + + g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + if (mask & GNOME_VFS_SET_FILE_INFO_NAME) { +gchar *name_dirname,*name_basename; +UNICODE_STRING *name_UnicodeString; +FILE_RENAME_INFORMATION *FileRenameInformation_structp; +gsize FileRenameInformation_struct_len; +IO_STATUS_BLOCK file_IoStatusBlock; +NTSTATUS err; +GnomeVFSResult errvfsresult; + + /* non-existing dirname assertion */ + name_dirname=g_path_get_dirname(info->name); + if (*name_dirname) { + g_assert_not_reached(); + errvfsresult=GNOME_VFS_ERROR_BAD_PARAMETERS; + goto err; + } + + /* fully-matching basename assertion */ + name_basename=g_path_get_basename(info->name); + if (strcmp(name_basename,info->name)) { + g_assert_not_reached(); + errvfsresult=GNOME_VFS_ERROR_BAD_PARAMETERS; + goto err_free_name_dirname; + } + + name_UnicodeString=captive_utf8_to_UnicodeString_alloca(info->name); + FileRenameInformation_struct_len=sizeof(*FileRenameInformation_structp) + +name_UnicodeString->MaximumLength; /* ==Length+(0-terminator); is the terminator needed? */ + + FileRenameInformation_structp=g_alloca(FileRenameInformation_struct_len); + FileRenameInformation_structp->Replace=FALSE; + FileRenameInformation_structp->RootDir=NULL; /* we do 'simple rename' here */ + FileRenameInformation_structp->FileNameLength=name_UnicodeString->Length; + memcpy(FileRenameInformation_structp->FileName,name_UnicodeString->Buffer, + name_UnicodeString->MaximumLength); /* ==Length+(0-terminator); is the terminator needed? */ + + err=NtSetInformationFile( + captive_file_slave_object->file_Handle, /* FileHandle */ + &file_IoStatusBlock, /* IoStatusBlock */ + FileRenameInformation_structp, /* FileInformation */ + FileRenameInformation_struct_len, /* Length */ + FileRenameInformation); /* FileInformationClass */ + if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) + goto err_free_name_basename; + +err_free_name_basename: + g_free(name_basename); +err_free_name_dirname: + g_free(name_dirname); +err: + + if (errvfsresult!=GNOME_VFS_OK) + return errvfsresult; + g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + } + + if (mask & (GNOME_VFS_SET_FILE_INFO_PERMISSIONS | GNOME_VFS_SET_FILE_INFO_TIME)) { +char FileBasicInformation_buf[sizeof(FILE_BASIC_INFORMATION)+4]; +FILE_BASIC_INFORMATION *FileBasicInformationp=(FILE_BASIC_INFORMATION *)FileBasicInformation_buf; +IO_STATUS_BLOCK file_IoStatusBlock; +NTSTATUS err; + + /* FIXME: Everywhere is is the declaration with 4xLARGE_INTEGER+1xULONG==36 bytes + * but the precompiled ext2fsd.sys wants 40 bytes - why? + * The same case applies to ntfs.sys of NT-5.1sp1. + */ + g_assert(sizeof(FILE_BASIC_INFORMATION)==36); + g_assert(sizeof(FileBasicInformation_buf)==40); + err=NtQueryInformationFile( + captive_file_slave_object->file_Handle, /* FileHandle */ + &file_IoStatusBlock, /* IoStatusBlock */ + FileBasicInformation_buf, /* FileInformation */ + sizeof(FileBasicInformation_buf), /* Length */ + FileBasicInformation); /* FileInformationClass */ + g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + + if (mask & GNOME_VFS_SET_FILE_INFO_PERMISSIONS) { + FileBasicInformationp->FileAttributes&=~FILE_ATTRIBUTE_READONLY; + g_assert(info->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS); + if (!(info->permissions&0200)) + FileBasicInformationp->FileAttributes|=FILE_ATTRIBUTE_READONLY; + } + + if (mask & GNOME_VFS_SET_FILE_INFO_TIME) { + g_assert(info->valid_fields & (0 + | GNOME_VFS_FILE_INFO_FIELDS_ATIME + | GNOME_VFS_FILE_INFO_FIELDS_MTIME + | GNOME_VFS_FILE_INFO_FIELDS_CTIME)); + if (info->valid_fields&GNOME_VFS_FILE_INFO_FIELDS_ATIME) { + RtlSecondsSince1970ToTime( + info->atime, /* SecondsSince1970 */ + &FileBasicInformationp->LastAccessTime); /* Time */ + } + if (info->valid_fields&GNOME_VFS_FILE_INFO_FIELDS_MTIME) { + RtlSecondsSince1970ToTime( + info->mtime, /* SecondsSince1970 */ + &FileBasicInformationp->LastWriteTime); /* Time */ + FileBasicInformationp->ChangeTime=FileBasicInformationp->LastWriteTime; + } + if (info->valid_fields&GNOME_VFS_FILE_INFO_FIELDS_CTIME) { + RtlSecondsSince1970ToTime( + info->ctime, /* SecondsSince1970 */ + &FileBasicInformationp->CreationTime); /* Time */ + } + } + + err=NtSetInformationFile( + captive_file_slave_object->file_Handle, /* FileHandle */ + &file_IoStatusBlock, /* IoStatusBlock */ + FileBasicInformation_buf, /* FileInformation */ + sizeof(FileBasicInformation_buf), /* Length */ + FileBasicInformation); /* FileInformationClass */ + g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + } + + if (mask & GNOME_VFS_SET_FILE_INFO_OWNER) { + /* FIXME: g_assert(info->valid_fields & ???); */ + /* owner ignored for W32 */ + } + + captive_leave(); + return GNOME_VFS_OK; +} + + +GnomeVFSResult captive_file_slave_truncate(CaptiveFileObject *captive_file_object,GnomeVFSFileSize file_size) +{ +CaptiveFileSlaveObject *captive_file_slave_object; +NTSTATUS err; +FILE_END_OF_FILE_INFORMATION FileEndOfFileInformation_struct; +IO_STATUS_BLOCK file_IoStatusBlock; +GnomeVFSResult errvfsresult; + + g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object); + + g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + FileEndOfFileInformation_struct.EndOfFile.QuadPart=file_size; + + err=NtSetInformationFile( + captive_file_slave_object->file_Handle, /* FileHandle */ + &file_IoStatusBlock, /* IoStatusBlock */ + &FileEndOfFileInformation_struct, /* FileInformation */ + sizeof(FileEndOfFileInformation_struct), /* Length */ + FileEndOfFileInformation); /* FileInformationClass */ + if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) + return errvfsresult; + g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + + captive_leave(); + return GNOME_VFS_OK; +} + + +GnomeVFSResult captive_file_slave_move + (CaptiveFileObject *captive_file_object_old,const gchar *pathname_new,gboolean force_replace) +{ +CaptiveFileSlaveObject *captive_file_slave_object_old; +NTSTATUS err; +FILE_RENAME_INFORMATION *FileRenameInformation_structp; +IO_STATUS_BLOCK file_IoStatusBlock; +GnomeVFSResult errvfsresult; +OBJECT_ATTRIBUTES pathname_new_ObjectAttributes; + + g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object_old),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(pathname_new!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_file_slave_object_old=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object_old); + + g_return_val_if_fail(captive_file_slave_object_old->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + errvfsresult=captive_ObjectAttributes_init(pathname_new,&pathname_new_ObjectAttributes); + g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult); + + FileRenameInformation_structp= + g_alloca(sizeof(*FileRenameInformation_structp)+pathname_new_ObjectAttributes.ObjectName->MaximumLength); + FileRenameInformation_structp->Replace=force_replace; + FileRenameInformation_structp->RootDir=0; /* AFAIK never set by orig W32 */ + FileRenameInformation_structp->FileNameLength=pathname_new_ObjectAttributes.ObjectName->Length; + memcpy(FileRenameInformation_structp->FileName,pathname_new_ObjectAttributes.ObjectName->Buffer, + pathname_new_ObjectAttributes.ObjectName->MaximumLength); + + err=NtSetInformationFile( + captive_file_slave_object_old->file_Handle, /* FileHandle */ + &file_IoStatusBlock, /* IoStatusBlock */ + FileRenameInformation_structp, /* FileInformation */ + sizeof(*FileRenameInformation_structp)+pathname_new_ObjectAttributes.ObjectName->MaximumLength, /* Length */ + FileRenameInformation); /* FileInformationClass */ + if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) + goto err_free_ObjectAttributes; + g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + + errvfsresult=GNOME_VFS_OK; + +err_free_ObjectAttributes: + g_free(pathname_new_ObjectAttributes.ObjectName); /* left from captive_file_slave_uri_parent_init() */ + + captive_leave(); + return errvfsresult; +} diff --git a/src/libcaptive/client/file-slave.h b/src/libcaptive/client/file-slave.h new file mode 100644 index 0000000..c05dd7a --- /dev/null +++ b/src/libcaptive/client/file-slave.h @@ -0,0 +1,53 @@ +/* $Id$ + * Include file for captive vfs 'file' private interface to reactos of sandbox slave + * Copyright (C) 2003 Jan Kratochvil + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; exactly version 2 of June 1991 is required + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#ifndef _CAPTIVE_CLIENT_PRIV_FILE_SLAVE_H +#define _CAPTIVE_CLIENT_PRIV_FILE_SLAVE_H 1 + + +#include +#include +#include +#include +#include "captive/client-file.h" + + +G_BEGIN_DECLS + +#define CAPTIVE_FILE_SLAVE_TYPE_OBJECT (captive_file_slave_object_get_type()) +#define CAPTIVE_FILE_SLAVE_OBJECT(object) (G_TYPE_CHECK_INSTANCE_CAST((object),CAPTIVE_FILE_SLAVE_TYPE_OBJECT,CaptiveFileSlaveObject)) +#define CAPTIVE_FILE_SLAVE_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),CAPTIVE_FILE_SLAVE_TYPE_OBJECT,CaptiveFileSlaveObjectClass)) +#define CAPTIVE_FILE_SLAVE_IS_OBJECT(object) (G_TYPE_CHECK_INSTANCE_TYPE((object),CAPTIVE_FILE_SLAVE_TYPE_OBJECT)) +#define CAPTIVE_FILE_SLAVE_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),CAPTIVE_FILE_SLAVE_TYPE_OBJECT)) +#define CAPTIVE_FILE_SLAVE_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),CAPTIVE_FILE_SLAVE_TYPE_OBJECT,CaptiveFileSlaveObjectClass)) +typedef struct _CaptiveFileSlaveObject CaptiveFileSlaveObject; +typedef struct _CaptiveFileSlaveObjectClass CaptiveFileSlaveObjectClass; + + +GType captive_file_slave_object_get_type(void); + +GnomeVFSResult captive_file_slave_new_open(CaptiveFileObject **captive_file_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname,GnomeVFSOpenMode mode); +GnomeVFSResult captive_file_slave_new_create(CaptiveFileObject **captive_file_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname,GnomeVFSOpenMode mode,gboolean exclusive,guint perm); + +G_END_DECLS + + +#endif /* _CAPTIVE_CLIENT_PRIV_FILE_SLAVE_H */ diff --git a/src/libcaptive/client/file.c b/src/libcaptive/client/file.c index f1f5c3a..47117ca 100644 --- a/src/libcaptive/client/file.c +++ b/src/libcaptive/client/file.c @@ -21,21 +21,9 @@ #include "captive/client-file.h" /* self */ #include "file.h" /* self-priv */ -#include "directory.h" -#include "lib.h" #include -#include "captive/unicode.h" -#include "reactos/ntos/types.h" /* for HANDLE */ -#include "reactos/ddk/iotypes.h" /* for IO_STATUS_BLOCK */ -#include "reactos/ddk/iofuncs.h" /* for IoCreateFile() */ -#include "result.h" -#include "captive/client-directory.h" -#include "reactos/ddk/obfuncs.h" /* for ObReferenceObjectByHandle() */ -#include "captive/macros.h" -#include "captive/leave.h" -#include "captive/usecount.h" #include "vfs.h" -#include "captive/parent-File.h" +#include "reactos/ntos/types.h" /* for ULONG */ static gpointer captive_file_object_parent_class=NULL; @@ -57,14 +45,13 @@ static void captive_file_object_class_init(CaptiveFileObjectClass *class) { GObjectClass *gobject_class=G_OBJECT_CLASS(class); - captive_file_object_parent_class=g_type_class_ref(G_TYPE_OBJECT); + captive_file_object_parent_class=g_type_class_ref(g_type_parent(G_TYPE_FROM_CLASS(class))); gobject_class->finalize=(void (*)(GObject *object))captive_file_object_finalize; } static void captive_file_object_init(CaptiveFileObject *captive_file_object) { - captive_file_object->file_Handle=NULL; } @@ -86,747 +73,163 @@ static const GTypeInfo captive_file_object_info={ }; captive_file_object_type=g_type_register_static(G_TYPE_OBJECT, - "CaptiveFileObject",&captive_file_object_info,0); + "CaptiveFileObject",&captive_file_object_info,G_TYPE_FLAG_ABSTRACT); } return captive_file_object_type; } -static GnomeVFSResult captive_file_new_internal(CaptiveFileObject *captive_file_object, - const gchar *pathname,GnomeVFSOpenMode mode,gboolean create,gboolean create_exclusive,guint create_perm) -{ -IO_STATUS_BLOCK file_IoStatusBlock; -GnomeVFSResult errvfsresult; -OBJECT_ATTRIBUTES file_ObjectAttributes; -HANDLE file_Handle; -NTSTATUS err; - - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - - errvfsresult=captive_ObjectAttributes_init(pathname,&file_ObjectAttributes); - g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult); - - /* open */ - err=IoCreateFile( - &file_Handle, /* FileHandle */ - 0 - |(!(mode&GNOME_VFS_OPEN_READ ) ? 0 : FILE_READ_DATA) - |(!(mode&GNOME_VFS_OPEN_WRITE) ? 0 : FILE_WRITE_DATA | FILE_APPEND_DATA | FILE_WRITE_ATTRIBUTES) - |( mode!=0 ? 0 : FILE_READ_ATTRIBUTES) - , /* DesiredAccess */ - &file_ObjectAttributes, /* ObjectAttributes */ - &file_IoStatusBlock, /* IoStatusBlock */ - NULL, /* AllocationSize; ignored for open */ - (!create || create_perm&0200 ? FILE_ATTRIBUTE_NORMAL: FILE_ATTRIBUTE_READONLY), /* FileAttributes; ignored for open */ - (!create || !create_exclusive /* ShareAccess; 0 means exclusive */ - ? (FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE) - : 0), - (!create ? FILE_OPEN : FILE_CREATE), /* CreateDisposition */ - /* FILE_SYNCHRONOUS_IO_{,NON}ALERT: We need to allow W32 filesystem - * any waits to not to let it return STATUS_CANT_WAIT us. - * Alertability should have only effect on asynchronous events - * from KeWaitForSingleObject() by setting/clearing its parameter 'Alertable'. - */ - FILE_SYNCHRONOUS_IO_ALERT, /* CreateOptions */ - NULL, /* EaBuffer */ - 0, /* EaLength */ - CreateFileTypeNone, /* CreateFileType */ - NULL, /* ExtraCreateParameters */ - 0); /* Options */ - g_free(file_ObjectAttributes.ObjectName); /* left from captive_file_uri_parent_init() */ - g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC); - if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) - return errvfsresult; - g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); - g_return_val_if_fail(file_IoStatusBlock.Information - ==(!create ? FILE_OPENED : FILE_CREATED), - GNOME_VFS_ERROR_GENERIC); - - captive_file_object->file_Handle=file_Handle; - - return GNOME_VFS_OK; -} - - GnomeVFSResult captive_file_new_open(CaptiveFileObject **captive_file_object_return, CaptiveVfsObject *captive_vfs_object,const gchar *pathname,GnomeVFSOpenMode mode) { -GnomeVFSResult r; -CaptiveFileObject *captive_file_object; - g_return_val_if_fail(captive_file_object_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_vfs_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - captive_file_object=g_object_new( - CAPTIVE_FILE_TYPE_OBJECT, /* object_type */ - NULL); /* first_property_name; FIXME: support properties */ - captive_file_object->vfs=captive_vfs_object; - captive_file_object->file_Handle=NULL; - captive_file_object->offset=0; - *captive_file_object_return=captive_file_object; - - if (captive_vfs_object->is_sandbox_parent) - return captive_sandbox_parent_file_new_open(captive_file_object,pathname,mode); - - r=captive_file_new_internal(captive_file_object,pathname,mode, - FALSE, /* create */ - FALSE, /* create_exclusive; ignored */ - 0); /* create_perm; ignored */ - - captive_leave(); - if (r==GNOME_VFS_OK) - captive_usecount(+1); - else { - g_object_unref(captive_file_object); - *captive_file_object_return=NULL; - } - return r; + return (*CAPTIVE_VFS_OBJECT_GET_CLASS(captive_vfs_object)->file_new_open) + (captive_file_object_return,captive_vfs_object,pathname,mode); } GnomeVFSResult captive_file_new_create(CaptiveFileObject **captive_file_object_return, CaptiveVfsObject *captive_vfs_object,const gchar *pathname,GnomeVFSOpenMode mode,gboolean exclusive,guint perm) { -GnomeVFSResult r; -CaptiveFileObject *captive_file_object; - g_return_val_if_fail(captive_file_object_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_vfs_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - captive_file_object=g_object_new( - CAPTIVE_FILE_TYPE_OBJECT, /* object_type */ - NULL); /* first_property_name; FIXME: support properties */ - captive_file_object->vfs=captive_vfs_object; - captive_file_object->file_Handle=NULL; - captive_file_object->offset=0; - *captive_file_object_return=captive_file_object; - - if (captive_vfs_object->is_sandbox_parent) - return captive_sandbox_parent_file_new_create(captive_file_object,pathname,mode,exclusive,perm); - - r=captive_file_new_internal(captive_file_object,pathname,mode, - TRUE, /* create */ - exclusive, /* create_exclusive */ - perm); /* create_perm */ - - captive_leave(); - if (r==GNOME_VFS_OK) - captive_usecount(+1); - else { - g_object_unref(captive_file_object); - *captive_file_object_return=NULL; - } - return r; + return (*CAPTIVE_VFS_OBJECT_GET_CLASS(captive_vfs_object)->file_new_create) + (captive_file_object_return,captive_vfs_object,pathname,mode,exclusive,perm); } -static GnomeVFSResult captive_file_close(CaptiveFileObject *captive_file_object) +GnomeVFSResult captive_file_init(CaptiveFileObject *captive_file_object,CaptiveVfsObject *captive_vfs_object) { -NTSTATUS err; -HANDLE file_Handle; + g_return_val_if_fail(CAPTIVE_FILE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + g_return_val_if_fail(captive_file_object->vfs==NULL,GNOME_VFS_ERROR_GENERIC); + + captive_file_object->vfs=g_object_ref(captive_vfs_object); - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + return GNOME_VFS_OK; +} - if (captive_file_object->vfs->is_sandbox_parent) - return captive_sandbox_parent_file_close(captive_file_object); - if (captive_file_object->file_Handle!=NULL) { /* not yet already closed */ - captive_usecount(-1); /* close() errors notwithstanding */ +static GnomeVFSResult captive_file_close(CaptiveFileObject *captive_file_object) +{ + g_return_val_if_fail(CAPTIVE_FILE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - file_Handle=captive_file_object->file_Handle; - captive_file_object->file_Handle=NULL; - err=NtClose(file_Handle); - g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + if (captive_file_object->vfs!=NULL) { + g_object_unref(captive_file_object->vfs); + captive_file_object->vfs=NULL; } - captive_leave(); return GNOME_VFS_OK; } +CaptiveVfsObject *captive_file_ref_vfs(CaptiveFileObject *captive_file_object) +{ + g_return_val_if_fail(CAPTIVE_FILE_IS_OBJECT(captive_file_object),NULL); + + g_return_val_if_fail(CAPTIVE_VFS_IS_OBJECT(captive_file_object->vfs),NULL); + + return g_object_ref(captive_file_object->vfs); +} + + GnomeVFSResult captive_file_read(CaptiveFileObject *captive_file_object, gpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_read_return) { -NTSTATUS err; -IO_STATUS_BLOCK file_IoStatusBlock; -LARGE_INTEGER file_offset; -GnomeVFSResult errvfsresult; - - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_FILE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(buffer!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(bytes_read_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(num_bytes==(ULONG)num_bytes,GNOME_VFS_ERROR_BAD_PARAMETERS); - if (captive_file_object->vfs->is_sandbox_parent) - return captive_sandbox_parent_file_read(captive_file_object,buffer,num_bytes,bytes_read_return); - - g_return_val_if_fail(captive_file_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - - file_offset.QuadPart=captive_file_object->offset; - err=NtReadFile( - captive_file_object->file_Handle, /* FileHandle */ - NULL, /* EventHandle; completion signalling; optional */ - NULL, /* ApcRoutine; optional */ - NULL, /* ApcContext; optional */ - &file_IoStatusBlock, /* IoStatusBlock */ - buffer, /* Buffer */ - num_bytes, /* Length */ - &file_offset, /* ByteOffset */ - NULL); /* Key; NULL means no file locking key */ - if (err==STATUS_END_OF_FILE) { - g_return_val_if_fail(file_IoStatusBlock.Status==STATUS_END_OF_FILE,GNOME_VFS_ERROR_GENERIC); - g_return_val_if_fail(file_IoStatusBlock.Information==0,GNOME_VFS_ERROR_GENERIC); - *bytes_read_return=0; - return GNOME_VFS_ERROR_EOF; - } - g_return_val_if_fail(file_IoStatusBlock.Information>0,GNOME_VFS_ERROR_GENERIC); /* if not STATUS_END_OF_FILE... */ - if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) - return errvfsresult; - g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC); - g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); - g_return_val_if_fail(file_IoStatusBlock.Information<=num_bytes,GNOME_VFS_ERROR_GENERIC); - - captive_file_object->offset+=file_IoStatusBlock.Information; - *bytes_read_return=file_IoStatusBlock.Information; - captive_leave(); - return GNOME_VFS_OK; + return (*CAPTIVE_FILE_OBJECT_GET_CLASS(captive_file_object)->read) + (captive_file_object,buffer,num_bytes,bytes_read_return); } GnomeVFSResult captive_file_write(CaptiveFileObject *captive_file_object, gconstpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_written_return) { -NTSTATUS err; -IO_STATUS_BLOCK file_IoStatusBlock; -LARGE_INTEGER file_offset; -GnomeVFSFileInfo file_info; -GnomeVFSFileSize endoffile_wanted; -GnomeVFSResult errvfsresult; - - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_FILE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(buffer!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(bytes_written_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(num_bytes==(ULONG)num_bytes,GNOME_VFS_ERROR_BAD_PARAMETERS); - if (captive_file_object->vfs->is_sandbox_parent) - return captive_sandbox_parent_file_write(captive_file_object,buffer,num_bytes,bytes_written_return); - - g_return_val_if_fail(captive_file_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - - if ((GnomeVFSFileOffset)(captive_file_object->offset+num_bytes) < captive_file_object->offset) - return GNOME_VFS_ERROR_TOO_BIG; - endoffile_wanted=captive_file_object->offset+num_bytes; - if (GNOME_VFS_OK!=(errvfsresult=captive_file_file_info_get(captive_file_object,&file_info))) - return errvfsresult; - if (file_info.sizeoffset; - err=NtWriteFile( - captive_file_object->file_Handle, /* FileHandle */ - NULL, /* Event; completion signalling; optional */ - NULL, /* ApcRoutine; optional */ - NULL, /* ApcContext; optional */ - &file_IoStatusBlock, /* IoStatusBlock */ - (gpointer /* de-const */ )buffer, /* Buffer */ - num_bytes, /* Length */ - &file_offset, /* ByteOffset */ - NULL); /* Key; NULL means no file locking key */ - g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC); - g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); - g_return_val_if_fail(file_IoStatusBlock.Information==num_bytes,GNOME_VFS_ERROR_GENERIC); - - captive_file_object->offset+=file_IoStatusBlock.Information; - *bytes_written_return=file_IoStatusBlock.Information; - captive_leave(); - return GNOME_VFS_OK; + return (*CAPTIVE_FILE_OBJECT_GET_CLASS(captive_file_object)->write) + (captive_file_object,buffer,num_bytes,bytes_written_return); } GnomeVFSResult captive_file_seek (CaptiveFileObject *captive_file_object,GnomeVFSSeekPosition whence,GnomeVFSFileOffset offset) { - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - - if (captive_file_object->vfs->is_sandbox_parent) - return captive_sandbox_parent_file_seek(captive_file_object,whence,offset); - - g_return_val_if_fail(captive_file_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - - switch (whence) { - case GNOME_VFS_SEEK_START: - captive_file_object->offset=offset; - break; - case GNOME_VFS_SEEK_CURRENT: - if (0 - || (offset>0 && (captive_file_object->offset+offset)offset) - || (offset<0 && (captive_file_object->offset+offset)>captive_file_object->offset)) - return GNOME_VFS_ERROR_BAD_PARAMETERS; - captive_file_object->offset+=offset; - break; - case GNOME_VFS_SEEK_END: - g_assert_not_reached(); /* NOT IMPLEMENTED YET */ - break; - default: - g_return_val_if_reached(GNOME_VFS_ERROR_BAD_PARAMETERS); - } + g_return_val_if_fail(CAPTIVE_FILE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - captive_leave(); - return GNOME_VFS_OK; + return (*CAPTIVE_FILE_OBJECT_GET_CLASS(captive_file_object)->seek) + (captive_file_object,whence,offset); } GnomeVFSResult captive_file_tell(CaptiveFileObject *captive_file_object,GnomeVFSFileOffset *offset_return) { - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(offset_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - - if (captive_file_object->vfs->is_sandbox_parent) - return captive_sandbox_parent_file_tell(captive_file_object,offset_return); - - g_return_val_if_fail(captive_file_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_FILE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - *offset_return=captive_file_object->offset; - captive_leave(); - return GNOME_VFS_OK; + return (*CAPTIVE_FILE_OBJECT_GET_CLASS(captive_file_object)->tell) + (captive_file_object,offset_return); } GnomeVFSResult captive_file_remove(CaptiveFileObject *captive_file_object) { -NTSTATUS err; -FILE_DISPOSITION_INFORMATION FileDispositionInformation_struct; -IO_STATUS_BLOCK file_IoStatusBlock; -GnomeVFSResult errvfsresult; - - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - - if (captive_file_object->vfs->is_sandbox_parent) - return captive_sandbox_parent_file_remove(captive_file_object); - - g_return_val_if_fail(captive_file_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - - FileDispositionInformation_struct.DoDeleteFile=TRUE; - - err=NtSetInformationFile( - captive_file_object->file_Handle, /* FileHandle */ - &file_IoStatusBlock, /* IoStatusBlock */ - &FileDispositionInformation_struct, /* FileInformation */ - sizeof(FileDispositionInformation_struct), /* Length */ - FileDispositionInformation); /* FileInformationClass */ - if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) - return errvfsresult; - g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); + g_return_val_if_fail(CAPTIVE_FILE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - captive_leave(); - return GNOME_VFS_OK; -} - - -/* Use 'FileNameInformationStruct' identifier instead of the logical 'FileNameInformation' - * to prevent override of enum member 'FileNameInformation' - */ -static GnomeVFSResult FileNameInformationStruct_to_GnomeVFSFileInfo(GnomeVFSFileInfo *file_info, - FILE_NAME_INFORMATION *FileNameInformationStruct) -{ -UNICODE_STRING FileName_UnicodeString; - - g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_GENERIC); - g_return_val_if_fail(FileNameInformationStruct!=NULL,GNOME_VFS_ERROR_GENERIC); - - FileName_UnicodeString.Length=FileNameInformationStruct->FileNameLength; - FileName_UnicodeString.MaximumLength=FileNameInformationStruct->FileNameLength - +sizeof(*FileNameInformationStruct->FileName); /* 0-terminator */ - -#if 0 /* 'IoStatusBlock->Information' is sometimes weird, do not check it */ - g_assert((gpointer)(((char *)FileNameInformationStruct->FileName)+FileName_UnicodeString.Length) - <=(gpointer)(((char *)FileAllInformationStruct)+IoStatusBlock->Information)); - /* ensure we fit below '->IoStatusBlock->Information' at least without the 0-terminator */ -#endif - - FileNameInformationStruct->FileName[FileNameInformationStruct->FileNameLength - /sizeof(*FileNameInformationStruct->FileName)]=0; /* 0-terminate it */ - FileName_UnicodeString.Buffer=FileNameInformationStruct->FileName; - file_info->name=captive_UnicodeString_to_utf8_malloc(&FileName_UnicodeString); - /* '->name' assumed for 'file_info->valid_fields' */ - - return GNOME_VFS_OK; -} - - -/* Use 'FileBasicInformationStruct' identifier instead of the logical 'FileBasicInformation' - * to prevent override of enum member 'FileBasicInformation' - */ -static GnomeVFSResult FileBasicInformationStruct_to_GnomeVFSFileInfo(GnomeVFSFileInfo *file_info, - FILE_BASIC_INFORMATION *FileBasicInformationStruct) -{ -BOOLEAN errBOOLEAN; -ULONG tmp_ULONG; - - /* FIXME: What is 'FILE_ATTRIBUTE_NORMAL'? */ - switch (FileBasicInformationStruct->FileAttributes & (0 - | FILE_ATTRIBUTE_DIRECTORY - | FILE_ATTRIBUTE_DEVICE)) { - case 0: file_info->type=GNOME_VFS_FILE_TYPE_REGULAR; break; - case FILE_ATTRIBUTE_DIRECTORY: file_info->type=GNOME_VFS_FILE_TYPE_DIRECTORY; break; - case FILE_ATTRIBUTE_DEVICE: file_info->type=GNOME_VFS_FILE_TYPE_SOCKET; - /* or GNOME_VFS_FILE_TYPE_CHARACTER_DEVICE or GNOME_VFS_FILE_TYPE_BLOCK_DEVICE ? */ - break; - default: file_info->type=GNOME_VFS_FILE_TYPE_UNKNOWN; break; - } - file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_TYPE; - - /* we use 0600 for r/w files, 0400 for FILE_ATTRIBUTE_READONLY */ - file_info->permissions=GNOME_VFS_PERM_USER_READ; - if (file_info->type==GNOME_VFS_FILE_TYPE_DIRECTORY) - file_info->permissions|=GNOME_VFS_PERM_USER_EXEC; - if (!(FileBasicInformationStruct->FileAttributes & FILE_ATTRIBUTE_READONLY)) - file_info->permissions|=GNOME_VFS_PERM_USER_WRITE; - file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS; - - if (FileBasicInformationStruct->LastAccessTime.QuadPart) { /* it may be 0 if not set */ - errBOOLEAN=RtlTimeToSecondsSince1970(&FileBasicInformationStruct->LastAccessTime,&tmp_ULONG); - g_assert(errBOOLEAN==TRUE); - file_info->atime=tmp_ULONG; - file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_ATIME; - } - - /* it may be 0 if not set */ - if (FileBasicInformationStruct->LastWriteTime.QuadPart || FileBasicInformationStruct->ChangeTime.QuadPart) { - errBOOLEAN=RtlTimeToSecondsSince1970( - /* take the more recent (==bigger) time: */ - (FileBasicInformationStruct->LastWriteTime.QuadPart > FileBasicInformationStruct->ChangeTime.QuadPart - ? &FileBasicInformationStruct->LastWriteTime : &FileBasicInformationStruct->ChangeTime), - &tmp_ULONG); - g_assert(errBOOLEAN==TRUE); - file_info->mtime=tmp_ULONG; - file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_MTIME; - } - - if (FileBasicInformationStruct->CreationTime.QuadPart) { /* it may be 0 if not set */ - errBOOLEAN=RtlTimeToSecondsSince1970(&FileBasicInformationStruct->CreationTime,&tmp_ULONG); - g_assert(errBOOLEAN==TRUE); - file_info->ctime=tmp_ULONG; - file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_CTIME; - } - - return GNOME_VFS_OK; -} - - -/* Use 'FileStandardInformationStruct' identifier instead of the logical 'FileStandardInformation' - * to prevent override of enum member 'FileStandardInformation' - */ -static GnomeVFSResult FileStandardInformationStruct_to_GnomeVFSFileInfo(GnomeVFSFileInfo *file_info, - FILE_STANDARD_INFORMATION *FileStandardInformationStruct) -{ - file_info->size=FileStandardInformationStruct->EndOfFile.QuadPart; - file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_SIZE; - - file_info->block_count=FileStandardInformationStruct->AllocationSize.QuadPart/512; - file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_BLOCK_COUNT; - - return GNOME_VFS_OK; + return (*CAPTIVE_FILE_OBJECT_GET_CLASS(captive_file_object)->remove) + (captive_file_object); } GnomeVFSResult captive_file_file_info_get(CaptiveFileObject *captive_file_object, GnomeVFSFileInfo *file_info) { -NTSTATUS err; -IO_STATUS_BLOCK file_IoStatusBlock; -FILE_NAME_INFORMATION *FileNameInformationStruct; -FILE_BASIC_INFORMATION *FileBasicInformationStruct; -FILE_STANDARD_INFORMATION *FileStandardInformationStruct; -GnomeVFSResult errvfsresult; -char QueryFile_buf[sizeof(FILE_NAME_INFORMATION) - +0x1000 /* max 'FileName' length, 255 should be enough */ * sizeof(WCHAR /* *FILE_ALL_INFORMATION.NameInformation.FileName */ )]; - - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_FILE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - if (captive_file_object->vfs->is_sandbox_parent) - return captive_sandbox_parent_file_file_info_get(captive_file_object,file_info); - - g_return_val_if_fail(captive_file_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - - /* ntfs.sys of NT-5.1sp1 has *(FILE_BASIC_INFORMATION *)FILE_ALL_INFORMATION.BasicInformation - * size 0x28 although reactos includes and all the information says 0x24. - * fastfat.sys of NT-5.1sp1 also has the 'official' sizeof 0x24. - * It would be a bit of heuristic to correctly detect its expected sizeof. - */ - - file_info->valid_fields=0; - - file_info->flags=GNOME_VFS_FILE_FLAGS_LOCAL; - file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_FLAGS; - - /* query NameInformation */ - FileNameInformationStruct=(void *)QueryFile_buf; - err=NtQueryInformationFile( - captive_file_object->file_Handle, /* FileHandle */ - &file_IoStatusBlock, /* IoStatusBlock */ - (gpointer)QueryFile_buf, /* FileInformation */ - sizeof(QueryFile_buf) /* Length */ - -sizeof(*FileNameInformationStruct->FileName), /* reserve space for a possible 0-terminator */ - FileNameInformation); /* FileInformationClass; =>FILE_NAME_INFORMATION */ - if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) - return errvfsresult; - g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC); - g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); - errvfsresult=FileNameInformationStruct_to_GnomeVFSFileInfo(file_info,FileNameInformationStruct); - g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult); - - /* query BasicInformation */ - FileBasicInformationStruct=(void *)QueryFile_buf; - err=NtQueryInformationFile( - captive_file_object->file_Handle, /* FileHandle */ - &file_IoStatusBlock, /* IoStatusBlock */ - (gpointer)QueryFile_buf, /* FileInformation */ - sizeof(QueryFile_buf), /* Length */ - FileBasicInformation); /* FileInformationClass; =>FILE_BASIC_INFORMATION */ - if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) - return errvfsresult; - g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC); - g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); - errvfsresult=FileBasicInformationStruct_to_GnomeVFSFileInfo(file_info,FileBasicInformationStruct); - g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult); - - /* query StandardInformation */ - FileStandardInformationStruct=(void *)QueryFile_buf; - err=NtQueryInformationFile( - captive_file_object->file_Handle, /* FileHandle */ - &file_IoStatusBlock, /* IoStatusBlock */ - (gpointer)QueryFile_buf, /* FileInformation */ - sizeof(QueryFile_buf), /* Length */ - FileStandardInformation); /* FileInformationClass; =>FILE_STANDARD_INFORMATION */ - if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) - return errvfsresult; - g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC); - g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); - errvfsresult=FileStandardInformationStruct_to_GnomeVFSFileInfo(file_info,FileStandardInformationStruct); - g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult); - - captive_leave(); - return GNOME_VFS_OK; + return (*CAPTIVE_FILE_OBJECT_GET_CLASS(captive_file_object)->file_info_get) + (captive_file_object,file_info); } GnomeVFSResult captive_file_file_info_set(CaptiveFileObject *captive_file_object, const GnomeVFSFileInfo *info,GnomeVFSSetFileInfoMask mask) { - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_FILE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - if (captive_file_object->vfs->is_sandbox_parent) - return captive_sandbox_parent_file_file_info_set(captive_file_object,info,mask); - - g_return_val_if_fail(captive_file_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - - if (mask & GNOME_VFS_SET_FILE_INFO_NAME) { -gchar *name_dirname,*name_basename; -UNICODE_STRING *name_UnicodeString; -FILE_RENAME_INFORMATION *FileRenameInformation_structp; -gsize FileRenameInformation_struct_len; -IO_STATUS_BLOCK file_IoStatusBlock; -NTSTATUS err; -GnomeVFSResult errvfsresult; - - /* non-existing dirname assertion */ - name_dirname=g_path_get_dirname(info->name); - if (*name_dirname) { - g_assert_not_reached(); - errvfsresult=GNOME_VFS_ERROR_BAD_PARAMETERS; - goto err; - } - - /* fully-matching basename assertion */ - name_basename=g_path_get_basename(info->name); - if (strcmp(name_basename,info->name)) { - g_assert_not_reached(); - errvfsresult=GNOME_VFS_ERROR_BAD_PARAMETERS; - goto err_free_name_dirname; - } - - name_UnicodeString=captive_utf8_to_UnicodeString_alloca(info->name); - FileRenameInformation_struct_len=sizeof(*FileRenameInformation_structp) - +name_UnicodeString->MaximumLength; /* ==Length+(0-terminator); is the terminator needed? */ - - FileRenameInformation_structp=g_alloca(FileRenameInformation_struct_len); - FileRenameInformation_structp->Replace=FALSE; - FileRenameInformation_structp->RootDir=NULL; /* we do 'simple rename' here */ - FileRenameInformation_structp->FileNameLength=name_UnicodeString->Length; - memcpy(FileRenameInformation_structp->FileName,name_UnicodeString->Buffer, - name_UnicodeString->MaximumLength); /* ==Length+(0-terminator); is the terminator needed? */ - - err=NtSetInformationFile( - captive_file_object->file_Handle, /* FileHandle */ - &file_IoStatusBlock, /* IoStatusBlock */ - FileRenameInformation_structp, /* FileInformation */ - FileRenameInformation_struct_len, /* Length */ - FileRenameInformation); /* FileInformationClass */ - if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) - goto err_free_name_basename; - -err_free_name_basename: - g_free(name_basename); -err_free_name_dirname: - g_free(name_dirname); -err: - - if (errvfsresult!=GNOME_VFS_OK) - return errvfsresult; - g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); - } - - if (mask & (GNOME_VFS_SET_FILE_INFO_PERMISSIONS | GNOME_VFS_SET_FILE_INFO_TIME)) { -char FileBasicInformation_buf[sizeof(FILE_BASIC_INFORMATION)+4]; -FILE_BASIC_INFORMATION *FileBasicInformationp=(FILE_BASIC_INFORMATION *)FileBasicInformation_buf; -IO_STATUS_BLOCK file_IoStatusBlock; -NTSTATUS err; - - /* FIXME: Everywhere is is the declaration with 4xLARGE_INTEGER+1xULONG==36 bytes - * but the precompiled ext2fsd.sys wants 40 bytes - why? - * The same case applies to ntfs.sys of NT-5.1sp1. - */ - g_assert(sizeof(FILE_BASIC_INFORMATION)==36); - g_assert(sizeof(FileBasicInformation_buf)==40); - err=NtQueryInformationFile( - captive_file_object->file_Handle, /* FileHandle */ - &file_IoStatusBlock, /* IoStatusBlock */ - FileBasicInformation_buf, /* FileInformation */ - sizeof(FileBasicInformation_buf), /* Length */ - FileBasicInformation); /* FileInformationClass */ - g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); - - if (mask & GNOME_VFS_SET_FILE_INFO_PERMISSIONS) { - FileBasicInformationp->FileAttributes&=~FILE_ATTRIBUTE_READONLY; - g_assert(info->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS); - if (!(info->permissions&0200)) - FileBasicInformationp->FileAttributes|=FILE_ATTRIBUTE_READONLY; - } - - if (mask & GNOME_VFS_SET_FILE_INFO_TIME) { - g_assert(info->valid_fields & (0 - | GNOME_VFS_FILE_INFO_FIELDS_ATIME - | GNOME_VFS_FILE_INFO_FIELDS_MTIME - | GNOME_VFS_FILE_INFO_FIELDS_CTIME)); - if (info->valid_fields&GNOME_VFS_FILE_INFO_FIELDS_ATIME) { - RtlSecondsSince1970ToTime( - info->atime, /* SecondsSince1970 */ - &FileBasicInformationp->LastAccessTime); /* Time */ - } - if (info->valid_fields&GNOME_VFS_FILE_INFO_FIELDS_MTIME) { - RtlSecondsSince1970ToTime( - info->mtime, /* SecondsSince1970 */ - &FileBasicInformationp->LastWriteTime); /* Time */ - FileBasicInformationp->ChangeTime=FileBasicInformationp->LastWriteTime; - } - if (info->valid_fields&GNOME_VFS_FILE_INFO_FIELDS_CTIME) { - RtlSecondsSince1970ToTime( - info->ctime, /* SecondsSince1970 */ - &FileBasicInformationp->CreationTime); /* Time */ - } - } - - err=NtSetInformationFile( - captive_file_object->file_Handle, /* FileHandle */ - &file_IoStatusBlock, /* IoStatusBlock */ - FileBasicInformation_buf, /* FileInformation */ - sizeof(FileBasicInformation_buf), /* Length */ - FileBasicInformation); /* FileInformationClass */ - g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); - } - - if (mask & GNOME_VFS_SET_FILE_INFO_OWNER) { - /* FIXME: g_assert(info->valid_fields & ???); */ - /* owner ignored for W32 */ - } - - captive_leave(); - return GNOME_VFS_OK; + return (*CAPTIVE_FILE_OBJECT_GET_CLASS(captive_file_object)->file_info_set) + (captive_file_object,info,mask); } GnomeVFSResult captive_file_truncate(CaptiveFileObject *captive_file_object,GnomeVFSFileSize file_size) { -NTSTATUS err; -FILE_END_OF_FILE_INFORMATION FileEndOfFileInformation_struct; -IO_STATUS_BLOCK file_IoStatusBlock; -GnomeVFSResult errvfsresult; - - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - - if (captive_file_object->vfs->is_sandbox_parent) - return captive_sandbox_parent_file_truncate(captive_file_object,file_size); + g_return_val_if_fail(CAPTIVE_FILE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_file_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - - FileEndOfFileInformation_struct.EndOfFile.QuadPart=file_size; - - err=NtSetInformationFile( - captive_file_object->file_Handle, /* FileHandle */ - &file_IoStatusBlock, /* IoStatusBlock */ - &FileEndOfFileInformation_struct, /* FileInformation */ - sizeof(FileEndOfFileInformation_struct), /* Length */ - FileEndOfFileInformation); /* FileInformationClass */ - if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) - return errvfsresult; - g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); - - captive_leave(); - return GNOME_VFS_OK; + return (*CAPTIVE_FILE_OBJECT_GET_CLASS(captive_file_object)->truncate) + (captive_file_object,file_size); } GnomeVFSResult captive_file_move(CaptiveFileObject *captive_file_object_old,const gchar *pathname_new,gboolean force_replace) { -NTSTATUS err; -FILE_RENAME_INFORMATION *FileRenameInformation_structp; -IO_STATUS_BLOCK file_IoStatusBlock; -GnomeVFSResult errvfsresult; -OBJECT_ATTRIBUTES pathname_new_ObjectAttributes; - - g_return_val_if_fail(captive_file_object_old!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_FILE_IS_OBJECT(captive_file_object_old),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(pathname_new!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - if (captive_file_object_old->vfs->is_sandbox_parent) - return captive_sandbox_parent_file_move(captive_file_object_old,pathname_new,force_replace); - - g_return_val_if_fail(captive_file_object_old->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - - errvfsresult=captive_ObjectAttributes_init(pathname_new,&pathname_new_ObjectAttributes); - g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult); - - FileRenameInformation_structp= - g_alloca(sizeof(*FileRenameInformation_structp)+pathname_new_ObjectAttributes.ObjectName->MaximumLength); - FileRenameInformation_structp->Replace=force_replace; - FileRenameInformation_structp->RootDir=0; /* AFAIK never set by orig W32 */ - FileRenameInformation_structp->FileNameLength=pathname_new_ObjectAttributes.ObjectName->Length; - memcpy(FileRenameInformation_structp->FileName,pathname_new_ObjectAttributes.ObjectName->Buffer, - pathname_new_ObjectAttributes.ObjectName->MaximumLength); - - err=NtSetInformationFile( - captive_file_object_old->file_Handle, /* FileHandle */ - &file_IoStatusBlock, /* IoStatusBlock */ - FileRenameInformation_structp, /* FileInformation */ - sizeof(*FileRenameInformation_structp)+pathname_new_ObjectAttributes.ObjectName->MaximumLength, /* Length */ - FileRenameInformation); /* FileInformationClass */ - if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) - goto err_free_ObjectAttributes; - g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC); - - errvfsresult=GNOME_VFS_OK; - -err_free_ObjectAttributes: - g_free(pathname_new_ObjectAttributes.ObjectName); /* left from captive_file_uri_parent_init() */ - - captive_leave(); - return errvfsresult; + return (*CAPTIVE_FILE_OBJECT_GET_CLASS(captive_file_object_old)->move) + (captive_file_object_old,pathname_new,force_replace); } diff --git a/src/libcaptive/client/file.h b/src/libcaptive/client/file.h index 16eebf8..e4f1af5 100644 --- a/src/libcaptive/client/file.h +++ b/src/libcaptive/client/file.h @@ -23,9 +23,7 @@ #include #include -#include "reactos/napi/types.h" /* for NTSTATUS */ #include "captive/client-vfs.h" -#include "../sandbox/sandbox.h" G_BEGIN_DECLS @@ -35,14 +33,28 @@ struct _CaptiveFileObject { /*< private >*/ CaptiveVfsObject *vfs; - Captive_File corba_File_object; - HANDLE file_Handle; - GnomeVFSFileOffset offset; }; struct _CaptiveFileObjectClass { GObjectClass parent_class; + + GnomeVFSResult (*read)(CaptiveFileObject *captive_file_object, + gpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_read_return); + GnomeVFSResult (*write)(CaptiveFileObject *captive_file_object, + gconstpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_written_return); + GnomeVFSResult (*seek) + (CaptiveFileObject *captive_file_object,GnomeVFSSeekPosition whence,GnomeVFSFileOffset offset); + GnomeVFSResult (*tell)(CaptiveFileObject *captive_file_object,GnomeVFSFileOffset *offset_return); + GnomeVFSResult (*remove)(CaptiveFileObject *captive_file_object); + GnomeVFSResult (*file_info_get)(CaptiveFileObject *captive_file_object, + GnomeVFSFileInfo *file_info); + GnomeVFSResult (*file_info_set)(CaptiveFileObject *captive_file_object, + const GnomeVFSFileInfo *info,GnomeVFSSetFileInfoMask mask); + GnomeVFSResult (*truncate)(CaptiveFileObject *captive_file_object,GnomeVFSFileSize file_size); + GnomeVFSResult (*move)(CaptiveFileObject *captive_file_object_old,const gchar *pathname_new,gboolean force_replace); }; +GnomeVFSResult captive_file_init(CaptiveFileObject *captive_file_object,CaptiveVfsObject *captive_vfs_object); + G_END_DECLS diff --git a/src/libcaptive/client/vfs-parent.c b/src/libcaptive/client/vfs-parent.c new file mode 100644 index 0000000..c2f1ef8 --- /dev/null +++ b/src/libcaptive/client/vfs-parent.c @@ -0,0 +1,148 @@ +/* $Id$ + * captive vfs 'vfs' interface to reactos of sandbox parent + * Copyright (C) 2002-2003 Jan Kratochvil + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; exactly version 2 of June 1991 is required + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include "config.h" + +#include "vfs-parent.h" /* self */ +#include +#include "captive/macros.h" +#include "../sandbox/parent-Vfs.h" +#include "directory-parent.h" +#include "file-parent.h" + + +static gpointer captive_vfs_parent_object_parent_class=NULL; + + +static GnomeVFSResult captive_vfs_parent_init(CaptiveVfsObject *captive_vfs_object); +static GnomeVFSResult captive_vfs_parent_close(CaptiveVfsObject *captive_vfs_object); +static GnomeVFSResult captive_vfs_parent_commit(CaptiveVfsObject *captive_vfs_object); +static GnomeVFSResult captive_vfs_parent_volume_info_get + (CaptiveVfsObject *captive_vfs_object,CaptiveVfsVolumeInfo *volume_info); + + +static void captive_vfs_parent_object_finalize(CaptiveVfsParentObject *captive_vfs_parent_object) +{ + g_return_if_fail(captive_vfs_parent_object!=NULL); + + captive_vfs_parent_close(CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)); /* errors ignored */ + + G_OBJECT_CLASS(captive_vfs_parent_object_parent_class)->finalize((GObject *)captive_vfs_parent_object); +} + + +static void captive_vfs_parent_object_class_init(CaptiveVfsParentObjectClass *class) +{ +GObjectClass *gobject_class=G_OBJECT_CLASS(class); +CaptiveVfsObjectClass *captive_vfs_object_class=CAPTIVE_VFS_OBJECT_CLASS(class); + + captive_vfs_parent_object_parent_class=g_type_class_ref(g_type_parent(G_TYPE_FROM_CLASS(class))); + gobject_class->finalize=(void (*)(GObject *object))captive_vfs_parent_object_finalize; + + captive_vfs_object_class->init=captive_vfs_parent_init; + captive_vfs_object_class->commit=captive_vfs_parent_commit; + captive_vfs_object_class->volume_info_get=captive_vfs_parent_volume_info_get; + + captive_vfs_object_class->directory_new_open=captive_directory_parent_new_open; + captive_vfs_object_class->directory_new_make=captive_directory_parent_new_make; + + captive_vfs_object_class->file_new_open=captive_file_parent_new_open; + captive_vfs_object_class->file_new_create=captive_file_parent_new_create; +} + + +static void captive_vfs_parent_object_init(CaptiveVfsParentObject *captive_vfs_parent_object) +{ + captive_vfs_parent_object->corba_parent_giochanel_blind=NULL; +} + + +GType captive_vfs_parent_object_get_type(void) +{ +static GType captive_vfs_parent_object_type=0; + + if (!captive_vfs_parent_object_type) { +static const GTypeInfo captive_vfs_parent_object_info={ + sizeof(CaptiveVfsParentObjectClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc)captive_vfs_parent_object_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof(CaptiveVfsParentObject), + 5, /* n_preallocs */ + (GInstanceInitFunc)captive_vfs_parent_object_init, + }; + + captive_vfs_parent_object_type=g_type_register_static(CAPTIVE_VFS_TYPE_OBJECT, + "CaptiveVfsParentObject",&captive_vfs_parent_object_info,0); + } + + return captive_vfs_parent_object_type; +} + + +static GnomeVFSResult captive_vfs_parent_init(CaptiveVfsObject *captive_vfs_object) +{ +CaptiveVfsParentObject *captive_vfs_parent_object; + + g_return_val_if_fail(CAPTIVE_VFS_PARENT_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(captive_vfs_object); + + return captive_sandbox_parent_vfs_new(captive_vfs_parent_object); +} + + +static GnomeVFSResult captive_vfs_parent_close(CaptiveVfsObject *captive_vfs_object) +{ +CaptiveVfsParentObject *captive_vfs_parent_object; + + g_return_val_if_fail(CAPTIVE_VFS_PARENT_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(captive_vfs_object); + + return captive_sandbox_parent_vfs_close(captive_vfs_parent_object); +} + + +static GnomeVFSResult captive_vfs_parent_commit(CaptiveVfsObject *captive_vfs_object) +{ +CaptiveVfsParentObject *captive_vfs_parent_object; + + g_return_val_if_fail(CAPTIVE_VFS_PARENT_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(captive_vfs_object); + + return captive_sandbox_parent_vfs_commit(captive_vfs_parent_object); +} + + +static GnomeVFSResult captive_vfs_parent_volume_info_get + (CaptiveVfsObject *captive_vfs_object,CaptiveVfsVolumeInfo *volume_info) +{ +CaptiveVfsParentObject *captive_vfs_parent_object; + + g_return_val_if_fail(CAPTIVE_VFS_PARENT_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(volume_info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(captive_vfs_object); + + return captive_sandbox_parent_vfs_volume_info_get(captive_vfs_parent_object,volume_info); +} diff --git a/src/libcaptive/client/vfs-parent.h b/src/libcaptive/client/vfs-parent.h new file mode 100644 index 0000000..c340133 --- /dev/null +++ b/src/libcaptive/client/vfs-parent.h @@ -0,0 +1,74 @@ +/* $Id$ + * Include vfs for captive 'vfs' private interface to reactos of sandbox parent + * Copyright (C) 2003 Jan Kratochvil + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; exactly version 2 of June 1991 is required + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#ifndef _CAPTIVE_CLIENT_PRIV_VFS_PARENT_H +#define _CAPTIVE_CLIENT_PRIV_VFS_PARENT_H 1 + + +#include +#include +#include +#include "captive/client-vfs.h" /* for CaptiveVfsObject */ +#include "vfs.h" /* for CaptiveVfsObject priv */ +#include "../sandbox/sandbox.h" +#include + + +G_BEGIN_DECLS + +#define CAPTIVE_VFS_PARENT_TYPE_OBJECT (captive_vfs_parent_object_get_type()) +#define CAPTIVE_VFS_PARENT_OBJECT(object) (G_TYPE_CHECK_INSTANCE_CAST((object),CAPTIVE_VFS_PARENT_TYPE_OBJECT,CaptiveVfsParentObject)) +#define CAPTIVE_VFS_PARENT_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),CAPTIVE_VFS_PARENT_TYPE_OBJECT,CaptiveVfsParentObjectClass)) +#define CAPTIVE_VFS_PARENT_IS_OBJECT(object) (G_TYPE_CHECK_INSTANCE_TYPE((object),CAPTIVE_VFS_PARENT_TYPE_OBJECT)) +#define CAPTIVE_VFS_PARENT_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),CAPTIVE_VFS_PARENT_TYPE_OBJECT)) +#define CAPTIVE_VFS_PARENT_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),CAPTIVE_VFS_PARENT_TYPE_OBJECT,CaptiveVfsParentObjectClass)) +typedef struct _CaptiveVfsParentObject CaptiveVfsParentObject; +typedef struct _CaptiveVfsParentObjectClass CaptiveVfsParentObjectClass; + + +GType captive_vfs_parent_object_get_type(void); + +struct _CaptiveVfsParentObject { + CaptiveVfsObject parent_instance; + + Captive_Vfs corba_Vfs_object; + Captive_GLogFunc corba_GLogFunc_object; + Captive_CaptiveIOChannel corba_CaptiveIOChannel_object; + /* It may corba_parent_giochanel_blind_source==options.image_iochannel ! + * 1st stage : corba_parent_giochanel_blind + * 2nd stage (optional): corba_parent_giochanel_blind_source + * 3rd stage : options.image_iochannel + */ + GIOChannel *corba_parent_giochanel_blind; + GIOChannel *corba_parent_giochanel_blind_source; + int corba_parentheart_fds_1; + pid_t corba_child_pid; + xmlDoc *corba_bug_doc; + xmlNode *corba_bug; + xmlNode *corba_bug_action; + xmlNode *corba_bug_log; + }; +struct _CaptiveVfsParentObjectClass { + CaptiveVfsObjectClass parent_class; + }; + +G_END_DECLS + + +#endif /* _CAPTIVE_CLIENT_PRIV_VFS_PARENT_H */ diff --git a/src/libcaptive/client/vfs-slave.c b/src/libcaptive/client/vfs-slave.c new file mode 100644 index 0000000..5bb7a0a --- /dev/null +++ b/src/libcaptive/client/vfs-slave.c @@ -0,0 +1,210 @@ +/* $Id$ + * captive vfs 'vfs' interface to reactos of sandbox slave + * Copyright (C) 2003 Jan Kratochvil + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; exactly version 2 of June 1991 is required + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include "config.h" + +#include "vfs-slave.h" /* self */ +#include +#include "captive/client-vfs.h" /* for CaptiveVfsObject */ +#include "vfs.h" /* for CaptiveVfsObject priv */ +#include "captive/macros.h" +#include "directory.h" +#include "reactos/ddk/iotypes.h" +#include "captive/client-directory.h" +#include "reactos/ntos/zw.h" /* for NtQueryVolumeInformationFile() */ +#include "result.h" +#include "init.h" +#include "directory-slave.h" +#include "file-slave.h" + + +struct _CaptiveVfsSlaveObject { + CaptiveVfsObject parent_instance; + }; +struct _CaptiveVfsSlaveObjectClass { + CaptiveVfsObjectClass parent_class; + }; + + +static gpointer captive_vfs_slave_object_parent_class=NULL; + + +static GnomeVFSResult captive_vfs_slave_init(CaptiveVfsObject *captive_vfs_object); +static GnomeVFSResult captive_vfs_slave_close(CaptiveVfsObject *captive_vfs_object); +static GnomeVFSResult captive_vfs_slave_commit(CaptiveVfsObject *captive_vfs_object); +static GnomeVFSResult captive_vfs_slave_volume_info_get + (CaptiveVfsObject *captive_vfs_object,CaptiveVfsVolumeInfo *volume_info); + + +static void captive_vfs_slave_object_finalize(CaptiveVfsSlaveObject *captive_vfs_slave_object) +{ + g_return_if_fail(captive_vfs_slave_object!=NULL); + + captive_vfs_slave_close(CAPTIVE_VFS_OBJECT(captive_vfs_slave_object)); /* errors ignored */ + + G_OBJECT_CLASS(captive_vfs_slave_object_parent_class)->finalize((GObject *)captive_vfs_slave_object); +} + + +static void captive_vfs_slave_object_class_init(CaptiveVfsSlaveObjectClass *class) +{ +GObjectClass *gobject_class=G_OBJECT_CLASS(class); +CaptiveVfsObjectClass *captive_vfs_object_class=CAPTIVE_VFS_OBJECT_CLASS(class); + + captive_vfs_slave_object_parent_class=g_type_class_ref(g_type_parent(G_TYPE_FROM_CLASS(class))); + gobject_class->finalize=(void (*)(GObject *object))captive_vfs_slave_object_finalize; + + captive_vfs_object_class->init=captive_vfs_slave_init; + captive_vfs_object_class->commit=captive_vfs_slave_commit; + captive_vfs_object_class->volume_info_get=captive_vfs_slave_volume_info_get; + + captive_vfs_object_class->directory_new_open=captive_directory_slave_new_open; + captive_vfs_object_class->directory_new_make=captive_directory_slave_new_make; + + captive_vfs_object_class->file_new_open=captive_file_slave_new_open; + captive_vfs_object_class->file_new_create=captive_file_slave_new_create; +} + + +static void captive_vfs_slave_object_init(CaptiveVfsSlaveObject *captive_vfs_slave_object) +{ +} + + +GType captive_vfs_slave_object_get_type(void) +{ +static GType captive_vfs_slave_object_type=0; + + if (!captive_vfs_slave_object_type) { +static const GTypeInfo captive_vfs_slave_object_info={ + sizeof(CaptiveVfsSlaveObjectClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc)captive_vfs_slave_object_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof(CaptiveVfsSlaveObject), + 5, /* n_preallocs */ + (GInstanceInitFunc)captive_vfs_slave_object_init, + }; + + captive_vfs_slave_object_type=g_type_register_static(CAPTIVE_VFS_TYPE_OBJECT, + "CaptiveVfsSlaveObject",&captive_vfs_slave_object_info,0); + } + + return captive_vfs_slave_object_type; +} + + +static GnomeVFSResult captive_vfs_slave_init(CaptiveVfsObject *captive_vfs_object) +{ +CaptiveVfsSlaveObject *captive_vfs_slave_object; +gboolean errbool; + + g_return_val_if_fail(CAPTIVE_VFS_SLAVE_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_vfs_slave_object=CAPTIVE_VFS_SLAVE_OBJECT(captive_vfs_object); + + g_assert(captive_options==NULL); + captive_options=&captive_vfs_object->options; + + errbool=captive_init(); + g_assert(errbool==TRUE); + + return GNOME_VFS_OK; +} + + +static GnomeVFSResult captive_vfs_slave_close(CaptiveVfsObject *captive_vfs_object) +{ +CaptiveVfsSlaveObject *captive_vfs_slave_object; +gboolean errbool; + + g_return_val_if_fail(CAPTIVE_VFS_SLAVE_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_vfs_slave_object=CAPTIVE_VFS_SLAVE_OBJECT(captive_vfs_object); + + g_assert(captive_options==&captive_vfs_object->options); + errbool=captive_shutdown(); + g_assert(errbool==TRUE); + + captive_options=NULL; + + return GNOME_VFS_OK; +} + + +static GnomeVFSResult captive_vfs_slave_commit(CaptiveVfsObject *captive_vfs_object) +{ +CaptiveVfsSlaveObject *captive_vfs_slave_object; + + g_return_val_if_fail(CAPTIVE_VFS_SLAVE_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_vfs_slave_object=CAPTIVE_VFS_SLAVE_OBJECT(captive_vfs_object); + + /* We do not buffer any data if not in sandboxed mode. */ + return GNOME_VFS_OK; +} + + +static GnomeVFSResult captive_vfs_slave_volume_info_get + (CaptiveVfsObject *captive_vfs_object,CaptiveVfsVolumeInfo *volume_info) +{ +CaptiveVfsSlaveObject *captive_vfs_slave_object; +FILE_FS_FULL_SIZE_INFORMATION FileFsFullSizeInformation_local; +NTSTATUS err; +IO_STATUS_BLOCK volume_IoStatusBlock; +GnomeVFSResult errvfsresult; +CaptiveDirectoryObject *captive_directory_object; + + g_return_val_if_fail(CAPTIVE_VFS_SLAVE_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(volume_info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_vfs_slave_object=CAPTIVE_VFS_SLAVE_OBJECT(captive_vfs_object); + + if (GNOME_VFS_OK!=(errvfsresult=captive_directory_new_open(&captive_directory_object,captive_vfs_object,"/"))) + return errvfsresult; + + err=NtQueryVolumeInformationFile( + CAPTIVE_DIRECTORY_SLAVE_OBJECT(captive_directory_object)->dir_Handle, /* FileHandle */ + &volume_IoStatusBlock, /* IoStatusBlock */ + &FileFsFullSizeInformation_local, /* FsInformation */ + sizeof(FileFsFullSizeInformation_local), /* Length */ + FileFsFullSizeInformation); /* FsInformationClass */ + if (NT_SUCCESS(err)!=NT_SUCCESS(volume_IoStatusBlock.Status)) { + g_assert_not_reached(); + goto err_unref_captive_directory_object; + } + if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) + goto err_unref_captive_directory_object; + + g_object_unref(captive_directory_object); + + volume_info->block_size=FileFsFullSizeInformation_local.BytesPerSector + *FileFsFullSizeInformation_local.SectorsPerAllocationUnit; + volume_info->bytes =FileFsFullSizeInformation_local.TotalAllocationUnits.QuadPart *volume_info->block_size; + volume_info->bytes_free =FileFsFullSizeInformation_local.ActualAvailableAllocationUnits.QuadPart*volume_info->block_size; + volume_info->bytes_available=FileFsFullSizeInformation_local.CallerAvailableAllocationUnits.QuadPart*volume_info->block_size; + + return GNOME_VFS_OK; + +err_unref_captive_directory_object: + g_object_unref(captive_directory_object); + return errvfsresult; +} diff --git a/src/libcaptive/client/vfs-slave.h b/src/libcaptive/client/vfs-slave.h new file mode 100644 index 0000000..45be1ec --- /dev/null +++ b/src/libcaptive/client/vfs-slave.h @@ -0,0 +1,46 @@ +/* $Id$ + * Include vfs for captive 'vfs' private interface to reactos of sandbox slave + * Copyright (C) 2003 Jan Kratochvil + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; exactly version 2 of June 1991 is required + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#ifndef _CAPTIVE_CLIENT_PRIV_VFS_SLAVE_H +#define _CAPTIVE_CLIENT_PRIV_VFS_SLAVE_H 1 + + +#include +#include +#include + + +G_BEGIN_DECLS + +#define CAPTIVE_VFS_SLAVE_TYPE_OBJECT (captive_vfs_slave_object_get_type()) +#define CAPTIVE_VFS_SLAVE_OBJECT(object) (G_TYPE_CHECK_INSTANCE_CAST((object),CAPTIVE_VFS_SLAVE_TYPE_OBJECT,CaptiveVfsSlaveObject)) +#define CAPTIVE_VFS_SLAVE_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),CAPTIVE_VFS_SLAVE_TYPE_OBJECT,CaptiveVfsSlaveObjectClass)) +#define CAPTIVE_VFS_SLAVE_IS_OBJECT(object) (G_TYPE_CHECK_INSTANCE_TYPE((object),CAPTIVE_VFS_SLAVE_TYPE_OBJECT)) +#define CAPTIVE_VFS_SLAVE_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),CAPTIVE_VFS_SLAVE_TYPE_OBJECT)) +#define CAPTIVE_VFS_SLAVE_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),CAPTIVE_VFS_SLAVE_TYPE_OBJECT,CaptiveVfsSlaveObjectClass)) +typedef struct _CaptiveVfsSlaveObject CaptiveVfsSlaveObject; +typedef struct _CaptiveVfsSlaveObjectClass CaptiveVfsSlaveObjectClass; + + +GType captive_vfs_slave_object_get_type(void); + +G_END_DECLS + + +#endif /* _CAPTIVE_CLIENT_PRIV_VFS_SLAVE_H */ diff --git a/src/libcaptive/client/vfs.c b/src/libcaptive/client/vfs.c index e668f97..b71d0a9 100644 --- a/src/libcaptive/client/vfs.c +++ b/src/libcaptive/client/vfs.c @@ -22,17 +22,10 @@ #include "captive/client-vfs.h" /* self */ #include "vfs.h" /* self-priv */ #include -#include "captive/macros.h" +#include "vfs-parent.h" +#include "vfs-slave.h" #include "init.h" -#include "captive/parent-Vfs.h" -#include "../sandbox/server-Vfs.h" /* for captive_corba_child_options */ #include "giochannel-blind.h" /* for captive_giochannel_setup() */ -#include "directory.h" -#include "reactos/ddk/iotypes.h" -#include "captive/client-directory.h" -#include "reactos/ntos/zw.h" /* for NtQueryVolumeInformationFile() */ -#include "result.h" -#include "init.h" static gpointer captive_vfs_object_parent_class=NULL; @@ -54,16 +47,14 @@ static void captive_vfs_object_class_init(CaptiveVfsObjectClass *class) { GObjectClass *gobject_class=G_OBJECT_CLASS(class); - captive_vfs_object_parent_class=g_type_class_ref(G_TYPE_OBJECT); + captive_vfs_object_parent_class=g_type_class_ref(g_type_parent(G_TYPE_FROM_CLASS(class))); gobject_class->finalize=(void (*)(GObject *object))captive_vfs_object_finalize; } static void captive_vfs_object_init(CaptiveVfsObject *captive_vfs_object) { - CAPTIVE_MEMZERO(&captive_vfs_object->options); - - captive_vfs_object->corba_parent_giochanel_blind=NULL; + captive_options_init(&captive_vfs_object->options); } @@ -85,7 +76,7 @@ static const GTypeInfo captive_vfs_object_info={ }; captive_vfs_object_type=g_type_register_static(G_TYPE_OBJECT, - "CaptiveVfsObject",&captive_vfs_object_info,0); + "CaptiveVfsObject",&captive_vfs_object_info,G_TYPE_FLAG_ABSTRACT); } return captive_vfs_object_type; @@ -96,7 +87,6 @@ GnomeVFSResult captive_vfs_new (CaptiveVfsObject **captive_vfs_object_return,const struct captive_options *options) { CaptiveVfsObject *captive_vfs_object; -gboolean errbool; g_return_val_if_fail(captive_vfs_object_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(options!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); @@ -106,9 +96,15 @@ gboolean errbool; *captive_vfs_object_return=NULL; - captive_vfs_object=g_object_new( - CAPTIVE_VFS_TYPE_OBJECT, /* object_type */ - NULL); /* first_property_name; FIXME: support properties */ + /* We are sandboxing && we are the master */ + if (options->sandbox && (options->sandbox_server_argv || options->sandbox_server_ior)) + captive_vfs_object=g_object_new( + CAPTIVE_VFS_PARENT_TYPE_OBJECT, /* object_type */ + NULL); /* first_property_name; FIXME: support properties */ + else + captive_vfs_object=g_object_new( + CAPTIVE_VFS_SLAVE_TYPE_OBJECT, /* object_type */ + NULL); /* first_property_name; FIXME: support properties */ captive_options_copy(&captive_vfs_object->options,options); @@ -117,34 +113,14 @@ gboolean errbool; *captive_vfs_object_return=captive_vfs_object; - /* We are sandboxing && we are the master */ - if (options->sandbox && (options->sandbox_server_argv || options->sandbox_server_ior)) - return captive_sandbox_parent_vfs_new(captive_vfs_object); - - g_assert(captive_options==NULL); - captive_options=&captive_vfs_object->options; - - errbool=captive_init(); - g_assert(errbool==TRUE); - - return GNOME_VFS_OK; + return (*CAPTIVE_VFS_OBJECT_GET_CLASS(captive_vfs_object)->init)(captive_vfs_object); } static GnomeVFSResult captive_vfs_close(CaptiveVfsObject *captive_vfs_object) { -gboolean errbool; - - g_return_val_if_fail(captive_vfs_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - if (captive_vfs_object->is_sandbox_parent) - return captive_sandbox_parent_vfs_close(captive_vfs_object); - - g_assert(captive_options==&captive_vfs_object->options); - errbool=captive_shutdown(); - g_assert(errbool==TRUE); - - captive_options=NULL; captive_options_free(&captive_vfs_object->options); return GNOME_VFS_OK; @@ -153,57 +129,16 @@ gboolean errbool; GnomeVFSResult captive_vfs_commit(CaptiveVfsObject *captive_vfs_object) { - g_return_val_if_fail(captive_vfs_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - - if (captive_vfs_object->is_sandbox_parent) - return captive_sandbox_parent_vfs_commit(captive_vfs_object); + g_return_val_if_fail(CAPTIVE_VFS_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - /* We do not buffer any data if not in sandboxed mode. */ - return GNOME_VFS_OK; + return (*CAPTIVE_VFS_OBJECT_GET_CLASS(captive_vfs_object)->commit)(captive_vfs_object); } GnomeVFSResult captive_vfs_volume_info_get(CaptiveVfsObject *captive_vfs_object,CaptiveVfsVolumeInfo *volume_info) { -FILE_FS_FULL_SIZE_INFORMATION FileFsFullSizeInformation_local; -NTSTATUS err; -IO_STATUS_BLOCK volume_IoStatusBlock; -GnomeVFSResult errvfsresult; -CaptiveDirectoryObject *captive_directory_object; - - g_return_val_if_fail(captive_vfs_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(volume_info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - if (captive_vfs_object->is_sandbox_parent) - return captive_sandbox_parent_vfs_volume_info_get(captive_vfs_object,volume_info); - - if (GNOME_VFS_OK!=(errvfsresult=captive_directory_new_open(&captive_directory_object,captive_vfs_object,"/"))) - return errvfsresult; - - err=NtQueryVolumeInformationFile( - captive_directory_object->dir_Handle, /* FileHandle */ - &volume_IoStatusBlock, /* IoStatusBlock */ - &FileFsFullSizeInformation_local, /* FsInformation */ - sizeof(FileFsFullSizeInformation_local), /* Length */ - FileFsFullSizeInformation); /* FsInformationClass */ - if (NT_SUCCESS(err)!=NT_SUCCESS(volume_IoStatusBlock.Status)) { - g_assert_not_reached(); - goto err_unref_captive_directory_object; - } - if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) - goto err_unref_captive_directory_object; - - g_object_unref(captive_directory_object); - - volume_info->block_size=FileFsFullSizeInformation_local.BytesPerSector - *FileFsFullSizeInformation_local.SectorsPerAllocationUnit; - volume_info->bytes =FileFsFullSizeInformation_local.TotalAllocationUnits.QuadPart *volume_info->block_size; - volume_info->bytes_free =FileFsFullSizeInformation_local.ActualAvailableAllocationUnits.QuadPart*volume_info->block_size; - volume_info->bytes_available=FileFsFullSizeInformation_local.CallerAvailableAllocationUnits.QuadPart*volume_info->block_size; - - return GNOME_VFS_OK; - -err_unref_captive_directory_object: - g_object_unref(captive_directory_object); - return errvfsresult; + return (*CAPTIVE_VFS_OBJECT_GET_CLASS(captive_vfs_object)->volume_info_get)(captive_vfs_object,volume_info); } diff --git a/src/libcaptive/client/vfs.h b/src/libcaptive/client/vfs.h index d6d44e1..a4efe4e 100644 --- a/src/libcaptive/client/vfs.h +++ b/src/libcaptive/client/vfs.h @@ -26,6 +26,10 @@ #include #include "../sandbox/sandbox.h" #include +#include "captive/options.h" +#include "captive/client-vfs.h" +#include "captive/client-directory.h" +#include "captive/client-file.h" G_BEGIN_DECLS @@ -35,27 +39,23 @@ struct _CaptiveVfsObject { /*< private >*/ struct captive_options options; - - gboolean is_sandbox_parent; - Captive_Vfs corba_Vfs_object; - Captive_GLogFunc corba_GLogFunc_object; - Captive_CaptiveIOChannel corba_CaptiveIOChannel_object; - /* It may corba_parent_giochanel_blind_source==options.image_iochannel ! - * 1st stage : corba_parent_giochanel_blind - * 2nd stage (optional): corba_parent_giochanel_blind_source - * 3rd stage : options.image_iochannel - */ - GIOChannel *corba_parent_giochanel_blind; - GIOChannel *corba_parent_giochanel_blind_source; - int corba_parentheart_fds_1; - pid_t corba_child_pid; - xmlDoc *corba_bug_doc; - xmlNode *corba_bug; - xmlNode *corba_bug_action; - xmlNode *corba_bug_log; }; struct _CaptiveVfsObjectClass { GObjectClass parent_class; + + GnomeVFSResult (*init)(CaptiveVfsObject *captive_vfs_object); + GnomeVFSResult (*commit)(CaptiveVfsObject *captive_vfs_object); + GnomeVFSResult (*volume_info_get)(CaptiveVfsObject *captive_vfs_object,CaptiveVfsVolumeInfo *volume_info); + + GnomeVFSResult (*directory_new_open)(CaptiveDirectoryObject **captive_directory_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname); + GnomeVFSResult (*directory_new_make)(CaptiveDirectoryObject **captive_directory_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname,guint perm); + + GnomeVFSResult (*file_new_open)(CaptiveFileObject **captive_file_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname,GnomeVFSOpenMode mode); + GnomeVFSResult (*file_new_create)(CaptiveFileObject **captive_file_object_return, + CaptiveVfsObject *captive_vfs_object,const gchar *pathname,GnomeVFSOpenMode mode,gboolean exclusive,guint perm); }; G_END_DECLS diff --git a/src/libcaptive/include/captive/Makefile.am b/src/libcaptive/include/captive/Makefile.am index 060b9c0..2cc9daa 100644 --- a/src/libcaptive/include/captive/Makefile.am +++ b/src/libcaptive/include/captive/Makefile.am @@ -34,9 +34,6 @@ pkginclude_HEADERS+= \ mm.h \ options-module.h \ options.h \ - parent-Directory.h \ - parent-File.h \ - parent-Vfs.h \ ps_reactos.h \ rtl-file.h \ signal.h \ diff --git a/src/libcaptive/sandbox/Makefile.am b/src/libcaptive/sandbox/Makefile.am index b61da48..c2bb7d8 100644 --- a/src/libcaptive/sandbox/Makefile.am +++ b/src/libcaptive/sandbox/Makefile.am @@ -33,8 +33,11 @@ libsandbox_la_SOURCES= \ client-CaptiveIOChannel.c \ client-CaptiveIOChannel.h \ parent-Directory.c \ + parent-Directory.h \ parent-File.c \ + parent-File.h \ parent-Vfs.c \ + parent-Vfs.h \ server-CaptiveIOChannel.c \ server-CaptiveIOChannel.h \ server-Directory.c \ diff --git a/src/libcaptive/sandbox/parent-Directory.c b/src/libcaptive/sandbox/parent-Directory.c index 189af3c..9a06079 100644 --- a/src/libcaptive/sandbox/parent-Directory.c +++ b/src/libcaptive/sandbox/parent-Directory.c @@ -19,7 +19,7 @@ #include "config.h" -#include "captive/parent-Directory.h" /* self */ +#include "parent-Directory.h" /* self */ #include #include "split.h" #include "sandbox.h" @@ -27,32 +27,35 @@ #include "../client/vfs.h" #include "FileInfo.h" #include "captive/macros.h" +#include "../client/vfs-parent.h" GnomeVFSResult captive_sandbox_parent_directory_new_open - (CaptiveDirectoryObject *captive_directory_object,const gchar *pathname) + (CaptiveDirectoryParentObject *captive_directory_parent_object,const gchar *pathname) { gboolean retried=FALSE; xmlNode *xml_action; +CaptiveVfsParentObject *captive_vfs_parent_object; - g_return_val_if_fail(captive_directory_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_DIRECTORY_PARENT_IS_OBJECT(captive_directory_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_directory_object->dir_Handle==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(CAPTIVE_DIRECTORY_OBJECT(captive_directory_parent_object)->vfs); retry: xml_action=NULL; - if (captive_directory_object->vfs->corba_bug_action) { - xml_action=xmlNewTextChild(captive_directory_object->vfs->corba_bug_action,NULL,"directory_new_open",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_directory_object)); + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"directory_new_open",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_directory_parent_object)); xmlNewProp(xml_action,"pathname",pathname); } - captive_directory_object->corba_Directory_object=Captive_Vfs_directory_new_open( - captive_directory_object->vfs->corba_Vfs_object,pathname,&captive_corba_ev); + captive_directory_parent_object->corba_Directory_object=Captive_Vfs_directory_new_open( + captive_vfs_parent_object->corba_Vfs_object,pathname,&captive_corba_ev); if (xml_action) xmlNewProp(xml_action,"result",(captive_corba_ev._major==CORBA_NO_EXCEPTION ? "1" : "0")); - if (!retried && captive_sandbox_parent_query_vfs_retry(&captive_corba_ev,captive_directory_object->vfs)) { + if (!retried && captive_sandbox_parent_query_vfs_retry(&captive_corba_ev,captive_vfs_parent_object)) { retried=TRUE; goto retry; } @@ -62,30 +65,32 @@ retry: GnomeVFSResult captive_sandbox_parent_directory_new_make - (CaptiveDirectoryObject *captive_directory_object,const gchar *pathname,guint perm) + (CaptiveDirectoryParentObject *captive_directory_parent_object,const gchar *pathname,guint perm) { gboolean retried=FALSE; xmlNode *xml_action; +CaptiveVfsParentObject *captive_vfs_parent_object; - g_return_val_if_fail(captive_directory_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_DIRECTORY_PARENT_IS_OBJECT(captive_directory_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_directory_object->dir_Handle==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(CAPTIVE_DIRECTORY_OBJECT(captive_directory_parent_object)->vfs); retry: xml_action=NULL; - if (captive_directory_object->vfs->corba_bug_action) { - xml_action=xmlNewTextChild(captive_directory_object->vfs->corba_bug_action,NULL,"directory_new_make",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_directory_object)); + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"directory_new_make",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_directory_parent_object)); xmlNewProp(xml_action,"pathname",pathname); xmlNewProp(xml_action,"perm",captive_printf_alloca("%u",(unsigned)perm)); } - captive_directory_object->corba_Directory_object=Captive_Vfs_directory_new_make( - captive_directory_object->vfs->corba_Vfs_object,pathname,perm,&captive_corba_ev); + captive_directory_parent_object->corba_Directory_object=Captive_Vfs_directory_new_make( + captive_vfs_parent_object->corba_Vfs_object,pathname,perm,&captive_corba_ev); if (xml_action) xmlNewProp(xml_action,"result",(captive_corba_ev._major==CORBA_NO_EXCEPTION ? "1" : "0")); - if (!retried && captive_sandbox_parent_query_vfs_retry(&captive_corba_ev,captive_directory_object->vfs)) { + if (!retried && captive_sandbox_parent_query_vfs_retry(&captive_corba_ev,captive_vfs_parent_object)) { retried=TRUE; goto retry; } @@ -94,62 +99,66 @@ retry: } -GnomeVFSResult captive_sandbox_parent_directory_close(CaptiveDirectoryObject *captive_directory_object) +GnomeVFSResult captive_sandbox_parent_directory_close(CaptiveDirectoryParentObject *captive_directory_parent_object) { GnomeVFSResult r; xmlNode *xml_action=NULL; +CaptiveVfsParentObject *captive_vfs_parent_object; + + g_return_val_if_fail(CAPTIVE_DIRECTORY_PARENT_IS_OBJECT(captive_directory_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_directory_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_directory_object->dir_Handle==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(CAPTIVE_DIRECTORY_OBJECT(captive_directory_parent_object)->vfs); - if (captive_directory_object->vfs->corba_bug_action) { - xml_action=xmlNewTextChild(captive_directory_object->vfs->corba_bug_action,NULL,"directory_close",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_directory_object)); + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"directory_close",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_directory_parent_object)); } - Captive_Directory_shutdown(captive_directory_object->corba_Directory_object,&captive_corba_ev); + Captive_Directory_shutdown(captive_directory_parent_object->corba_Directory_object,&captive_corba_ev); r=captive_sandbox_parent_return_from_CORBA_Environment(&captive_corba_ev); if (xml_action) xmlNewProp(xml_action,"result",gnome_vfs_result_to_string(r)); if (r!=GNOME_VFS_OK) return r; - CORBA_Object_release((CORBA_Object)captive_directory_object->corba_Directory_object,&captive_corba_ev); - captive_directory_object->corba_Directory_object=CORBA_OBJECT_NIL; + CORBA_Object_release((CORBA_Object)captive_directory_parent_object->corba_Directory_object,&captive_corba_ev); + captive_directory_parent_object->corba_Directory_object=CORBA_OBJECT_NIL; - if (captive_directory_object->corba_Directory_file_info_list) { -GList *file_info_last_l=g_list_last(captive_directory_object->corba_Directory_file_info_list); + if (captive_directory_parent_object->corba_Directory_file_info_list) { +GList *file_info_last_l=g_list_last(captive_directory_parent_object->corba_Directory_file_info_list); /* Prevent gnome_vfs_file_info_list_free() and its gnome_vfs_file_info_unref() * on the last 'file_info_list' items as it is EOF with NULL '->data'. */ g_assert(file_info_last_l->data==NULL); /* directory EOF */ - captive_directory_object->corba_Directory_file_info_list=g_list_delete_link( - captive_directory_object->corba_Directory_file_info_list,file_info_last_l); - gnome_vfs_file_info_list_free(captive_directory_object->corba_Directory_file_info_list); - captive_directory_object->corba_Directory_file_info_list=NULL; + captive_directory_parent_object->corba_Directory_file_info_list=g_list_delete_link( + captive_directory_parent_object->corba_Directory_file_info_list,file_info_last_l); + gnome_vfs_file_info_list_free(captive_directory_parent_object->corba_Directory_file_info_list); + captive_directory_parent_object->corba_Directory_file_info_list=NULL; } return captive_sandbox_parent_return_from_CORBA_Environment(&captive_corba_ev); } static GnomeVFSResult captive_sandbox_parent_directory_read_fill1 - (CaptiveDirectoryObject *captive_directory_object,GnomeVFSFileInfo *file_info_captive) + (CaptiveDirectoryParentObject *captive_directory_parent_object,GnomeVFSFileInfo *file_info_captive) { xmlNode *xml_action=NULL; Captive_GnomeVFSFileInfo *file_info_corba; GnomeVFSResult r; +CaptiveVfsParentObject *captive_vfs_parent_object; - g_return_val_if_fail(captive_directory_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_DIRECTORY_PARENT_IS_OBJECT(captive_directory_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(file_info_captive!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_directory_object->dir_Handle==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - if (captive_directory_object->vfs->corba_bug_action) { - xml_action=xmlNewTextChild(captive_directory_object->vfs->corba_bug_action,NULL,"directory_read",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_directory_object)); + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(CAPTIVE_DIRECTORY_OBJECT(captive_directory_parent_object)->vfs); + + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"directory_read",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_directory_parent_object)); } - Captive_Directory_read(captive_directory_object->corba_Directory_object,&file_info_corba,&captive_corba_ev); + Captive_Directory_read(captive_directory_parent_object->corba_Directory_object,&file_info_corba,&captive_corba_ev); r=captive_sandbox_parent_return_from_CORBA_Environment(&captive_corba_ev); if (xml_action) xmlNewProp(xml_action,"result",gnome_vfs_result_to_string(r)); @@ -168,36 +177,35 @@ GnomeVFSResult r; return GNOME_VFS_OK; } -static GnomeVFSResult captive_sandbox_parent_directory_read_filldir(CaptiveDirectoryObject *captive_directory_object) +static GnomeVFSResult captive_sandbox_parent_directory_read_filldir(CaptiveDirectoryParentObject *captive_directory_parent_object) { GnomeVFSFileInfo *file_info_captive; GnomeVFSResult r; - g_return_val_if_fail(captive_directory_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_directory_object->dir_Handle==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_directory_object->corba_Directory_file_info_list==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_DIRECTORY_PARENT_IS_OBJECT(captive_directory_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(captive_directory_parent_object->corba_Directory_file_info_list==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); for (;;) { file_info_captive=gnome_vfs_file_info_new(); - r=captive_sandbox_parent_directory_read_fill1(captive_directory_object,file_info_captive); + r=captive_sandbox_parent_directory_read_fill1(captive_directory_parent_object,file_info_captive); if (r==GNOME_VFS_ERROR_EOF) { gnome_vfs_file_info_unref(file_info_captive); break; } if (r!=GNOME_VFS_OK) { gnome_vfs_file_info_unref(file_info_captive); - gnome_vfs_file_info_list_free(captive_directory_object->corba_Directory_file_info_list); - captive_directory_object->corba_Directory_file_info_list=NULL; + gnome_vfs_file_info_list_free(captive_directory_parent_object->corba_Directory_file_info_list); + captive_directory_parent_object->corba_Directory_file_info_list=NULL; return r; } - captive_directory_object->corba_Directory_file_info_list=g_list_prepend( - captive_directory_object->corba_Directory_file_info_list,file_info_captive); + captive_directory_parent_object->corba_Directory_file_info_list=g_list_prepend( + captive_directory_parent_object->corba_Directory_file_info_list,file_info_captive); } - captive_directory_object->corba_Directory_file_info_list=g_list_prepend( - captive_directory_object->corba_Directory_file_info_list,NULL); /* EOF */ - captive_directory_object->corba_Directory_file_info_list=g_list_reverse( - captive_directory_object->corba_Directory_file_info_list); + captive_directory_parent_object->corba_Directory_file_info_list=g_list_prepend( + captive_directory_parent_object->corba_Directory_file_info_list,NULL); /* EOF */ + captive_directory_parent_object->corba_Directory_file_info_list=g_list_reverse( + captive_directory_parent_object->corba_Directory_file_info_list); return GNOME_VFS_OK; } @@ -206,20 +214,19 @@ GnomeVFSResult r; * as during valid child restart we would loose our reading position. */ GnomeVFSResult captive_sandbox_parent_directory_read - (CaptiveDirectoryObject *captive_directory_object,GnomeVFSFileInfo *file_info_captive) + (CaptiveDirectoryParentObject *captive_directory_parent_object,GnomeVFSFileInfo *file_info_captive) { GnomeVFSResult r; - g_return_val_if_fail(captive_directory_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_DIRECTORY_PARENT_IS_OBJECT(captive_directory_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(file_info_captive!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_directory_object->dir_Handle==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - if (!captive_directory_object->corba_Directory_file_info_list) - if (GNOME_VFS_OK!=(r=captive_sandbox_parent_directory_read_filldir(captive_directory_object))) + if (!captive_directory_parent_object->corba_Directory_file_info_list) + if (GNOME_VFS_OK!=(r=captive_sandbox_parent_directory_read_filldir(captive_directory_parent_object))) return r; - if (!captive_directory_object->corba_Directory_file_info_list->data) { - g_assert(captive_directory_object->corba_Directory_file_info_list->next==NULL); + if (!captive_directory_parent_object->corba_Directory_file_info_list->data) { + g_assert(captive_directory_parent_object->corba_Directory_file_info_list->next==NULL); /* Do not clear the list to leave us stuck at EOF - GnomeVFS behaves that way. */ r=GNOME_VFS_ERROR_EOF; } @@ -227,11 +234,11 @@ GnomeVFSResult r; /* Cut first list item. */ gnome_vfs_file_info_copy( file_info_captive, /* dest */ - captive_directory_object->corba_Directory_file_info_list->data); /* src */ - gnome_vfs_file_info_unref(captive_directory_object->corba_Directory_file_info_list->data); - captive_directory_object->corba_Directory_file_info_list=g_list_delete_link( - captive_directory_object->corba_Directory_file_info_list, - captive_directory_object->corba_Directory_file_info_list); + captive_directory_parent_object->corba_Directory_file_info_list->data); /* src */ + gnome_vfs_file_info_unref(captive_directory_parent_object->corba_Directory_file_info_list->data); + captive_directory_parent_object->corba_Directory_file_info_list=g_list_delete_link( + captive_directory_parent_object->corba_Directory_file_info_list, + captive_directory_parent_object->corba_Directory_file_info_list); r=GNOME_VFS_OK; } @@ -239,20 +246,22 @@ GnomeVFSResult r; } -GnomeVFSResult captive_sandbox_parent_directory_remove(CaptiveDirectoryObject *captive_directory_object) +GnomeVFSResult captive_sandbox_parent_directory_remove(CaptiveDirectoryParentObject *captive_directory_parent_object) { GnomeVFSResult r; xmlNode *xml_action=NULL; +CaptiveVfsParentObject *captive_vfs_parent_object; + + g_return_val_if_fail(CAPTIVE_DIRECTORY_PARENT_IS_OBJECT(captive_directory_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_directory_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_directory_object->dir_Handle==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(CAPTIVE_DIRECTORY_OBJECT(captive_directory_parent_object)->vfs); - if (captive_directory_object->vfs->corba_bug_action) { - xml_action=xmlNewTextChild(captive_directory_object->vfs->corba_bug_action,NULL,"directory_remove",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_directory_object)); + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"directory_remove",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_directory_parent_object)); } - Captive_Directory_remove(captive_directory_object->corba_Directory_object,&captive_corba_ev); + Captive_Directory_remove(captive_directory_parent_object->corba_Directory_object,&captive_corba_ev); r=captive_sandbox_parent_return_from_CORBA_Environment(&captive_corba_ev); if (xml_action) xmlNewProp(xml_action,"result",gnome_vfs_result_to_string(r)); diff --git a/src/libcaptive/include/captive/parent-Directory.h b/src/libcaptive/sandbox/parent-Directory.h similarity index 71% rename from src/libcaptive/include/captive/parent-Directory.h rename to src/libcaptive/sandbox/parent-Directory.h index 5458075..38e6e25 100644 --- a/src/libcaptive/include/captive/parent-Directory.h +++ b/src/libcaptive/sandbox/parent-Directory.h @@ -17,28 +17,28 @@ */ -#ifndef _CAPTIVE_CLIENT_PARENT_DIRECTORY_H -#define _CAPTIVE_CLIENT_PARENT_DIRECTORY_H 1 +#ifndef _PARENT_DIRECTORY_H +#define _PARENT_DIRECTORY_H 1 #include #include #include /* for GnomeVFSResult */ -#include "captive/client-directory.h" +#include "../client/directory-parent.h" G_BEGIN_DECLS GnomeVFSResult captive_sandbox_parent_directory_new_open - (CaptiveDirectoryObject *captive_directory_object,const gchar *pathname); + (CaptiveDirectoryParentObject *captive_directory_parent_object,const gchar *pathname); GnomeVFSResult captive_sandbox_parent_directory_new_make - (CaptiveDirectoryObject *captive_directory_object,const gchar *pathname,guint perm); -GnomeVFSResult captive_sandbox_parent_directory_close(CaptiveDirectoryObject *captive_directory_object); + (CaptiveDirectoryParentObject *captive_directory_parent_object,const gchar *pathname,guint perm); +GnomeVFSResult captive_sandbox_parent_directory_close(CaptiveDirectoryParentObject *captive_directory_parent_object); GnomeVFSResult captive_sandbox_parent_directory_read - (CaptiveDirectoryObject *captive_directory_object,GnomeVFSFileInfo *file_info_captive); -GnomeVFSResult captive_sandbox_parent_directory_remove(CaptiveDirectoryObject *captive_directory_object); + (CaptiveDirectoryParentObject *captive_directory_parent_object,GnomeVFSFileInfo *file_info_captive); +GnomeVFSResult captive_sandbox_parent_directory_remove(CaptiveDirectoryParentObject *captive_directory_parent_object); G_END_DECLS -#endif /* _CAPTIVE_CLIENT_PARENT_DIRECTORY_H */ +#endif /* _PARENT_DIRECTORY_H */ diff --git a/src/libcaptive/sandbox/parent-File.c b/src/libcaptive/sandbox/parent-File.c index b661116..971a8b7 100644 --- a/src/libcaptive/sandbox/parent-File.c +++ b/src/libcaptive/sandbox/parent-File.c @@ -19,7 +19,7 @@ #include "config.h" -#include "captive/parent-File.h" /* self */ +#include "parent-File.h" /* self */ #include #include "split.h" #include "sandbox.h" @@ -27,25 +27,29 @@ #include "../client/vfs.h" #include "FileInfo.h" #include "captive/macros.h" +#include "reactos/ntos/types.h" /* for ULONG */ -GnomeVFSResult captive_sandbox_parent_file_new_open(CaptiveFileObject *captive_file_object, +GnomeVFSResult captive_sandbox_parent_file_new_open(CaptiveFileParentObject *captive_file_parent_object, const gchar *pathname,GnomeVFSOpenMode mode) { xmlNode *xml_action=NULL; +CaptiveVfsParentObject *captive_vfs_parent_object; - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - if (captive_file_object->vfs->corba_bug_action) { - xml_action=xmlNewTextChild(captive_file_object->vfs->corba_bug_action,NULL,"file_new_open",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_object)); + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(CAPTIVE_FILE_OBJECT(captive_file_parent_object)->vfs); + + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"file_new_open",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_parent_object)); xmlNewProp(xml_action,"pathname",pathname); xmlNewProp(xml_action,"mode",captive_printf_alloca("%u",(unsigned)mode)); } - captive_file_object->corba_File_object=Captive_Vfs_file_new_open( - captive_file_object->vfs->corba_Vfs_object,pathname,mode,&captive_corba_ev); + captive_file_parent_object->corba_File_object=Captive_Vfs_file_new_open( + captive_vfs_parent_object->corba_Vfs_object,pathname,mode,&captive_corba_ev); if (xml_action) xmlNewProp(xml_action,"result",(captive_corba_ev._major==CORBA_NO_EXCEPTION ? "1" : "0")); @@ -53,25 +57,28 @@ xmlNode *xml_action=NULL; } -GnomeVFSResult captive_sandbox_parent_file_new_create(CaptiveFileObject *captive_file_object, +GnomeVFSResult captive_sandbox_parent_file_new_create(CaptiveFileParentObject *captive_file_parent_object, const gchar *pathname,GnomeVFSOpenMode mode,gboolean exclusive,guint perm) { xmlNode *xml_action=NULL; +CaptiveVfsParentObject *captive_vfs_parent_object; - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - if (captive_file_object->vfs->corba_bug_action) { - xml_action=xmlNewTextChild(captive_file_object->vfs->corba_bug_action,NULL,"file_new_create",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_object)); + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(CAPTIVE_FILE_OBJECT(captive_file_parent_object)->vfs); + + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"file_new_create",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_parent_object)); xmlNewProp(xml_action,"pathname",pathname); xmlNewProp(xml_action,"mode",captive_printf_alloca("%u",(unsigned)mode)); xmlNewProp(xml_action,"exclusive",captive_printf_alloca("%u",(unsigned)exclusive)); xmlNewProp(xml_action,"perm",captive_printf_alloca("%u",(unsigned)perm)); } - captive_file_object->corba_File_object=Captive_Vfs_file_new_create( - captive_file_object->vfs->corba_Vfs_object,pathname,mode,exclusive,perm,&captive_corba_ev); + captive_file_parent_object->corba_File_object=Captive_Vfs_file_new_create( + captive_vfs_parent_object->corba_Vfs_object,pathname,mode,exclusive,perm,&captive_corba_ev); if (xml_action) xmlNewProp(xml_action,"result",(captive_corba_ev._major==CORBA_NO_EXCEPTION ? "1" : "0")); @@ -79,55 +86,59 @@ xmlNode *xml_action=NULL; } -GnomeVFSResult captive_sandbox_parent_file_close(CaptiveFileObject *captive_file_object) +GnomeVFSResult captive_sandbox_parent_file_close(CaptiveFileParentObject *captive_file_parent_object) { GnomeVFSResult r; xmlNode *xml_action=NULL; +CaptiveVfsParentObject *captive_vfs_parent_object; + + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_file_object->file_Handle==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(CAPTIVE_FILE_OBJECT(captive_file_parent_object)->vfs); - if (captive_file_object->vfs->corba_bug_action) { - xml_action=xmlNewTextChild(captive_file_object->vfs->corba_bug_action,NULL,"file_close",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_object)); + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"file_close",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_parent_object)); } - Captive_File_shutdown(captive_file_object->corba_File_object,&captive_corba_ev); + Captive_File_shutdown(captive_file_parent_object->corba_File_object,&captive_corba_ev); r=captive_sandbox_parent_return_from_CORBA_Environment(&captive_corba_ev); if (xml_action) xmlNewProp(xml_action,"result",gnome_vfs_result_to_string(r)); if (r!=GNOME_VFS_OK) return r; - CORBA_Object_release((CORBA_Object)captive_file_object->corba_File_object,&captive_corba_ev); - captive_file_object->corba_File_object=CORBA_OBJECT_NIL; + CORBA_Object_release((CORBA_Object)captive_file_parent_object->corba_File_object,&captive_corba_ev); + captive_file_parent_object->corba_File_object=CORBA_OBJECT_NIL; return captive_sandbox_parent_return_from_CORBA_Environment(&captive_corba_ev); } -GnomeVFSResult captive_sandbox_parent_file_read(CaptiveFileObject *captive_file_object, +GnomeVFSResult captive_sandbox_parent_file_read(CaptiveFileParentObject *captive_file_parent_object, gpointer buffer_captive,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_read_return) { GnomeVFSResult r; Captive_Bytes *buffer_corba; xmlNode *xml_action=NULL; +CaptiveVfsParentObject *captive_vfs_parent_object; - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(buffer_captive!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(bytes_read_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(num_bytes==(ULONG)num_bytes,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_file_object->file_Handle==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(CAPTIVE_FILE_OBJECT(captive_file_parent_object)->vfs); *bytes_read_return=0; - if (captive_file_object->vfs->corba_bug_action) { - xml_action=xmlNewTextChild(captive_file_object->vfs->corba_bug_action,NULL,"file_read",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_object)); + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"file_read",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_parent_object)); xmlNewProp(xml_action,"num_bytes",captive_printf_alloca("%lu",(unsigned long)num_bytes)); } - Captive_File_read(captive_file_object->corba_File_object,&buffer_corba,num_bytes,&captive_corba_ev); + Captive_File_read(captive_file_parent_object->corba_File_object,&buffer_corba,num_bytes,&captive_corba_ev); r=captive_sandbox_parent_return_from_CORBA_Environment(&captive_corba_ev); if (xml_action) xmlNewProp(xml_action,"result",gnome_vfs_result_to_string(r)); @@ -148,25 +159,27 @@ xmlNode *xml_action=NULL; } -GnomeVFSResult captive_sandbox_parent_file_write(CaptiveFileObject *captive_file_object, +GnomeVFSResult captive_sandbox_parent_file_write(CaptiveFileParentObject *captive_file_parent_object, gconstpointer buffer_captive,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_written_return) { GnomeVFSResult r; Captive_Bytes buffer_corba_local; Captive_GnomeVFSFileSize bytes_written_corba; xmlNode *xml_action=NULL; +CaptiveVfsParentObject *captive_vfs_parent_object; - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(buffer_captive!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(bytes_written_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(num_bytes==(ULONG)num_bytes,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_file_object->file_Handle==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(CAPTIVE_FILE_OBJECT(captive_file_parent_object)->vfs); *bytes_written_return=0; - if (captive_file_object->vfs->corba_bug_action) { - xml_action=xmlNewTextChild(captive_file_object->vfs->corba_bug_action,NULL,"file_write",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_object)); + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"file_write",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_parent_object)); xmlNewProp(xml_action,"num_bytes",captive_printf_alloca("%lu",(unsigned long)num_bytes)); } @@ -175,7 +188,7 @@ xmlNode *xml_action=NULL; buffer_corba_local._buffer=(/* de-const */gpointer)buffer_captive; buffer_corba_local._release=FALSE; - Captive_File_write(captive_file_object->corba_File_object,&buffer_corba_local,&bytes_written_corba,&captive_corba_ev); + Captive_File_write(captive_file_parent_object->corba_File_object,&buffer_corba_local,&bytes_written_corba,&captive_corba_ev); r=captive_sandbox_parent_return_from_CORBA_Environment(&captive_corba_ev); if (xml_action) xmlNewProp(xml_action,"result",gnome_vfs_result_to_string(r)); @@ -192,17 +205,19 @@ xmlNode *xml_action=NULL; GnomeVFSResult captive_sandbox_parent_file_seek - (CaptiveFileObject *captive_file_object,GnomeVFSSeekPosition whence,GnomeVFSFileOffset offset) + (CaptiveFileParentObject *captive_file_parent_object,GnomeVFSSeekPosition whence,GnomeVFSFileOffset offset) { GnomeVFSResult r; xmlNode *xml_action=NULL; +CaptiveVfsParentObject *captive_vfs_parent_object; + + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_file_object->file_Handle==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(CAPTIVE_FILE_OBJECT(captive_file_parent_object)->vfs); - if (captive_file_object->vfs->corba_bug_action) { - xml_action=xmlNewTextChild(captive_file_object->vfs->corba_bug_action,NULL,"file_seek",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_object)); + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"file_seek",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_parent_object)); xmlNewProp(xml_action,"whence", (whence==GNOME_VFS_SEEK_START ? "start" : (whence==GNOME_VFS_SEEK_CURRENT ? "current" : @@ -210,7 +225,7 @@ xmlNode *xml_action=NULL; xmlNewProp(xml_action,"offset",captive_printf_alloca("%" G_GINT64_FORMAT,(gint64)offset)); } - Captive_File_seek(captive_file_object->corba_File_object,whence,offset,&captive_corba_ev); + Captive_File_seek(captive_file_parent_object->corba_File_object,whence,offset,&captive_corba_ev); r=captive_sandbox_parent_return_from_CORBA_Environment(&captive_corba_ev); if (xml_action) xmlNewProp(xml_action,"result",gnome_vfs_result_to_string(r)); @@ -221,22 +236,24 @@ xmlNode *xml_action=NULL; } -GnomeVFSResult captive_sandbox_parent_file_tell(CaptiveFileObject *captive_file_object,GnomeVFSFileOffset *offset_return) +GnomeVFSResult captive_sandbox_parent_file_tell(CaptiveFileParentObject *captive_file_parent_object,GnomeVFSFileOffset *offset_return) { Captive_GnomeVFSFileOffset offset_corba; GnomeVFSResult r; xmlNode *xml_action=NULL; +CaptiveVfsParentObject *captive_vfs_parent_object; - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(offset_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_file_object->file_Handle==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - if (captive_file_object->vfs->corba_bug_action) { - xml_action=xmlNewTextChild(captive_file_object->vfs->corba_bug_action,NULL,"file_tell",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_object)); + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(CAPTIVE_FILE_OBJECT(captive_file_parent_object)->vfs); + + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"file_tell",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_parent_object)); } - Captive_File_tell(captive_file_object->corba_File_object,&offset_corba,&captive_corba_ev); + Captive_File_tell(captive_file_parent_object->corba_File_object,&offset_corba,&captive_corba_ev); r=captive_sandbox_parent_return_from_CORBA_Environment(&captive_corba_ev); if (xml_action) xmlNewProp(xml_action,"result",gnome_vfs_result_to_string(r)); @@ -252,20 +269,22 @@ xmlNode *xml_action=NULL; } -GnomeVFSResult captive_sandbox_parent_file_remove(CaptiveFileObject *captive_file_object) +GnomeVFSResult captive_sandbox_parent_file_remove(CaptiveFileParentObject *captive_file_parent_object) { GnomeVFSResult r; xmlNode *xml_action=NULL; +CaptiveVfsParentObject *captive_vfs_parent_object; + + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_file_object->file_Handle==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(CAPTIVE_FILE_OBJECT(captive_file_parent_object)->vfs); - if (captive_file_object->vfs->corba_bug_action) { - xml_action=xmlNewTextChild(captive_file_object->vfs->corba_bug_action,NULL,"file_remove",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_object)); + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"file_remove",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_parent_object)); } - Captive_File_remove(captive_file_object->corba_File_object,&captive_corba_ev); + Captive_File_remove(captive_file_parent_object->corba_File_object,&captive_corba_ev); r=captive_sandbox_parent_return_from_CORBA_Environment(&captive_corba_ev); if (xml_action) xmlNewProp(xml_action,"result",gnome_vfs_result_to_string(r)); @@ -276,23 +295,25 @@ xmlNode *xml_action=NULL; } -GnomeVFSResult captive_sandbox_parent_file_file_info_get(CaptiveFileObject *captive_file_object, +GnomeVFSResult captive_sandbox_parent_file_file_info_get(CaptiveFileParentObject *captive_file_parent_object, GnomeVFSFileInfo *file_info_captive) { Captive_GnomeVFSFileInfo *file_info_corba; GnomeVFSResult r; xmlNode *xml_action=NULL; +CaptiveVfsParentObject *captive_vfs_parent_object; - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(file_info_captive!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_file_object->file_Handle==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - if (captive_file_object->vfs->corba_bug_action) { - xml_action=xmlNewTextChild(captive_file_object->vfs->corba_bug_action,NULL,"file_file_info_get",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_object)); + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(CAPTIVE_FILE_OBJECT(captive_file_parent_object)->vfs); + + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"file_file_info_get",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_parent_object)); } - Captive_File_file_info_get(captive_file_object->corba_File_object,&file_info_corba,&captive_corba_ev); + Captive_File_file_info_get(captive_file_parent_object->corba_File_object,&file_info_corba,&captive_corba_ev); r=captive_sandbox_parent_return_from_CORBA_Environment(&captive_corba_ev); if (xml_action) xmlNewProp(xml_action,"result",gnome_vfs_result_to_string(r)); @@ -311,27 +332,29 @@ xmlNode *xml_action=NULL; } -GnomeVFSResult captive_sandbox_parent_file_file_info_set(CaptiveFileObject *captive_file_object, +GnomeVFSResult captive_sandbox_parent_file_file_info_set(CaptiveFileParentObject *captive_file_parent_object, const GnomeVFSFileInfo *file_info_captive,GnomeVFSSetFileInfoMask mask) { Captive_GnomeVFSFileInfo file_info_corba; GnomeVFSResult r; xmlNode *xml_action=NULL; +CaptiveVfsParentObject *captive_vfs_parent_object; - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(file_info_captive!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_file_object->file_Handle==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - if (captive_file_object->vfs->corba_bug_action) { - xml_action=xmlNewTextChild(captive_file_object->vfs->corba_bug_action,NULL,"file_file_info_set",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_object)); + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(CAPTIVE_FILE_OBJECT(captive_file_parent_object)->vfs); + + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"file_file_info_set",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_parent_object)); xmlNewProp(xml_action,"mask",captive_printf_alloca("%u",(unsigned)mask)); } if (GNOME_VFS_OK!=(r=captive_sandbox_file_info_captive_to_corba(&file_info_corba,file_info_captive))) return r; - Captive_File_file_info_set(captive_file_object->corba_File_object,&file_info_corba,mask,&captive_corba_ev); + Captive_File_file_info_set(captive_file_parent_object->corba_File_object,&file_info_corba,mask,&captive_corba_ev); r=captive_sandbox_parent_return_from_CORBA_Environment(&captive_corba_ev); if (xml_action) xmlNewProp(xml_action,"result",gnome_vfs_result_to_string(r)); @@ -344,21 +367,23 @@ xmlNode *xml_action=NULL; } -GnomeVFSResult captive_sandbox_parent_file_truncate(CaptiveFileObject *captive_file_object,GnomeVFSFileSize file_size) +GnomeVFSResult captive_sandbox_parent_file_truncate(CaptiveFileParentObject *captive_file_parent_object,GnomeVFSFileSize file_size) { GnomeVFSResult r; xmlNode *xml_action=NULL; +CaptiveVfsParentObject *captive_vfs_parent_object; + + g_return_val_if_fail(CAPTIVE_FILE_PARENT_IS_OBJECT(captive_file_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_file_object->file_Handle==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(CAPTIVE_FILE_OBJECT(captive_file_parent_object)->vfs); - if (captive_file_object->vfs->corba_bug_action) { - xml_action=xmlNewTextChild(captive_file_object->vfs->corba_bug_action,NULL,"file_truncate",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_object)); + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"file_truncate",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_parent_object)); xmlNewProp(xml_action,"file_size",captive_printf_alloca("%" G_GUINT64_FORMAT,(guint64)file_size)); } - Captive_File_truncate(captive_file_object->corba_File_object,file_size,&captive_corba_ev); + Captive_File_truncate(captive_file_parent_object->corba_File_object,file_size,&captive_corba_ev); r=captive_sandbox_parent_return_from_CORBA_Environment(&captive_corba_ev); if (xml_action) xmlNewProp(xml_action,"result",gnome_vfs_result_to_string(r)); @@ -370,23 +395,25 @@ xmlNode *xml_action=NULL; GnomeVFSResult captive_sandbox_parent_file_move - (CaptiveFileObject *captive_file_object_old,const gchar *pathname_new,gboolean force_replace) + (CaptiveFileParentObject *captive_file_parent_object_old,const gchar *pathname_new,gboolean force_replace) { GnomeVFSResult r; xmlNode *xml_action=NULL; +CaptiveVfsParentObject *captive_vfs_parent_object; - g_return_val_if_fail(captive_file_object_old!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(captive_file_parent_object_old!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(pathname_new!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - g_return_val_if_fail(captive_file_object_old->file_Handle==NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); - if (captive_file_object_old->vfs->corba_bug_action) { - xml_action=xmlNewTextChild(captive_file_object_old->vfs->corba_bug_action,NULL,"file_truncate",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_object_old)); + captive_vfs_parent_object=CAPTIVE_VFS_PARENT_OBJECT(CAPTIVE_FILE_OBJECT(captive_file_parent_object_old)->vfs); + + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"file_truncate",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_file_parent_object_old)); xmlNewProp(xml_action,"pathname_new",pathname_new); xmlNewProp(xml_action,"force_replace",captive_printf_alloca("%u",(unsigned)force_replace)); } - Captive_File_move(captive_file_object_old->corba_File_object,pathname_new,force_replace,&captive_corba_ev); + Captive_File_move(captive_file_parent_object_old->corba_File_object,pathname_new,force_replace,&captive_corba_ev); r=captive_sandbox_parent_return_from_CORBA_Environment(&captive_corba_ev); if (xml_action) xmlNewProp(xml_action,"result",gnome_vfs_result_to_string(r)); diff --git a/src/libcaptive/include/captive/parent-File.h b/src/libcaptive/sandbox/parent-File.h similarity index 57% rename from src/libcaptive/include/captive/parent-File.h rename to src/libcaptive/sandbox/parent-File.h index a93c2e3..486e5be 100644 --- a/src/libcaptive/include/captive/parent-File.h +++ b/src/libcaptive/sandbox/parent-File.h @@ -17,40 +17,42 @@ */ -#ifndef _CAPTIVE_CLIENT_PARENT_FILE_H -#define _CAPTIVE_CLIENT_PARENT_FILE_H 1 +#ifndef _PARENT_FILE_H +#define _PARENT_FILE_H 1 #include #include #include /* for GnomeVFSResult */ -#include "captive/client-file.h" +#include "../client/file-parent.h" G_BEGIN_DECLS -GnomeVFSResult captive_sandbox_parent_file_new_open(CaptiveFileObject *captive_file_object, +GnomeVFSResult captive_sandbox_parent_file_new_open(CaptiveFileParentObject *captive_file_parent_object, const gchar *pathname,GnomeVFSOpenMode mode); -GnomeVFSResult captive_sandbox_parent_file_new_create(CaptiveFileObject *captive_file_object, +GnomeVFSResult captive_sandbox_parent_file_new_create(CaptiveFileParentObject *captive_file_parent_object, const gchar *pathname,GnomeVFSOpenMode mode,gboolean exclusive,guint perm); -GnomeVFSResult captive_sandbox_parent_file_close(CaptiveFileObject *captive_file_object); -GnomeVFSResult captive_sandbox_parent_file_read(CaptiveFileObject *captive_file_object, +GnomeVFSResult captive_sandbox_parent_file_close(CaptiveFileParentObject *captive_file_parent_object); +GnomeVFSResult captive_sandbox_parent_file_read(CaptiveFileParentObject *captive_file_parent_object, gpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_read_return); -GnomeVFSResult captive_sandbox_parent_file_write(CaptiveFileObject *captive_file_object, +GnomeVFSResult captive_sandbox_parent_file_write(CaptiveFileParentObject *captive_file_parent_object, gconstpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_written_return); GnomeVFSResult captive_sandbox_parent_file_seek - (CaptiveFileObject *captive_file_object,GnomeVFSSeekPosition whence,GnomeVFSFileOffset offset); -GnomeVFSResult captive_sandbox_parent_file_tell(CaptiveFileObject *captive_file_object,GnomeVFSFileOffset *offset_return); -GnomeVFSResult captive_sandbox_parent_file_remove(CaptiveFileObject *captive_file_object); -GnomeVFSResult captive_sandbox_parent_file_file_info_get(CaptiveFileObject *captive_file_object, + (CaptiveFileParentObject *captive_file_parent_object,GnomeVFSSeekPosition whence,GnomeVFSFileOffset offset); +GnomeVFSResult captive_sandbox_parent_file_tell + (CaptiveFileParentObject *captive_file_parent_object,GnomeVFSFileOffset *offset_return); +GnomeVFSResult captive_sandbox_parent_file_remove(CaptiveFileParentObject *captive_file_parent_object); +GnomeVFSResult captive_sandbox_parent_file_file_info_get(CaptiveFileParentObject *captive_file_parent_object, GnomeVFSFileInfo *file_info); -GnomeVFSResult captive_sandbox_parent_file_file_info_set(CaptiveFileObject *captive_file_object, +GnomeVFSResult captive_sandbox_parent_file_file_info_set(CaptiveFileParentObject *captive_file_parent_object, const GnomeVFSFileInfo *info,GnomeVFSSetFileInfoMask mask); -GnomeVFSResult captive_sandbox_parent_file_truncate(CaptiveFileObject *captive_file_object,GnomeVFSFileSize file_size); +GnomeVFSResult captive_sandbox_parent_file_truncate + (CaptiveFileParentObject *captive_file_parent_object,GnomeVFSFileSize file_size); GnomeVFSResult captive_sandbox_parent_file_move - (CaptiveFileObject *captive_file_object_old,const gchar *pathname_new,gboolean force_replace); + (CaptiveFileParentObject *captive_file_parent_object_old,const gchar *pathname_new,gboolean force_replace); G_END_DECLS -#endif /* _CAPTIVE_CLIENT_PARENT_FILE_H */ +#endif /* _PARENT_FILE_H */ diff --git a/src/libcaptive/sandbox/parent-Vfs.c b/src/libcaptive/sandbox/parent-Vfs.c index d3d265d..648b907 100644 --- a/src/libcaptive/sandbox/parent-Vfs.c +++ b/src/libcaptive/sandbox/parent-Vfs.c @@ -19,7 +19,7 @@ #include "config.h" -#include "captive/parent-Vfs.h" /* self */ +#include "parent-Vfs.h" /* self */ #include #include "split.h" #include "../client/vfs.h" @@ -36,41 +36,39 @@ #include "captive/macros.h" -static GnomeVFSResult captive_sandbox_parent_vfs_new_silent(CaptiveVfsObject *captive_vfs_object) +static GnomeVFSResult captive_sandbox_parent_vfs_new_silent(CaptiveVfsParentObject *captive_vfs_parent_object) { gboolean errbool; - g_return_val_if_fail(captive_vfs_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_PARENT_IS_OBJECT(captive_vfs_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - captive_vfs_object->is_sandbox_parent=TRUE; - - errbool=captive_sandbox_spawn(captive_vfs_object); + errbool=captive_sandbox_spawn(captive_vfs_parent_object); g_return_val_if_fail(errbool==TRUE,GNOME_VFS_ERROR_GENERIC); return GNOME_VFS_OK; } -GnomeVFSResult captive_sandbox_parent_vfs_new(CaptiveVfsObject *captive_vfs_object) +GnomeVFSResult captive_sandbox_parent_vfs_new(CaptiveVfsParentObject *captive_vfs_parent_object) { GnomeVFSResult r; - g_return_val_if_fail(captive_vfs_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_PARENT_IS_OBJECT(captive_vfs_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - r=captive_sandbox_parent_vfs_new_silent(captive_vfs_object); + r=captive_sandbox_parent_vfs_new_silent(captive_vfs_parent_object); - if (captive_vfs_object->corba_bug_action) { + if (captive_vfs_parent_object->corba_bug_action) { xmlNode *xml_action; - xml_action=xmlNewTextChild(captive_vfs_object->corba_bug_action,NULL,"vfs_new",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_vfs_object)); + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"vfs_new",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_vfs_parent_object)); } return r; } -static void bug_doc_generate(CaptiveVfsObject *captive_vfs_object) +static void bug_doc_generate(CaptiveVfsParentObject *captive_vfs_parent_object) { size_t out_fname_size; time_t time_t_local; @@ -79,21 +77,21 @@ int errint; xmlNode *xml_media; const gchar *xml_media_type; - g_return_if_fail(captive_vfs_object!=NULL); + g_return_if_fail(CAPTIVE_VFS_PARENT_IS_OBJECT(captive_vfs_parent_object)); - xml_media=captive_giochannel_blind_readreport_to_xml(captive_vfs_object->corba_bug,captive_vfs_object->corba_parent_giochanel_blind); - switch(captive_vfs_object->options.media) { + xml_media=captive_giochannel_blind_readreport_to_xml(captive_vfs_parent_object->corba_bug,captive_vfs_parent_object->corba_parent_giochanel_blind); + switch (CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.media) { case CAPTIVE_OPTION_MEDIA_CDROM: xml_media_type="cdrom"; break; case CAPTIVE_OPTION_MEDIA_DISK: xml_media_type="disk"; break; default: g_assert_not_reached(); } xmlNewProp(xml_media,"type",xml_media_type); - xmlSetDocCompressMode(captive_vfs_object->corba_bug_doc,9); + xmlSetDocCompressMode(captive_vfs_parent_object->corba_bug_doc,9); time(&time_t_local); - if (!(out_fname_size=strftime(out_fname,sizeof(out_fname),captive_vfs_object->options.bug_pathname, - localtime(&time_t_local)))) { + if (!(out_fname_size=strftime(out_fname,sizeof(out_fname), + CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.bug_pathname,localtime(&time_t_local)))) { g_assert_not_reached(); return; } @@ -101,13 +99,13 @@ const gchar *xml_media_type; /* xmlSaveFormatFileEnc() would be better to prevent rewriting * of target 'out_fname' but it does not support compression. */ - errint=xmlSaveFormatFileEnc(out_fname,captive_vfs_object->corba_bug_doc,"UTF-8", + errint=xmlSaveFormatFileEnc(out_fname,captive_vfs_parent_object->corba_bug_doc,"UTF-8", 1); /* format; ==output indenting; FIXME: Is it really indented? */ g_assert(errint!=-1); } -static GnomeVFSResult captive_sandbox_parent_vfs_close_silent(CaptiveVfsObject *captive_vfs_object) +static GnomeVFSResult captive_sandbox_parent_vfs_close_silent(CaptiveVfsParentObject *captive_vfs_parent_object) { GnomeVFSResult r; int errint; @@ -115,110 +113,110 @@ impl_POA_Captive_GLogFunc *GLogFunc_servant; impl_POA_Captive_CaptiveIOChannel *CaptiveIOChannel_servant; GIOStatus erriostatus; - g_return_val_if_fail(captive_vfs_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_PARENT_IS_OBJECT(captive_vfs_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - Captive_Vfs_shutdown(captive_vfs_object->corba_Vfs_object,&captive_corba_ev); + Captive_Vfs_shutdown(captive_vfs_parent_object->corba_Vfs_object,&captive_corba_ev); r=captive_sandbox_parent_return_from_CORBA_Environment(&captive_corba_ev); - CORBA_Object_release(captive_vfs_object->corba_Vfs_object,&captive_corba_ev); + CORBA_Object_release(captive_vfs_parent_object->corba_Vfs_object,&captive_corba_ev); g_assert(validate_CORBA_Environment(&captive_corba_ev)); /* Shutdown 'GLogFunc' servant. */ GLogFunc_servant=PortableServer_POA_reference_to_servant(captive_corba_poa, - captive_vfs_object->corba_GLogFunc_object,&captive_corba_ev); + captive_vfs_parent_object->corba_GLogFunc_object,&captive_corba_ev); g_assert(validate_CORBA_Environment(&captive_corba_ev)); - CORBA_Object_release(captive_vfs_object->corba_GLogFunc_object,&captive_corba_ev); + CORBA_Object_release(captive_vfs_parent_object->corba_GLogFunc_object,&captive_corba_ev); g_assert(validate_CORBA_Environment(&captive_corba_ev)); impl_Captive_GLogFunc__destroy(GLogFunc_servant,&captive_corba_ev); g_assert(validate_CORBA_Environment(&captive_corba_ev)); /* Shutdown 'CaptiveIOChannel' servant. */ CaptiveIOChannel_servant=PortableServer_POA_reference_to_servant(captive_corba_poa, - captive_vfs_object->corba_CaptiveIOChannel_object,&captive_corba_ev); + captive_vfs_parent_object->corba_CaptiveIOChannel_object,&captive_corba_ev); g_assert(validate_CORBA_Environment(&captive_corba_ev)); - CORBA_Object_release(captive_vfs_object->corba_CaptiveIOChannel_object,&captive_corba_ev); + CORBA_Object_release(captive_vfs_parent_object->corba_CaptiveIOChannel_object,&captive_corba_ev); g_assert(validate_CORBA_Environment(&captive_corba_ev)); impl_Captive_CaptiveIOChannel__destroy(CaptiveIOChannel_servant,&captive_corba_ev); g_assert(validate_CORBA_Environment(&captive_corba_ev)); /* Close parentheart_fd_write. */ - if (captive_vfs_object->corba_parentheart_fds_1!=-1) { - errint=close(captive_vfs_object->corba_parentheart_fds_1); + if (captive_vfs_parent_object->corba_parentheart_fds_1!=-1) { + errint=close(captive_vfs_parent_object->corba_parentheart_fds_1); g_return_val_if_fail(errint==0,FALSE); } /* Cleanup the child process. */ - if (captive_vfs_object->corba_child_pid!=(pid_t)-1) { - kill(captive_vfs_object->corba_child_pid,SIGKILL); /* errors ignored */ + if (captive_vfs_parent_object->corba_child_pid!=(pid_t)-1) { + kill(captive_vfs_parent_object->corba_child_pid,SIGKILL); /* errors ignored */ /* waitpid(2) errors are ignored as we should be immune against failures as the parent. */ - waitpid(captive_vfs_object->corba_child_pid, + waitpid(captive_vfs_parent_object->corba_child_pid, NULL, /* status */ WNOHANG); /* options */ } if (r==GNOME_VFS_OK) { - erriostatus=captive_giochannel_blind_commit(captive_vfs_object->corba_parent_giochanel_blind); + erriostatus=captive_giochannel_blind_commit(captive_vfs_parent_object->corba_parent_giochanel_blind); g_assert(erriostatus==G_IO_STATUS_NORMAL); } else { /* sandbox child failure */ /* Flush the channel to catch all the disk accesses to the bugreport. */ erriostatus=g_io_channel_flush( - captive_vfs_object->corba_parent_giochanel_blind, /* channel */ + captive_vfs_parent_object->corba_parent_giochanel_blind, /* channel */ NULL); /* error */ g_assert(erriostatus==G_IO_STATUS_NORMAL); /* Summarize the bugreport. */ - if (captive_vfs_object->corba_bug_doc) - bug_doc_generate(captive_vfs_object); + if (captive_vfs_parent_object->corba_bug_doc) + bug_doc_generate(captive_vfs_parent_object); } - g_io_channel_unref(captive_vfs_object->corba_parent_giochanel_blind); - captive_vfs_object->corba_parent_giochanel_blind=NULL; - - if (captive_vfs_object->corba_bug_doc) { - xmlFreeDoc(captive_vfs_object->corba_bug_doc); - captive_vfs_object->corba_bug_doc=NULL; - captive_vfs_object->corba_bug=NULL; - captive_vfs_object->corba_bug_action=NULL; - captive_vfs_object->corba_bug_log=NULL; + g_io_channel_unref(captive_vfs_parent_object->corba_parent_giochanel_blind); + captive_vfs_parent_object->corba_parent_giochanel_blind=NULL; + + if (captive_vfs_parent_object->corba_bug_doc) { + xmlFreeDoc(captive_vfs_parent_object->corba_bug_doc); + captive_vfs_parent_object->corba_bug_doc=NULL; + captive_vfs_parent_object->corba_bug=NULL; + captive_vfs_parent_object->corba_bug_action=NULL; + captive_vfs_parent_object->corba_bug_log=NULL; } return r; } -GnomeVFSResult captive_sandbox_parent_vfs_close(CaptiveVfsObject *captive_vfs_object) +GnomeVFSResult captive_sandbox_parent_vfs_close(CaptiveVfsParentObject *captive_vfs_parent_object) { - g_return_val_if_fail(captive_vfs_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_PARENT_IS_OBJECT(captive_vfs_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - if (captive_vfs_object->corba_bug_action) { + if (captive_vfs_parent_object->corba_bug_action) { xmlNode *xml_action; - xml_action=xmlNewTextChild(captive_vfs_object->corba_bug_action,NULL,"vfs_close",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_vfs_object)); + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"vfs_close",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_vfs_parent_object)); } - return captive_sandbox_parent_vfs_close_silent(captive_vfs_object); + return captive_sandbox_parent_vfs_close_silent(captive_vfs_parent_object); } -GnomeVFSResult captive_sandbox_parent_vfs_commit(CaptiveVfsObject *captive_vfs_object) +GnomeVFSResult captive_sandbox_parent_vfs_commit(CaptiveVfsParentObject *captive_vfs_parent_object) { GnomeVFSResult r_close,r_new; xmlNode *xml_action=NULL; - g_return_val_if_fail(captive_vfs_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_PARENT_IS_OBJECT(captive_vfs_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); - if (captive_vfs_object->corba_bug_action) { - xmlNewTextChild(captive_vfs_object->corba_bug_action,NULL,"vfs_commit",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_vfs_object)); + if (captive_vfs_parent_object->corba_bug_action) { + xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"vfs_commit",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_vfs_parent_object)); } - r_close=captive_sandbox_parent_vfs_close_silent(captive_vfs_object); /* errors ignored */ - r_new=captive_sandbox_parent_vfs_new_silent(captive_vfs_object); + r_close=captive_sandbox_parent_vfs_close_silent(captive_vfs_parent_object); /* errors ignored */ + r_new=captive_sandbox_parent_vfs_new_silent(captive_vfs_parent_object); - if (captive_vfs_object->corba_bug_action) { - xml_action=xmlNewTextChild(captive_vfs_object->corba_bug_action,NULL,"vfs_commit",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_vfs_object)); + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"vfs_commit",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_vfs_parent_object)); xmlNewProp(xml_action,"result_prev_close",gnome_vfs_result_to_string(r_close)); xmlNewProp(xml_action,"result",gnome_vfs_result_to_string(r_new)); } @@ -228,28 +226,28 @@ xmlNode *xml_action=NULL; GnomeVFSResult captive_sandbox_parent_vfs_volume_info_get - (CaptiveVfsObject *captive_vfs_object,CaptiveVfsVolumeInfo *volume_info_captive) + (CaptiveVfsParentObject *captive_vfs_parent_object,CaptiveVfsVolumeInfo *volume_info_captive) { xmlNode *xml_action; Captive_CaptiveVfsVolumeInfo volume_info_corba; GnomeVFSResult r; gboolean retried=FALSE; - g_return_val_if_fail(captive_vfs_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); + g_return_val_if_fail(CAPTIVE_VFS_PARENT_IS_OBJECT(captive_vfs_parent_object),GNOME_VFS_ERROR_BAD_PARAMETERS); g_return_val_if_fail(volume_info_captive!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS); retry: xml_action=NULL; - if (captive_vfs_object->corba_bug_action) { - xml_action=xmlNewTextChild(captive_vfs_object->corba_bug_action,NULL,"vfs_volume_info_get",NULL); - xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_vfs_object)); + if (captive_vfs_parent_object->corba_bug_action) { + xml_action=xmlNewTextChild(captive_vfs_parent_object->corba_bug_action,NULL,"vfs_volume_info_get",NULL); + xmlNewProp(xml_action,"object",captive_printf_alloca("%p",captive_vfs_parent_object)); } - Captive_Vfs_volume_info_get(captive_vfs_object->corba_Vfs_object,&volume_info_corba,&captive_corba_ev); + Captive_Vfs_volume_info_get(captive_vfs_parent_object->corba_Vfs_object,&volume_info_corba,&captive_corba_ev); if (xml_action) xmlNewProp(xml_action,"result",(captive_corba_ev._major==CORBA_NO_EXCEPTION ? "1" : "0")); - if (!retried && captive_sandbox_parent_query_vfs_retry(&captive_corba_ev,captive_vfs_object)) { + if (!retried && captive_sandbox_parent_query_vfs_retry(&captive_corba_ev,captive_vfs_parent_object)) { retried=TRUE; goto retry; } diff --git a/src/libcaptive/include/captive/parent-Vfs.h b/src/libcaptive/sandbox/parent-Vfs.h similarity index 67% rename from src/libcaptive/include/captive/parent-Vfs.h rename to src/libcaptive/sandbox/parent-Vfs.h index 8da04a8..58b61a0 100644 --- a/src/libcaptive/include/captive/parent-Vfs.h +++ b/src/libcaptive/sandbox/parent-Vfs.h @@ -17,25 +17,25 @@ */ -#ifndef _CAPTIVE_CLIENT_PARENT_VFS_H -#define _CAPTIVE_CLIENT_PARENT_VFS_H 1 +#ifndef _PARENT_VFS_H +#define _PARENT_VFS_H 1 #include #include #include /* for GnomeVFSResult */ -#include "captive/client-vfs.h" +#include "../client/vfs-parent.h" G_BEGIN_DECLS -GnomeVFSResult captive_sandbox_parent_vfs_new(CaptiveVfsObject *captive_vfs_object); -GnomeVFSResult captive_sandbox_parent_vfs_close(CaptiveVfsObject *captive_vfs_object); -GnomeVFSResult captive_sandbox_parent_vfs_commit(CaptiveVfsObject *captive_vfs_object); +GnomeVFSResult captive_sandbox_parent_vfs_new(CaptiveVfsParentObject *captive_vfs_parent_object); +GnomeVFSResult captive_sandbox_parent_vfs_close(CaptiveVfsParentObject *captive_vfs_parent_object); +GnomeVFSResult captive_sandbox_parent_vfs_commit(CaptiveVfsParentObject *captive_vfs_parent_object); GnomeVFSResult captive_sandbox_parent_vfs_volume_info_get - (CaptiveVfsObject *captive_vfs_object,CaptiveVfsVolumeInfo *volume_info_captive); + (CaptiveVfsParentObject *captive_vfs_parent_object,CaptiveVfsVolumeInfo *volume_info_captive); G_END_DECLS -#endif /* _CAPTIVE_CLIENT_PARENT_VFS_H */ +#endif /* _PARENT_VFS_H */ diff --git a/src/libcaptive/sandbox/server-Directory.c b/src/libcaptive/sandbox/server-Directory.c index f0f7ea4..f31ad24 100644 --- a/src/libcaptive/sandbox/server-Directory.c +++ b/src/libcaptive/sandbox/server-Directory.c @@ -26,6 +26,7 @@ #include "../client/directory.h" #include "FileInfo.h" #include "split.h" +#include "../client/vfs-slave.h" static void impl_Captive_Directory_fini(impl_POA_Captive_Directory *servant,CORBA_Environment *ev); @@ -99,7 +100,7 @@ Captive_Directory retval; impl_POA_Captive_Directory *retval_servant; GnomeVFSResult errvfsresult; - g_return_val_if_fail(servant->captive_vfs_object!=NULL,NULL); /* not yet initialized? */ + g_return_val_if_fail(CAPTIVE_VFS_SLAVE_IS_OBJECT(servant->captive_vfs_object),NULL); /* not yet initialized? */ retval=impl_Captive_Directory__create(servant->poa,ev); if (ev->_major!=CORBA_NO_EXCEPTION) @@ -127,7 +128,7 @@ Captive_Directory retval; impl_POA_Captive_Directory *retval_servant; GnomeVFSResult errvfsresult; - g_return_val_if_fail(servant->captive_vfs_object!=NULL,NULL); /* not yet initialized? */ + g_return_val_if_fail(CAPTIVE_VFS_SLAVE_IS_OBJECT(servant->captive_vfs_object),NULL); /* not yet initialized? */ retval=impl_Captive_Directory__create(servant->poa,ev); if (ev->_major!=CORBA_NO_EXCEPTION) diff --git a/src/libcaptive/sandbox/server-File.c b/src/libcaptive/sandbox/server-File.c index 93a3271..ae0ecc3 100644 --- a/src/libcaptive/sandbox/server-File.c +++ b/src/libcaptive/sandbox/server-File.c @@ -25,6 +25,7 @@ #include "captive/macros.h" #include "split.h" #include "FileInfo.h" +#include "../client/vfs-slave.h" static void impl_Captive_File_fini(impl_POA_Captive_File *servant,CORBA_Environment *ev); @@ -119,7 +120,7 @@ Captive_File retval; impl_POA_Captive_File *retval_servant; GnomeVFSResult errvfsresult; - g_return_val_if_fail(servant->captive_vfs_object!=NULL,NULL); /* not yet initialized? */ + g_return_val_if_fail(CAPTIVE_VFS_SLAVE_IS_OBJECT(servant->captive_vfs_object),NULL); /* not yet initialized? */ retval=impl_Captive_File__create(servant->poa,ev); if (ev->_major!=CORBA_NO_EXCEPTION) @@ -147,7 +148,7 @@ Captive_File retval; impl_POA_Captive_File *retval_servant; GnomeVFSResult errvfsresult; - g_return_val_if_fail(servant->captive_vfs_object!=NULL,NULL); /* not yet initialized? */ + g_return_val_if_fail(CAPTIVE_VFS_SLAVE_IS_OBJECT(servant->captive_vfs_object),NULL); /* not yet initialized? */ retval=impl_Captive_File__create(servant->poa,ev); if (ev->_major!=CORBA_NO_EXCEPTION) diff --git a/src/libcaptive/sandbox/server-GLogFunc.c b/src/libcaptive/sandbox/server-GLogFunc.c index e03c219..fc75aee 100644 --- a/src/libcaptive/sandbox/server-GLogFunc.c +++ b/src/libcaptive/sandbox/server-GLogFunc.c @@ -25,7 +25,7 @@ #include #include "captive/macros.h" #include -#include "../client/vfs.h" +#include "../client/vfs-parent.h" static void impl_Captive_GLogFunc_g_log_func @@ -47,7 +47,7 @@ static POA_Captive_GLogFunc__vepv impl_Captive_GLogFunc_vepv={ Captive_GLogFunc impl_Captive_GLogFunc__create - (PortableServer_POA poa,CaptiveVfsObject *captive_vfs_object,CORBA_Environment *ev) + (PortableServer_POA poa,CaptiveVfsParentObject *captive_vfs_parent_object,CORBA_Environment *ev) { Captive_GLogFunc retval; impl_POA_Captive_GLogFunc *newservant; @@ -56,7 +56,7 @@ PortableServer_ObjectId *objid; captive_new0(newservant); /* FIXME: leak */ newservant->servant.vepv=&impl_Captive_GLogFunc_vepv; newservant->poa=poa; - newservant->captive_vfs_object=captive_vfs_object; + newservant->captive_vfs_parent_object=captive_vfs_parent_object; POA_Captive_GLogFunc__init((PortableServer_Servant)newservant,ev); objid=PortableServer_POA_activate_object(poa,newservant,ev); CORBA_free(objid); @@ -111,8 +111,8 @@ const struct flag_map *flagp; { xmlNode *xml_message=NULL; - if (servant->captive_vfs_object->corba_bug_log) { - xml_message=xmlNewTextChild(servant->captive_vfs_object->corba_bug_log,NULL,"message",g_log_message->message); + if (servant->captive_vfs_parent_object->corba_bug_log) { + xml_message=xmlNewTextChild(servant->captive_vfs_parent_object->corba_bug_log,NULL,"message",g_log_message->message); xmlNewProp(xml_message,"level",levelp->name); } diff --git a/src/libcaptive/sandbox/server-GLogFunc.h b/src/libcaptive/sandbox/server-GLogFunc.h index be913d6..be47472 100644 --- a/src/libcaptive/sandbox/server-GLogFunc.h +++ b/src/libcaptive/sandbox/server-GLogFunc.h @@ -24,6 +24,7 @@ #include #include "sandbox.h" #include "server-Vfs.h" /* for impl_POA_Captive_Vfs */ +#include "../client/vfs-parent.h" G_BEGIN_DECLS @@ -31,13 +32,13 @@ G_BEGIN_DECLS typedef struct { POA_Captive_GLogFunc servant; PortableServer_POA poa; - CaptiveVfsObject *captive_vfs_object; + CaptiveVfsParentObject *captive_vfs_parent_object; } impl_POA_Captive_GLogFunc; void impl_Captive_Vfs_init_g_log_func(const Captive_GLogFunc g_log_func,gboolean debug_messages,CORBA_Environment *ev); Captive_GLogFunc impl_Captive_GLogFunc__create - (PortableServer_POA poa,CaptiveVfsObject *captive_vfs_object,CORBA_Environment *ev); + (PortableServer_POA poa,CaptiveVfsParentObject *captive_vfs_parent_object,CORBA_Environment *ev); void impl_Captive_GLogFunc__destroy(impl_POA_Captive_GLogFunc *servant,CORBA_Environment *ev); void impl_Captive_Vfs_init_g_log_func_disable(void); diff --git a/src/libcaptive/sandbox/server-Vfs.c b/src/libcaptive/sandbox/server-Vfs.c index 2f28a85..7f4048f 100644 --- a/src/libcaptive/sandbox/server-Vfs.c +++ b/src/libcaptive/sandbox/server-Vfs.c @@ -28,6 +28,7 @@ #include "split.h" #include "server-GLogFunc.h" #include "client-CaptiveIOChannel.h" +#include "../client/vfs-slave.h" static void impl_Captive_Vfs_fini(impl_POA_Captive_Vfs *servant,CORBA_Environment *ev); @@ -162,7 +163,7 @@ struct captive_options_module *options_module; captive_options_free(&options_captive); - g_assert(servant->captive_vfs_object!=NULL); + g_assert(CAPTIVE_VFS_SLAVE_IS_OBJECT(servant->captive_vfs_object)); } diff --git a/src/libcaptive/sandbox/split.c b/src/libcaptive/sandbox/split.c index 780ca64..772f7d6 100644 --- a/src/libcaptive/sandbox/split.c +++ b/src/libcaptive/sandbox/split.c @@ -32,7 +32,7 @@ #include "server-Directory.h" #include "server-Vfs.h" #include "../client/vfs.h" -#include "captive/parent-Vfs.h" +#include "parent-Vfs.h" #include #include "server-CaptiveIOChannel.h" #include @@ -541,25 +541,25 @@ static xmlNode *options_module_captive_to_xml } -static void sandbox_parent_bug_doc_make(CaptiveVfsObject *captive_vfs_object) +static void sandbox_parent_bug_doc_make(CaptiveVfsParentObject *captive_vfs_parent_object) { { xmlDoc *doc=xmlNewDoc("1.0"); - captive_vfs_object->corba_bug_doc=doc; - { xmlNode *bug=xmlNewDocNode(captive_vfs_object->corba_bug_doc,NULL,"bug",NULL); - xmlDocSetRootElement(captive_vfs_object->corba_bug_doc,bug); - captive_vfs_object->corba_bug=bug; + captive_vfs_parent_object->corba_bug_doc=doc; + { xmlNode *bug=xmlNewDocNode(captive_vfs_parent_object->corba_bug_doc,NULL,"bug",NULL); + xmlDocSetRootElement(captive_vfs_parent_object->corba_bug_doc,bug); + captive_vfs_parent_object->corba_bug=bug; { xmlNode *bug_captive=xmlNewTextChild(bug,NULL,"captive",NULL); xmlNewProp(bug_captive,"version",VERSION); } { xmlNode *bug_filesystem=xmlNewTextChild(bug,NULL,"filesystem",NULL); - options_module_captive_to_xml(bug_filesystem,&captive_vfs_object->options.filesystem); + options_module_captive_to_xml(bug_filesystem,&CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.filesystem); } { xmlNode *bug_load_module=xmlNewTextChild(bug,NULL,"load_module",NULL); guint load_moduleui; struct captive_options_module *options_module; GList *load_module_node; - for (load_moduleui=0,load_module_node=captive_vfs_object->options.load_module; + for (load_moduleui=0,load_module_node=CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.load_module; load_module_node; load_moduleui++,load_module_node=load_module_node->next) { options_module=load_module_node->data; @@ -567,17 +567,17 @@ static void sandbox_parent_bug_doc_make(CaptiveVfsObject *captive_vfs_object) } } { xmlNode *bug_action=xmlNewTextChild(bug,NULL,"action",NULL); - captive_vfs_object->corba_bug_action=bug_action; + captive_vfs_parent_object->corba_bug_action=bug_action; } { xmlNode *bug_log=xmlNewTextChild(bug,NULL,"log",NULL); - captive_vfs_object->corba_bug_log=bug_log; + captive_vfs_parent_object->corba_bug_log=bug_log; } } } } -static void sandbox_parent(const gchar *Vfs_IOR,const gchar *child_chroot_pid_hashkey_dir,CaptiveVfsObject *captive_vfs_object) +static void sandbox_parent(const gchar *Vfs_IOR,const gchar *child_chroot_pid_hashkey_dir,CaptiveVfsParentObject *captive_vfs_parent_object) { Captive_Vfs Vfs_object; Captive_GLogFunc GLogFunc_object; @@ -591,35 +591,35 @@ int errint; g_return_if_fail(Vfs_IOR!=NULL); /* 'child_chroot_pid_hashkey_dir' may be NULL */ - g_return_if_fail(captive_vfs_object!=NULL); + g_return_if_fail(CAPTIVE_VFS_PARENT_IS_OBJECT(captive_vfs_parent_object)); Vfs_object=CORBA_ORB_string_to_object(captive_corba_orb,Vfs_IOR,&captive_corba_ev); g_assert(validate_CORBA_Environment(&captive_corba_ev)); /* Init 'GLogFunc_object' */ - GLogFunc_object=impl_Captive_GLogFunc__create(captive_corba_poa,captive_vfs_object,&captive_corba_ev); + GLogFunc_object=impl_Captive_GLogFunc__create(captive_corba_poa,captive_vfs_parent_object,&captive_corba_ev); g_assert(validate_CORBA_Environment(&captive_corba_ev)); /* Init 'CaptiveIOChannel_object' */ - if (!captive_vfs_object->corba_parent_giochanel_blind_source) - switch (captive_vfs_object->options.rwmode) { + if (!captive_vfs_parent_object->corba_parent_giochanel_blind_source) + switch (CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.rwmode) { case CAPTIVE_OPTION_RWMODE_RO: case CAPTIVE_OPTION_RWMODE_RW: - captive_vfs_object->corba_parent_giochanel_blind_source=captive_vfs_object->options.image_iochannel; + captive_vfs_parent_object->corba_parent_giochanel_blind_source=CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.image_iochannel; break; case CAPTIVE_OPTION_RWMODE_BLIND: - captive_vfs_object->corba_parent_giochanel_blind_source=(GIOChannel *)captive_giochannel_blind_new( - captive_vfs_object->options.image_iochannel, /* giochannel_orig */ + captive_vfs_parent_object->corba_parent_giochanel_blind_source=(GIOChannel *)captive_giochannel_blind_new( + CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.image_iochannel, /* giochannel_orig */ TRUE); /* writeable */ break; default: g_assert_not_reached(); } - if (!captive_vfs_object->corba_parent_giochanel_blind) - captive_vfs_object->corba_parent_giochanel_blind=(GIOChannel *)captive_giochannel_blind_new( - captive_vfs_object->corba_parent_giochanel_blind_source, /* giochannel_orig */ - (captive_vfs_object->options.rwmode!=CAPTIVE_OPTION_RWMODE_RO)); /* writeable */ + if (!captive_vfs_parent_object->corba_parent_giochanel_blind) + captive_vfs_parent_object->corba_parent_giochanel_blind=(GIOChannel *)captive_giochannel_blind_new( + captive_vfs_parent_object->corba_parent_giochanel_blind_source, /* giochannel_orig */ + (CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.rwmode!=CAPTIVE_OPTION_RWMODE_RO)); /* writeable */ CaptiveIOChannel_object=impl_Captive_CaptiveIOChannel__create(captive_corba_poa, - captive_vfs_object->corba_parent_giochanel_blind,&captive_corba_ev); + captive_vfs_parent_object->corba_parent_giochanel_blind,&captive_corba_ev); g_assert(validate_CORBA_Environment(&captive_corba_ev)); /* Create the socket needed for 'sandbox_parent_own_orbit_socket' below @@ -666,22 +666,22 @@ struct dirent *dirent; } options_corba.g_log_func=GLogFunc_object; - options_module_captive_to_options_module_corba(&options_corba.filesystem,&captive_vfs_object->options.filesystem); + options_module_captive_to_options_module_corba(&options_corba.filesystem,&CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.filesystem); /* Prevent secondary captive_giochannel_blind inside of our sandbox child * as we already have one captive_giochannel_blind in the parent. */ - options_corba.rwmode =(captive_vfs_object->options.rwmode == CAPTIVE_OPTION_RWMODE_BLIND ? CAPTIVE_OPTION_RWMODE_RW - : captive_vfs_object->options.rwmode); - options_corba.media =captive_vfs_object->options.media; - options_corba.debug_messages=captive_vfs_object->options.debug_messages; + options_corba.rwmode =(CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.rwmode == CAPTIVE_OPTION_RWMODE_BLIND ? CAPTIVE_OPTION_RWMODE_RW + : CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.rwmode); + options_corba.media =CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.media; + options_corba.debug_messages=CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.debug_messages; options_corba.image_iochannel=CaptiveIOChannel_object; - load_module_length=g_list_length(captive_vfs_object->options.load_module); + load_module_length=g_list_length(CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.load_module); captive_newn(options_corba.load_module._buffer,load_module_length); options_corba.load_module._maximum=load_module_length; options_corba.load_module._length=load_module_length; options_corba.load_module._release=TRUE; - for (load_moduleui=0,load_module_node=captive_vfs_object->options.load_module; + for (load_moduleui=0,load_module_node=CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.load_module; load_module_node; load_moduleui++,load_module_node=load_module_node->next) { options_module=load_module_node->data; @@ -693,12 +693,12 @@ struct dirent *dirent; /* FIXME: Free 'options_corba' - LEAK */ - captive_vfs_object->corba_Vfs_object=Vfs_object; - captive_vfs_object->corba_GLogFunc_object=GLogFunc_object; - captive_vfs_object->corba_CaptiveIOChannel_object=CaptiveIOChannel_object; + captive_vfs_parent_object->corba_Vfs_object=Vfs_object; + captive_vfs_parent_object->corba_GLogFunc_object=GLogFunc_object; + captive_vfs_parent_object->corba_CaptiveIOChannel_object=CaptiveIOChannel_object; - if (captive_vfs_object->options.bug_pathname) - sandbox_parent_bug_doc_make(captive_vfs_object); + if (CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.bug_pathname) + sandbox_parent_bug_doc_make(captive_vfs_parent_object); } static void fd_shiftup(int *fdp) @@ -750,7 +750,7 @@ char *endptr; close(dir_fd); g_assert(errno==EBADF); /* just a bit of paranoia; it should be already closed by closedir() */ } -gboolean captive_sandbox_spawn(CaptiveVfsObject *captive_vfs_object) +gboolean captive_sandbox_spawn(CaptiveVfsParentObject *captive_vfs_parent_object) { /* Vfs_IOR_fds[0] for reading by sandbox_parent() - client, * Vfs_IOR_fds[1] for writing by sandbox_child() - server @@ -759,7 +759,7 @@ int Vfs_IOR_fds[2],parentheart_fds[2]; int errint; gboolean errbool; - g_return_val_if_fail(captive_vfs_object!=NULL,FALSE); + g_return_val_if_fail(CAPTIVE_VFS_PARENT_IS_OBJECT(captive_vfs_parent_object),FALSE); errint=pipe(Vfs_IOR_fds); g_return_val_if_fail(errint==0,FALSE); @@ -771,23 +771,23 @@ gboolean errbool; * g_assert(errbool==TRUE); */ - if (captive_vfs_object->options.sandbox_server_ior) { - g_assert(captive_vfs_object->options.sandbox_server_argv==NULL); + if (CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.sandbox_server_ior) { + g_assert(CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.sandbox_server_argv==NULL); errbool=corba_init("captive-sandbox-parent",&captive_corba_ev,&captive_corba_orb,&captive_corba_poa); g_assert(errbool==TRUE); - captive_vfs_object->corba_parentheart_fds_1=-1; - captive_vfs_object->corba_child_pid=-1; + captive_vfs_parent_object->corba_parentheart_fds_1=-1; + captive_vfs_parent_object->corba_child_pid=-1; sandbox_parent( - captive_vfs_object->options.sandbox_server_ior, /* Vfs_IOR */ + CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.sandbox_server_ior, /* Vfs_IOR */ NULL, /* child_chroot_pid_hashkey_dir */ - captive_vfs_object); /* captive_vfs_object */ + captive_vfs_parent_object); /* captive_vfs_parent_object */ return TRUE; } - g_assert(captive_vfs_object->options.sandbox_server_argv!=NULL); - switch ((captive_vfs_object->corba_child_pid=fork())) { + g_assert(CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.sandbox_server_argv!=NULL); + switch ((captive_vfs_parent_object->corba_child_pid=fork())) { case -1: /* error */ g_return_val_if_reached(FALSE); @@ -807,8 +807,8 @@ gboolean errbool; captive_sandbox_fd_closeup(2 /* STDERR */ +1); - execv(captive_vfs_object->options.sandbox_server_argv[0], - /* re-const */ (char * const *)captive_vfs_object->options.sandbox_server_argv); + execv(CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.sandbox_server_argv[0], + /* re-const */ (char * const *)CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.sandbox_server_argv); g_return_val_if_reached(FALSE); } /* NOTREACHED */ @@ -827,7 +827,7 @@ gchar *child_chroot_pid_hashkey_dir; * Currently I am not aware such case would occur. */ g_return_val_if_fail(errint==0,FALSE); - captive_vfs_object->corba_parentheart_fds_1=parentheart_fds[1]; + captive_vfs_parent_object->corba_parentheart_fds_1=parentheart_fds[1]; Vfs_IOR=sandbox_parent_read_ior( Vfs_IOR_fds[0], /* Vfs_IOR_fd_read */ @@ -836,7 +836,7 @@ gchar *child_chroot_pid_hashkey_dir; sandbox_parent( Vfs_IOR, /* Vfs_IOR */ child_chroot_pid_hashkey_dir, /* child_chroot_pid_hashkey_dir */ - captive_vfs_object); /* captive_vfs_object */ + captive_vfs_parent_object); /* captive_vfs_parent_object */ g_free(Vfs_IOR); g_free(child_chroot_pid_hashkey_dir); @@ -870,26 +870,26 @@ GnomeVFSResult r; } -gboolean captive_sandbox_parent_query_vfs_retry(CORBA_Environment *evp,CaptiveVfsObject *captive_vfs_object) +gboolean captive_sandbox_parent_query_vfs_retry(CORBA_Environment *evp,CaptiveVfsParentObject *captive_vfs_parent_object) { GnomeVFSResult errvfsresult; gboolean want_retry; g_return_val_if_fail(evp!=NULL,FALSE); - g_return_val_if_fail(captive_vfs_object!=NULL,FALSE); + g_return_val_if_fail(CAPTIVE_VFS_PARENT_IS_OBJECT(captive_vfs_parent_object),FALSE); - /* If !captive_vfs_object->options.sandbox_server_argv it is captive_vfs_object->options.sandbox_server_ior + /* If !CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.sandbox_server_argv it is CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.sandbox_server_ior * where we cannot do any restart anyway. */ - want_retry=(captive_vfs_object->options.sandbox_server_argv + want_retry=(CAPTIVE_VFS_OBJECT(captive_vfs_parent_object)->options.sandbox_server_argv && (evp->_major==CORBA_SYSTEM_EXCEPTION && !strcmp(ex_CORBA_COMM_FAILURE,CORBA_exception_id(evp)))); /* Never free 'evp' if returning as no-retry - 'evp' will be reevaluated by the caller! */ if (!want_retry) return FALSE; /* no retry */ CORBA_exception_free(evp); - captive_sandbox_parent_vfs_close(captive_vfs_object); /* errors ignored */ - errvfsresult=captive_sandbox_parent_vfs_new(captive_vfs_object); + captive_sandbox_parent_vfs_close(captive_vfs_parent_object); /* errors ignored */ + errvfsresult=captive_sandbox_parent_vfs_new(captive_vfs_parent_object); return errvfsresult==GNOME_VFS_OK; /* retry if restart succeeded */ } diff --git a/src/libcaptive/sandbox/split.h b/src/libcaptive/sandbox/split.h index 172b47d..dd46858 100644 --- a/src/libcaptive/sandbox/split.h +++ b/src/libcaptive/sandbox/split.h @@ -25,6 +25,7 @@ #ifdef ORBIT2 /* Prevent missing $(ORBIT_CFLAGS) outside of libcaptive/sandbox/ */ #include "sandbox.h" #include "captive/client-vfs.h" +#include "../client/vfs-parent.h" #endif @@ -41,11 +42,11 @@ void sandbox_child_prepare_shutdown(void); void captive_sandbox_fd_closeup(int fd_first_to_delete); void sandbox_child_shutdown(void); #ifdef ORBIT2 /* Prevent missing $(ORBIT_CFLAGS) outside of libcaptive/sandbox/ */ -gboolean captive_sandbox_spawn(CaptiveVfsObject *captive_vfs_object); +gboolean captive_sandbox_spawn(CaptiveVfsParentObject *captive_vfs_parent_object); gboolean validate_CORBA_Environment(CORBA_Environment *evp); GnomeVFSResult captive_sandbox_parent_return_from_CORBA_Environment(CORBA_Environment *evp); void captive_sandbox_child_GnomeVFSResultException_throw(CORBA_Environment *evp,GnomeVFSResult errvfsresult); -gboolean captive_sandbox_parent_query_vfs_retry(CORBA_Environment *evp,CaptiveVfsObject *captive_vfs_object); +gboolean captive_sandbox_parent_query_vfs_retry(CORBA_Environment *evp,CaptiveVfsParentObject *captive_vfs_parent_object); #endif G_END_DECLS -- 1.8.3.1