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