src/libcaptive/client/file.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 "captive/client-file.h"        /* self */
  23 #include "lib.h"
  24 #include <glib/gmessages.h>
  25 #include "captive/unicode.h"
  26 #include "reactos/ntos/types.h" /* for HANDLE */
  27 #include "reactos/ddk/iotypes.h"        /* for IO_STATUS_BLOCK */
  28 #include "reactos/ddk/iofuncs.h"        /* for IoCreateFile() */
  29 #include "captive/sandbox.h"
  30 #include "result.h"
  31 #include "captive/client-directory.h"
  32 #include "reactos/ddk/obfuncs.h"        /* for ObReferenceObjectByHandle() */
  33 #include "captive/macros.h"
  34
  35
  36 static gpointer captive_file_object_parent_class=NULL;
  37
  38
  39 static GnomeVFSResult captive_file_close(CaptiveFileObject *captive_file_object);
  40
  41 static void captive_file_object_finalize(CaptiveFileObject *captive_file_object)
  42 {
  43 GnomeVFSResult errvfsresult;
  44
  45         g_return_if_fail(captive_file_object!=NULL);
  46
  47         errvfsresult=captive_file_close(captive_file_object);
  48         g_assert(errvfsresult==GNOME_VFS_OK);
  49
  50         G_OBJECT_CLASS(captive_file_object_parent_class)->finalize((GObject *)captive_file_object);
  51 }
  52
  53
  54 static void captive_file_object_class_init(CaptiveFileObjectClass *class)
  55 {
  56 GObjectClass *gobject_class=G_OBJECT_CLASS(class);
  57
  58         captive_file_object_parent_class=g_type_class_ref(G_TYPE_OBJECT);
  59         gobject_class->finalize=(void (*)(GObject *object))captive_file_object_finalize;
  60 }
  61
  62
  63 static void captive_file_object_init(CaptiveFileObject *captive_file_object)
  64 {
  65         captive_file_object->file_Handle=NULL;
  66 }
  67
  68
  69 GType captive_file_object_get_type(void)
  70 {
  71 static GType captive_file_object_type=0;
  72
  73         if (!captive_file_object_type) {
  74 static const GTypeInfo captive_file_object_info={
  75                                 sizeof(CaptiveFileObjectClass),
  76                                 NULL,   /* base_init */
  77                                 NULL,   /* base_finalize */
  78                                 (GClassInitFunc)captive_file_object_class_init,
  79                                 NULL,   /* class_finalize */
  80                                 NULL,   /* class_data */
  81                                 sizeof(CaptiveFileObject),
  82                                 5,      /* n_preallocs */
  83                                 (GInstanceInitFunc)captive_file_object_init,
  84                                 };
  85
  86                 captive_file_object_type=g_type_register_static(G_TYPE_OBJECT,
  87                                 "CaptiveFileObject",&captive_file_object_info,0);
  88                 }
  89
  90         return captive_file_object_type;
  91 }
  92
  93
  94 static GnomeVFSResult captive_file_new_internal(CaptiveFileObject **captive_file_object_return,
  95                 const gchar *pathname,GnomeVFSOpenMode mode,gboolean create,gboolean create_exclusive,guint create_perm)
  96 {
  97 IO_STATUS_BLOCK file_IoStatusBlock;
  98 GnomeVFSResult errvfsresult;
  99 OBJECT_ATTRIBUTES file_ObjectAttributes;
 100 HANDLE file_Handle;
 101 CaptiveFileObject *captive_file_object;
 102 NTSTATUS err;
 103
 104         if (CAPTIVE_IS_SANDBOX_PARENT())
 105                 return captive_sandbox_parent_file_new_open(captive_file_object_return,pathname,mode);
 106
 107         g_return_val_if_fail(captive_file_object_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 108         g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 109
 110         *captive_file_object_return=NULL;
 111
 112         errvfsresult=captive_ObjectAttributes_init(pathname,&file_ObjectAttributes);
 113         g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult);
 114
 115         /* open */
 116         err=IoCreateFile(
 117                         &file_Handle,   /* FileHandle */
 118                         0
 119                                         |(!(mode&GNOME_VFS_OPEN_READ ) ? 0 : FILE_READ_DATA)
 120                                         |(!(mode&GNOME_VFS_OPEN_WRITE) ? 0 : FILE_WRITE_DATA | FILE_APPEND_DATA | FILE_WRITE_ATTRIBUTES)
 121                                         |(  mode!=0                    ? 0 : FILE_READ_ATTRIBUTES)
 122                                         ,       /* DesiredAccess */
 123                         &file_ObjectAttributes, /* ObjectAttributes */
 124                         &file_IoStatusBlock,    /* IoStatusBlock */
 125                         NULL,   /* AllocationSize; ignored for open */
 126                         (!create || create_perm&0200 ? FILE_ATTRIBUTE_NORMAL: FILE_ATTRIBUTE_READONLY), /* FileAttributes; ignored for open */
 127                         (!create || !create_exclusive   /* ShareAccess; 0 means exclusive */
 128                                         ? (FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE)
 129                                         : 0),
 130                         (!create ? FILE_OPEN : FILE_CREATE),    /* CreateDisposition */
 131                         /* FILE_SYNCHRONOUS_IO_{,NON}ALERT: We need to allow W32 filesystem
 132                                  * any waits to not to let it return STATUS_CANT_WAIT us.
 133                                  * Alertability should have only effect on asynchronous events
 134                                  * from KeWaitForSingleObject() by setting/clearing its parameter 'Alertable'.
 135                                  */
 136                         FILE_SYNCHRONOUS_IO_ALERT,      /* CreateOptions */
 137                         NULL,   /* EaBuffer */
 138                         0,      /* EaLength */
 139                         CreateFileTypeNone,     /* CreateFileType */
 140                         NULL,   /* ExtraCreateParameters */
 141                         0);     /* Options */
 142         g_free(file_ObjectAttributes.ObjectName);       /* left from captive_file_uri_parent_init() */
 143         g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC);
 144         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 145                 return errvfsresult;
 146         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 147         g_return_val_if_fail(file_IoStatusBlock.Information
 148                                         ==(!create ? FILE_OPENED : FILE_CREATED),
 149                         GNOME_VFS_ERROR_GENERIC);
 150
 151         captive_file_object=g_object_new(
 152                         CAPTIVE_FILE_TYPE_OBJECT,       /* object_type */
 153                         NULL);  /* first_property_name; FIXME: support properties */
 154
 155         captive_file_object->file_Handle=file_Handle;
 156         captive_file_object->offset=0;
 157
 158         *captive_file_object_return=captive_file_object;
 159         return GNOME_VFS_OK;
 160 }
 161
 162
 163 GnomeVFSResult captive_file_new_open
 164                 (CaptiveFileObject **captive_file_object_return,const gchar *pathname,GnomeVFSOpenMode mode)
 165 {
 166         g_return_val_if_fail(captive_file_object_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 167         g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 168
 169         return captive_file_new_internal(captive_file_object_return,pathname,mode,
 170                         FALSE,  /* create */
 171                         FALSE,  /* create_exclusive; ignored */
 172                         0);     /* create_perm; ignored */
 173 }
 174
 175
 176 GnomeVFSResult captive_file_new_create
 177                 (CaptiveFileObject **captive_file_object_return,const gchar *pathname,GnomeVFSOpenMode mode,gboolean exclusive,guint perm)
 178 {
 179         g_return_val_if_fail(captive_file_object_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 180         g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 181
 182         return captive_file_new_internal(captive_file_object_return,pathname,mode,
 183                         TRUE,   /* create */
 184                         exclusive,      /* create_exclusive */
 185                         perm);  /* create_perm */
 186 }
 187
 188
 189 static GnomeVFSResult captive_file_close(CaptiveFileObject *captive_file_object)
 190 {
 191 NTSTATUS err;
 192 HANDLE file_Handle;
 193
 194         if (CAPTIVE_IS_SANDBOX_PARENT())
 195                 return captive_sandbox_parent_file_close(captive_file_object);
 196
 197         g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 198         g_return_val_if_fail(captive_file_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);    /* already closed */
 199
 200         file_Handle=captive_file_object->file_Handle;
 201         captive_file_object->file_Handle=NULL;
 202         err=NtClose(file_Handle);
 203         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 204
 205         return GNOME_VFS_OK;
 206 }
 207
 208
 209 GnomeVFSResult captive_file_read(CaptiveFileObject *captive_file_object,
 210                 gpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_read_return)
 211 {
 212 NTSTATUS err;
 213 IO_STATUS_BLOCK file_IoStatusBlock;
 214 LARGE_INTEGER file_offset;
 215 GnomeVFSResult errvfsresult;
 216
 217         if (CAPTIVE_IS_SANDBOX_PARENT())
 218                 return captive_sandbox_parent_file_read(captive_file_object,buffer,num_bytes,bytes_read_return);
 219
 220         g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 221         g_return_val_if_fail(captive_file_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 222         g_return_val_if_fail(buffer!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 223         g_return_val_if_fail(bytes_read_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 224         g_return_val_if_fail(num_bytes==(ULONG)num_bytes,GNOME_VFS_ERROR_BAD_PARAMETERS);
 225
 226         file_offset.QuadPart=captive_file_object->offset;
 227         err=NtReadFile(
 228                         captive_file_object->file_Handle,       /* FileHandle */
 229                         NULL,   /* EventHandle; completion signalling; optional */
 230                         NULL,   /* ApcRoutine; optional */
 231                         NULL,   /* ApcContext; optional */
 232                         &file_IoStatusBlock,    /* IoStatusBlock */
 233                         buffer, /* Buffer */
 234                         num_bytes,      /* Length */
 235                         &file_offset,   /* ByteOffset */
 236                         NULL);  /* Key; NULL means no file locking key */
 237         if (err==STATUS_END_OF_FILE) {
 238                 g_return_val_if_fail(file_IoStatusBlock.Status==STATUS_END_OF_FILE,GNOME_VFS_ERROR_GENERIC);
 239                 g_return_val_if_fail(file_IoStatusBlock.Information==0,GNOME_VFS_ERROR_GENERIC);
 240                 *bytes_read_return=0;
 241                 return GNOME_VFS_ERROR_EOF;
 242                 }
 243         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 244                 return errvfsresult;
 245         g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC);
 246         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 247         g_return_val_if_fail(file_IoStatusBlock.Information<=num_bytes,GNOME_VFS_ERROR_GENERIC);
 248
 249         captive_file_object->offset+=file_IoStatusBlock.Information;
 250         *bytes_read_return=file_IoStatusBlock.Information;
 251         return GNOME_VFS_OK;
 252 }
 253
 254
 255 GnomeVFSResult captive_file_write(CaptiveFileObject *captive_file_object,
 256                 gconstpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_written_return)
 257 {
 258 NTSTATUS err;
 259 IO_STATUS_BLOCK file_IoStatusBlock;
 260 LARGE_INTEGER file_offset;
 261
 262         if (CAPTIVE_IS_SANDBOX_PARENT())
 263                 return captive_sandbox_parent_file_write(captive_file_object,buffer,num_bytes,bytes_written_return);
 264
 265         g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 266         g_return_val_if_fail(captive_file_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 267         g_return_val_if_fail(buffer!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 268         g_return_val_if_fail(bytes_written_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 269         g_return_val_if_fail(num_bytes==(ULONG)num_bytes,GNOME_VFS_ERROR_BAD_PARAMETERS);
 270
 271         file_offset.QuadPart=captive_file_object->offset;
 272         err=NtWriteFile(
 273                         captive_file_object->file_Handle,       /* FileHandle */
 274                         NULL,   /* Event; completion signalling; optional */
 275                         NULL,   /* ApcRoutine; optional */
 276                         NULL,   /* ApcContext; optional */
 277                         &file_IoStatusBlock,    /* IoStatusBlock */
 278                         (gpointer /* de-const */ )buffer,       /* Buffer */
 279                         num_bytes,      /* Length */
 280                         &file_offset,   /* ByteOffset */
 281                         NULL);  /* Key; NULL means no file locking key */
 282         g_return_val_if_fail(NT_SUCCESS(err)==NT_SUCCESS(file_IoStatusBlock.Status),GNOME_VFS_ERROR_GENERIC);
 283         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 284         g_return_val_if_fail(file_IoStatusBlock.Information==num_bytes,GNOME_VFS_ERROR_GENERIC);
 285
 286         captive_file_object->offset+=file_IoStatusBlock.Information;
 287         *bytes_written_return=file_IoStatusBlock.Information;
 288         return GNOME_VFS_OK;
 289 }
 290
 291
 292 GnomeVFSResult captive_file_seek
 293                 (CaptiveFileObject *captive_file_object,GnomeVFSSeekPosition whence,GnomeVFSFileOffset offset)
 294 {
 295         if (CAPTIVE_IS_SANDBOX_PARENT())
 296                 return captive_sandbox_parent_file_seek(captive_file_object,whence,offset);
 297
 298         g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 299         g_return_val_if_fail(captive_file_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 300
 301         switch (whence) {
 302                 case GNOME_VFS_SEEK_START:
 303                         captive_file_object->offset=offset;
 304                         break;
 305                 case GNOME_VFS_SEEK_CURRENT:
 306                         if (0
 307                                         || (offset>0 && (captive_file_object->offset+offset)<captive_file_object->offset)
 308                                         || (offset<0 && (captive_file_object->offset+offset)>captive_file_object->offset))
 309                                 return GNOME_VFS_ERROR_BAD_PARAMETERS;
 310                         captive_file_object->offset+=offset;
 311                         break;
 312                 case GNOME_VFS_SEEK_END:
 313                         g_assert_not_reached(); /* NOT IMPLEMENTED YET */
 314                         break;
 315                 default:
 316                         g_return_val_if_reached(GNOME_VFS_ERROR_BAD_PARAMETERS);
 317                 }
 318
 319         return GNOME_VFS_OK;
 320 }
 321
 322
 323 GnomeVFSResult captive_file_tell(CaptiveFileObject *captive_file_object,GnomeVFSFileOffset *offset_return)
 324 {
 325         if (CAPTIVE_IS_SANDBOX_PARENT())
 326                 return captive_sandbox_parent_file_tell(captive_file_object,offset_return);
 327
 328         g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 329         g_return_val_if_fail(captive_file_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 330         g_return_val_if_fail(offset_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 331
 332         *offset_return=captive_file_object->offset;
 333         return GNOME_VFS_OK;
 334 }
 335
 336
 337 GnomeVFSResult captive_file_remove(CaptiveFileObject *captive_file_object)
 338 {
 339 NTSTATUS err;
 340 FILE_DISPOSITION_INFORMATION FileDispositionInformation_struct;
 341 IO_STATUS_BLOCK file_IoStatusBlock;
 342 GnomeVFSResult errvfsresult;
 343
 344         g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 345         g_return_val_if_fail(captive_file_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 346
 347         FileDispositionInformation_struct.DoDeleteFile=TRUE;
 348
 349         err=NtSetInformationFile(
 350                         captive_file_object->file_Handle,       /* FileHandle */
 351                         &file_IoStatusBlock,    /* IoStatusBlock */
 352                         &FileDispositionInformation_struct,     /* FileInformation */
 353                         sizeof(FileDispositionInformation_struct),      /* Length */
 354                         FileDispositionInformation);    /* FileInformationClass */
 355         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 356                 return errvfsresult;
 357         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 358
 359         return GNOME_VFS_OK;
 360 }
 361
 362
 363 /* Use 'FileAllInformationStruct' identifier instead of the logical 'FileAllInformation'
 364  * to prevent override of enum member 'FileAllInformation'
 365  */
 366 static GnomeVFSResult FileAllInformationStruct_to_GnomeVFSFileInfo(GnomeVFSFileInfo *file_info,
 367                 FILE_ALL_INFORMATION *FileAllInformationStruct,IO_STATUS_BLOCK *IoStatusBlock)
 368 {
 369 UNICODE_STRING FileName_UnicodeString;
 370 BOOLEAN errBOOLEAN;
 371 ULONG tmp_ULONG;
 372
 373         g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_GENERIC);
 374         g_return_val_if_fail(FileAllInformationStruct!=NULL,GNOME_VFS_ERROR_GENERIC);
 375
 376         g_return_val_if_fail(NT_SUCCESS(IoStatusBlock->Status),GNOME_VFS_ERROR_GENERIC);
 377
 378         file_info->valid_fields=0;
 379
 380         FileName_UnicodeString.Length=FileAllInformationStruct->NameInformation.FileNameLength;
 381         FileName_UnicodeString.MaximumLength=FileAllInformationStruct->NameInformation.FileNameLength
 382                         +sizeof(*FileAllInformationStruct->NameInformation.FileName);   /* 0-terminator */
 383         g_assert((gpointer)(((char *)FileAllInformationStruct->NameInformation.FileName)+FileName_UnicodeString.Length)
 384                         <=(gpointer)(((char *)FileAllInformationStruct)+IoStatusBlock->Information));
 385                                         /* ensure we fit below '->IoStatusBlock->Information' at least without the 0-terminator */
 386         FileAllInformationStruct->NameInformation.FileName[FileAllInformationStruct->NameInformation.FileNameLength
 387                         /sizeof(*FileAllInformationStruct->NameInformation.FileName)]=0;        /* 0-terminate it */
 388         FileName_UnicodeString.Buffer=FileAllInformationStruct->NameInformation.FileName;
 389         file_info->name=captive_UnicodeString_to_utf8_malloc(&FileName_UnicodeString);
 390         /* '->name' assumed for 'file_info->valid_fields' */
 391
 392         /* FIXME: What is 'FILE_ATTRIBUTE_NORMAL'? */
 393         switch (FileAllInformationStruct->BasicInformation.FileAttributes & (0
 394                         | FILE_ATTRIBUTE_DIRECTORY
 395                         | FILE_ATTRIBUTE_DEVICE)) {
 396                 case 0:                        file_info->type=GNOME_VFS_FILE_TYPE_REGULAR;   break;
 397                 case FILE_ATTRIBUTE_DIRECTORY: file_info->type=GNOME_VFS_FILE_TYPE_DIRECTORY; break;
 398                 case FILE_ATTRIBUTE_DEVICE:    file_info->type=GNOME_VFS_FILE_TYPE_SOCKET;
 399                         /* or GNOME_VFS_FILE_TYPE_CHARACTER_DEVICE or GNOME_VFS_FILE_TYPE_BLOCK_DEVICE ? */
 400                         break;
 401                 default:                       file_info->type=GNOME_VFS_FILE_TYPE_UNKNOWN;   break;
 402                 }
 403         file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_TYPE;
 404
 405         /* we use 0600 for r/w files, 0400 for FILE_ATTRIBUTE_READONLY */
 406         file_info->permissions=GNOME_VFS_PERM_USER_READ;
 407         if (file_info->type==GNOME_VFS_FILE_TYPE_DIRECTORY)
 408                 file_info->permissions|=GNOME_VFS_PERM_USER_EXEC;
 409         if (!(FileAllInformationStruct->BasicInformation.FileAttributes & FILE_ATTRIBUTE_READONLY))
 410                 file_info->permissions|=GNOME_VFS_PERM_USER_WRITE;
 411         file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS;
 412
 413         file_info->size=FileAllInformationStruct->StandardInformation.EndOfFile.QuadPart;
 414         file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_SIZE;
 415
 416         file_info->block_count=FileAllInformationStruct->StandardInformation.AllocationSize.QuadPart/512;
 417         file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_BLOCK_COUNT;
 418
 419         file_info->flags=GNOME_VFS_FILE_FLAGS_LOCAL;
 420         file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_FLAGS;
 421
 422         if (FileAllInformationStruct->BasicInformation.LastAccessTime.QuadPart) {       /* it may be 0 if not set */
 423                 errBOOLEAN=RtlTimeToSecondsSince1970(&FileAllInformationStruct->BasicInformation.LastAccessTime,&tmp_ULONG);
 424                 g_assert(errBOOLEAN==TRUE);
 425                 file_info->atime=tmp_ULONG;
 426                 file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_ATIME;
 427                 }
 428
 429         /* it may be 0 if not set */
 430         if (FileAllInformationStruct->BasicInformation.LastWriteTime.QuadPart || FileAllInformationStruct->BasicInformation.ChangeTime.QuadPart) {
 431                 errBOOLEAN=RtlTimeToSecondsSince1970(
 432                                 /* take the more recent (==bigger) time: */
 433                                 (FileAllInformationStruct->BasicInformation.LastWriteTime.QuadPart > FileAllInformationStruct->BasicInformation.ChangeTime.QuadPart
 434                                                 ? &FileAllInformationStruct->BasicInformation.LastWriteTime : &FileAllInformationStruct->BasicInformation.ChangeTime),
 435                                 &tmp_ULONG);
 436                 g_assert(errBOOLEAN==TRUE);
 437                 file_info->mtime=tmp_ULONG;
 438                 file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_MTIME;
 439                 }
 440
 441         if (FileAllInformationStruct->BasicInformation.CreationTime.QuadPart) { /* it may be 0 if not set */
 442                 errBOOLEAN=RtlTimeToSecondsSince1970(&FileAllInformationStruct->BasicInformation.CreationTime,&tmp_ULONG);
 443                 g_assert(errBOOLEAN==TRUE);
 444                 file_info->ctime=tmp_ULONG;
 445                 file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_CTIME;
 446                 }
 447
 448         return GNOME_VFS_OK;
 449 }
 450
 451
 452 GnomeVFSResult captive_file_file_info_get(CaptiveFileObject *captive_file_object,
 453                 GnomeVFSFileInfo *file_info)
 454 {
 455 NTSTATUS err;
 456 IO_STATUS_BLOCK file_IoStatusBlock;
 457 FILE_ALL_INFORMATION *FileAllInformationStruct;
 458 GnomeVFSResult errvfsresult;
 459 char QueryFile_buf[sizeof(FILE_ALL_INFORMATION)
 460                 +0x1000 /* max 'FileName' length, 255 should be enough */ * sizeof(WCHAR /* *FILE_ALL_INFORMATION.NameInformation.FileName */ )];
 461
 462         g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 463         g_return_val_if_fail(captive_file_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 464         g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 465
 466         /* query */
 467         FileAllInformationStruct=(void *)QueryFile_buf;
 468         err=NtQueryInformationFile(
 469                         captive_file_object->file_Handle,       /* FileHandle */
 470                         &file_IoStatusBlock,    /* IoStatusBlock */
 471                         (gpointer)QueryFile_buf,        /* FileInformation */
 472                         sizeof(QueryFile_buf)   /* Length */
 473                                         -sizeof(*FileAllInformationStruct->NameInformation.FileName),   /* reserve space for 0-terminator */
 474                         FileAllInformation);    /* FileInformationClass; =>FILE_ALL_INFORMATION */
 475         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 476                 return errvfsresult;
 477         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 478
 479         /* process gathered info */
 480         errvfsresult=FileAllInformationStruct_to_GnomeVFSFileInfo(file_info,FileAllInformationStruct,
 481                         &file_IoStatusBlock);
 482         g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult);
 483
 484         return GNOME_VFS_OK;
 485 }
 486
 487
 488 GnomeVFSResult captive_file_file_info_set(CaptiveFileObject *captive_file_object,
 489     const GnomeVFSFileInfo *info,GnomeVFSSetFileInfoMask mask)
 490 {
 491         g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 492         g_return_val_if_fail(captive_file_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 493         g_return_val_if_fail(info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 494
 495         if (mask & GNOME_VFS_SET_FILE_INFO_NAME) {
 496 gchar *name_basename,*name_dirname;
 497 UNICODE_STRING *name_UnicodeString;
 498 FILE_RENAME_INFORMATION *FileRenameInformation_structp;
 499 gsize FileRenameInformation_struct_len;
 500 IO_STATUS_BLOCK file_IoStatusBlock;
 501 NTSTATUS err;
 502 GnomeVFSResult errvfsresult;
 503
 504                 /* non-existing dirname assertion */
 505                 name_dirname=g_path_get_dirname(info->name);
 506                 if (strcmp(name_basename,info->name)) {
 507                         g_assert_not_reached();
 508                         errvfsresult=GNOME_VFS_ERROR_BAD_PARAMETERS;
 509                         goto err_free_name_dirname;
 510                         }
 511
 512                 /* fully-matching basename assertion */
 513                 name_basename=g_path_get_basename(info->name);
 514                 if (*name_basename) {
 515                         g_assert_not_reached();
 516                         errvfsresult=GNOME_VFS_ERROR_BAD_PARAMETERS;
 517                         goto err_free_name_basename;
 518                         }
 519
 520                 name_UnicodeString=captive_utf8_to_UnicodeString_alloca(info->name);
 521                 FileRenameInformation_struct_len=sizeof(*FileRenameInformation_structp)
 522                                 +name_UnicodeString->MaximumLength;     /* ==Length+(0-terminator); is the terminator needed? */
 523
 524                 FileRenameInformation_structp=g_alloca(FileRenameInformation_struct_len);
 525                 FileRenameInformation_structp->Replace=FALSE;
 526                 FileRenameInformation_structp->RootDir=NULL;    /* we do 'simple rename' here */
 527                 FileRenameInformation_structp->FileNameLength=name_UnicodeString->Length;
 528                 memcpy(FileRenameInformation_structp->FileName,name_UnicodeString->Buffer,
 529                                 name_UnicodeString->MaximumLength);     /* ==Length+(0-terminator); is the terminator needed? */
 530
 531                 err=NtSetInformationFile(
 532                                 captive_file_object->file_Handle,       /* FileHandle */
 533                                 &file_IoStatusBlock,    /* IoStatusBlock */
 534                                 FileRenameInformation_structp,  /* FileInformation */
 535                                 FileRenameInformation_struct_len,       /* Length */
 536                                 FileRenameInformation); /* FileInformationClass */
 537                 if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) {
 538                         g_assert_not_reached();
 539                         errvfsresult=GNOME_VFS_ERROR_GENERIC;
 540                         goto err_free_name_basename;
 541                         }
 542
 543                 errvfsresult=GNOME_VFS_OK;
 544
 545 err_free_name_basename:
 546                 g_free(name_basename);
 547 err_free_name_dirname:
 548                 g_free(name_dirname);
 549
 550                 if (errvfsresult!=GNOME_VFS_OK)
 551                         return errvfsresult;
 552                 }
 553
 554         if (mask & (GNOME_VFS_SET_FILE_INFO_PERMISSIONS | GNOME_VFS_SET_FILE_INFO_TIME)) {
 555 FILE_BASIC_INFORMATION FileBasicInformation_struct;
 556 IO_STATUS_BLOCK file_IoStatusBlock;
 557 NTSTATUS err;
 558
 559                 err=NtQueryInformationFile(
 560                                 captive_file_object->file_Handle,       /* FileHandle */
 561                                 &file_IoStatusBlock,    /* IoStatusBlock */
 562                                 &FileBasicInformation_struct,   /* FileInformation */
 563                                 sizeof(FileBasicInformation_struct),    /* Length */
 564                                 FileBasicInformation);  /* FileInformationClass */
 565                 g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 566
 567                 if (mask & GNOME_VFS_SET_FILE_INFO_PERMISSIONS) {
 568                         FileBasicInformation_struct.FileAttributes&=~FILE_ATTRIBUTE_READONLY;
 569                         g_assert(info->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS);
 570                         if (!(info->permissions&0200))
 571                                 FileBasicInformation_struct.FileAttributes|=FILE_ATTRIBUTE_READONLY;
 572                         }
 573
 574                 if (mask & GNOME_VFS_SET_FILE_INFO_TIME) {
 575                         g_assert(info->valid_fields & (0
 576                                         | GNOME_VFS_FILE_INFO_FIELDS_ATIME
 577                                         | GNOME_VFS_FILE_INFO_FIELDS_MTIME
 578                                         | GNOME_VFS_FILE_INFO_FIELDS_CTIME));
 579                         if (info->valid_fields&GNOME_VFS_FILE_INFO_FIELDS_ATIME) {
 580                                 RtlSecondsSince1970ToTime(
 581                                                 info->atime,    /* SecondsSince1970 */
 582                                                 &FileBasicInformation_struct.LastAccessTime);   /* Time */
 583                                 }
 584                         if (info->valid_fields&GNOME_VFS_FILE_INFO_FIELDS_MTIME) {
 585                                 RtlSecondsSince1970ToTime(
 586                                                 info->mtime,    /* SecondsSince1970 */
 587                                                 &FileBasicInformation_struct.LastWriteTime);    /* Time */
 588                                 FileBasicInformation_struct.ChangeTime=FileBasicInformation_struct.LastWriteTime;
 589                                 }
 590                         if (info->valid_fields&GNOME_VFS_FILE_INFO_FIELDS_CTIME) {
 591                                 RtlSecondsSince1970ToTime(
 592                                                 info->ctime,    /* SecondsSince1970 */
 593                                                 &FileBasicInformation_struct.CreationTime);     /* Time */
 594                                 }
 595                         }
 596
 597                 err=NtSetInformationFile(
 598                                 captive_file_object->file_Handle,       /* FileHandle */
 599                                 &file_IoStatusBlock,    /* IoStatusBlock */
 600                                 &FileBasicInformation_struct,   /* FileInformation */
 601                                 sizeof(FileBasicInformation_struct),    /* Length */
 602                                 FileBasicInformation);  /* FileInformationClass */
 603                 g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 604                 }
 605
 606         if (mask & GNOME_VFS_SET_FILE_INFO_OWNER) {
 607                 /* FIXME: g_assert(info->valid_fields & ???); */
 608                 /* owner ignored for W32 */
 609                 }
 610
 611         return GNOME_VFS_OK;
 612 }
 613
 614
 615 GnomeVFSResult captive_file_truncate(CaptiveFileObject *captive_file_object,GnomeVFSFileSize file_size)
 616 {
 617 NTSTATUS err;
 618 FILE_END_OF_FILE_INFORMATION FileEndOfFileInformation_struct;
 619 IO_STATUS_BLOCK file_IoStatusBlock;
 620 GnomeVFSResult errvfsresult;
 621
 622         g_return_val_if_fail(captive_file_object!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 623         g_return_val_if_fail(captive_file_object->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 624
 625         FileEndOfFileInformation_struct.EndOfFile.QuadPart=file_size;
 626
 627         err=NtSetInformationFile(
 628                         captive_file_object->file_Handle,       /* FileHandle */
 629                         &file_IoStatusBlock,    /* IoStatusBlock */
 630                         &FileEndOfFileInformation_struct,       /* FileInformation */
 631                         sizeof(FileEndOfFileInformation_struct),        /* Length */
 632                         FileEndOfFileInformation);      /* FileInformationClass */
 633         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err)))
 634                 return errvfsresult;
 635         g_return_val_if_fail(NT_SUCCESS(err),GNOME_VFS_ERROR_GENERIC);
 636
 637         return GNOME_VFS_OK;
 638 }
 639
 640
 641 GnomeVFSResult captive_file_move(CaptiveFileObject *captive_file_object_old,const gchar *pathname_new,gboolean force_replace)
 642 {
 643 NTSTATUS err;
 644 FILE_RENAME_INFORMATION FileRenameInformation_struct;
 645 IO_STATUS_BLOCK file_IoStatusBlock;
 646 GnomeVFSResult errvfsresult;
 647 gchar *pathname_new_dirname,*pathname_new_basename;
 648 CaptiveDirectoryObject *captive_target_directory_object;
 649 FILE_OBJECT *target_dir_FileObject;
 650 UNICODE_STRING *target_dir_FileObject_FileName_UnicodeString_local;
 651
 652         g_return_val_if_fail(captive_file_object_old!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 653         g_return_val_if_fail(captive_file_object_old->file_Handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 654         g_return_val_if_fail(pathname_new!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 655
 656         pathname_new_dirname=g_path_get_dirname(pathname_new);
 657         pathname_new_basename=g_path_get_basename(pathname_new);
 658
 659         errvfsresult=captive_directory_new_open(&captive_target_directory_object,pathname_new_dirname);
 660         if (errvfsresult!=GNOME_VFS_OK)
 661                 goto err_free_pathnames;
 662
 663         err=ObReferenceObjectByHandle(
 664                         captive_target_directory_object->dir_Handle,    /* Handle */
 665                         (FILE_ADD_FILE | FILE_ADD_SUBDIRECTORY),        /* DesiredAccess */
 666                         IoFileObjectType,       /* ObjectType */
 667                         KernelMode,     /* AccessMode */
 668                         (PVOID *)&target_dir_FileObject,        /* Object */
 669                         NULL);  /* HandleInfo */
 670         if (!NT_SUCCESS(err)) {
 671                 g_assert_not_reached();
 672                 errvfsresult=GNOME_VFS_ERROR_GENERIC;
 673                 goto err_close_captive_target_directory_object;
 674                 }
 675
 676         /* Supply only the 'basename' to 'target_dir_FileObject->FileName'
 677          * as the directory is fully determined by its other attributes.
 678          */
 679         target_dir_FileObject_FileName_UnicodeString_local=captive_utf8_to_UnicodeString_alloca(pathname_new_basename);
 680         target_dir_FileObject->FileName=*target_dir_FileObject_FileName_UnicodeString_local;
 681
 682         ObDereferenceObject(target_dir_FileObject);
 683
 684         FileRenameInformation_struct.Replace=force_replace;
 685         FileRenameInformation_struct.RootDir=captive_target_directory_object->dir_Handle;       /* ->'target_dir_FileObject' */
 686         FileRenameInformation_struct.FileNameLength=0;  /* provided by 'FileRenameInformation_struct.RootDir' */
 687
 688         err=NtSetInformationFile(
 689                         captive_file_object_old->file_Handle,   /* FileHandle */
 690                         &file_IoStatusBlock,    /* IoStatusBlock */
 691                         &FileRenameInformation_struct,  /* FileInformation */
 692                         sizeof(FileRenameInformation_struct),   /* Length */
 693                         FileRenameInformation); /* FileInformationClass */
 694         if (GNOME_VFS_OK!=(errvfsresult=captive_NTSTATUS_to_GnomeVFSResult(err))) {
 695                 g_assert_not_reached();
 696                 errvfsresult=GNOME_VFS_ERROR_GENERIC;
 697                 }
 698
 699         /* PASSTHRU */
 700
 701 err_close_captive_target_directory_object:
 702         g_object_unref(captive_target_directory_object);
 703 err_free_pathnames:
 704         g_free(pathname_new_dirname);
 705         g_free(pathname_new_basename);
 706
 707         return errvfsresult;
 708 }