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