reactos/drivers/filesystems/ntfs/create.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 2002, 2014 ReactOS Team
   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; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
  18  *
  19  * COPYRIGHT:        See COPYING in the top level directory
  20  * PROJECT:          ReactOS kernel
  21  * FILE:             drivers/filesystem/ntfs/create.c
  22  * PURPOSE:          NTFS filesystem driver
  23  * PROGRAMMERS:      Eric Kohl
  24  *                   Pierre Schweitzer (pierre@reactos.org)
  25  */
  26
  27 /* INCLUDES *****************************************************************/
  28
  29 #include "ntfs.h"
  30
  31 #define NDEBUG
  32 #include <debug.h>
  33
  34 static PCWSTR MftIdToName[] = {
  35     L"$MFT",
  36     L"$MFTMirr",
  37     L"$LogFile",
  38     L"$Volume",
  39     L"AttrDef",
  40     L".",
  41     L"$Bitmap",
  42     L"$Boot",
  43     L"$BadClus",
  44     L"$Quota",
  45     L"$UpCase",
  46     L"$Extended",
  47 };
  48
  49 /* FUNCTIONS ****************************************************************/
  50
  51 static
  52 NTSTATUS
  53 NtfsMakeAbsoluteFilename(PFILE_OBJECT pFileObject,
  54                          PWSTR pRelativeFileName,
  55                          PWSTR *pAbsoluteFilename)
  56 {
  57     PWSTR rcName;
  58     PNTFS_FCB Fcb;
  59
  60     DPRINT("try related for %S\n", pRelativeFileName);
  61     Fcb = pFileObject->FsContext;
  62     ASSERT(Fcb);
  63
  64     if (Fcb->Flags & FCB_IS_VOLUME)
  65     {
  66         /* This is likely to be an opening by ID, return ourselves */
  67         if (pRelativeFileName[0] == L'\\')
  68         {
  69             *pAbsoluteFilename = NULL;
  70             return STATUS_SUCCESS;
  71         }
  72
  73         return STATUS_INVALID_PARAMETER;
  74     }
  75
  76     /* verify related object is a directory and target name
  77        don't start with \. */
  78     if (NtfsFCBIsDirectory(Fcb) == FALSE ||
  79         pRelativeFileName[0] == L'\\')
  80     {
  81         return STATUS_INVALID_PARAMETER;
  82     }
  83
  84     /* construct absolute path name */
  85     ASSERT(wcslen (Fcb->PathName) + 1 + wcslen (pRelativeFileName) + 1 <= MAX_PATH);
  86     rcName = ExAllocatePoolWithTag(NonPagedPool, MAX_PATH * sizeof(WCHAR), TAG_NTFS);
  87     if (!rcName)
  88     {
  89         return STATUS_INSUFFICIENT_RESOURCES;
  90     }
  91
  92     wcscpy(rcName, Fcb->PathName);
  93     if (!NtfsFCBIsRoot(Fcb))
  94         wcscat (rcName, L"\\");
  95     wcscat (rcName, pRelativeFileName);
  96     *pAbsoluteFilename = rcName;
  97
  98     return STATUS_SUCCESS;
  99 }
 100
 101
 102 static
 103 NTSTATUS
 104 NtfsMoonWalkID(PDEVICE_EXTENSION DeviceExt,
 105                ULONGLONG Id,
 106                PUNICODE_STRING OutPath)
 107 {
 108     NTSTATUS Status;
 109     PFILE_RECORD_HEADER MftRecord;
 110     PFILENAME_ATTRIBUTE FileName;
 111     WCHAR FullPath[MAX_PATH];
 112     ULONG WritePosition = MAX_PATH - 1;
 113
 114     DPRINT1("NtfsMoonWalkID(%p, %I64x, %p)\n", DeviceExt, Id, OutPath);
 115
 116     RtlZeroMemory(FullPath, sizeof(FullPath));
 117     MftRecord = ExAllocatePoolWithTag(NonPagedPool,
 118                                       DeviceExt->NtfsInfo.BytesPerFileRecord,
 119                                       TAG_NTFS);
 120     if (MftRecord == NULL)
 121     {
 122         return STATUS_INSUFFICIENT_RESOURCES;
 123     }
 124
 125     while (TRUE)
 126     {
 127         Status = ReadFileRecord(DeviceExt, Id, MftRecord);
 128         if (!NT_SUCCESS(Status))
 129             break;
 130
 131         ASSERT(MftRecord->Ntfs.Type == NRH_FILE_TYPE);
 132         if (!(MftRecord->Flags & FRH_IN_USE))
 133         {
 134             Status = STATUS_OBJECT_PATH_NOT_FOUND;
 135             break;
 136         }
 137
 138         FileName = GetBestFileNameFromRecord(MftRecord);
 139         if (FileName == NULL)
 140         {
 141             DPRINT1("$FILE_NAME attribute not found for %I64x\n", Id);
 142             Status = STATUS_OBJECT_PATH_NOT_FOUND;
 143             break;
 144         }
 145
 146         WritePosition -= FileName->NameLength;
 147         ASSERT(WritePosition < MAX_PATH);
 148         RtlCopyMemory(FullPath + WritePosition, FileName->Name, FileName->NameLength * sizeof(WCHAR));
 149         WritePosition -= 1;
 150         ASSERT(WritePosition < MAX_PATH);
 151         FullPath[WritePosition] = L'\\';
 152
 153         Id = FileName->DirectoryFileReferenceNumber & NTFS_MFT_MASK;
 154         if (Id == NTFS_FILE_ROOT)
 155             break;
 156     }
 157
 158     ExFreePoolWithTag(MftRecord, TAG_NTFS);
 159
 160     if (!NT_SUCCESS(Status))
 161         return Status;
 162
 163     OutPath->Length = (MAX_PATH - WritePosition - 1) * sizeof(WCHAR);
 164     OutPath->MaximumLength = (MAX_PATH - WritePosition) * sizeof(WCHAR);
 165     OutPath->Buffer = ExAllocatePoolWithTag(NonPagedPool, OutPath->MaximumLength, TAG_NTFS);
 166     if (OutPath->Buffer == NULL)
 167     {
 168         return STATUS_INSUFFICIENT_RESOURCES;
 169     }
 170     RtlCopyMemory(OutPath->Buffer, FullPath + WritePosition, OutPath->MaximumLength);
 171
 172     return Status;
 173 }
 174
 175 static
 176 NTSTATUS
 177 NtfsOpenFileById(PDEVICE_EXTENSION DeviceExt,
 178                  PFILE_OBJECT FileObject,
 179                  ULONGLONG MftId,
 180                  PNTFS_FCB * FoundFCB)
 181 {
 182     NTSTATUS Status;
 183     PNTFS_FCB FCB;
 184     PFILE_RECORD_HEADER MftRecord;
 185
 186     DPRINT1("NtfsOpenFileById(%p, %p, %I64x, %p)\n", DeviceExt, FileObject, MftId, FoundFCB);
 187
 188     ASSERT(MftId < 0x10);
 189     if (MftId > 0xb) /* No entries are used yet beyond this */
 190     {
 191         return STATUS_OBJECT_NAME_NOT_FOUND;
 192     }
 193
 194     MftRecord = ExAllocatePoolWithTag(NonPagedPool,
 195                                       DeviceExt->NtfsInfo.BytesPerFileRecord,
 196                                       TAG_NTFS);
 197     if (MftRecord == NULL)
 198     {
 199         return STATUS_INSUFFICIENT_RESOURCES;
 200     }
 201
 202     Status = ReadFileRecord(DeviceExt, MftId, MftRecord);
 203     if (!NT_SUCCESS(Status))
 204     {
 205         ExFreePoolWithTag(MftRecord, TAG_NTFS);
 206         return Status;
 207     }
 208
 209     if (!(MftRecord->Flags & FRH_IN_USE))
 210     {
 211         ExFreePoolWithTag(MftRecord, TAG_NTFS);
 212         return STATUS_OBJECT_PATH_NOT_FOUND;
 213     }
 214
 215     FCB = NtfsGrabFCBFromTable(DeviceExt, MftIdToName[MftId]);
 216     if (FCB == NULL)
 217     {
 218         UNICODE_STRING Name;
 219
 220         RtlInitUnicodeString(&Name, MftIdToName[MftId]);
 221         Status = NtfsMakeFCBFromDirEntry(DeviceExt, NULL, &Name, MftRecord, MftId, &FCB);
 222         if (!NT_SUCCESS(Status))
 223         {
 224             ExFreePoolWithTag(MftRecord, TAG_NTFS);
 225             return Status;
 226         }
 227     }
 228
 229     ASSERT(FCB != NULL);
 230
 231     ExFreePoolWithTag(MftRecord, TAG_NTFS);
 232
 233     Status = NtfsAttachFCBToFileObject(DeviceExt,
 234                                        FCB,
 235                                        FileObject);
 236     *FoundFCB = FCB;
 237
 238     return Status;
 239 }
 240
 241 /*
 242  * FUNCTION: Opens a file
 243  */
 244 static
 245 NTSTATUS
 246 NtfsOpenFile(PDEVICE_EXTENSION DeviceExt,
 247              PFILE_OBJECT FileObject,
 248              PWSTR FileName,
 249              PNTFS_FCB * FoundFCB)
 250 {
 251     PNTFS_FCB ParentFcb;
 252     PNTFS_FCB Fcb;
 253     NTSTATUS Status;
 254     PWSTR AbsFileName = NULL;
 255
 256     DPRINT1("NtfsOpenFile(%p, %p, %S, %p)\n", DeviceExt, FileObject, FileName, FoundFCB);
 257
 258     *FoundFCB = NULL;
 259
 260     if (FileObject->RelatedFileObject)
 261     {
 262         DPRINT("Converting relative filename to absolute filename\n");
 263
 264         Status = NtfsMakeAbsoluteFilename(FileObject->RelatedFileObject,
 265                                           FileName,
 266                                           &AbsFileName);
 267         if (AbsFileName) FileName = AbsFileName;
 268         if (!NT_SUCCESS(Status))
 269         {
 270             return Status;
 271         }
 272     }
 273
 274     //FIXME: Get cannonical path name (remove .'s, ..'s and extra separators)
 275
 276     DPRINT("PathName to open: %S\n", FileName);
 277
 278     /*  try first to find an existing FCB in memory  */
 279     DPRINT("Checking for existing FCB in memory\n");
 280     Fcb = NtfsGrabFCBFromTable(DeviceExt,
 281                                FileName);
 282     if (Fcb == NULL)
 283     {
 284         DPRINT("No existing FCB found, making a new one if file exists.\n");
 285         Status = NtfsGetFCBForFile(DeviceExt,
 286                                    &ParentFcb,
 287                                    &Fcb,
 288                                    FileName);
 289         if (ParentFcb != NULL)
 290         {
 291             NtfsReleaseFCB(DeviceExt,
 292                            ParentFcb);
 293         }
 294
 295         if (!NT_SUCCESS (Status))
 296         {
 297             DPRINT("Could not make a new FCB, status: %x\n", Status);
 298
 299             if (AbsFileName)
 300                 ExFreePool(AbsFileName);
 301
 302             return Status;
 303         }
 304     }
 305
 306     DPRINT("Attaching FCB to fileObject\n");
 307     Status = NtfsAttachFCBToFileObject(DeviceExt,
 308                                        Fcb,
 309                                        FileObject);
 310
 311     if (AbsFileName)
 312         ExFreePool(AbsFileName);
 313
 314     *FoundFCB = Fcb;
 315
 316     return Status;
 317 }
 318
 319
 320 /*
 321  * FUNCTION: Opens a file
 322  */
 323 static
 324 NTSTATUS
 325 NtfsCreateFile(PDEVICE_OBJECT DeviceObject,
 326                PIRP Irp)
 327 {
 328     PDEVICE_EXTENSION DeviceExt;
 329     PIO_STACK_LOCATION Stack;
 330     PFILE_OBJECT FileObject;
 331     ULONG RequestedDisposition;
 332     ULONG RequestedOptions;
 333     PNTFS_FCB Fcb = NULL;
 334 //    PWSTR FileName;
 335     NTSTATUS Status;
 336     UNICODE_STRING FullPath;
 337
 338     DPRINT1("NtfsCreateFile(%p, %p) called\n", DeviceObject, Irp);
 339
 340     DeviceExt = DeviceObject->DeviceExtension;
 341     ASSERT(DeviceExt);
 342     Stack = IoGetCurrentIrpStackLocation (Irp);
 343     ASSERT(Stack);
 344
 345     RequestedDisposition = ((Stack->Parameters.Create.Options >> 24) & 0xff);
 346     RequestedOptions = Stack->Parameters.Create.Options & FILE_VALID_OPTION_FLAGS;
 347 //  PagingFileCreate = (Stack->Flags & SL_OPEN_PAGING_FILE) ? TRUE : FALSE;
 348     if (RequestedOptions & FILE_DIRECTORY_FILE &&
 349         RequestedDisposition == FILE_SUPERSEDE)
 350     {
 351         return STATUS_INVALID_PARAMETER;
 352     }
 353
 354     FileObject = Stack->FileObject;
 355
 356     if (RequestedDisposition == FILE_CREATE ||
 357         RequestedDisposition == FILE_OVERWRITE_IF ||
 358         RequestedDisposition == FILE_SUPERSEDE)
 359     {
 360         return STATUS_ACCESS_DENIED;
 361     }
 362
 363     if ((RequestedOptions & FILE_OPEN_BY_FILE_ID) == FILE_OPEN_BY_FILE_ID)
 364     {
 365         ULONGLONG MFTId;
 366
 367         if (FileObject->FileName.Length != sizeof(ULONGLONG))
 368             return STATUS_INVALID_PARAMETER;
 369
 370         MFTId = (*(PULONGLONG)FileObject->FileName.Buffer) & NTFS_MFT_MASK;
 371         if (MFTId < 0x10)
 372         {
 373             Status = NtfsOpenFileById(DeviceExt, FileObject, MFTId, &Fcb);
 374         }
 375         else
 376         {
 377             Status = NtfsMoonWalkID(DeviceExt, MFTId, &FullPath);
 378         }
 379
 380         if (!NT_SUCCESS(Status))
 381         {
 382             return Status;
 383         }
 384
 385         DPRINT1("Open by ID: %I64x -> %wZ\n", (*(PULONGLONG)FileObject->FileName.Buffer) & NTFS_MFT_MASK, &FullPath);
 386     }
 387
 388     /* This a open operation for the volume itself */
 389     if (FileObject->FileName.Length == 0 &&
 390         (FileObject->RelatedFileObject == NULL || FileObject->RelatedFileObject->FsContext2 != NULL))
 391     {
 392         if (RequestedDisposition != FILE_OPEN &&
 393             RequestedDisposition != FILE_OPEN_IF)
 394         {
 395             return STATUS_ACCESS_DENIED;
 396         }
 397
 398         if (RequestedOptions & FILE_DIRECTORY_FILE)
 399         {
 400             return STATUS_NOT_A_DIRECTORY;
 401         }
 402
 403         NtfsAttachFCBToFileObject(DeviceExt, DeviceExt->VolumeFcb, FileObject);
 404         DeviceExt->VolumeFcb->RefCount++;
 405
 406         Irp->IoStatus.Information = FILE_OPENED;
 407         return STATUS_SUCCESS;
 408     }
 409
 410     if (Fcb == NULL)
 411     {
 412         Status = NtfsOpenFile(DeviceExt,
 413                               FileObject,
 414                               ((RequestedOptions & FILE_OPEN_BY_FILE_ID) ? FullPath.Buffer : FileObject->FileName.Buffer),
 415                               &Fcb);
 416
 417         if (RequestedOptions & FILE_OPEN_BY_FILE_ID)
 418         {
 419             ExFreePoolWithTag(FullPath.Buffer, TAG_NTFS);
 420         }
 421     }
 422
 423     if (NT_SUCCESS(Status))
 424     {
 425         if (RequestedDisposition == FILE_CREATE)
 426         {
 427             Irp->IoStatus.Information = FILE_EXISTS;
 428             NtfsCloseFile(DeviceExt, FileObject);
 429             return STATUS_OBJECT_NAME_COLLISION;
 430         }
 431
 432         if (RequestedOptions & FILE_NON_DIRECTORY_FILE &&
 433             NtfsFCBIsDirectory(Fcb))
 434         {
 435             NtfsCloseFile(DeviceExt, FileObject);
 436             return STATUS_FILE_IS_A_DIRECTORY;
 437         }
 438
 439         if (RequestedOptions & FILE_DIRECTORY_FILE &&
 440             !NtfsFCBIsDirectory(Fcb))
 441         {
 442             NtfsCloseFile(DeviceExt, FileObject);
 443             return STATUS_NOT_A_DIRECTORY;
 444         }
 445
 446         /*
 447          * If it is a reparse point & FILE_OPEN_REPARSE_POINT, then allow opening it
 448          * as a normal file.
 449          * Otherwise, attempt to read reparse data and hand them to the Io manager
 450          * with status reparse to force a reparse.
 451          */
 452         if (NtfsFCBIsReparsePoint(Fcb) &&
 453             ((RequestedOptions & FILE_OPEN_REPARSE_POINT) != FILE_OPEN_REPARSE_POINT))
 454         {
 455             PREPARSE_DATA_BUFFER ReparseData = NULL;
 456
 457             Status = NtfsReadFCBAttribute(DeviceExt, Fcb,
 458                                           AttributeReparsePoint, L"", 0,
 459                                           (PVOID *)&Irp->Tail.Overlay.AuxiliaryBuffer);
 460             if (NT_SUCCESS(Status))
 461             {
 462                 ReparseData = (PREPARSE_DATA_BUFFER)Irp->Tail.Overlay.AuxiliaryBuffer;
 463                 if (ReparseData->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT)
 464                 {
 465                     Status = STATUS_REPARSE;
 466                 }
 467                 else
 468                 {
 469                     Status = STATUS_NOT_IMPLEMENTED;
 470                     ExFreePoolWithTag(ReparseData, TAG_NTFS);
 471                 }
 472             }
 473
 474             Irp->IoStatus.Information = ((Status == STATUS_REPARSE) ? ReparseData->ReparseTag : 0);
 475
 476             NtfsCloseFile(DeviceExt, FileObject);
 477             return Status;
 478         }
 479
 480         /* HUGLY HACK: remain RO so far... */
 481         if (RequestedDisposition == FILE_OVERWRITE ||
 482             RequestedDisposition == FILE_OVERWRITE_IF ||
 483             RequestedDisposition == FILE_SUPERSEDE)
 484         {
 485             DPRINT1("Denying write request on NTFS volume\n");
 486             NtfsCloseFile(DeviceExt, FileObject);
 487             return STATUS_ACCESS_DENIED;
 488         }
 489     }
 490     else
 491     {
 492         /* HUGLY HACK: remain RO so far... */
 493         if (RequestedDisposition == FILE_CREATE ||
 494             RequestedDisposition == FILE_OPEN_IF ||
 495             RequestedDisposition == FILE_OVERWRITE_IF ||
 496             RequestedDisposition == FILE_SUPERSEDE)
 497         {
 498             DPRINT1("Denying write request on NTFS volume\n");
 499             return STATUS_ACCESS_DENIED;
 500         }
 501     }
 502
 503     /*
 504      * If the directory containing the file to open doesn't exist then
 505      * fail immediately
 506      */
 507     Irp->IoStatus.Information = (NT_SUCCESS(Status)) ? FILE_OPENED : 0;
 508
 509     return Status;
 510 }
 511
 512
 513 NTSTATUS
 514 NtfsCreate(PNTFS_IRP_CONTEXT IrpContext)
 515 {
 516     PDEVICE_EXTENSION DeviceExt;
 517     NTSTATUS Status;
 518     PDEVICE_OBJECT DeviceObject;
 519
 520     DeviceObject = IrpContext->DeviceObject;
 521     if (DeviceObject == NtfsGlobalData->DeviceObject)
 522     {
 523         /* DeviceObject represents FileSystem instead of logical volume */
 524         DPRINT("Opening file system\n");
 525         IrpContext->Irp->IoStatus.Information = FILE_OPENED;
 526         return STATUS_SUCCESS;
 527     }
 528
 529     DeviceExt = DeviceObject->DeviceExtension;
 530
 531     if (!(IrpContext->Flags & IRPCONTEXT_CANWAIT))
 532     {
 533         return NtfsMarkIrpContextForQueue(IrpContext);
 534     }
 535
 536     ExAcquireResourceExclusiveLite(&DeviceExt->DirResource,
 537                                    TRUE);
 538     Status = NtfsCreateFile(DeviceObject,
 539                             IrpContext->Irp);
 540     ExReleaseResourceLite(&DeviceExt->DirResource);
 541
 542     return Status;
 543 }
 544
 545 /* EOF */