src/libcaptive/client/file-slave.c

   1 /* $Id$
   2  * captive vfs 'file' interface to reactos
   3  * Copyright (C) 2002-2003 Jan Kratochvil <project-captive@jankratochvil.net>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; exactly version 2 of June 1991 is required
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19
  20 #include "config.h"
  21
  22 #include "file-slave.h" /* self */
  23 #include "captive/client-file.h"        /* for CaptiveFileObject */
  24 #include "file.h"       /* for CaptiveFileObject priv */
  25 #include "directory.h"
  26 #include "lib.h"
  27 #include <glib/gmessages.h>
  28 #include "captive/unicode.h"
  29 #include "reactos/ntos/types.h" /* for HANDLE */
  30 #include "reactos/ddk/iotypes.h"        /* for IO_STATUS_BLOCK */
  31 #include "reactos/ddk/iofuncs.h"        /* for IoCreateFile() */
  32 #include "result.h"
  33 #include "captive/client-directory.h"
  34 #include "reactos/ddk/obfuncs.h"        /* for ObReferenceObjectByHandle() */
  35 #include "captive/macros.h"
  36 #include "captive/leave.h"
  37 #include "captive/usecount.h"
  38 #include "vfs.h"
  39 #include "vfs-slave.h"
  40
  41
  42 struct _CaptiveFileSlaveObject {
  43         CaptiveFileObject parent_instance;
  44
  45         /*< private >*/
  46         HANDLE file_Handle;
  47         GnomeVFSFileOffset offset;
  48         };
  49 struct _CaptiveFileSlaveObjectClass {
  50         CaptiveFileObjectClass parent_class;
  51         };
  52
  53
  54 static gpointer captive_file_slave_object_parent_class=NULL;
  55
  56
  57 static GnomeVFSResult captive_file_slave_close(CaptiveFileObject *captive_file_object);
  58 static GnomeVFSResult captive_file_slave_read(CaptiveFileObject *captive_file_object,
  59                 gpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_read_return);
  60 static GnomeVFSResult captive_file_slave_write(CaptiveFileObject *captive_file_object,
  61                 gconstpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_written_return);
  62 static GnomeVFSResult captive_file_slave_seek
  63                 (CaptiveFileObject *captive_file_object,GnomeVFSSeekPosition whence,GnomeVFSFileOffset offset);
  64 static GnomeVFSResult captive_file_slave_tell(CaptiveFileObject *captive_file_object,GnomeVFSFileOffset *offset_return);
  65 static GnomeVFSResult captive_file_slave_remove(CaptiveFileObject *captive_file_object);
  66 static GnomeVFSResult captive_file_slave_file_info_get
  67                 (CaptiveFileObject *captive_file_object,GnomeVFSFileInfo *file_info);
  68 static GnomeVFSResult captive_file_slave_file_info_set
  69                 (CaptiveFileObject *captive_file_object,const GnomeVFSFileInfo *info,GnomeVFSSetFileInfoMask mask);
  70 static GnomeVFSResult captive_file_slave_truncate(CaptiveFileObject *captive_file_object,GnomeVFSFileSize file_size);
  71 static GnomeVFSResult captive_file_slave_move
  72                 (CaptiveFileObject *captive_file_object_old,const gchar *pathname_new,gboolean force_replace);
  73
  74
  75 static void captive_file_slave_object_finalize(CaptiveFileSlaveObject *captive_file_slave_object)
  76 {
  77         g_return_if_fail(captive_file_slave_object!=NULL);
  78
  79         captive_file_slave_close(CAPTIVE_FILE_OBJECT(captive_file_slave_object));       /* errors ignored */
  80
  81         G_OBJECT_CLASS(captive_file_slave_object_parent_class)->finalize((GObject *)captive_file_slave_object);
  82 }
  83
  84
  85 static void captive_file_slave_object_class_init(CaptiveFileSlaveObjectClass *class)
  86 {
  87 GObjectClass *gobject_class=G_OBJECT_CLASS(class);
  88 CaptiveFileObjectClass *captive_file_object_class=CAPTIVE_FILE_OBJECT_CLASS(class);
  89
  90         captive_file_slave_object_parent_class=g_type_class_ref(g_type_parent(G_TYPE_FROM_CLASS(class)));
  91         gobject_class->finalize=(void (*)(GObject *object))captive_file_slave_object_finalize;
  92
  93         captive_file_object_class->read=captive_file_slave_read;
  94         captive_file_object_class->write=captive_file_slave_write;
  95         captive_file_object_class->seek=captive_file_slave_seek;
  96         captive_file_object_class->tell=captive_file_slave_tell;
  97         captive_file_object_class->remove=captive_file_slave_remove;
  98         captive_file_object_class->file_info_get=captive_file_slave_file_info_get;
  99         captive_file_object_class->file_info_set=captive_file_slave_file_info_set;
 100         captive_file_object_class->truncate=captive_file_slave_truncate;
 101         captive_file_object_class->move=captive_file_slave_move;
 102 }
 103
 104
 105 static void captive_file_slave_object_init(CaptiveFileSlaveObject *captive_file_slave_object)
 106 {
 107         captive_file_slave_object->file_Handle=NULL;
 108 }
 109
 110
 111 GType captive_file_slave_object_get_type(void)
 112 {
 113 static GType captive_file_slave_object_type=0;
 114
 115         if (!captive_file_slave_object_type) {
 116 static const GTypeInfo captive_file_slave_object_info={
 117                                 sizeof(CaptiveFileSlaveObjectClass),
 118                                 NULL,   /* base_init */
 119                                 NULL,   /* base_finalize */
 120                                 (GClassInitFunc)captive_file_slave_object_class_init,
 121                                 NULL,   /* class_finalize */
 122                                 NULL,   /* class_data */
 123                                 sizeof(CaptiveFileSlaveObject),
 124                                 5,      /* n_preallocs */
 125                                 (GInstanceInitFunc)captive_file_slave_object_init,
 126                                 };
 127
 128                 captive_file_slave_object_type=g_type_register_static(CAPTIVE_FILE_TYPE_OBJECT,
 129                                 "CaptiveFileSlaveObject",&captive_file_slave_object_info,0);
 130                 }
 131
 132         return captive_file_slave_object_type;
 133 }
 134
 135
 136 static GnomeVFSResult captive_file_slave_new_internal(CaptiveFileSlaveObject *captive_file_slave_object,
 137                 const gchar *pathname,GnomeVFSOpenMode mode,gboolean create,gboolean create_exclusive,guint create_perm)
 138 {
 139 IO_STATUS_BLOCK file_IoStatusBlock;
 140 GnomeVFSResult errvfsresult;
 141 OBJECT_ATTRIBUTES file_ObjectAttributes;
 142 HANDLE file_Handle;
 143 NTSTATUS err;
 144
 145         g_return_val_if_fail(captive_file_slave_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 146         g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 147
 148         errvfsresult=captive_ObjectAttributes_init(pathname,&file_ObjectAttributes);
 149         g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult);
 150
 151         /* open */
 152         err=IoCreateFile(
 153                         &file_Handle,   /* FileHandle */
 154                         0
 155                                         |(!(mode&GNOME_VFS_OPEN_READ ) ? 0 : FILE_READ_DATA)
 156                                         |(!(mode&GNOME_VFS_OPEN_WRITE) ? 0 : FILE_WRITE_DATA | FILE_APPEND_DATA | FILE_WRITE_ATTRIBUTES)
 157                                         |(  mode!=0                    ? 0 : FILE_READ_ATTRIBUTES)
 158                                         ,       /* DesiredAccess */
 159                         &file_ObjectAttributes, /* ObjectAttributes */
 160                         &file_IoStatusBlock,    /* IoStatusBlock */
 161                         NULL,   /* AllocationSize; ignored for open */
 162                         (!create || create_perm&0200 ? FILE_ATTRIBUTE_NORMAL: FILE_ATTRIBUTE_READONLY), /* FileAttributes; ignored for open */
 163                         (!create || !create_exclusive   /* ShareAccess; 0 means exclusive */
 164                                         ? (FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE)
 165                                         : 0),
 166                         (!create ? FILE_OPEN : FILE_CREATE),    /* CreateDisposition */
 167                         /* FILE_SYNCHRONOUS_IO_{,NON}ALERT: We need to allow W32 filesystem
 168                                  * any waits to not to let it return STATUS_CANT_WAIT us.
 169                                  * Alertability should have only effect on asynchronous events
 170                                  * from KeWaitForSingleObject() by setting/clearing its parameter 'Alertable'.
 171                                  */
 172                         FILE_SYNCHRONOUS_IO_ALERT,      /* CreateOptions */
 173                         NULL,   /* EaBuffer */
 174                         0,      /* EaLength */
 175                         CreateFileTypeNone,     /* CreateFileType */
 176                         NULL,   /* ExtraCreateParameters */
 177                         0);     /* Options */
 178         g_free(file_ObjectAttributes.ObjectName);       /* left from captive_file_slave_uri_parent_init() */
 179         g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC);
 180         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 181                 return errvfsresult;
 182         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 183         g_return_val_if_fail(file_IoStatusBlock.Information
 184                                         ==(!create ? FILE_OPENED : FILE_CREATED),
 185                         GNOME_VFS_ERROR_GENERIC);
 186
 187         captive_file_slave_object->file_Handle=file_Handle;
 188
 189         return GNOME_VFS_OK;
 190 }
 191
 192
 193 GnomeVFSResult captive_file_slave_new_open(CaptiveFileObject **captive_file_object_return,
 194                 CaptiveVfsObject *captive_vfs_object,const gchar *pathname,GnomeVFSOpenMode mode)
 195 {
 196 GnomeVFSResult r;
 197 CaptiveFileSlaveObject *captive_file_slave_object;
 198
 199         g_return_val_if_fail(captive_file_object_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 200         g_return_val_if_fail(CAPTIVE_VFS_SLAVE_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS);
 201         g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 202
 203         captive_file_slave_object=g_object_new(
 204                         CAPTIVE_FILE_SLAVE_TYPE_OBJECT, /* object_type */
 205                         NULL);  /* first_property_name; FIXME: support properties */
 206
 207         captive_file_init(CAPTIVE_FILE_OBJECT(captive_file_slave_object),captive_vfs_object);
 208
 209         *captive_file_object_return=CAPTIVE_FILE_OBJECT(captive_file_slave_object);
 210
 211         r=captive_file_slave_new_internal(captive_file_slave_object,pathname,mode,
 212                         FALSE,  /* create */
 213                         FALSE,  /* create_exclusive; ignored */
 214                         0);     /* create_perm; ignored */
 215
 216         captive_leave();
 217         if (r==GNOME_VFS_OK)
 218                 captive_usecount(+1);
 219         else {
 220                 g_object_unref(captive_file_slave_object);
 221                 *captive_file_object_return=NULL;
 222                 }
 223         return r;
 224 }
 225
 226
 227 GnomeVFSResult captive_file_slave_new_create(CaptiveFileObject **captive_file_object_return,
 228                 CaptiveVfsObject *captive_vfs_object,const gchar *pathname,GnomeVFSOpenMode mode,gboolean exclusive,guint perm)
 229 {
 230 GnomeVFSResult r;
 231 CaptiveFileSlaveObject *captive_file_slave_object;
 232
 233         g_return_val_if_fail(captive_file_object_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 234         g_return_val_if_fail(CAPTIVE_VFS_SLAVE_IS_OBJECT(captive_vfs_object),GNOME_VFS_ERROR_BAD_PARAMETERS);
 235         g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 236
 237         captive_file_slave_object=g_object_new(
 238                         CAPTIVE_FILE_SLAVE_TYPE_OBJECT, /* object_type */
 239                         NULL);  /* first_property_name; FIXME: support properties */
 240
 241         captive_file_init(CAPTIVE_FILE_OBJECT(captive_file_slave_object),captive_vfs_object);
 242
 243         *captive_file_object_return=CAPTIVE_FILE_OBJECT(captive_file_slave_object);
 244
 245         r=captive_file_slave_new_internal(captive_file_slave_object,pathname,mode,
 246                         TRUE,   /* create */
 247                         exclusive,      /* create_exclusive */
 248                         perm);  /* create_perm */
 249
 250         captive_leave();
 251         if (r==GNOME_VFS_OK)
 252                 captive_usecount(+1);
 253         else {
 254                 g_object_unref(captive_file_slave_object);
 255                 *captive_file_object_return=NULL;
 256                 }
 257         return r;
 258 }
 259
 260
 261 static GnomeVFSResult captive_file_slave_close(CaptiveFileObject *captive_file_object)
 262 {
 263 CaptiveFileSlaveObject *captive_file_slave_object;
 264 NTSTATUS err;
 265 HANDLE file_Handle;
 266
 267         g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS);
 268
 269         captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object);
 270
 271         if (captive_file_slave_object->file_Handle!=NULL) {     /* not yet already closed */
 272                 captive_usecount(-1);   /* close() errors notwithstanding */
 273
 274                 file_Handle=captive_file_slave_object->file_Handle;
 275                 captive_file_slave_object->file_Handle=NULL;
 276                 err=NtClose(file_Handle);
 277                 g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 278                 }
 279
 280         captive_leave();
 281         return GNOME_VFS_OK;
 282 }
 283
 284
 285 GnomeVFSResult captive_file_slave_read(CaptiveFileObject *captive_file_object,
 286                 gpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_read_return)
 287 {
 288 CaptiveFileSlaveObject *captive_file_slave_object;
 289 NTSTATUS err;
 290 IO_STATUS_BLOCK file_IoStatusBlock;
 291 LARGE_INTEGER file_offset;
 292 GnomeVFSResult errvfsresult;
 293
 294         g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS);
 295         g_return_val_if_fail(buffer!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 296         g_return_val_if_fail(bytes_read_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 297         g_return_val_if_fail(num_bytes==(ULONG)num_bytes,GNOME_VFS_ERROR_BAD_PARAMETERS);
 298
 299         captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object);
 300
 301         g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 302
 303         file_offset.QuadPart=captive_file_slave_object->offset;
 304         err=NtReadFile(
 305                         captive_file_slave_object->file_Handle, /* FileHandle */
 306                         NULL,   /* EventHandle; completion signalling; optional */
 307                         NULL,   /* ApcRoutine; optional */
 308                         NULL,   /* ApcContext; optional */
 309                         &file_IoStatusBlock,    /* IoStatusBlock */
 310                         buffer, /* Buffer */
 311                         num_bytes,      /* Length */
 312                         &file_offset,   /* ByteOffset */
 313                         NULL);  /* Key; NULL means no file locking key */
 314         if (err==STATUS_END_OF_FILE) {
 315                 g_return_val_if_fail(file_IoStatusBlock.Status==STATUS_END_OF_FILE,GNOME_VFS_ERROR_GENERIC);
 316                 g_return_val_if_fail(file_IoStatusBlock.Information==0,GNOME_VFS_ERROR_GENERIC);
 317                 *bytes_read_return=0;
 318                 return GNOME_VFS_ERROR_EOF;
 319                 }
 320         g_return_val_if_fail(file_IoStatusBlock.Information>0,GNOME_VFS_ERROR_GENERIC); /* if not STATUS_END_OF_FILE... */
 321         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 322                 return errvfsresult;
 323         g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC);
 324         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 325         g_return_val_if_fail(file_IoStatusBlock.Information<=num_bytes,GNOME_VFS_ERROR_GENERIC);
 326
 327         captive_file_slave_object->offset+=file_IoStatusBlock.Information;
 328         *bytes_read_return=file_IoStatusBlock.Information;
 329         captive_leave();
 330         return GNOME_VFS_OK;
 331 }
 332
 333
 334 GnomeVFSResult captive_file_slave_write(CaptiveFileObject *captive_file_object,
 335                 gconstpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_written_return)
 336 {
 337 CaptiveFileSlaveObject *captive_file_slave_object;
 338 NTSTATUS err;
 339 IO_STATUS_BLOCK file_IoStatusBlock;
 340 LARGE_INTEGER file_offset;
 341 GnomeVFSFileInfo file_info;
 342 GnomeVFSFileSize endoffile_wanted;
 343 GnomeVFSResult errvfsresult;
 344
 345         g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS);
 346         g_return_val_if_fail(buffer!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 347         g_return_val_if_fail(bytes_written_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 348         g_return_val_if_fail(num_bytes==(ULONG)num_bytes,GNOME_VFS_ERROR_BAD_PARAMETERS);
 349
 350         captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object);
 351
 352         g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 353
 354         if ((GnomeVFSFileOffset)(captive_file_slave_object->offset+num_bytes) < captive_file_slave_object->offset)
 355                 return GNOME_VFS_ERROR_TOO_BIG;
 356         endoffile_wanted=captive_file_slave_object->offset+num_bytes;
 357         if (GNOME_VFS_OK!=(errvfsresult=captive_file_slave_file_info_get(
 358                         CAPTIVE_FILE_OBJECT(captive_file_slave_object),&file_info)))
 359                 return errvfsresult;
 360         if (file_info.size<endoffile_wanted) {
 361                 if (GNOME_VFS_OK!=(errvfsresult=captive_file_slave_truncate(
 362                                 CAPTIVE_FILE_OBJECT(captive_file_slave_object),endoffile_wanted)))
 363                         return errvfsresult;
 364                 }
 365
 366         file_offset.QuadPart=captive_file_slave_object->offset;
 367         err=NtWriteFile(
 368                         captive_file_slave_object->file_Handle, /* FileHandle */
 369                         NULL,   /* Event; completion signalling; optional */
 370                         NULL,   /* ApcRoutine; optional */
 371                         NULL,   /* ApcContext; optional */
 372                         &file_IoStatusBlock,    /* IoStatusBlock */
 373                         (gpointer /* de-const */ )buffer,       /* Buffer */
 374                         num_bytes,      /* Length */
 375                         &file_offset,   /* ByteOffset */
 376                         NULL);  /* Key; NULL means no file locking key */
 377         g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC);
 378         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 379         if (!file_IoStatusBlock.Information) {
 380                 /* FIXME: Check ExRaiseStatus(STATUS_LOG_FILE_FULL);
 381                  * really occured. We expect so and we will remount the volume.
 382                  */
 383                 *bytes_written_return=0;
 384                 return GNOME_VFS_ERROR_LAUNCH;
 385                 }
 386         g_return_val_if_fail(file_IoStatusBlock.Information==num_bytes,GNOME_VFS_ERROR_GENERIC);
 387
 388         captive_file_slave_object->offset+=file_IoStatusBlock.Information;
 389         *bytes_written_return=file_IoStatusBlock.Information;
 390         captive_leave();
 391         return GNOME_VFS_OK;
 392 }
 393
 394
 395 GnomeVFSResult captive_file_slave_seek
 396                 (CaptiveFileObject *captive_file_object,GnomeVFSSeekPosition whence,GnomeVFSFileOffset offset)
 397 {
 398 CaptiveFileSlaveObject *captive_file_slave_object;
 399
 400         g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS);
 401
 402         captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object);
 403
 404         g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 405
 406         switch (whence) {
 407                 case GNOME_VFS_SEEK_START:
 408                         captive_file_slave_object->offset=offset;
 409                         break;
 410                 case GNOME_VFS_SEEK_CURRENT:
 411                         if (0
 412                                         || (offset>0 && (captive_file_slave_object->offset+offset)<captive_file_slave_object->offset)
 413                                         || (offset<0 && (captive_file_slave_object->offset+offset)>captive_file_slave_object->offset))
 414                                 return GNOME_VFS_ERROR_BAD_PARAMETERS;
 415                         captive_file_slave_object->offset+=offset;
 416                         break;
 417                 case GNOME_VFS_SEEK_END:
 418                         g_assert_not_reached(); /* NOT IMPLEMENTED YET */
 419                         break;
 420                 default:
 421                         g_return_val_if_reached(GNOME_VFS_ERROR_BAD_PARAMETERS);
 422                 }
 423
 424         captive_leave();
 425         return GNOME_VFS_OK;
 426 }
 427
 428
 429 GnomeVFSResult captive_file_slave_tell(CaptiveFileObject *captive_file_object,GnomeVFSFileOffset *offset_return)
 430 {
 431 CaptiveFileSlaveObject *captive_file_slave_object;
 432
 433         g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS);
 434         g_return_val_if_fail(offset_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 435
 436         captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object);
 437
 438         g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 439
 440         *offset_return=captive_file_slave_object->offset;
 441         captive_leave();
 442         return GNOME_VFS_OK;
 443 }
 444
 445
 446 GnomeVFSResult captive_file_slave_remove(CaptiveFileObject *captive_file_object)
 447 {
 448 CaptiveFileSlaveObject *captive_file_slave_object;
 449 NTSTATUS err;
 450 FILE_DISPOSITION_INFORMATION FileDispositionInformation_struct;
 451 IO_STATUS_BLOCK file_IoStatusBlock;
 452 GnomeVFSResult errvfsresult;
 453
 454         g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS);
 455
 456         captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object);
 457
 458         g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 459
 460         FileDispositionInformation_struct.DoDeleteFile=TRUE;
 461
 462         err=NtSetInformationFile(
 463                         captive_file_slave_object->file_Handle, /* FileHandle */
 464                         &file_IoStatusBlock,    /* IoStatusBlock */
 465                         &FileDispositionInformation_struct,     /* FileInformation */
 466                         sizeof(FileDispositionInformation_struct),      /* Length */
 467                         FileDispositionInformation);    /* FileInformationClass */
 468         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 469                 return errvfsresult;
 470         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 471
 472         captive_leave();
 473         return GNOME_VFS_OK;
 474 }
 475
 476
 477 /* Use 'FileNameInformationStruct' identifier instead of the logical 'FileNameInformation'
 478  * to prevent override of enum member 'FileNameInformation'
 479  */
 480 static GnomeVFSResult FileNameInformationStruct_to_GnomeVFSFileInfo(GnomeVFSFileInfo *file_info,
 481                 FILE_NAME_INFORMATION *FileNameInformationStruct)
 482 {
 483 UNICODE_STRING FileName_UnicodeString;
 484
 485         g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_GENERIC);
 486         g_return_val_if_fail(FileNameInformationStruct!=NULL,GNOME_VFS_ERROR_GENERIC);
 487
 488         FileName_UnicodeString.Length=FileNameInformationStruct->FileNameLength;
 489         FileName_UnicodeString.MaximumLength=FileNameInformationStruct->FileNameLength
 490                         +sizeof(*FileNameInformationStruct->FileName);  /* 0-terminator */
 491
 492 #if 0   /* 'IoStatusBlock->Information' is sometimes weird, do not check it */
 493         g_assert((gpointer)(((char *)FileNameInformationStruct->FileName)+FileName_UnicodeString.Length)
 494                         <=(gpointer)(((char *)FileAllInformationStruct)+IoStatusBlock->Information));
 495                                         /* ensure we fit below '->IoStatusBlock->Information' at least without the 0-terminator */
 496 #endif
 497
 498         FileNameInformationStruct->FileName[FileNameInformationStruct->FileNameLength
 499                         /sizeof(*FileNameInformationStruct->FileName)]=0;       /* 0-terminate it */
 500         FileName_UnicodeString.Buffer=FileNameInformationStruct->FileName;
 501         file_info->name=captive_UnicodeString_to_utf8_malloc(&FileName_UnicodeString);
 502         /* '->name' assumed for 'file_info->valid_fields' */
 503
 504         return GNOME_VFS_OK;
 505 }
 506
 507
 508 /* Use 'FileBasicInformationStruct' identifier instead of the logical 'FileBasicInformation'
 509  * to prevent override of enum member 'FileBasicInformation'
 510  */
 511 static GnomeVFSResult FileBasicInformationStruct_to_GnomeVFSFileInfo(GnomeVFSFileInfo *file_info,
 512                 FILE_BASIC_INFORMATION *FileBasicInformationStruct)
 513 {
 514 BOOLEAN errBOOLEAN;
 515 ULONG tmp_ULONG;
 516
 517         /* FIXME: What is 'FILE_ATTRIBUTE_NORMAL'? */
 518         switch (FileBasicInformationStruct->FileAttributes & (0
 519                         | FILE_ATTRIBUTE_DIRECTORY
 520                         | FILE_ATTRIBUTE_DEVICE)) {
 521                 case 0:                        file_info->type=GNOME_VFS_FILE_TYPE_REGULAR;   break;
 522                 case FILE_ATTRIBUTE_DIRECTORY: file_info->type=GNOME_VFS_FILE_TYPE_DIRECTORY; break;
 523                 case FILE_ATTRIBUTE_DEVICE:    file_info->type=GNOME_VFS_FILE_TYPE_SOCKET;
 524                         /* or GNOME_VFS_FILE_TYPE_CHARACTER_DEVICE or GNOME_VFS_FILE_TYPE_BLOCK_DEVICE ? */
 525                         break;
 526                 default:                       file_info->type=GNOME_VFS_FILE_TYPE_UNKNOWN;   break;
 527                 }
 528         file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_TYPE;
 529
 530         /* we use 0600 for r/w files, 0400 for FILE_ATTRIBUTE_READONLY */
 531         file_info->permissions=GNOME_VFS_PERM_USER_READ;
 532         if (file_info->type==GNOME_VFS_FILE_TYPE_DIRECTORY)
 533                 file_info->permissions|=GNOME_VFS_PERM_USER_EXEC;
 534         if (!(FileBasicInformationStruct->FileAttributes & FILE_ATTRIBUTE_READONLY))
 535                 file_info->permissions|=GNOME_VFS_PERM_USER_WRITE;
 536         file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS;
 537
 538         if (FileBasicInformationStruct->LastAccessTime.QuadPart) {      /* it may be 0 if not set */
 539                 errBOOLEAN=RtlTimeToSecondsSince1970(&FileBasicInformationStruct->LastAccessTime,&tmp_ULONG);
 540                 g_assert(errBOOLEAN==TRUE);
 541                 file_info->atime=tmp_ULONG;
 542                 file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_ATIME;
 543                 }
 544
 545         /* it may be 0 if not set */
 546         if (FileBasicInformationStruct->LastWriteTime.QuadPart || FileBasicInformationStruct->ChangeTime.QuadPart) {
 547                 errBOOLEAN=RtlTimeToSecondsSince1970(
 548                                 /* take the more recent (==bigger) time: */
 549                                 (FileBasicInformationStruct->LastWriteTime.QuadPart > FileBasicInformationStruct->ChangeTime.QuadPart
 550                                                 ? &FileBasicInformationStruct->LastWriteTime : &FileBasicInformationStruct->ChangeTime),
 551                                 &tmp_ULONG);
 552                 g_assert(errBOOLEAN==TRUE);
 553                 file_info->mtime=tmp_ULONG;
 554                 file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_MTIME;
 555                 }
 556
 557         if (FileBasicInformationStruct->CreationTime.QuadPart) {        /* it may be 0 if not set */
 558                 errBOOLEAN=RtlTimeToSecondsSince1970(&FileBasicInformationStruct->CreationTime,&tmp_ULONG);
 559                 g_assert(errBOOLEAN==TRUE);
 560                 file_info->ctime=tmp_ULONG;
 561                 file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_CTIME;
 562                 }
 563
 564         return GNOME_VFS_OK;
 565 }
 566
 567
 568 /* Use 'FileStandardInformationStruct' identifier instead of the logical 'FileStandardInformation'
 569  * to prevent override of enum member 'FileStandardInformation'
 570  */
 571 static GnomeVFSResult FileStandardInformationStruct_to_GnomeVFSFileInfo(GnomeVFSFileInfo *file_info,
 572                 FILE_STANDARD_INFORMATION *FileStandardInformationStruct)
 573 {
 574         file_info->size=FileStandardInformationStruct->EndOfFile.QuadPart;
 575         file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_SIZE;
 576
 577         file_info->block_count=FileStandardInformationStruct->AllocationSize.QuadPart/512;
 578         file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_BLOCK_COUNT;
 579
 580         return GNOME_VFS_OK;
 581 }
 582
 583
 584 GnomeVFSResult captive_file_slave_file_info_get(CaptiveFileObject *captive_file_object,
 585                 GnomeVFSFileInfo *file_info)
 586 {
 587 CaptiveFileSlaveObject *captive_file_slave_object;
 588 NTSTATUS err;
 589 IO_STATUS_BLOCK file_IoStatusBlock;
 590 FILE_NAME_INFORMATION *FileNameInformationStruct;
 591 FILE_BASIC_INFORMATION *FileBasicInformationStruct;
 592 FILE_STANDARD_INFORMATION *FileStandardInformationStruct;
 593 GnomeVFSResult errvfsresult;
 594 char QueryFile_buf[sizeof(FILE_NAME_INFORMATION)
 595                 +0x1000 /* max 'FileName' length, 255 should be enough */ * sizeof(WCHAR /* *FILE_ALL_INFORMATION.NameInformation.FileName */ )];
 596
 597         g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS);
 598         g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 599
 600         captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object);
 601
 602         g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 603
 604         /* ntfs.sys of NT-5.1sp1 has *(FILE_BASIC_INFORMATION *)FILE_ALL_INFORMATION.BasicInformation
 605          * size 0x28 although reactos includes and all the information says 0x24.
 606          * fastfat.sys of NT-5.1sp1 also has the 'official' sizeof 0x24.
 607          * It would be a bit of heuristic to correctly detect its expected sizeof.
 608          */
 609
 610         file_info->valid_fields=0;
 611
 612         file_info->flags=GNOME_VFS_FILE_FLAGS_LOCAL;
 613         file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_FLAGS;
 614
 615         /* query NameInformation */
 616         FileNameInformationStruct=(void *)QueryFile_buf;
 617         err=NtQueryInformationFile(
 618                         captive_file_slave_object->file_Handle, /* FileHandle */
 619                         &file_IoStatusBlock,    /* IoStatusBlock */
 620                         (gpointer)QueryFile_buf,        /* FileInformation */
 621                         sizeof(QueryFile_buf)   /* Length */
 622                                         -sizeof(*FileNameInformationStruct->FileName),  /* reserve space for a possible 0-terminator */
 623                         FileNameInformation);   /* FileInformationClass; =>FILE_NAME_INFORMATION */
 624         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 625                 return errvfsresult;
 626         g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC);
 627         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 628         errvfsresult=FileNameInformationStruct_to_GnomeVFSFileInfo(file_info,FileNameInformationStruct);
 629         g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult);
 630
 631         /* query BasicInformation */
 632         FileBasicInformationStruct=(void *)QueryFile_buf;
 633         err=NtQueryInformationFile(
 634                         captive_file_slave_object->file_Handle, /* FileHandle */
 635                         &file_IoStatusBlock,    /* IoStatusBlock */
 636                         (gpointer)QueryFile_buf,        /* FileInformation */
 637                         sizeof(QueryFile_buf),  /* Length */
 638                         FileBasicInformation);  /* FileInformationClass; =>FILE_BASIC_INFORMATION */
 639         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 640                 return errvfsresult;
 641         g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC);
 642         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 643         errvfsresult=FileBasicInformationStruct_to_GnomeVFSFileInfo(file_info,FileBasicInformationStruct);
 644         g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult);
 645
 646         /* query StandardInformation */
 647         FileStandardInformationStruct=(void *)QueryFile_buf;
 648         err=NtQueryInformationFile(
 649                         captive_file_slave_object->file_Handle, /* FileHandle */
 650                         &file_IoStatusBlock,    /* IoStatusBlock */
 651                         (gpointer)QueryFile_buf,        /* FileInformation */
 652                         sizeof(QueryFile_buf),  /* Length */
 653                         FileStandardInformation);       /* FileInformationClass; =>FILE_STANDARD_INFORMATION */
 654         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 655                 return errvfsresult;
 656         g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC);
 657         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 658         errvfsresult=FileStandardInformationStruct_to_GnomeVFSFileInfo(file_info,FileStandardInformationStruct);
 659         g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult);
 660
 661         captive_leave();
 662         return GNOME_VFS_OK;
 663 }
 664
 665
 666 GnomeVFSResult captive_file_slave_file_info_set(CaptiveFileObject *captive_file_object,
 667     const GnomeVFSFileInfo *info,GnomeVFSSetFileInfoMask mask)
 668 {
 669 CaptiveFileSlaveObject *captive_file_slave_object;
 670
 671         g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS);
 672         g_return_val_if_fail(info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 673
 674         captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object);
 675
 676         g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 677
 678         if (mask & GNOME_VFS_SET_FILE_INFO_NAME) {
 679 gchar *name_dirname,*name_basename;
 680 UNICODE_STRING *name_UnicodeString;
 681 FILE_RENAME_INFORMATION *FileRenameInformation_structp;
 682 gsize FileRenameInformation_struct_len;
 683 IO_STATUS_BLOCK file_IoStatusBlock;
 684 NTSTATUS err;
 685 GnomeVFSResult errvfsresult;
 686
 687                 /* non-existing dirname assertion */
 688                 name_dirname=g_path_get_dirname(info->name);
 689                 if (*name_dirname) {
 690                         g_assert_not_reached();
 691                         errvfsresult=GNOME_VFS_ERROR_BAD_PARAMETERS;
 692                         goto err;
 693                         }
 694
 695                 /* fully-matching basename assertion */
 696                 name_basename=g_path_get_basename(info->name);
 697                 if (strcmp(name_basename,info->name)) {
 698                         g_assert_not_reached();
 699                         errvfsresult=GNOME_VFS_ERROR_BAD_PARAMETERS;
 700                         goto err_free_name_dirname;
 701                         }
 702
 703                 name_UnicodeString=captive_utf8_to_UnicodeString_alloca(info->name);
 704                 FileRenameInformation_struct_len=sizeof(*FileRenameInformation_structp)
 705                                 +name_UnicodeString->MaximumLength;     /* ==Length+(0-terminator); is the terminator needed? */
 706
 707                 FileRenameInformation_structp=g_alloca(FileRenameInformation_struct_len);
 708                 FileRenameInformation_structp->Replace=FALSE;
 709                 FileRenameInformation_structp->RootDir=NULL;    /* we do 'simple rename' here */
 710                 FileRenameInformation_structp->FileNameLength=name_UnicodeString->Length;
 711                 memcpy(FileRenameInformation_structp->FileName,name_UnicodeString->Buffer,
 712                                 name_UnicodeString->MaximumLength);     /* ==Length+(0-terminator); is the terminator needed? */
 713
 714                 err=NtSetInformationFile(
 715                                 captive_file_slave_object->file_Handle, /* FileHandle */
 716                                 &file_IoStatusBlock,    /* IoStatusBlock */
 717                                 FileRenameInformation_structp,  /* FileInformation */
 718                                 FileRenameInformation_struct_len,       /* Length */
 719                                 FileRenameInformation); /* FileInformationClass */
 720                 if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 721                         goto err_free_name_basename;
 722
 723 err_free_name_basename:
 724                 g_free(name_basename);
 725 err_free_name_dirname:
 726                 g_free(name_dirname);
 727 err:
 728
 729                 if (errvfsresult!=GNOME_VFS_OK)
 730                         return errvfsresult;
 731                 g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 732                 }
 733
 734         if (mask & (GNOME_VFS_SET_FILE_INFO_PERMISSIONS | GNOME_VFS_SET_FILE_INFO_TIME)) {
 735 char FileBasicInformation_buf[sizeof(FILE_BASIC_INFORMATION)+4];
 736 FILE_BASIC_INFORMATION *FileBasicInformationp=(FILE_BASIC_INFORMATION *)FileBasicInformation_buf;
 737 IO_STATUS_BLOCK file_IoStatusBlock;
 738 NTSTATUS err;
 739
 740                 /* FIXME: Everywhere is is the declaration with 4xLARGE_INTEGER+1xULONG==36 bytes
 741                  * but the precompiled ext2fsd.sys wants 40 bytes - why?
 742                  * The same case applies to ntfs.sys of NT-5.1sp1.
 743                  */
 744                 g_assert(sizeof(FILE_BASIC_INFORMATION)==36);
 745                 g_assert(sizeof(FileBasicInformation_buf)==40);
 746                 err=NtQueryInformationFile(
 747                                 captive_file_slave_object->file_Handle, /* FileHandle */
 748                                 &file_IoStatusBlock,    /* IoStatusBlock */
 749                                 FileBasicInformation_buf,       /* FileInformation */
 750                                 sizeof(FileBasicInformation_buf),       /* Length */
 751                                 FileBasicInformation);  /* FileInformationClass */
 752                 g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 753
 754                 if (mask & GNOME_VFS_SET_FILE_INFO_PERMISSIONS) {
 755                         FileBasicInformationp->FileAttributes&=~FILE_ATTRIBUTE_READONLY;
 756                         g_assert(info->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS);
 757                         if (!(info->permissions&0200))
 758                                 FileBasicInformationp->FileAttributes|=FILE_ATTRIBUTE_READONLY;
 759                         }
 760
 761                 if (mask & GNOME_VFS_SET_FILE_INFO_TIME) {
 762                         g_assert(info->valid_fields & (0
 763                                         | GNOME_VFS_FILE_INFO_FIELDS_ATIME
 764                                         | GNOME_VFS_FILE_INFO_FIELDS_MTIME
 765                                         | GNOME_VFS_FILE_INFO_FIELDS_CTIME));
 766                         if (info->valid_fields&GNOME_VFS_FILE_INFO_FIELDS_ATIME) {
 767                                 RtlSecondsSince1970ToTime(
 768                                                 info->atime,    /* SecondsSince1970 */
 769                                                 &FileBasicInformationp->LastAccessTime);        /* Time */
 770                                 }
 771                         if (info->valid_fields&GNOME_VFS_FILE_INFO_FIELDS_MTIME) {
 772                                 RtlSecondsSince1970ToTime(
 773                                                 info->mtime,    /* SecondsSince1970 */
 774                                                 &FileBasicInformationp->LastWriteTime); /* Time */
 775                                 FileBasicInformationp->ChangeTime=FileBasicInformationp->LastWriteTime;
 776                                 }
 777                         if (info->valid_fields&GNOME_VFS_FILE_INFO_FIELDS_CTIME) {
 778                                 RtlSecondsSince1970ToTime(
 779                                                 info->ctime,    /* SecondsSince1970 */
 780                                                 &FileBasicInformationp->CreationTime);  /* Time */
 781                                 }
 782                         }
 783
 784                 err=NtSetInformationFile(
 785                                 captive_file_slave_object->file_Handle, /* FileHandle */
 786                                 &file_IoStatusBlock,    /* IoStatusBlock */
 787                                 FileBasicInformation_buf,       /* FileInformation */
 788                                 sizeof(FileBasicInformation_buf),       /* Length */
 789                                 FileBasicInformation);  /* FileInformationClass */
 790                 g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 791                 }
 792
 793         if (mask & GNOME_VFS_SET_FILE_INFO_OWNER) {
 794                 /* FIXME: g_assert(info->valid_fields & ???); */
 795                 /* owner ignored for W32 */
 796                 }
 797
 798         captive_leave();
 799         return GNOME_VFS_OK;
 800 }
 801
 802
 803 GnomeVFSResult captive_file_slave_truncate(CaptiveFileObject *captive_file_object,GnomeVFSFileSize file_size)
 804 {
 805 CaptiveFileSlaveObject *captive_file_slave_object;
 806 NTSTATUS err;
 807 FILE_END_OF_FILE_INFORMATION FileEndOfFileInformation_struct;
 808 IO_STATUS_BLOCK file_IoStatusBlock;
 809 GnomeVFSResult errvfsresult;
 810
 811         g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS);
 812
 813         captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object);
 814
 815         g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 816
 817         FileEndOfFileInformation_struct.EndOfFile.QuadPart=file_size;
 818
 819         err=NtSetInformationFile(
 820                         captive_file_slave_object->file_Handle, /* FileHandle */
 821                         &file_IoStatusBlock,    /* IoStatusBlock */
 822                         &FileEndOfFileInformation_struct,       /* FileInformation */
 823                         sizeof(FileEndOfFileInformation_struct),        /* Length */
 824                         FileEndOfFileInformation);      /* FileInformationClass */
 825         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 826                 return errvfsresult;
 827         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 828
 829         captive_leave();
 830         return GNOME_VFS_OK;
 831 }
 832
 833
 834 GnomeVFSResult captive_file_slave_move
 835                 (CaptiveFileObject *captive_file_object_old,const gchar *pathname_new,gboolean force_replace)
 836 {
 837 CaptiveFileSlaveObject *captive_file_slave_object_old;
 838 NTSTATUS err;
 839 FILE_RENAME_INFORMATION *FileRenameInformation_structp;
 840 IO_STATUS_BLOCK file_IoStatusBlock;
 841 GnomeVFSResult errvfsresult;
 842 OBJECT_ATTRIBUTES pathname_new_ObjectAttributes;
 843
 844         g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object_old),GNOME_VFS_ERROR_BAD_PARAMETERS);
 845         g_return_val_if_fail(pathname_new!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 846
 847         captive_file_slave_object_old=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object_old);
 848
 849         g_return_val_if_fail(captive_file_slave_object_old->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 850
 851         errvfsresult=captive_ObjectAttributes_init(pathname_new,&pathname_new_ObjectAttributes);
 852         g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult);
 853
 854         FileRenameInformation_structp=
 855                         g_alloca(sizeof(*FileRenameInformation_structp)+pathname_new_ObjectAttributes.ObjectName->MaximumLength);
 856         FileRenameInformation_structp->Replace=force_replace;
 857         FileRenameInformation_structp->RootDir=0;       /* AFAIK never set by orig W32 */
 858         FileRenameInformation_structp->FileNameLength=pathname_new_ObjectAttributes.ObjectName->Length;
 859         memcpy(FileRenameInformation_structp->FileName,pathname_new_ObjectAttributes.ObjectName->Buffer,
 860                         pathname_new_ObjectAttributes.ObjectName->MaximumLength);
 861
 862         err=NtSetInformationFile(
 863                         captive_file_slave_object_old->file_Handle,     /* FileHandle */
 864                         &file_IoStatusBlock,    /* IoStatusBlock */
 865                         FileRenameInformation_structp,  /* FileInformation */
 866                         sizeof(*FileRenameInformation_structp)+pathname_new_ObjectAttributes.ObjectName->MaximumLength, /* Length */
 867                         FileRenameInformation); /* FileInformationClass */
 868         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 869                 goto err_free_ObjectAttributes;
 870         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 871
 872         errvfsresult=GNOME_VFS_OK;
 873
 874 err_free_ObjectAttributes:
 875         g_free(pathname_new_ObjectAttributes.ObjectName);       /* left from captive_file_slave_uri_parent_init() */
 876
 877         captive_leave();
 878         return errvfsresult;
 879 }