mirror of
https://github.com/reactos/reactos.git
synced 2024-08-30 07:08:19 +00:00
1000 lines
31 KiB
C
1000 lines
31 KiB
C
/*
|
|
* PROJECT: ReactOS Setup Library
|
|
* LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
|
|
* PURPOSE: File support functions.
|
|
* COPYRIGHT: Casper S. Hornstrup (chorns@users.sourceforge.net)
|
|
* Copyright 2017-2018 Hermes Belusca-Maito
|
|
*/
|
|
|
|
/* INCLUDES *****************************************************************/
|
|
|
|
#include "precomp.h"
|
|
#include "filesup.h"
|
|
|
|
#define NDEBUG
|
|
#include <debug.h>
|
|
|
|
|
|
// ACHTUNG! HAXX FIXME!!
|
|
#define _SEH2_TRY
|
|
#define _SEH2_LEAVE goto __SEH2_FINALLY__label;
|
|
#define _SEH2_FINALLY __SEH2_FINALLY__label:
|
|
#define _SEH2_END
|
|
|
|
|
|
/* FUNCTIONS ****************************************************************/
|
|
|
|
static
|
|
NTSTATUS
|
|
SetupCreateSingleDirectory(
|
|
IN PCWSTR DirectoryName)
|
|
{
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
UNICODE_STRING PathName;
|
|
HANDLE DirectoryHandle;
|
|
NTSTATUS Status;
|
|
|
|
if (!RtlCreateUnicodeString(&PathName, DirectoryName))
|
|
return STATUS_NO_MEMORY;
|
|
|
|
if (PathName.Length > sizeof(WCHAR) &&
|
|
PathName.Buffer[PathName.Length / sizeof(WCHAR) - 2] == L'\\' &&
|
|
PathName.Buffer[PathName.Length / sizeof(WCHAR) - 1] == L'.')
|
|
{
|
|
PathName.Length -= sizeof(WCHAR);
|
|
PathName.Buffer[PathName.Length / sizeof(WCHAR)] = UNICODE_NULL;
|
|
}
|
|
|
|
if (PathName.Length > sizeof(WCHAR) &&
|
|
PathName.Buffer[PathName.Length / sizeof(WCHAR) - 1] == L'\\')
|
|
{
|
|
PathName.Length -= sizeof(WCHAR);
|
|
PathName.Buffer[PathName.Length / sizeof(WCHAR)] = UNICODE_NULL;
|
|
}
|
|
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&PathName,
|
|
OBJ_CASE_INSENSITIVE | OBJ_INHERIT,
|
|
NULL,
|
|
NULL);
|
|
|
|
Status = NtCreateFile(&DirectoryHandle,
|
|
FILE_LIST_DIRECTORY | SYNCHRONIZE,
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
NULL,
|
|
FILE_ATTRIBUTE_DIRECTORY,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
FILE_OPEN_IF,
|
|
FILE_OPEN_FOR_BACKUP_INTENT | FILE_DIRECTORY_FILE,
|
|
NULL,
|
|
0);
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
NtClose(DirectoryHandle);
|
|
}
|
|
|
|
RtlFreeUnicodeString(&PathName);
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
SetupCreateDirectory(
|
|
IN PCWSTR PathName)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
PWCHAR PathBuffer = NULL;
|
|
PWCHAR Ptr, EndPtr;
|
|
ULONG BackslashCount;
|
|
ULONG Size;
|
|
|
|
Size = (wcslen(PathName) + 1) * sizeof(WCHAR);
|
|
PathBuffer = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, Size);
|
|
if (PathBuffer == NULL)
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
wcscpy(PathBuffer, PathName);
|
|
EndPtr = PathBuffer + wcslen(PathName);
|
|
|
|
Ptr = PathBuffer;
|
|
|
|
/* Skip the '\Device\HarddiskX\PartitionY\ part */
|
|
BackslashCount = 0;
|
|
while (Ptr < EndPtr && BackslashCount < 4)
|
|
{
|
|
if (*Ptr == L'\\')
|
|
BackslashCount++;
|
|
|
|
Ptr++;
|
|
}
|
|
|
|
while (Ptr < EndPtr)
|
|
{
|
|
if (*Ptr == L'\\')
|
|
{
|
|
*Ptr = 0;
|
|
|
|
DPRINT("PathBuffer: %S\n", PathBuffer);
|
|
if (!DoesDirExist(NULL, PathBuffer))
|
|
{
|
|
DPRINT("Create: %S\n", PathBuffer);
|
|
Status = SetupCreateSingleDirectory(PathBuffer);
|
|
if (!NT_SUCCESS(Status))
|
|
goto done;
|
|
}
|
|
|
|
*Ptr = L'\\';
|
|
}
|
|
|
|
Ptr++;
|
|
}
|
|
|
|
if (!DoesDirExist(NULL, PathBuffer))
|
|
{
|
|
DPRINT("Create: %S\n", PathBuffer);
|
|
Status = SetupCreateSingleDirectory(PathBuffer);
|
|
if (!NT_SUCCESS(Status))
|
|
goto done;
|
|
}
|
|
|
|
done:
|
|
DPRINT("Done.\n");
|
|
if (PathBuffer != NULL)
|
|
RtlFreeHeap(RtlGetProcessHeap(), 0, PathBuffer);
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
SetupDeleteFile(
|
|
IN PCWSTR FileName,
|
|
IN BOOLEAN ForceDelete) // ForceDelete can be used to delete read-only files
|
|
{
|
|
NTSTATUS Status;
|
|
UNICODE_STRING NtPathU;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
HANDLE FileHandle;
|
|
FILE_DISPOSITION_INFORMATION FileDispInfo;
|
|
BOOLEAN RetryOnce = FALSE;
|
|
|
|
/* Open the directory name that was passed in */
|
|
RtlInitUnicodeString(&NtPathU, FileName);
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&NtPathU,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL);
|
|
|
|
Retry: // We go back there once if RetryOnce == TRUE
|
|
Status = NtOpenFile(&FileHandle,
|
|
DELETE | FILE_READ_ATTRIBUTES |
|
|
(RetryOnce ? FILE_WRITE_ATTRIBUTES : 0),
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
|
|
FILE_NON_DIRECTORY_FILE | FILE_OPEN_FOR_BACKUP_INTENT);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtOpenFile failed with Status 0x%08lx\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
if (RetryOnce)
|
|
{
|
|
FILE_BASIC_INFORMATION FileInformation;
|
|
|
|
Status = NtQueryInformationFile(FileHandle,
|
|
&IoStatusBlock,
|
|
&FileInformation,
|
|
sizeof(FILE_BASIC_INFORMATION),
|
|
FileBasicInformation);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtQueryInformationFile failed with Status 0x%08lx\n", Status);
|
|
NtClose(FileHandle);
|
|
return Status;
|
|
}
|
|
|
|
FileInformation.FileAttributes = FILE_ATTRIBUTE_NORMAL;
|
|
Status = NtSetInformationFile(FileHandle,
|
|
&IoStatusBlock,
|
|
&FileInformation,
|
|
sizeof(FILE_BASIC_INFORMATION),
|
|
FileBasicInformation);
|
|
NtClose(FileHandle);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtSetInformationFile failed with Status 0x%08lx\n", Status);
|
|
return Status;
|
|
}
|
|
}
|
|
|
|
/* Ask for the file to be deleted */
|
|
FileDispInfo.DeleteFile = TRUE;
|
|
Status = NtSetInformationFile(FileHandle,
|
|
&IoStatusBlock,
|
|
&FileDispInfo,
|
|
sizeof(FILE_DISPOSITION_INFORMATION),
|
|
FileDispositionInformation);
|
|
NtClose(FileHandle);
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
DPRINT1("Deletion of file '%S' failed, Status 0x%08lx\n", FileName, Status);
|
|
|
|
// FIXME: Check the precise value of Status!
|
|
if (!NT_SUCCESS(Status) && ForceDelete && !RetryOnce)
|
|
{
|
|
/* Retry once */
|
|
RetryOnce = TRUE;
|
|
goto Retry;
|
|
}
|
|
|
|
/* Return result to the caller */
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
SetupCopyFile(
|
|
IN PCWSTR SourceFileName,
|
|
IN PCWSTR DestinationFileName,
|
|
IN BOOLEAN FailIfExists)
|
|
{
|
|
NTSTATUS Status;
|
|
UNICODE_STRING FileName;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
HANDLE FileHandleSource;
|
|
HANDLE FileHandleDest;
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
FILE_STANDARD_INFORMATION FileStandard;
|
|
FILE_BASIC_INFORMATION FileBasic;
|
|
ULONG RegionSize;
|
|
HANDLE SourceFileSection;
|
|
PVOID SourceFileMap = NULL;
|
|
SIZE_T SourceSectionSize = 0;
|
|
LARGE_INTEGER ByteOffset;
|
|
|
|
RtlInitUnicodeString(&FileName, SourceFileName);
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&FileName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL);
|
|
|
|
Status = NtOpenFile(&FileHandleSource,
|
|
GENERIC_READ,
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
FILE_SHARE_READ,
|
|
FILE_SEQUENTIAL_ONLY);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtOpenFile failed: %x, %wZ\n", Status, &FileName);
|
|
goto done;
|
|
}
|
|
|
|
Status = NtQueryInformationFile(FileHandleSource,
|
|
&IoStatusBlock,
|
|
&FileStandard,
|
|
sizeof(FILE_STANDARD_INFORMATION),
|
|
FileStandardInformation);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtQueryInformationFile failed: %x\n", Status);
|
|
goto closesrc;
|
|
}
|
|
|
|
Status = NtQueryInformationFile(FileHandleSource,
|
|
&IoStatusBlock,
|
|
&FileBasic,
|
|
sizeof(FILE_BASIC_INFORMATION),
|
|
FileBasicInformation);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtQueryInformationFile failed: %x\n", Status);
|
|
goto closesrc;
|
|
}
|
|
|
|
Status = NtCreateSection(&SourceFileSection,
|
|
SECTION_MAP_READ,
|
|
NULL,
|
|
NULL,
|
|
PAGE_READONLY,
|
|
SEC_COMMIT,
|
|
FileHandleSource);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtCreateSection failed: %x, %S\n", Status, SourceFileName);
|
|
goto closesrc;
|
|
}
|
|
|
|
Status = NtMapViewOfSection(SourceFileSection,
|
|
NtCurrentProcess(),
|
|
&SourceFileMap,
|
|
0,
|
|
0,
|
|
NULL,
|
|
&SourceSectionSize,
|
|
ViewUnmap,
|
|
0,
|
|
PAGE_READONLY);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtMapViewOfSection failed: %x, %S\n", Status, SourceFileName);
|
|
goto closesrcsec;
|
|
}
|
|
|
|
RtlInitUnicodeString(&FileName, DestinationFileName);
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&FileName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL);
|
|
|
|
Status = NtCreateFile(&FileHandleDest,
|
|
GENERIC_WRITE | SYNCHRONIZE,
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
NULL,
|
|
FileBasic.FileAttributes, // FILE_ATTRIBUTE_NORMAL,
|
|
0,
|
|
FailIfExists ? FILE_CREATE : FILE_OVERWRITE_IF,
|
|
FILE_NO_INTERMEDIATE_BUFFERING |
|
|
FILE_SEQUENTIAL_ONLY |
|
|
FILE_SYNCHRONOUS_IO_NONALERT,
|
|
NULL,
|
|
0);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
/*
|
|
* Open may have failed because the file to overwrite
|
|
* is in readonly mode.
|
|
*/
|
|
if (Status == STATUS_ACCESS_DENIED)
|
|
{
|
|
FILE_BASIC_INFORMATION FileBasicInfo;
|
|
|
|
/* Reattempt to open it with limited access */
|
|
Status = NtCreateFile(&FileHandleDest,
|
|
FILE_WRITE_ATTRIBUTES | SYNCHRONIZE,
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
NULL,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
0,
|
|
FILE_OPEN,
|
|
FILE_NO_INTERMEDIATE_BUFFERING |
|
|
FILE_SEQUENTIAL_ONLY |
|
|
FILE_SYNCHRONOUS_IO_NONALERT,
|
|
NULL,
|
|
0);
|
|
/* Fail for real if we cannot open it that way */
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtCreateFile failed: %x, %wZ\n", Status, &FileName);
|
|
goto unmapsrcsec;
|
|
}
|
|
|
|
/* Zero our basic info, just to set attributes */
|
|
RtlZeroMemory(&FileBasicInfo, sizeof(FileBasicInfo));
|
|
/* Reset attributes to normal, no read-only */
|
|
FileBasicInfo.FileAttributes = FILE_ATTRIBUTE_NORMAL;
|
|
/*
|
|
* We basically don't care about whether it succeed:
|
|
* if it didn't, later open will fail.
|
|
*/
|
|
NtSetInformationFile(FileHandleDest, &IoStatusBlock, &FileBasicInfo,
|
|
sizeof(FileBasicInfo), FileBasicInformation);
|
|
|
|
/* Close file */
|
|
NtClose(FileHandleDest);
|
|
|
|
/* And re-attempt overwrite */
|
|
Status = NtCreateFile(&FileHandleDest,
|
|
GENERIC_WRITE | SYNCHRONIZE,
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
NULL,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
0,
|
|
FILE_OVERWRITE_IF,
|
|
FILE_NO_INTERMEDIATE_BUFFERING |
|
|
FILE_SEQUENTIAL_ONLY |
|
|
FILE_SYNCHRONOUS_IO_NONALERT,
|
|
NULL,
|
|
0);
|
|
}
|
|
|
|
/* We failed */
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtCreateFile failed: %x, %wZ\n", Status, &FileName);
|
|
goto unmapsrcsec;
|
|
}
|
|
}
|
|
|
|
RegionSize = (ULONG)PAGE_ROUND_UP(FileStandard.EndOfFile.u.LowPart);
|
|
IoStatusBlock.Status = 0;
|
|
ByteOffset.QuadPart = 0ULL;
|
|
Status = NtWriteFile(FileHandleDest,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&IoStatusBlock,
|
|
SourceFileMap,
|
|
RegionSize,
|
|
&ByteOffset,
|
|
NULL);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtWriteFile failed: %x:%x, iosb: %p src: %p, size: %x\n",
|
|
Status, IoStatusBlock.Status, &IoStatusBlock, SourceFileMap, RegionSize);
|
|
goto closedest;
|
|
}
|
|
|
|
/* Copy file date/time from source file */
|
|
Status = NtSetInformationFile(FileHandleDest,
|
|
&IoStatusBlock,
|
|
&FileBasic,
|
|
sizeof(FILE_BASIC_INFORMATION),
|
|
FileBasicInformation);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtSetInformationFile failed: %x\n", Status);
|
|
goto closedest;
|
|
}
|
|
|
|
/* Shorten the file back to its real size after completing the write */
|
|
Status = NtSetInformationFile(FileHandleDest,
|
|
&IoStatusBlock,
|
|
&FileStandard.EndOfFile,
|
|
sizeof(FILE_END_OF_FILE_INFORMATION),
|
|
FileEndOfFileInformation);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtSetInformationFile failed: %x\n", Status);
|
|
}
|
|
|
|
closedest:
|
|
NtClose(FileHandleDest);
|
|
|
|
unmapsrcsec:
|
|
NtUnmapViewOfSection(NtCurrentProcess(), SourceFileMap);
|
|
|
|
closesrcsec:
|
|
NtClose(SourceFileSection);
|
|
|
|
closesrc:
|
|
NtClose(FileHandleSource);
|
|
|
|
done:
|
|
return Status;
|
|
}
|
|
|
|
/*
|
|
* Synchronized with its kernel32 counterpart, but we don't manage reparse points here.
|
|
*/
|
|
NTSTATUS
|
|
SetupMoveFile(
|
|
IN PCWSTR ExistingFileName,
|
|
IN PCWSTR NewFileName,
|
|
IN ULONG Flags)
|
|
{
|
|
NTSTATUS Status;
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
PFILE_RENAME_INFORMATION RenameInfo;
|
|
UNICODE_STRING NewPathU, ExistingPathU;
|
|
HANDLE SourceHandle = NULL;
|
|
BOOLEAN ReplaceIfExists;
|
|
|
|
RtlInitUnicodeString(&ExistingPathU, ExistingFileName);
|
|
RtlInitUnicodeString(&NewPathU, NewFileName);
|
|
|
|
_SEH2_TRY
|
|
{
|
|
ReplaceIfExists = !!(Flags & MOVEFILE_REPLACE_EXISTING);
|
|
|
|
/* Unless we manage a proper opening, we'll attempt to reopen without reparse support */
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&ExistingPathU,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL);
|
|
/* Attempt to open source file */
|
|
Status = NtOpenFile(&SourceHandle,
|
|
FILE_READ_ATTRIBUTES | DELETE | SYNCHRONIZE,
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
|
|
FILE_OPEN_FOR_BACKUP_INTENT | ((Flags & MOVEFILE_WRITE_THROUGH) ? FILE_WRITE_THROUGH : 0));
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
if (Status != STATUS_INVALID_PARAMETER)
|
|
{
|
|
_SEH2_LEAVE;
|
|
}
|
|
}
|
|
|
|
/* At that point, we MUST have a source handle */
|
|
ASSERT(SourceHandle);
|
|
|
|
/* Allocate renaming buffer and fill it */
|
|
RenameInfo = RtlAllocateHeap(RtlGetProcessHeap(), 0, NewPathU.Length + sizeof(FILE_RENAME_INFORMATION));
|
|
if (RenameInfo == NULL)
|
|
{
|
|
Status = STATUS_NO_MEMORY;
|
|
_SEH2_LEAVE;
|
|
}
|
|
|
|
RtlCopyMemory(&RenameInfo->FileName, NewPathU.Buffer, NewPathU.Length);
|
|
RenameInfo->ReplaceIfExists = ReplaceIfExists;
|
|
RenameInfo->RootDirectory = NULL;
|
|
RenameInfo->FileNameLength = NewPathU.Length;
|
|
|
|
/* Attempt to rename the file */
|
|
Status = NtSetInformationFile(SourceHandle,
|
|
&IoStatusBlock,
|
|
RenameInfo,
|
|
NewPathU.Length + sizeof(FILE_RENAME_INFORMATION),
|
|
FileRenameInformation);
|
|
RtlFreeHeap(RtlGetProcessHeap(), 0, RenameInfo);
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
/* If it succeeded, all fine, quit */
|
|
_SEH2_LEAVE;
|
|
}
|
|
/*
|
|
* If we failed for any other reason than not the same device, fail.
|
|
* If we failed because of different devices, only allow renaming
|
|
* if user allowed copy.
|
|
*/
|
|
if (Status != STATUS_NOT_SAME_DEVICE || !(Flags & MOVEFILE_COPY_ALLOWED))
|
|
{
|
|
/* ReactOS hack! To be removed once all FSD have proper renaming support
|
|
* Just leave status to error and leave
|
|
*/
|
|
if (Status == STATUS_NOT_IMPLEMENTED)
|
|
{
|
|
DPRINT1("Forcing copy, renaming not supported by FSD\n");
|
|
}
|
|
else
|
|
{
|
|
_SEH2_LEAVE;
|
|
}
|
|
}
|
|
|
|
/* Close the source file */
|
|
NtClose(SourceHandle);
|
|
SourceHandle = NULL;
|
|
|
|
/* Perform the file copy */
|
|
Status = SetupCopyFile(ExistingFileName,
|
|
NewFileName,
|
|
!ReplaceIfExists);
|
|
|
|
/* If it succeeded, delete the source file */
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
/* Force-delete files even if read-only */
|
|
SetupDeleteFile(ExistingFileName, TRUE);
|
|
}
|
|
}
|
|
_SEH2_FINALLY
|
|
{
|
|
if (SourceHandle)
|
|
NtClose(SourceHandle);
|
|
}
|
|
_SEH2_END;
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
ConcatPathsV(
|
|
IN OUT PWSTR PathBuffer,
|
|
IN SIZE_T cchPathSize,
|
|
IN ULONG NumberOfPathComponents,
|
|
IN va_list PathComponentsList)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
SIZE_T cchPathLen;
|
|
PCWSTR PathComponent;
|
|
|
|
if (cchPathSize < 1)
|
|
return STATUS_SUCCESS;
|
|
|
|
while (NumberOfPathComponents--)
|
|
{
|
|
PathComponent = va_arg(PathComponentsList, PCWSTR);
|
|
if (!PathComponent)
|
|
continue;
|
|
|
|
cchPathLen = min(cchPathSize, wcslen(PathBuffer));
|
|
if (cchPathLen >= cchPathSize)
|
|
return STATUS_BUFFER_OVERFLOW;
|
|
|
|
if (PathComponent[0] != OBJ_NAME_PATH_SEPARATOR &&
|
|
cchPathLen > 0 && PathBuffer[cchPathLen-1] != OBJ_NAME_PATH_SEPARATOR)
|
|
{
|
|
/* PathComponent does not start with '\' and PathBuffer does not end with '\' */
|
|
Status = RtlStringCchCatW(PathBuffer, cchPathSize, L"\\");
|
|
if (!NT_SUCCESS(Status))
|
|
return Status;
|
|
}
|
|
else if (PathComponent[0] == OBJ_NAME_PATH_SEPARATOR &&
|
|
cchPathLen > 0 && PathBuffer[cchPathLen-1] == OBJ_NAME_PATH_SEPARATOR)
|
|
{
|
|
/* PathComponent starts with '\' and PathBuffer ends with '\' */
|
|
while (*PathComponent == OBJ_NAME_PATH_SEPARATOR)
|
|
++PathComponent; // Skip any backslash
|
|
}
|
|
Status = RtlStringCchCatW(PathBuffer, cchPathSize, PathComponent);
|
|
if (!NT_SUCCESS(Status))
|
|
return Status;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
CombinePathsV(
|
|
OUT PWSTR PathBuffer,
|
|
IN SIZE_T cchPathSize,
|
|
IN ULONG NumberOfPathComponents,
|
|
IN va_list PathComponentsList)
|
|
{
|
|
if (cchPathSize < 1)
|
|
return STATUS_SUCCESS;
|
|
|
|
*PathBuffer = UNICODE_NULL;
|
|
return ConcatPathsV(PathBuffer, cchPathSize,
|
|
NumberOfPathComponents,
|
|
PathComponentsList);
|
|
}
|
|
|
|
NTSTATUS
|
|
ConcatPaths(
|
|
IN OUT PWSTR PathBuffer,
|
|
IN SIZE_T cchPathSize,
|
|
IN ULONG NumberOfPathComponents,
|
|
IN /* PCWSTR */ ...)
|
|
{
|
|
NTSTATUS Status;
|
|
va_list PathComponentsList;
|
|
|
|
if (cchPathSize < 1)
|
|
return STATUS_SUCCESS;
|
|
|
|
va_start(PathComponentsList, NumberOfPathComponents);
|
|
Status = ConcatPathsV(PathBuffer, cchPathSize,
|
|
NumberOfPathComponents,
|
|
PathComponentsList);
|
|
va_end(PathComponentsList);
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
CombinePaths(
|
|
OUT PWSTR PathBuffer,
|
|
IN SIZE_T cchPathSize,
|
|
IN ULONG NumberOfPathComponents,
|
|
IN /* PCWSTR */ ...)
|
|
{
|
|
NTSTATUS Status;
|
|
va_list PathComponentsList;
|
|
|
|
if (cchPathSize < 1)
|
|
return STATUS_SUCCESS;
|
|
|
|
*PathBuffer = UNICODE_NULL;
|
|
|
|
va_start(PathComponentsList, NumberOfPathComponents);
|
|
Status = CombinePathsV(PathBuffer, cchPathSize,
|
|
NumberOfPathComponents,
|
|
PathComponentsList);
|
|
va_end(PathComponentsList);
|
|
|
|
return Status;
|
|
}
|
|
|
|
BOOLEAN
|
|
DoesPathExist(
|
|
IN HANDLE RootDirectory OPTIONAL,
|
|
IN PCWSTR PathName,
|
|
IN BOOLEAN IsDirectory)
|
|
{
|
|
NTSTATUS Status;
|
|
UNICODE_STRING Name;
|
|
HANDLE FileHandle;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
|
|
RtlInitUnicodeString(&Name, PathName);
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&Name,
|
|
OBJ_CASE_INSENSITIVE,
|
|
RootDirectory,
|
|
NULL);
|
|
|
|
Status = NtOpenFile(&FileHandle,
|
|
IsDirectory ? (FILE_LIST_DIRECTORY | SYNCHRONIZE)
|
|
: FILE_GENERIC_READ, // Contains SYNCHRONIZE
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
FILE_SYNCHRONOUS_IO_NONALERT |
|
|
(IsDirectory ? FILE_DIRECTORY_FILE
|
|
: FILE_NON_DIRECTORY_FILE));
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
NtClose(FileHandle);
|
|
}
|
|
else
|
|
{
|
|
DPRINT("Failed to open %s '%wZ', Status 0x%08lx\n",
|
|
IsDirectory ? "directory" : "file",
|
|
&Name, Status);
|
|
}
|
|
|
|
return NT_SUCCESS(Status);
|
|
}
|
|
|
|
// FIXME: DEPRECATED! HACKish function that needs to be deprecated!
|
|
BOOLEAN
|
|
DoesFileExist_2(
|
|
IN PCWSTR PathName OPTIONAL,
|
|
IN PCWSTR FileName)
|
|
{
|
|
WCHAR FullName[MAX_PATH];
|
|
CombinePaths(FullName, ARRAYSIZE(FullName), 2, PathName, FileName);
|
|
return DoesFileExist(NULL, FullName);
|
|
}
|
|
|
|
/*
|
|
* The format of NtPath should be:
|
|
* \Device\HarddiskXXX\PartitionYYY[\path] ,
|
|
* where XXX and YYY respectively represent the hard disk and partition numbers,
|
|
* and [\path] represent an optional path (separated by '\\').
|
|
*
|
|
* If a NT path of such a form is correctly parsed, the function returns respectively:
|
|
* - in pDiskNumber: the hard disk number XXX,
|
|
* - in pPartNumber: the partition number YYY,
|
|
* - in PathComponent: pointer value (inside NtPath) to the beginning of \path.
|
|
*
|
|
* NOTE: The function does not accept leading whitespace.
|
|
*/
|
|
BOOLEAN
|
|
NtPathToDiskPartComponents(
|
|
IN PCWSTR NtPath,
|
|
OUT PULONG pDiskNumber,
|
|
OUT PULONG pPartNumber,
|
|
OUT PCWSTR* PathComponent OPTIONAL)
|
|
{
|
|
ULONG DiskNumber, PartNumber;
|
|
PCWSTR Path;
|
|
|
|
*pDiskNumber = 0;
|
|
*pPartNumber = 0;
|
|
if (PathComponent) *PathComponent = NULL;
|
|
|
|
Path = NtPath;
|
|
|
|
if (_wcsnicmp(Path, L"\\Device\\Harddisk", 16) != 0)
|
|
{
|
|
/* The NT path doesn't start with the prefix string, thus it cannot be a hard disk device path */
|
|
DPRINT1("'%S' : Not a possible hard disk device.\n", NtPath);
|
|
return FALSE;
|
|
}
|
|
|
|
Path += 16;
|
|
|
|
/* A number must be present now */
|
|
if (!iswdigit(*Path))
|
|
{
|
|
DPRINT1("'%S' : expected a number! Not a regular hard disk device.\n", Path);
|
|
return FALSE;
|
|
}
|
|
DiskNumber = wcstoul(Path, (PWSTR*)&Path, 10);
|
|
|
|
/* Either NULL termination, or a path separator must be present now */
|
|
if (*Path && *Path != OBJ_NAME_PATH_SEPARATOR)
|
|
{
|
|
DPRINT1("'%S' : expected a path separator!\n", Path);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!*Path)
|
|
{
|
|
DPRINT1("The path only specified a hard disk (and nothing else, like a partition...), so we stop there.\n");
|
|
goto Quit;
|
|
}
|
|
|
|
/* Here, *Path == L'\\' */
|
|
|
|
if (_wcsnicmp(Path, L"\\Partition", 10) != 0)
|
|
{
|
|
/* Actually, \Partition is optional so, if we don't have it, we still return success. Or should we? */
|
|
DPRINT1("'%S' : unexpected format!\n", NtPath);
|
|
goto Quit;
|
|
}
|
|
|
|
Path += 10;
|
|
|
|
/* A number must be present now */
|
|
if (!iswdigit(*Path))
|
|
{
|
|
/* If we don't have a number it means this part of path is actually not a partition specifier, so we shouldn't fail either. Or should we? */
|
|
DPRINT1("'%S' : expected a number!\n", Path);
|
|
goto Quit;
|
|
}
|
|
PartNumber = wcstoul(Path, (PWSTR*)&Path, 10);
|
|
|
|
/* Either NULL termination, or a path separator must be present now */
|
|
if (*Path && *Path != OBJ_NAME_PATH_SEPARATOR)
|
|
{
|
|
/* We shouldn't fail here because it just means this part of path is actually not a partition specifier. Or should we? */
|
|
DPRINT1("'%S' : expected a path separator!\n", Path);
|
|
goto Quit;
|
|
}
|
|
|
|
/* OK, here we really have a partition specifier: return its number */
|
|
*pPartNumber = PartNumber;
|
|
|
|
Quit:
|
|
/* Return the disk number */
|
|
*pDiskNumber = DiskNumber;
|
|
|
|
/* Return the path component also, if the user wants it */
|
|
if (PathComponent) *PathComponent = Path;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
NTSTATUS
|
|
OpenAndMapFile(
|
|
IN HANDLE RootDirectory OPTIONAL,
|
|
IN PCWSTR PathNameToFile,
|
|
OUT PHANDLE FileHandle, // IN OUT PHANDLE OPTIONAL
|
|
OUT PHANDLE SectionHandle,
|
|
OUT PVOID* BaseAddress,
|
|
OUT PULONG FileSize OPTIONAL,
|
|
IN BOOLEAN ReadWriteAccess)
|
|
{
|
|
NTSTATUS Status;
|
|
UNICODE_STRING FileName;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
ULONG SectionPageProtection;
|
|
SIZE_T ViewSize;
|
|
PVOID ViewBase;
|
|
|
|
/* Open the file */
|
|
|
|
RtlInitUnicodeString(&FileName, PathNameToFile);
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&FileName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
RootDirectory,
|
|
NULL);
|
|
|
|
*FileHandle = NULL;
|
|
*SectionHandle = NULL;
|
|
|
|
Status = NtOpenFile(FileHandle,
|
|
FILE_GENERIC_READ | // Contains SYNCHRONIZE
|
|
(ReadWriteAccess ? FILE_GENERIC_WRITE : 0),
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
FILE_SHARE_READ,
|
|
FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("Failed to open file '%wZ', Status 0x%08lx\n", &FileName, Status);
|
|
return Status;
|
|
}
|
|
|
|
if (FileSize)
|
|
{
|
|
/* Query the file size */
|
|
FILE_STANDARD_INFORMATION FileInfo;
|
|
Status = NtQueryInformationFile(*FileHandle,
|
|
&IoStatusBlock,
|
|
&FileInfo,
|
|
sizeof(FileInfo),
|
|
FileStandardInformation);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT("NtQueryInformationFile() failed (Status %lx)\n", Status);
|
|
NtClose(*FileHandle);
|
|
*FileHandle = NULL;
|
|
return Status;
|
|
}
|
|
|
|
if (FileInfo.EndOfFile.HighPart != 0)
|
|
DPRINT1("WARNING!! The file '%wZ' is too large!\n", &FileName);
|
|
|
|
*FileSize = FileInfo.EndOfFile.LowPart;
|
|
|
|
DPRINT("File size: %lu\n", *FileSize);
|
|
}
|
|
|
|
/* Map the file in memory */
|
|
|
|
SectionPageProtection = (ReadWriteAccess ? PAGE_READWRITE : PAGE_READONLY);
|
|
|
|
/* Create the section */
|
|
Status = NtCreateSection(SectionHandle,
|
|
STANDARD_RIGHTS_REQUIRED | SECTION_QUERY |
|
|
SECTION_MAP_READ |
|
|
(ReadWriteAccess ? SECTION_MAP_WRITE : 0),
|
|
NULL,
|
|
NULL,
|
|
SectionPageProtection,
|
|
SEC_COMMIT /* | SEC_IMAGE (_NO_EXECUTE) */,
|
|
*FileHandle);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("Failed to create a memory section for file '%wZ', Status 0x%08lx\n", &FileName, Status);
|
|
NtClose(*FileHandle);
|
|
*FileHandle = NULL;
|
|
return Status;
|
|
}
|
|
|
|
/* Map the section */
|
|
ViewSize = 0;
|
|
ViewBase = NULL;
|
|
Status = NtMapViewOfSection(*SectionHandle,
|
|
NtCurrentProcess(),
|
|
&ViewBase,
|
|
0, 0,
|
|
NULL,
|
|
&ViewSize,
|
|
ViewShare,
|
|
0,
|
|
SectionPageProtection);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("Failed to map a view for file '%wZ', Status 0x%08lx\n", &FileName, Status);
|
|
NtClose(*SectionHandle);
|
|
*SectionHandle = NULL;
|
|
NtClose(*FileHandle);
|
|
*FileHandle = NULL;
|
|
return Status;
|
|
}
|
|
|
|
*BaseAddress = ViewBase;
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
BOOLEAN
|
|
UnMapFile(
|
|
IN HANDLE SectionHandle,
|
|
IN PVOID BaseAddress)
|
|
{
|
|
NTSTATUS Status;
|
|
BOOLEAN Success = TRUE;
|
|
|
|
Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("UnMapFile: NtUnmapViewOfSection(0x%p) failed with Status 0x%08lx\n",
|
|
BaseAddress, Status);
|
|
Success = FALSE;
|
|
}
|
|
Status = NtClose(SectionHandle);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("UnMapFile: NtClose(0x%p) failed with Status 0x%08lx\n",
|
|
SectionHandle, Status);
|
|
Success = FALSE;
|
|
}
|
|
|
|
return Success;
|
|
}
|
|
|
|
/* EOF */
|