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         g_return_val_if_fail(file_IoStatusBlock.Information==num_bytes,GNOME_VFS_ERROR_GENERIC);
 380
 381         captive_file_slave_object->offset+=file_IoStatusBlock.Information;
 382         *bytes_written_return=file_IoStatusBlock.Information;
 383         captive_leave();
 384         return GNOME_VFS_OK;
 385 }
 386
 387
 388 GnomeVFSResult captive_file_slave_seek
 389                 (CaptiveFileObject *captive_file_object,GnomeVFSSeekPosition whence,GnomeVFSFileOffset offset)
 390 {
 391 CaptiveFileSlaveObject *captive_file_slave_object;
 392
 393         g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS);
 394
 395         captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object);
 396
 397         g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 398
 399         switch (whence) {
 400                 case GNOME_VFS_SEEK_START:
 401                         captive_file_slave_object->offset=offset;
 402                         break;
 403                 case GNOME_VFS_SEEK_CURRENT:
 404                         if (0
 405                                         || (offset>0 && (captive_file_slave_object->offset+offset)<captive_file_slave_object->offset)
 406                                         || (offset<0 && (captive_file_slave_object->offset+offset)>captive_file_slave_object->offset))
 407                                 return GNOME_VFS_ERROR_BAD_PARAMETERS;
 408                         captive_file_slave_object->offset+=offset;
 409                         break;
 410                 case GNOME_VFS_SEEK_END:
 411                         g_assert_not_reached(); /* NOT IMPLEMENTED YET */
 412                         break;
 413                 default:
 414                         g_return_val_if_reached(GNOME_VFS_ERROR_BAD_PARAMETERS);
 415                 }
 416
 417         captive_leave();
 418         return GNOME_VFS_OK;
 419 }
 420
 421
 422 GnomeVFSResult captive_file_slave_tell(CaptiveFileObject *captive_file_object,GnomeVFSFileOffset *offset_return)
 423 {
 424 CaptiveFileSlaveObject *captive_file_slave_object;
 425
 426         g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS);
 427         g_return_val_if_fail(offset_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 428
 429         captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object);
 430
 431         g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 432
 433         *offset_return=captive_file_slave_object->offset;
 434         captive_leave();
 435         return GNOME_VFS_OK;
 436 }
 437
 438
 439 GnomeVFSResult captive_file_slave_remove(CaptiveFileObject *captive_file_object)
 440 {
 441 CaptiveFileSlaveObject *captive_file_slave_object;
 442 NTSTATUS err;
 443 FILE_DISPOSITION_INFORMATION FileDispositionInformation_struct;
 444 IO_STATUS_BLOCK file_IoStatusBlock;
 445 GnomeVFSResult errvfsresult;
 446
 447         g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS);
 448
 449         captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object);
 450
 451         g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 452
 453         FileDispositionInformation_struct.DoDeleteFile=TRUE;
 454
 455         err=NtSetInformationFile(
 456                         captive_file_slave_object->file_Handle, /* FileHandle */
 457                         &file_IoStatusBlock,    /* IoStatusBlock */
 458                         &FileDispositionInformation_struct,     /* FileInformation */
 459                         sizeof(FileDispositionInformation_struct),      /* Length */
 460                         FileDispositionInformation);    /* FileInformationClass */
 461         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 462                 return errvfsresult;
 463         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 464
 465         captive_leave();
 466         return GNOME_VFS_OK;
 467 }
 468
 469
 470 /* Use 'FileNameInformationStruct' identifier instead of the logical 'FileNameInformation'
 471  * to prevent override of enum member 'FileNameInformation'
 472  */
 473 static GnomeVFSResult FileNameInformationStruct_to_GnomeVFSFileInfo(GnomeVFSFileInfo *file_info,
 474                 FILE_NAME_INFORMATION *FileNameInformationStruct)
 475 {
 476 UNICODE_STRING FileName_UnicodeString;
 477
 478         g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_GENERIC);
 479         g_return_val_if_fail(FileNameInformationStruct!=NULL,GNOME_VFS_ERROR_GENERIC);
 480
 481         FileName_UnicodeString.Length=FileNameInformationStruct->FileNameLength;
 482         FileName_UnicodeString.MaximumLength=FileNameInformationStruct->FileNameLength
 483                         +sizeof(*FileNameInformationStruct->FileName);  /* 0-terminator */
 484
 485 #if 0   /* 'IoStatusBlock->Information' is sometimes weird, do not check it */
 486         g_assert((gpointer)(((char *)FileNameInformationStruct->FileName)+FileName_UnicodeString.Length)
 487                         <=(gpointer)(((char *)FileAllInformationStruct)+IoStatusBlock->Information));
 488                                         /* ensure we fit below '->IoStatusBlock->Information' at least without the 0-terminator */
 489 #endif
 490
 491         FileNameInformationStruct->FileName[FileNameInformationStruct->FileNameLength
 492                         /sizeof(*FileNameInformationStruct->FileName)]=0;       /* 0-terminate it */
 493         FileName_UnicodeString.Buffer=FileNameInformationStruct->FileName;
 494         file_info->name=captive_UnicodeString_to_utf8_malloc(&FileName_UnicodeString);
 495         /* '->name' assumed for 'file_info->valid_fields' */
 496
 497         return GNOME_VFS_OK;
 498 }
 499
 500
 501 /* Use 'FileBasicInformationStruct' identifier instead of the logical 'FileBasicInformation'
 502  * to prevent override of enum member 'FileBasicInformation'
 503  */
 504 static GnomeVFSResult FileBasicInformationStruct_to_GnomeVFSFileInfo(GnomeVFSFileInfo *file_info,
 505                 FILE_BASIC_INFORMATION *FileBasicInformationStruct)
 506 {
 507 BOOLEAN errBOOLEAN;
 508 ULONG tmp_ULONG;
 509
 510         /* FIXME: What is 'FILE_ATTRIBUTE_NORMAL'? */
 511         switch (FileBasicInformationStruct->FileAttributes & (0
 512                         | FILE_ATTRIBUTE_DIRECTORY
 513                         | FILE_ATTRIBUTE_DEVICE)) {
 514                 case 0:                        file_info->type=GNOME_VFS_FILE_TYPE_REGULAR;   break;
 515                 case FILE_ATTRIBUTE_DIRECTORY: file_info->type=GNOME_VFS_FILE_TYPE_DIRECTORY; break;
 516                 case FILE_ATTRIBUTE_DEVICE:    file_info->type=GNOME_VFS_FILE_TYPE_SOCKET;
 517                         /* or GNOME_VFS_FILE_TYPE_CHARACTER_DEVICE or GNOME_VFS_FILE_TYPE_BLOCK_DEVICE ? */
 518                         break;
 519                 default:                       file_info->type=GNOME_VFS_FILE_TYPE_UNKNOWN;   break;
 520                 }
 521         file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_TYPE;
 522
 523         /* we use 0600 for r/w files, 0400 for FILE_ATTRIBUTE_READONLY */
 524         file_info->permissions=GNOME_VFS_PERM_USER_READ;
 525         if (file_info->type==GNOME_VFS_FILE_TYPE_DIRECTORY)
 526                 file_info->permissions|=GNOME_VFS_PERM_USER_EXEC;
 527         if (!(FileBasicInformationStruct->FileAttributes & FILE_ATTRIBUTE_READONLY))
 528                 file_info->permissions|=GNOME_VFS_PERM_USER_WRITE;
 529         file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS;
 530
 531         if (FileBasicInformationStruct->LastAccessTime.QuadPart) {      /* it may be 0 if not set */
 532                 errBOOLEAN=RtlTimeToSecondsSince1970(&FileBasicInformationStruct->LastAccessTime,&tmp_ULONG);
 533                 g_assert(errBOOLEAN==TRUE);
 534                 file_info->atime=tmp_ULONG;
 535                 file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_ATIME;
 536                 }
 537
 538         /* it may be 0 if not set */
 539         if (FileBasicInformationStruct->LastWriteTime.QuadPart || FileBasicInformationStruct->ChangeTime.QuadPart) {
 540                 errBOOLEAN=RtlTimeToSecondsSince1970(
 541                                 /* take the more recent (==bigger) time: */
 542                                 (FileBasicInformationStruct->LastWriteTime.QuadPart > FileBasicInformationStruct->ChangeTime.QuadPart
 543                                                 ? &FileBasicInformationStruct->LastWriteTime : &FileBasicInformationStruct->ChangeTime),
 544                                 &tmp_ULONG);
 545                 g_assert(errBOOLEAN==TRUE);
 546                 file_info->mtime=tmp_ULONG;
 547                 file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_MTIME;
 548                 }
 549
 550         if (FileBasicInformationStruct->CreationTime.QuadPart) {        /* it may be 0 if not set */
 551                 errBOOLEAN=RtlTimeToSecondsSince1970(&FileBasicInformationStruct->CreationTime,&tmp_ULONG);
 552                 g_assert(errBOOLEAN==TRUE);
 553                 file_info->ctime=tmp_ULONG;
 554                 file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_CTIME;
 555                 }
 556
 557         return GNOME_VFS_OK;
 558 }
 559
 560
 561 /* Use 'FileStandardInformationStruct' identifier instead of the logical 'FileStandardInformation'
 562  * to prevent override of enum member 'FileStandardInformation'
 563  */
 564 static GnomeVFSResult FileStandardInformationStruct_to_GnomeVFSFileInfo(GnomeVFSFileInfo *file_info,
 565                 FILE_STANDARD_INFORMATION *FileStandardInformationStruct)
 566 {
 567         file_info->size=FileStandardInformationStruct->EndOfFile.QuadPart;
 568         file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_SIZE;
 569
 570         file_info->block_count=FileStandardInformationStruct->AllocationSize.QuadPart/512;
 571         file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_BLOCK_COUNT;
 572
 573         return GNOME_VFS_OK;
 574 }
 575
 576
 577 GnomeVFSResult captive_file_slave_file_info_get(CaptiveFileObject *captive_file_object,
 578                 GnomeVFSFileInfo *file_info)
 579 {
 580 CaptiveFileSlaveObject *captive_file_slave_object;
 581 NTSTATUS err;
 582 IO_STATUS_BLOCK file_IoStatusBlock;
 583 FILE_NAME_INFORMATION *FileNameInformationStruct;
 584 FILE_BASIC_INFORMATION *FileBasicInformationStruct;
 585 FILE_STANDARD_INFORMATION *FileStandardInformationStruct;
 586 GnomeVFSResult errvfsresult;
 587 char QueryFile_buf[sizeof(FILE_NAME_INFORMATION)
 588                 +0x1000 /* max 'FileName' length, 255 should be enough */ * sizeof(WCHAR /* *FILE_ALL_INFORMATION.NameInformation.FileName */ )];
 589
 590         g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS);
 591         g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 592
 593         captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object);
 594
 595         g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 596
 597         /* ntfs.sys of NT-5.1sp1 has *(FILE_BASIC_INFORMATION *)FILE_ALL_INFORMATION.BasicInformation
 598          * size 0x28 although reactos includes and all the information says 0x24.
 599          * fastfat.sys of NT-5.1sp1 also has the 'official' sizeof 0x24.
 600          * It would be a bit of heuristic to correctly detect its expected sizeof.
 601          */
 602
 603         file_info->valid_fields=0;
 604
 605         file_info->flags=GNOME_VFS_FILE_FLAGS_LOCAL;
 606         file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_FLAGS;
 607
 608         /* query NameInformation */
 609         FileNameInformationStruct=(void *)QueryFile_buf;
 610         err=NtQueryInformationFile(
 611                         captive_file_slave_object->file_Handle, /* FileHandle */
 612                         &file_IoStatusBlock,    /* IoStatusBlock */
 613                         (gpointer)QueryFile_buf,        /* FileInformation */
 614                         sizeof(QueryFile_buf)   /* Length */
 615                                         -sizeof(*FileNameInformationStruct->FileName),  /* reserve space for a possible 0-terminator */
 616                         FileNameInformation);   /* FileInformationClass; =>FILE_NAME_INFORMATION */
 617         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 618                 return errvfsresult;
 619         g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC);
 620         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 621         errvfsresult=FileNameInformationStruct_to_GnomeVFSFileInfo(file_info,FileNameInformationStruct);
 622         g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult);
 623
 624         /* query BasicInformation */
 625         FileBasicInformationStruct=(void *)QueryFile_buf;
 626         err=NtQueryInformationFile(
 627                         captive_file_slave_object->file_Handle, /* FileHandle */
 628                         &file_IoStatusBlock,    /* IoStatusBlock */
 629                         (gpointer)QueryFile_buf,        /* FileInformation */
 630                         sizeof(QueryFile_buf),  /* Length */
 631                         FileBasicInformation);  /* FileInformationClass; =>FILE_BASIC_INFORMATION */
 632         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 633                 return errvfsresult;
 634         g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC);
 635         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 636         errvfsresult=FileBasicInformationStruct_to_GnomeVFSFileInfo(file_info,FileBasicInformationStruct);
 637         g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult);
 638
 639         /* query StandardInformation */
 640         FileStandardInformationStruct=(void *)QueryFile_buf;
 641         err=NtQueryInformationFile(
 642                         captive_file_slave_object->file_Handle, /* FileHandle */
 643                         &file_IoStatusBlock,    /* IoStatusBlock */
 644                         (gpointer)QueryFile_buf,        /* FileInformation */
 645                         sizeof(QueryFile_buf),  /* Length */
 646                         FileStandardInformation);       /* FileInformationClass; =>FILE_STANDARD_INFORMATION */
 647         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 648                 return errvfsresult;
 649         g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC);
 650         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 651         errvfsresult=FileStandardInformationStruct_to_GnomeVFSFileInfo(file_info,FileStandardInformationStruct);
 652         g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult);
 653
 654         captive_leave();
 655         return GNOME_VFS_OK;
 656 }
 657
 658
 659 GnomeVFSResult captive_file_slave_file_info_set(CaptiveFileObject *captive_file_object,
 660     const GnomeVFSFileInfo *info,GnomeVFSSetFileInfoMask mask)
 661 {
 662 CaptiveFileSlaveObject *captive_file_slave_object;
 663
 664         g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS);
 665         g_return_val_if_fail(info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 666
 667         captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object);
 668
 669         g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 670
 671         if (mask & GNOME_VFS_SET_FILE_INFO_NAME) {
 672 gchar *name_dirname,*name_basename;
 673 UNICODE_STRING *name_UnicodeString;
 674 FILE_RENAME_INFORMATION *FileRenameInformation_structp;
 675 gsize FileRenameInformation_struct_len;
 676 IO_STATUS_BLOCK file_IoStatusBlock;
 677 NTSTATUS err;
 678 GnomeVFSResult errvfsresult;
 679
 680                 /* non-existing dirname assertion */
 681                 name_dirname=g_path_get_dirname(info->name);
 682                 if (*name_dirname) {
 683                         g_assert_not_reached();
 684                         errvfsresult=GNOME_VFS_ERROR_BAD_PARAMETERS;
 685                         goto err;
 686                         }
 687
 688                 /* fully-matching basename assertion */
 689                 name_basename=g_path_get_basename(info->name);
 690                 if (strcmp(name_basename,info->name)) {
 691                         g_assert_not_reached();
 692                         errvfsresult=GNOME_VFS_ERROR_BAD_PARAMETERS;
 693                         goto err_free_name_dirname;
 694                         }
 695
 696                 name_UnicodeString=captive_utf8_to_UnicodeString_alloca(info->name);
 697                 FileRenameInformation_struct_len=sizeof(*FileRenameInformation_structp)
 698                                 +name_UnicodeString->MaximumLength;     /* ==Length+(0-terminator); is the terminator needed? */
 699
 700                 FileRenameInformation_structp=g_alloca(FileRenameInformation_struct_len);
 701                 FileRenameInformation_structp->Replace=FALSE;
 702                 FileRenameInformation_structp->RootDir=NULL;    /* we do 'simple rename' here */
 703                 FileRenameInformation_structp->FileNameLength=name_UnicodeString->Length;
 704                 memcpy(FileRenameInformation_structp->FileName,name_UnicodeString->Buffer,
 705                                 name_UnicodeString->MaximumLength);     /* ==Length+(0-terminator); is the terminator needed? */
 706
 707                 err=NtSetInformationFile(
 708                                 captive_file_slave_object->file_Handle, /* FileHandle */
 709                                 &file_IoStatusBlock,    /* IoStatusBlock */
 710                                 FileRenameInformation_structp,  /* FileInformation */
 711                                 FileRenameInformation_struct_len,       /* Length */
 712                                 FileRenameInformation); /* FileInformationClass */
 713                 if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 714                         goto err_free_name_basename;
 715
 716 err_free_name_basename:
 717                 g_free(name_basename);
 718 err_free_name_dirname:
 719                 g_free(name_dirname);
 720 err:
 721
 722                 if (errvfsresult!=GNOME_VFS_OK)
 723                         return errvfsresult;
 724                 g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 725                 }
 726
 727         if (mask & (GNOME_VFS_SET_FILE_INFO_PERMISSIONS | GNOME_VFS_SET_FILE_INFO_TIME)) {
 728 char FileBasicInformation_buf[sizeof(FILE_BASIC_INFORMATION)+4];
 729 FILE_BASIC_INFORMATION *FileBasicInformationp=(FILE_BASIC_INFORMATION *)FileBasicInformation_buf;
 730 IO_STATUS_BLOCK file_IoStatusBlock;
 731 NTSTATUS err;
 732
 733                 /* FIXME: Everywhere is is the declaration with 4xLARGE_INTEGER+1xULONG==36 bytes
 734                  * but the precompiled ext2fsd.sys wants 40 bytes - why?
 735                  * The same case applies to ntfs.sys of NT-5.1sp1.
 736                  */
 737                 g_assert(sizeof(FILE_BASIC_INFORMATION)==36);
 738                 g_assert(sizeof(FileBasicInformation_buf)==40);
 739                 err=NtQueryInformationFile(
 740                                 captive_file_slave_object->file_Handle, /* FileHandle */
 741                                 &file_IoStatusBlock,    /* IoStatusBlock */
 742                                 FileBasicInformation_buf,       /* FileInformation */
 743                                 sizeof(FileBasicInformation_buf),       /* Length */
 744                                 FileBasicInformation);  /* FileInformationClass */
 745                 g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 746
 747                 if (mask & GNOME_VFS_SET_FILE_INFO_PERMISSIONS) {
 748                         FileBasicInformationp->FileAttributes&=~FILE_ATTRIBUTE_READONLY;
 749                         g_assert(info->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS);
 750                         if (!(info->permissions&0200))
 751                                 FileBasicInformationp->FileAttributes|=FILE_ATTRIBUTE_READONLY;
 752                         }
 753
 754                 if (mask & GNOME_VFS_SET_FILE_INFO_TIME) {
 755                         g_assert(info->valid_fields & (0
 756                                         | GNOME_VFS_FILE_INFO_FIELDS_ATIME
 757                                         | GNOME_VFS_FILE_INFO_FIELDS_MTIME
 758                                         | GNOME_VFS_FILE_INFO_FIELDS_CTIME));
 759                         if (info->valid_fields&GNOME_VFS_FILE_INFO_FIELDS_ATIME) {
 760                                 RtlSecondsSince1970ToTime(
 761                                                 info->atime,    /* SecondsSince1970 */
 762                                                 &FileBasicInformationp->LastAccessTime);        /* Time */
 763                                 }
 764                         if (info->valid_fields&GNOME_VFS_FILE_INFO_FIELDS_MTIME) {
 765                                 RtlSecondsSince1970ToTime(
 766                                                 info->mtime,    /* SecondsSince1970 */
 767                                                 &FileBasicInformationp->LastWriteTime); /* Time */
 768                                 FileBasicInformationp->ChangeTime=FileBasicInformationp->LastWriteTime;
 769                                 }
 770                         if (info->valid_fields&GNOME_VFS_FILE_INFO_FIELDS_CTIME) {
 771                                 RtlSecondsSince1970ToTime(
 772                                                 info->ctime,    /* SecondsSince1970 */
 773                                                 &FileBasicInformationp->CreationTime);  /* Time */
 774                                 }
 775                         }
 776
 777                 err=NtSetInformationFile(
 778                                 captive_file_slave_object->file_Handle, /* FileHandle */
 779                                 &file_IoStatusBlock,    /* IoStatusBlock */
 780                                 FileBasicInformation_buf,       /* FileInformation */
 781                                 sizeof(FileBasicInformation_buf),       /* Length */
 782                                 FileBasicInformation);  /* FileInformationClass */
 783                 g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 784                 }
 785
 786         if (mask & GNOME_VFS_SET_FILE_INFO_OWNER) {
 787                 /* FIXME: g_assert(info->valid_fields & ???); */
 788                 /* owner ignored for W32 */
 789                 }
 790
 791         captive_leave();
 792         return GNOME_VFS_OK;
 793 }
 794
 795
 796 GnomeVFSResult captive_file_slave_truncate(CaptiveFileObject *captive_file_object,GnomeVFSFileSize file_size)
 797 {
 798 CaptiveFileSlaveObject *captive_file_slave_object;
 799 NTSTATUS err;
 800 FILE_END_OF_FILE_INFORMATION FileEndOfFileInformation_struct;
 801 IO_STATUS_BLOCK file_IoStatusBlock;
 802 GnomeVFSResult errvfsresult;
 803
 804         g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object),GNOME_VFS_ERROR_BAD_PARAMETERS);
 805
 806         captive_file_slave_object=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object);
 807
 808         g_return_val_if_fail(captive_file_slave_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 809
 810         FileEndOfFileInformation_struct.EndOfFile.QuadPart=file_size;
 811
 812         err=NtSetInformationFile(
 813                         captive_file_slave_object->file_Handle, /* FileHandle */
 814                         &file_IoStatusBlock,    /* IoStatusBlock */
 815                         &FileEndOfFileInformation_struct,       /* FileInformation */
 816                         sizeof(FileEndOfFileInformation_struct),        /* Length */
 817                         FileEndOfFileInformation);      /* FileInformationClass */
 818         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 819                 return errvfsresult;
 820         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 821
 822         captive_leave();
 823         return GNOME_VFS_OK;
 824 }
 825
 826
 827 GnomeVFSResult captive_file_slave_move
 828                 (CaptiveFileObject *captive_file_object_old,const gchar *pathname_new,gboolean force_replace)
 829 {
 830 CaptiveFileSlaveObject *captive_file_slave_object_old;
 831 NTSTATUS err;
 832 FILE_RENAME_INFORMATION *FileRenameInformation_structp;
 833 IO_STATUS_BLOCK file_IoStatusBlock;
 834 GnomeVFSResult errvfsresult;
 835 OBJECT_ATTRIBUTES pathname_new_ObjectAttributes;
 836
 837         g_return_val_if_fail(CAPTIVE_FILE_SLAVE_IS_OBJECT(captive_file_object_old),GNOME_VFS_ERROR_BAD_PARAMETERS);
 838         g_return_val_if_fail(pathname_new!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 839
 840         captive_file_slave_object_old=CAPTIVE_FILE_SLAVE_OBJECT(captive_file_object_old);
 841
 842         g_return_val_if_fail(captive_file_slave_object_old->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 843
 844         errvfsresult=captive_ObjectAttributes_init(pathname_new,&pathname_new_ObjectAttributes);
 845         g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult);
 846
 847         FileRenameInformation_structp=
 848                         g_alloca(sizeof(*FileRenameInformation_structp)+pathname_new_ObjectAttributes.ObjectName->MaximumLength);
 849         FileRenameInformation_structp->Replace=force_replace;
 850         FileRenameInformation_structp->RootDir=0;       /* AFAIK never set by orig W32 */
 851         FileRenameInformation_structp->FileNameLength=pathname_new_ObjectAttributes.ObjectName->Length;
 852         memcpy(FileRenameInformation_structp->FileName,pathname_new_ObjectAttributes.ObjectName->Buffer,
 853                         pathname_new_ObjectAttributes.ObjectName->MaximumLength);
 854
 855         err=NtSetInformationFile(
 856                         captive_file_slave_object_old->file_Handle,     /* FileHandle */
 857                         &file_IoStatusBlock,    /* IoStatusBlock */
 858                         FileRenameInformation_structp,  /* FileInformation */
 859                         sizeof(*FileRenameInformation_structp)+pathname_new_ObjectAttributes.ObjectName->MaximumLength, /* Length */
 860                         FileRenameInformation); /* FileInformationClass */
 861         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 862                 goto err_free_ObjectAttributes;
 863         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 864
 865         errvfsresult=GNOME_VFS_OK;
 866
 867 err_free_ObjectAttributes:
 868         g_free(pathname_new_ObjectAttributes.ObjectName);       /* left from captive_file_slave_uri_parent_init() */
 869
 870         captive_leave();
 871         return errvfsresult;
 872 }